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