power.c 15.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
/*
 *  acpi_power.c - ACPI Bus Power Management ($Revision: 39 $)
 *
 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or (at
 *  your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

/*
 * ACPI power-managed devices may be controlled in two ways:
 * 1. via "Device Specific (D-State) Control"
 * 2. via "Power Resource Control".
 * This module is used to manage devices relying on Power Resource Control.
 * 
 * An ACPI "power resource object" describes a software controllable power
 * plane, clock plane, or other resource used by a power managed device.
 * A device may rely on multiple power resources, and a power resource
 * may be shared by multiple devices.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>

#define _COMPONENT		ACPI_POWER_COMPONENT
L
Len Brown 已提交
48
ACPI_MODULE_NAME("acpi_power")
L
Linus Torvalds 已提交
49 50 51 52 53 54 55 56 57
#define ACPI_POWER_COMPONENT		0x00800000
#define ACPI_POWER_CLASS		"power_resource"
#define ACPI_POWER_DRIVER_NAME		"ACPI Power Resource Driver"
#define ACPI_POWER_DEVICE_NAME		"Power Resource"
#define ACPI_POWER_FILE_INFO		"info"
#define ACPI_POWER_FILE_STATUS		"state"
#define ACPI_POWER_RESOURCE_STATE_OFF	0x00
#define ACPI_POWER_RESOURCE_STATE_ON	0x01
#define ACPI_POWER_RESOURCE_STATE_UNKNOWN 0xFF
L
Len Brown 已提交
58 59
static int acpi_power_add(struct acpi_device *device);
static int acpi_power_remove(struct acpi_device *device, int type);
L
Linus Torvalds 已提交
60 61 62
static int acpi_power_open_fs(struct inode *inode, struct file *file);

static struct acpi_driver acpi_power_driver = {
L
Len Brown 已提交
63 64 65 66 67 68 69
	.name = ACPI_POWER_DRIVER_NAME,
	.class = ACPI_POWER_CLASS,
	.ids = ACPI_POWER_HID,
	.ops = {
		.add = acpi_power_add,
		.remove = acpi_power_remove,
		},
L
Linus Torvalds 已提交
70 71
};

L
Len Brown 已提交
72
struct acpi_power_resource {
73
	struct acpi_device * device;
L
Len Brown 已提交
74 75 76 77 78
	acpi_bus_id name;
	u32 system_level;
	u32 order;
	int state;
	int references;
L
Linus Torvalds 已提交
79 80
};

L
Len Brown 已提交
81
static struct list_head acpi_power_resource_list;
L
Linus Torvalds 已提交
82

83
static const struct file_operations acpi_power_fops = {
L
Len Brown 已提交
84 85 86 87
	.open = acpi_power_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
88 89 90 91 92 93 94
};

/* --------------------------------------------------------------------------
                             Power Resource Management
   -------------------------------------------------------------------------- */

static int
L
Len Brown 已提交
95 96
acpi_power_get_context(acpi_handle handle,
		       struct acpi_power_resource **resource)
L
Linus Torvalds 已提交
97
{
L
Len Brown 已提交
98 99
	int result = 0;
	struct acpi_device *device = NULL;
L
Linus Torvalds 已提交
100 101 102


	if (!resource)
103
		return -ENODEV;
L
Linus Torvalds 已提交
104 105 106

	result = acpi_bus_get_device(handle, &device);
	if (result) {
107
		printk(KERN_WARNING PREFIX "Getting context [%p]\n", handle);
108
		return result;
L
Linus Torvalds 已提交
109 110
	}

111
	*resource = acpi_driver_data(device);
L
Linus Torvalds 已提交
112
	if (!resource)
113
		return -ENODEV;
L
Linus Torvalds 已提交
114

115
	return 0;
L
Linus Torvalds 已提交
116 117
}

