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