power.c 16.6 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 73 74 75 76 77 78
struct acpi_power_resource {
	acpi_handle handle;
	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 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 103 104 105 106 107

	ACPI_FUNCTION_TRACE("acpi_power_get_context");

	if (!resource)
		return_VALUE(-ENODEV);

	result = acpi_bus_get_device(handle, &device);
	if (result) {
108
		ACPI_WARNING((AE_INFO, "Getting context [%p]", handle));
L
Linus Torvalds 已提交
109 110 111
		return_VALUE(result);
	}

L
Len Brown 已提交
112
	*resource = (struct acpi_power_resource *)acpi_driver_data(device);
L
Linus Torvalds 已提交
113 114 115 116 117 118
	if (!resource)
		return_VALUE(-ENODEV);

	return_VALUE(0);
}

L
Len Brown 已提交
119
static int acpi_power_get_state(struct acpi_power_resource *resource)
L
Linus Torvalds 已提交
120
{
L
Len Brown 已提交
121 122
	acpi_status status = AE_OK;
	unsigned long sta = 0;
L
Linus Torvalds 已提交
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138

	ACPI_FUNCTION_TRACE("acpi_power_get_state");

	if (!resource)
		return_VALUE(-EINVAL);

	status = acpi_evaluate_integer(resource->handle, "_STA", NULL, &sta);
	if (ACPI_FAILURE(status))
		return_VALUE(-ENODEV);

	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 已提交
139
			  resource->name, resource->state ? "on" : "off"));
L
Linus Torvalds 已提交
140 141 142 143

	return_VALUE(0);
}

L
Len Brown 已提交
144
static int acpi_power_get_list_state(struct acpi_handle_list *list, int *state)
L
Linus Torvalds 已提交
145
{
L
Len Brown 已提交
146
	int result = 0;
L
Linus Torvalds 已提交
147
	struct acpi_power_resource *resource = NULL;
L
Len Brown 已提交
148
	u32 i = 0;
L
Linus Torvalds 已提交
149 150 151 152 153 154 155 156

	ACPI_FUNCTION_TRACE("acpi_power_get_list_state");

	if (!list || !state)
		return_VALUE(-EINVAL);

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

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

		*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 已提交
172
			  *state ? "on" : "off"));
L
Linus Torvalds 已提交
173 174 175 176

	return_VALUE(result);
}

L
Len Brown 已提交
177
static int acpi_power_on(acpi_handle handle)
L
Linus Torvalds 已提交
178
{
L
Len Brown 已提交
179 180 181
	int result = 0;
	acpi_status status = AE_OK;
	struct acpi_device *device = NULL;
L
Linus Torvalds 已提交
182 183 184 185 186 187 188 189 190 191
	struct acpi_power_resource *resource = NULL;

	ACPI_FUNCTION_TRACE("acpi_power_on");

	result = acpi_power_get_context(handle, &resource);
	if (result)
		return_VALUE(result);

	resource->references++;

L
Len Brown 已提交
192 193
	if ((resource->references > 1)
	    || (resource->state == ACPI_POWER_RESOURCE_STATE_ON)) {
L
Linus Torvalds 已提交
194
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] already on\n",
L
Len Brown 已提交
195
				  resource->name));
L
Linus Torvalds 已提交
196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
		return_VALUE(0);
	}

	status = acpi_evaluate_object(resource->handle, "_ON", NULL, NULL);
	if (ACPI_FAILURE(status))
		return_VALUE(-ENODEV);

	result = acpi_power_get_state(resource);
	if (result)
		return_VALUE(result);
	if (resource->state != ACPI_POWER_RESOURCE_STATE_ON)
		return_VALUE(-ENOEXEC);

	/* Update the power resource's _device_ power state */
	result = acpi_bus_get_device(resource->handle, &device);
	if (result)
		return_VALUE(result);
	device->power.state = ACPI_STATE_D0;

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

	return_VALUE(0);
}

