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#define pr_fmt(fmt) "acpiphp_glue: " fmt
43
44#include <linux/module.h>
45
46#include <linux/kernel.h>
47#include <linux/pci.h>
48#include <linux/pci_hotplug.h>
49#include <linux/pci-acpi.h>
50#include <linux/pm_runtime.h>
51#include <linux/mutex.h>
52#include <linux/slab.h>
53#include <linux/acpi.h>
54
55#include "../pci.h"
56#include "acpiphp.h"
57
58static LIST_HEAD(bridge_list);
59static DEFINE_MUTEX(bridge_mutex);
60
61static int acpiphp_hotplug_notify(struct acpi_device *adev, u32 type);
62static void acpiphp_post_dock_fixup(struct acpi_device *adev);
63static void acpiphp_sanitize_bus(struct pci_bus *bus);
64static void hotplug_event(u32 type, struct acpiphp_context *context);
65static void free_bridge(struct kref *kref);
66
67
68
69
70
71
72
73static struct acpiphp_context *acpiphp_init_context(struct acpi_device *adev)
74{
75 struct acpiphp_context *context;
76
77 context = kzalloc(sizeof(*context), GFP_KERNEL);
78 if (!context)
79 return NULL;
80
81 context->refcount = 1;
82 context->hp.notify = acpiphp_hotplug_notify;
83 context->hp.fixup = acpiphp_post_dock_fixup;
84 acpi_set_hp_context(adev, &context->hp);
85 return context;
86}
87
88
89
90
91
92
93
94static struct acpiphp_context *acpiphp_get_context(struct acpi_device *adev)
95{
96 struct acpiphp_context *context;
97
98 if (!adev->hp)
99 return NULL;
100
101 context = to_acpiphp_context(adev->hp);
102 context->refcount++;
103 return context;
104}
105
106
107
108
109
110
111
112
113
114static void acpiphp_put_context(struct acpiphp_context *context)
115{
116 if (--context->refcount)
117 return;
118
119 WARN_ON(context->bridge);
120 context->hp.self->hp = NULL;
121 kfree(context);
122}
123
124static inline void get_bridge(struct acpiphp_bridge *bridge)
125{
126 kref_get(&bridge->ref);
127}
128
129static inline void put_bridge(struct acpiphp_bridge *bridge)
130{
131 kref_put(&bridge->ref, free_bridge);
132}
133
134static struct acpiphp_context *acpiphp_grab_context(struct acpi_device *adev)
135{
136 struct acpiphp_context *context;
137
138 acpi_lock_hp_context();
139 context = acpiphp_get_context(adev);
140 if (!context || context->func.parent->is_going_away) {
141 acpi_unlock_hp_context();
142 return NULL;
143 }
144 get_bridge(context->func.parent);
145 acpiphp_put_context(context);
146 acpi_unlock_hp_context();
147 return context;
148}
149
150static void acpiphp_let_context_go(struct acpiphp_context *context)
151{
152 put_bridge(context->func.parent);
153}
154
155static void free_bridge(struct kref *kref)
156{
157 struct acpiphp_context *context;
158 struct acpiphp_bridge *bridge;
159 struct acpiphp_slot *slot, *next;
160 struct acpiphp_func *func, *tmp;
161
162 acpi_lock_hp_context();
163
164 bridge = container_of(kref, struct acpiphp_bridge, ref);
165
166 list_for_each_entry_safe(slot, next, &bridge->slots, node) {
167 list_for_each_entry_safe(func, tmp, &slot->funcs, sibling)
168 acpiphp_put_context(func_to_context(func));
169
170 kfree(slot);
171 }
172
173 context = bridge->context;
174
175 if (context) {
176
177 put_bridge(context->func.parent);
178 context->bridge = NULL;
179 acpiphp_put_context(context);
180 }
181
182 put_device(&bridge->pci_bus->dev);
183 pci_dev_put(bridge->pci_dev);
184 kfree(bridge);
185
186 acpi_unlock_hp_context();
187}
188
189
190
191
192
193
194
195static void acpiphp_post_dock_fixup(struct acpi_device *adev)
196{
197 struct acpiphp_context *context = acpiphp_grab_context(adev);
198 struct pci_bus *bus;
199 u32 buses;
200
201 if (!context)
202 return;
203
204 bus = context->func.slot->bus;
205 if (!bus->self)
206 goto out;
207
208
209
210
211 pci_read_config_dword(bus->self, PCI_PRIMARY_BUS, &buses);
212
213 if (((buses >> 8) & 0xff) != bus->busn_res.start) {
214 buses = (buses & 0xff000000)
215 | ((unsigned int)(bus->primary) << 0)
216 | ((unsigned int)(bus->busn_res.start) << 8)
217 | ((unsigned int)(bus->busn_res.end) << 16);
218 pci_write_config_dword(bus->self, PCI_PRIMARY_BUS, buses);
219 }
220
221 out:
222 acpiphp_let_context_go(context);
223}
224
225
226static bool device_is_managed_by_native_pciehp(struct pci_dev *pdev)
227{
228 u32 reg32;
229 acpi_handle tmp;
230 struct acpi_pci_root *root;
231
232
233 if (pcie_capability_read_dword(pdev, PCI_EXP_SLTCAP, ®32))
234 return false;
235 if (!(reg32 & PCI_EXP_SLTCAP_HPC))
236 return false;
237
238
239
240
241
242 tmp = acpi_find_root_bridge_handle(pdev);
243 if (!tmp)
244 return false;
245 root = acpi_pci_find_root(tmp);
246 if (!root)
247 return false;
248 if (!(root->osc_control_set & OSC_PCI_EXPRESS_NATIVE_HP_CONTROL))
249 return false;
250
251 return true;
252}
253
254
255
256
257
258
259
260
261static acpi_status acpiphp_add_context(acpi_handle handle, u32 lvl, void *data,
262 void **rv)
263{
264 struct acpiphp_bridge *bridge = data;
265 struct acpiphp_context *context;
266 struct acpi_device *adev;
267 struct acpiphp_slot *slot;
268 struct acpiphp_func *newfunc;
269 acpi_status status = AE_OK;
270 unsigned long long adr;
271 int device, function;
272 struct pci_bus *pbus = bridge->pci_bus;
273 struct pci_dev *pdev = bridge->pci_dev;
274 u32 val;
275
276 status = acpi_evaluate_integer(handle, "_ADR", NULL, &adr);
277 if (ACPI_FAILURE(status)) {
278 if (status != AE_NOT_FOUND)
279 acpi_handle_warn(handle,
280 "can't evaluate _ADR (%#x)\n", status);
281 return AE_OK;
282 }
283 if (acpi_bus_get_device(handle, &adev))
284 return AE_OK;
285
286 device = (adr >> 16) & 0xffff;
287 function = adr & 0xffff;
288
289 acpi_lock_hp_context();
290 context = acpiphp_init_context(adev);
291 if (!context) {
292 acpi_unlock_hp_context();
293 acpi_handle_err(handle, "No hotplug context\n");
294 return AE_NOT_EXIST;
295 }
296 newfunc = &context->func;
297 newfunc->function = function;
298 newfunc->parent = bridge;
299 acpi_unlock_hp_context();
300
301
302
303
304
305 if (!is_dock_device(adev) && acpi_has_method(handle, "_EJ0"))
306 newfunc->flags = FUNC_HAS_EJ0;
307
308 if (acpi_has_method(handle, "_STA"))
309 newfunc->flags |= FUNC_HAS_STA;
310
311
312 list_for_each_entry(slot, &bridge->slots, node)
313 if (slot->device == device)
314 goto slot_found;
315
316 slot = kzalloc(sizeof(struct acpiphp_slot), GFP_KERNEL);
317 if (!slot) {
318 acpi_lock_hp_context();
319 acpiphp_put_context(context);
320 acpi_unlock_hp_context();
321 return AE_NO_MEMORY;
322 }
323
324 slot->bus = bridge->pci_bus;
325 slot->device = device;
326 INIT_LIST_HEAD(&slot->funcs);
327
328 list_add_tail(&slot->node, &bridge->slots);
329
330
331
332
333
334
335
336 if ((acpi_pci_check_ejectable(pbus, handle) || is_dock_device(adev))
337 && !(pdev && device_is_managed_by_native_pciehp(pdev))) {
338 unsigned long long sun;
339 int retval;
340
341 bridge->nr_slots++;
342 status = acpi_evaluate_integer(handle, "_SUN", NULL, &sun);
343 if (ACPI_FAILURE(status))
344 sun = bridge->nr_slots;
345
346 pr_debug("found ACPI PCI Hotplug slot %llu at PCI %04x:%02x:%02x\n",
347 sun, pci_domain_nr(pbus), pbus->number, device);
348
349 retval = acpiphp_register_hotplug_slot(slot, sun);
350 if (retval) {
351 slot->slot = NULL;
352 bridge->nr_slots--;
353 if (retval == -EBUSY)
354 pr_warn("Slot %llu already registered by another hotplug driver\n", sun);
355 else
356 pr_warn("acpiphp_register_hotplug_slot failed (err code = 0x%x)\n", retval);
357 }
358
359 }
360
361 slot_found:
362 newfunc->slot = slot;
363 list_add_tail(&newfunc->sibling, &slot->funcs);
364
365 if (pci_bus_read_dev_vendor_id(pbus, PCI_DEVFN(device, function),
366 &val, 60*1000))
367 slot->flags |= SLOT_ENABLED;
368
369 return AE_OK;
370}
371
372static void cleanup_bridge(struct acpiphp_bridge *bridge)
373{
374 struct acpiphp_slot *slot;
375 struct acpiphp_func *func;
376
377 list_for_each_entry(slot, &bridge->slots, node) {
378 list_for_each_entry(func, &slot->funcs, sibling) {
379 struct acpi_device *adev = func_to_acpi_device(func);
380
381 acpi_lock_hp_context();
382 adev->hp->notify = NULL;
383 adev->hp->fixup = NULL;
384 acpi_unlock_hp_context();
385 }
386 slot->flags |= SLOT_IS_GOING_AWAY;
387 if (slot->slot)
388 acpiphp_unregister_hotplug_slot(slot);
389 }
390
391 mutex_lock(&bridge_mutex);
392 list_del(&bridge->list);
393 mutex_unlock(&bridge_mutex);
394
395 acpi_lock_hp_context();
396 bridge->is_going_away = true;
397 acpi_unlock_hp_context();
398}
399
400
401
402
403
404static unsigned char acpiphp_max_busnr(struct pci_bus *bus)
405{
406 struct pci_bus *tmp;
407 unsigned char max, n;
408
409
410
411
412
413
414
415
416
417 max = bus->busn_res.start;
418
419 list_for_each_entry(tmp, &bus->children, node) {
420 n = pci_bus_max_busnr(tmp);
421 if (n > max)
422 max = n;
423 }
424 return max;
425}
426
427static void acpiphp_set_acpi_region(struct acpiphp_slot *slot)
428{
429 struct acpiphp_func *func;
430 union acpi_object params[2];
431 struct acpi_object_list arg_list;
432
433 list_for_each_entry(func, &slot->funcs, sibling) {
434 arg_list.count = 2;
435 arg_list.pointer = params;
436 params[0].type = ACPI_TYPE_INTEGER;
437 params[0].integer.value = ACPI_ADR_SPACE_PCI_CONFIG;
438 params[1].type = ACPI_TYPE_INTEGER;
439 params[1].integer.value = 1;
440
441 acpi_evaluate_object(func_to_handle(func), "_REG", &arg_list,
442 NULL);
443 }
444}
445
446static void check_hotplug_bridge(struct acpiphp_slot *slot, struct pci_dev *dev)
447{
448 struct acpiphp_func *func;
449
450
451 if (dev->is_hotplug_bridge)
452 return;
453
454 list_for_each_entry(func, &slot->funcs, sibling) {
455 if (PCI_FUNC(dev->devfn) == func->function) {
456 dev->is_hotplug_bridge = 1;
457 break;
458 }
459 }
460}
461
462static int acpiphp_rescan_slot(struct acpiphp_slot *slot)
463{
464 struct acpiphp_func *func;
465
466 list_for_each_entry(func, &slot->funcs, sibling) {
467 struct acpi_device *adev = func_to_acpi_device(func);
468
469 acpi_bus_scan(adev->handle);
470 if (acpi_device_enumerated(adev))
471 acpi_device_set_power(adev, ACPI_STATE_D0);
472 }
473 return pci_scan_slot(slot->bus, PCI_DEVFN(slot->device, 0));
474}
475
476
477
478
479
480
481
482
483static void enable_slot(struct acpiphp_slot *slot)
484{
485 struct pci_dev *dev;
486 struct pci_bus *bus = slot->bus;
487 struct acpiphp_func *func;
488 int max, pass;
489 LIST_HEAD(add_list);
490
491 acpiphp_rescan_slot(slot);
492 max = acpiphp_max_busnr(bus);
493 for (pass = 0; pass < 2; pass++) {
494 list_for_each_entry(dev, &bus->devices, bus_list) {
495 if (PCI_SLOT(dev->devfn) != slot->device)
496 continue;
497
498 if (pci_is_bridge(dev)) {
499 max = pci_scan_bridge(bus, dev, max, pass);
500 if (pass && dev->subordinate) {
501 check_hotplug_bridge(slot, dev);
502 pcibios_resource_survey_bus(dev->subordinate);
503 __pci_bus_size_bridges(dev->subordinate,
504 &add_list);
505 }
506 }
507 }
508 }
509 __pci_bus_assign_resources(bus, &add_list, NULL);
510
511 acpiphp_sanitize_bus(bus);
512 pcie_bus_configure_settings(bus);
513 acpiphp_set_acpi_region(slot);
514
515 list_for_each_entry(dev, &bus->devices, bus_list) {
516
517 if (!dev->is_added)
518 dev->current_state = PCI_D0;
519 }
520
521 pci_bus_add_devices(bus);
522
523 slot->flags |= SLOT_ENABLED;
524 list_for_each_entry(func, &slot->funcs, sibling) {
525 dev = pci_get_slot(bus, PCI_DEVFN(slot->device,
526 func->function));
527 if (!dev) {
528
529
530 slot->flags &= (~SLOT_ENABLED);
531 continue;
532 }
533 }
534}
535
536
537
538
539
540static void disable_slot(struct acpiphp_slot *slot)
541{
542 struct pci_bus *bus = slot->bus;
543 struct pci_dev *dev, *prev;
544 struct acpiphp_func *func;
545
546
547
548
549
550
551
552 list_for_each_entry_safe_reverse(dev, prev, &bus->devices, bus_list)
553 if (PCI_SLOT(dev->devfn) == slot->device)
554 pci_stop_and_remove_bus_device(dev);
555
556 list_for_each_entry(func, &slot->funcs, sibling)
557 acpi_bus_trim(func_to_acpi_device(func));
558
559 slot->flags &= (~SLOT_ENABLED);
560}
561
562static bool slot_no_hotplug(struct acpiphp_slot *slot)
563{
564 struct pci_bus *bus = slot->bus;
565 struct pci_dev *dev;
566
567 list_for_each_entry(dev, &bus->devices, bus_list) {
568 if (PCI_SLOT(dev->devfn) == slot->device && dev->ignore_hotplug)
569 return true;
570 }
571 return false;
572}
573
574
575
576
577
578
579
580
581
582
583
584
585
586static unsigned int get_slot_status(struct acpiphp_slot *slot)
587{
588 unsigned long long sta = 0;
589 struct acpiphp_func *func;
590
591 list_for_each_entry(func, &slot->funcs, sibling) {
592 if (func->flags & FUNC_HAS_STA) {
593 acpi_status status;
594
595 status = acpi_evaluate_integer(func_to_handle(func),
596 "_STA", NULL, &sta);
597 if (ACPI_SUCCESS(status) && sta)
598 break;
599 } else {
600 u32 dvid;
601
602 pci_bus_read_config_dword(slot->bus,
603 PCI_DEVFN(slot->device,
604 func->function),
605 PCI_VENDOR_ID, &dvid);
606 if (dvid != 0xffffffff) {
607 sta = ACPI_STA_ALL;
608 break;
609 }
610 }
611 }
612
613 return (unsigned int)sta;
614}
615
616static inline bool device_status_valid(unsigned int sta)
617{
618
619
620
621
622
623 unsigned int mask = ACPI_STA_DEVICE_ENABLED | ACPI_STA_DEVICE_FUNCTIONING;
624 return (sta & mask) == mask;
625}
626
627
628
629
630
631static void trim_stale_devices(struct pci_dev *dev)
632{
633 struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
634 struct pci_bus *bus = dev->subordinate;
635 bool alive = false;
636
637 if (adev) {
638 acpi_status status;
639 unsigned long long sta;
640
641 status = acpi_evaluate_integer(adev->handle, "_STA", NULL, &sta);
642 alive = (ACPI_SUCCESS(status) && device_status_valid(sta))
643 || dev->ignore_hotplug;
644 }
645 if (!alive)
646 alive = pci_device_is_present(dev);
647
648 if (!alive) {
649 pci_stop_and_remove_bus_device(dev);
650 if (adev)
651 acpi_bus_trim(adev);
652 } else if (bus) {
653 struct pci_dev *child, *tmp;
654
655
656 pm_runtime_get_sync(&dev->dev);
657 list_for_each_entry_safe_reverse(child, tmp, &bus->devices, bus_list)
658 trim_stale_devices(child);
659
660 pm_runtime_put(&dev->dev);
661 }
662}
663
664
665
666
667
668
669
670
671static void acpiphp_check_bridge(struct acpiphp_bridge *bridge)
672{
673 struct acpiphp_slot *slot;
674
675
676 if (bridge->is_going_away)
677 return;
678
679 list_for_each_entry(slot, &bridge->slots, node) {
680 struct pci_bus *bus = slot->bus;
681 struct pci_dev *dev, *tmp;
682
683 if (slot_no_hotplug(slot)) {
684 ;
685 } else if (device_status_valid(get_slot_status(slot))) {
686
687 list_for_each_entry_safe_reverse(dev, tmp,
688 &bus->devices, bus_list)
689 if (PCI_SLOT(dev->devfn) == slot->device)
690 trim_stale_devices(dev);
691
692
693 enable_slot(slot);
694 } else {
695 disable_slot(slot);
696 }
697 }
698}
699
700
701
702
703
704static void acpiphp_sanitize_bus(struct pci_bus *bus)
705{
706 struct pci_dev *dev, *tmp;
707 int i;
708 unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM;
709
710 list_for_each_entry_safe_reverse(dev, tmp, &bus->devices, bus_list) {
711 for (i=0; i<PCI_BRIDGE_RESOURCES; i++) {
712 struct resource *res = &dev->resource[i];
713 if ((res->flags & type_mask) && !res->start &&
714 res->end) {
715
716
717 pci_stop_and_remove_bus_device(dev);
718 break;
719 }
720 }
721 }
722}
723
724
725
726
727
728void acpiphp_check_host_bridge(struct acpi_device *adev)
729{
730 struct acpiphp_bridge *bridge = NULL;
731
732 acpi_lock_hp_context();
733 if (adev->hp) {
734 bridge = to_acpiphp_root_context(adev->hp)->root_bridge;
735 if (bridge)
736 get_bridge(bridge);
737 }
738 acpi_unlock_hp_context();
739 if (bridge) {
740 pci_lock_rescan_remove();
741
742 acpiphp_check_bridge(bridge);
743
744 pci_unlock_rescan_remove();
745 put_bridge(bridge);
746 }
747}
748
749static int acpiphp_disable_and_eject_slot(struct acpiphp_slot *slot);
750
751static void hotplug_event(u32 type, struct acpiphp_context *context)
752{
753 acpi_handle handle = context->hp.self->handle;
754 struct acpiphp_func *func = &context->func;
755 struct acpiphp_slot *slot = func->slot;
756 struct acpiphp_bridge *bridge;
757
758 acpi_lock_hp_context();
759 bridge = context->bridge;
760 if (bridge)
761 get_bridge(bridge);
762
763 acpi_unlock_hp_context();
764
765 pci_lock_rescan_remove();
766
767 switch (type) {
768 case ACPI_NOTIFY_BUS_CHECK:
769
770 acpi_handle_debug(handle, "Bus check in %s()\n", __func__);
771 if (bridge)
772 acpiphp_check_bridge(bridge);
773 else if (!(slot->flags & SLOT_IS_GOING_AWAY))
774 enable_slot(slot);
775
776 break;
777
778 case ACPI_NOTIFY_DEVICE_CHECK:
779
780 acpi_handle_debug(handle, "Device check in %s()\n", __func__);
781 if (bridge) {
782 acpiphp_check_bridge(bridge);
783 } else if (!(slot->flags & SLOT_IS_GOING_AWAY)) {
784
785
786
787
788 if (acpiphp_rescan_slot(slot))
789 acpiphp_check_bridge(func->parent);
790 }
791 break;
792
793 case ACPI_NOTIFY_EJECT_REQUEST:
794
795 acpi_handle_debug(handle, "Eject request in %s()\n", __func__);
796 acpiphp_disable_and_eject_slot(slot);
797 break;
798 }
799
800 pci_unlock_rescan_remove();
801 if (bridge)
802 put_bridge(bridge);
803}
804
805static int acpiphp_hotplug_notify(struct acpi_device *adev, u32 type)
806{
807 struct acpiphp_context *context;
808
809 context = acpiphp_grab_context(adev);
810 if (!context)
811 return -ENODATA;
812
813 hotplug_event(type, context);
814 acpiphp_let_context_go(context);
815 return 0;
816}
817
818
819
820
821
822
823
824
825void acpiphp_enumerate_slots(struct pci_bus *bus)
826{
827 struct acpiphp_bridge *bridge;
828 struct acpi_device *adev;
829 acpi_handle handle;
830 acpi_status status;
831
832 if (acpiphp_disabled)
833 return;
834
835 adev = ACPI_COMPANION(bus->bridge);
836 if (!adev)
837 return;
838
839 handle = adev->handle;
840 bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL);
841 if (!bridge) {
842 acpi_handle_err(handle, "No memory for bridge object\n");
843 return;
844 }
845
846 INIT_LIST_HEAD(&bridge->slots);
847 kref_init(&bridge->ref);
848 bridge->pci_dev = pci_dev_get(bus->self);
849 bridge->pci_bus = bus;
850
851
852
853
854
855
856 get_device(&bus->dev);
857
858 acpi_lock_hp_context();
859 if (pci_is_root_bus(bridge->pci_bus)) {
860 struct acpiphp_root_context *root_context;
861
862 root_context = kzalloc(sizeof(*root_context), GFP_KERNEL);
863 if (!root_context)
864 goto err;
865
866 root_context->root_bridge = bridge;
867 acpi_set_hp_context(adev, &root_context->hp);
868 } else {
869 struct acpiphp_context *context;
870
871
872
873
874
875
876
877 context = acpiphp_get_context(adev);
878 if (!context)
879 goto err;
880
881 bridge->context = context;
882 context->bridge = bridge;
883
884 get_bridge(context->func.parent);
885 }
886 acpi_unlock_hp_context();
887
888
889 mutex_lock(&bridge_mutex);
890 list_add(&bridge->list, &bridge_list);
891 mutex_unlock(&bridge_mutex);
892
893
894 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
895 acpiphp_add_context, NULL, bridge, NULL);
896 if (ACPI_FAILURE(status)) {
897 acpi_handle_err(handle, "failed to register slots\n");
898 cleanup_bridge(bridge);
899 put_bridge(bridge);
900 }
901 return;
902
903 err:
904 acpi_unlock_hp_context();
905 put_device(&bus->dev);
906 pci_dev_put(bridge->pci_dev);
907 kfree(bridge);
908}
909
910static void acpiphp_drop_bridge(struct acpiphp_bridge *bridge)
911{
912 if (pci_is_root_bus(bridge->pci_bus)) {
913 struct acpiphp_root_context *root_context;
914 struct acpi_device *adev;
915
916 acpi_lock_hp_context();
917 adev = ACPI_COMPANION(bridge->pci_bus->bridge);
918 root_context = to_acpiphp_root_context(adev->hp);
919 adev->hp = NULL;
920 acpi_unlock_hp_context();
921 kfree(root_context);
922 }
923 cleanup_bridge(bridge);
924 put_bridge(bridge);
925}
926
927
928
929
930
931void acpiphp_remove_slots(struct pci_bus *bus)
932{
933 struct acpiphp_bridge *bridge;
934
935 if (acpiphp_disabled)
936 return;
937
938 mutex_lock(&bridge_mutex);
939 list_for_each_entry(bridge, &bridge_list, list)
940 if (bridge->pci_bus == bus) {
941 mutex_unlock(&bridge_mutex);
942 acpiphp_drop_bridge(bridge);
943 return;
944 }
945
946 mutex_unlock(&bridge_mutex);
947}
948
949
950
951
952
953int acpiphp_enable_slot(struct acpiphp_slot *slot)
954{
955 pci_lock_rescan_remove();
956
957 if (slot->flags & SLOT_IS_GOING_AWAY)
958 return -ENODEV;
959
960
961 if (!(slot->flags & SLOT_ENABLED))
962 enable_slot(slot);
963
964 pci_unlock_rescan_remove();
965 return 0;
966}
967
968
969
970
971
972static int acpiphp_disable_and_eject_slot(struct acpiphp_slot *slot)
973{
974 struct acpiphp_func *func;
975
976 if (slot->flags & SLOT_IS_GOING_AWAY)
977 return -ENODEV;
978
979
980 disable_slot(slot);
981
982 list_for_each_entry(func, &slot->funcs, sibling)
983 if (func->flags & FUNC_HAS_EJ0) {
984 acpi_handle handle = func_to_handle(func);
985
986 if (ACPI_FAILURE(acpi_evaluate_ej0(handle)))
987 acpi_handle_err(handle, "_EJ0 failed\n");
988
989 break;
990 }
991
992 return 0;
993}
994
995int acpiphp_disable_slot(struct acpiphp_slot *slot)
996{
997 int ret;
998
999
1000
1001
1002
1003 acpi_scan_lock_acquire();
1004 pci_lock_rescan_remove();
1005 ret = acpiphp_disable_and_eject_slot(slot);
1006 pci_unlock_rescan_remove();
1007 acpi_scan_lock_release();
1008 return ret;
1009}
1010
1011
1012
1013
1014
1015u8 acpiphp_get_power_status(struct acpiphp_slot *slot)
1016{
1017 return (slot->flags & SLOT_ENABLED);
1018}
1019
1020
1021
1022
1023
1024u8 acpiphp_get_latch_status(struct acpiphp_slot *slot)
1025{
1026 return !(get_slot_status(slot) & ACPI_STA_DEVICE_UI);
1027}
1028
1029
1030
1031
1032
1033u8 acpiphp_get_adapter_status(struct acpiphp_slot *slot)
1034{
1035 return !!get_slot_status(slot);
1036}
1037