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