L
Len Brown 已提交
118
static int acpi_power_get_state(struct acpi_power_resource *resource)
L
Linus Torvalds 已提交
119
{
L
Len Brown 已提交
120 121
	acpi_status status = AE_OK;
	unsigned long sta = 0;
L
Linus Torvalds 已提交
122 123 124


	if (!resource)
125
		return -EINVAL;
L
Linus Torvalds 已提交
126

127
	status = acpi_evaluate_integer(resource->device->handle, "_STA", NULL, &sta);
L
Linus Torvalds 已提交
128
	if (ACPI_FAILURE(status))
129
		return -ENODEV;
L
Linus Torvalds 已提交
130 131 132 133 134 135 136

	if (sta & 0x01)
		resource->state = ACPI_POWER_RESOURCE_STATE_ON;
	else
		resource->state = ACPI_POWER_RESOURCE_STATE_OFF;

	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] is %s\n",
L
Len Brown 已提交
137
			  resource->name, resource->state ? "on" : "off"));
L
Linus Torvalds 已提交
138

139
	return 0;
L
Linus Torvalds 已提交
140 141
}

L
Len Brown 已提交
142
static int acpi_power_get_list_state(struct acpi_handle_list *list, int *state)
L
Linus Torvalds 已提交
143
{
L
Len Brown 已提交
144
	int result = 0;
L
Linus Torvalds 已提交
145
	struct acpi_power_resource *resource = NULL;
L
Len Brown 已提交
146
	u32 i = 0;
L
Linus Torvalds 已提交
147 148 149


	if (!list || !state)
150
		return -EINVAL;
L
Linus Torvalds 已提交
151 152 153

	/* The state of the list is 'on' IFF all resources are 'on'. */

L
Len Brown 已提交
154
	for (i = 0; i < list->count; i++) {
L
Linus Torvalds 已提交
155 156
		result = acpi_power_get_context(list->handles[i], &resource);
		if (result)
157
			return result;
L
Linus Torvalds 已提交
158 159
		result = acpi_power_get_state(resource);
		if (result)
160
			return result;
L
Linus Torvalds 已提交
161 162 163 164 165 166 167 168

		*state = resource->state;

		if (*state != ACPI_POWER_RESOURCE_STATE_ON)
			break;
	}

	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource list is %s\n",
L
Len Brown 已提交
169
			  *state ? "on" : "off"));
L
Linus Torvalds 已提交
170

171
	return result;
L
Linus Torvalds 已提交
172 173
}

L
Len Brown 已提交
174
static int acpi_power_on(acpi_handle handle)
L
Linus Torvalds 已提交
175
{
L
Len Brown 已提交
176 177 178
	int result = 0;
	acpi_status status = AE_OK;
	struct acpi_device *device = NULL;
L
Linus Torvalds 已提交
179 180 181 182 183
	struct acpi_power_resource *resource = NULL;


	result = acpi_power_get_context(handle, &resource);
	if (result)
184
		return result;
L
Linus Torvalds 已提交
185 186 187

	resource->references++;

L
Len Brown 已提交
188 189
	if ((resource->references > 1)
	    || (resource->state == ACPI_POWER_RESOURCE_STATE_ON)) {
L
Linus Torvalds 已提交
190
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] already on\n",
L
Len Brown 已提交
191
				  resource->name));
192
		return 0;
L
Linus Torvalds 已提交
193 194
	}

195
	status = acpi_evaluate_object(resource->device->handle, "_ON", NULL, NULL);
L
Linus Torvalds 已提交
196
	if (ACPI_FAILURE(status))
197
		return -ENODEV;
L
Linus Torvalds 已提交
198 199 200

	result = acpi_power_get_state(resource);
	if (result)
201
		return result;
L
Linus Torvalds 已提交
202
	if (resource->state != ACPI_POWER_RESOURCE_STATE_ON)
203
		return -ENOEXEC;
L
Linus Torvalds 已提交
204 205

	/* Update the power resource's _device_ power state */
206 207
	device = resource->device;
	resource->device->power.state = ACPI_STATE_D0;
L
Linus Torvalds 已提交
208 209

	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] turned on\n",
L
Len Brown 已提交
210
			  resource->name));
L
Linus Torvalds 已提交
211

