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