1 /*
2 * acpi_bus.c - ACPI Bus Driver ($Revision: 77 $)
3 *
4 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
5 *
6 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or (at
11 * your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
21 *
22 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
23 */
24
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/init.h>
28 #include <linux/types.h>
29 #include <linux/version.h>
30 #include <linux/ioport.h>
31 #include <linux/list.h>
32 #include <linux/sched.h>
33 #include <linux/pm.h>
34 #include <linux/proc_fs.h>
35 #ifdef CONFIG_X86
36 #include <asm/mpspec.h>
37 #endif
38 #include <acpi/acpi_bus.h>
39 #include <acpi/acpi_drivers.h>
40 #include <acpi/acinterp.h> /* for acpi_ex_eisa_id_to_string() */
41
42
43 #define _COMPONENT ACPI_BUS_COMPONENT
44 ACPI_MODULE_NAME ("acpi_bus")
45
46 MODULE_AUTHOR("Paul Diefenbaugh");
47 MODULE_DESCRIPTION(ACPI_BUS_DRIVER_NAME);
48 MODULE_LICENSE("GPL");
49
50 #define PREFIX "ACPI: "
51
52 extern void __init acpi_pic_sci_set_trigger(unsigned int irq, u16 trigger);
53
54 FADT_DESCRIPTOR acpi_fadt;
55 struct acpi_device *acpi_root;
56 struct proc_dir_entry *acpi_root_dir;
57
58 #define STRUCT_TO_INT(s) (*((int*)&s))
59
60
61 /* --------------------------------------------------------------------------
62 Linux Driver Model (LDM) Support
63 -------------------------------------------------------------------------- */
64
65 #ifdef CONFIG_LDM
66
67 static int acpi_device_probe(struct device *dev);
68 static int acpi_device_remove(struct device *dev);
69 static int acpi_device_suspend(struct device *dev, u32 state, u32 stage);
70 static int acpi_device_resume(struct device *dev, u32 stage);
71
72 static struct device_driver acpi_bus_driver = {
73 .probe = acpi_device_probe,
74 .remove = acpi_device_remove,
75 .suspend = acpi_device_suspend,
76 .resume = acpi_device_resume,
77 };
78
79
80 static int
acpi_device_probe(struct device * dev)81 acpi_device_probe (
82 struct device *dev)
83 {
84 ACPI_FUNCTION_TRACE("acpi_device_probe");
85
86 if (!dev)
87 return_VALUE(-EINVAL);
88
89 /* TBD */
90
91 return_VALUE(0);
92 }
93
94
95 static int
acpi_device_remove(struct device * dev)96 acpi_device_remove (
97 struct device *dev)
98 {
99 ACPI_FUNCTION_TRACE("acpi_device_remove");
100
101 if (!dev)
102 return_VALUE(-EINVAL);
103
104 /* TBD */
105
106 return_VALUE(0);
107 }
108
109
110 static int
acpi_device_suspend(struct device * dev,u32 state,u32 stage)111 acpi_device_suspend (
112 struct device *dev,
113 u32 state,
114 u32 stage)
115 {
116 ACPI_FUNCTION_TRACE("acpi_device_suspend");
117
118 if (!dev)
119 return_VALUE(-EINVAL);
120
121 /* TBD */
122
123 return_VALUE(0);
124 }
125
126
127 static int
acpi_device_resume(struct device * dev,u32 stage)128 acpi_device_resume (
129 struct device *dev,
130 u32 stage)
131 {
132 ACPI_FUNCTION_TRACE("acpi_device_resume");
133
134 if (!dev)
135 return_VALUE(-EINVAL);
136
137 /* TBD */
138
139 return_VALUE(0);
140 }
141
142 #if 0 /* not used ATM */
143 static int
144 acpi_platform_add (
145 struct device *dev)
146 {
147 ACPI_FUNCTION_TRACE("acpi_platform_add");
148
149 if (!dev)
150 return -EINVAL;
151
152 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device %s (%s) added\n",
153 dev->name, dev->bus_id));
154
155 /* TBD */
156
157 return_VALUE(0);
158 }
159
160
161 static int
162 acpi_platform_remove (
163 struct device *dev)
164 {
165 ACPI_FUNCTION_TRACE("acpi_platform_add");
166
167 if (!dev)
168 return -EINVAL;
169
170 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device %s (%s) removed\n",
171 dev->name, dev->bus_id));
172
173 /* TBD */
174
175 return_VALUE(0);
176 }
177 #endif /* unused */
178
179
180 #endif /*CONFIG_LDM*/
181
182
183 static int
acpi_device_register(struct acpi_device * device,struct acpi_device * parent)184 acpi_device_register (
185 struct acpi_device *device,
186 struct acpi_device *parent)
187 {
188 int result = 0;
189
190 ACPI_FUNCTION_TRACE("acpi_device_register");
191
192 if (!device)
193 return_VALUE(-EINVAL);
194
195 #ifdef CONFIG_LDM
196 sprintf(device->dev.name, "ACPI device %s:%s",
197 device->pnp.hardware_id, device->pnp.unique_id);
198 strncpy(device->dev.bus_id, device->pnp.bus_id, sizeof(acpi_bus_id));
199 if (parent)
200 device->dev.parent = &parent->dev;
201 device->dev.driver = &acpi_bus_driver;
202
203 result = device_register(&device->dev);
204 #endif /*CONFIG_LDM*/
205
206 return_VALUE(result);
207 }
208
209
210 static int
acpi_device_unregister(struct acpi_device * device)211 acpi_device_unregister (
212 struct acpi_device *device)
213 {
214 ACPI_FUNCTION_TRACE("acpi_device_unregister");
215
216 if (!device)
217 return_VALUE(-EINVAL);
218
219 #ifdef CONFIG_LDM
220 put_device(&device->dev);
221 #endif /*CONFIG_LDM*/
222
223 return_VALUE(0);
224 }
225
226
227 /* --------------------------------------------------------------------------
228 Device Management
229 -------------------------------------------------------------------------- */
230
231 static void
acpi_bus_data_handler(acpi_handle handle,u32 function,void * context)232 acpi_bus_data_handler (
233 acpi_handle handle,
234 u32 function,
235 void *context)
236 {
237 ACPI_FUNCTION_TRACE("acpi_bus_data_handler");
238
239 /* TBD */
240
241 return_VOID;
242 }
243
244
245 int
acpi_bus_get_device(acpi_handle handle,struct acpi_device ** device)246 acpi_bus_get_device (
247 acpi_handle handle,
248 struct acpi_device **device)
249 {
250 acpi_status status = AE_OK;
251
252 ACPI_FUNCTION_TRACE("acpi_bus_get_device");
253
254 if (!device)
255 return_VALUE(-EINVAL);
256
257 /* TBD: Support fixed-feature devices */
258
259 status = acpi_get_data(handle, acpi_bus_data_handler, (void**) device);
260 if (ACPI_FAILURE(status) || !*device) {
261 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Error getting context for object [%p]\n",
262 handle));
263 return_VALUE(-ENODEV);
264 }
265
266 return_VALUE(0);
267 }
268
269 int
acpi_bus_get_status(struct acpi_device * device)270 acpi_bus_get_status (
271 struct acpi_device *device)
272 {
273 acpi_status status = AE_OK;
274 unsigned long sta = 0;
275
276 ACPI_FUNCTION_TRACE("acpi_bus_get_status");
277
278 if (!device)
279 return_VALUE(-EINVAL);
280
281 /*
282 * Evaluate _STA if present.
283 */
284 if (device->flags.dynamic_status) {
285 status = acpi_evaluate_integer(device->handle, "_STA", NULL, &sta);
286 if (ACPI_FAILURE(status))
287 return_VALUE(-ENODEV);
288 STRUCT_TO_INT(device->status) = (int) sta;
289 }
290
291 /*
292 * Otherwise we assume the status of our parent (unless we don't
293 * have one, in which case status is implied).
294 */
295 else if (device->parent)
296 device->status = device->parent->status;
297 else
298 STRUCT_TO_INT(device->status) = 0x0F;
299
300 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n",
301 device->pnp.bus_id, (u32) STRUCT_TO_INT(device->status)));
302
303 return_VALUE(0);
304 }
305
306
307 /*
308 static int
309 acpi_bus_create_device_fs (struct device *device)
310 {
311 ACPI_FUNCTION_TRACE("acpi_bus_create_device_fs");
312
313 if (!device)
314 return_VALUE(-EINVAL);
315
316 if (device->dir.entry)
317 return_VALUE(-EEXIST);
318
319 if (!device->parent)
320 device->dir.entry = proc_mkdir(device->pnp.bus_id, NULL);
321 else
322 device->dir.entry = proc_mkdir(device->pnp.bus_id,
323 device->parent->fs.entry);
324
325 if (!device->dir.entry) {
326 printk(KERN_ERR PREFIX "Unable to create fs entry '%s'\n",
327 device->pnp.bus_id);
328 return_VALUE(-ENODEV);
329 }
330
331 return_VALUE(0);
332 }
333
334
335 static int
336 acpi_bus_remove_device_fs (struct device *device)
337 {
338 ACPI_FUNCTION_TRACE("acpi_bus_create_device_fs");
339
340 if (!device)
341 return_VALUE(-EINVAL);
342
343 if (!device->dir.entry)
344 return_VALUE(-ENODEV);
345
346 if (!device->parent)
347 remove_proc_entry(device->pnp_bus_id, NULL);
348 else
349 remove_proc_entry(device->pnp.bus_id, device->parent->fs.entry);
350
351 device->dir.entry = NULL;
352
353 return_VALUE(0);
354 }
355 */
356
357
358 /* --------------------------------------------------------------------------
359 Power Management
360 -------------------------------------------------------------------------- */
361
362 int
acpi_bus_get_power(acpi_handle handle,int * state)363 acpi_bus_get_power (
364 acpi_handle handle,
365 int *state)
366 {
367 int result = 0;
368 acpi_status status = 0;
369 struct acpi_device *device = NULL;
370 unsigned long psc = 0;
371
372 ACPI_FUNCTION_TRACE("acpi_bus_get_power");
373
374 result = acpi_bus_get_device(handle, &device);
375 if (result)
376 return_VALUE(result);
377
378 *state = ACPI_STATE_UNKNOWN;
379
380 if (!device->flags.power_manageable) {
381 /* TBD: Non-recursive algorithm for walking up hierarchy */
382 if (device->parent)
383 *state = device->parent->power.state;
384 else
385 *state = ACPI_STATE_D0;
386 }
387 else {
388 /*
389 * Get the device's power state either directly (via _PSC) or
390 * indirectly (via power resources).
391 */
392 if (device->power.flags.explicit_get) {
393 status = acpi_evaluate_integer(device->handle, "_PSC",
394 NULL, &psc);
395 if (ACPI_FAILURE(status))
396 return_VALUE(-ENODEV);
397 device->power.state = (int) psc;
398 }
399 else if (device->power.flags.power_resources) {
400 result = acpi_power_get_inferred_state(device);
401 if (result)
402 return_VALUE(result);
403 }
404
405 *state = device->power.state;
406 }
407
408 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is D%d\n",
409 device->pnp.bus_id, device->power.state));
410
411 return_VALUE(0);
412 }
413
414
415 int
acpi_bus_set_power(acpi_handle handle,int state)416 acpi_bus_set_power (
417 acpi_handle handle,
418 int state)
419 {
420 int result = 0;
421 acpi_status status = AE_OK;
422 struct acpi_device *device = NULL;
423 char object_name[5] = {'_','P','S','0'+state,'\0'};
424
425 ACPI_FUNCTION_TRACE("acpi_bus_set_power");
426
427 result = acpi_bus_get_device(handle, &device);
428 if (result)
429 return_VALUE(result);
430
431 if ((state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
432 return_VALUE(-EINVAL);
433
434 /* Make sure this is a valid target state */
435
436 if (!device->flags.power_manageable) {
437 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Device is not power manageable\n"));
438 return_VALUE(-ENODEV);
439 }
440 if (state == device->power.state) {
441 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n", state));
442 return_VALUE(0);
443 }
444 if (!device->power.states[state].flags.valid) {
445 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Device does not support D%d\n", state));
446 return_VALUE(-ENODEV);
447 }
448 if (device->parent && (state < device->parent->power.state)) {
449 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Cannot set device to a higher-powered state than parent\n"));
450 return_VALUE(-ENODEV);
451 }
452
453 /*
454 * Transition Power
455 * ----------------
456 * On transitions to a high-powered state we first apply power (via
457 * power resources) then evalute _PSx. Conversly for transitions to
458 * a lower-powered state.
459 */
460 if (state < device->power.state) {
461 if (device->power.flags.power_resources) {
462 result = acpi_power_transition(device, state);
463 if (result)
464 goto end;
465 }
466 if (device->power.states[state].flags.explicit_set) {
467 status = acpi_evaluate_object(device->handle,
468 object_name, NULL, NULL);
469 if (ACPI_FAILURE(status)) {
470 result = -ENODEV;
471 goto end;
472 }
473 }
474 }
475 else {
476 if (device->power.states[state].flags.explicit_set) {
477 status = acpi_evaluate_object(device->handle,
478 object_name, NULL, NULL);
479 if (ACPI_FAILURE(status)) {
480 result = -ENODEV;
481 goto end;
482 }
483 }
484 if (device->power.flags.power_resources) {
485 result = acpi_power_transition(device, state);
486 if (result)
487 goto end;
488 }
489 }
490
491 end:
492 if (result)
493 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Error transitioning device [%s] to D%d\n",
494 device->pnp.bus_id, state));
495 else
496 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] transitioned to D%d\n",
497 device->pnp.bus_id, state));
498
499 return_VALUE(result);
500 }
501
502
503 static int
acpi_bus_get_power_flags(struct acpi_device * device)504 acpi_bus_get_power_flags (
505 struct acpi_device *device)
506 {
507 acpi_status status = 0;
508 acpi_handle handle = 0;
509 u32 i = 0;
510
511 ACPI_FUNCTION_TRACE("acpi_bus_get_power_flags");
512
513 if (!device)
514 return -ENODEV;
515
516 /*
517 * Power Management Flags
518 */
519 status = acpi_get_handle(device->handle, "_PSC", &handle);
520 if (ACPI_SUCCESS(status))
521 device->power.flags.explicit_get = 1;
522 status = acpi_get_handle(device->handle, "_IRC", &handle);
523 if (ACPI_SUCCESS(status))
524 device->power.flags.inrush_current = 1;
525 status = acpi_get_handle(device->handle, "_PRW", &handle);
526 if (ACPI_SUCCESS(status))
527 device->power.flags.wake_capable = 1;
528
529 /*
530 * Enumerate supported power management states
531 */
532 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3; i++) {
533 struct acpi_device_power_state *ps = &device->power.states[i];
534 char object_name[5] = {'_','P','R','0'+i,'\0'};
535
536 /* Evaluate "_PRx" to se if power resources are referenced */
537 acpi_evaluate_reference(device->handle, object_name, NULL,
538 &ps->resources);
539 if (ps->resources.count) {
540 device->power.flags.power_resources = 1;
541 ps->flags.valid = 1;
542 }
543
544 /* Evaluate "_PSx" to see if we can do explicit sets */
545 object_name[2] = 'S';
546 status = acpi_get_handle(device->handle, object_name, &handle);
547 if (ACPI_SUCCESS(status)) {
548 ps->flags.explicit_set = 1;
549 ps->flags.valid = 1;
550 }
551
552 /* State is valid if we have some power control */
553 if (ps->resources.count || ps->flags.explicit_set)
554 ps->flags.valid = 1;
555
556 ps->power = -1; /* Unknown - driver assigned */
557 ps->latency = -1; /* Unknown - driver assigned */
558 }
559
560 /* Set defaults for D0 and D3 states (always valid) */
561 device->power.states[ACPI_STATE_D0].flags.valid = 1;
562 device->power.states[ACPI_STATE_D0].power = 100;
563 device->power.states[ACPI_STATE_D3].flags.valid = 1;
564 device->power.states[ACPI_STATE_D3].power = 0;
565
566 /*
567 * System Power States
568 * -------------------
569 */
570 /* TBD: S1-S4 power state support and resource requirements. */
571 /*
572 for (i=ACPI_STATE_S1; i<ACPI_STATE_S5; i++) {
573 char name[5] = {'_','S',('0'+i),'D','\0'};
574 status = acpi_evaluate_integer(device->handle, name, NULL,
575 &state);
576 if (ACPI_FAILURE(status))
577 continue;
578 }
579 */
580
581 /* TBD: System wake support and resource requirements. */
582
583 device->power.state = ACPI_STATE_UNKNOWN;
584
585 return 0;
586 }
587
588
589 /* --------------------------------------------------------------------------
590 Performance Management
591 -------------------------------------------------------------------------- */
592
593 static int
acpi_bus_get_perf_flags(struct acpi_device * device)594 acpi_bus_get_perf_flags (
595 struct acpi_device *device)
596 {
597 ACPI_FUNCTION_TRACE("acpi_bus_get_perf_flags");
598
599 if (!device)
600 return -ENODEV;
601
602 device->performance.state = ACPI_STATE_UNKNOWN;
603
604 return 0;
605 }
606
607
608 /* --------------------------------------------------------------------------
609 Event Management
610 -------------------------------------------------------------------------- */
611
612 static spinlock_t acpi_bus_event_lock = SPIN_LOCK_UNLOCKED;
613
614 LIST_HEAD(acpi_bus_event_list);
615 DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue);
616
617 extern int event_is_open;
618
619 int
acpi_bus_generate_event(struct acpi_device * device,u8 type,int data)620 acpi_bus_generate_event (
621 struct acpi_device *device,
622 u8 type,
623 int data)
624 {
625 struct acpi_bus_event *event = NULL;
626 unsigned long flags = 0;
627
628 ACPI_FUNCTION_TRACE("acpi_bus_generate_event");
629
630 if (!device)
631 return_VALUE(-EINVAL);
632
633 /* drop event on the floor if no one's listening */
634 if (!event_is_open)
635 return_VALUE(0);
636
637 event = kmalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC);
638 if (!event)
639 return_VALUE(-ENOMEM);
640
641 sprintf(event->device_class, "%s", device->pnp.device_class);
642 sprintf(event->bus_id, "%s", device->pnp.bus_id);
643 event->type = type;
644 event->data = data;
645
646 spin_lock_irqsave(&acpi_bus_event_lock, flags);
647 list_add_tail(&event->node, &acpi_bus_event_list);
648 spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
649
650 wake_up_interruptible(&acpi_bus_event_queue);
651
652 return_VALUE(0);
653 }
654
655 int
acpi_bus_receive_event(struct acpi_bus_event * event)656 acpi_bus_receive_event (
657 struct acpi_bus_event *event)
658 {
659 unsigned long flags = 0;
660 struct acpi_bus_event *entry = NULL;
661
662 DECLARE_WAITQUEUE(wait, current);
663
664 ACPI_FUNCTION_TRACE("acpi_bus_receive_event");
665
666 if (!event)
667 return -EINVAL;
668
669 if (list_empty(&acpi_bus_event_list)) {
670
671 set_current_state(TASK_INTERRUPTIBLE);
672 add_wait_queue(&acpi_bus_event_queue, &wait);
673
674 if (list_empty(&acpi_bus_event_list))
675 schedule();
676
677 remove_wait_queue(&acpi_bus_event_queue, &wait);
678 set_current_state(TASK_RUNNING);
679
680 if (signal_pending(current))
681 return_VALUE(-ERESTARTSYS);
682 }
683
684 spin_lock_irqsave(&acpi_bus_event_lock, flags);
685 entry = list_entry(acpi_bus_event_list.next, struct acpi_bus_event, node);
686 if (entry)
687 list_del(&entry->node);
688 spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
689
690 if (!entry)
691 return_VALUE(-ENODEV);
692
693 memcpy(event, entry, sizeof(struct acpi_bus_event));
694
695 kfree(entry);
696
697 return_VALUE(0);
698 }
699
700
701 /* --------------------------------------------------------------------------
702 Namespace Management
703 -------------------------------------------------------------------------- */
704
705 #define WALK_UP 0
706 #define WALK_DOWN 1
707
708 typedef int (*acpi_bus_walk_callback)(struct acpi_device*, int, void*);
709
710 #define HAS_CHILDREN(d) ((d)->children.next != &((d)->children))
711 #define HAS_SIBLINGS(d) (((d)->parent) && ((d)->node.next != &(d)->parent->children))
712 #define NODE_TO_DEVICE(n) (list_entry(n, struct acpi_device, node))
713
714
715 /**
716 * acpi_bus_walk
717 * -------------
718 * Used to walk the ACPI Bus's device namespace. Can walk down (depth-first)
719 * or up. Able to parse starting at any node in the namespace. Note that a
720 * callback return value of -ELOOP will terminate the walk.
721 *
722 * @start: starting point
723 * callback: function to call for every device encountered while parsing
724 * direction: direction to parse (up or down)
725 * @data: context for this search operation
726 */
727 static int
acpi_bus_walk(struct acpi_device * start,acpi_bus_walk_callback callback,int direction,void * data)728 acpi_bus_walk (
729 struct acpi_device *start,
730 acpi_bus_walk_callback callback,
731 int direction,
732 void *data)
733 {
734 int result = 0;
735 int level = 0;
736 struct acpi_device *device = NULL;
737
738 if (!start || !callback)
739 return -EINVAL;
740
741 device = start;
742
743 /*
744 * Parse Namespace
745 * ---------------
746 * Parse a given subtree (specified by start) in the given direction.
747 * Walking 'up' simply means that we execute the callback on leaf
748 * devices prior to their parents (useful for things like removing
749 * or powering down a subtree).
750 */
751
752 while (device) {
753
754 if (direction == WALK_DOWN)
755 if (-ELOOP == callback(device, level, data))
756 break;
757
758 /* Depth First */
759
760 if (HAS_CHILDREN(device)) {
761 device = NODE_TO_DEVICE(device->children.next);
762 ++level;
763 continue;
764 }
765
766 if (direction == WALK_UP)
767 if (-ELOOP == callback(device, level, data))
768 break;
769
770 /* Now Breadth */
771
772 if (HAS_SIBLINGS(device)) {
773 device = NODE_TO_DEVICE(device->node.next);
774 continue;
775 }
776
777 /* Scope Exhausted - Find Next */
778
779 while ((device = device->parent)) {
780 --level;
781 if (HAS_SIBLINGS(device)) {
782 device = NODE_TO_DEVICE(device->node.next);
783 break;
784 }
785 }
786 }
787
788 if ((direction == WALK_UP) && (result == 0))
789 callback(start, level, data);
790
791 return result;
792 }
793
794
795 /* --------------------------------------------------------------------------
796 Notification Handling
797 -------------------------------------------------------------------------- */
798
799 static int
acpi_bus_check_device(struct acpi_device * device,int * status_changed)800 acpi_bus_check_device (
801 struct acpi_device *device,
802 int *status_changed)
803 {
804 acpi_status status = 0;
805 struct acpi_device_status old_status;
806
807 ACPI_FUNCTION_TRACE("acpi_bus_check_device");
808
809 if (!device)
810 return_VALUE(-EINVAL);
811
812 if (status_changed)
813 *status_changed = 0;
814
815 old_status = device->status;
816
817 /*
818 * Make sure this device's parent is present before we go about
819 * messing with the device.
820 */
821 if (device->parent && !device->parent->status.present) {
822 device->status = device->parent->status;
823 if (STRUCT_TO_INT(old_status) != STRUCT_TO_INT(device->status)) {
824 if (status_changed)
825 *status_changed = 1;
826 }
827 return_VALUE(0);
828 }
829
830 status = acpi_bus_get_status(device);
831 if (ACPI_FAILURE(status))
832 return_VALUE(-ENODEV);
833
834 if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status))
835 return_VALUE(0);
836
837 if (status_changed)
838 *status_changed = 1;
839
840 /*
841 * Device Insertion/Removal
842 */
843 if ((device->status.present) && !(old_status.present)) {
844 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device insertion detected\n"));
845 /* TBD: Handle device insertion */
846 }
847 else if (!(device->status.present) && (old_status.present)) {
848 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n"));
849 /* TBD: Handle device removal */
850 }
851
852 return_VALUE(0);
853 }
854
855
856 static int
acpi_bus_check_scope(struct acpi_device * device)857 acpi_bus_check_scope (
858 struct acpi_device *device)
859 {
860 int result = 0;
861 int status_changed = 0;
862
863 ACPI_FUNCTION_TRACE("acpi_bus_check_scope");
864
865 if (!device)
866 return_VALUE(-EINVAL);
867
868 /* Status Change? */
869 result = acpi_bus_check_device(device, &status_changed);
870 if (result)
871 return_VALUE(result);
872
873 if (!status_changed)
874 return_VALUE(0);
875
876 /*
877 * TBD: Enumerate child devices within this device's scope and
878 * run acpi_bus_check_device()'s on them.
879 */
880
881 return_VALUE(0);
882 }
883
884
885 /**
886 * acpi_bus_notify
887 * ---------------
888 * Callback for all 'system-level' device notifications (values 0x00-0x7F).
889 */
890 static void
acpi_bus_notify(acpi_handle handle,u32 type,void * data)891 acpi_bus_notify (
892 acpi_handle handle,
893 u32 type,
894 void *data)
895 {
896 int result = 0;
897 struct acpi_device *device = NULL;
898
899 ACPI_FUNCTION_TRACE("acpi_bus_notify");
900
901 if (acpi_bus_get_device(handle, &device))
902 return_VOID;
903
904 switch (type) {
905
906 case ACPI_NOTIFY_BUS_CHECK:
907 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received BUS CHECK notification for device [%s]\n",
908 device->pnp.bus_id));
909 result = acpi_bus_check_scope(device);
910 /*
911 * TBD: We'll need to outsource certain events to non-ACPI
912 * drivers via the device manager (device.c).
913 */
914 break;
915
916 case ACPI_NOTIFY_DEVICE_CHECK:
917 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received DEVICE CHECK notification for device [%s]\n",
918 device->pnp.bus_id));
919 result = acpi_bus_check_device(device, NULL);
920 /*
921 * TBD: We'll need to outsource certain events to non-ACPI
922 * drivers via the device manager (device.c).
923 */
924 break;
925
926 case ACPI_NOTIFY_DEVICE_WAKE:
927 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received DEVICE WAKE notification for device [%s]\n",
928 device->pnp.bus_id));
929 /* TBD */
930 break;
931
932 case ACPI_NOTIFY_EJECT_REQUEST:
933 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received EJECT REQUEST notification for device [%s]\n",
934 device->pnp.bus_id));
935 /* TBD */
936 break;
937
938 case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
939 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received DEVICE CHECK LIGHT notification for device [%s]\n",
940 device->pnp.bus_id));
941 /* TBD: Exactly what does 'light' mean? */
942 break;
943
944 case ACPI_NOTIFY_FREQUENCY_MISMATCH:
945 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received FREQUENCY MISMATCH notification for device [%s]\n",
946 device->pnp.bus_id));
947 /* TBD */
948 break;
949
950 case ACPI_NOTIFY_BUS_MODE_MISMATCH:
951 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received BUS MODE MISMATCH notification for device [%s]\n",
952 device->pnp.bus_id));
953 /* TBD */
954 break;
955
956 case ACPI_NOTIFY_POWER_FAULT:
957 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received POWER FAULT notification for device [%s]\n",
958 device->pnp.bus_id));
959 /* TBD */
960 break;
961
962 default:
963 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received unknown/unsupported notification [%08x]\n",
964 type));
965 break;
966 }
967
968 return_VOID;
969 }
970
971
972 /* --------------------------------------------------------------------------
973 Driver Management
974 -------------------------------------------------------------------------- */
975
976 static LIST_HEAD(acpi_bus_drivers);
977 static DECLARE_MUTEX(acpi_bus_drivers_lock);
978
979
980 /**
981 * acpi_bus_match
982 * --------------
983 * Checks the device's hardware (_HID) or compatible (_CID) ids to see if it
984 * matches the specified driver's criteria.
985 */
986 static int
acpi_bus_match(struct acpi_device * device,struct acpi_driver * driver)987 acpi_bus_match (
988 struct acpi_device *device,
989 struct acpi_driver *driver)
990 {
991 int error = 0;
992
993 if (device->flags.hardware_id)
994 if (strstr(driver->ids, device->pnp.hardware_id))
995 goto Done;
996
997 if (device->flags.compatible_ids) {
998 struct acpi_compatible_id_list *cid_list = device->pnp.cid_list;
999 int i;
1000
1001 /* compare multiple _CID entries against driver ids */
1002 for (i = 0; i < cid_list->count; i++)
1003 {
1004 if (strstr(driver->ids, cid_list->id[i].value))
1005 goto Done;
1006 }
1007 }
1008 error = -ENOENT;
1009
1010 Done:
1011
1012 return error;
1013 }
1014
1015
1016 /**
1017 * acpi_bus_driver_init
1018 * --------------------
1019 * Used to initialize a device via its device driver. Called whenever a
1020 * driver is bound to a device. Invokes the driver's add() and start() ops.
1021 */
1022 static int
acpi_bus_driver_init(struct acpi_device * device,struct acpi_driver * driver)1023 acpi_bus_driver_init (
1024 struct acpi_device *device,
1025 struct acpi_driver *driver)
1026 {
1027 int result = 0;
1028
1029 ACPI_FUNCTION_TRACE("acpi_bus_driver_init");
1030
1031 if (!device || !driver)
1032 return_VALUE(-EINVAL);
1033
1034 if (!driver->ops.add)
1035 return_VALUE(-ENOSYS);
1036
1037 result = driver->ops.add(device);
1038 if (result) {
1039 device->driver = NULL;
1040 acpi_driver_data(device) = NULL;
1041 return_VALUE(result);
1042 }
1043
1044 device->driver = driver;
1045
1046 /*
1047 * TBD - Configuration Management: Assign resources to device based
1048 * upon possible configuration and currently allocated resources.
1049 */
1050
1051 if (driver->ops.start) {
1052 result = driver->ops.start(device);
1053 if (result && driver->ops.remove)
1054 driver->ops.remove(device, ACPI_BUS_REMOVAL_NORMAL);
1055 return_VALUE(result);
1056 }
1057
1058 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Driver successfully bound to device\n"));
1059
1060 #ifdef CONFIG_LDM
1061 /*
1062 * Update the device information (in the global device hierarchy) now
1063 * that there's a driver bound to it.
1064 */
1065 strncpy(device->dev.name, device->pnp.device_name,
1066 sizeof(device->dev.name));
1067 #endif
1068
1069 if (driver->ops.scan) {
1070 driver->ops.scan(device);
1071 }
1072
1073 return_VALUE(0);
1074 }
1075
1076
1077 /**
1078 * acpi_bus_attach
1079 * -------------
1080 * Callback for acpi_bus_walk() used to find devices that match a specific
1081 * driver's criteria and then attach the driver.
1082 */
1083 static int
acpi_bus_attach(struct acpi_device * device,int level,void * data)1084 acpi_bus_attach (
1085 struct acpi_device *device,
1086 int level,
1087 void *data)
1088 {
1089 int result = 0;
1090 struct acpi_driver *driver = NULL;
1091
1092 ACPI_FUNCTION_TRACE("acpi_bus_attach");
1093
1094 if (!device || !data)
1095 return_VALUE(-EINVAL);
1096
1097 driver = (struct acpi_driver *) data;
1098
1099 if (device->driver)
1100 return_VALUE(-EEXIST);
1101
1102 if (!device->status.present)
1103 return_VALUE(-ENODEV);
1104
1105 result = acpi_bus_match(device, driver);
1106 if (result)
1107 return_VALUE(result);
1108
1109 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found driver [%s] for device [%s]\n",
1110 driver->name, device->pnp.bus_id));
1111
1112 result = acpi_bus_driver_init(device, driver);
1113 if (result)
1114 return_VALUE(result);
1115
1116 down(&acpi_bus_drivers_lock);
1117 ++driver->references;
1118 up(&acpi_bus_drivers_lock);
1119
1120 return_VALUE(0);
1121 }
1122
1123
1124 /**
1125 * acpi_bus_unattach
1126 * -----------------
1127 * Callback for acpi_bus_walk() used to find devices that match a specific
1128 * driver's criteria and unattach the driver.
1129 */
1130 static int
acpi_bus_unattach(struct acpi_device * device,int level,void * data)1131 acpi_bus_unattach (
1132 struct acpi_device *device,
1133 int level,
1134 void *data)
1135 {
1136 int result = 0;
1137 struct acpi_driver *driver = (struct acpi_driver *) data;
1138
1139 ACPI_FUNCTION_TRACE("acpi_bus_unattach");
1140
1141 if (!device || !driver)
1142 return_VALUE(-EINVAL);
1143
1144 if (device->driver != driver)
1145 return_VALUE(-ENOENT);
1146
1147 if (!driver->ops.remove)
1148 return_VALUE(-ENOSYS);
1149
1150 result = driver->ops.remove(device, ACPI_BUS_REMOVAL_NORMAL);
1151 if (result)
1152 return_VALUE(result);
1153
1154 device->driver = NULL;
1155 acpi_driver_data(device) = NULL;
1156
1157 down(&acpi_bus_drivers_lock);
1158 driver->references--;
1159 up(&acpi_bus_drivers_lock);
1160
1161 return_VALUE(0);
1162 }
1163
1164
1165 /**
1166 * acpi_bus_find_driver
1167 * --------------------
1168 * Parses the list of registered drivers looking for a driver applicable for
1169 * the specified device.
1170 */
1171 static int
acpi_bus_find_driver(struct acpi_device * device)1172 acpi_bus_find_driver (
1173 struct acpi_device *device)
1174 {
1175 int result = -ENODEV;
1176 struct list_head *entry = NULL;
1177 struct acpi_driver *driver = NULL;
1178
1179 ACPI_FUNCTION_TRACE("acpi_bus_find_driver");
1180
1181 if (!device || device->driver)
1182 return_VALUE(-EINVAL);
1183
1184 down(&acpi_bus_drivers_lock);
1185
1186 list_for_each(entry, &acpi_bus_drivers) {
1187
1188 driver = list_entry(entry, struct acpi_driver, node);
1189
1190 if (acpi_bus_match(device, driver))
1191 continue;
1192
1193 result = acpi_bus_driver_init(device, driver);
1194 if (!result)
1195 ++driver->references;
1196
1197 break;
1198 }
1199
1200 up(&acpi_bus_drivers_lock);
1201
1202 return_VALUE(result);
1203 }
1204
1205
1206 /**
1207 * acpi_bus_register_driver
1208 * ------------------------
1209 * Registers a driver with the ACPI bus. Searches the namespace for all
1210 * devices that match the driver's criteria and binds.
1211 */
1212 int
acpi_bus_register_driver(struct acpi_driver * driver)1213 acpi_bus_register_driver (
1214 struct acpi_driver *driver)
1215 {
1216 ACPI_FUNCTION_TRACE("acpi_bus_register_driver");
1217
1218 if (!driver)
1219 return_VALUE(-EINVAL);
1220
1221 if (acpi_disabled)
1222 return_VALUE(-ENODEV);
1223
1224 down(&acpi_bus_drivers_lock);
1225 list_add_tail(&driver->node, &acpi_bus_drivers);
1226 up(&acpi_bus_drivers_lock);
1227
1228 acpi_bus_walk(acpi_root, acpi_bus_attach,
1229 WALK_DOWN, driver);
1230
1231 return_VALUE(driver->references);
1232 }
1233
1234
1235 /**
1236 * acpi_bus_unregister_driver
1237 * --------------------------
1238 * Unregisters a driver with the ACPI bus. Searches the namespace for all
1239 * devices that match the driver's criteria and unbinds.
1240 */
1241 int
acpi_bus_unregister_driver(struct acpi_driver * driver)1242 acpi_bus_unregister_driver (
1243 struct acpi_driver *driver)
1244 {
1245 ACPI_FUNCTION_TRACE("acpi_bus_unregister_driver");
1246
1247 if (!driver)
1248 return_VALUE(-EINVAL);
1249
1250 acpi_bus_walk(acpi_root, acpi_bus_unattach, WALK_UP, driver);
1251
1252 if (driver->references)
1253 return_VALUE(driver->references);
1254
1255 down(&acpi_bus_drivers_lock);
1256 list_del(&driver->node);
1257 up(&acpi_bus_drivers_lock);
1258
1259 return_VALUE(0);
1260 }
1261
1262
1263 /* --------------------------------------------------------------------------
1264 Device Enumeration
1265 -------------------------------------------------------------------------- */
1266
1267 static int
acpi_bus_get_flags(struct acpi_device * device)1268 acpi_bus_get_flags (
1269 struct acpi_device *device)
1270 {
1271 acpi_status status = AE_OK;
1272 acpi_handle temp = NULL;
1273
1274 ACPI_FUNCTION_TRACE("acpi_bus_get_flags");
1275
1276 /* Presence of _STA indicates 'dynamic_status' */
1277 status = acpi_get_handle(device->handle, "_STA", &temp);
1278 if (ACPI_SUCCESS(status))
1279 device->flags.dynamic_status = 1;
1280
1281 /* Presence of _CID indicates 'compatible_ids' */
1282 status = acpi_get_handle(device->handle, "_CID", &temp);
1283 if (ACPI_SUCCESS(status))
1284 device->flags.compatible_ids = 1;
1285
1286 /* Presence of _RMV indicates 'removable' */
1287 status = acpi_get_handle(device->handle, "_RMV", &temp);
1288 if (ACPI_SUCCESS(status))
1289 device->flags.removable = 1;
1290
1291 /* Presence of _EJD|_EJ0 indicates 'ejectable' */
1292 status = acpi_get_handle(device->handle, "_EJD", &temp);
1293 if (ACPI_SUCCESS(status))
1294 device->flags.ejectable = 1;
1295 else {
1296 status = acpi_get_handle(device->handle, "_EJ0", &temp);
1297 if (ACPI_SUCCESS(status))
1298 device->flags.ejectable = 1;
1299 }
1300
1301 /* Presence of _LCK indicates 'lockable' */
1302 status = acpi_get_handle(device->handle, "_LCK", &temp);
1303 if (ACPI_SUCCESS(status))
1304 device->flags.lockable = 1;
1305
1306 /* Presence of _PS0|_PR0 indicates 'power manageable' */
1307 status = acpi_get_handle(device->handle, "_PS0", &temp);
1308 if (ACPI_FAILURE(status))
1309 status = acpi_get_handle(device->handle, "_PR0", &temp);
1310 if (ACPI_SUCCESS(status))
1311 device->flags.power_manageable = 1;
1312
1313 /* TBD: Peformance management */
1314
1315 return_VALUE(0);
1316 }
1317
1318
1319 static int
acpi_bus_add(struct acpi_device ** child,struct acpi_device * parent,acpi_handle handle,int type)1320 acpi_bus_add (
1321 struct acpi_device **child,
1322 struct acpi_device *parent,
1323 acpi_handle handle,
1324 int type)
1325 {
1326 int result = 0;
1327 acpi_status status = AE_OK;
1328 struct acpi_device *device = NULL;
1329 char bus_id[5] = {'?',0};
1330 struct acpi_buffer buffer = {0, NULL};
1331 struct acpi_device_info *info;
1332 char *hid = NULL;
1333 char *uid = NULL;
1334 struct acpi_compatible_id_list *cid_list = NULL;
1335 int i = 0;
1336
1337 ACPI_FUNCTION_TRACE("acpi_bus_add");
1338
1339 if (!child)
1340 return_VALUE(-EINVAL);
1341
1342 device = kmalloc(sizeof(struct acpi_device), GFP_KERNEL);
1343 if (!device) {
1344 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Memory allocation error\n"));
1345 return_VALUE(-ENOMEM);
1346 }
1347 memset(device, 0, sizeof(struct acpi_device));
1348
1349 device->handle = handle;
1350 device->parent = parent;
1351
1352 /*
1353 * Bus ID
1354 * ------
1355 * The device's Bus ID is simply the object name.
1356 * TBD: Shouldn't this value be unique (within the ACPI namespace)?
1357 */
1358 switch (type) {
1359 case ACPI_BUS_TYPE_SYSTEM:
1360 sprintf(device->pnp.bus_id, "%s", "ACPI");
1361 break;
1362 case ACPI_BUS_TYPE_POWER_BUTTON:
1363 sprintf(device->pnp.bus_id, "%s", "PWRF");
1364 break;
1365 case ACPI_BUS_TYPE_SLEEP_BUTTON:
1366 sprintf(device->pnp.bus_id, "%s", "SLPF");
1367 break;
1368 default:
1369 buffer.length = sizeof(bus_id);
1370 buffer.pointer = bus_id;
1371 acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
1372 /* Clean up trailing underscores (if any) */
1373 for (i = 3; i > 1; i--) {
1374 if (bus_id[i] == '_')
1375 bus_id[i] = '\0';
1376 else
1377 break;
1378 }
1379 sprintf(device->pnp.bus_id, "%s", bus_id);
1380 buffer.pointer = NULL;
1381 break;
1382 }
1383
1384 /*
1385 * Flags
1386 * -----
1387 * Get prior to calling acpi_bus_get_status() so we know whether
1388 * or not _STA is present. Note that we only look for object
1389 * handles -- cannot evaluate objects until we know the device is
1390 * present and properly initialized.
1391 */
1392 result = acpi_bus_get_flags(device);
1393 if (result)
1394 goto end;
1395
1396 /*
1397 * Status
1398 * ------
1399 * See if the device is present. We always assume that non-Device()
1400 * objects (e.g. thermal zones, power resources, processors, etc.) are
1401 * present, functioning, etc. (at least when parent object is present).
1402 * Note that _STA has a different meaning for some objects (e.g.
1403 * power resources) so we need to be careful how we use it.
1404 */
1405 switch (type) {
1406 case ACPI_BUS_TYPE_DEVICE:
1407 result = acpi_bus_get_status(device);
1408 if (result)
1409 goto end;
1410 break;
1411 default:
1412 STRUCT_TO_INT(device->status) = 0x0F;
1413 break;
1414 }
1415 if (!device->status.present) {
1416 result = -ENOENT;
1417 goto end;
1418 }
1419
1420 /*
1421 * Initialize Device
1422 * -----------------
1423 * TBD: Synch with Core's enumeration/initialization process.
1424 */
1425
1426 /*
1427 * Hardware ID, Unique ID, & Bus Address
1428 * -------------------------------------
1429 */
1430 switch (type) {
1431 case ACPI_BUS_TYPE_DEVICE:
1432 buffer.length = ACPI_ALLOCATE_BUFFER;
1433 buffer.pointer = NULL;
1434 status = acpi_get_object_info(handle, &buffer);
1435 if (ACPI_FAILURE(status)) {
1436 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1437 "Error reading device info\n"));
1438 result = -ENODEV;
1439 goto end;
1440 }
1441 info = buffer.pointer;
1442 if (info->valid & ACPI_VALID_HID)
1443 hid = info->hardware_id.value;
1444 if (info->valid & ACPI_VALID_UID)
1445 uid = info->unique_id.value;
1446 if (info->valid & ACPI_VALID_CID) {
1447 cid_list = &info->compatibility_id;
1448 device->pnp.cid_list = kmalloc(cid_list->size, GFP_KERNEL);
1449 if (device->pnp.cid_list)
1450 memcpy(device->pnp.cid_list, cid_list, cid_list->size);
1451 else
1452 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Memory allocation error\n"));
1453 }
1454 if (info->valid & ACPI_VALID_ADR) {
1455 device->pnp.bus_address = info->address;
1456 device->flags.bus_address = 1;
1457 }
1458 break;
1459 case ACPI_BUS_TYPE_POWER:
1460 hid = ACPI_POWER_HID;
1461 break;
1462 case ACPI_BUS_TYPE_PROCESSOR:
1463 hid = ACPI_PROCESSOR_HID;
1464 break;
1465 case ACPI_BUS_TYPE_SYSTEM:
1466 hid = ACPI_SYSTEM_HID;
1467 break;
1468 case ACPI_BUS_TYPE_THERMAL:
1469 hid = ACPI_THERMAL_HID;
1470 break;
1471 case ACPI_BUS_TYPE_POWER_BUTTON:
1472 hid = ACPI_BUTTON_HID_POWERF;
1473 break;
1474 case ACPI_BUS_TYPE_SLEEP_BUTTON:
1475 hid = ACPI_BUTTON_HID_SLEEPF;
1476 break;
1477 }
1478
1479 /*
1480 * \_SB
1481 * ----
1482 * Fix for the system root bus device -- the only root-level device.
1483 */
1484 if ((parent == ACPI_ROOT_OBJECT) && (type == ACPI_BUS_TYPE_DEVICE)) {
1485 hid = ACPI_BUS_HID;
1486 sprintf(device->pnp.device_name, "%s", ACPI_BUS_DEVICE_NAME);
1487 sprintf(device->pnp.device_class, "%s", ACPI_BUS_CLASS);
1488 }
1489
1490 if (hid) {
1491 sprintf(device->pnp.hardware_id, "%s", hid);
1492 device->flags.hardware_id = 1;
1493 }
1494 if (uid) {
1495 sprintf(device->pnp.unique_id, "%s", uid);
1496 device->flags.unique_id = 1;
1497 }
1498
1499 /*
1500 * If we called get_object_info, we now are finished with the buffer,
1501 * so we can free it.
1502 */
1503 if (buffer.pointer)
1504 acpi_os_free(buffer.pointer);
1505
1506 /*
1507 * Power Management
1508 * ----------------
1509 */
1510 if (device->flags.power_manageable) {
1511 result = acpi_bus_get_power_flags(device);
1512 if (result)
1513 goto end;
1514 }
1515
1516 /*
1517 * Performance Management
1518 * ----------------------
1519 */
1520 if (device->flags.performance_manageable) {
1521 result = acpi_bus_get_perf_flags(device);
1522 if (result)
1523 goto end;
1524 }
1525
1526 /*
1527 * Context
1528 * -------
1529 * Attach this 'struct acpi_device' to the ACPI object. This makes
1530 * resolutions from handle->device very efficient. Note that we need
1531 * to be careful with fixed-feature devices as they all attach to the
1532 * root object.
1533 */
1534 switch (type) {
1535 case ACPI_BUS_TYPE_POWER_BUTTON:
1536 case ACPI_BUS_TYPE_SLEEP_BUTTON:
1537 break;
1538 default:
1539 status = acpi_attach_data(device->handle,
1540 acpi_bus_data_handler, device);
1541 break;
1542 }
1543 if (ACPI_FAILURE(status)) {
1544 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1545 "Error attaching device data\n"));
1546 result = -ENODEV;
1547 goto end;
1548 }
1549
1550 /*
1551 * Linkage
1552 * -------
1553 * Link this device to its parent and siblings.
1554 */
1555 INIT_LIST_HEAD(&device->children);
1556 if (!device->parent)
1557 INIT_LIST_HEAD(&device->node);
1558 else
1559 list_add_tail(&device->node, &device->parent->children);
1560
1561 #ifdef CONFIG_ACPI_DEBUG
1562 {
1563 char *type_string = NULL;
1564 char name[80] = {'?','\0'};
1565 struct acpi_buffer buffer = {sizeof(name), name};
1566
1567 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1568
1569 switch (type) {
1570 case ACPI_BUS_TYPE_DEVICE:
1571 type_string = "Device";
1572 break;
1573 case ACPI_BUS_TYPE_POWER:
1574 type_string = "Power Resource";
1575 break;
1576 case ACPI_BUS_TYPE_PROCESSOR:
1577 type_string = "Processor";
1578 break;
1579 case ACPI_BUS_TYPE_SYSTEM:
1580 type_string = "System";
1581 break;
1582 case ACPI_BUS_TYPE_THERMAL:
1583 type_string = "Thermal Zone";
1584 break;
1585 case ACPI_BUS_TYPE_POWER_BUTTON:
1586 type_string = "Power Button";
1587 sprintf(name, "PWRB");
1588 break;
1589 case ACPI_BUS_TYPE_SLEEP_BUTTON:
1590 type_string = "Sleep Button";
1591 sprintf(name, "SLPB");
1592 break;
1593 }
1594
1595 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %s %s [%p]\n",
1596 type_string, name, handle));
1597 }
1598 #endif /*CONFIG_ACPI_DEBUG*/
1599
1600 /*
1601 * Global Device Hierarchy:
1602 * ------------------------
1603 * Register this device with the global device hierarchy.
1604 */
1605 acpi_device_register(device, parent);
1606
1607 /*
1608 * Bind _ADR-Based Devices
1609 * -----------------------
1610 * If there's a a bus address (_ADR) then we utilize the parent's
1611 * 'bind' function (if exists) to bind the ACPI- and natively-
1612 * enumerated device representations.
1613 */
1614 if (device->flags.bus_address) {
1615 if (device->parent && device->parent->ops.bind)
1616 device->parent->ops.bind(device);
1617 }
1618
1619 /*
1620 * Locate & Attach Driver
1621 * ----------------------
1622 * If there's a hardware id (_HID) or compatible ids (_CID) we check
1623 * to see if there's a driver installed for this kind of device. Note
1624 * that drivers can install before or after a device is enumerated.
1625 *
1626 * TBD: Assumes LDM provides driver hot-plug capability.
1627 */
1628 if (device->flags.hardware_id || device->flags.compatible_ids)
1629 acpi_bus_find_driver(device);
1630
1631 end:
1632 if (result) {
1633 if (device->pnp.cid_list) {
1634 kfree(device->pnp.cid_list);
1635 }
1636 kfree(device);
1637 return_VALUE(result);
1638 }
1639 *child = device;
1640
1641 return_VALUE(0);
1642 }
1643
1644
1645 static int
acpi_bus_remove(struct acpi_device * device,int type)1646 acpi_bus_remove (
1647 struct acpi_device *device,
1648 int type)
1649 {
1650 ACPI_FUNCTION_TRACE("acpi_bus_remove");
1651
1652 if (!device)
1653 return_VALUE(-ENODEV);
1654
1655 acpi_device_unregister(device);
1656
1657 #if 0
1658 if (device->pnp.cid_list)
1659 kfree(device->pnp.cid_list);
1660 #endif
1661 kfree(device);
1662
1663 return_VALUE(0);
1664 }
1665
1666
1667 int
acpi_bus_scan(struct acpi_device * start)1668 acpi_bus_scan (
1669 struct acpi_device *start)
1670 {
1671 acpi_status status = AE_OK;
1672 struct acpi_device *parent = NULL;
1673 struct acpi_device *child = NULL;
1674 acpi_handle phandle = 0;
1675 acpi_handle chandle = 0;
1676 acpi_object_type type = 0;
1677 u32 level = 1;
1678
1679 ACPI_FUNCTION_TRACE("acpi_bus_scan");
1680
1681 if (!start)
1682 return_VALUE(-EINVAL);
1683
1684 parent = start;
1685 phandle = start->handle;
1686
1687 /*
1688 * Parse through the ACPI namespace, identify all 'devices', and
1689 * create a new 'struct acpi_device' for each.
1690 */
1691 while ((level > 0) && parent) {
1692
1693 status = acpi_get_next_object(ACPI_TYPE_ANY, phandle,
1694 chandle, &chandle);
1695
1696 /*
1697 * If this scope is exhausted then move our way back up.
1698 */
1699 if (ACPI_FAILURE(status)) {
1700 level--;
1701 chandle = phandle;
1702 acpi_get_parent(phandle, &phandle);
1703 if (parent->parent)
1704 parent = parent->parent;
1705 continue;
1706 }
1707
1708 status = acpi_get_type(chandle, &type);
1709 if (ACPI_FAILURE(status))
1710 continue;
1711
1712 /*
1713 * If this is a scope object then parse it (depth-first).
1714 */
1715 if (type == ACPI_TYPE_LOCAL_SCOPE) {
1716 level++;
1717 phandle = chandle;
1718 chandle = 0;
1719 continue;
1720 }
1721
1722 /*
1723 * We're only interested in objects that we consider 'devices'.
1724 */
1725 switch (type) {
1726 case ACPI_TYPE_DEVICE:
1727 type = ACPI_BUS_TYPE_DEVICE;
1728 break;
1729 case ACPI_TYPE_PROCESSOR:
1730 type = ACPI_BUS_TYPE_PROCESSOR;
1731 break;
1732 case ACPI_TYPE_THERMAL:
1733 type = ACPI_BUS_TYPE_THERMAL;
1734 break;
1735 case ACPI_TYPE_POWER:
1736 type = ACPI_BUS_TYPE_POWER;
1737 break;
1738 default:
1739 continue;
1740 }
1741
1742 status = acpi_bus_add(&child, parent, chandle, type);
1743 if (ACPI_FAILURE(status))
1744 continue;
1745
1746 /*
1747 * If the device is present, enabled, and functioning then
1748 * parse its scope (depth-first). Note that we need to
1749 * represent absent devices to facilitate PnP notifications
1750 * -- but only the subtree head (not all of its children,
1751 * which will be enumerated when the parent is inserted).
1752 *
1753 * TBD: Need notifications and other detection mechanisms
1754 * in place before we can fully implement this.
1755 */
1756 if (child->status.present) {
1757 status = acpi_get_next_object(ACPI_TYPE_ANY, chandle,
1758 0, NULL);
1759 if (ACPI_SUCCESS(status)) {
1760 level++;
1761 phandle = chandle;
1762 chandle = 0;
1763 parent = child;
1764 }
1765 }
1766 }
1767
1768 return_VALUE(0);
1769 }
1770
1771
1772 static int
acpi_bus_scan_fixed(struct acpi_device * root)1773 acpi_bus_scan_fixed (
1774 struct acpi_device *root)
1775 {
1776 int result = 0;
1777 struct acpi_device *device = NULL;
1778
1779 ACPI_FUNCTION_TRACE("acpi_bus_scan_fixed");
1780
1781 if (!root)
1782 return_VALUE(-ENODEV);
1783
1784 /*
1785 * Enumerate all fixed-feature devices.
1786 */
1787 if (acpi_fadt.pwr_button == 0)
1788 result = acpi_bus_add(&device, acpi_root,
1789 NULL, ACPI_BUS_TYPE_POWER_BUTTON);
1790
1791 if (acpi_fadt.sleep_button == 0)
1792 result = acpi_bus_add(&device, acpi_root,
1793 NULL, ACPI_BUS_TYPE_SLEEP_BUTTON);
1794
1795 return_VALUE(result);
1796 }
1797
1798
1799 /* --------------------------------------------------------------------------
1800 Initialization/Cleanup
1801 -------------------------------------------------------------------------- */
1802
1803 static int __init
acpi_bus_init_irq(void)1804 acpi_bus_init_irq (void)
1805 {
1806 acpi_status status = AE_OK;
1807 union acpi_object arg = {ACPI_TYPE_INTEGER};
1808 struct acpi_object_list arg_list = {1, &arg};
1809 char *message = NULL;
1810
1811 ACPI_FUNCTION_TRACE("acpi_bus_init_irq");
1812
1813 /*
1814 * Let the system know what interrupt model we are using by
1815 * evaluating the \_PIC object, if exists.
1816 */
1817
1818 switch (acpi_irq_model) {
1819 case ACPI_IRQ_MODEL_PIC:
1820 message = "PIC";
1821 break;
1822 case ACPI_IRQ_MODEL_IOAPIC:
1823 message = "IOAPIC";
1824 break;
1825 case ACPI_IRQ_MODEL_IOSAPIC:
1826 message = "IOSAPIC";
1827 break;
1828 default:
1829 printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
1830 return_VALUE(-ENODEV);
1831 }
1832
1833 printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message);
1834
1835 arg.integer.value = acpi_irq_model;
1836
1837 status = acpi_evaluate_object(NULL, "\\_PIC", &arg_list, NULL);
1838 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
1839 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PIC\n"));
1840 return_VALUE(-ENODEV);
1841 }
1842
1843 return_VALUE(0);
1844 }
1845
1846
1847 void __init
acpi_early_init(void)1848 acpi_early_init (void)
1849 {
1850 acpi_status status = AE_OK;
1851 struct acpi_buffer buffer = {sizeof(acpi_fadt), &acpi_fadt};
1852
1853 ACPI_FUNCTION_TRACE("acpi_early_init");
1854
1855 if (acpi_disabled)
1856 return_VOID;
1857
1858 status = acpi_initialize_subsystem();
1859 if (ACPI_FAILURE(status)) {
1860 printk(KERN_ERR PREFIX "Unable to initialize the ACPI Interpreter\n");
1861 goto error0;
1862 }
1863
1864 status = acpi_load_tables();
1865 if (ACPI_FAILURE(status)) {
1866 printk(KERN_ERR PREFIX "Unable to load the System Description Tables\n");
1867 goto error0;
1868 }
1869
1870 /*
1871 * Get a separate copy of the FADT for use by other drivers.
1872 */
1873 status = acpi_get_table(ACPI_TABLE_FADT, 1, &buffer);
1874 if (ACPI_FAILURE(status)) {
1875 printk(KERN_ERR PREFIX "Unable to get the FADT\n");
1876 goto error0;
1877 }
1878
1879 #ifdef CONFIG_X86
1880 if (!acpi_ioapic) {
1881 extern acpi_interrupt_flags acpi_sci_flags;
1882
1883 /* compatible (0) means level (3) */
1884 if (acpi_sci_flags.trigger == 0)
1885 acpi_sci_flags.trigger = 3;
1886
1887 /* Set PIC-mode SCI trigger type */
1888 acpi_pic_sci_set_trigger(acpi_fadt.sci_int, acpi_sci_flags.trigger);
1889 } else {
1890 extern int acpi_sci_override_gsi;
1891 /*
1892 * now that acpi_fadt is initialized,
1893 * update it with result from INT_SRC_OVR parsing
1894 */
1895 acpi_fadt.sci_int = acpi_sci_override_gsi;
1896 }
1897 #endif
1898
1899 status = acpi_enable_subsystem(~(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE));
1900 if (ACPI_FAILURE(status)) {
1901 printk(KERN_ERR PREFIX "Unable to enable ACPI\n");
1902 goto error0;
1903 }
1904
1905 return_VOID;
1906
1907 error0:
1908 disable_acpi();
1909 return_VOID;
1910 }
1911
1912 static int __init
acpi_bus_init(void)1913 acpi_bus_init (void)
1914 {
1915 int result = 0;
1916 acpi_status status = AE_OK;
1917 extern acpi_status acpi_os_initialize1(void);
1918
1919 ACPI_FUNCTION_TRACE("acpi_bus_init");
1920
1921 status = acpi_os_initialize1();
1922
1923 status = acpi_enable_subsystem(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE);
1924 if (ACPI_FAILURE(status)) {
1925 printk(KERN_ERR PREFIX "Unable to start the ACPI Interpreter\n");
1926 goto error1;
1927 }
1928
1929 if (ACPI_FAILURE(status)) {
1930 printk(KERN_ERR PREFIX "Unable to initialize ACPI OS objects\n");
1931 goto error1;
1932 }
1933 #ifdef CONFIG_ACPI_EC
1934 /*
1935 * ACPI 2.0 requires the EC driver to be loaded and work before
1936 * the EC device is found in the namespace. This is accomplished
1937 * by looking for the ECDT table, and getting the EC parameters out
1938 * of that.
1939 */
1940 result = acpi_ec_ecdt_probe();
1941 /* Ignore result. Not having an ECDT is not fatal. */
1942 #endif
1943
1944 status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
1945 if (ACPI_FAILURE(status)) {
1946 printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n");
1947 goto error1;
1948 }
1949
1950 printk(KERN_INFO PREFIX "Interpreter enabled\n");
1951
1952 /*
1953 * Get the system interrupt model and evaluate \_PIC.
1954 */
1955 result = acpi_bus_init_irq();
1956 if (result)
1957 goto error1;
1958
1959 /*
1960 * Register the for all standard device notifications.
1961 */
1962 status = acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY, &acpi_bus_notify, NULL);
1963 if (ACPI_FAILURE(status)) {
1964 printk(KERN_ERR PREFIX "Unable to register for device notifications\n");
1965 result = -ENODEV;
1966 goto error1;
1967 }
1968
1969 /*
1970 * Create the root device in the bus's device tree
1971 */
1972 result = acpi_bus_add(&acpi_root, NULL, ACPI_ROOT_OBJECT,
1973 ACPI_BUS_TYPE_SYSTEM);
1974 if (result)
1975 goto error2;
1976
1977 /*
1978 * Create the top ACPI proc directory
1979 */
1980 acpi_device_dir(acpi_root) = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);
1981 if (!acpi_root) {
1982 result = -ENODEV;
1983 goto error3;
1984 }
1985 acpi_root_dir = acpi_device_dir(acpi_root);
1986
1987 /*
1988 * Install drivers required for proper enumeration of the
1989 * ACPI namespace.
1990 */
1991 acpi_system_init(); /* ACPI System */
1992 acpi_power_init(); /* ACPI Bus Power Management */
1993 #ifdef CONFIG_ACPI_EC
1994 acpi_ec_init(); /* ACPI Embedded Controller */
1995 #endif
1996 #ifdef CONFIG_ACPI_PCI
1997 if (!acpi_pci_disabled) {
1998 acpi_pci_link_init(); /* ACPI PCI Interrupt Link */
1999 acpi_pci_root_init(); /* ACPI PCI Root Bridge */
2000 }
2001 #endif
2002 /*
2003 * Enumerate devices in the ACPI namespace.
2004 */
2005 result = acpi_bus_scan_fixed(acpi_root);
2006 if (result)
2007 goto error4;
2008 result = acpi_bus_scan(acpi_root);
2009 if (result)
2010 goto error4;
2011
2012 acpi_motherboard_init();
2013 return_VALUE(0);
2014
2015 /* Mimic structured exception handling */
2016 error4:
2017 remove_proc_entry(ACPI_BUS_FILE_ROOT, NULL);
2018 error3:
2019 acpi_bus_remove(acpi_root, ACPI_BUS_REMOVAL_NORMAL);
2020 error2:
2021 acpi_remove_notify_handler(ACPI_ROOT_OBJECT,
2022 ACPI_SYSTEM_NOTIFY, &acpi_bus_notify);
2023 error1:
2024 acpi_terminate();
2025 return_VALUE(-ENODEV);
2026 }
2027
2028
2029 static void __exit
acpi_bus_exit(void)2030 acpi_bus_exit (void)
2031 {
2032 acpi_status status = AE_OK;
2033
2034 ACPI_FUNCTION_TRACE("acpi_bus_exit");
2035
2036 status = acpi_remove_notify_handler(ACPI_ROOT_OBJECT,
2037 ACPI_SYSTEM_NOTIFY, acpi_bus_notify);
2038 if (ACPI_FAILURE(status))
2039 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
2040 "Error removing notify handler\n"));
2041
2042 #ifdef CONFIG_ACPI_PCI
2043 acpi_pci_root_exit();
2044 acpi_pci_link_exit();
2045 #endif
2046 #ifdef CONFIG_ACPI_EC
2047 acpi_ec_exit();
2048 #endif
2049 acpi_power_exit();
2050 acpi_system_exit();
2051
2052 acpi_bus_remove(acpi_root, ACPI_BUS_REMOVAL_NORMAL);
2053
2054 remove_proc_entry(ACPI_BUS_FILE_ROOT, NULL);
2055
2056 status = acpi_terminate();
2057 if (ACPI_FAILURE(status))
2058 printk(KERN_ERR PREFIX "Unable to terminate the ACPI Interpreter\n");
2059 else
2060 printk(KERN_ERR PREFIX "Interpreter disabled\n");
2061
2062 return_VOID;
2063 }
2064
2065
2066 int __init
acpi_init(void)2067 acpi_init (void)
2068 {
2069 int result = 0;
2070
2071 ACPI_FUNCTION_TRACE("acpi_init");
2072
2073 printk(KERN_INFO PREFIX "Subsystem revision %08x\n",
2074 ACPI_CA_VERSION);
2075
2076 /* Initial core debug level excludes drivers, so include them now */
2077 acpi_set_debug(ACPI_DEBUG_LOW);
2078
2079 if (acpi_disabled) {
2080 printk(KERN_INFO PREFIX "Interpreter disabled.\n");
2081 return -ENODEV;
2082 }
2083
2084 #ifdef CONFIG_PM
2085 if (PM_IS_ACTIVE()) {
2086 printk(KERN_INFO PREFIX "APM is already active, exiting\n");
2087 return -ENODEV;
2088 }
2089 #endif
2090
2091 result = acpi_bus_init();
2092 if (result) {
2093 disable_acpi();
2094 return_VALUE(result);
2095 }
2096
2097 #ifdef CONFIG_PM
2098 pm_active = 1;
2099 #endif
2100
2101 return_VALUE(0);
2102 }
2103
2104
2105 void __exit
acpi_exit(void)2106 acpi_exit (void)
2107 {
2108 ACPI_FUNCTION_TRACE("acpi_exit");
2109
2110 #ifdef CONFIG_PM
2111 pm_active = 0;
2112 #endif
2113
2114 acpi_bus_exit();
2115
2116 return_VOID;
2117 }
2118
2119