212
	return 0;
L
Linus Torvalds 已提交
213 214
}

L
Len Brown 已提交
215
static int acpi_power_off_device(acpi_handle handle)
L
Linus Torvalds 已提交
216
{
L
Len Brown 已提交
217 218
	int result = 0;
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
219 220 221 222
	struct acpi_power_resource *resource = NULL;

	result = acpi_power_get_context(handle, &resource);
	if (result)
223
		return result;
L
Linus Torvalds 已提交
224 225 226 227 228

	if (resource->references)
		resource->references--;

	if (resource->references) {
L
Len Brown 已提交
229 230
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Resource [%s] is still in use, dereferencing\n",
231
				  resource->device->pnp.bus_id));
232
		return 0;
L
Linus Torvalds 已提交
233 234 235 236
	}

	if (resource->state == ACPI_POWER_RESOURCE_STATE_OFF) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] already off\n",
237
				  resource->device->pnp.bus_id));
238
		return 0;
L
Linus Torvalds 已提交
239 240
	}

241
	status = acpi_evaluate_object(resource->device->handle, "_OFF", NULL, NULL);
L
Linus Torvalds 已提交
242
	if (ACPI_FAILURE(status))
243
		return -ENODEV;
L
Linus Torvalds 已提交
244 245 246

	result = acpi_power_get_state(resource);
	if (result)
247
		return result;
L
Linus Torvalds 已提交
248
	if (resource->state != ACPI_POWER_RESOURCE_STATE_OFF)
249
		return -ENOEXEC;
L
Linus Torvalds 已提交
250 251

	/* Update the power resource's _device_ power state */
252
	resource->device->power.state = ACPI_STATE_D3;
L
Linus Torvalds 已提交
253 254

	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] turned off\n",
L
Len Brown 已提交
255
			  resource->name));
L
Linus Torvalds 已提交
256

257
	return 0;
L
Linus Torvalds 已提交
258 259 260 261 262 263 264
}

/*
 * Prepare a wakeup device, two steps (Ref ACPI 2.0:P229):
 * 1. Power on the power resources required for the wakeup device 
 * 2. Enable _PSW (power state wake) for the device if present
 */
L
Len Brown 已提交
265
int acpi_enable_wakeup_device_power(struct acpi_device *dev)
L
Linus Torvalds 已提交
266
{
L
Len Brown 已提交
267 268 269 270 271
	union acpi_object arg = { ACPI_TYPE_INTEGER };
	struct acpi_object_list arg_list = { 1, &arg };
	acpi_status status = AE_OK;
	int i;
	int ret = 0;
L
Linus Torvalds 已提交
272 273

	if (!dev || !dev->wakeup.flags.valid)
274
		return -1;
L
Linus Torvalds 已提交
275 276 277 278 279 280

	arg.integer.value = 1;
	/* Open power resource */
	for (i = 0; i < dev->wakeup.resources.count; i++) {
		ret = acpi_power_on(dev->wakeup.resources.handles[i]);
		if (ret) {
281
			printk(KERN_ERR PREFIX "Transition power state\n");
L
Linus Torvalds 已提交
282
			dev->wakeup.flags.valid = 0;
283
			return -1;
L
Linus Torvalds 已提交
284 285 286 287 288 289
		}
	}

	/* Execute PSW */
	status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL);
	if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
290
		printk(KERN_ERR PREFIX "Evaluate _PSW\n");
L
Linus Torvalds 已提交
291 292 293 294
		dev->wakeup.flags.valid = 0;
		ret = -1;
	}

295
	return ret;
L
Linus Torvalds 已提交
296 297 298 299 300 301 302
}

/*
 * Shutdown a wakeup device, counterpart of above method
 * 1. Disable _PSW (power state wake)
 * 2. Shutdown down the power resources
 */
