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