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