L
Len Brown 已提交
221
static int acpi_power_off_device(acpi_handle handle)
L
Linus Torvalds 已提交
222
{
L
Len Brown 已提交
223 224 225
	int result = 0;
	acpi_status status = AE_OK;
	struct acpi_device *device = NULL;
L
Linus Torvalds 已提交
226 227 228 229 230 231 232 233 234 235 236 237
	struct acpi_power_resource *resource = NULL;

	ACPI_FUNCTION_TRACE("acpi_power_off_device");

	result = acpi_power_get_context(handle, &resource);
	if (result)
		return_VALUE(result);

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

	if (resource->references) {
L
Len Brown 已提交
238 239 240
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Resource [%s] is still in use, dereferencing\n",
				  device->pnp.bus_id));
L
Linus Torvalds 已提交
241 242 243 244 245
		return_VALUE(0);
	}

	if (resource->state == ACPI_POWER_RESOURCE_STATE_OFF) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] already off\n",
L
Len Brown 已提交
246
				  device->pnp.bus_id));
L
Linus Torvalds 已提交
247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
		return_VALUE(0);
	}

	status = acpi_evaluate_object(resource->handle, "_OFF", NULL, NULL);
	if (ACPI_FAILURE(status))
		return_VALUE(-ENODEV);

	result = acpi_power_get_state(resource);
	if (result)
		return_VALUE(result);
	if (resource->state != ACPI_POWER_RESOURCE_STATE_OFF)
		return_VALUE(-ENOEXEC);

	/* Update the power resource's _device_ power state */
	result = acpi_bus_get_device(resource->handle, &device);
	if (result)
		return_VALUE(result);
	device->power.state = ACPI_STATE_D3;

	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] turned off\n",
L
Len Brown 已提交
267
			  resource->name));
L
Linus Torvalds 已提交
268 269 270 271 272 273 274 275 276

	return_VALUE(0);
}

/*
 * 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 已提交
277
int acpi_enable_wakeup_device_power(struct acpi_device *dev)
L
Linus Torvalds 已提交
278
{
L
Len Brown 已提交
279 280 281 282 283
	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 已提交
284 285 286 287 288 289 290 291 292 293

	ACPI_FUNCTION_TRACE("acpi_enable_wakeup_device_power");
	if (!dev || !dev->wakeup.flags.valid)
		return_VALUE(-1);

	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) {
294
			ACPI_ERROR((AE_INFO, "Transition power state"));
L
Linus Torvalds 已提交
295 296 297 298 299 300 301 302
			dev->wakeup.flags.valid = 0;
			return_VALUE(-1);
		}
	}

	/* Execute PSW */
	status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL);
	if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
303
		ACPI_ERROR((AE_INFO, "Evaluate _PSW"));
L
Linus Torvalds 已提交
304 305 306 307 308 309 310 311 312 313 314 315
		dev->wakeup.flags.valid = 0;
		ret = -1;
	}

	return_VALUE(ret);
}

/*
 * Shutdown a wakeup device, counterpart of above method
 * 1. Disable _PSW (power state wake)
 * 2. Shutdown down the power resources
 */
L
Len Brown 已提交
316
int acpi_disable_wakeup_device_power(struct acpi_device *dev)
L
Linus Torvalds 已提交
317
{
L
Len Brown 已提交
318 319 320 321 322
	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 已提交
323 324 325 326 327 328

	ACPI_FUNCTION_TRACE("acpi_disable_wakeup_device_power");

	if (!dev || !dev->wakeup.flags.valid)
		return_VALUE(-1);

L
Len Brown 已提交
329
	arg.integer.value = 0;
L
Linus Torvalds 已提交
330 331 332
	/* Execute PSW */
	status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL);
	if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
333
		ACPI_ERROR((AE_INFO, "Evaluate _PSW"));
