1 /*
2  * ACPI PCI HotPlug glue functions to ACPI CA subsystem
3  *
4  * Copyright (C) 2002,2003 Takayoshi Kochi (t-kochi@bq.jp.nec.com)
5  * Copyright (C) 2002 Hiroshi Aono (h-aono@ap.jp.nec.com)
6  * Copyright (C) 2002,2003 NEC Corporation
7  * Copyright (C) 2003-2005 Matthew Wilcox (matthew.wilcox@hp.com)
8  * Copyright (C) 2003-2005 Hewlett Packard
9  * Copyright (C) 2005 Rajesh Shah (rajesh.shah@intel.com)
10  * Copyright (C) 2005 Intel Corporation
11  *
12  * All rights reserved.
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or (at
17  * your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful, but
20  * WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
22  * NON INFRINGEMENT.  See the GNU General Public License for more
23  * details.
24  *
25  * You should have received a copy of the GNU General Public License
26  * along with this program; if not, write to the Free Software
27  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28  *
29  * Send feedback to <kristen.c.accardi@intel.com>
30  *
31  */
32 
33 /*
34  * Lifetime rules for pci_dev:
35  *  - The one in acpiphp_bridge has its refcount elevated by pci_get_slot()
36  *    when the bridge is scanned and it loses a refcount when the bridge
37  *    is removed.
38  *  - When a P2P bridge is present, we elevate the refcount on the subordinate
39  *    bus. It loses the refcount when the the driver unloads.
40  */
41 
42 #define pr_fmt(fmt) "acpiphp_glue: " fmt
43 
44 #include <linux/init.h>
45 #include <linux/module.h>
46 
47 #include <linux/kernel.h>
48 #include <linux/pci.h>
49 #include <linux/pci_hotplug.h>
50 #include <linux/pci-acpi.h>
51 #include <linux/pm_runtime.h>
52 #include <linux/mutex.h>
53 #include <linux/slab.h>
54 #include <linux/acpi.h>
55 
56 #include "../pci.h"
57 #include "acpiphp.h"
58 
59 static LIST_HEAD(bridge_list);
60 static DEFINE_MUTEX(bridge_mutex);
61 static DEFINE_MUTEX(acpiphp_context_lock);
62 
63 static void handle_hotplug_event(acpi_handle handle, u32 type, void *data);
64 static void acpiphp_sanitize_bus(struct pci_bus *bus);
65 static void acpiphp_set_hpp_values(struct pci_bus *bus);
66 static void hotplug_event(acpi_handle handle, u32 type, void *data);
67 static void free_bridge(struct kref *kref);
68 
69 static void acpiphp_context_handler(acpi_handle handle, void *context)
70 {
71 	/* Intentionally empty. */
72 }
73 
74 /**
75  * acpiphp_init_context - Create hotplug context and grab a reference to it.
76  * @handle: ACPI object handle to create the context for.
77  *
78  * Call under acpiphp_context_lock.
79  */
80 static struct acpiphp_context *acpiphp_init_context(acpi_handle handle)
81 {
82 	struct acpiphp_context *context;
83 	acpi_status status;
84 
85 	context = kzalloc(sizeof(*context), GFP_KERNEL);
86 	if (!context)
87 		return NULL;
88 
89 	context->handle = handle;
90 	context->refcount = 1;
91 	status = acpi_attach_data(handle, acpiphp_context_handler, context);
92 	if (ACPI_FAILURE(status)) {
93 		kfree(context);
94 		return NULL;
95 	}
96 	return context;
97 }
98 
99 /**
100  * acpiphp_get_context - Get hotplug context and grab a reference to it.
101  * @handle: ACPI object handle to get the context for.
102  *
103  * Call under acpiphp_context_lock.
104  */
105 static struct acpiphp_context *acpiphp_get_context(acpi_handle handle)
106 {
107 	struct acpiphp_context *context = NULL;
108 	acpi_status status;
109 	void *data;
110 
111 	status = acpi_get_data(handle, acpiphp_context_handler, &data);
112 	if (ACPI_SUCCESS(status)) {
113 		context = data;
114 		context->refcount++;
115 	}
116 	return context;
117 }
118 
119 /**
120  * acpiphp_put_context - Drop a reference to ACPI hotplug context.
121  * @handle: ACPI object handle to put the context for.
122  *
123  * The context object is removed if there are no more references to it.
124  *
125  * Call under acpiphp_context_lock.
126  */
127 static void acpiphp_put_context(struct acpiphp_context *context)
128 {
129 	if (--context->refcount)
130 		return;
131 
132 	WARN_ON(context->bridge);
133 	acpi_detach_data(context->handle, acpiphp_context_handler);
134 	kfree(context);
135 }
136 
137 static inline void get_bridge(struct acpiphp_bridge *bridge)
138 {
139 	kref_get(&bridge->ref);
140 }
141 
142 static inline void put_bridge(struct acpiphp_bridge *bridge)
143 {
144 	kref_put(&bridge->ref, free_bridge);
145 }
146 
147 static void free_bridge(struct kref *kref)
148 {
149 	struct acpiphp_context *context;
150 	struct acpiphp_bridge *bridge;
151 	struct acpiphp_slot *slot, *next;
152 	struct acpiphp_func *func, *tmp;
153 
154 	mutex_lock(&acpiphp_context_lock);
155 
156 	bridge = container_of(kref, struct acpiphp_bridge, ref);
157 
158 	list_for_each_entry_safe(slot, next, &bridge->slots, node) {
159 		list_for_each_entry_safe(func, tmp, &slot->funcs, sibling)
160 			acpiphp_put_context(func_to_context(func));
161 
162 		kfree(slot);
163 	}
164 
165 	context = bridge->context;
166 	/* Root bridges will not have hotplug context. */
167 	if (context) {
168 		/* Release the reference taken by acpiphp_enumerate_slots(). */
169 		put_bridge(context->func.parent);
170 		context->bridge = NULL;
171 		acpiphp_put_context(context);
172 	}
173 
174 	put_device(&bridge->pci_bus->dev);
175 	pci_dev_put(bridge->pci_dev);
176 	kfree(bridge);
177 
178 	mutex_unlock(&acpiphp_context_lock);
179 }
180 
181 /*
182  * the _DCK method can do funny things... and sometimes not
183  * hah-hah funny.
184  *
185  * TBD - figure out a way to only call fixups for
186  * systems that require them.
187  */
188 static void post_dock_fixups(acpi_handle not_used, u32 event, void *data)
189 {
190 	struct acpiphp_context *context = data;
191 	struct pci_bus *bus = context->func.slot->bus;
192 	u32 buses;
193 
194 	if (!bus->self)
195 		return;
196 
197 	/* fixup bad _DCK function that rewrites
198 	 * secondary bridge on slot
199 	 */
200 	pci_read_config_dword(bus->self,
201 			PCI_PRIMARY_BUS,
202 			&buses);
203 
204 	if (((buses >> 8) & 0xff) != bus->busn_res.start) {
205 		buses = (buses & 0xff000000)
206 			| ((unsigned int)(bus->primary)     <<  0)
207 			| ((unsigned int)(bus->busn_res.start)   <<  8)
208 			| ((unsigned int)(bus->busn_res.end) << 16);
209 		pci_write_config_dword(bus->self, PCI_PRIMARY_BUS, buses);
210 	}
211 }
212 
213 
214 static const struct acpi_dock_ops acpiphp_dock_ops = {
215 	.fixup = post_dock_fixups,
216 	.handler = hotplug_event,
217 };
218 
219 /* Check whether the PCI device is managed by native PCIe hotplug driver */
220 static bool device_is_managed_by_native_pciehp(struct pci_dev *pdev)
221 {
222 	u32 reg32;
223 	acpi_handle tmp;
224 	struct acpi_pci_root *root;
225 
226 	/* Check whether the PCIe port supports native PCIe hotplug */
227 	if (pcie_capability_read_dword(pdev, PCI_EXP_SLTCAP, &reg32))
228 		return false;
229 	if (!(reg32 & PCI_EXP_SLTCAP_HPC))
230 		return false;
231 
232 	/*
233 	 * Check whether native PCIe hotplug has been enabled for
234 	 * this PCIe hierarchy.
235 	 */
236 	tmp = acpi_find_root_bridge_handle(pdev);
237 	if (!tmp)
238 		return false;
239 	root = acpi_pci_find_root(tmp);
240 	if (!root)
241 		return false;
242 	if (!(root->osc_control_set & OSC_PCI_EXPRESS_NATIVE_HP_CONTROL))
243 		return false;
244 
245 	return true;
246 }
247 
248 static void acpiphp_dock_init(void *data)
249 {
250 	struct acpiphp_context *context = data;
251 
252 	get_bridge(context->func.parent);
253 }
254 
255 static void acpiphp_dock_release(void *data)
256 {
257 	struct acpiphp_context *context = data;
258 
259 	put_bridge(context->func.parent);
260 }
261 
262 /* callback routine to register each ACPI PCI slot object */
263 static acpi_status register_slot(acpi_handle handle, u32 lvl, void *data,
264 				 void **rv)
265 {
266 	struct acpiphp_bridge *bridge = data;
267 	struct acpiphp_context *context;
268 	struct acpiphp_slot *slot;
269 	struct acpiphp_func *newfunc;
270 	acpi_status status = AE_OK;
271 	unsigned long long adr;
272 	int device, function;
273 	struct pci_bus *pbus = bridge->pci_bus;
274 	struct pci_dev *pdev = bridge->pci_dev;
275 	u32 val;
276 
277 	if (pdev && device_is_managed_by_native_pciehp(pdev))
278 		return AE_OK;
279 
280 	status = acpi_evaluate_integer(handle, "_ADR", NULL, &adr);
281 	if (ACPI_FAILURE(status)) {
282 		if (status != AE_NOT_FOUND)
283 			acpi_handle_warn(handle,
284 				"can't evaluate _ADR (%#x)\n", status);
285 		return AE_OK;
286 	}
287 
288 	device = (adr >> 16) & 0xffff;
289 	function = adr & 0xffff;
290 
291 	mutex_lock(&acpiphp_context_lock);
292 	context = acpiphp_init_context(handle);
293 	if (!context) {
294 		mutex_unlock(&acpiphp_context_lock);
295 		acpi_handle_err(handle, "No hotplug context\n");
296 		return AE_NOT_EXIST;
297 	}
298 	newfunc = &context->func;
299 	newfunc->function = function;
300 	newfunc->parent = bridge;
301 	mutex_unlock(&acpiphp_context_lock);
302 
303 	if (acpi_has_method(handle, "_EJ0"))
304 		newfunc->flags = FUNC_HAS_EJ0;
305 
306 	if (acpi_has_method(handle, "_STA"))
307 		newfunc->flags |= FUNC_HAS_STA;
308 
309 	if (acpi_has_method(handle, "_DCK"))
310 		newfunc->flags |= FUNC_HAS_DCK;
311 
312 	/* search for objects that share the same slot */
313 	list_for_each_entry(slot, &bridge->slots, node)
314 		if (slot->device == device)
315 			goto slot_found;
316 
317 	slot = kzalloc(sizeof(struct acpiphp_slot), GFP_KERNEL);
318 	if (!slot) {
319 		status = AE_NO_MEMORY;
320 		goto err;
321 	}
322 
323 	slot->bus = bridge->pci_bus;
324 	slot->device = device;
325 	INIT_LIST_HEAD(&slot->funcs);
326 	mutex_init(&slot->crit_sect);
327 
328 	list_add_tail(&slot->node, &bridge->slots);
329 
330 	/* Register slots for ejectable functions only. */
331 	if (acpi_pci_check_ejectable(pbus, handle)  || is_dock_device(handle)) {
332 		unsigned long long sun;
333 		int retval;
334 
335 		bridge->nr_slots++;
336 		status = acpi_evaluate_integer(handle, "_SUN", NULL, &sun);
337 		if (ACPI_FAILURE(status))
338 			sun = bridge->nr_slots;
339 
340 		pr_debug("found ACPI PCI Hotplug slot %llu at PCI %04x:%02x:%02x\n",
341 		    sun, pci_domain_nr(pbus), pbus->number, device);
342 
343 		retval = acpiphp_register_hotplug_slot(slot, sun);
344 		if (retval) {
345 			slot->slot = NULL;
346 			bridge->nr_slots--;
347 			if (retval == -EBUSY)
348 				pr_warn("Slot %llu already registered by another "
349 					"hotplug driver\n", sun);
350 			else
351 				pr_warn("acpiphp_register_hotplug_slot failed "
352 					"(err code = 0x%x)\n", retval);
353 		}
354 		/* Even if the slot registration fails, we can still use it. */
355 	}
356 
357  slot_found:
358 	newfunc->slot = slot;
359 	list_add_tail(&newfunc->sibling, &slot->funcs);
360 
361 	if (pci_bus_read_dev_vendor_id(pbus, PCI_DEVFN(device, function),
362 				       &val, 60*1000))
363 		slot->flags |= SLOT_ENABLED;
364 
365 	if (is_dock_device(handle)) {
366 		/* we don't want to call this device's _EJ0
367 		 * because we want the dock notify handler
368 		 * to call it after it calls _DCK
369 		 */
370 		newfunc->flags &= ~FUNC_HAS_EJ0;
371 		if (register_hotplug_dock_device(handle,
372 			&acpiphp_dock_ops, context,
373 			acpiphp_dock_init, acpiphp_dock_release))
374 			pr_debug("failed to register dock device\n");
375 	}
376 
377 	/* install notify handler */
378 	if (!(newfunc->flags & FUNC_HAS_DCK)) {
379 		status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
380 						     handle_hotplug_event,
381 						     context);
382 		if (ACPI_FAILURE(status))
383 			acpi_handle_err(handle,
384 					"failed to install notify handler\n");
385 	}
386 
387 	return AE_OK;
388 
389  err:
390 	mutex_lock(&acpiphp_context_lock);
391 	acpiphp_put_context(context);
392 	mutex_unlock(&acpiphp_context_lock);
393 	return status;
394 }
395 
396 static struct acpiphp_bridge *acpiphp_handle_to_bridge(acpi_handle handle)
397 {
398 	struct acpiphp_context *context;
399 	struct acpiphp_bridge *bridge = NULL;
400 
401 	mutex_lock(&acpiphp_context_lock);
402 	context = acpiphp_get_context(handle);
403 	if (context) {
404 		bridge = context->bridge;
405 		if (bridge)
406 			get_bridge(bridge);
407 
408 		acpiphp_put_context(context);
409 	}
410 	mutex_unlock(&acpiphp_context_lock);
411 	return bridge;
412 }
413 
414 static void cleanup_bridge(struct acpiphp_bridge *bridge)
415 {
416 	struct acpiphp_slot *slot;
417 	struct acpiphp_func *func;
418 	acpi_status status;
419 
420 	list_for_each_entry(slot, &bridge->slots, node) {
421 		list_for_each_entry(func, &slot->funcs, sibling) {
422 			acpi_handle handle = func_to_handle(func);
423 
424 			if (is_dock_device(handle))
425 				unregister_hotplug_dock_device(handle);
426 
427 			if (!(func->flags & FUNC_HAS_DCK)) {
428 				status = acpi_remove_notify_handler(handle,
429 							ACPI_SYSTEM_NOTIFY,
430 							handle_hotplug_event);
431 				if (ACPI_FAILURE(status))
432 					pr_err("failed to remove notify handler\n");
433 			}
434 		}
435 		if (slot->slot)
436 			acpiphp_unregister_hotplug_slot(slot);
437 	}
438 
439 	mutex_lock(&bridge_mutex);
440 	list_del(&bridge->list);
441 	mutex_unlock(&bridge_mutex);
442 }
443 
444 /**
445  * acpiphp_max_busnr - return the highest reserved bus number under the given bus.
446  * @bus: bus to start search with
447  */
448 static unsigned char acpiphp_max_busnr(struct pci_bus *bus)
449 {
450 	struct list_head *tmp;
451 	unsigned char max, n;
452 
453 	/*
454 	 * pci_bus_max_busnr will return the highest
455 	 * reserved busnr for all these children.
456 	 * that is equivalent to the bus->subordinate
457 	 * value.  We don't want to use the parent's
458 	 * bus->subordinate value because it could have
459 	 * padding in it.
460 	 */
461 	max = bus->busn_res.start;
462 
463 	list_for_each(tmp, &bus->children) {
464 		n = pci_bus_max_busnr(pci_bus_b(tmp));
465 		if (n > max)
466 			max = n;
467 	}
468 	return max;
469 }
470 
471 /**
472  * acpiphp_bus_trim - Trim device objects in an ACPI namespace subtree.
473  * @handle: ACPI device object handle to start from.
474  */
475 static void acpiphp_bus_trim(acpi_handle handle)
476 {
477 	struct acpi_device *adev = NULL;
478 
479 	acpi_bus_get_device(handle, &adev);
480 	if (adev)
481 		acpi_bus_trim(adev);
482 }
483 
484 /**
485  * acpiphp_bus_add - Scan ACPI namespace subtree.
486  * @handle: ACPI object handle to start the scan from.
487  */
488 static void acpiphp_bus_add(acpi_handle handle)
489 {
490 	struct acpi_device *adev = NULL;
491 
492 	acpi_bus_scan(handle);
493 	acpi_bus_get_device(handle, &adev);
494 	if (adev)
495 		acpi_device_set_power(adev, ACPI_STATE_D0);
496 }
497 
498 static void acpiphp_set_acpi_region(struct acpiphp_slot *slot)
499 {
500 	struct acpiphp_func *func;
501 	union acpi_object params[2];
502 	struct acpi_object_list arg_list;
503 
504 	list_for_each_entry(func, &slot->funcs, sibling) {
505 		arg_list.count = 2;
506 		arg_list.pointer = params;
507 		params[0].type = ACPI_TYPE_INTEGER;
508 		params[0].integer.value = ACPI_ADR_SPACE_PCI_CONFIG;
509 		params[1].type = ACPI_TYPE_INTEGER;
510 		params[1].integer.value = 1;
511 		/* _REG is optional, we don't care about if there is failure */
512 		acpi_evaluate_object(func_to_handle(func), "_REG", &arg_list,
513 				     NULL);
514 	}
515 }
516 
517 static void check_hotplug_bridge(struct acpiphp_slot *slot, struct pci_dev *dev)
518 {
519 	struct acpiphp_func *func;
520 
521 	/* quirk, or pcie could set it already */
522 	if (dev->is_hotplug_bridge)
523 		return;
524 
525 	list_for_each_entry(func, &slot->funcs, sibling) {
526 		if (PCI_FUNC(dev->devfn) == func->function) {
527 			dev->is_hotplug_bridge = 1;
528 			break;
529 		}
530 	}
531 }
532 
533 static int acpiphp_rescan_slot(struct acpiphp_slot *slot)
534 {
535 	struct acpiphp_func *func;
536 
537 	list_for_each_entry(func, &slot->funcs, sibling)
538 		acpiphp_bus_add(func_to_handle(func));
539 
540 	return pci_scan_slot(slot->bus, PCI_DEVFN(slot->device, 0));
541 }
542 
543 /**
544  * enable_slot - enable, configure a slot
545  * @slot: slot to be enabled
546  *
547  * This function should be called per *physical slot*,
548  * not per each slot object in ACPI namespace.
549  */
550 static void __ref enable_slot(struct acpiphp_slot *slot)
551 {
552 	struct pci_dev *dev;
553 	struct pci_bus *bus = slot->bus;
554 	struct acpiphp_func *func;
555 	int max, pass;
556 	LIST_HEAD(add_list);
557 
558 	acpiphp_rescan_slot(slot);
559 	max = acpiphp_max_busnr(bus);
560 	for (pass = 0; pass < 2; pass++) {
561 		list_for_each_entry(dev, &bus->devices, bus_list) {
562 			if (PCI_SLOT(dev->devfn) != slot->device)
563 				continue;
564 
565 			if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
566 			    dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) {
567 				max = pci_scan_bridge(bus, dev, max, pass);
568 				if (pass && dev->subordinate) {
569 					check_hotplug_bridge(slot, dev);
570 					pcibios_resource_survey_bus(dev->subordinate);
571 					__pci_bus_size_bridges(dev->subordinate,
572 							       &add_list);
573 				}
574 			}
575 		}
576 	}
577 	__pci_bus_assign_resources(bus, &add_list, NULL);
578 
579 	acpiphp_sanitize_bus(bus);
580 	acpiphp_set_hpp_values(bus);
581 	acpiphp_set_acpi_region(slot);
582 
583 	list_for_each_entry(dev, &bus->devices, bus_list) {
584 		/* Assume that newly added devices are powered on already. */
585 		if (!dev->is_added)
586 			dev->current_state = PCI_D0;
587 	}
588 
589 	pci_bus_add_devices(bus);
590 
591 	slot->flags |= SLOT_ENABLED;
592 	list_for_each_entry(func, &slot->funcs, sibling) {
593 		dev = pci_get_slot(bus, PCI_DEVFN(slot->device,
594 						  func->function));
595 		if (!dev) {
596 			/* Do not set SLOT_ENABLED flag if some funcs
597 			   are not added. */
598 			slot->flags &= (~SLOT_ENABLED);
599 			continue;
600 		}
601 	}
602 }
603 
604 /* return first device in slot, acquiring a reference on it */
605 static struct pci_dev *dev_in_slot(struct acpiphp_slot *slot)
606 {
607 	struct pci_bus *bus = slot->bus;
608 	struct pci_dev *dev;
609 	struct pci_dev *ret = NULL;
610 
611 	down_read(&pci_bus_sem);
612 	list_for_each_entry(dev, &bus->devices, bus_list)
613 		if (PCI_SLOT(dev->devfn) == slot->device) {
614 			ret = pci_dev_get(dev);
615 			break;
616 		}
617 	up_read(&pci_bus_sem);
618 
619 	return ret;
620 }
621 
622 /**
623  * disable_slot - disable a slot
624  * @slot: ACPI PHP slot
625  */
626 static void disable_slot(struct acpiphp_slot *slot)
627 {
628 	struct acpiphp_func *func;
629 	struct pci_dev *pdev;
630 
631 	/*
632 	 * enable_slot() enumerates all functions in this device via
633 	 * pci_scan_slot(), whether they have associated ACPI hotplug
634 	 * methods (_EJ0, etc.) or not.  Therefore, we remove all functions
635 	 * here.
636 	 */
637 	while ((pdev = dev_in_slot(slot))) {
638 		pci_stop_and_remove_bus_device(pdev);
639 		pci_dev_put(pdev);
640 	}
641 
642 	list_for_each_entry(func, &slot->funcs, sibling)
643 		acpiphp_bus_trim(func_to_handle(func));
644 
645 	slot->flags &= (~SLOT_ENABLED);
646 }
647 
648 static bool acpiphp_no_hotplug(acpi_handle handle)
649 {
650 	struct acpi_device *adev = NULL;
651 
652 	acpi_bus_get_device(handle, &adev);
653 	return adev && adev->flags.no_hotplug;
654 }
655 
656 static bool slot_no_hotplug(struct acpiphp_slot *slot)
657 {
658 	struct acpiphp_func *func;
659 
660 	list_for_each_entry(func, &slot->funcs, sibling)
661 		if (acpiphp_no_hotplug(func_to_handle(func)))
662 			return true;
663 
664 	return false;
665 }
666 
667 /**
668  * get_slot_status - get ACPI slot status
669  * @slot: ACPI PHP slot
670  *
671  * If a slot has _STA for each function and if any one of them
672  * returned non-zero status, return it.
673  *
674  * If a slot doesn't have _STA and if any one of its functions'
675  * configuration space is configured, return 0x0f as a _STA.
676  *
677  * Otherwise return 0.
678  */
679 static unsigned int get_slot_status(struct acpiphp_slot *slot)
680 {
681 	unsigned long long sta = 0;
682 	struct acpiphp_func *func;
683 
684 	list_for_each_entry(func, &slot->funcs, sibling) {
685 		if (func->flags & FUNC_HAS_STA) {
686 			acpi_status status;
687 
688 			status = acpi_evaluate_integer(func_to_handle(func),
689 						       "_STA", NULL, &sta);
690 			if (ACPI_SUCCESS(status) && sta)
691 				break;
692 		} else {
693 			u32 dvid;
694 
695 			pci_bus_read_config_dword(slot->bus,
696 						  PCI_DEVFN(slot->device,
697 							    func->function),
698 						  PCI_VENDOR_ID, &dvid);
699 			if (dvid != 0xffffffff) {
700 				sta = ACPI_STA_ALL;
701 				break;
702 			}
703 		}
704 	}
705 
706 	return (unsigned int)sta;
707 }
708 
709 /**
710  * trim_stale_devices - remove PCI devices that are not responding.
711  * @dev: PCI device to start walking the hierarchy from.
712  */
713 static void trim_stale_devices(struct pci_dev *dev)
714 {
715 	acpi_handle handle = ACPI_HANDLE(&dev->dev);
716 	struct pci_bus *bus = dev->subordinate;
717 	bool alive = false;
718 
719 	if (handle) {
720 		acpi_status status;
721 		unsigned long long sta;
722 
723 		status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
724 		alive = (ACPI_SUCCESS(status) && sta == ACPI_STA_ALL)
725 			|| acpiphp_no_hotplug(handle);
726 	}
727 	if (!alive) {
728 		u32 v;
729 
730 		/* Check if the device responds. */
731 		alive = pci_bus_read_dev_vendor_id(dev->bus, dev->devfn, &v, 0);
732 	}
733 	if (!alive) {
734 		pci_stop_and_remove_bus_device(dev);
735 		if (handle)
736 			acpiphp_bus_trim(handle);
737 	} else if (bus) {
738 		struct pci_dev *child, *tmp;
739 
740 		/* The device is a bridge. so check the bus below it. */
741 		pm_runtime_get_sync(&dev->dev);
742 		list_for_each_entry_safe(child, tmp, &bus->devices, bus_list)
743 			trim_stale_devices(child);
744 
745 		pm_runtime_put(&dev->dev);
746 	}
747 }
748 
749 /**
750  * acpiphp_check_bridge - re-enumerate devices
751  * @bridge: where to begin re-enumeration
752  *
753  * Iterate over all slots under this bridge and make sure that if a
754  * card is present they are enabled, and if not they are disabled.
755  */
756 static void acpiphp_check_bridge(struct acpiphp_bridge *bridge)
757 {
758 	struct acpiphp_slot *slot;
759 
760 	list_for_each_entry(slot, &bridge->slots, node) {
761 		struct pci_bus *bus = slot->bus;
762 		struct pci_dev *dev, *tmp;
763 
764 		mutex_lock(&slot->crit_sect);
765 		if (slot_no_hotplug(slot)) {
766 			; /* do nothing */
767 		} else if (get_slot_status(slot) == ACPI_STA_ALL) {
768 			/* remove stale devices if any */
769 			list_for_each_entry_safe(dev, tmp, &bus->devices,
770 						 bus_list)
771 				if (PCI_SLOT(dev->devfn) == slot->device)
772 					trim_stale_devices(dev);
773 
774 			/* configure all functions */
775 			enable_slot(slot);
776 		} else {
777 			disable_slot(slot);
778 		}
779 		mutex_unlock(&slot->crit_sect);
780 	}
781 }
782 
783 static void acpiphp_set_hpp_values(struct pci_bus *bus)
784 {
785 	struct pci_dev *dev;
786 
787 	list_for_each_entry(dev, &bus->devices, bus_list)
788 		pci_configure_slot(dev);
789 }
790 
791 /*
792  * Remove devices for which we could not assign resources, call
793  * arch specific code to fix-up the bus
794  */
795 static void acpiphp_sanitize_bus(struct pci_bus *bus)
796 {
797 	struct pci_dev *dev, *tmp;
798 	int i;
799 	unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM;
800 
801 	list_for_each_entry_safe(dev, tmp, &bus->devices, bus_list) {
802 		for (i=0; i<PCI_BRIDGE_RESOURCES; i++) {
803 			struct resource *res = &dev->resource[i];
804 			if ((res->flags & type_mask) && !res->start &&
805 					res->end) {
806 				/* Could not assign a required resources
807 				 * for this device, remove it */
808 				pci_stop_and_remove_bus_device(dev);
809 				break;
810 			}
811 		}
812 	}
813 }
814 
815 /*
816  * ACPI event handlers
817  */
818 
819 void acpiphp_check_host_bridge(acpi_handle handle)
820 {
821 	struct acpiphp_bridge *bridge;
822 
823 	bridge = acpiphp_handle_to_bridge(handle);
824 	if (bridge) {
825 		acpiphp_check_bridge(bridge);
826 		put_bridge(bridge);
827 	}
828 }
829 
830 static void hotplug_event(acpi_handle handle, u32 type, void *data)
831 {
832 	struct acpiphp_context *context = data;
833 	struct acpiphp_func *func = &context->func;
834 	struct acpiphp_bridge *bridge;
835 	char objname[64];
836 	struct acpi_buffer buffer = { .length = sizeof(objname),
837 				      .pointer = objname };
838 
839 	mutex_lock(&acpiphp_context_lock);
840 	bridge = context->bridge;
841 	if (bridge)
842 		get_bridge(bridge);
843 
844 	mutex_unlock(&acpiphp_context_lock);
845 
846 	acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
847 
848 	switch (type) {
849 	case ACPI_NOTIFY_BUS_CHECK:
850 		/* bus re-enumerate */
851 		pr_debug("%s: Bus check notify on %s\n", __func__, objname);
852 		pr_debug("%s: re-enumerating slots under %s\n",
853 			 __func__, objname);
854 		if (bridge) {
855 			acpiphp_check_bridge(bridge);
856 		} else {
857 			struct acpiphp_slot *slot = func->slot;
858 
859 			mutex_lock(&slot->crit_sect);
860 			enable_slot(slot);
861 			mutex_unlock(&slot->crit_sect);
862 		}
863 		break;
864 
865 	case ACPI_NOTIFY_DEVICE_CHECK:
866 		/* device check */
867 		pr_debug("%s: Device check notify on %s\n", __func__, objname);
868 		if (bridge) {
869 			acpiphp_check_bridge(bridge);
870 		} else {
871 			struct acpiphp_slot *slot = func->slot;
872 			int ret;
873 
874 			/*
875 			 * Check if anything has changed in the slot and rescan
876 			 * from the parent if that's the case.
877 			 */
878 			mutex_lock(&slot->crit_sect);
879 			ret = acpiphp_rescan_slot(slot);
880 			mutex_unlock(&slot->crit_sect);
881 			if (ret)
882 				acpiphp_check_bridge(func->parent);
883 		}
884 		break;
885 
886 	case ACPI_NOTIFY_EJECT_REQUEST:
887 		/* request device eject */
888 		pr_debug("%s: Device eject notify on %s\n", __func__, objname);
889 		acpiphp_disable_and_eject_slot(func->slot);
890 		break;
891 	}
892 
893 	if (bridge)
894 		put_bridge(bridge);
895 }
896 
897 static void hotplug_event_work(void *data, u32 type)
898 {
899 	struct acpiphp_context *context = data;
900 	acpi_handle handle = context->handle;
901 
902 	acpi_scan_lock_acquire();
903 
904 	hotplug_event(handle, type, context);
905 
906 	acpi_scan_lock_release();
907 	acpi_evaluate_hotplug_ost(handle, type, ACPI_OST_SC_SUCCESS, NULL);
908 	put_bridge(context->func.parent);
909 }
910 
911 /**
912  * handle_hotplug_event - handle ACPI hotplug event
913  * @handle: Notify()'ed acpi_handle
914  * @type: Notify code
915  * @data: pointer to acpiphp_context structure
916  *
917  * Handles ACPI event notification on slots.
918  */
919 static void handle_hotplug_event(acpi_handle handle, u32 type, void *data)
920 {
921 	struct acpiphp_context *context;
922 	u32 ost_code = ACPI_OST_SC_SUCCESS;
923 
924 	switch (type) {
925 	case ACPI_NOTIFY_BUS_CHECK:
926 	case ACPI_NOTIFY_DEVICE_CHECK:
927 		break;
928 	case ACPI_NOTIFY_EJECT_REQUEST:
929 		ost_code = ACPI_OST_SC_EJECT_IN_PROGRESS;
930 		acpi_evaluate_hotplug_ost(handle, type, ost_code, NULL);
931 		break;
932 
933 	case ACPI_NOTIFY_DEVICE_WAKE:
934 		return;
935 
936 	case ACPI_NOTIFY_FREQUENCY_MISMATCH:
937 		acpi_handle_err(handle, "Device cannot be configured due "
938 				"to a frequency mismatch\n");
939 		goto out;
940 
941 	case ACPI_NOTIFY_BUS_MODE_MISMATCH:
942 		acpi_handle_err(handle, "Device cannot be configured due "
943 				"to a bus mode mismatch\n");
944 		goto out;
945 
946 	case ACPI_NOTIFY_POWER_FAULT:
947 		acpi_handle_err(handle, "Device has suffered a power fault\n");
948 		goto out;
949 
950 	default:
951 		acpi_handle_warn(handle, "Unsupported event type 0x%x\n", type);
952 		ost_code = ACPI_OST_SC_UNRECOGNIZED_NOTIFY;
953 		goto out;
954 	}
955 
956 	mutex_lock(&acpiphp_context_lock);
957 	context = acpiphp_get_context(handle);
958 	if (context && !WARN_ON(context->handle != handle)) {
959 		get_bridge(context->func.parent);
960 		acpiphp_put_context(context);
961 		acpi_hotplug_execute(hotplug_event_work, context, type);
962 		mutex_unlock(&acpiphp_context_lock);
963 		return;
964 	}
965 	mutex_unlock(&acpiphp_context_lock);
966 	ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
967 
968  out:
969 	acpi_evaluate_hotplug_ost(handle, type, ost_code, NULL);
970 }
971 
972 /*
973  * Create hotplug slots for the PCI bus.
974  * It should always return 0 to avoid skipping following notifiers.
975  */
976 void acpiphp_enumerate_slots(struct pci_bus *bus)
977 {
978 	struct acpiphp_bridge *bridge;
979 	acpi_handle handle;
980 	acpi_status status;
981 
982 	if (acpiphp_disabled)
983 		return;
984 
985 	handle = ACPI_HANDLE(bus->bridge);
986 	if (!handle)
987 		return;
988 
989 	bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL);
990 	if (!bridge) {
991 		acpi_handle_err(handle, "No memory for bridge object\n");
992 		return;
993 	}
994 
995 	INIT_LIST_HEAD(&bridge->slots);
996 	kref_init(&bridge->ref);
997 	bridge->pci_dev = pci_dev_get(bus->self);
998 	bridge->pci_bus = bus;
999 
1000 	/*
1001 	 * Grab a ref to the subordinate PCI bus in case the bus is
1002 	 * removed via PCI core logical hotplug. The ref pins the bus
1003 	 * (which we access during module unload).
1004 	 */
1005 	get_device(&bus->dev);
1006 
1007 	if (!pci_is_root_bus(bridge->pci_bus)) {
1008 		struct acpiphp_context *context;
1009 
1010 		/*
1011 		 * This bridge should have been registered as a hotplug function
1012 		 * under its parent, so the context should be there, unless the
1013 		 * parent is going to be handled by pciehp, in which case this
1014 		 * bridge is not interesting to us either.
1015 		 */
1016 		mutex_lock(&acpiphp_context_lock);
1017 		context = acpiphp_get_context(handle);
1018 		if (!context) {
1019 			mutex_unlock(&acpiphp_context_lock);
1020 			put_device(&bus->dev);
1021 			pci_dev_put(bridge->pci_dev);
1022 			kfree(bridge);
1023 			return;
1024 		}
1025 		bridge->context = context;
1026 		context->bridge = bridge;
1027 		/* Get a reference to the parent bridge. */
1028 		get_bridge(context->func.parent);
1029 		mutex_unlock(&acpiphp_context_lock);
1030 	}
1031 
1032 	/* must be added to the list prior to calling register_slot */
1033 	mutex_lock(&bridge_mutex);
1034 	list_add(&bridge->list, &bridge_list);
1035 	mutex_unlock(&bridge_mutex);
1036 
1037 	/* register all slot objects under this bridge */
1038 	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
1039 				     register_slot, NULL, bridge, NULL);
1040 	if (ACPI_FAILURE(status)) {
1041 		acpi_handle_err(handle, "failed to register slots\n");
1042 		cleanup_bridge(bridge);
1043 		put_bridge(bridge);
1044 	}
1045 }
1046 
1047 /* Destroy hotplug slots associated with the PCI bus */
1048 void acpiphp_remove_slots(struct pci_bus *bus)
1049 {
1050 	struct acpiphp_bridge *bridge;
1051 
1052 	if (acpiphp_disabled)
1053 		return;
1054 
1055 	mutex_lock(&bridge_mutex);
1056 	list_for_each_entry(bridge, &bridge_list, list)
1057 		if (bridge->pci_bus == bus) {
1058 			mutex_unlock(&bridge_mutex);
1059 			cleanup_bridge(bridge);
1060 			put_bridge(bridge);
1061 			return;
1062 		}
1063 
1064 	mutex_unlock(&bridge_mutex);
1065 }
1066 
1067 /**
1068  * acpiphp_enable_slot - power on slot
1069  * @slot: ACPI PHP slot
1070  */
1071 int acpiphp_enable_slot(struct acpiphp_slot *slot)
1072 {
1073 	mutex_lock(&slot->crit_sect);
1074 	/* configure all functions */
1075 	if (!(slot->flags & SLOT_ENABLED))
1076 		enable_slot(slot);
1077 
1078 	mutex_unlock(&slot->crit_sect);
1079 	return 0;
1080 }
1081 
1082 /**
1083  * acpiphp_disable_and_eject_slot - power off and eject slot
1084  * @slot: ACPI PHP slot
1085  */
1086 int acpiphp_disable_and_eject_slot(struct acpiphp_slot *slot)
1087 {
1088 	struct acpiphp_func *func;
1089 	int retval = 0;
1090 
1091 	mutex_lock(&slot->crit_sect);
1092 
1093 	/* unconfigure all functions */
1094 	disable_slot(slot);
1095 
1096 	list_for_each_entry(func, &slot->funcs, sibling)
1097 		if (func->flags & FUNC_HAS_EJ0) {
1098 			acpi_handle handle = func_to_handle(func);
1099 
1100 			if (ACPI_FAILURE(acpi_evaluate_ej0(handle)))
1101 				acpi_handle_err(handle, "_EJ0 failed\n");
1102 
1103 			break;
1104 		}
1105 
1106 	mutex_unlock(&slot->crit_sect);
1107 	return retval;
1108 }
1109 
1110 
1111 /*
1112  * slot enabled:  1
1113  * slot disabled: 0
1114  */
1115 u8 acpiphp_get_power_status(struct acpiphp_slot *slot)
1116 {
1117 	return (slot->flags & SLOT_ENABLED);
1118 }
1119 
1120 
1121 /*
1122  * latch   open:  1
1123  * latch closed:  0
1124  */
1125 u8 acpiphp_get_latch_status(struct acpiphp_slot *slot)
1126 {
1127 	return !(get_slot_status(slot) & ACPI_STA_DEVICE_UI);
1128 }
1129 
1130 
1131 /*
1132  * adapter presence : 1
1133  *          absence : 0
1134  */
1135 u8 acpiphp_get_adapter_status(struct acpiphp_slot *slot)
1136 {
1137 	return !!get_slot_status(slot);
1138 }
1139