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 * @adev: ACPI device object to create the context for. 77 * 78 * Call under acpiphp_context_lock. 79 */ 80 static struct acpiphp_context *acpiphp_init_context(struct acpi_device *adev) 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->adev = adev; 90 context->refcount = 1; 91 status = acpi_attach_data(adev->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 * @context: ACPI hotplug context to drop a reference to. 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->adev->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 static void dock_event(acpi_handle handle, u32 type, void *data) 214 { 215 struct acpiphp_context *context; 216 217 mutex_lock(&acpiphp_context_lock); 218 context = acpiphp_get_context(handle); 219 if (!context || WARN_ON(context->adev->handle != handle) 220 || context->func.parent->is_going_away) { 221 mutex_unlock(&acpiphp_context_lock); 222 return; 223 } 224 get_bridge(context->func.parent); 225 acpiphp_put_context(context); 226 mutex_unlock(&acpiphp_context_lock); 227 228 hotplug_event(handle, type, data); 229 230 put_bridge(context->func.parent); 231 } 232 233 static const struct acpi_dock_ops acpiphp_dock_ops = { 234 .fixup = post_dock_fixups, 235 .handler = dock_event, 236 }; 237 238 /* Check whether the PCI device is managed by native PCIe hotplug driver */ 239 static bool device_is_managed_by_native_pciehp(struct pci_dev *pdev) 240 { 241 u32 reg32; 242 acpi_handle tmp; 243 struct acpi_pci_root *root; 244 245 /* Check whether the PCIe port supports native PCIe hotplug */ 246 if (pcie_capability_read_dword(pdev, PCI_EXP_SLTCAP, ®32)) 247 return false; 248 if (!(reg32 & PCI_EXP_SLTCAP_HPC)) 249 return false; 250 251 /* 252 * Check whether native PCIe hotplug has been enabled for 253 * this PCIe hierarchy. 254 */ 255 tmp = acpi_find_root_bridge_handle(pdev); 256 if (!tmp) 257 return false; 258 root = acpi_pci_find_root(tmp); 259 if (!root) 260 return false; 261 if (!(root->osc_control_set & OSC_PCI_EXPRESS_NATIVE_HP_CONTROL)) 262 return false; 263 264 return true; 265 } 266 267 static void acpiphp_dock_init(void *data) 268 { 269 struct acpiphp_context *context = data; 270 271 get_bridge(context->func.parent); 272 } 273 274 static void acpiphp_dock_release(void *data) 275 { 276 struct acpiphp_context *context = data; 277 278 put_bridge(context->func.parent); 279 } 280 281 /* callback routine to register each ACPI PCI slot object */ 282 static acpi_status register_slot(acpi_handle handle, u32 lvl, void *data, 283 void **rv) 284 { 285 struct acpiphp_bridge *bridge = data; 286 struct acpiphp_context *context; 287 struct acpi_device *adev; 288 struct acpiphp_slot *slot; 289 struct acpiphp_func *newfunc; 290 acpi_status status = AE_OK; 291 unsigned long long adr; 292 int device, function; 293 struct pci_bus *pbus = bridge->pci_bus; 294 struct pci_dev *pdev = bridge->pci_dev; 295 u32 val; 296 297 if (pdev && device_is_managed_by_native_pciehp(pdev)) 298 return AE_OK; 299 300 status = acpi_evaluate_integer(handle, "_ADR", NULL, &adr); 301 if (ACPI_FAILURE(status)) { 302 if (status != AE_NOT_FOUND) 303 acpi_handle_warn(handle, 304 "can't evaluate _ADR (%#x)\n", status); 305 return AE_OK; 306 } 307 if (acpi_bus_get_device(handle, &adev)) 308 return AE_OK; 309 310 device = (adr >> 16) & 0xffff; 311 function = adr & 0xffff; 312 313 mutex_lock(&acpiphp_context_lock); 314 context = acpiphp_init_context(adev); 315 if (!context) { 316 mutex_unlock(&acpiphp_context_lock); 317 acpi_handle_err(handle, "No hotplug context\n"); 318 return AE_NOT_EXIST; 319 } 320 newfunc = &context->func; 321 newfunc->function = function; 322 newfunc->parent = bridge; 323 mutex_unlock(&acpiphp_context_lock); 324 325 if (acpi_has_method(handle, "_EJ0")) 326 newfunc->flags = FUNC_HAS_EJ0; 327 328 if (acpi_has_method(handle, "_STA")) 329 newfunc->flags |= FUNC_HAS_STA; 330 331 if (acpi_has_method(handle, "_DCK")) 332 newfunc->flags |= FUNC_HAS_DCK; 333 334 /* search for objects that share the same slot */ 335 list_for_each_entry(slot, &bridge->slots, node) 336 if (slot->device == device) 337 goto slot_found; 338 339 slot = kzalloc(sizeof(struct acpiphp_slot), GFP_KERNEL); 340 if (!slot) { 341 mutex_lock(&acpiphp_context_lock); 342 acpiphp_put_context(context); 343 mutex_unlock(&acpiphp_context_lock); 344 return AE_NO_MEMORY; 345 } 346 347 slot->bus = bridge->pci_bus; 348 slot->device = device; 349 INIT_LIST_HEAD(&slot->funcs); 350 351 list_add_tail(&slot->node, &bridge->slots); 352 353 /* Register slots for ejectable functions only. */ 354 if (acpi_pci_check_ejectable(pbus, handle) || is_dock_device(handle)) { 355 unsigned long long sun; 356 int retval; 357 358 bridge->nr_slots++; 359 status = acpi_evaluate_integer(handle, "_SUN", NULL, &sun); 360 if (ACPI_FAILURE(status)) 361 sun = bridge->nr_slots; 362 363 pr_debug("found ACPI PCI Hotplug slot %llu at PCI %04x:%02x:%02x\n", 364 sun, pci_domain_nr(pbus), pbus->number, device); 365 366 retval = acpiphp_register_hotplug_slot(slot, sun); 367 if (retval) { 368 slot->slot = NULL; 369 bridge->nr_slots--; 370 if (retval == -EBUSY) 371 pr_warn("Slot %llu already registered by another " 372 "hotplug driver\n", sun); 373 else 374 pr_warn("acpiphp_register_hotplug_slot failed " 375 "(err code = 0x%x)\n", retval); 376 } 377 /* Even if the slot registration fails, we can still use it. */ 378 } 379 380 slot_found: 381 newfunc->slot = slot; 382 list_add_tail(&newfunc->sibling, &slot->funcs); 383 384 if (pci_bus_read_dev_vendor_id(pbus, PCI_DEVFN(device, function), 385 &val, 60*1000)) 386 slot->flags |= SLOT_ENABLED; 387 388 if (is_dock_device(handle)) { 389 /* we don't want to call this device's _EJ0 390 * because we want the dock notify handler 391 * to call it after it calls _DCK 392 */ 393 newfunc->flags &= ~FUNC_HAS_EJ0; 394 if (register_hotplug_dock_device(handle, 395 &acpiphp_dock_ops, context, 396 acpiphp_dock_init, acpiphp_dock_release)) 397 pr_debug("failed to register dock device\n"); 398 } 399 400 /* install notify handler */ 401 if (!(newfunc->flags & FUNC_HAS_DCK)) { 402 status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY, 403 handle_hotplug_event, 404 context); 405 if (ACPI_FAILURE(status)) 406 acpi_handle_err(handle, 407 "failed to install notify handler\n"); 408 } 409 410 return AE_OK; 411 } 412 413 static struct acpiphp_bridge *acpiphp_handle_to_bridge(acpi_handle handle) 414 { 415 struct acpiphp_context *context; 416 struct acpiphp_bridge *bridge = NULL; 417 418 mutex_lock(&acpiphp_context_lock); 419 context = acpiphp_get_context(handle); 420 if (context) { 421 bridge = context->bridge; 422 if (bridge) 423 get_bridge(bridge); 424 425 acpiphp_put_context(context); 426 } 427 mutex_unlock(&acpiphp_context_lock); 428 return bridge; 429 } 430 431 static void cleanup_bridge(struct acpiphp_bridge *bridge) 432 { 433 struct acpiphp_slot *slot; 434 struct acpiphp_func *func; 435 acpi_status status; 436 437 list_for_each_entry(slot, &bridge->slots, node) { 438 list_for_each_entry(func, &slot->funcs, sibling) { 439 acpi_handle handle = func_to_handle(func); 440 441 if (is_dock_device(handle)) 442 unregister_hotplug_dock_device(handle); 443 444 if (!(func->flags & FUNC_HAS_DCK)) { 445 status = acpi_remove_notify_handler(handle, 446 ACPI_SYSTEM_NOTIFY, 447 handle_hotplug_event); 448 if (ACPI_FAILURE(status)) 449 pr_err("failed to remove notify handler\n"); 450 } 451 } 452 slot->flags |= SLOT_IS_GOING_AWAY; 453 if (slot->slot) 454 acpiphp_unregister_hotplug_slot(slot); 455 } 456 457 mutex_lock(&bridge_mutex); 458 list_del(&bridge->list); 459 mutex_unlock(&bridge_mutex); 460 461 mutex_lock(&acpiphp_context_lock); 462 bridge->is_going_away = true; 463 mutex_unlock(&acpiphp_context_lock); 464 } 465 466 /** 467 * acpiphp_max_busnr - return the highest reserved bus number under the given bus. 468 * @bus: bus to start search with 469 */ 470 static unsigned char acpiphp_max_busnr(struct pci_bus *bus) 471 { 472 struct list_head *tmp; 473 unsigned char max, n; 474 475 /* 476 * pci_bus_max_busnr will return the highest 477 * reserved busnr for all these children. 478 * that is equivalent to the bus->subordinate 479 * value. We don't want to use the parent's 480 * bus->subordinate value because it could have 481 * padding in it. 482 */ 483 max = bus->busn_res.start; 484 485 list_for_each(tmp, &bus->children) { 486 n = pci_bus_max_busnr(pci_bus_b(tmp)); 487 if (n > max) 488 max = n; 489 } 490 return max; 491 } 492 493 static void acpiphp_set_acpi_region(struct acpiphp_slot *slot) 494 { 495 struct acpiphp_func *func; 496 union acpi_object params[2]; 497 struct acpi_object_list arg_list; 498 499 list_for_each_entry(func, &slot->funcs, sibling) { 500 arg_list.count = 2; 501 arg_list.pointer = params; 502 params[0].type = ACPI_TYPE_INTEGER; 503 params[0].integer.value = ACPI_ADR_SPACE_PCI_CONFIG; 504 params[1].type = ACPI_TYPE_INTEGER; 505 params[1].integer.value = 1; 506 /* _REG is optional, we don't care about if there is failure */ 507 acpi_evaluate_object(func_to_handle(func), "_REG", &arg_list, 508 NULL); 509 } 510 } 511 512 static void check_hotplug_bridge(struct acpiphp_slot *slot, struct pci_dev *dev) 513 { 514 struct acpiphp_func *func; 515 516 /* quirk, or pcie could set it already */ 517 if (dev->is_hotplug_bridge) 518 return; 519 520 list_for_each_entry(func, &slot->funcs, sibling) { 521 if (PCI_FUNC(dev->devfn) == func->function) { 522 dev->is_hotplug_bridge = 1; 523 break; 524 } 525 } 526 } 527 528 static int acpiphp_rescan_slot(struct acpiphp_slot *slot) 529 { 530 struct acpiphp_func *func; 531 532 list_for_each_entry(func, &slot->funcs, sibling) { 533 struct acpi_device *adev = func_to_acpi_device(func); 534 535 acpi_bus_scan(adev->handle); 536 if (acpi_device_enumerated(adev)) 537 acpi_device_set_power(adev, ACPI_STATE_D0); 538 } 539 return pci_scan_slot(slot->bus, PCI_DEVFN(slot->device, 0)); 540 } 541 542 /** 543 * enable_slot - enable, configure a slot 544 * @slot: slot to be enabled 545 * 546 * This function should be called per *physical slot*, 547 * not per each slot object in ACPI namespace. 548 */ 549 static void __ref enable_slot(struct acpiphp_slot *slot) 550 { 551 struct pci_dev *dev; 552 struct pci_bus *bus = slot->bus; 553 struct acpiphp_func *func; 554 int max, pass; 555 LIST_HEAD(add_list); 556 557 acpiphp_rescan_slot(slot); 558 max = acpiphp_max_busnr(bus); 559 for (pass = 0; pass < 2; pass++) { 560 list_for_each_entry(dev, &bus->devices, bus_list) { 561 if (PCI_SLOT(dev->devfn) != slot->device) 562 continue; 563 564 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE || 565 dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) { 566 max = pci_scan_bridge(bus, dev, max, pass); 567 if (pass && dev->subordinate) { 568 check_hotplug_bridge(slot, dev); 569 pcibios_resource_survey_bus(dev->subordinate); 570 __pci_bus_size_bridges(dev->subordinate, 571 &add_list); 572 } 573 } 574 } 575 } 576 __pci_bus_assign_resources(bus, &add_list, NULL); 577 578 acpiphp_sanitize_bus(bus); 579 acpiphp_set_hpp_values(bus); 580 acpiphp_set_acpi_region(slot); 581 582 list_for_each_entry(dev, &bus->devices, bus_list) { 583 /* Assume that newly added devices are powered on already. */ 584 if (!dev->is_added) 585 dev->current_state = PCI_D0; 586 } 587 588 pci_bus_add_devices(bus); 589 590 slot->flags |= SLOT_ENABLED; 591 list_for_each_entry(func, &slot->funcs, sibling) { 592 dev = pci_get_slot(bus, PCI_DEVFN(slot->device, 593 func->function)); 594 if (!dev) { 595 /* Do not set SLOT_ENABLED flag if some funcs 596 are not added. */ 597 slot->flags &= (~SLOT_ENABLED); 598 continue; 599 } 600 } 601 } 602 603 /** 604 * disable_slot - disable a slot 605 * @slot: ACPI PHP slot 606 */ 607 static void disable_slot(struct acpiphp_slot *slot) 608 { 609 struct pci_bus *bus = slot->bus; 610 struct pci_dev *dev, *prev; 611 struct acpiphp_func *func; 612 613 /* 614 * enable_slot() enumerates all functions in this device via 615 * pci_scan_slot(), whether they have associated ACPI hotplug 616 * methods (_EJ0, etc.) or not. Therefore, we remove all functions 617 * here. 618 */ 619 list_for_each_entry_safe_reverse(dev, prev, &bus->devices, bus_list) 620 if (PCI_SLOT(dev->devfn) == slot->device) 621 pci_stop_and_remove_bus_device(dev); 622 623 list_for_each_entry(func, &slot->funcs, sibling) 624 acpi_bus_trim(func_to_acpi_device(func)); 625 626 slot->flags &= (~SLOT_ENABLED); 627 } 628 629 static bool acpiphp_no_hotplug(struct acpi_device *adev) 630 { 631 return adev && adev->flags.no_hotplug; 632 } 633 634 static bool slot_no_hotplug(struct acpiphp_slot *slot) 635 { 636 struct acpiphp_func *func; 637 638 list_for_each_entry(func, &slot->funcs, sibling) 639 if (acpiphp_no_hotplug(func_to_acpi_device(func))) 640 return true; 641 642 return false; 643 } 644 645 /** 646 * get_slot_status - get ACPI slot status 647 * @slot: ACPI PHP slot 648 * 649 * If a slot has _STA for each function and if any one of them 650 * returned non-zero status, return it. 651 * 652 * If a slot doesn't have _STA and if any one of its functions' 653 * configuration space is configured, return 0x0f as a _STA. 654 * 655 * Otherwise return 0. 656 */ 657 static unsigned int get_slot_status(struct acpiphp_slot *slot) 658 { 659 unsigned long long sta = 0; 660 struct acpiphp_func *func; 661 662 list_for_each_entry(func, &slot->funcs, sibling) { 663 if (func->flags & FUNC_HAS_STA) { 664 acpi_status status; 665 666 status = acpi_evaluate_integer(func_to_handle(func), 667 "_STA", NULL, &sta); 668 if (ACPI_SUCCESS(status) && sta) 669 break; 670 } else { 671 u32 dvid; 672 673 pci_bus_read_config_dword(slot->bus, 674 PCI_DEVFN(slot->device, 675 func->function), 676 PCI_VENDOR_ID, &dvid); 677 if (dvid != 0xffffffff) { 678 sta = ACPI_STA_ALL; 679 break; 680 } 681 } 682 } 683 684 return (unsigned int)sta; 685 } 686 687 /** 688 * trim_stale_devices - remove PCI devices that are not responding. 689 * @dev: PCI device to start walking the hierarchy from. 690 */ 691 static void trim_stale_devices(struct pci_dev *dev) 692 { 693 struct acpi_device *adev = ACPI_COMPANION(&dev->dev); 694 struct pci_bus *bus = dev->subordinate; 695 bool alive = false; 696 697 if (adev) { 698 acpi_status status; 699 unsigned long long sta; 700 701 status = acpi_evaluate_integer(adev->handle, "_STA", NULL, &sta); 702 alive = (ACPI_SUCCESS(status) && sta == ACPI_STA_ALL) 703 || acpiphp_no_hotplug(adev); 704 } 705 if (!alive) { 706 u32 v; 707 708 /* Check if the device responds. */ 709 alive = pci_bus_read_dev_vendor_id(dev->bus, dev->devfn, &v, 0); 710 } 711 if (!alive) { 712 pci_stop_and_remove_bus_device(dev); 713 if (adev) 714 acpi_bus_trim(adev); 715 } else if (bus) { 716 struct pci_dev *child, *tmp; 717 718 /* The device is a bridge. so check the bus below it. */ 719 pm_runtime_get_sync(&dev->dev); 720 list_for_each_entry_safe_reverse(child, tmp, &bus->devices, bus_list) 721 trim_stale_devices(child); 722 723 pm_runtime_put(&dev->dev); 724 } 725 } 726 727 /** 728 * acpiphp_check_bridge - re-enumerate devices 729 * @bridge: where to begin re-enumeration 730 * 731 * Iterate over all slots under this bridge and make sure that if a 732 * card is present they are enabled, and if not they are disabled. 733 */ 734 static void acpiphp_check_bridge(struct acpiphp_bridge *bridge) 735 { 736 struct acpiphp_slot *slot; 737 738 /* Bail out if the bridge is going away. */ 739 if (bridge->is_going_away) 740 return; 741 742 list_for_each_entry(slot, &bridge->slots, node) { 743 struct pci_bus *bus = slot->bus; 744 struct pci_dev *dev, *tmp; 745 746 if (slot_no_hotplug(slot)) { 747 ; /* do nothing */ 748 } else if (get_slot_status(slot) == ACPI_STA_ALL) { 749 /* remove stale devices if any */ 750 list_for_each_entry_safe_reverse(dev, tmp, 751 &bus->devices, bus_list) 752 if (PCI_SLOT(dev->devfn) == slot->device) 753 trim_stale_devices(dev); 754 755 /* configure all functions */ 756 enable_slot(slot); 757 } else { 758 disable_slot(slot); 759 } 760 } 761 } 762 763 static void acpiphp_set_hpp_values(struct pci_bus *bus) 764 { 765 struct pci_dev *dev; 766 767 list_for_each_entry(dev, &bus->devices, bus_list) 768 pci_configure_slot(dev); 769 } 770 771 /* 772 * Remove devices for which we could not assign resources, call 773 * arch specific code to fix-up the bus 774 */ 775 static void acpiphp_sanitize_bus(struct pci_bus *bus) 776 { 777 struct pci_dev *dev, *tmp; 778 int i; 779 unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM; 780 781 list_for_each_entry_safe_reverse(dev, tmp, &bus->devices, bus_list) { 782 for (i=0; i<PCI_BRIDGE_RESOURCES; i++) { 783 struct resource *res = &dev->resource[i]; 784 if ((res->flags & type_mask) && !res->start && 785 res->end) { 786 /* Could not assign a required resources 787 * for this device, remove it */ 788 pci_stop_and_remove_bus_device(dev); 789 break; 790 } 791 } 792 } 793 } 794 795 /* 796 * ACPI event handlers 797 */ 798 799 void acpiphp_check_host_bridge(acpi_handle handle) 800 { 801 struct acpiphp_bridge *bridge; 802 803 bridge = acpiphp_handle_to_bridge(handle); 804 if (bridge) { 805 pci_lock_rescan_remove(); 806 807 acpiphp_check_bridge(bridge); 808 809 pci_unlock_rescan_remove(); 810 put_bridge(bridge); 811 } 812 } 813 814 static int acpiphp_disable_and_eject_slot(struct acpiphp_slot *slot); 815 816 static void hotplug_event(acpi_handle handle, u32 type, void *data) 817 { 818 struct acpiphp_context *context = data; 819 struct acpiphp_func *func = &context->func; 820 struct acpiphp_slot *slot = func->slot; 821 struct acpiphp_bridge *bridge; 822 char objname[64]; 823 struct acpi_buffer buffer = { .length = sizeof(objname), 824 .pointer = objname }; 825 826 mutex_lock(&acpiphp_context_lock); 827 bridge = context->bridge; 828 if (bridge) 829 get_bridge(bridge); 830 831 mutex_unlock(&acpiphp_context_lock); 832 833 pci_lock_rescan_remove(); 834 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer); 835 836 switch (type) { 837 case ACPI_NOTIFY_BUS_CHECK: 838 /* bus re-enumerate */ 839 pr_debug("%s: Bus check notify on %s\n", __func__, objname); 840 pr_debug("%s: re-enumerating slots under %s\n", 841 __func__, objname); 842 if (bridge) 843 acpiphp_check_bridge(bridge); 844 else if (!(slot->flags & SLOT_IS_GOING_AWAY)) 845 enable_slot(slot); 846 847 break; 848 849 case ACPI_NOTIFY_DEVICE_CHECK: 850 /* device check */ 851 pr_debug("%s: Device check notify on %s\n", __func__, objname); 852 if (bridge) { 853 acpiphp_check_bridge(bridge); 854 } else if (!(slot->flags & SLOT_IS_GOING_AWAY)) { 855 /* 856 * Check if anything has changed in the slot and rescan 857 * from the parent if that's the case. 858 */ 859 if (acpiphp_rescan_slot(slot)) 860 acpiphp_check_bridge(func->parent); 861 } 862 break; 863 864 case ACPI_NOTIFY_EJECT_REQUEST: 865 /* request device eject */ 866 pr_debug("%s: Device eject notify on %s\n", __func__, objname); 867 acpiphp_disable_and_eject_slot(slot); 868 break; 869 } 870 871 pci_unlock_rescan_remove(); 872 if (bridge) 873 put_bridge(bridge); 874 } 875 876 static void hotplug_event_work(void *data, u32 type) 877 { 878 struct acpiphp_context *context = data; 879 acpi_handle handle = context->adev->handle; 880 881 acpi_scan_lock_acquire(); 882 883 hotplug_event(handle, type, context); 884 885 acpi_scan_lock_release(); 886 acpi_evaluate_hotplug_ost(handle, type, ACPI_OST_SC_SUCCESS, NULL); 887 put_bridge(context->func.parent); 888 } 889 890 /** 891 * handle_hotplug_event - handle ACPI hotplug event 892 * @handle: Notify()'ed acpi_handle 893 * @type: Notify code 894 * @data: pointer to acpiphp_context structure 895 * 896 * Handles ACPI event notification on slots. 897 */ 898 static void handle_hotplug_event(acpi_handle handle, u32 type, void *data) 899 { 900 struct acpiphp_context *context; 901 u32 ost_code = ACPI_OST_SC_SUCCESS; 902 acpi_status status; 903 904 switch (type) { 905 case ACPI_NOTIFY_BUS_CHECK: 906 case ACPI_NOTIFY_DEVICE_CHECK: 907 break; 908 case ACPI_NOTIFY_EJECT_REQUEST: 909 ost_code = ACPI_OST_SC_EJECT_IN_PROGRESS; 910 acpi_evaluate_hotplug_ost(handle, type, ost_code, NULL); 911 break; 912 913 case ACPI_NOTIFY_DEVICE_WAKE: 914 return; 915 916 case ACPI_NOTIFY_FREQUENCY_MISMATCH: 917 acpi_handle_err(handle, "Device cannot be configured due " 918 "to a frequency mismatch\n"); 919 goto out; 920 921 case ACPI_NOTIFY_BUS_MODE_MISMATCH: 922 acpi_handle_err(handle, "Device cannot be configured due " 923 "to a bus mode mismatch\n"); 924 goto out; 925 926 case ACPI_NOTIFY_POWER_FAULT: 927 acpi_handle_err(handle, "Device has suffered a power fault\n"); 928 goto out; 929 930 default: 931 acpi_handle_warn(handle, "Unsupported event type 0x%x\n", type); 932 ost_code = ACPI_OST_SC_UNRECOGNIZED_NOTIFY; 933 goto out; 934 } 935 936 mutex_lock(&acpiphp_context_lock); 937 context = acpiphp_get_context(handle); 938 if (!context || WARN_ON(context->adev->handle != handle) 939 || context->func.parent->is_going_away) 940 goto err_out; 941 942 get_bridge(context->func.parent); 943 acpiphp_put_context(context); 944 status = acpi_hotplug_execute(hotplug_event_work, context, type); 945 if (ACPI_SUCCESS(status)) { 946 mutex_unlock(&acpiphp_context_lock); 947 return; 948 } 949 put_bridge(context->func.parent); 950 951 err_out: 952 mutex_unlock(&acpiphp_context_lock); 953 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE; 954 955 out: 956 acpi_evaluate_hotplug_ost(handle, type, ost_code, NULL); 957 } 958 959 /** 960 * acpiphp_enumerate_slots - Enumerate PCI slots for a given bus. 961 * @bus: PCI bus to enumerate the slots for. 962 * 963 * A "slot" is an object associated with a PCI device number. All functions 964 * (PCI devices) with the same bus and device number belong to the same slot. 965 */ 966 void acpiphp_enumerate_slots(struct pci_bus *bus) 967 { 968 struct acpiphp_bridge *bridge; 969 struct acpi_device *adev; 970 acpi_handle handle; 971 acpi_status status; 972 973 if (acpiphp_disabled) 974 return; 975 976 adev = ACPI_COMPANION(bus->bridge); 977 if (!adev) 978 return; 979 980 handle = adev->handle; 981 bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL); 982 if (!bridge) { 983 acpi_handle_err(handle, "No memory for bridge object\n"); 984 return; 985 } 986 987 INIT_LIST_HEAD(&bridge->slots); 988 kref_init(&bridge->ref); 989 bridge->pci_dev = pci_dev_get(bus->self); 990 bridge->pci_bus = bus; 991 992 /* 993 * Grab a ref to the subordinate PCI bus in case the bus is 994 * removed via PCI core logical hotplug. The ref pins the bus 995 * (which we access during module unload). 996 */ 997 get_device(&bus->dev); 998 999 if (!pci_is_root_bus(bridge->pci_bus)) { 1000 struct acpiphp_context *context; 1001 1002 /* 1003 * This bridge should have been registered as a hotplug function 1004 * under its parent, so the context should be there, unless the 1005 * parent is going to be handled by pciehp, in which case this 1006 * bridge is not interesting to us either. 1007 */ 1008 mutex_lock(&acpiphp_context_lock); 1009 context = acpiphp_get_context(handle); 1010 if (!context) { 1011 mutex_unlock(&acpiphp_context_lock); 1012 put_device(&bus->dev); 1013 pci_dev_put(bridge->pci_dev); 1014 kfree(bridge); 1015 return; 1016 } 1017 bridge->context = context; 1018 context->bridge = bridge; 1019 /* Get a reference to the parent bridge. */ 1020 get_bridge(context->func.parent); 1021 mutex_unlock(&acpiphp_context_lock); 1022 } 1023 1024 /* must be added to the list prior to calling register_slot */ 1025 mutex_lock(&bridge_mutex); 1026 list_add(&bridge->list, &bridge_list); 1027 mutex_unlock(&bridge_mutex); 1028 1029 /* register all slot objects under this bridge */ 1030 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1, 1031 register_slot, NULL, bridge, NULL); 1032 if (ACPI_FAILURE(status)) { 1033 acpi_handle_err(handle, "failed to register slots\n"); 1034 cleanup_bridge(bridge); 1035 put_bridge(bridge); 1036 } 1037 } 1038 1039 /** 1040 * acpiphp_remove_slots - Remove slot objects associated with a given bus. 1041 * @bus: PCI bus to remove the slot objects for. 1042 */ 1043 void acpiphp_remove_slots(struct pci_bus *bus) 1044 { 1045 struct acpiphp_bridge *bridge; 1046 1047 if (acpiphp_disabled) 1048 return; 1049 1050 mutex_lock(&bridge_mutex); 1051 list_for_each_entry(bridge, &bridge_list, list) 1052 if (bridge->pci_bus == bus) { 1053 mutex_unlock(&bridge_mutex); 1054 cleanup_bridge(bridge); 1055 put_bridge(bridge); 1056 return; 1057 } 1058 1059 mutex_unlock(&bridge_mutex); 1060 } 1061 1062 /** 1063 * acpiphp_enable_slot - power on slot 1064 * @slot: ACPI PHP slot 1065 */ 1066 int acpiphp_enable_slot(struct acpiphp_slot *slot) 1067 { 1068 pci_lock_rescan_remove(); 1069 1070 if (slot->flags & SLOT_IS_GOING_AWAY) 1071 return -ENODEV; 1072 1073 /* configure all functions */ 1074 if (!(slot->flags & SLOT_ENABLED)) 1075 enable_slot(slot); 1076 1077 pci_unlock_rescan_remove(); 1078 return 0; 1079 } 1080 1081 /** 1082 * acpiphp_disable_and_eject_slot - power off and eject slot 1083 * @slot: ACPI PHP slot 1084 */ 1085 static int acpiphp_disable_and_eject_slot(struct acpiphp_slot *slot) 1086 { 1087 struct acpiphp_func *func; 1088 1089 if (slot->flags & SLOT_IS_GOING_AWAY) 1090 return -ENODEV; 1091 1092 /* unconfigure all functions */ 1093 disable_slot(slot); 1094 1095 list_for_each_entry(func, &slot->funcs, sibling) 1096 if (func->flags & FUNC_HAS_EJ0) { 1097 acpi_handle handle = func_to_handle(func); 1098 1099 if (ACPI_FAILURE(acpi_evaluate_ej0(handle))) 1100 acpi_handle_err(handle, "_EJ0 failed\n"); 1101 1102 break; 1103 } 1104 1105 return 0; 1106 } 1107 1108 int acpiphp_disable_slot(struct acpiphp_slot *slot) 1109 { 1110 int ret; 1111 1112 pci_lock_rescan_remove(); 1113 ret = acpiphp_disable_and_eject_slot(slot); 1114 pci_unlock_rescan_remove(); 1115 return ret; 1116 } 1117 1118 /* 1119 * slot enabled: 1 1120 * slot disabled: 0 1121 */ 1122 u8 acpiphp_get_power_status(struct acpiphp_slot *slot) 1123 { 1124 return (slot->flags & SLOT_ENABLED); 1125 } 1126 1127 /* 1128 * latch open: 1 1129 * latch closed: 0 1130 */ 1131 u8 acpiphp_get_latch_status(struct acpiphp_slot *slot) 1132 { 1133 return !(get_slot_status(slot) & ACPI_STA_DEVICE_UI); 1134 } 1135 1136 /* 1137 * adapter presence : 1 1138 * absence : 0 1139 */ 1140 u8 acpiphp_get_adapter_status(struct acpiphp_slot *slot) 1141 { 1142 return !!get_slot_status(slot); 1143 } 1144