L
Linus Torvalds 已提交
334 335 336 337 338 339 340 341
		dev->wakeup.flags.valid = 0;
		return_VALUE(-1);
	}

	/* Close power resource */
	for (i = 0; i < dev->wakeup.resources.count; i++) {
		ret = acpi_power_off_device(dev->wakeup.resources.handles[i]);
		if (ret) {
342
			ACPI_ERROR((AE_INFO, "Transition power state"));
L
Linus Torvalds 已提交
343 344 345 346 347 348 349 350 351 352 353 354
			dev->wakeup.flags.valid = 0;
			return_VALUE(-1);
		}
	}

	return_VALUE(ret);
}

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

L
Len Brown 已提交
355
int acpi_power_get_inferred_state(struct acpi_device *device)
L
Linus Torvalds 已提交
356
{
L
Len Brown 已提交
357 358 359 360
	int result = 0;
	struct acpi_handle_list *list = NULL;
	int list_state = 0;
	int i = 0;
L
Linus Torvalds 已提交
361 362 363 364 365 366 367 368 369 370 371 372

	ACPI_FUNCTION_TRACE("acpi_power_get_inferred_state");

	if (!device)
		return_VALUE(-EINVAL);

	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 已提交
373
	for (i = ACPI_STATE_D0; i < ACPI_STATE_D3; i++) {
L
Linus Torvalds 已提交
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392
		list = &device->power.states[i].resources;
		if (list->count < 1)
			continue;

		result = acpi_power_get_list_state(list, &list_state);
		if (result)
			return_VALUE(result);

		if (list_state == ACPI_POWER_RESOURCE_STATE_ON) {
			device->power.state = i;
			return_VALUE(0);
		}
	}

	device->power.state = ACPI_STATE_D3;

	return_VALUE(0);
}

L
Len Brown 已提交
393
int acpi_power_transition(struct acpi_device *device, int state)
L
Linus Torvalds 已提交
394
{
L
Len Brown 已提交
395 396 397 398
	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 已提交
399 400 401 402 403 404

	ACPI_FUNCTION_TRACE("acpi_power_transition");

	if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
		return_VALUE(-EINVAL);

L
Len Brown 已提交
405 406
	if ((device->power.state < ACPI_STATE_D0)
	    || (device->power.state > ACPI_STATE_D3))
L
Linus Torvalds 已提交
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424
		return_VALUE(-ENODEV);

	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 已提交
425
	for (i = 0; i < tl->count; i++) {
L
Linus Torvalds 已提交
426 427 428 429 430 431 432 433
		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 已提交
434
	for (i = 0; i < cl->count; i++) {
L
Linus Torvalds 已提交
435 436 437 438 439 440 441
		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 已提交
442
      end:
L
Linus Torvalds 已提交
443
	if (result)
444 445
		ACPI_WARNING((AE_INFO, "Transitioning device [%s] to D%d",
			      device->pnp.bus_id, state));
L
Linus Torvalds 已提交
446 447 448 449 450 451 452 453

	return_VALUE(result);
}

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

L
Len Brown 已提交
454
static struct proc_dir_entry *acpi_power_dir;
L
Linus Torvalds 已提交
455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480

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

	ACPI_FUNCTION_TRACE("acpi_power_seq_show");

	resource = (struct acpi_power_resource *)seq->private;

	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 已提交
481 482 483 484
		   "order:                   %d\n"
		   "reference count:         %d\n",
		   resource->system_level,
		   resource->order, resource->references);
L
Linus Torvalds 已提交
485

L
Len Brown 已提交
486
      end:
L
Linus Torvalds 已提交
487 488 489 490 491 492 493 494
	return_VALUE(0);
}

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 已提交
495
static int acpi_power_add_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
496
{
L
Len Brown 已提交
497
	struct proc_dir_entry *entry = NULL;
L
Linus Torvalds 已提交
498 499 500 501 502 503 504 505

	ACPI_FUNCTION_TRACE("acpi_power_add_fs");

	if (!device)
		return_VALUE(-EINVAL);

	if (!acpi_device_dir(device)) {
		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
L
Len Brown 已提交
506
						     acpi_power_dir);
L
Linus Torvalds 已提交
507 508 509 510 511 512
		if (!acpi_device_dir(device))
			return_VALUE(-ENODEV);
	}

	/* 'status' [R] */
	entry = create_proc_entry(ACPI_POWER_FILE_STATUS,
L
Len Brown 已提交
513
				  S_IRUGO, acpi_device_dir(device));
