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