1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * ACPI PCI HotPlug glue functions to ACPI CA subsystem |
4 | * |
5 | * Copyright (C) 2002,2003 Takayoshi Kochi (t-kochi@bq.jp.nec.com) |
6 | * Copyright (C) 2002 Hiroshi Aono (h-aono@ap.jp.nec.com) |
7 | * Copyright (C) 2002,2003 NEC Corporation |
8 | * Copyright (C) 2003-2005 Matthew Wilcox (willy@infradead.org) |
9 | * Copyright (C) 2003-2005 Hewlett Packard |
10 | * Copyright (C) 2005 Rajesh Shah (rajesh.shah@intel.com) |
11 | * Copyright (C) 2005 Intel Corporation |
12 | * |
13 | * All rights reserved. |
14 | * |
15 | * Send feedback to <kristen.c.accardi@intel.com> |
16 | * |
17 | */ |
18 | |
19 | /* |
20 | * Lifetime rules for pci_dev: |
21 | * - The one in acpiphp_bridge has its refcount elevated by pci_get_slot() |
22 | * when the bridge is scanned and it loses a refcount when the bridge |
23 | * is removed. |
24 | * - When a P2P bridge is present, we elevate the refcount on the subordinate |
25 | * bus. It loses the refcount when the driver unloads. |
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 | * acpiphp_init_context - Create hotplug context and grab a reference to it. |
55 | * @adev: ACPI device object to create the context for. |
56 | * |
57 | * Call under acpi_hp_context_lock. |
58 | */ |
59 | static struct acpiphp_context *acpiphp_init_context(struct acpi_device *adev) |
60 | { |
61 | struct acpiphp_context *context; |
62 | |
63 | context = kzalloc(size: 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, hp: &context->hp); |
71 | return context; |
72 | } |
73 | |
74 | /** |
75 | * acpiphp_get_context - Get hotplug context and grab a reference to it. |
76 | * @adev: ACPI device object to get the context for. |
77 | * |
78 | * Call under acpi_hp_context_lock. |
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(hp: adev->hp); |
88 | context->refcount++; |
89 | return context; |
90 | } |
91 | |
92 | /** |
93 | * acpiphp_put_context - Drop a reference to ACPI hotplug context. |
94 | * @context: ACPI hotplug context to drop a reference to. |
95 | * |
96 | * The context object is removed if there are no more references to it. |
97 | * |
98 | * Call under acpi_hp_context_lock. |
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(objp: context); |
108 | } |
109 | |
110 | static inline void get_bridge(struct acpiphp_bridge *bridge) |
111 | { |
112 | kref_get(kref: &bridge->ref); |
113 | } |
114 | |
115 | static inline void put_bridge(struct acpiphp_bridge *bridge) |
116 | { |
117 | kref_put(kref: &bridge->ref, release: 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 | |
126 | context = acpiphp_get_context(adev); |
127 | if (!context) |
128 | goto unlock; |
129 | |
130 | if (context->func.parent->is_going_away) { |
131 | acpiphp_put_context(context); |
132 | context = NULL; |
133 | goto unlock; |
134 | } |
135 | |
136 | get_bridge(bridge: context->func.parent); |
137 | acpiphp_put_context(context); |
138 | |
139 | unlock: |
140 | acpi_unlock_hp_context(); |
141 | return context; |
142 | } |
143 | |
144 | static void acpiphp_let_context_go(struct acpiphp_context *context) |
145 | { |
146 | put_bridge(bridge: context->func.parent); |
147 | } |
148 | |
149 | static void free_bridge(struct kref *kref) |
150 | { |
151 | struct acpiphp_context *context; |
152 | struct acpiphp_bridge *bridge; |
153 | struct acpiphp_slot *slot, *next; |
154 | struct acpiphp_func *func, *tmp; |
155 | |
156 | acpi_lock_hp_context(); |
157 | |
158 | bridge = container_of(kref, struct acpiphp_bridge, ref); |
159 | |
160 | list_for_each_entry_safe(slot, next, &bridge->slots, node) { |
161 | list_for_each_entry_safe(func, tmp, &slot->funcs, sibling) |
162 | acpiphp_put_context(context: func_to_context(func)); |
163 | |
164 | kfree(objp: slot); |
165 | } |
166 | |
167 | context = bridge->context; |
168 | /* Root bridges will not have hotplug context. */ |
169 | if (context) { |
170 | /* Release the reference taken by acpiphp_enumerate_slots(). */ |
171 | put_bridge(bridge: context->func.parent); |
172 | context->bridge = NULL; |
173 | acpiphp_put_context(context); |
174 | } |
175 | |
176 | put_device(dev: &bridge->pci_bus->dev); |
177 | pci_dev_put(dev: bridge->pci_dev); |
178 | kfree(objp: bridge); |
179 | |
180 | acpi_unlock_hp_context(); |
181 | } |
182 | |
183 | /** |
184 | * acpiphp_post_dock_fixup - Post-dock fixups for PCI devices. |
185 | * @adev: ACPI device object corresponding to a PCI device. |
186 | * |
187 | * TBD - figure out a way to only call fixups for systems that require them. |
188 | */ |
189 | static void acpiphp_post_dock_fixup(struct acpi_device *adev) |
190 | { |
191 | struct acpiphp_context *context = acpiphp_grab_context(adev); |
192 | struct pci_bus *bus; |
193 | u32 buses; |
194 | |
195 | if (!context) |
196 | return; |
197 | |
198 | bus = context->func.slot->bus; |
199 | if (!bus->self) |
200 | goto out; |
201 | |
202 | /* fixup bad _DCK function that rewrites |
203 | * secondary bridge on slot |
204 | */ |
205 | pci_read_config_dword(dev: bus->self, PCI_PRIMARY_BUS, val: &buses); |
206 | |
207 | if (((buses >> 8) & 0xff) != bus->busn_res.start) { |
208 | buses = (buses & 0xff000000) |
209 | | ((unsigned int)(bus->primary) << 0) |
210 | | ((unsigned int)(bus->busn_res.start) << 8) |
211 | | ((unsigned int)(bus->busn_res.end) << 16); |
212 | pci_write_config_dword(dev: bus->self, PCI_PRIMARY_BUS, val: buses); |
213 | } |
214 | |
215 | out: |
216 | acpiphp_let_context_go(context); |
217 | } |
218 | |
219 | /** |
220 | * acpiphp_add_context - Add ACPIPHP context to an ACPI device object. |
221 | * @handle: ACPI handle of the object to add a context to. |
222 | * @lvl: Not used. |
223 | * @data: The object's parent ACPIPHP bridge. |
224 | * @rv: Not used. |
225 | */ |
226 | static acpi_status acpiphp_add_context(acpi_handle handle, u32 lvl, void *data, |
227 | void **rv) |
228 | { |
229 | struct acpi_device *adev = acpi_fetch_acpi_dev(handle); |
230 | struct acpiphp_bridge *bridge = data; |
231 | struct acpiphp_context *context; |
232 | struct acpiphp_slot *slot; |
233 | struct acpiphp_func *newfunc; |
234 | acpi_status status = AE_OK; |
235 | unsigned long long adr; |
236 | int device, function; |
237 | struct pci_bus *pbus = bridge->pci_bus; |
238 | struct pci_dev *pdev = bridge->pci_dev; |
239 | u32 val; |
240 | |
241 | if (!adev) |
242 | return AE_OK; |
243 | |
244 | status = acpi_evaluate_integer(handle, pathname: "_ADR" , NULL, data: &adr); |
245 | if (ACPI_FAILURE(status)) { |
246 | if (status != AE_NOT_FOUND) |
247 | acpi_handle_warn(handle, |
248 | "can't evaluate _ADR (%#x)\n" , status); |
249 | return AE_OK; |
250 | } |
251 | |
252 | device = (adr >> 16) & 0xffff; |
253 | function = adr & 0xffff; |
254 | |
255 | acpi_lock_hp_context(); |
256 | context = acpiphp_init_context(adev); |
257 | if (!context) { |
258 | acpi_unlock_hp_context(); |
259 | acpi_handle_err(handle, "No hotplug context\n" ); |
260 | return AE_NOT_EXIST; |
261 | } |
262 | newfunc = &context->func; |
263 | newfunc->function = function; |
264 | newfunc->parent = bridge; |
265 | acpi_unlock_hp_context(); |
266 | |
267 | /* |
268 | * If this is a dock device, its _EJ0 should be executed by the dock |
269 | * notify handler after calling _DCK. |
270 | */ |
271 | if (!is_dock_device(adev) && acpi_has_method(handle, name: "_EJ0" )) |
272 | newfunc->flags = FUNC_HAS_EJ0; |
273 | |
274 | if (acpi_has_method(handle, name: "_STA" )) |
275 | newfunc->flags |= FUNC_HAS_STA; |
276 | |
277 | /* search for objects that share the same slot */ |
278 | list_for_each_entry(slot, &bridge->slots, node) |
279 | if (slot->device == device) |
280 | goto slot_found; |
281 | |
282 | slot = kzalloc(size: sizeof(struct acpiphp_slot), GFP_KERNEL); |
283 | if (!slot) { |
284 | acpi_lock_hp_context(); |
285 | acpiphp_put_context(context); |
286 | acpi_unlock_hp_context(); |
287 | return AE_NO_MEMORY; |
288 | } |
289 | |
290 | slot->bus = bridge->pci_bus; |
291 | slot->device = device; |
292 | INIT_LIST_HEAD(list: &slot->funcs); |
293 | |
294 | list_add_tail(new: &slot->node, head: &bridge->slots); |
295 | |
296 | /* |
297 | * Expose slots to user space for functions that have _EJ0 or _RMV or |
298 | * are located in dock stations. Do not expose them for devices handled |
299 | * by the native PCIe hotplug (PCIeHP) or standard PCI hotplug |
300 | * (SHPCHP), because that code is supposed to expose slots to user |
301 | * space in those cases. |
302 | */ |
303 | if ((acpi_pci_check_ejectable(pbus, handle) || is_dock_device(adev)) |
304 | && !(pdev && hotplug_is_native(bridge: pdev))) { |
305 | unsigned long long sun; |
306 | int retval; |
307 | |
308 | bridge->nr_slots++; |
309 | status = acpi_evaluate_integer(handle, pathname: "_SUN" , NULL, data: &sun); |
310 | if (ACPI_FAILURE(status)) |
311 | sun = bridge->nr_slots; |
312 | |
313 | pr_debug("found ACPI PCI Hotplug slot %llu at PCI %04x:%02x:%02x\n" , |
314 | sun, pci_domain_nr(pbus), pbus->number, device); |
315 | |
316 | retval = acpiphp_register_hotplug_slot(slot, sun); |
317 | if (retval) { |
318 | slot->slot = NULL; |
319 | bridge->nr_slots--; |
320 | if (retval == -EBUSY) |
321 | pr_warn("Slot %llu already registered by another hotplug driver\n" , sun); |
322 | else |
323 | pr_warn("acpiphp_register_hotplug_slot failed (err code = 0x%x)\n" , retval); |
324 | } |
325 | /* Even if the slot registration fails, we can still use it. */ |
326 | } |
327 | |
328 | slot_found: |
329 | newfunc->slot = slot; |
330 | list_add_tail(new: &newfunc->sibling, head: &slot->funcs); |
331 | |
332 | if (pci_bus_read_dev_vendor_id(bus: pbus, PCI_DEVFN(device, function), |
333 | pl: &val, crs_timeout: 60*1000)) |
334 | slot->flags |= SLOT_ENABLED; |
335 | |
336 | return AE_OK; |
337 | } |
338 | |
339 | static void cleanup_bridge(struct acpiphp_bridge *bridge) |
340 | { |
341 | struct acpiphp_slot *slot; |
342 | struct acpiphp_func *func; |
343 | |
344 | list_for_each_entry(slot, &bridge->slots, node) { |
345 | list_for_each_entry(func, &slot->funcs, sibling) { |
346 | struct acpi_device *adev = func_to_acpi_device(func); |
347 | |
348 | acpi_lock_hp_context(); |
349 | adev->hp->notify = NULL; |
350 | adev->hp->fixup = NULL; |
351 | acpi_unlock_hp_context(); |
352 | } |
353 | slot->flags |= SLOT_IS_GOING_AWAY; |
354 | if (slot->slot) |
355 | acpiphp_unregister_hotplug_slot(slot); |
356 | } |
357 | |
358 | mutex_lock(&bridge_mutex); |
359 | list_del(entry: &bridge->list); |
360 | mutex_unlock(lock: &bridge_mutex); |
361 | |
362 | acpi_lock_hp_context(); |
363 | bridge->is_going_away = true; |
364 | acpi_unlock_hp_context(); |
365 | } |
366 | |
367 | /** |
368 | * acpiphp_max_busnr - return the highest reserved bus number under the given bus. |
369 | * @bus: bus to start search with |
370 | */ |
371 | static unsigned char acpiphp_max_busnr(struct pci_bus *bus) |
372 | { |
373 | struct pci_bus *tmp; |
374 | unsigned char max, n; |
375 | |
376 | /* |
377 | * pci_bus_max_busnr will return the highest |
378 | * reserved busnr for all these children. |
379 | * that is equivalent to the bus->subordinate |
380 | * value. We don't want to use the parent's |
381 | * bus->subordinate value because it could have |
382 | * padding in it. |
383 | */ |
384 | max = bus->busn_res.start; |
385 | |
386 | list_for_each_entry(tmp, &bus->children, node) { |
387 | n = pci_bus_max_busnr(bus: tmp); |
388 | if (n > max) |
389 | max = n; |
390 | } |
391 | return max; |
392 | } |
393 | |
394 | static void acpiphp_set_acpi_region(struct acpiphp_slot *slot) |
395 | { |
396 | struct acpiphp_func *func; |
397 | |
398 | list_for_each_entry(func, &slot->funcs, sibling) { |
399 | /* _REG is optional, we don't care about if there is failure */ |
400 | acpi_evaluate_reg(handle: func_to_handle(func), |
401 | ACPI_ADR_SPACE_PCI_CONFIG, |
402 | ACPI_REG_CONNECT); |
403 | } |
404 | } |
405 | |
406 | static void check_hotplug_bridge(struct acpiphp_slot *slot, struct pci_dev *dev) |
407 | { |
408 | struct acpiphp_func *func; |
409 | |
410 | /* quirk, or pcie could set it already */ |
411 | if (dev->is_hotplug_bridge) |
412 | return; |
413 | |
414 | /* |
415 | * In the PCIe case, only Root Ports and Downstream Ports are capable of |
416 | * accommodating hotplug devices, so avoid marking Upstream Ports as |
417 | * "hotplug bridges". |
418 | */ |
419 | if (pci_is_pcie(dev) && pci_pcie_type(dev) == PCI_EXP_TYPE_UPSTREAM) |
420 | return; |
421 | |
422 | list_for_each_entry(func, &slot->funcs, sibling) { |
423 | if (PCI_FUNC(dev->devfn) == func->function) { |
424 | dev->is_hotplug_bridge = 1; |
425 | break; |
426 | } |
427 | } |
428 | } |
429 | |
430 | static int acpiphp_rescan_slot(struct acpiphp_slot *slot) |
431 | { |
432 | struct acpiphp_func *func; |
433 | |
434 | list_for_each_entry(func, &slot->funcs, sibling) { |
435 | struct acpi_device *adev = func_to_acpi_device(func); |
436 | |
437 | acpi_bus_scan(handle: adev->handle); |
438 | if (acpi_device_enumerated(adev)) |
439 | acpi_device_set_power(device: adev, ACPI_STATE_D0); |
440 | } |
441 | return pci_scan_slot(bus: slot->bus, PCI_DEVFN(slot->device, 0)); |
442 | } |
443 | |
444 | static void acpiphp_native_scan_bridge(struct pci_dev *bridge) |
445 | { |
446 | struct pci_bus *bus = bridge->subordinate; |
447 | struct pci_dev *dev; |
448 | int max; |
449 | |
450 | if (!bus) |
451 | return; |
452 | |
453 | max = bus->busn_res.start; |
454 | /* Scan already configured non-hotplug bridges */ |
455 | for_each_pci_bridge(dev, bus) { |
456 | if (!hotplug_is_native(bridge: dev)) |
457 | max = pci_scan_bridge(bus, dev, max, pass: 0); |
458 | } |
459 | |
460 | /* Scan non-hotplug bridges that need to be reconfigured */ |
461 | for_each_pci_bridge(dev, bus) { |
462 | if (hotplug_is_native(bridge: dev)) |
463 | continue; |
464 | |
465 | max = pci_scan_bridge(bus, dev, max, pass: 1); |
466 | if (dev->subordinate) { |
467 | pcibios_resource_survey_bus(bus: dev->subordinate); |
468 | pci_bus_size_bridges(bus: dev->subordinate); |
469 | pci_bus_assign_resources(bus: dev->subordinate); |
470 | } |
471 | } |
472 | } |
473 | |
474 | /** |
475 | * enable_slot - enable, configure a slot |
476 | * @slot: slot to be enabled |
477 | * @bridge: true if enable is for the whole bridge (not a single slot) |
478 | * |
479 | * This function should be called per *physical slot*, |
480 | * not per each slot object in ACPI namespace. |
481 | */ |
482 | static void enable_slot(struct acpiphp_slot *slot, bool bridge) |
483 | { |
484 | struct pci_dev *dev; |
485 | struct pci_bus *bus = slot->bus; |
486 | struct acpiphp_func *func; |
487 | |
488 | if (bridge && bus->self && hotplug_is_native(bridge: bus->self)) { |
489 | /* |
490 | * If native hotplug is used, it will take care of hotplug |
491 | * slot management and resource allocation for hotplug |
492 | * bridges. However, ACPI hotplug may still be used for |
493 | * non-hotplug bridges to bring in additional devices such |
494 | * as a Thunderbolt host controller. |
495 | */ |
496 | for_each_pci_bridge(dev, bus) { |
497 | if (PCI_SLOT(dev->devfn) == slot->device) |
498 | acpiphp_native_scan_bridge(bridge: dev); |
499 | } |
500 | } else { |
501 | LIST_HEAD(add_list); |
502 | int max, pass; |
503 | |
504 | acpiphp_rescan_slot(slot); |
505 | max = acpiphp_max_busnr(bus); |
506 | for (pass = 0; pass < 2; pass++) { |
507 | for_each_pci_bridge(dev, bus) { |
508 | if (PCI_SLOT(dev->devfn) != slot->device) |
509 | continue; |
510 | |
511 | max = pci_scan_bridge(bus, dev, max, pass); |
512 | if (pass && dev->subordinate) { |
513 | check_hotplug_bridge(slot, dev); |
514 | pcibios_resource_survey_bus(bus: dev->subordinate); |
515 | __pci_bus_size_bridges(bus: dev->subordinate, |
516 | realloc_head: &add_list); |
517 | } |
518 | } |
519 | } |
520 | __pci_bus_assign_resources(bus, realloc_head: &add_list, NULL); |
521 | } |
522 | |
523 | acpiphp_sanitize_bus(bus); |
524 | pcie_bus_configure_settings(bus); |
525 | acpiphp_set_acpi_region(slot); |
526 | |
527 | list_for_each_entry(dev, &bus->devices, bus_list) { |
528 | /* Assume that newly added devices are powered on already. */ |
529 | if (!pci_dev_is_added(dev)) |
530 | dev->current_state = PCI_D0; |
531 | } |
532 | |
533 | pci_bus_add_devices(bus); |
534 | |
535 | slot->flags |= SLOT_ENABLED; |
536 | list_for_each_entry(func, &slot->funcs, sibling) { |
537 | dev = pci_get_slot(bus, PCI_DEVFN(slot->device, |
538 | func->function)); |
539 | if (!dev) { |
540 | /* Do not set SLOT_ENABLED flag if some funcs |
541 | are not added. */ |
542 | slot->flags &= ~SLOT_ENABLED; |
543 | continue; |
544 | } |
545 | pci_dev_put(dev); |
546 | } |
547 | } |
548 | |
549 | /** |
550 | * disable_slot - disable a slot |
551 | * @slot: ACPI PHP slot |
552 | */ |
553 | static void disable_slot(struct acpiphp_slot *slot) |
554 | { |
555 | struct pci_bus *bus = slot->bus; |
556 | struct pci_dev *dev, *prev; |
557 | struct acpiphp_func *func; |
558 | |
559 | /* |
560 | * enable_slot() enumerates all functions in this device via |
561 | * pci_scan_slot(), whether they have associated ACPI hotplug |
562 | * methods (_EJ0, etc.) or not. Therefore, we remove all functions |
563 | * here. |
564 | */ |
565 | list_for_each_entry_safe_reverse(dev, prev, &bus->devices, bus_list) |
566 | if (PCI_SLOT(dev->devfn) == slot->device) |
567 | pci_stop_and_remove_bus_device(dev); |
568 | |
569 | list_for_each_entry(func, &slot->funcs, sibling) |
570 | acpi_bus_trim(start: func_to_acpi_device(func)); |
571 | |
572 | slot->flags &= ~SLOT_ENABLED; |
573 | } |
574 | |
575 | static bool slot_no_hotplug(struct acpiphp_slot *slot) |
576 | { |
577 | struct pci_bus *bus = slot->bus; |
578 | struct pci_dev *dev; |
579 | |
580 | list_for_each_entry(dev, &bus->devices, bus_list) { |
581 | if (PCI_SLOT(dev->devfn) == slot->device && dev->ignore_hotplug) |
582 | return true; |
583 | } |
584 | return false; |
585 | } |
586 | |
587 | /** |
588 | * get_slot_status - get ACPI slot status |
589 | * @slot: ACPI PHP slot |
590 | * |
591 | * If a slot has _STA for each function and if any one of them |
592 | * returned non-zero status, return it. |
593 | * |
594 | * If a slot doesn't have _STA and if any one of its functions' |
595 | * configuration space is configured, return 0x0f as a _STA. |
596 | * |
597 | * Otherwise return 0. |
598 | */ |
599 | static unsigned int get_slot_status(struct acpiphp_slot *slot) |
600 | { |
601 | unsigned long long sta = 0; |
602 | struct acpiphp_func *func; |
603 | u32 dvid; |
604 | |
605 | list_for_each_entry(func, &slot->funcs, sibling) { |
606 | if (func->flags & FUNC_HAS_STA) { |
607 | acpi_status status; |
608 | |
609 | status = acpi_evaluate_integer(handle: func_to_handle(func), |
610 | pathname: "_STA" , NULL, data: &sta); |
611 | if (ACPI_SUCCESS(status) && sta) |
612 | break; |
613 | } else { |
614 | if (pci_bus_read_dev_vendor_id(bus: slot->bus, |
615 | PCI_DEVFN(slot->device, func->function), |
616 | pl: &dvid, crs_timeout: 0)) { |
617 | sta = ACPI_STA_ALL; |
618 | break; |
619 | } |
620 | } |
621 | } |
622 | |
623 | if (!sta) { |
624 | /* |
625 | * Check for the slot itself since it may be that the |
626 | * ACPI slot is a device below PCIe upstream port so in |
627 | * that case it may not even be reachable yet. |
628 | */ |
629 | if (pci_bus_read_dev_vendor_id(bus: slot->bus, |
630 | PCI_DEVFN(slot->device, 0), pl: &dvid, crs_timeout: 0)) { |
631 | sta = ACPI_STA_ALL; |
632 | } |
633 | } |
634 | |
635 | return (unsigned int)sta; |
636 | } |
637 | |
638 | static inline bool device_status_valid(unsigned int sta) |
639 | { |
640 | /* |
641 | * ACPI spec says that _STA may return bit 0 clear with bit 3 set |
642 | * if the device is valid but does not require a device driver to be |
643 | * loaded (Section 6.3.7 of ACPI 5.0A). |
644 | */ |
645 | unsigned int mask = ACPI_STA_DEVICE_ENABLED | ACPI_STA_DEVICE_FUNCTIONING; |
646 | return (sta & mask) == mask; |
647 | } |
648 | |
649 | /** |
650 | * trim_stale_devices - remove PCI devices that are not responding. |
651 | * @dev: PCI device to start walking the hierarchy from. |
652 | */ |
653 | static void trim_stale_devices(struct pci_dev *dev) |
654 | { |
655 | struct acpi_device *adev = ACPI_COMPANION(&dev->dev); |
656 | struct pci_bus *bus = dev->subordinate; |
657 | bool alive = dev->ignore_hotplug; |
658 | |
659 | if (adev) { |
660 | acpi_status status; |
661 | unsigned long long sta; |
662 | |
663 | status = acpi_evaluate_integer(handle: adev->handle, pathname: "_STA" , NULL, data: &sta); |
664 | alive = alive || (ACPI_SUCCESS(status) && device_status_valid(sta)); |
665 | } |
666 | if (!alive) |
667 | alive = pci_device_is_present(pdev: dev); |
668 | |
669 | if (!alive) { |
670 | pci_dev_set_disconnected(dev, NULL); |
671 | if (pci_has_subordinate(pci_dev: dev)) |
672 | pci_walk_bus(top: dev->subordinate, cb: pci_dev_set_disconnected, |
673 | NULL); |
674 | |
675 | pci_stop_and_remove_bus_device(dev); |
676 | if (adev) |
677 | acpi_bus_trim(start: adev); |
678 | } else if (bus) { |
679 | struct pci_dev *child, *tmp; |
680 | |
681 | /* The device is a bridge. so check the bus below it. */ |
682 | pm_runtime_get_sync(dev: &dev->dev); |
683 | list_for_each_entry_safe_reverse(child, tmp, &bus->devices, bus_list) |
684 | trim_stale_devices(dev: child); |
685 | |
686 | pm_runtime_put(dev: &dev->dev); |
687 | } |
688 | } |
689 | |
690 | /** |
691 | * acpiphp_check_bridge - re-enumerate devices |
692 | * @bridge: where to begin re-enumeration |
693 | * |
694 | * Iterate over all slots under this bridge and make sure that if a |
695 | * card is present they are enabled, and if not they are disabled. |
696 | */ |
697 | static void acpiphp_check_bridge(struct acpiphp_bridge *bridge) |
698 | { |
699 | struct acpiphp_slot *slot; |
700 | |
701 | /* Bail out if the bridge is going away. */ |
702 | if (bridge->is_going_away) |
703 | return; |
704 | |
705 | if (bridge->pci_dev) |
706 | pm_runtime_get_sync(dev: &bridge->pci_dev->dev); |
707 | |
708 | list_for_each_entry(slot, &bridge->slots, node) { |
709 | struct pci_bus *bus = slot->bus; |
710 | struct pci_dev *dev, *tmp; |
711 | |
712 | if (slot_no_hotplug(slot)) { |
713 | ; /* do nothing */ |
714 | } else if (device_status_valid(sta: get_slot_status(slot))) { |
715 | /* remove stale devices if any */ |
716 | list_for_each_entry_safe_reverse(dev, tmp, |
717 | &bus->devices, bus_list) |
718 | if (PCI_SLOT(dev->devfn) == slot->device) |
719 | trim_stale_devices(dev); |
720 | |
721 | /* configure all functions */ |
722 | enable_slot(slot, bridge: true); |
723 | } else { |
724 | disable_slot(slot); |
725 | } |
726 | } |
727 | |
728 | if (bridge->pci_dev) |
729 | pm_runtime_put(dev: &bridge->pci_dev->dev); |
730 | } |
731 | |
732 | /* |
733 | * Remove devices for which we could not assign resources, call |
734 | * arch specific code to fix-up the bus |
735 | */ |
736 | static void acpiphp_sanitize_bus(struct pci_bus *bus) |
737 | { |
738 | struct pci_dev *dev, *tmp; |
739 | int i; |
740 | unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM; |
741 | |
742 | list_for_each_entry_safe_reverse(dev, tmp, &bus->devices, bus_list) { |
743 | for (i = 0; i < PCI_BRIDGE_RESOURCES; i++) { |
744 | struct resource *res = &dev->resource[i]; |
745 | if ((res->flags & type_mask) && !res->start && |
746 | res->end) { |
747 | /* Could not assign a required resources |
748 | * for this device, remove it */ |
749 | pci_stop_and_remove_bus_device(dev); |
750 | break; |
751 | } |
752 | } |
753 | } |
754 | } |
755 | |
756 | /* |
757 | * ACPI event handlers |
758 | */ |
759 | |
760 | void acpiphp_check_host_bridge(struct acpi_device *adev) |
761 | { |
762 | struct acpiphp_bridge *bridge = NULL; |
763 | |
764 | acpi_lock_hp_context(); |
765 | if (adev->hp) { |
766 | bridge = to_acpiphp_root_context(hp: adev->hp)->root_bridge; |
767 | if (bridge) |
768 | get_bridge(bridge); |
769 | } |
770 | acpi_unlock_hp_context(); |
771 | if (bridge) { |
772 | pci_lock_rescan_remove(); |
773 | |
774 | acpiphp_check_bridge(bridge); |
775 | |
776 | pci_unlock_rescan_remove(); |
777 | put_bridge(bridge); |
778 | } |
779 | } |
780 | |
781 | static int acpiphp_disable_and_eject_slot(struct acpiphp_slot *slot); |
782 | |
783 | static void hotplug_event(u32 type, struct acpiphp_context *context) |
784 | { |
785 | acpi_handle handle = context->hp.self->handle; |
786 | struct acpiphp_func *func = &context->func; |
787 | struct acpiphp_slot *slot = func->slot; |
788 | struct acpiphp_bridge *bridge; |
789 | |
790 | acpi_lock_hp_context(); |
791 | bridge = context->bridge; |
792 | if (bridge) |
793 | get_bridge(bridge); |
794 | |
795 | acpi_unlock_hp_context(); |
796 | |
797 | pci_lock_rescan_remove(); |
798 | |
799 | switch (type) { |
800 | case ACPI_NOTIFY_BUS_CHECK: |
801 | /* bus re-enumerate */ |
802 | acpi_handle_debug(handle, "Bus check in %s()\n" , __func__); |
803 | if (bridge) |
804 | acpiphp_check_bridge(bridge); |
805 | else if (!(slot->flags & SLOT_IS_GOING_AWAY)) |
806 | enable_slot(slot, bridge: false); |
807 | |
808 | break; |
809 | |
810 | case ACPI_NOTIFY_DEVICE_CHECK: |
811 | /* device check */ |
812 | acpi_handle_debug(handle, "Device check in %s()\n" , __func__); |
813 | if (bridge) { |
814 | acpiphp_check_bridge(bridge); |
815 | } else if (!(slot->flags & SLOT_IS_GOING_AWAY)) { |
816 | /* |
817 | * Check if anything has changed in the slot and rescan |
818 | * from the parent if that's the case. |
819 | */ |
820 | if (acpiphp_rescan_slot(slot)) |
821 | acpiphp_check_bridge(bridge: func->parent); |
822 | } |
823 | break; |
824 | |
825 | case ACPI_NOTIFY_EJECT_REQUEST: |
826 | /* request device eject */ |
827 | acpi_handle_debug(handle, "Eject request in %s()\n" , __func__); |
828 | acpiphp_disable_and_eject_slot(slot); |
829 | break; |
830 | } |
831 | |
832 | pci_unlock_rescan_remove(); |
833 | if (bridge) |
834 | put_bridge(bridge); |
835 | } |
836 | |
837 | static int acpiphp_hotplug_notify(struct acpi_device *adev, u32 type) |
838 | { |
839 | struct acpiphp_context *context; |
840 | |
841 | context = acpiphp_grab_context(adev); |
842 | if (!context) |
843 | return -ENODATA; |
844 | |
845 | hotplug_event(type, context); |
846 | acpiphp_let_context_go(context); |
847 | return 0; |
848 | } |
849 | |
850 | /** |
851 | * acpiphp_enumerate_slots - Enumerate PCI slots for a given bus. |
852 | * @bus: PCI bus to enumerate the slots for. |
853 | * |
854 | * A "slot" is an object associated with a PCI device number. All functions |
855 | * (PCI devices) with the same bus and device number belong to the same slot. |
856 | */ |
857 | void acpiphp_enumerate_slots(struct pci_bus *bus) |
858 | { |
859 | struct acpiphp_bridge *bridge; |
860 | struct acpi_device *adev; |
861 | acpi_handle handle; |
862 | acpi_status status; |
863 | |
864 | if (acpiphp_disabled) |
865 | return; |
866 | |
867 | adev = ACPI_COMPANION(bus->bridge); |
868 | if (!adev) |
869 | return; |
870 | |
871 | handle = adev->handle; |
872 | bridge = kzalloc(size: sizeof(struct acpiphp_bridge), GFP_KERNEL); |
873 | if (!bridge) |
874 | return; |
875 | |
876 | INIT_LIST_HEAD(list: &bridge->slots); |
877 | kref_init(kref: &bridge->ref); |
878 | bridge->pci_dev = pci_dev_get(dev: bus->self); |
879 | bridge->pci_bus = bus; |
880 | |
881 | /* |
882 | * Grab a ref to the subordinate PCI bus in case the bus is |
883 | * removed via PCI core logical hotplug. The ref pins the bus |
884 | * (which we access during module unload). |
885 | */ |
886 | get_device(dev: &bus->dev); |
887 | |
888 | acpi_lock_hp_context(); |
889 | if (pci_is_root_bus(pbus: bridge->pci_bus)) { |
890 | struct acpiphp_root_context *root_context; |
891 | |
892 | root_context = kzalloc(size: sizeof(*root_context), GFP_KERNEL); |
893 | if (!root_context) |
894 | goto err; |
895 | |
896 | root_context->root_bridge = bridge; |
897 | acpi_set_hp_context(adev, hp: &root_context->hp); |
898 | } else { |
899 | struct acpiphp_context *context; |
900 | |
901 | /* |
902 | * This bridge should have been registered as a hotplug function |
903 | * under its parent, so the context should be there, unless the |
904 | * parent is going to be handled by pciehp, in which case this |
905 | * bridge is not interesting to us either. |
906 | */ |
907 | context = acpiphp_get_context(adev); |
908 | if (!context) |
909 | goto err; |
910 | |
911 | bridge->context = context; |
912 | context->bridge = bridge; |
913 | /* Get a reference to the parent bridge. */ |
914 | get_bridge(bridge: context->func.parent); |
915 | } |
916 | acpi_unlock_hp_context(); |
917 | |
918 | /* Must be added to the list prior to calling acpiphp_add_context(). */ |
919 | mutex_lock(&bridge_mutex); |
920 | list_add(new: &bridge->list, head: &bridge_list); |
921 | mutex_unlock(lock: &bridge_mutex); |
922 | |
923 | /* register all slot objects under this bridge */ |
924 | status = acpi_walk_namespace(ACPI_TYPE_DEVICE, start_object: handle, max_depth: 1, |
925 | descending_callback: acpiphp_add_context, NULL, context: bridge, NULL); |
926 | if (ACPI_FAILURE(status)) { |
927 | acpi_handle_err(handle, "failed to register slots\n" ); |
928 | cleanup_bridge(bridge); |
929 | put_bridge(bridge); |
930 | } |
931 | return; |
932 | |
933 | err: |
934 | acpi_unlock_hp_context(); |
935 | put_device(dev: &bus->dev); |
936 | pci_dev_put(dev: bridge->pci_dev); |
937 | kfree(objp: bridge); |
938 | } |
939 | |
940 | static void acpiphp_drop_bridge(struct acpiphp_bridge *bridge) |
941 | { |
942 | if (pci_is_root_bus(pbus: bridge->pci_bus)) { |
943 | struct acpiphp_root_context *root_context; |
944 | struct acpi_device *adev; |
945 | |
946 | acpi_lock_hp_context(); |
947 | adev = ACPI_COMPANION(bridge->pci_bus->bridge); |
948 | root_context = to_acpiphp_root_context(hp: adev->hp); |
949 | adev->hp = NULL; |
950 | acpi_unlock_hp_context(); |
951 | kfree(objp: root_context); |
952 | } |
953 | cleanup_bridge(bridge); |
954 | put_bridge(bridge); |
955 | } |
956 | |
957 | /** |
958 | * acpiphp_remove_slots - Remove slot objects associated with a given bus. |
959 | * @bus: PCI bus to remove the slot objects for. |
960 | */ |
961 | void acpiphp_remove_slots(struct pci_bus *bus) |
962 | { |
963 | struct acpiphp_bridge *bridge; |
964 | |
965 | if (acpiphp_disabled) |
966 | return; |
967 | |
968 | mutex_lock(&bridge_mutex); |
969 | list_for_each_entry(bridge, &bridge_list, list) |
970 | if (bridge->pci_bus == bus) { |
971 | mutex_unlock(lock: &bridge_mutex); |
972 | acpiphp_drop_bridge(bridge); |
973 | return; |
974 | } |
975 | |
976 | mutex_unlock(lock: &bridge_mutex); |
977 | } |
978 | |
979 | /** |
980 | * acpiphp_enable_slot - power on slot |
981 | * @slot: ACPI PHP slot |
982 | */ |
983 | int acpiphp_enable_slot(struct acpiphp_slot *slot) |
984 | { |
985 | pci_lock_rescan_remove(); |
986 | |
987 | if (slot->flags & SLOT_IS_GOING_AWAY) { |
988 | pci_unlock_rescan_remove(); |
989 | return -ENODEV; |
990 | } |
991 | |
992 | /* configure all functions */ |
993 | if (!(slot->flags & SLOT_ENABLED)) |
994 | enable_slot(slot, bridge: false); |
995 | |
996 | pci_unlock_rescan_remove(); |
997 | return 0; |
998 | } |
999 | |
1000 | /** |
1001 | * acpiphp_disable_and_eject_slot - power off and eject slot |
1002 | * @slot: ACPI PHP slot |
1003 | */ |
1004 | static int acpiphp_disable_and_eject_slot(struct acpiphp_slot *slot) |
1005 | { |
1006 | struct acpiphp_func *func; |
1007 | |
1008 | if (slot->flags & SLOT_IS_GOING_AWAY) |
1009 | return -ENODEV; |
1010 | |
1011 | /* unconfigure all functions */ |
1012 | disable_slot(slot); |
1013 | |
1014 | list_for_each_entry(func, &slot->funcs, sibling) |
1015 | if (func->flags & FUNC_HAS_EJ0) { |
1016 | acpi_handle handle = func_to_handle(func); |
1017 | |
1018 | if (ACPI_FAILURE(acpi_evaluate_ej0(handle))) |
1019 | acpi_handle_err(handle, "_EJ0 failed\n" ); |
1020 | |
1021 | break; |
1022 | } |
1023 | |
1024 | return 0; |
1025 | } |
1026 | |
1027 | int acpiphp_disable_slot(struct acpiphp_slot *slot) |
1028 | { |
1029 | int ret; |
1030 | |
1031 | /* |
1032 | * Acquire acpi_scan_lock to ensure that the execution of _EJ0 in |
1033 | * acpiphp_disable_and_eject_slot() will be synchronized properly. |
1034 | */ |
1035 | acpi_scan_lock_acquire(); |
1036 | pci_lock_rescan_remove(); |
1037 | ret = acpiphp_disable_and_eject_slot(slot); |
1038 | pci_unlock_rescan_remove(); |
1039 | acpi_scan_lock_release(); |
1040 | return ret; |
1041 | } |
1042 | |
1043 | /* |
1044 | * slot enabled: 1 |
1045 | * slot disabled: 0 |
1046 | */ |
1047 | u8 acpiphp_get_power_status(struct acpiphp_slot *slot) |
1048 | { |
1049 | return (slot->flags & SLOT_ENABLED); |
1050 | } |
1051 | |
1052 | /* |
1053 | * latch open: 1 |
1054 | * latch closed: 0 |
1055 | */ |
1056 | u8 acpiphp_get_latch_status(struct acpiphp_slot *slot) |
1057 | { |
1058 | return !(get_slot_status(slot) & ACPI_STA_DEVICE_UI); |
1059 | } |
1060 | |
1061 | /* |
1062 | * adapter presence : 1 |
1063 | * absence : 0 |
1064 | */ |
1065 | u8 acpiphp_get_adapter_status(struct acpiphp_slot *slot) |
1066 | { |
1067 | return !!get_slot_status(slot); |
1068 | } |
1069 | |