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#include <linux/kernel.h>
39#include <linux/module.h>
40#include <linux/init.h>
41#include <linux/types.h>
42#include <linux/proc_fs.h>
43#include <linux/seq_file.h>
44#include <acpi/acpi_bus.h>
45#include <acpi/acpi_drivers.h>
46
47#define _COMPONENT ACPI_POWER_COMPONENT
48ACPI_MODULE_NAME("power");
49#define ACPI_POWER_COMPONENT 0x00800000
50#define ACPI_POWER_CLASS "power_resource"
51#define ACPI_POWER_DEVICE_NAME "Power Resource"
52#define ACPI_POWER_FILE_INFO "info"
53#define ACPI_POWER_FILE_STATUS "state"
54#define ACPI_POWER_RESOURCE_STATE_OFF 0x00
55#define ACPI_POWER_RESOURCE_STATE_ON 0x01
56#define ACPI_POWER_RESOURCE_STATE_UNKNOWN 0xFF
57static int acpi_power_add(struct acpi_device *device);
58static int acpi_power_remove(struct acpi_device *device, int type);
59static int acpi_power_resume(struct acpi_device *device);
60static int acpi_power_open_fs(struct inode *inode, struct file *file);
61
62static struct acpi_device_id power_device_ids[] = {
63 {ACPI_POWER_HID, 0},
64 {"", 0},
65};
66MODULE_DEVICE_TABLE(acpi, power_device_ids);
67
68static struct acpi_driver acpi_power_driver = {
69 .name = "power",
70 .class = ACPI_POWER_CLASS,
71 .ids = power_device_ids,
72 .ops = {
73 .add = acpi_power_add,
74 .remove = acpi_power_remove,
75 .resume = acpi_power_resume,
76 },
77};
78
79struct acpi_power_reference {
80 struct list_head node;
81 struct acpi_device *device;
82};
83
84struct acpi_power_resource {
85 struct acpi_device * device;
86 acpi_bus_id name;
87 u32 system_level;
88 u32 order;
89 struct mutex resource_lock;
90 struct list_head reference;
91};
92
93static struct list_head acpi_power_resource_list;
94
95static const struct file_operations acpi_power_fops = {
96 .open = acpi_power_open_fs,
97 .read = seq_read,
98 .llseek = seq_lseek,
99 .release = single_release,
100};
101
102
103
104
105
106static int
107acpi_power_get_context(acpi_handle handle,
108 struct acpi_power_resource **resource)
109{
110 int result = 0;
111 struct acpi_device *device = NULL;
112
113
114 if (!resource)
115 return -ENODEV;
116
117 result = acpi_bus_get_device(handle, &device);
118 if (result) {
119 printk(KERN_WARNING PREFIX "Getting context [%p]\n", handle);
120 return result;
121 }
122
123 *resource = acpi_driver_data(device);
124 if (!resource)
125 return -ENODEV;
126
127 return 0;
128}
129
130static int acpi_power_get_state(struct acpi_power_resource *resource, int *state)
131{
132 acpi_status status = AE_OK;
133 unsigned long sta = 0;
134
135
136 if (!resource || !state)
137 return -EINVAL;
138
139 status = acpi_evaluate_integer(resource->device->handle, "_STA", NULL, &sta);
140 if (ACPI_FAILURE(status))
141 return -ENODEV;
142
143 *state = (sta & 0x01)?ACPI_POWER_RESOURCE_STATE_ON:
144 ACPI_POWER_RESOURCE_STATE_OFF;
145
146 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] is %s\n",
147 resource->name, state ? "on" : "off"));
148
149 return 0;
150}
151
152static int acpi_power_get_list_state(struct acpi_handle_list *list, int *state)
153{
154 int result = 0, state1;
155 struct acpi_power_resource *resource = NULL;
156 u32 i = 0;
157
158
159 if (!list || !state)
160 return -EINVAL;
161
162
163
164 for (i = 0; i < list->count; i++) {
165 result = acpi_power_get_context(list->handles[i], &resource);
166 if (result)
167 return result;
168 result = acpi_power_get_state(resource, &state1);
169 if (result)
170 return result;
171
172 *state = state1;
173
174 if (*state != ACPI_POWER_RESOURCE_STATE_ON)
175 break;
176 }
177
178 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource list is %s\n",
179 *state ? "on" : "off"));
180
181 return result;
182}
183
184static int acpi_power_on(acpi_handle handle, struct acpi_device *dev)
185{
186 int result = 0, state;
187 int found = 0;
188 acpi_status status = AE_OK;
189 struct acpi_power_resource *resource = NULL;
190 struct list_head *node, *next;
191 struct acpi_power_reference *ref;
192
193
194 result = acpi_power_get_context(handle, &resource);
195 if (result)
196 return result;
197
198 mutex_lock(&resource->resource_lock);
199 list_for_each_safe(node, next, &resource->reference) {
200 ref = container_of(node, struct acpi_power_reference, node);
201 if (dev->handle == ref->device->handle) {
202 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] already referenced by resource [%s]\n",
203 dev->pnp.bus_id, resource->name));
204 found = 1;
205 break;
206 }
207 }
208
209 if (!found) {
210 ref = kmalloc(sizeof (struct acpi_power_reference),
211 irqs_disabled() ? GFP_ATOMIC : GFP_KERNEL);
212 if (!ref) {
213 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "kmalloc() failed\n"));
214 mutex_unlock(&resource->resource_lock);
215 return -ENOMEM;
216 }
217 list_add_tail(&ref->node, &resource->reference);
218 ref->device = dev;
219 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] added to resource [%s] references\n",
220 dev->pnp.bus_id, resource->name));
221 }
222 mutex_unlock(&resource->resource_lock);
223
224 status = acpi_evaluate_object(resource->device->handle, "_ON", NULL, NULL);
225 if (ACPI_FAILURE(status))
226 return -ENODEV;
227
228 result = acpi_power_get_state(resource, &state);
229 if (result)
230 return result;
231 if (state != ACPI_POWER_RESOURCE_STATE_ON)
232 return -ENOEXEC;
233
234
235 resource->device->power.state = ACPI_STATE_D0;
236
237 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] turned on\n",
238 resource->name));
239 return 0;
240}
241
242static int acpi_power_off_device(acpi_handle handle, struct acpi_device *dev)
243{
244 int result = 0, state;
245 acpi_status status = AE_OK;
246 struct acpi_power_resource *resource = NULL;
247 struct list_head *node, *next;
248 struct acpi_power_reference *ref;
249
250
251 result = acpi_power_get_context(handle, &resource);
252 if (result)
253 return result;
254
255 mutex_lock(&resource->resource_lock);
256 list_for_each_safe(node, next, &resource->reference) {
257 ref = container_of(node, struct acpi_power_reference, node);
258 if (dev->handle == ref->device->handle) {
259 list_del(&ref->node);
260 kfree(ref);
261 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] removed from resource [%s] references\n",
262 dev->pnp.bus_id, resource->name));
263 break;
264 }
265 }
266
267 if (!list_empty(&resource->reference)) {
268 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Cannot turn resource [%s] off - resource is in use\n",
269 resource->name));
270 mutex_unlock(&resource->resource_lock);
271 return 0;
272 }
273 mutex_unlock(&resource->resource_lock);
274
275 status = acpi_evaluate_object(resource->device->handle, "_OFF", NULL, NULL);
276 if (ACPI_FAILURE(status))
277 return -ENODEV;
278
279 result = acpi_power_get_state(resource, &state);
280 if (result)
281 return result;
282 if (state != ACPI_POWER_RESOURCE_STATE_OFF)
283 return -ENOEXEC;
284
285
286 resource->device->power.state = ACPI_STATE_D3;
287
288 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] turned off\n",
289 resource->name));
290
291 return 0;
292}
293
294
295
296
297
298
299int acpi_enable_wakeup_device_power(struct acpi_device *dev)
300{
301 union acpi_object arg = { ACPI_TYPE_INTEGER };
302 struct acpi_object_list arg_list = { 1, &arg };
303 acpi_status status = AE_OK;
304 int i;
305 int ret = 0;
306
307 if (!dev || !dev->wakeup.flags.valid)
308 return -1;
309
310 arg.integer.value = 1;
311
312 for (i = 0; i < dev->wakeup.resources.count; i++) {
313 ret = acpi_power_on(dev->wakeup.resources.handles[i], dev);
314 if (ret) {
315 printk(KERN_ERR PREFIX "Transition power state\n");
316 dev->wakeup.flags.valid = 0;
317 return -1;
318 }
319 }
320
321
322 status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL);
323 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
324 printk(KERN_ERR PREFIX "Evaluate _PSW\n");
325 dev->wakeup.flags.valid = 0;
326 ret = -1;
327 }
328
329 return ret;
330}
331
332
333
334
335
336
337int acpi_disable_wakeup_device_power(struct acpi_device *dev)
338{
339 union acpi_object arg = { ACPI_TYPE_INTEGER };
340 struct acpi_object_list arg_list = { 1, &arg };
341 acpi_status status = AE_OK;
342 int i;
343 int ret = 0;
344
345
346 if (!dev || !dev->wakeup.flags.valid)
347 return -1;
348
349 arg.integer.value = 0;
350
351 status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL);
352 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
353 printk(KERN_ERR PREFIX "Evaluate _PSW\n");
354 dev->wakeup.flags.valid = 0;
355 return -1;
356 }
357
358
359 for (i = 0; i < dev->wakeup.resources.count; i++) {
360 ret = acpi_power_off_device(dev->wakeup.resources.handles[i], dev);
361 if (ret) {
362 printk(KERN_ERR PREFIX "Transition power state\n");
363 dev->wakeup.flags.valid = 0;
364 return -1;
365 }
366 }
367
368 return ret;
369}
370
371
372
373
374
375int acpi_power_get_inferred_state(struct acpi_device *device)
376{
377 int result = 0;
378 struct acpi_handle_list *list = NULL;
379 int list_state = 0;
380 int i = 0;
381
382
383 if (!device)
384 return -EINVAL;
385
386 device->power.state = ACPI_STATE_UNKNOWN;
387
388
389
390
391
392 for (i = ACPI_STATE_D0; i < ACPI_STATE_D3; i++) {
393 list = &device->power.states[i].resources;
394 if (list->count < 1)
395 continue;
396
397 result = acpi_power_get_list_state(list, &list_state);
398 if (result)
399 return result;
400
401 if (list_state == ACPI_POWER_RESOURCE_STATE_ON) {
402 device->power.state = i;
403 return 0;
404 }
405 }
406
407 device->power.state = ACPI_STATE_D3;
408
409 return 0;
410}
411
412int acpi_power_transition(struct acpi_device *device, int state)
413{
414 int result = 0;
415 struct acpi_handle_list *cl = NULL;
416 struct acpi_handle_list *tl = NULL;
417 int i = 0;
418
419
420 if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
421 return -EINVAL;
422
423 if ((device->power.state < ACPI_STATE_D0)
424 || (device->power.state > ACPI_STATE_D3))
425 return -ENODEV;
426
427 cl = &device->power.states[device->power.state].resources;
428 tl = &device->power.states[state].resources;
429
430 if (!cl->count && !tl->count) {
431 result = -ENODEV;
432 goto end;
433 }
434
435
436
437
438
439
440
441 for (i = 0; i < tl->count; i++) {
442 result = acpi_power_on(tl->handles[i], device);
443 if (result)
444 goto end;
445 }
446
447 if (device->power.state == state) {
448 goto end;
449 }
450
451
452
453
454 for (i = 0; i < cl->count; i++) {
455 result = acpi_power_off_device(cl->handles[i], device);
456 if (result)
457 goto end;
458 }
459
460 end:
461 if (result) {
462 device->power.state = ACPI_STATE_UNKNOWN;
463 printk(KERN_WARNING PREFIX "Transitioning device [%s] to D%d\n",
464 device->pnp.bus_id, state);
465 } else {
466
467 device->power.state = state;
468 }
469
470 return result;
471}
472
473
474
475
476
477static struct proc_dir_entry *acpi_power_dir;
478
479static int acpi_power_seq_show(struct seq_file *seq, void *offset)
480{
481 int count = 0;
482 int result = 0, state;
483 struct acpi_power_resource *resource = NULL;
484 struct list_head *node, *next;
485 struct acpi_power_reference *ref;
486
487
488 resource = seq->private;
489
490 if (!resource)
491 goto end;
492
493 result = acpi_power_get_state(resource, &state);
494 if (result)
495 goto end;
496
497 seq_puts(seq, "state: ");
498 switch (state) {
499 case ACPI_POWER_RESOURCE_STATE_ON:
500 seq_puts(seq, "on\n");
501 break;
502 case ACPI_POWER_RESOURCE_STATE_OFF:
503 seq_puts(seq, "off\n");
504 break;
505 default:
506 seq_puts(seq, "unknown\n");
507 break;
508 }
509
510 mutex_lock(&resource->resource_lock);
511 list_for_each_safe(node, next, &resource->reference) {
512 ref = container_of(node, struct acpi_power_reference, node);
513 count++;
514 }
515 mutex_unlock(&resource->resource_lock);
516
517 seq_printf(seq, "system level: S%d\n"
518 "order: %d\n"
519 "reference count: %d\n",
520 resource->system_level,
521 resource->order, count);
522
523 end:
524 return 0;
525}
526
527static int acpi_power_open_fs(struct inode *inode, struct file *file)
528{
529 return single_open(file, acpi_power_seq_show, PDE(inode)->data);
530}
531
532static int acpi_power_add_fs(struct acpi_device *device)
533{
534 struct proc_dir_entry *entry = NULL;
535
536
537 if (!device)
538 return -EINVAL;
539
540 if (!acpi_device_dir(device)) {
541 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
542 acpi_power_dir);
543 if (!acpi_device_dir(device))
544 return -ENODEV;
545 }
546
547
548 entry = create_proc_entry(ACPI_POWER_FILE_STATUS,
549 S_IRUGO, acpi_device_dir(device));
550 if (!entry)
551 return -EIO;
552 else {
553 entry->proc_fops = &acpi_power_fops;
554 entry->data = acpi_driver_data(device);
555 }
556
557 return 0;
558}
559
560static int acpi_power_remove_fs(struct acpi_device *device)
561{
562
563 if (acpi_device_dir(device)) {
564 remove_proc_entry(ACPI_POWER_FILE_STATUS,
565 acpi_device_dir(device));
566 remove_proc_entry(acpi_device_bid(device), acpi_power_dir);
567 acpi_device_dir(device) = NULL;
568 }
569
570 return 0;
571}
572
573
574
575
576
577static int acpi_power_add(struct acpi_device *device)
578{
579 int result = 0, state;
580 acpi_status status = AE_OK;
581 struct acpi_power_resource *resource = NULL;
582 union acpi_object acpi_object;
583 struct acpi_buffer buffer = { sizeof(acpi_object), &acpi_object };
584
585
586 if (!device)
587 return -EINVAL;
588
589 resource = kzalloc(sizeof(struct acpi_power_resource), GFP_KERNEL);
590 if (!resource)
591 return -ENOMEM;
592
593 resource->device = device;
594 mutex_init(&resource->resource_lock);
595 INIT_LIST_HEAD(&resource->reference);
596 strcpy(resource->name, device->pnp.bus_id);
597 strcpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME);
598 strcpy(acpi_device_class(device), ACPI_POWER_CLASS);
599 acpi_driver_data(device) = resource;
600
601
602 status = acpi_evaluate_object(device->handle, NULL, NULL, &buffer);
603 if (ACPI_FAILURE(status)) {
604 result = -ENODEV;
605 goto end;
606 }
607 resource->system_level = acpi_object.power_resource.system_level;
608 resource->order = acpi_object.power_resource.resource_order;
609
610 result = acpi_power_get_state(resource, &state);
611 if (result)
612 goto end;
613
614 switch (state) {
615 case ACPI_POWER_RESOURCE_STATE_ON:
616 device->power.state = ACPI_STATE_D0;
617 break;
618 case ACPI_POWER_RESOURCE_STATE_OFF:
619 device->power.state = ACPI_STATE_D3;
620 break;
621 default:
622 device->power.state = ACPI_STATE_UNKNOWN;
623 break;
624 }
625
626 result = acpi_power_add_fs(device);
627 if (result)
628 goto end;
629
630 printk(KERN_INFO PREFIX "%s [%s] (%s)\n", acpi_device_name(device),
631 acpi_device_bid(device), state ? "on" : "off");
632
633 end:
634 if (result)
635 kfree(resource);
636
637 return result;
638}
639
640static int acpi_power_remove(struct acpi_device *device, int type)
641{
642 struct acpi_power_resource *resource = NULL;
643 struct list_head *node, *next;
644
645
646 if (!device || !acpi_driver_data(device))
647 return -EINVAL;
648
649 resource = acpi_driver_data(device);
650
651 acpi_power_remove_fs(device);
652
653 mutex_lock(&resource->resource_lock);
654 list_for_each_safe(node, next, &resource->reference) {
655 struct acpi_power_reference *ref = container_of(node, struct acpi_power_reference, node);
656 list_del(&ref->node);
657 kfree(ref);
658 }
659 mutex_unlock(&resource->resource_lock);
660
661 kfree(resource);
662
663 return 0;
664}
665
666static int acpi_power_resume(struct acpi_device *device)
667{
668 int result = 0, state;
669 struct acpi_power_resource *resource = NULL;
670 struct acpi_power_reference *ref;
671
672 if (!device || !acpi_driver_data(device))
673 return -EINVAL;
674
675 resource = (struct acpi_power_resource *)acpi_driver_data(device);
676
677 result = acpi_power_get_state(resource, &state);
678 if (result)
679 return result;
680
681 mutex_lock(&resource->resource_lock);
682 if (state == ACPI_POWER_RESOURCE_STATE_OFF &&
683 !list_empty(&resource->reference)) {
684 ref = container_of(resource->reference.next, struct acpi_power_reference, node);
685 mutex_unlock(&resource->resource_lock);
686 result = acpi_power_on(device->handle, ref->device);
687 return result;
688 }
689
690 mutex_unlock(&resource->resource_lock);
691 return 0;
692}
693
694static int __init acpi_power_init(void)
695{
696 int result = 0;
697
698
699 if (acpi_disabled)
700 return 0;
701
702 INIT_LIST_HEAD(&acpi_power_resource_list);
703
704 acpi_power_dir = proc_mkdir(ACPI_POWER_CLASS, acpi_root_dir);
705 if (!acpi_power_dir)
706 return -ENODEV;
707
708 result = acpi_bus_register_driver(&acpi_power_driver);
709 if (result < 0) {
710 remove_proc_entry(ACPI_POWER_CLASS, acpi_root_dir);
711 return -ENODEV;
712 }
713
714 return 0;
715}
716
717subsys_initcall(acpi_power_init);
718
