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#include <linux/init.h>
43#include <linux/module.h>
44
45#include <linux/kernel.h>
46#include <linux/pci.h>
47#include <linux/pci_hotplug.h>
48#include <linux/pci-acpi.h>
49#include <linux/mutex.h>
50
51#include "../pci.h"
52#include "acpiphp.h"
53
54static LIST_HEAD(bridge_list);
55static LIST_HEAD(ioapic_list);
56static DEFINE_SPINLOCK(ioapic_list_lock);
57
58#define MY_NAME "acpiphp_glue"
59
60static void handle_hotplug_event_bridge (acpi_handle, u32, void *);
61static void acpiphp_sanitize_bus(struct pci_bus *bus);
62static void acpiphp_set_hpp_values(struct pci_bus *bus);
63static void handle_hotplug_event_func(acpi_handle handle, u32 type, void *context);
64
65
66static acpi_status
67is_pci_dock_device(acpi_handle handle, u32 lvl, void *context, void **rv)
68{
69 int *count = (int *)context;
70
71 if (is_dock_device(handle)) {
72 (*count)++;
73 return AE_CTRL_TERMINATE;
74 } else {
75 return AE_OK;
76 }
77}
78
79
80
81
82
83
84
85
86static int post_dock_fixups(struct notifier_block *nb, unsigned long val,
87 void *v)
88{
89 struct acpiphp_func *func = container_of(nb, struct acpiphp_func, nb);
90 struct pci_bus *bus = func->slot->bridge->pci_bus;
91 u32 buses;
92
93 if (!bus->self)
94 return NOTIFY_OK;
95
96
97
98
99 pci_read_config_dword(bus->self,
100 PCI_PRIMARY_BUS,
101 &buses);
102
103 if (((buses >> 8) & 0xff) != bus->secondary) {
104 buses = (buses & 0xff000000)
105 | ((unsigned int)(bus->primary) << 0)
106 | ((unsigned int)(bus->secondary) << 8)
107 | ((unsigned int)(bus->subordinate) << 16);
108 pci_write_config_dword(bus->self, PCI_PRIMARY_BUS, buses);
109 }
110 return NOTIFY_OK;
111}
112
113
114static struct acpi_dock_ops acpiphp_dock_ops = {
115 .handler = handle_hotplug_event_func,
116};
117
118
119static acpi_status
120register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
121{
122 struct acpiphp_bridge *bridge = (struct acpiphp_bridge *)context;
123 struct acpiphp_slot *slot;
124 struct acpiphp_func *newfunc;
125 acpi_handle tmp;
126 acpi_status status = AE_OK;
127 unsigned long long adr, sun;
128 int device, function, retval;
129 struct pci_bus *pbus = bridge->pci_bus;
130 struct pci_dev *pdev;
131
132 if (!acpi_pci_check_ejectable(pbus, handle) && !is_dock_device(handle))
133 return AE_OK;
134
135 acpi_evaluate_integer(handle, "_ADR", NULL, &adr);
136 device = (adr >> 16) & 0xffff;
137 function = adr & 0xffff;
138
139 newfunc = kzalloc(sizeof(struct acpiphp_func), GFP_KERNEL);
140 if (!newfunc)
141 return AE_NO_MEMORY;
142
143 INIT_LIST_HEAD(&newfunc->sibling);
144 newfunc->handle = handle;
145 newfunc->function = function;
146
147 if (ACPI_SUCCESS(acpi_get_handle(handle, "_EJ0", &tmp)))
148 newfunc->flags = FUNC_HAS_EJ0;
149
150 if (ACPI_SUCCESS(acpi_get_handle(handle, "_STA", &tmp)))
151 newfunc->flags |= FUNC_HAS_STA;
152
153 if (ACPI_SUCCESS(acpi_get_handle(handle, "_PS0", &tmp)))
154 newfunc->flags |= FUNC_HAS_PS0;
155
156 if (ACPI_SUCCESS(acpi_get_handle(handle, "_PS3", &tmp)))
157 newfunc->flags |= FUNC_HAS_PS3;
158
159 if (ACPI_SUCCESS(acpi_get_handle(handle, "_DCK", &tmp)))
160 newfunc->flags |= FUNC_HAS_DCK;
161
162 status = acpi_evaluate_integer(handle, "_SUN", NULL, &sun);
163 if (ACPI_FAILURE(status)) {
164
165
166
167
168 sun = bridge->nr_slots+1;
169 }
170
171
172 for (slot = bridge->slots; slot; slot = slot->next)
173 if (slot->device == device) {
174 if (slot->sun != sun)
175 warn("sibling found, but _SUN doesn't match!\n");
176 break;
177 }
178
179 if (!slot) {
180 slot = kzalloc(sizeof(struct acpiphp_slot), GFP_KERNEL);
181 if (!slot) {
182 kfree(newfunc);
183 return AE_NO_MEMORY;
184 }
185
186 slot->bridge = bridge;
187 slot->device = device;
188 slot->sun = sun;
189 INIT_LIST_HEAD(&slot->funcs);
190 mutex_init(&slot->crit_sect);
191
192 slot->next = bridge->slots;
193 bridge->slots = slot;
194
195 bridge->nr_slots++;
196
197 dbg("found ACPI PCI Hotplug slot %llu at PCI %04x:%02x:%02x\n",
198 slot->sun, pci_domain_nr(pbus), pbus->number, device);
199 retval = acpiphp_register_hotplug_slot(slot);
200 if (retval) {
201 if (retval == -EBUSY)
202 warn("Slot %llu already registered by another "
203 "hotplug driver\n", slot->sun);
204 else
205 warn("acpiphp_register_hotplug_slot failed "
206 "(err code = 0x%x)\n", retval);
207 goto err_exit;
208 }
209 }
210
211 newfunc->slot = slot;
212 list_add_tail(&newfunc->sibling, &slot->funcs);
213
214 pdev = pci_get_slot(pbus, PCI_DEVFN(device, function));
215 if (pdev) {
216 slot->flags |= (SLOT_ENABLED | SLOT_POWEREDON);
217 pci_dev_put(pdev);
218 }
219
220 if (is_dock_device(handle)) {
221
222
223
224
225 newfunc->flags &= ~FUNC_HAS_EJ0;
226 if (register_hotplug_dock_device(handle,
227 &acpiphp_dock_ops, newfunc))
228 dbg("failed to register dock device\n");
229
230
231
232
233
234 newfunc->nb.notifier_call = post_dock_fixups;
235 if (register_dock_notifier(&newfunc->nb))
236 dbg("failed to register a dock notifier");
237 }
238
239
240 if (!(newfunc->flags & FUNC_HAS_DCK)) {
241 status = acpi_install_notify_handler(handle,
242 ACPI_SYSTEM_NOTIFY,
243 handle_hotplug_event_func,
244 newfunc);
245
246 if (ACPI_FAILURE(status))
247 err("failed to register interrupt notify handler\n");
248 } else
249 status = AE_OK;
250
251 return status;
252
253 err_exit:
254 bridge->nr_slots--;
255 bridge->slots = slot->next;
256 kfree(slot);
257 kfree(newfunc);
258
259 return AE_OK;
260}
261
262
263
264static int detect_ejectable_slots(acpi_handle handle)
265{
266 int found = acpi_pci_detect_ejectable(handle);
267 if (!found) {
268 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
269 is_pci_dock_device, (void *)&found, NULL);
270 }
271 return found;
272}
273
274
275static void init_bridge_misc(struct acpiphp_bridge *bridge)
276{
277 acpi_status status;
278
279
280 list_add(&bridge->list, &bridge_list);
281
282
283 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge->handle, (u32)1,
284 register_slot, bridge, NULL);
285 if (ACPI_FAILURE(status)) {
286 list_del(&bridge->list);
287 return;
288 }
289
290
291 if (bridge->type != BRIDGE_TYPE_HOST) {
292 if ((bridge->flags & BRIDGE_HAS_EJ0) && bridge->func) {
293 status = acpi_remove_notify_handler(bridge->func->handle,
294 ACPI_SYSTEM_NOTIFY,
295 handle_hotplug_event_func);
296 if (ACPI_FAILURE(status))
297 err("failed to remove notify handler\n");
298 }
299 status = acpi_install_notify_handler(bridge->handle,
300 ACPI_SYSTEM_NOTIFY,
301 handle_hotplug_event_bridge,
302 bridge);
303
304 if (ACPI_FAILURE(status)) {
305 err("failed to register interrupt notify handler\n");
306 }
307 }
308}
309
310
311
312static struct acpiphp_func *acpiphp_bridge_handle_to_function(acpi_handle handle)
313{
314 struct list_head *node, *l;
315 struct acpiphp_bridge *bridge;
316 struct acpiphp_slot *slot;
317 struct acpiphp_func *func;
318
319 list_for_each(node, &bridge_list) {
320 bridge = list_entry(node, struct acpiphp_bridge, list);
321 for (slot = bridge->slots; slot; slot = slot->next) {
322 list_for_each(l, &slot->funcs) {
323 func = list_entry(l, struct acpiphp_func,
324 sibling);
325 if (func->handle == handle)
326 return func;
327 }
328 }
329 }
330
331 return NULL;
332}
333
334
335static inline void config_p2p_bridge_flags(struct acpiphp_bridge *bridge)
336{
337 acpi_handle dummy_handle;
338
339 if (ACPI_SUCCESS(acpi_get_handle(bridge->handle,
340 "_STA", &dummy_handle)))
341 bridge->flags |= BRIDGE_HAS_STA;
342
343 if (ACPI_SUCCESS(acpi_get_handle(bridge->handle,
344 "_EJ0", &dummy_handle)))
345 bridge->flags |= BRIDGE_HAS_EJ0;
346
347 if (ACPI_SUCCESS(acpi_get_handle(bridge->handle,
348 "_PS0", &dummy_handle)))
349 bridge->flags |= BRIDGE_HAS_PS0;
350
351 if (ACPI_SUCCESS(acpi_get_handle(bridge->handle,
352 "_PS3", &dummy_handle)))
353 bridge->flags |= BRIDGE_HAS_PS3;
354
355
356 if (bridge->flags & BRIDGE_HAS_EJ0) {
357 struct acpiphp_func *func;
358
359 dbg("found ejectable p2p bridge\n");
360
361
362 func = acpiphp_bridge_handle_to_function(bridge->handle);
363 if (!func)
364 return;
365 bridge->func = func;
366 func->bridge = bridge;
367 }
368}
369
370
371
372static void add_host_bridge(acpi_handle *handle)
373{
374 struct acpiphp_bridge *bridge;
375 struct acpi_pci_root *root = acpi_pci_find_root(handle);
376
377 bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL);
378 if (bridge == NULL)
379 return;
380
381 bridge->type = BRIDGE_TYPE_HOST;
382 bridge->handle = handle;
383
384 bridge->pci_bus = root->bus;
385
386 spin_lock_init(&bridge->res_lock);
387
388 init_bridge_misc(bridge);
389}
390
391
392
393static void add_p2p_bridge(acpi_handle *handle)
394{
395 struct acpiphp_bridge *bridge;
396
397 bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL);
398 if (bridge == NULL) {
399 err("out of memory\n");
400 return;
401 }
402
403 bridge->type = BRIDGE_TYPE_P2P;
404 bridge->handle = handle;
405 config_p2p_bridge_flags(bridge);
406
407 bridge->pci_dev = acpi_get_pci_dev(handle);
408 bridge->pci_bus = bridge->pci_dev->subordinate;
409 if (!bridge->pci_bus) {
410 err("This is not a PCI-to-PCI bridge!\n");
411 goto err;
412 }
413
414
415
416
417
418
419 get_device(&bridge->pci_bus->dev);
420 spin_lock_init(&bridge->res_lock);
421
422 init_bridge_misc(bridge);
423 return;
424 err:
425 pci_dev_put(bridge->pci_dev);
426 kfree(bridge);
427 return;
428}
429
430
431
432static acpi_status
433find_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv)
434{
435 acpi_status status;
436 struct pci_dev *dev;
437
438 dev = acpi_get_pci_dev(handle);
439 if (!dev || !dev->subordinate)
440 goto out;
441
442
443 if ((detect_ejectable_slots(handle) > 0)) {
444 dbg("found PCI-to-PCI bridge at PCI %s\n", pci_name(dev));
445 add_p2p_bridge(handle);
446 }
447
448
449 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
450 find_p2p_bridge, NULL, NULL);
451 if (ACPI_FAILURE(status))
452 warn("find_p2p_bridge failed (error code = 0x%x)\n", status);
453
454 out:
455 pci_dev_put(dev);
456 return AE_OK;
457}
458
459
460
461static int add_bridge(acpi_handle handle)
462{
463 acpi_status status;
464 unsigned long long tmp;
465 acpi_handle dummy_handle;
466
467
468 status = acpi_get_handle(handle, "_STA", &dummy_handle);
469 if (ACPI_SUCCESS(status)) {
470 status = acpi_evaluate_integer(handle, "_STA", NULL, &tmp);
471 if (ACPI_FAILURE(status)) {
472 dbg("%s: _STA evaluation failure\n", __func__);
473 return 0;
474 }
475 if ((tmp & ACPI_STA_FUNCTIONING) == 0)
476
477 return 0;
478 }
479
480
481 if (detect_ejectable_slots(handle) > 0) {
482 dbg("found PCI host-bus bridge with hot-pluggable slots\n");
483 add_host_bridge(handle);
484 }
485
486
487 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
488 find_p2p_bridge, NULL, NULL);
489
490 if (ACPI_FAILURE(status))
491 warn("find_p2p_bridge failed (error code = 0x%x)\n", status);
492
493 return 0;
494}
495
496static struct acpiphp_bridge *acpiphp_handle_to_bridge(acpi_handle handle)
497{
498 struct list_head *head;
499 list_for_each(head, &bridge_list) {
500 struct acpiphp_bridge *bridge = list_entry(head,
501 struct acpiphp_bridge, list);
502 if (bridge->handle == handle)
503 return bridge;
504 }
505
506 return NULL;
507}
508
509static void cleanup_bridge(struct acpiphp_bridge *bridge)
510{
511 struct list_head *list, *tmp;
512 struct acpiphp_slot *slot;
513 acpi_status status;
514 acpi_handle handle = bridge->handle;
515
516 status = acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
517 handle_hotplug_event_bridge);
518 if (ACPI_FAILURE(status))
519 err("failed to remove notify handler\n");
520
521 if ((bridge->type != BRIDGE_TYPE_HOST) &&
522 ((bridge->flags & BRIDGE_HAS_EJ0) && bridge->func)) {
523 status = acpi_install_notify_handler(bridge->func->handle,
524 ACPI_SYSTEM_NOTIFY,
525 handle_hotplug_event_func,
526 bridge->func);
527 if (ACPI_FAILURE(status))
528 err("failed to install interrupt notify handler\n");
529 }
530
531 slot = bridge->slots;
532 while (slot) {
533 struct acpiphp_slot *next = slot->next;
534 list_for_each_safe (list, tmp, &slot->funcs) {
535 struct acpiphp_func *func;
536 func = list_entry(list, struct acpiphp_func, sibling);
537 if (is_dock_device(func->handle)) {
538 unregister_hotplug_dock_device(func->handle);
539 unregister_dock_notifier(&func->nb);
540 }
541 if (!(func->flags & FUNC_HAS_DCK)) {
542 status = acpi_remove_notify_handler(func->handle,
543 ACPI_SYSTEM_NOTIFY,
544 handle_hotplug_event_func);
545 if (ACPI_FAILURE(status))
546 err("failed to remove notify handler\n");
547 }
548 list_del(list);
549 kfree(func);
550 }
551 acpiphp_unregister_hotplug_slot(slot);
552 list_del(&slot->funcs);
553 kfree(slot);
554 slot = next;
555 }
556
557
558
559
560 if (bridge->pci_dev)
561 put_device(&bridge->pci_bus->dev);
562
563 pci_dev_put(bridge->pci_dev);
564 list_del(&bridge->list);
565 kfree(bridge);
566}
567
568static acpi_status
569cleanup_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv)
570{
571 struct acpiphp_bridge *bridge;
572
573
574
575 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
576 cleanup_p2p_bridge, NULL, NULL);
577
578 bridge = acpiphp_handle_to_bridge(handle);
579 if (bridge)
580 cleanup_bridge(bridge);
581
582 return AE_OK;
583}
584
585static void remove_bridge(acpi_handle handle)
586{
587 struct acpiphp_bridge *bridge;
588
589
590
591 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
592 (u32)1, cleanup_p2p_bridge, NULL, NULL);
593
594
595
596
597
598
599
600
601 bridge = acpiphp_handle_to_bridge(handle);
602 if (bridge)
603 cleanup_bridge(bridge);
604 else
605 acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
606 handle_hotplug_event_bridge);
607}
608
609static struct pci_dev * get_apic_pci_info(acpi_handle handle)
610{
611 struct pci_dev *dev;
612
613 dev = acpi_get_pci_dev(handle);
614 if (!dev)
615 return NULL;
616
617 if ((dev->class != PCI_CLASS_SYSTEM_PIC_IOAPIC) &&
618 (dev->class != PCI_CLASS_SYSTEM_PIC_IOXAPIC))
619 {
620 pci_dev_put(dev);
621 return NULL;
622 }
623
624 return dev;
625}
626
627static int get_gsi_base(acpi_handle handle, u32 *gsi_base)
628{
629 acpi_status status;
630 int result = -1;
631 unsigned long long gsb;
632 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
633 union acpi_object *obj;
634 void *table;
635
636 status = acpi_evaluate_integer(handle, "_GSB", NULL, &gsb);
637 if (ACPI_SUCCESS(status)) {
638 *gsi_base = (u32)gsb;
639 return 0;
640 }
641
642 status = acpi_evaluate_object(handle, "_MAT", NULL, &buffer);
643 if (ACPI_FAILURE(status) || !buffer.length || !buffer.pointer)
644 return -1;
645
646 obj = buffer.pointer;
647 if (obj->type != ACPI_TYPE_BUFFER)
648 goto out;
649
650 table = obj->buffer.pointer;
651 switch (((struct acpi_subtable_header *)table)->type) {
652 case ACPI_MADT_TYPE_IO_SAPIC:
653 *gsi_base = ((struct acpi_madt_io_sapic *)table)->global_irq_base;
654 result = 0;
655 break;
656 case ACPI_MADT_TYPE_IO_APIC:
657 *gsi_base = ((struct acpi_madt_io_apic *)table)->global_irq_base;
658 result = 0;
659 break;
660 default:
661 break;
662 }
663 out:
664 kfree(buffer.pointer);
665 return result;
666}
667
668static acpi_status
669ioapic_add(acpi_handle handle, u32 lvl, void *context, void **rv)
670{
671 acpi_status status;
672 unsigned long long sta;
673 acpi_handle tmp;
674 struct pci_dev *pdev;
675 u32 gsi_base;
676 u64 phys_addr;
677 struct acpiphp_ioapic *ioapic;
678
679
680 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
681 if (ACPI_SUCCESS(status) && sta != ACPI_STA_ALL)
682 return AE_CTRL_DEPTH;
683
684
685 status = acpi_get_handle(handle, "_HID", &tmp);
686 if (ACPI_SUCCESS(status))
687 return AE_CTRL_DEPTH;
688
689 if (get_gsi_base(handle, &gsi_base))
690 return AE_OK;
691
692 ioapic = kmalloc(sizeof(*ioapic), GFP_KERNEL);
693 if (!ioapic)
694 return AE_NO_MEMORY;
695
696 pdev = get_apic_pci_info(handle);
697 if (!pdev)
698 goto exit_kfree;
699
700 if (pci_enable_device(pdev))
701 goto exit_pci_dev_put;
702
703 pci_set_master(pdev);
704
705 if (pci_request_region(pdev, 0, "I/O APIC(acpiphp)"))
706 goto exit_pci_disable_device;
707
708 phys_addr = pci_resource_start(pdev, 0);
709 if (acpi_register_ioapic(handle, phys_addr, gsi_base))
710 goto exit_pci_release_region;
711
712 ioapic->gsi_base = gsi_base;
713 ioapic->dev = pdev;
714 spin_lock(&ioapic_list_lock);
715 list_add_tail(&ioapic->list, &ioapic_list);
716 spin_unlock(&ioapic_list_lock);
717
718 return AE_OK;
719
720 exit_pci_release_region:
721 pci_release_region(pdev, 0);
722 exit_pci_disable_device:
723 pci_disable_device(pdev);
724 exit_pci_dev_put:
725 pci_dev_put(pdev);
726 exit_kfree:
727 kfree(ioapic);
728
729 return AE_OK;
730}
731
732static acpi_status
733ioapic_remove(acpi_handle handle, u32 lvl, void *context, void **rv)
734{
735 acpi_status status;
736 unsigned long long sta;
737 acpi_handle tmp;
738 u32 gsi_base;
739 struct acpiphp_ioapic *pos, *n, *ioapic = NULL;
740
741
742 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
743 if (ACPI_SUCCESS(status) && sta != ACPI_STA_ALL)
744 return AE_CTRL_DEPTH;
745
746
747 status = acpi_get_handle(handle, "_HID", &tmp);
748 if (ACPI_SUCCESS(status))
749 return AE_CTRL_DEPTH;
750
751 if (get_gsi_base(handle, &gsi_base))
752 return AE_OK;
753
754 acpi_unregister_ioapic(handle, gsi_base);
755
756 spin_lock(&ioapic_list_lock);
757 list_for_each_entry_safe(pos, n, &ioapic_list, list) {
758 if (pos->gsi_base != gsi_base)
759 continue;
760 ioapic = pos;
761 list_del(&ioapic->list);
762 break;
763 }
764 spin_unlock(&ioapic_list_lock);
765
766 if (!ioapic)
767 return AE_OK;
768
769 pci_release_region(ioapic->dev, 0);
770 pci_disable_device(ioapic->dev);
771 pci_dev_put(ioapic->dev);
772 kfree(ioapic);
773
774 return AE_OK;
775}
776
777static int acpiphp_configure_ioapics(acpi_handle handle)
778{
779 ioapic_add(handle, 0, NULL, NULL);
780 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
781 ACPI_UINT32_MAX, ioapic_add, NULL, NULL);
782 return 0;
783}
784
785static int acpiphp_unconfigure_ioapics(acpi_handle handle)
786{
787 ioapic_remove(handle, 0, NULL, NULL);
788 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
789 ACPI_UINT32_MAX, ioapic_remove, NULL, NULL);
790 return 0;
791}
792
793static int power_on_slot(struct acpiphp_slot *slot)
794{
795 acpi_status status;
796 struct acpiphp_func *func;
797 struct list_head *l;
798 int retval = 0;
799
800
801 if (slot->flags & SLOT_POWEREDON)
802 goto err_exit;
803
804 list_for_each (l, &slot->funcs) {
805 func = list_entry(l, struct acpiphp_func, sibling);
806
807 if (func->flags & FUNC_HAS_PS0) {
808 dbg("%s: executing _PS0\n", __func__);
809 status = acpi_evaluate_object(func->handle, "_PS0", NULL, NULL);
810 if (ACPI_FAILURE(status)) {
811 warn("%s: _PS0 failed\n", __func__);
812 retval = -1;
813 goto err_exit;
814 } else
815 break;
816 }
817 }
818
819
820
821 slot->flags |= SLOT_POWEREDON;
822
823 err_exit:
824 return retval;
825}
826
827
828static int power_off_slot(struct acpiphp_slot *slot)
829{
830 acpi_status status;
831 struct acpiphp_func *func;
832 struct list_head *l;
833
834 int retval = 0;
835
836
837 if ((slot->flags & SLOT_POWEREDON) == 0)
838 goto err_exit;
839
840 list_for_each (l, &slot->funcs) {
841 func = list_entry(l, struct acpiphp_func, sibling);
842
843 if (func->flags & FUNC_HAS_PS3) {
844 status = acpi_evaluate_object(func->handle, "_PS3", NULL, NULL);
845 if (ACPI_FAILURE(status)) {
846 warn("%s: _PS3 failed\n", __func__);
847 retval = -1;
848 goto err_exit;
849 } else
850 break;
851 }
852 }
853
854
855
856 slot->flags &= (~SLOT_POWEREDON);
857
858 err_exit:
859 return retval;
860}
861
862
863
864
865
866
867
868static unsigned char acpiphp_max_busnr(struct pci_bus *bus)
869{
870 struct list_head *tmp;
871 unsigned char max, n;
872
873
874
875
876
877
878
879
880
881 max = bus->secondary;
882
883 list_for_each(tmp, &bus->children) {
884 n = pci_bus_max_busnr(pci_bus_b(tmp));
885 if (n > max)
886 max = n;
887 }
888 return max;
889}
890
891
892
893
894
895
896static int acpiphp_bus_add(struct acpiphp_func *func)
897{
898 acpi_handle phandle;
899 struct acpi_device *device, *pdevice;
900 int ret_val;
901
902 acpi_get_parent(func->handle, &phandle);
903 if (acpi_bus_get_device(phandle, &pdevice)) {
904 dbg("no parent device, assuming NULL\n");
905 pdevice = NULL;
906 }
907 if (!acpi_bus_get_device(func->handle, &device)) {
908 dbg("bus exists... trim\n");
909
910
911
912 ret_val = acpi_bus_trim(device, 1);
913 dbg("acpi_bus_trim return %x\n", ret_val);
914 }
915
916 ret_val = acpi_bus_add(&device, pdevice, func->handle,
917 ACPI_BUS_TYPE_DEVICE);
918 if (ret_val) {
919 dbg("error adding bus, %x\n",
920 -ret_val);
921 goto acpiphp_bus_add_out;
922 }
923
924
925
926
927
928
929 ret_val = acpi_bus_start(device);
930
931acpiphp_bus_add_out:
932 return ret_val;
933}
934
935
936
937
938
939
940static int acpiphp_bus_trim(acpi_handle handle)
941{
942 struct acpi_device *device;
943 int retval;
944
945 retval = acpi_bus_get_device(handle, &device);
946 if (retval) {
947 dbg("acpi_device not found\n");
948 return retval;
949 }
950
951 retval = acpi_bus_trim(device, 1);
952 if (retval)
953 err("cannot remove from acpi list\n");
954
955 return retval;
956}
957
958
959
960
961
962
963
964
965static int __ref enable_device(struct acpiphp_slot *slot)
966{
967 struct pci_dev *dev;
968 struct pci_bus *bus = slot->bridge->pci_bus;
969 struct list_head *l;
970 struct acpiphp_func *func;
971 int retval = 0;
972 int num, max, pass;
973 acpi_status status;
974
975 if (slot->flags & SLOT_ENABLED)
976 goto err_exit;
977
978
979 dev = pci_get_slot(bus, PCI_DEVFN(slot->device, 0));
980 if (dev) {
981
982 err("pci_dev structure already exists.\n");
983 pci_dev_put(dev);
984 retval = -1;
985 goto err_exit;
986 }
987
988 num = pci_scan_slot(bus, PCI_DEVFN(slot->device, 0));
989 if (num == 0) {
990 err("No new device found\n");
991 retval = -1;
992 goto err_exit;
993 }
994
995 max = acpiphp_max_busnr(bus);
996 for (pass = 0; pass < 2; pass++) {
997 list_for_each_entry(dev, &bus->devices, bus_list) {
998 if (PCI_SLOT(dev->devfn) != slot->device)
999 continue;
1000 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
1001 dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) {
1002 max = pci_scan_bridge(bus, dev, max, pass);
1003 if (pass && dev->subordinate)
1004 pci_bus_size_bridges(dev->subordinate);
1005 }
1006 }
1007 }
1008
1009 list_for_each (l, &slot->funcs) {
1010 func = list_entry(l, struct acpiphp_func, sibling);
1011 acpiphp_bus_add(func);
1012 }
1013
1014 pci_bus_assign_resources(bus);
1015 acpiphp_sanitize_bus(bus);
1016 acpiphp_set_hpp_values(bus);
1017 list_for_each_entry(func, &slot->funcs, sibling)
1018 acpiphp_configure_ioapics(func->handle);
1019 pci_enable_bridges(bus);
1020 pci_bus_add_devices(bus);
1021
1022 list_for_each (l, &slot->funcs) {
1023 func = list_entry(l, struct acpiphp_func, sibling);
1024 dev = pci_get_slot(bus, PCI_DEVFN(slot->device,
1025 func->function));
1026 if (!dev)
1027 continue;
1028
1029 if (dev->hdr_type != PCI_HEADER_TYPE_BRIDGE &&
1030 dev->hdr_type != PCI_HEADER_TYPE_CARDBUS) {
1031 pci_dev_put(dev);
1032 continue;
1033 }
1034
1035 status = find_p2p_bridge(func->handle, (u32)1, bus, NULL);
1036 if (ACPI_FAILURE(status))
1037 warn("find_p2p_bridge failed (error code = 0x%x)\n",
1038 status);
1039 pci_dev_put(dev);
1040 }
1041
1042 slot->flags |= SLOT_ENABLED;
1043
1044 err_exit:
1045 return retval;
1046}
1047
1048static void disable_bridges(struct pci_bus *bus)
1049{
1050 struct pci_dev *dev;
1051 list_for_each_entry(dev, &bus->devices, bus_list) {
1052 if (dev->subordinate) {
1053 disable_bridges(dev->subordinate);
1054 pci_disable_device(dev);
1055 }
1056 }
1057}
1058
1059
1060
1061
1062
1063static int disable_device(struct acpiphp_slot *slot)
1064{
1065 struct acpiphp_func *func;
1066 struct pci_dev *pdev;
1067
1068
1069 if (!(slot->flags & SLOT_ENABLED))
1070 goto err_exit;
1071
1072 list_for_each_entry(func, &slot->funcs, sibling) {
1073 if (func->bridge) {
1074
1075 cleanup_p2p_bridge(func->bridge->handle,
1076 (u32)1, NULL, NULL);
1077 func->bridge = NULL;
1078 }
1079
1080 pdev = pci_get_slot(slot->bridge->pci_bus,
1081 PCI_DEVFN(slot->device, func->function));
1082 if (pdev) {
1083 pci_stop_bus_device(pdev);
1084 if (pdev->subordinate) {
1085 disable_bridges(pdev->subordinate);
1086 pci_disable_device(pdev);
1087 }
1088 pci_remove_bus_device(pdev);
1089 pci_dev_put(pdev);
1090 }
1091 }
1092
1093 list_for_each_entry(func, &slot->funcs, sibling) {
1094 acpiphp_unconfigure_ioapics(func->handle);
1095 acpiphp_bus_trim(func->handle);
1096 }
1097
1098 slot->flags &= (~SLOT_ENABLED);
1099
1100err_exit:
1101 return 0;
1102}
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117static unsigned int get_slot_status(struct acpiphp_slot *slot)
1118{
1119 acpi_status status;
1120 unsigned long long sta = 0;
1121 u32 dvid;
1122 struct list_head *l;
1123 struct acpiphp_func *func;
1124
1125 list_for_each (l, &slot->funcs) {
1126 func = list_entry(l, struct acpiphp_func, sibling);
1127
1128 if (func->flags & FUNC_HAS_STA) {
1129 status = acpi_evaluate_integer(func->handle, "_STA", NULL, &sta);
1130 if (ACPI_SUCCESS(status) && sta)
1131 break;
1132 } else {
1133 pci_bus_read_config_dword(slot->bridge->pci_bus,
1134 PCI_DEVFN(slot->device,
1135 func->function),
1136 PCI_VENDOR_ID, &dvid);
1137 if (dvid != 0xffffffff) {
1138 sta = ACPI_STA_ALL;
1139 break;
1140 }
1141 }
1142 }
1143
1144 return (unsigned int)sta;
1145}
1146
1147
1148
1149
1150
1151int acpiphp_eject_slot(struct acpiphp_slot *slot)
1152{
1153 acpi_status status;
1154 struct acpiphp_func *func;
1155 struct list_head *l;
1156 struct acpi_object_list arg_list;
1157 union acpi_object arg;
1158
1159 list_for_each (l, &slot->funcs) {
1160 func = list_entry(l, struct acpiphp_func, sibling);
1161
1162
1163 if ((func->flags & FUNC_HAS_EJ0)) {
1164
1165 arg_list.count = 1;
1166 arg_list.pointer = &arg;
1167 arg.type = ACPI_TYPE_INTEGER;
1168 arg.integer.value = 1;
1169
1170 status = acpi_evaluate_object(func->handle, "_EJ0", &arg_list, NULL);
1171 if (ACPI_FAILURE(status)) {
1172 warn("%s: _EJ0 failed\n", __func__);
1173 return -1;
1174 } else
1175 break;
1176 }
1177 }
1178 return 0;
1179}
1180
1181
1182
1183
1184
1185
1186
1187
1188static int acpiphp_check_bridge(struct acpiphp_bridge *bridge)
1189{
1190 struct acpiphp_slot *slot;
1191 int retval = 0;
1192 int enabled, disabled;
1193
1194 enabled = disabled = 0;
1195
1196 for (slot = bridge->slots; slot; slot = slot->next) {
1197 unsigned int status = get_slot_status(slot);
1198 if (slot->flags & SLOT_ENABLED) {
1199 if (status == ACPI_STA_ALL)
1200 continue;
1201 retval = acpiphp_disable_slot(slot);
1202 if (retval) {
1203 err("Error occurred in disabling\n");
1204 goto err_exit;
1205 } else {
1206 acpiphp_eject_slot(slot);
1207 }
1208 disabled++;
1209 } else {
1210 if (status != ACPI_STA_ALL)
1211 continue;
1212 retval = acpiphp_enable_slot(slot);
1213 if (retval) {
1214 err("Error occurred in enabling\n");
1215 goto err_exit;
1216 }
1217 enabled++;
1218 }
1219 }
1220
1221 dbg("%s: %d enabled, %d disabled\n", __func__, enabled, disabled);
1222
1223 err_exit:
1224 return retval;
1225}
1226
1227static void acpiphp_set_hpp_values(struct pci_bus *bus)
1228{
1229 struct pci_dev *dev;
1230
1231 list_for_each_entry(dev, &bus->devices, bus_list)
1232 pci_configure_slot(dev);
1233}
1234
1235
1236
1237
1238
1239static void acpiphp_sanitize_bus(struct pci_bus *bus)
1240{
1241 struct pci_dev *dev;
1242 int i;
1243 unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM;
1244
1245 list_for_each_entry(dev, &bus->devices, bus_list) {
1246 for (i=0; i<PCI_BRIDGE_RESOURCES; i++) {
1247 struct resource *res = &dev->resource[i];
1248 if ((res->flags & type_mask) && !res->start &&
1249 res->end) {
1250
1251
1252 pci_remove_bus_device(dev);
1253 break;
1254 }
1255 }
1256 }
1257}
1258
1259
1260static int acpiphp_configure_bridge (acpi_handle handle)
1261{
1262 struct pci_bus *bus;
1263
1264 if (acpi_is_root_bridge(handle)) {
1265 struct acpi_pci_root *root = acpi_pci_find_root(handle);
1266 bus = root->bus;
1267 } else {
1268 struct pci_dev *pdev = acpi_get_pci_dev(handle);
1269 bus = pdev->subordinate;
1270 pci_dev_put(pdev);
1271 }
1272
1273 pci_bus_size_bridges(bus);
1274 pci_bus_assign_resources(bus);
1275 acpiphp_sanitize_bus(bus);
1276 acpiphp_set_hpp_values(bus);
1277 pci_enable_bridges(bus);
1278 acpiphp_configure_ioapics(handle);
1279 return 0;
1280}
1281
1282static void handle_bridge_insertion(acpi_handle handle, u32 type)
1283{
1284 struct acpi_device *device, *pdevice;
1285 acpi_handle phandle;
1286
1287 if ((type != ACPI_NOTIFY_BUS_CHECK) &&
1288 (type != ACPI_NOTIFY_DEVICE_CHECK)) {
1289 err("unexpected notification type %d\n", type);
1290 return;
1291 }
1292
1293 acpi_get_parent(handle, &phandle);
1294 if (acpi_bus_get_device(phandle, &pdevice)) {
1295 dbg("no parent device, assuming NULL\n");
1296 pdevice = NULL;
1297 }
1298 if (acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE)) {
1299 err("cannot add bridge to acpi list\n");
1300 return;
1301 }
1302 if (!acpiphp_configure_bridge(handle) &&
1303 !acpi_bus_start(device))
1304 add_bridge(handle);
1305 else
1306 err("cannot configure and start bridge\n");
1307
1308}
1309
1310
1311
1312
1313
1314static acpi_status
1315count_sub_bridges(acpi_handle handle, u32 lvl, void *context, void **rv)
1316{
1317 int *count = (int *)context;
1318 struct acpiphp_bridge *bridge;
1319
1320 bridge = acpiphp_handle_to_bridge(handle);
1321 if (bridge)
1322 (*count)++;
1323 return AE_OK ;
1324}
1325
1326static acpi_status
1327check_sub_bridges(acpi_handle handle, u32 lvl, void *context, void **rv)
1328{
1329 struct acpiphp_bridge *bridge;
1330 char objname[64];
1331 struct acpi_buffer buffer = { .length = sizeof(objname),
1332 .pointer = objname };
1333
1334 bridge = acpiphp_handle_to_bridge(handle);
1335 if (bridge) {
1336 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1337 dbg("%s: re-enumerating slots under %s\n",
1338 __func__, objname);
1339 acpiphp_check_bridge(bridge);
1340 }
1341 return AE_OK ;
1342}
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352static void handle_hotplug_event_bridge(acpi_handle handle, u32 type, void *context)
1353{
1354 struct acpiphp_bridge *bridge;
1355 char objname[64];
1356 struct acpi_buffer buffer = { .length = sizeof(objname),
1357 .pointer = objname };
1358 struct acpi_device *device;
1359 int num_sub_bridges = 0;
1360
1361 if (acpi_bus_get_device(handle, &device)) {
1362
1363 handle_bridge_insertion(handle, type);
1364 return;
1365 }
1366
1367 bridge = acpiphp_handle_to_bridge(handle);
1368 if (type == ACPI_NOTIFY_BUS_CHECK) {
1369 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, ACPI_UINT32_MAX,
1370 count_sub_bridges, &num_sub_bridges, NULL);
1371 }
1372
1373 if (!bridge && !num_sub_bridges) {
1374 err("cannot get bridge info\n");
1375 return;
1376 }
1377
1378 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1379
1380 switch (type) {
1381 case ACPI_NOTIFY_BUS_CHECK:
1382
1383 dbg("%s: Bus check notify on %s\n", __func__, objname);
1384 if (bridge) {
1385 dbg("%s: re-enumerating slots under %s\n",
1386 __func__, objname);
1387 acpiphp_check_bridge(bridge);
1388 }
1389 if (num_sub_bridges)
1390 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
1391 ACPI_UINT32_MAX, check_sub_bridges, NULL, NULL);
1392 break;
1393
1394 case ACPI_NOTIFY_DEVICE_CHECK:
1395
1396 dbg("%s: Device check notify on %s\n", __func__, objname);
1397 acpiphp_check_bridge(bridge);
1398 break;
1399
1400 case ACPI_NOTIFY_DEVICE_WAKE:
1401
1402 dbg("%s: Device wake notify on %s\n", __func__, objname);
1403 break;
1404
1405 case ACPI_NOTIFY_EJECT_REQUEST:
1406
1407 dbg("%s: Device eject notify on %s\n", __func__, objname);
1408 if ((bridge->type != BRIDGE_TYPE_HOST) &&
1409 (bridge->flags & BRIDGE_HAS_EJ0)) {
1410 struct acpiphp_slot *slot;
1411 slot = bridge->func->slot;
1412 if (!acpiphp_disable_slot(slot))
1413 acpiphp_eject_slot(slot);
1414 }
1415 break;
1416
1417 case ACPI_NOTIFY_FREQUENCY_MISMATCH:
1418 printk(KERN_ERR "Device %s cannot be configured due"
1419 " to a frequency mismatch\n", objname);
1420 break;
1421
1422 case ACPI_NOTIFY_BUS_MODE_MISMATCH:
1423 printk(KERN_ERR "Device %s cannot be configured due"
1424 " to a bus mode mismatch\n", objname);
1425 break;
1426
1427 case ACPI_NOTIFY_POWER_FAULT:
1428 printk(KERN_ERR "Device %s has suffered a power fault\n",
1429 objname);
1430 break;
1431
1432 default:
1433 warn("notify_handler: unknown event type 0x%x for %s\n", type, objname);
1434 break;
1435 }
1436}
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446static void handle_hotplug_event_func(acpi_handle handle, u32 type, void *context)
1447{
1448 struct acpiphp_func *func;
1449 char objname[64];
1450 struct acpi_buffer buffer = { .length = sizeof(objname),
1451 .pointer = objname };
1452
1453 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1454
1455 func = (struct acpiphp_func *)context;
1456
1457 switch (type) {
1458 case ACPI_NOTIFY_BUS_CHECK:
1459
1460 dbg("%s: Bus check notify on %s\n", __func__, objname);
1461 acpiphp_enable_slot(func->slot);
1462 break;
1463
1464 case ACPI_NOTIFY_DEVICE_CHECK:
1465
1466 dbg("%s: Device check notify on %s\n", __func__, objname);
1467 acpiphp_check_bridge(func->slot->bridge);
1468 break;
1469
1470 case ACPI_NOTIFY_DEVICE_WAKE:
1471
1472 dbg("%s: Device wake notify on %s\n", __func__, objname);
1473 break;
1474
1475 case ACPI_NOTIFY_EJECT_REQUEST:
1476
1477 dbg("%s: Device eject notify on %s\n", __func__, objname);
1478 if (!(acpiphp_disable_slot(func->slot)))
1479 acpiphp_eject_slot(func->slot);
1480 break;
1481
1482 default:
1483 warn("notify_handler: unknown event type 0x%x for %s\n", type, objname);
1484 break;
1485 }
1486}
1487
1488
1489static acpi_status
1490find_root_bridges(acpi_handle handle, u32 lvl, void *context, void **rv)
1491{
1492 int *count = (int *)context;
1493
1494 if (acpi_is_root_bridge(handle)) {
1495 acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
1496 handle_hotplug_event_bridge, NULL);
1497 (*count)++;
1498 }
1499 return AE_OK ;
1500}
1501
1502static struct acpi_pci_driver acpi_pci_hp_driver = {
1503 .add = add_bridge,
1504 .remove = remove_bridge,
1505};
1506
1507
1508
1509
1510int __init acpiphp_glue_init(void)
1511{
1512 int num = 0;
1513
1514 acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
1515 ACPI_UINT32_MAX, find_root_bridges, &num, NULL);
1516
1517 if (num <= 0)
1518 return -1;
1519 else
1520 acpi_pci_register_driver(&acpi_pci_hp_driver);
1521
1522 return 0;
1523}
1524
1525
1526
1527
1528
1529
1530
1531void acpiphp_glue_exit(void)
1532{
1533 acpi_pci_unregister_driver(&acpi_pci_hp_driver);
1534}
1535
1536
1537
1538
1539
1540int __init acpiphp_get_num_slots(void)
1541{
1542 struct acpiphp_bridge *bridge;
1543 int num_slots = 0;
1544
1545 list_for_each_entry (bridge, &bridge_list, list) {
1546 dbg("Bus %04x:%02x has %d slot%s\n",
1547 pci_domain_nr(bridge->pci_bus),
1548 bridge->pci_bus->number, bridge->nr_slots,
1549 bridge->nr_slots == 1 ? "" : "s");
1550 num_slots += bridge->nr_slots;
1551 }
1552
1553 dbg("Total %d slots\n", num_slots);
1554 return num_slots;
1555}
1556
1557
1558#if 0
1559
1560
1561
1562
1563
1564static int acpiphp_for_each_slot(acpiphp_callback fn, void *data)
1565{
1566 struct list_head *node;
1567 struct acpiphp_bridge *bridge;
1568 struct acpiphp_slot *slot;
1569 int retval = 0;
1570
1571 list_for_each (node, &bridge_list) {
1572 bridge = (struct acpiphp_bridge *)node;
1573 for (slot = bridge->slots; slot; slot = slot->next) {
1574 retval = fn(slot, data);
1575 if (!retval)
1576 goto err_exit;
1577 }
1578 }
1579
1580 err_exit:
1581 return retval;
1582}
1583#endif
1584
1585
1586
1587
1588
1589
1590int acpiphp_enable_slot(struct acpiphp_slot *slot)
1591{
1592 int retval;
1593
1594 mutex_lock(&slot->crit_sect);
1595
1596
1597 retval = power_on_slot(slot);
1598 if (retval)
1599 goto err_exit;
1600
1601 if (get_slot_status(slot) == ACPI_STA_ALL) {
1602
1603 retval = enable_device(slot);
1604 if (retval)
1605 power_off_slot(slot);
1606 } else {
1607 dbg("%s: Slot status is not ACPI_STA_ALL\n", __func__);
1608 power_off_slot(slot);
1609 }
1610
1611 err_exit:
1612 mutex_unlock(&slot->crit_sect);
1613 return retval;
1614}
1615
1616
1617
1618
1619
1620int acpiphp_disable_slot(struct acpiphp_slot *slot)
1621{
1622 int retval = 0;
1623
1624 mutex_lock(&slot->crit_sect);
1625
1626
1627 retval = disable_device(slot);
1628 if (retval)
1629 goto err_exit;
1630
1631
1632 retval = power_off_slot(slot);
1633 if (retval)
1634 goto err_exit;
1635
1636 err_exit:
1637 mutex_unlock(&slot->crit_sect);
1638 return retval;
1639}
1640
1641
1642
1643
1644
1645
1646u8 acpiphp_get_power_status(struct acpiphp_slot *slot)
1647{
1648 return (slot->flags & SLOT_POWEREDON);
1649}
1650
1651
1652
1653
1654
1655
1656u8 acpiphp_get_latch_status(struct acpiphp_slot *slot)
1657{
1658 unsigned int sta;
1659
1660 sta = get_slot_status(slot);
1661
1662 return (sta & ACPI_STA_SHOW_IN_UI) ? 0 : 1;
1663}
1664
1665
1666
1667
1668
1669
1670u8 acpiphp_get_adapter_status(struct acpiphp_slot *slot)
1671{
1672 unsigned int sta;
1673
1674 sta = get_slot_status(slot);
1675
1676 return (sta == 0) ? 0 : 1;
1677}
1678