L
Len Brown 已提交
303
int acpi_disable_wakeup_device_power(struct acpi_device *dev)
L
Linus Torvalds 已提交
304
{
L
Len Brown 已提交
305 306 307 308 309
	union acpi_object arg = { ACPI_TYPE_INTEGER };
	struct acpi_object_list arg_list = { 1, &arg };
	acpi_status status = AE_OK;
	int i;
	int ret = 0;
L
Linus Torvalds 已提交
310 311 312


	if (!dev || !dev->wakeup.flags.valid)
313
		return -1;
L
Linus Torvalds 已提交
314

L
Len Brown 已提交
315
	arg.integer.value = 0;
L
Linus Torvalds 已提交
316 317 318
	/* Execute PSW */
	status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL);
	if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
319
		printk(KERN_ERR PREFIX "Evaluate _PSW\n");
L
Linus Torvalds 已提交
320
		dev->wakeup.flags.valid = 0;
321
		return -1;
L
Linus Torvalds 已提交
322 323 324 325 326 327
	}

	/* Close power resource */
	for (i = 0; i < dev->wakeup.resources.count; i++) {
		ret = acpi_power_off_device(dev->wakeup.resources.handles[i]);
		if (ret) {
328
			printk(KERN_ERR PREFIX "Transition power state\n");
L
Linus Torvalds 已提交
329
			dev->wakeup.flags.valid = 0;
330
			return -1;
L
Linus Torvalds 已提交
331 332 333
		}
	}

334
	return ret;
L
Linus Torvalds 已提交
335 336 337 338 339 340
}

/* --------------------------------------------------------------------------
                             Device Power Management
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
341
int acpi_power_get_inferred_state(struct acpi_device *device)
L
Linus Torvalds 已提交
342
{
L
Len Brown 已提交
343 344 345 346
	int result = 0;
	struct acpi_handle_list *list = NULL;
	int list_state = 0;
	int i = 0;
L
Linus Torvalds 已提交
347 348 349


	if (!device)
350
		return -EINVAL;
L
Linus Torvalds 已提交
351 352 353 354 355 356 357

	device->power.state = ACPI_STATE_UNKNOWN;

	/*
	 * We know a device's inferred power state when all the resources
	 * required for a given D-state are 'on'.
	 */
L
Len Brown 已提交
358
	for (i = ACPI_STATE_D0; i < ACPI_STATE_D3; i++) {
L
Linus Torvalds 已提交
359 360 361 362 363 364
		list = &device->power.states[i].resources;
		if (list->count < 1)
			continue;

		result = acpi_power_get_list_state(list, &list_state);
		if (result)
365
			return result;
L
Linus Torvalds 已提交
366 367 368

		if (list_state == ACPI_POWER_RESOURCE_STATE_ON) {
			device->power.state = i;
369
			return 0;
L
Linus Torvalds 已提交
370 371 372 373 374
		}
	}

	device->power.state = ACPI_STATE_D3;

375
	return 0;
L
Linus Torvalds 已提交
376 377
}

L
Len Brown 已提交
378
int acpi_power_transition(struct acpi_device *device, int state)
L
Linus Torvalds 已提交
379
{
L
Len Brown 已提交
380 381 382 383
	int result = 0;
	struct acpi_handle_list *cl = NULL;	/* Current Resources */
	struct acpi_handle_list *tl = NULL;	/* Target Resources */
	int i = 0;
L
Linus Torvalds 已提交
384 385 386


	if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
387
		return -EINVAL;
L
Linus Torvalds 已提交
388

L
Len Brown 已提交
389 390
	if ((device->power.state < ACPI_STATE_D0)
	    || (device->power.state > ACPI_STATE_D3))
391
		return -ENODEV;
L
Linus Torvalds 已提交
392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408

	cl = &device->power.states[device->power.state].resources;
	tl = &device->power.states[state].resources;

	device->power.state = ACPI_STATE_UNKNOWN;

	if (!cl->count && !tl->count) {
		result = -ENODEV;
		goto end;
	}

	/* TBD: Resources must be ordered. */

	/*
	 * First we reference all power resources required in the target list
	 * (e.g. so the device doesn't lose power while transitioning).
	 */
L
Len Brown 已提交
409
	for (i = 0; i < tl->count; i++) {
L
Linus Torvalds 已提交
410 411 412 413 414 415 416 417
		result = acpi_power_on(tl->handles[i]);
		if (result)
			goto end;
	}

	/*
	 * Then we dereference all power resources used in the current list.
	 */
L
Len Brown 已提交
418
	for (i = 0; i < cl->count; i++) {
L
Linus Torvalds 已提交
419 420 421 422 423 424 425
		result = acpi_power_off_device(cl->handles[i]);
		if (result)
			goto end;
	}

	/* We shouldn't change the state till all above operations succeed */
	device->power.state = state;
L
Len Brown 已提交
426
      end:
L
Linus Torvalds 已提交
427
	if (result)
428 429
		printk(KERN_WARNING PREFIX "Transitioning device [%s] to D%d\n",
			      device->pnp.bus_id, state);
L
Linus Torvalds 已提交
430

431
	return result;
L
Linus Torvalds 已提交
432 433 434 435 436 437
}