L
Linus Torvalds 已提交
514
	if (!entry)
515
		return_VALUE(-EIO);
L
Linus Torvalds 已提交
516 517 518 519 520 521 522 523
	else {
		entry->proc_fops = &acpi_power_fops;
		entry->data = acpi_driver_data(device);
	}

	return_VALUE(0);
}

L
Len Brown 已提交
524
static int acpi_power_remove_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
{
	ACPI_FUNCTION_TRACE("acpi_power_remove_fs");

	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;
	}

	return_VALUE(0);
}

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

L
Len Brown 已提交
542
static int acpi_power_add(struct acpi_device *device)
L
Linus Torvalds 已提交
543
{
L
Len Brown 已提交
544 545
	int result = 0;
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
546
	struct acpi_power_resource *resource = NULL;
L
Len Brown 已提交
547 548
	union acpi_object acpi_object;
	struct acpi_buffer buffer = { sizeof(acpi_object), &acpi_object };
L
Linus Torvalds 已提交
549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593

	ACPI_FUNCTION_TRACE("acpi_power_add");

	if (!device)
		return_VALUE(-EINVAL);

	resource = kmalloc(sizeof(struct acpi_power_resource), GFP_KERNEL);
	if (!resource)
		return_VALUE(-ENOMEM);
	memset(resource, 0, sizeof(struct acpi_power_resource));

	resource->handle = device->handle;
	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. */
	status = acpi_evaluate_object(resource->handle, NULL, NULL, &buffer);
	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 已提交
594

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

L
Len Brown 已提交
598
      end:
L
Linus Torvalds 已提交
599 600
	if (result)
		kfree(resource);
L
Len Brown 已提交
601

L
Linus Torvalds 已提交
602 603 604
	return_VALUE(result);
}

L
Len Brown 已提交
605
static int acpi_power_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
606 607 608 609 610 611 612 613
{
	struct acpi_power_resource *resource = NULL;

	ACPI_FUNCTION_TRACE("acpi_power_remove");

	if (!device || !acpi_driver_data(device))
		return_VALUE(-EINVAL);

L
Len Brown 已提交
614
	resource = (struct acpi_power_resource *)acpi_driver_data(device);
L
Linus Torvalds 已提交
615 616 617 618 619 620 621 622

	acpi_power_remove_fs(device);

	kfree(resource);

	return_VALUE(0);
}

L
Len Brown 已提交
623
static int __init acpi_power_init(void)
L
Linus Torvalds 已提交
624
{
L
Len Brown 已提交
625
	int result = 0;
L
Linus Torvalds 已提交
626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647

	ACPI_FUNCTION_TRACE("acpi_power_init");

	if (acpi_disabled)
		return_VALUE(0);

	INIT_LIST_HEAD(&acpi_power_resource_list);

	acpi_power_dir = proc_mkdir(ACPI_POWER_CLASS, acpi_root_dir);
	if (!acpi_power_dir)
		return_VALUE(-ENODEV);

	result = acpi_bus_register_driver(&acpi_power_driver);
	if (result < 0) {
		remove_proc_entry(ACPI_POWER_CLASS, acpi_root_dir);
		return_VALUE(-ENODEV);
	}

	return_VALUE(0);
}

subsys_initcall(acpi_power_init);