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 #include <linux/init.h> 43 #include <linux/module.h> 44 45 #include <linux/kernel.h> 46 #include <linux/pci.h> 47 #include <linux/pci_hotplug.h> 48 #include <linux/pci-acpi.h> 49 #include <linux/mutex.h> 50 #include <linux/slab.h> 51 #include <linux/acpi.h> 52 53 #include "../pci.h" 54 #include "acpiphp.h" 55 56 static LIST_HEAD(bridge_list); 57 58 #define MY_NAME "acpiphp_glue" 59 60 static void handle_hotplug_event_bridge (acpi_handle, u32, void *); 61 static void acpiphp_sanitize_bus(struct pci_bus *bus); 62 static void acpiphp_set_hpp_values(struct pci_bus *bus); 63 static void handle_hotplug_event_func(acpi_handle handle, u32 type, void *context); 64 65 /* callback routine to check for the existence of a pci dock device */ 66 static acpi_status 67 is_pci_dock_device(acpi_handle handle, u32 lvl, void *context, void **rv) 68 { 69 int *count = (int *)context; 70 71 if (is_dock_device(handle)) { 72 (*count)++; 73 return AE_CTRL_TERMINATE; 74 } else { 75 return AE_OK; 76 } 77 } 78 79 /* 80 * the _DCK method can do funny things... and sometimes not 81 * hah-hah funny. 82 * 83 * TBD - figure out a way to only call fixups for 84 * systems that require them. 85 */ 86 static int post_dock_fixups(struct notifier_block *nb, unsigned long val, 87 void *v) 88 { 89 struct acpiphp_func *func = container_of(nb, struct acpiphp_func, nb); 90 struct pci_bus *bus = func->slot->bridge->pci_bus; 91 u32 buses; 92 93 if (!bus->self) 94 return NOTIFY_OK; 95 96 /* fixup bad _DCK function that rewrites 97 * secondary bridge on slot 98 */ 99 pci_read_config_dword(bus->self, 100 PCI_PRIMARY_BUS, 101 &buses); 102 103 if (((buses >> 8) & 0xff) != bus->busn_res.start) { 104 buses = (buses & 0xff000000) 105 | ((unsigned int)(bus->primary) << 0) 106 | ((unsigned int)(bus->busn_res.start) << 8) 107 | ((unsigned int)(bus->busn_res.end) << 16); 108 pci_write_config_dword(bus->self, PCI_PRIMARY_BUS, buses); 109 } 110 return NOTIFY_OK; 111 } 112 113 114 static const struct acpi_dock_ops acpiphp_dock_ops = { 115 .handler = handle_hotplug_event_func, 116 }; 117 118 /* callback routine to register each ACPI PCI slot object */ 119 static acpi_status 120 register_slot(acpi_handle handle, u32 lvl, void *context, void **rv) 121 { 122 struct acpiphp_bridge *bridge = (struct acpiphp_bridge *)context; 123 struct acpiphp_slot *slot; 124 struct acpiphp_func *newfunc; 125 acpi_handle tmp; 126 acpi_status status = AE_OK; 127 unsigned long long adr, sun; 128 int device, function, retval; 129 struct pci_bus *pbus = bridge->pci_bus; 130 struct pci_dev *pdev; 131 132 if (!acpi_pci_check_ejectable(pbus, handle) && !is_dock_device(handle)) 133 return AE_OK; 134 135 pdev = pbus->self; 136 if (pdev && pci_is_pcie(pdev)) { 137 tmp = acpi_find_root_bridge_handle(pdev); 138 if (tmp) { 139 struct acpi_pci_root *root = acpi_pci_find_root(tmp); 140 141 if (root && (root->osc_control_set & 142 OSC_PCI_EXPRESS_NATIVE_HP_CONTROL)) 143 return AE_OK; 144 } 145 } 146 147 acpi_evaluate_integer(handle, "_ADR", NULL, &adr); 148 device = (adr >> 16) & 0xffff; 149 function = adr & 0xffff; 150 151 newfunc = kzalloc(sizeof(struct acpiphp_func), GFP_KERNEL); 152 if (!newfunc) 153 return AE_NO_MEMORY; 154 155 INIT_LIST_HEAD(&newfunc->sibling); 156 newfunc->handle = handle; 157 newfunc->function = function; 158 159 if (ACPI_SUCCESS(acpi_get_handle(handle, "_EJ0", &tmp))) 160 newfunc->flags = FUNC_HAS_EJ0; 161 162 if (ACPI_SUCCESS(acpi_get_handle(handle, "_STA", &tmp))) 163 newfunc->flags |= FUNC_HAS_STA; 164 165 if (ACPI_SUCCESS(acpi_get_handle(handle, "_PS0", &tmp))) 166 newfunc->flags |= FUNC_HAS_PS0; 167 168 if (ACPI_SUCCESS(acpi_get_handle(handle, "_PS3", &tmp))) 169 newfunc->flags |= FUNC_HAS_PS3; 170 171 if (ACPI_SUCCESS(acpi_get_handle(handle, "_DCK", &tmp))) 172 newfunc->flags |= FUNC_HAS_DCK; 173 174 status = acpi_evaluate_integer(handle, "_SUN", NULL, &sun); 175 if (ACPI_FAILURE(status)) { 176 /* 177 * use the count of the number of slots we've found 178 * for the number of the slot 179 */ 180 sun = bridge->nr_slots+1; 181 } 182 183 /* search for objects that share the same slot */ 184 for (slot = bridge->slots; slot; slot = slot->next) 185 if (slot->device == device) { 186 if (slot->sun != sun) 187 warn("sibling found, but _SUN doesn't match!\n"); 188 break; 189 } 190 191 if (!slot) { 192 slot = kzalloc(sizeof(struct acpiphp_slot), GFP_KERNEL); 193 if (!slot) { 194 kfree(newfunc); 195 return AE_NO_MEMORY; 196 } 197 198 slot->bridge = bridge; 199 slot->device = device; 200 slot->sun = sun; 201 INIT_LIST_HEAD(&slot->funcs); 202 mutex_init(&slot->crit_sect); 203 204 slot->next = bridge->slots; 205 bridge->slots = slot; 206 207 bridge->nr_slots++; 208 209 dbg("found ACPI PCI Hotplug slot %llu at PCI %04x:%02x:%02x\n", 210 slot->sun, pci_domain_nr(pbus), pbus->number, device); 211 retval = acpiphp_register_hotplug_slot(slot); 212 if (retval) { 213 if (retval == -EBUSY) 214 warn("Slot %llu already registered by another " 215 "hotplug driver\n", slot->sun); 216 else 217 warn("acpiphp_register_hotplug_slot failed " 218 "(err code = 0x%x)\n", retval); 219 goto err_exit; 220 } 221 } 222 223 newfunc->slot = slot; 224 list_add_tail(&newfunc->sibling, &slot->funcs); 225 226 pdev = pci_get_slot(pbus, PCI_DEVFN(device, function)); 227 if (pdev) { 228 slot->flags |= (SLOT_ENABLED | SLOT_POWEREDON); 229 pci_dev_put(pdev); 230 } 231 232 if (is_dock_device(handle)) { 233 /* we don't want to call this device's _EJ0 234 * because we want the dock notify handler 235 * to call it after it calls _DCK 236 */ 237 newfunc->flags &= ~FUNC_HAS_EJ0; 238 if (register_hotplug_dock_device(handle, 239 &acpiphp_dock_ops, newfunc)) 240 dbg("failed to register dock device\n"); 241 242 /* we need to be notified when dock events happen 243 * outside of the hotplug operation, since we may 244 * need to do fixups before we can hotplug. 245 */ 246 newfunc->nb.notifier_call = post_dock_fixups; 247 if (register_dock_notifier(&newfunc->nb)) 248 dbg("failed to register a dock notifier"); 249 } 250 251 /* install notify handler */ 252 if (!(newfunc->flags & FUNC_HAS_DCK)) { 253 status = acpi_install_notify_handler(handle, 254 ACPI_SYSTEM_NOTIFY, 255 handle_hotplug_event_func, 256 newfunc); 257 258 if (ACPI_FAILURE(status)) 259 err("failed to register interrupt notify handler\n"); 260 } else 261 status = AE_OK; 262 263 return status; 264 265 err_exit: 266 bridge->nr_slots--; 267 bridge->slots = slot->next; 268 kfree(slot); 269 kfree(newfunc); 270 271 return AE_OK; 272 } 273 274 275 /* see if it's worth looking at this bridge */ 276 static int detect_ejectable_slots(acpi_handle handle) 277 { 278 int found = acpi_pci_detect_ejectable(handle); 279 if (!found) { 280 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1, 281 is_pci_dock_device, NULL, (void *)&found, NULL); 282 } 283 return found; 284 } 285 286 /* initialize miscellaneous stuff for both root and PCI-to-PCI bridge */ 287 static void init_bridge_misc(struct acpiphp_bridge *bridge) 288 { 289 acpi_status status; 290 291 /* must be added to the list prior to calling register_slot */ 292 list_add(&bridge->list, &bridge_list); 293 294 /* register all slot objects under this bridge */ 295 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge->handle, (u32)1, 296 register_slot, NULL, bridge, NULL); 297 if (ACPI_FAILURE(status)) { 298 list_del(&bridge->list); 299 return; 300 } 301 302 /* install notify handler */ 303 if (bridge->type != BRIDGE_TYPE_HOST) { 304 if ((bridge->flags & BRIDGE_HAS_EJ0) && bridge->func) { 305 status = acpi_remove_notify_handler(bridge->func->handle, 306 ACPI_SYSTEM_NOTIFY, 307 handle_hotplug_event_func); 308 if (ACPI_FAILURE(status)) 309 err("failed to remove notify handler\n"); 310 } 311 status = acpi_install_notify_handler(bridge->handle, 312 ACPI_SYSTEM_NOTIFY, 313 handle_hotplug_event_bridge, 314 bridge); 315 316 if (ACPI_FAILURE(status)) { 317 err("failed to register interrupt notify handler\n"); 318 } 319 } 320 } 321 322 323 /* find acpiphp_func from acpiphp_bridge */ 324 static struct acpiphp_func *acpiphp_bridge_handle_to_function(acpi_handle handle) 325 { 326 struct acpiphp_bridge *bridge; 327 struct acpiphp_slot *slot; 328 struct acpiphp_func *func; 329 330 list_for_each_entry(bridge, &bridge_list, list) { 331 for (slot = bridge->slots; slot; slot = slot->next) { 332 list_for_each_entry(func, &slot->funcs, sibling) { 333 if (func->handle == handle) 334 return func; 335 } 336 } 337 } 338 339 return NULL; 340 } 341 342 343 static inline void config_p2p_bridge_flags(struct acpiphp_bridge *bridge) 344 { 345 acpi_handle dummy_handle; 346 347 if (ACPI_SUCCESS(acpi_get_handle(bridge->handle, 348 "_STA", &dummy_handle))) 349 bridge->flags |= BRIDGE_HAS_STA; 350 351 if (ACPI_SUCCESS(acpi_get_handle(bridge->handle, 352 "_EJ0", &dummy_handle))) 353 bridge->flags |= BRIDGE_HAS_EJ0; 354 355 if (ACPI_SUCCESS(acpi_get_handle(bridge->handle, 356 "_PS0", &dummy_handle))) 357 bridge->flags |= BRIDGE_HAS_PS0; 358 359 if (ACPI_SUCCESS(acpi_get_handle(bridge->handle, 360 "_PS3", &dummy_handle))) 361 bridge->flags |= BRIDGE_HAS_PS3; 362 363 /* is this ejectable p2p bridge? */ 364 if (bridge->flags & BRIDGE_HAS_EJ0) { 365 struct acpiphp_func *func; 366 367 dbg("found ejectable p2p bridge\n"); 368 369 /* make link between PCI bridge and PCI function */ 370 func = acpiphp_bridge_handle_to_function(bridge->handle); 371 if (!func) 372 return; 373 bridge->func = func; 374 func->bridge = bridge; 375 } 376 } 377 378 379 /* allocate and initialize host bridge data structure */ 380 static void add_host_bridge(acpi_handle *handle) 381 { 382 struct acpiphp_bridge *bridge; 383 struct acpi_pci_root *root = acpi_pci_find_root(handle); 384 385 bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL); 386 if (bridge == NULL) 387 return; 388 389 bridge->type = BRIDGE_TYPE_HOST; 390 bridge->handle = handle; 391 392 bridge->pci_bus = root->bus; 393 394 spin_lock_init(&bridge->res_lock); 395 396 init_bridge_misc(bridge); 397 } 398 399 400 /* allocate and initialize PCI-to-PCI bridge data structure */ 401 static void add_p2p_bridge(acpi_handle *handle) 402 { 403 struct acpiphp_bridge *bridge; 404 405 bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL); 406 if (bridge == NULL) { 407 err("out of memory\n"); 408 return; 409 } 410 411 bridge->type = BRIDGE_TYPE_P2P; 412 bridge->handle = handle; 413 config_p2p_bridge_flags(bridge); 414 415 bridge->pci_dev = acpi_get_pci_dev(handle); 416 bridge->pci_bus = bridge->pci_dev->subordinate; 417 if (!bridge->pci_bus) { 418 err("This is not a PCI-to-PCI bridge!\n"); 419 goto err; 420 } 421 422 /* 423 * Grab a ref to the subordinate PCI bus in case the bus is 424 * removed via PCI core logical hotplug. The ref pins the bus 425 * (which we access during module unload). 426 */ 427 get_device(&bridge->pci_bus->dev); 428 spin_lock_init(&bridge->res_lock); 429 430 init_bridge_misc(bridge); 431 return; 432 err: 433 pci_dev_put(bridge->pci_dev); 434 kfree(bridge); 435 return; 436 } 437 438 439 /* callback routine to find P2P bridges */ 440 static acpi_status 441 find_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv) 442 { 443 acpi_status status; 444 struct pci_dev *dev; 445 446 dev = acpi_get_pci_dev(handle); 447 if (!dev || !dev->subordinate) 448 goto out; 449 450 /* check if this bridge has ejectable slots */ 451 if ((detect_ejectable_slots(handle) > 0)) { 452 dbg("found PCI-to-PCI bridge at PCI %s\n", pci_name(dev)); 453 add_p2p_bridge(handle); 454 } 455 456 /* search P2P bridges under this p2p bridge */ 457 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1, 458 find_p2p_bridge, NULL, NULL, NULL); 459 if (ACPI_FAILURE(status)) 460 warn("find_p2p_bridge failed (error code = 0x%x)\n", status); 461 462 out: 463 pci_dev_put(dev); 464 return AE_OK; 465 } 466 467 468 /* find hot-pluggable slots, and then find P2P bridge */ 469 static int add_bridge(acpi_handle handle) 470 { 471 acpi_status status; 472 unsigned long long tmp; 473 acpi_handle dummy_handle; 474 475 /* if the bridge doesn't have _STA, we assume it is always there */ 476 status = acpi_get_handle(handle, "_STA", &dummy_handle); 477 if (ACPI_SUCCESS(status)) { 478 status = acpi_evaluate_integer(handle, "_STA", NULL, &tmp); 479 if (ACPI_FAILURE(status)) { 480 dbg("%s: _STA evaluation failure\n", __func__); 481 return 0; 482 } 483 if ((tmp & ACPI_STA_FUNCTIONING) == 0) 484 /* don't register this object */ 485 return 0; 486 } 487 488 /* check if this bridge has ejectable slots */ 489 if (detect_ejectable_slots(handle) > 0) { 490 dbg("found PCI host-bus bridge with hot-pluggable slots\n"); 491 add_host_bridge(handle); 492 } 493 494 /* search P2P bridges under this host bridge */ 495 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1, 496 find_p2p_bridge, NULL, NULL, NULL); 497 498 if (ACPI_FAILURE(status)) 499 warn("find_p2p_bridge failed (error code = 0x%x)\n", status); 500 501 return 0; 502 } 503 504 static struct acpiphp_bridge *acpiphp_handle_to_bridge(acpi_handle handle) 505 { 506 struct acpiphp_bridge *bridge; 507 508 list_for_each_entry(bridge, &bridge_list, list) 509 if (bridge->handle == handle) 510 return bridge; 511 512 return NULL; 513 } 514 515 static void cleanup_bridge(struct acpiphp_bridge *bridge) 516 { 517 struct acpiphp_slot *slot, *next; 518 struct acpiphp_func *func, *tmp; 519 acpi_status status; 520 acpi_handle handle = bridge->handle; 521 522 status = acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY, 523 handle_hotplug_event_bridge); 524 if (ACPI_FAILURE(status)) 525 err("failed to remove notify handler\n"); 526 527 if ((bridge->type != BRIDGE_TYPE_HOST) && 528 ((bridge->flags & BRIDGE_HAS_EJ0) && bridge->func)) { 529 status = acpi_install_notify_handler(bridge->func->handle, 530 ACPI_SYSTEM_NOTIFY, 531 handle_hotplug_event_func, 532 bridge->func); 533 if (ACPI_FAILURE(status)) 534 err("failed to install interrupt notify handler\n"); 535 } 536 537 slot = bridge->slots; 538 while (slot) { 539 next = slot->next; 540 list_for_each_entry_safe(func, tmp, &slot->funcs, sibling) { 541 if (is_dock_device(func->handle)) { 542 unregister_hotplug_dock_device(func->handle); 543 unregister_dock_notifier(&func->nb); 544 } 545 if (!(func->flags & FUNC_HAS_DCK)) { 546 status = acpi_remove_notify_handler(func->handle, 547 ACPI_SYSTEM_NOTIFY, 548 handle_hotplug_event_func); 549 if (ACPI_FAILURE(status)) 550 err("failed to remove notify handler\n"); 551 } 552 list_del(&func->sibling); 553 kfree(func); 554 } 555 acpiphp_unregister_hotplug_slot(slot); 556 list_del(&slot->funcs); 557 kfree(slot); 558 slot = next; 559 } 560 561 /* 562 * Only P2P bridges have a pci_dev 563 */ 564 if (bridge->pci_dev) 565 put_device(&bridge->pci_bus->dev); 566 567 pci_dev_put(bridge->pci_dev); 568 list_del(&bridge->list); 569 kfree(bridge); 570 } 571 572 static acpi_status 573 cleanup_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv) 574 { 575 struct acpiphp_bridge *bridge; 576 577 /* cleanup p2p bridges under this P2P bridge 578 in a depth-first manner */ 579 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1, 580 cleanup_p2p_bridge, NULL, NULL, NULL); 581 582 bridge = acpiphp_handle_to_bridge(handle); 583 if (bridge) 584 cleanup_bridge(bridge); 585 586 return AE_OK; 587 } 588 589 static void remove_bridge(acpi_handle handle) 590 { 591 struct acpiphp_bridge *bridge; 592 593 /* cleanup p2p bridges under this host bridge 594 in a depth-first manner */ 595 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 596 (u32)1, cleanup_p2p_bridge, NULL, NULL, NULL); 597 598 /* 599 * On root bridges with hotplug slots directly underneath (ie, 600 * no p2p bridge between), we call cleanup_bridge(). 601 * 602 * The else clause cleans up root bridges that either had no 603 * hotplug slots at all, or had a p2p bridge underneath. 604 */ 605 bridge = acpiphp_handle_to_bridge(handle); 606 if (bridge) 607 cleanup_bridge(bridge); 608 else 609 acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY, 610 handle_hotplug_event_bridge); 611 } 612 613 static int power_on_slot(struct acpiphp_slot *slot) 614 { 615 acpi_status status; 616 struct acpiphp_func *func; 617 int retval = 0; 618 619 /* if already enabled, just skip */ 620 if (slot->flags & SLOT_POWEREDON) 621 goto err_exit; 622 623 list_for_each_entry(func, &slot->funcs, sibling) { 624 if (func->flags & FUNC_HAS_PS0) { 625 dbg("%s: executing _PS0\n", __func__); 626 status = acpi_evaluate_object(func->handle, "_PS0", NULL, NULL); 627 if (ACPI_FAILURE(status)) { 628 warn("%s: _PS0 failed\n", __func__); 629 retval = -1; 630 goto err_exit; 631 } else 632 break; 633 } 634 } 635 636 /* TBD: evaluate _STA to check if the slot is enabled */ 637 638 slot->flags |= SLOT_POWEREDON; 639 640 err_exit: 641 return retval; 642 } 643 644 645 static int power_off_slot(struct acpiphp_slot *slot) 646 { 647 acpi_status status; 648 struct acpiphp_func *func; 649 650 int retval = 0; 651 652 /* if already disabled, just skip */ 653 if ((slot->flags & SLOT_POWEREDON) == 0) 654 goto err_exit; 655 656 list_for_each_entry(func, &slot->funcs, sibling) { 657 if (func->flags & FUNC_HAS_PS3) { 658 status = acpi_evaluate_object(func->handle, "_PS3", NULL, NULL); 659 if (ACPI_FAILURE(status)) { 660 warn("%s: _PS3 failed\n", __func__); 661 retval = -1; 662 goto err_exit; 663 } else 664 break; 665 } 666 } 667 668 /* TBD: evaluate _STA to check if the slot is disabled */ 669 670 slot->flags &= (~SLOT_POWEREDON); 671 672 err_exit: 673 return retval; 674 } 675 676 677 678 /** 679 * acpiphp_max_busnr - return the highest reserved bus number under the given bus. 680 * @bus: bus to start search with 681 */ 682 static unsigned char acpiphp_max_busnr(struct pci_bus *bus) 683 { 684 struct list_head *tmp; 685 unsigned char max, n; 686 687 /* 688 * pci_bus_max_busnr will return the highest 689 * reserved busnr for all these children. 690 * that is equivalent to the bus->subordinate 691 * value. We don't want to use the parent's 692 * bus->subordinate value because it could have 693 * padding in it. 694 */ 695 max = bus->busn_res.start; 696 697 list_for_each(tmp, &bus->children) { 698 n = pci_bus_max_busnr(pci_bus_b(tmp)); 699 if (n > max) 700 max = n; 701 } 702 return max; 703 } 704 705 706 /** 707 * acpiphp_bus_add - add a new bus to acpi subsystem 708 * @func: acpiphp_func of the bridge 709 */ 710 static int acpiphp_bus_add(struct acpiphp_func *func) 711 { 712 acpi_handle phandle; 713 struct acpi_device *device, *pdevice; 714 int ret_val; 715 716 acpi_get_parent(func->handle, &phandle); 717 if (acpi_bus_get_device(phandle, &pdevice)) { 718 dbg("no parent device, assuming NULL\n"); 719 pdevice = NULL; 720 } 721 if (!acpi_bus_get_device(func->handle, &device)) { 722 dbg("bus exists... trim\n"); 723 /* this shouldn't be in here, so remove 724 * the bus then re-add it... 725 */ 726 ret_val = acpi_bus_trim(device, 1); 727 dbg("acpi_bus_trim return %x\n", ret_val); 728 } 729 730 ret_val = acpi_bus_add(&device, pdevice, func->handle, 731 ACPI_BUS_TYPE_DEVICE); 732 if (ret_val) { 733 dbg("error adding bus, %x\n", 734 -ret_val); 735 goto acpiphp_bus_add_out; 736 } 737 ret_val = acpi_bus_start(device); 738 739 acpiphp_bus_add_out: 740 return ret_val; 741 } 742 743 744 /** 745 * acpiphp_bus_trim - trim a bus from acpi subsystem 746 * @handle: handle to acpi namespace 747 */ 748 static int acpiphp_bus_trim(acpi_handle handle) 749 { 750 struct acpi_device *device; 751 int retval; 752 753 retval = acpi_bus_get_device(handle, &device); 754 if (retval) { 755 dbg("acpi_device not found\n"); 756 return retval; 757 } 758 759 retval = acpi_bus_trim(device, 1); 760 if (retval) 761 err("cannot remove from acpi list\n"); 762 763 return retval; 764 } 765 766 static void acpiphp_set_acpi_region(struct acpiphp_slot *slot) 767 { 768 struct acpiphp_func *func; 769 union acpi_object params[2]; 770 struct acpi_object_list arg_list; 771 772 list_for_each_entry(func, &slot->funcs, sibling) { 773 arg_list.count = 2; 774 arg_list.pointer = params; 775 params[0].type = ACPI_TYPE_INTEGER; 776 params[0].integer.value = ACPI_ADR_SPACE_PCI_CONFIG; 777 params[1].type = ACPI_TYPE_INTEGER; 778 params[1].integer.value = 1; 779 /* _REG is optional, we don't care about if there is failure */ 780 acpi_evaluate_object(func->handle, "_REG", &arg_list, NULL); 781 } 782 } 783 784 /** 785 * enable_device - enable, configure a slot 786 * @slot: slot to be enabled 787 * 788 * This function should be called per *physical slot*, 789 * not per each slot object in ACPI namespace. 790 */ 791 static int __ref enable_device(struct acpiphp_slot *slot) 792 { 793 struct pci_dev *dev; 794 struct pci_bus *bus = slot->bridge->pci_bus; 795 struct acpiphp_func *func; 796 int retval = 0; 797 int num, max, pass; 798 acpi_status status; 799 800 if (slot->flags & SLOT_ENABLED) 801 goto err_exit; 802 803 num = pci_scan_slot(bus, PCI_DEVFN(slot->device, 0)); 804 if (num == 0) { 805 /* Maybe only part of funcs are added. */ 806 dbg("No new device found\n"); 807 goto err_exit; 808 } 809 810 max = acpiphp_max_busnr(bus); 811 for (pass = 0; pass < 2; pass++) { 812 list_for_each_entry(dev, &bus->devices, bus_list) { 813 if (PCI_SLOT(dev->devfn) != slot->device) 814 continue; 815 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE || 816 dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) { 817 max = pci_scan_bridge(bus, dev, max, pass); 818 if (pass && dev->subordinate) 819 pci_bus_size_bridges(dev->subordinate); 820 } 821 } 822 } 823 824 list_for_each_entry(func, &slot->funcs, sibling) 825 acpiphp_bus_add(func); 826 827 pci_bus_assign_resources(bus); 828 acpiphp_sanitize_bus(bus); 829 acpiphp_set_hpp_values(bus); 830 acpiphp_set_acpi_region(slot); 831 pci_enable_bridges(bus); 832 833 list_for_each_entry(dev, &bus->devices, bus_list) { 834 /* Assume that newly added devices are powered on already. */ 835 if (!dev->is_added) 836 dev->current_state = PCI_D0; 837 } 838 839 pci_bus_add_devices(bus); 840 841 slot->flags |= SLOT_ENABLED; 842 list_for_each_entry(func, &slot->funcs, sibling) { 843 dev = pci_get_slot(bus, PCI_DEVFN(slot->device, 844 func->function)); 845 if (!dev) { 846 /* Do not set SLOT_ENABLED flag if some funcs 847 are not added. */ 848 slot->flags &= (~SLOT_ENABLED); 849 continue; 850 } 851 852 if (dev->hdr_type != PCI_HEADER_TYPE_BRIDGE && 853 dev->hdr_type != PCI_HEADER_TYPE_CARDBUS) { 854 pci_dev_put(dev); 855 continue; 856 } 857 858 status = find_p2p_bridge(func->handle, (u32)1, bus, NULL); 859 if (ACPI_FAILURE(status)) 860 warn("find_p2p_bridge failed (error code = 0x%x)\n", 861 status); 862 pci_dev_put(dev); 863 } 864 865 866 err_exit: 867 return retval; 868 } 869 870 static void disable_bridges(struct pci_bus *bus) 871 { 872 struct pci_dev *dev; 873 list_for_each_entry(dev, &bus->devices, bus_list) { 874 if (dev->subordinate) { 875 disable_bridges(dev->subordinate); 876 pci_disable_device(dev); 877 } 878 } 879 } 880 881 /** 882 * disable_device - disable a slot 883 * @slot: ACPI PHP slot 884 */ 885 static int disable_device(struct acpiphp_slot *slot) 886 { 887 struct acpiphp_func *func; 888 struct pci_dev *pdev; 889 struct pci_bus *bus = slot->bridge->pci_bus; 890 891 /* The slot will be enabled when func 0 is added, so check 892 func 0 before disable the slot. */ 893 pdev = pci_get_slot(bus, PCI_DEVFN(slot->device, 0)); 894 if (!pdev) 895 goto err_exit; 896 pci_dev_put(pdev); 897 898 list_for_each_entry(func, &slot->funcs, sibling) { 899 if (func->bridge) { 900 /* cleanup p2p bridges under this P2P bridge */ 901 cleanup_p2p_bridge(func->bridge->handle, 902 (u32)1, NULL, NULL); 903 func->bridge = NULL; 904 } 905 906 pdev = pci_get_slot(slot->bridge->pci_bus, 907 PCI_DEVFN(slot->device, func->function)); 908 if (pdev) { 909 pci_stop_bus_device(pdev); 910 if (pdev->subordinate) { 911 disable_bridges(pdev->subordinate); 912 pci_disable_device(pdev); 913 } 914 __pci_remove_bus_device(pdev); 915 pci_dev_put(pdev); 916 } 917 } 918 919 list_for_each_entry(func, &slot->funcs, sibling) { 920 acpiphp_bus_trim(func->handle); 921 } 922 923 slot->flags &= (~SLOT_ENABLED); 924 925 err_exit: 926 return 0; 927 } 928 929 930 /** 931 * get_slot_status - get ACPI slot status 932 * @slot: ACPI PHP slot 933 * 934 * If a slot has _STA for each function and if any one of them 935 * returned non-zero status, return it. 936 * 937 * If a slot doesn't have _STA and if any one of its functions' 938 * configuration space is configured, return 0x0f as a _STA. 939 * 940 * Otherwise return 0. 941 */ 942 static unsigned int get_slot_status(struct acpiphp_slot *slot) 943 { 944 acpi_status status; 945 unsigned long long sta = 0; 946 u32 dvid; 947 struct acpiphp_func *func; 948 949 list_for_each_entry(func, &slot->funcs, sibling) { 950 if (func->flags & FUNC_HAS_STA) { 951 status = acpi_evaluate_integer(func->handle, "_STA", NULL, &sta); 952 if (ACPI_SUCCESS(status) && sta) 953 break; 954 } else { 955 pci_bus_read_config_dword(slot->bridge->pci_bus, 956 PCI_DEVFN(slot->device, 957 func->function), 958 PCI_VENDOR_ID, &dvid); 959 if (dvid != 0xffffffff) { 960 sta = ACPI_STA_ALL; 961 break; 962 } 963 } 964 } 965 966 return (unsigned int)sta; 967 } 968 969 /** 970 * acpiphp_eject_slot - physically eject the slot 971 * @slot: ACPI PHP slot 972 */ 973 int acpiphp_eject_slot(struct acpiphp_slot *slot) 974 { 975 acpi_status status; 976 struct acpiphp_func *func; 977 struct acpi_object_list arg_list; 978 union acpi_object arg; 979 980 list_for_each_entry(func, &slot->funcs, sibling) { 981 /* We don't want to call _EJ0 on non-existing functions. */ 982 if ((func->flags & FUNC_HAS_EJ0)) { 983 /* _EJ0 method take one argument */ 984 arg_list.count = 1; 985 arg_list.pointer = &arg; 986 arg.type = ACPI_TYPE_INTEGER; 987 arg.integer.value = 1; 988 989 status = acpi_evaluate_object(func->handle, "_EJ0", &arg_list, NULL); 990 if (ACPI_FAILURE(status)) { 991 warn("%s: _EJ0 failed\n", __func__); 992 return -1; 993 } else 994 break; 995 } 996 } 997 return 0; 998 } 999 1000 /** 1001 * acpiphp_check_bridge - re-enumerate devices 1002 * @bridge: where to begin re-enumeration 1003 * 1004 * Iterate over all slots under this bridge and make sure that if a 1005 * card is present they are enabled, and if not they are disabled. 1006 */ 1007 static int acpiphp_check_bridge(struct acpiphp_bridge *bridge) 1008 { 1009 struct acpiphp_slot *slot; 1010 int retval = 0; 1011 int enabled, disabled; 1012 1013 enabled = disabled = 0; 1014 1015 for (slot = bridge->slots; slot; slot = slot->next) { 1016 unsigned int status = get_slot_status(slot); 1017 if (slot->flags & SLOT_ENABLED) { 1018 if (status == ACPI_STA_ALL) 1019 continue; 1020 retval = acpiphp_disable_slot(slot); 1021 if (retval) { 1022 err("Error occurred in disabling\n"); 1023 goto err_exit; 1024 } else { 1025 acpiphp_eject_slot(slot); 1026 } 1027 disabled++; 1028 } else { 1029 if (status != ACPI_STA_ALL) 1030 continue; 1031 retval = acpiphp_enable_slot(slot); 1032 if (retval) { 1033 err("Error occurred in enabling\n"); 1034 goto err_exit; 1035 } 1036 enabled++; 1037 } 1038 } 1039 1040 dbg("%s: %d enabled, %d disabled\n", __func__, enabled, disabled); 1041 1042 err_exit: 1043 return retval; 1044 } 1045 1046 static void acpiphp_set_hpp_values(struct pci_bus *bus) 1047 { 1048 struct pci_dev *dev; 1049 1050 list_for_each_entry(dev, &bus->devices, bus_list) 1051 pci_configure_slot(dev); 1052 } 1053 1054 /* 1055 * Remove devices for which we could not assign resources, call 1056 * arch specific code to fix-up the bus 1057 */ 1058 static void acpiphp_sanitize_bus(struct pci_bus *bus) 1059 { 1060 struct pci_dev *dev; 1061 int i; 1062 unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM; 1063 1064 list_for_each_entry(dev, &bus->devices, bus_list) { 1065 for (i=0; i<PCI_BRIDGE_RESOURCES; i++) { 1066 struct resource *res = &dev->resource[i]; 1067 if ((res->flags & type_mask) && !res->start && 1068 res->end) { 1069 /* Could not assign a required resources 1070 * for this device, remove it */ 1071 pci_stop_and_remove_bus_device(dev); 1072 break; 1073 } 1074 } 1075 } 1076 } 1077 1078 /* Program resources in newly inserted bridge */ 1079 static int acpiphp_configure_bridge (acpi_handle handle) 1080 { 1081 struct pci_bus *bus; 1082 1083 if (acpi_is_root_bridge(handle)) { 1084 struct acpi_pci_root *root = acpi_pci_find_root(handle); 1085 bus = root->bus; 1086 } else { 1087 struct pci_dev *pdev = acpi_get_pci_dev(handle); 1088 bus = pdev->subordinate; 1089 pci_dev_put(pdev); 1090 } 1091 1092 pci_bus_size_bridges(bus); 1093 pci_bus_assign_resources(bus); 1094 acpiphp_sanitize_bus(bus); 1095 acpiphp_set_hpp_values(bus); 1096 pci_enable_bridges(bus); 1097 return 0; 1098 } 1099 1100 static void handle_bridge_insertion(acpi_handle handle, u32 type) 1101 { 1102 struct acpi_device *device, *pdevice; 1103 acpi_handle phandle; 1104 1105 if ((type != ACPI_NOTIFY_BUS_CHECK) && 1106 (type != ACPI_NOTIFY_DEVICE_CHECK)) { 1107 err("unexpected notification type %d\n", type); 1108 return; 1109 } 1110 1111 acpi_get_parent(handle, &phandle); 1112 if (acpi_bus_get_device(phandle, &pdevice)) { 1113 dbg("no parent device, assuming NULL\n"); 1114 pdevice = NULL; 1115 } 1116 if (acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE)) { 1117 err("cannot add bridge to acpi list\n"); 1118 return; 1119 } 1120 if (!acpiphp_configure_bridge(handle) && 1121 !acpi_bus_start(device)) 1122 add_bridge(handle); 1123 else 1124 err("cannot configure and start bridge\n"); 1125 1126 } 1127 1128 /* 1129 * ACPI event handlers 1130 */ 1131 1132 static acpi_status 1133 count_sub_bridges(acpi_handle handle, u32 lvl, void *context, void **rv) 1134 { 1135 int *count = (int *)context; 1136 struct acpiphp_bridge *bridge; 1137 1138 bridge = acpiphp_handle_to_bridge(handle); 1139 if (bridge) 1140 (*count)++; 1141 return AE_OK ; 1142 } 1143 1144 static acpi_status 1145 check_sub_bridges(acpi_handle handle, u32 lvl, void *context, void **rv) 1146 { 1147 struct acpiphp_bridge *bridge; 1148 char objname[64]; 1149 struct acpi_buffer buffer = { .length = sizeof(objname), 1150 .pointer = objname }; 1151 1152 bridge = acpiphp_handle_to_bridge(handle); 1153 if (bridge) { 1154 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer); 1155 dbg("%s: re-enumerating slots under %s\n", 1156 __func__, objname); 1157 acpiphp_check_bridge(bridge); 1158 } 1159 return AE_OK ; 1160 } 1161 1162 struct acpiphp_hp_work { 1163 struct work_struct work; 1164 acpi_handle handle; 1165 u32 type; 1166 void *context; 1167 }; 1168 1169 static void alloc_acpiphp_hp_work(acpi_handle handle, u32 type, 1170 void *context, 1171 void (*func)(struct work_struct *work)) 1172 { 1173 struct acpiphp_hp_work *hp_work; 1174 int ret; 1175 1176 hp_work = kmalloc(sizeof(*hp_work), GFP_KERNEL); 1177 if (!hp_work) 1178 return; 1179 1180 hp_work->handle = handle; 1181 hp_work->type = type; 1182 hp_work->context = context; 1183 1184 INIT_WORK(&hp_work->work, func); 1185 ret = queue_work(kacpi_hotplug_wq, &hp_work->work); 1186 if (!ret) 1187 kfree(hp_work); 1188 } 1189 1190 static void _handle_hotplug_event_bridge(struct work_struct *work) 1191 { 1192 struct acpiphp_bridge *bridge; 1193 char objname[64]; 1194 struct acpi_buffer buffer = { .length = sizeof(objname), 1195 .pointer = objname }; 1196 struct acpi_device *device; 1197 int num_sub_bridges = 0; 1198 struct acpiphp_hp_work *hp_work; 1199 acpi_handle handle; 1200 u32 type; 1201 1202 hp_work = container_of(work, struct acpiphp_hp_work, work); 1203 handle = hp_work->handle; 1204 type = hp_work->type; 1205 1206 if (acpi_bus_get_device(handle, &device)) { 1207 /* This bridge must have just been physically inserted */ 1208 handle_bridge_insertion(handle, type); 1209 goto out; 1210 } 1211 1212 bridge = acpiphp_handle_to_bridge(handle); 1213 if (type == ACPI_NOTIFY_BUS_CHECK) { 1214 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, ACPI_UINT32_MAX, 1215 count_sub_bridges, NULL, &num_sub_bridges, NULL); 1216 } 1217 1218 if (!bridge && !num_sub_bridges) { 1219 err("cannot get bridge info\n"); 1220 goto out; 1221 } 1222 1223 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer); 1224 1225 switch (type) { 1226 case ACPI_NOTIFY_BUS_CHECK: 1227 /* bus re-enumerate */ 1228 dbg("%s: Bus check notify on %s\n", __func__, objname); 1229 if (bridge) { 1230 dbg("%s: re-enumerating slots under %s\n", 1231 __func__, objname); 1232 acpiphp_check_bridge(bridge); 1233 } 1234 if (num_sub_bridges) 1235 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1236 ACPI_UINT32_MAX, check_sub_bridges, NULL, NULL, NULL); 1237 break; 1238 1239 case ACPI_NOTIFY_DEVICE_CHECK: 1240 /* device check */ 1241 dbg("%s: Device check notify on %s\n", __func__, objname); 1242 acpiphp_check_bridge(bridge); 1243 break; 1244 1245 case ACPI_NOTIFY_DEVICE_WAKE: 1246 /* wake event */ 1247 dbg("%s: Device wake notify on %s\n", __func__, objname); 1248 break; 1249 1250 case ACPI_NOTIFY_EJECT_REQUEST: 1251 /* request device eject */ 1252 dbg("%s: Device eject notify on %s\n", __func__, objname); 1253 if ((bridge->type != BRIDGE_TYPE_HOST) && 1254 (bridge->flags & BRIDGE_HAS_EJ0)) { 1255 struct acpiphp_slot *slot; 1256 slot = bridge->func->slot; 1257 if (!acpiphp_disable_slot(slot)) 1258 acpiphp_eject_slot(slot); 1259 } 1260 break; 1261 1262 case ACPI_NOTIFY_FREQUENCY_MISMATCH: 1263 printk(KERN_ERR "Device %s cannot be configured due" 1264 " to a frequency mismatch\n", objname); 1265 break; 1266 1267 case ACPI_NOTIFY_BUS_MODE_MISMATCH: 1268 printk(KERN_ERR "Device %s cannot be configured due" 1269 " to a bus mode mismatch\n", objname); 1270 break; 1271 1272 case ACPI_NOTIFY_POWER_FAULT: 1273 printk(KERN_ERR "Device %s has suffered a power fault\n", 1274 objname); 1275 break; 1276 1277 default: 1278 warn("notify_handler: unknown event type 0x%x for %s\n", type, objname); 1279 break; 1280 } 1281 1282 out: 1283 kfree(hp_work); /* allocated in handle_hotplug_event_bridge */ 1284 } 1285 1286 /** 1287 * handle_hotplug_event_bridge - handle ACPI event on bridges 1288 * @handle: Notify()'ed acpi_handle 1289 * @type: Notify code 1290 * @context: pointer to acpiphp_bridge structure 1291 * 1292 * Handles ACPI event notification on {host,p2p} bridges. 1293 */ 1294 static void handle_hotplug_event_bridge(acpi_handle handle, u32 type, 1295 void *context) 1296 { 1297 /* 1298 * Currently the code adds all hotplug events to the kacpid_wq 1299 * queue when it should add hotplug events to the kacpi_hotplug_wq. 1300 * The proper way to fix this is to reorganize the code so that 1301 * drivers (dock, etc.) do not call acpi_os_execute(), etc. 1302 * For now just re-add this work to the kacpi_hotplug_wq so we 1303 * don't deadlock on hotplug actions. 1304 */ 1305 alloc_acpiphp_hp_work(handle, type, context, 1306 _handle_hotplug_event_bridge); 1307 } 1308 1309 static void _handle_hotplug_event_func(struct work_struct *work) 1310 { 1311 struct acpiphp_func *func; 1312 char objname[64]; 1313 struct acpi_buffer buffer = { .length = sizeof(objname), 1314 .pointer = objname }; 1315 struct acpiphp_hp_work *hp_work; 1316 acpi_handle handle; 1317 u32 type; 1318 void *context; 1319 1320 hp_work = container_of(work, struct acpiphp_hp_work, work); 1321 handle = hp_work->handle; 1322 type = hp_work->type; 1323 context = hp_work->context; 1324 1325 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer); 1326 1327 func = (struct acpiphp_func *)context; 1328 1329 switch (type) { 1330 case ACPI_NOTIFY_BUS_CHECK: 1331 /* bus re-enumerate */ 1332 dbg("%s: Bus check notify on %s\n", __func__, objname); 1333 acpiphp_enable_slot(func->slot); 1334 break; 1335 1336 case ACPI_NOTIFY_DEVICE_CHECK: 1337 /* device check : re-enumerate from parent bus */ 1338 dbg("%s: Device check notify on %s\n", __func__, objname); 1339 acpiphp_check_bridge(func->slot->bridge); 1340 break; 1341 1342 case ACPI_NOTIFY_DEVICE_WAKE: 1343 /* wake event */ 1344 dbg("%s: Device wake notify on %s\n", __func__, objname); 1345 break; 1346 1347 case ACPI_NOTIFY_EJECT_REQUEST: 1348 /* request device eject */ 1349 dbg("%s: Device eject notify on %s\n", __func__, objname); 1350 if (!(acpiphp_disable_slot(func->slot))) 1351 acpiphp_eject_slot(func->slot); 1352 break; 1353 1354 default: 1355 warn("notify_handler: unknown event type 0x%x for %s\n", type, objname); 1356 break; 1357 } 1358 1359 kfree(hp_work); /* allocated in handle_hotplug_event_func */ 1360 } 1361 1362 /** 1363 * handle_hotplug_event_func - handle ACPI event on functions (i.e. slots) 1364 * @handle: Notify()'ed acpi_handle 1365 * @type: Notify code 1366 * @context: pointer to acpiphp_func structure 1367 * 1368 * Handles ACPI event notification on slots. 1369 */ 1370 static void handle_hotplug_event_func(acpi_handle handle, u32 type, 1371 void *context) 1372 { 1373 /* 1374 * Currently the code adds all hotplug events to the kacpid_wq 1375 * queue when it should add hotplug events to the kacpi_hotplug_wq. 1376 * The proper way to fix this is to reorganize the code so that 1377 * drivers (dock, etc.) do not call acpi_os_execute(), etc. 1378 * For now just re-add this work to the kacpi_hotplug_wq so we 1379 * don't deadlock on hotplug actions. 1380 */ 1381 alloc_acpiphp_hp_work(handle, type, context, 1382 _handle_hotplug_event_func); 1383 } 1384 1385 static acpi_status 1386 find_root_bridges(acpi_handle handle, u32 lvl, void *context, void **rv) 1387 { 1388 int *count = (int *)context; 1389 1390 if (!acpi_is_root_bridge(handle)) 1391 return AE_OK; 1392 1393 (*count)++; 1394 acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY, 1395 handle_hotplug_event_bridge, NULL); 1396 1397 return AE_OK ; 1398 } 1399 1400 static struct acpi_pci_driver acpi_pci_hp_driver = { 1401 .add = add_bridge, 1402 .remove = remove_bridge, 1403 }; 1404 1405 /** 1406 * acpiphp_glue_init - initializes all PCI hotplug - ACPI glue data structures 1407 */ 1408 int __init acpiphp_glue_init(void) 1409 { 1410 int num = 0; 1411 1412 acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 1413 ACPI_UINT32_MAX, find_root_bridges, NULL, &num, NULL); 1414 1415 if (num <= 0) 1416 return -1; 1417 else 1418 acpi_pci_register_driver(&acpi_pci_hp_driver); 1419 1420 return 0; 1421 } 1422 1423 1424 /** 1425 * acpiphp_glue_exit - terminates all PCI hotplug - ACPI glue data structures 1426 * 1427 * This function frees all data allocated in acpiphp_glue_init(). 1428 */ 1429 void acpiphp_glue_exit(void) 1430 { 1431 acpi_pci_unregister_driver(&acpi_pci_hp_driver); 1432 } 1433 1434 1435 /** 1436 * acpiphp_get_num_slots - count number of slots in a system 1437 */ 1438 int __init acpiphp_get_num_slots(void) 1439 { 1440 struct acpiphp_bridge *bridge; 1441 int num_slots = 0; 1442 1443 list_for_each_entry(bridge, &bridge_list, list) { 1444 dbg("Bus %04x:%02x has %d slot%s\n", 1445 pci_domain_nr(bridge->pci_bus), 1446 bridge->pci_bus->number, bridge->nr_slots, 1447 bridge->nr_slots == 1 ? "" : "s"); 1448 num_slots += bridge->nr_slots; 1449 } 1450 1451 dbg("Total %d slots\n", num_slots); 1452 return num_slots; 1453 } 1454 1455 1456 #if 0 1457 /** 1458 * acpiphp_for_each_slot - call function for each slot 1459 * @fn: callback function 1460 * @data: context to be passed to callback function 1461 */ 1462 static int acpiphp_for_each_slot(acpiphp_callback fn, void *data) 1463 { 1464 struct list_head *node; 1465 struct acpiphp_bridge *bridge; 1466 struct acpiphp_slot *slot; 1467 int retval = 0; 1468 1469 list_for_each (node, &bridge_list) { 1470 bridge = (struct acpiphp_bridge *)node; 1471 for (slot = bridge->slots; slot; slot = slot->next) { 1472 retval = fn(slot, data); 1473 if (!retval) 1474 goto err_exit; 1475 } 1476 } 1477 1478 err_exit: 1479 return retval; 1480 } 1481 #endif 1482 1483 1484 /** 1485 * acpiphp_enable_slot - power on slot 1486 * @slot: ACPI PHP slot 1487 */ 1488 int acpiphp_enable_slot(struct acpiphp_slot *slot) 1489 { 1490 int retval; 1491 1492 mutex_lock(&slot->crit_sect); 1493 1494 /* wake up all functions */ 1495 retval = power_on_slot(slot); 1496 if (retval) 1497 goto err_exit; 1498 1499 if (get_slot_status(slot) == ACPI_STA_ALL) { 1500 /* configure all functions */ 1501 retval = enable_device(slot); 1502 if (retval) 1503 power_off_slot(slot); 1504 } else { 1505 dbg("%s: Slot status is not ACPI_STA_ALL\n", __func__); 1506 power_off_slot(slot); 1507 } 1508 1509 err_exit: 1510 mutex_unlock(&slot->crit_sect); 1511 return retval; 1512 } 1513 1514 /** 1515 * acpiphp_disable_slot - power off slot 1516 * @slot: ACPI PHP slot 1517 */ 1518 int acpiphp_disable_slot(struct acpiphp_slot *slot) 1519 { 1520 int retval = 0; 1521 1522 mutex_lock(&slot->crit_sect); 1523 1524 /* unconfigure all functions */ 1525 retval = disable_device(slot); 1526 if (retval) 1527 goto err_exit; 1528 1529 /* power off all functions */ 1530 retval = power_off_slot(slot); 1531 if (retval) 1532 goto err_exit; 1533 1534 err_exit: 1535 mutex_unlock(&slot->crit_sect); 1536 return retval; 1537 } 1538 1539 1540 /* 1541 * slot enabled: 1 1542 * slot disabled: 0 1543 */ 1544 u8 acpiphp_get_power_status(struct acpiphp_slot *slot) 1545 { 1546 return (slot->flags & SLOT_POWEREDON); 1547 } 1548 1549 1550 /* 1551 * latch open: 1 1552 * latch closed: 0 1553 */ 1554 u8 acpiphp_get_latch_status(struct acpiphp_slot *slot) 1555 { 1556 unsigned int sta; 1557 1558 sta = get_slot_status(slot); 1559 1560 return (sta & ACPI_STA_SHOW_IN_UI) ? 0 : 1; 1561 } 1562 1563 1564 /* 1565 * adapter presence : 1 1566 * absence : 0 1567 */ 1568 u8 acpiphp_get_adapter_status(struct acpiphp_slot *slot) 1569 { 1570 unsigned int sta; 1571 1572 sta = get_slot_status(slot); 1573 1574 return (sta == 0) ? 0 : 1; 1575 } 1576