/* --------------------------------------------------------------------------
                              FS Interface (/proc)
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
438
static struct proc_dir_entry *acpi_power_dir;
L
Linus Torvalds 已提交
439 440 441 442 443 444

static int acpi_power_seq_show(struct seq_file *seq, void *offset)
{
	struct acpi_power_resource *resource = NULL;


445
	resource = seq->private;
L
Linus Torvalds 已提交
446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463

	if (!resource)
		goto end;

	seq_puts(seq, "state:                   ");
	switch (resource->state) {
	case ACPI_POWER_RESOURCE_STATE_ON:
		seq_puts(seq, "on\n");
		break;
	case ACPI_POWER_RESOURCE_STATE_OFF:
		seq_puts(seq, "off\n");
		break;
	default:
		seq_puts(seq, "unknown\n");
		break;
	}

	seq_printf(seq, "system level:            S%d\n"
L
Len Brown 已提交
464 465 466 467
		   "order:                   %d\n"
		   "reference count:         %d\n",
		   resource->system_level,
		   resource->order, resource->references);
L
Linus Torvalds 已提交
468

L
Len Brown 已提交
469
      end:
470
	return 0;
L
Linus Torvalds 已提交
471 472 473 474 475 476 477
}

static int acpi_power_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, acpi_power_seq_show, PDE(inode)->data);
}

L
Len Brown 已提交
478
static int acpi_power_add_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
479
{
L
Len Brown 已提交
480
	struct proc_dir_entry *entry = NULL;
L
Linus Torvalds 已提交
481 482 483


	if (!device)
484
		return -EINVAL;
L
Linus Torvalds 已提交
485 486 487

	if (!acpi_device_dir(device)) {
		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
L
Len Brown 已提交
488
						     acpi_power_dir);
L
Linus Torvalds 已提交
489
		if (!acpi_device_dir(device))
490
			return -ENODEV;
L
Linus Torvalds 已提交
491 492 493 494
	}

	/* 'status' [R] */
	entry = create_proc_entry(ACPI_POWER_FILE_STATUS,
L
Len Brown 已提交
495
				  S_IRUGO, acpi_device_dir(device));
L
Linus Torvalds 已提交
496
	if (!entry)
497
		return -EIO;
L
Linus Torvalds 已提交
498 499 500 501 502
	else {
		entry->proc_fops = &acpi_power_fops;
		entry->data = acpi_driver_data(device);
	}

503
	return 0;
L
Linus Torvalds 已提交
504 505
}

L
Len Brown 已提交
506
static int acpi_power_remove_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
507 508 509 510 511 512 513 514 515
{

	if (acpi_device_dir(device)) {
		remove_proc_entry(ACPI_POWER_FILE_STATUS,
				  acpi_device_dir(device));
		remove_proc_entry(acpi_device_bid(device), acpi_power_dir);
		acpi_device_dir(device) = NULL;
	}

516
	return 0;
L
Linus Torvalds 已提交
517 518 519 520 521 522
}

/* --------------------------------------------------------------------------
                                Driver Interface
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
523
static int acpi_power_add(struct acpi_device *device)
L
Linus Torvalds 已提交
524
{
L
Len Brown 已提交
525 526
	int result = 0;
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
527
	struct acpi_power_resource *resource = NULL;
L
Len Brown 已提交
528 529
	union acpi_object acpi_object;
	struct acpi_buffer buffer = { sizeof(acpi_object), &acpi_object };
L
Linus Torvalds 已提交
530 531 532


	if (!device)
533
		return -EINVAL;
L
Linus Torvalds 已提交
534

535
	resource = kzalloc(sizeof(struct acpi_power_resource), GFP_KERNEL);
L
Linus Torvalds 已提交
536
	if (!resource)
537
		return -ENOMEM;
L
Linus Torvalds 已提交
538

539
	resource->device = device;
L
Linus Torvalds 已提交
540 541 542 543 544 545
	strcpy(resource->name, device->pnp.bus_id);
	strcpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_POWER_CLASS);
	acpi_driver_data(device) = resource;

	/* Evalute the object to get the system level and resource order. */
546
	status = acpi_evaluate_object(device->handle, NULL, NULL, &buffer);
L
Linus Torvalds 已提交
547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572
	if (ACPI_FAILURE(status)) {
		result = -ENODEV;
		goto end;
	}
	resource->system_level = acpi_object.power_resource.system_level;
	resource->order = acpi_object.power_resource.resource_order;

	result = acpi_power_get_state(resource);
	if (result)
		goto end;

	switch (resource->state) {
	case ACPI_POWER_RESOURCE_STATE_ON:
		device->power.state = ACPI_STATE_D0;
		break;
	case ACPI_POWER_RESOURCE_STATE_OFF:
		device->power.state = ACPI_STATE_D3;
		break;
	default:
		device->power.state = ACPI_STATE_UNKNOWN;
		break;
	}

	result = acpi_power_add_fs(device);
	if (result)
		goto end;
L
Len Brown 已提交
573

L
Linus Torvalds 已提交
574
	printk(KERN_INFO PREFIX "%s [%s] (%s)\n", acpi_device_name(device),
L
Len Brown 已提交
575
	       acpi_device_bid(device), resource->state ? "on" : "off");
L
Linus Torvalds 已提交
576

L
Len Brown 已提交
577
      end:
L
Linus Torvalds 已提交
578 579
	if (result)
		kfree(resource);
L
Len Brown 已提交
580

581
	return result;
L
Linus Torvalds 已提交
582 583
}

L
Len Brown 已提交
584
static int acpi_power_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
585 586 587 588 589
{
	struct acpi_power_resource *resource = NULL;


	if (!device || !acpi_driver_data(device))
590
		return -EINVAL;
L
Linus Torvalds 已提交
591

592
	resource = acpi_driver_data(device);
L
Linus Torvalds 已提交
593 594 595 596 597

	acpi_power_remove_fs(device);

	kfree(resource);

598
	return 0;
L
Linus Torvalds 已提交
599 600
}

L
Len Brown 已提交
601
static int __init acpi_power_init(void)
L
Linus Torvalds 已提交
602
{
L
Len Brown 已提交
603
	int result = 0;
L
Linus Torvalds 已提交
604 605 606


	if (acpi_disabled)
607
		return 0;
L
Linus Torvalds 已提交
608 609 610 611 612

	INIT_LIST_HEAD(&acpi_power_resource_list);

	acpi_power_dir = proc_mkdir(ACPI_POWER_CLASS, acpi_root_dir);
	if (!acpi_power_dir)
613
		return -ENODEV;
L
Linus Torvalds 已提交
614 615 616 617

	result = acpi_bus_register_driver(&acpi_power_driver);
	if (result < 0) {
		remove_proc_entry(ACPI_POWER_CLASS, acpi_root_dir);
618
		return -ENODEV;
L
Linus Torvalds 已提交
619 620
	}

621
	return 0;
L
Linus Torvalds 已提交
622 623 624
}

subsys_initcall(acpi_power_init);