drivers/pci/hotplug/acpiphp_glue.c

   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->secondary) {
 104                 buses = (buses & 0xff000000)
 105                         | ((unsigned int)(bus->primary)     <<  0)
 106                         | ((unsigned int)(bus->secondary)   <<  8)
 107                         | ((unsigned int)(bus->subordinate) << 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->secondary;
 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
 897         list_for_each_entry(func, &slot->funcs, sibling) {
 898                 if (func->bridge) {
 899                         /* cleanup p2p bridges under this P2P bridge */
 900                         cleanup_p2p_bridge(func->bridge->handle,
 901                                                 (u32)1, NULL, NULL);
 902                         func->bridge = NULL;
 903                 }
 904
 905                 pdev = pci_get_slot(slot->bridge->pci_bus,
 906                                     PCI_DEVFN(slot->device, func->function));
 907                 if (pdev) {
 908                         pci_stop_bus_device(pdev);
 909                         if (pdev->subordinate) {
 910                                 disable_bridges(pdev->subordinate);
 911                                 pci_disable_device(pdev);
 912                         }
 913                         __pci_remove_bus_device(pdev);
 914                         pci_dev_put(pdev);
 915                 }
 916         }
 917
 918         list_for_each_entry(func, &slot->funcs, sibling) {
 919                 acpiphp_bus_trim(func->handle);
 920         }
 921
 922         slot->flags &= (~SLOT_ENABLED);
 923
 924 err_exit:
 925         return 0;
 926 }
 927
 928
 929 /**
 930  * get_slot_status - get ACPI slot status
 931  * @slot: ACPI PHP slot
 932  *
 933  * If a slot has _STA for each function and if any one of them
 934  * returned non-zero status, return it.
 935  *
 936  * If a slot doesn't have _STA and if any one of its functions'
 937  * configuration space is configured, return 0x0f as a _STA.
 938  *
 939  * Otherwise return 0.
 940  */
 941 static unsigned int get_slot_status(struct acpiphp_slot *slot)
 942 {
 943         acpi_status status;
 944         unsigned long long sta = 0;
 945         u32 dvid;
 946         struct acpiphp_func *func;
 947
 948         list_for_each_entry(func, &slot->funcs, sibling) {
 949                 if (func->flags & FUNC_HAS_STA) {
 950                         status = acpi_evaluate_integer(func->handle, "_STA", NULL, &sta);
 951                         if (ACPI_SUCCESS(status) && sta)
 952                                 break;
 953                 } else {
 954                         pci_bus_read_config_dword(slot->bridge->pci_bus,
 955                                                   PCI_DEVFN(slot->device,
 956                                                             func->function),
 957                                                   PCI_VENDOR_ID, &dvid);
 958                         if (dvid != 0xffffffff) {
 959                                 sta = ACPI_STA_ALL;
 960                                 break;
 961                         }
 962                 }
 963         }
 964
 965         return (unsigned int)sta;
 966 }
 967
 968 /**
 969  * acpiphp_eject_slot - physically eject the slot
 970  * @slot: ACPI PHP slot
 971  */
 972 int acpiphp_eject_slot(struct acpiphp_slot *slot)
 973 {
 974         acpi_status status;
 975         struct acpiphp_func *func;
 976         struct acpi_object_list arg_list;
 977         union acpi_object arg;
 978
 979         list_for_each_entry(func, &slot->funcs, sibling) {
 980                 /* We don't want to call _EJ0 on non-existing functions. */
 981                 if ((func->flags & FUNC_HAS_EJ0)) {
 982                         /* _EJ0 method take one argument */
 983                         arg_list.count = 1;
 984                         arg_list.pointer = &arg;
 985                         arg.type = ACPI_TYPE_INTEGER;
 986                         arg.integer.value = 1;
 987
 988                         status = acpi_evaluate_object(func->handle, "_EJ0", &arg_list, NULL);
 989                         if (ACPI_FAILURE(status)) {
 990                                 warn("%s: _EJ0 failed\n", __func__);
 991                                 return -1;
 992                         } else
 993                                 break;
 994                 }
 995         }
 996         return 0;
 997 }
 998
 999 /**
1000  * acpiphp_check_bridge - re-enumerate devices
1001  * @bridge: where to begin re-enumeration
1002  *
1003  * Iterate over all slots under this bridge and make sure that if a
1004  * card is present they are enabled, and if not they are disabled.
1005  */
1006 static int acpiphp_check_bridge(struct acpiphp_bridge *bridge)
1007 {
1008         struct acpiphp_slot *slot;
1009         int retval = 0;
1010         int enabled, disabled;
1011
1012         enabled = disabled = 0;
1013
1014         for (slot = bridge->slots; slot; slot = slot->next) {
1015                 unsigned int status = get_slot_status(slot);
1016                 if (slot->flags & SLOT_ENABLED) {
1017                         if (status == ACPI_STA_ALL)
1018                                 continue;
1019                         retval = acpiphp_disable_slot(slot);
1020                         if (retval) {
1021                                 err("Error occurred in disabling\n");
1022                                 goto err_exit;
1023                         } else {
1024                                 acpiphp_eject_slot(slot);
1025                         }
1026                         disabled++;
1027                 } else {
1028                         if (status != ACPI_STA_ALL)
1029                                 continue;
1030                         retval = acpiphp_enable_slot(slot);
1031                         if (retval) {
1032                                 err("Error occurred in enabling\n");
1033                                 goto err_exit;
1034                         }
1035                         enabled++;
1036                 }
1037         }
1038
1039         dbg("%s: %d enabled, %d disabled\n", __func__, enabled, disabled);
1040
1041  err_exit:
1042         return retval;
1043 }
1044
1045 static void acpiphp_set_hpp_values(struct pci_bus *bus)
1046 {
1047         struct pci_dev *dev;
1048
1049         list_for_each_entry(dev, &bus->devices, bus_list)
1050                 pci_configure_slot(dev);
1051 }
1052
1053 /*
1054  * Remove devices for which we could not assign resources, call
1055  * arch specific code to fix-up the bus
1056  */
1057 static void acpiphp_sanitize_bus(struct pci_bus *bus)
1058 {
1059         struct pci_dev *dev;
1060         int i;
1061         unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM;
1062
1063         list_for_each_entry(dev, &bus->devices, bus_list) {
1064                 for (i=0; i<PCI_BRIDGE_RESOURCES; i++) {
1065                         struct resource *res = &dev->resource[i];
1066                         if ((res->flags & type_mask) && !res->start &&
1067                                         res->end) {
1068                                 /* Could not assign a required resources
1069                                  * for this device, remove it */
1070                                 pci_stop_and_remove_bus_device(dev);
1071                                 break;
1072                         }
1073                 }
1074         }
1075 }
1076
1077 /* Program resources in newly inserted bridge */
1078 static int acpiphp_configure_bridge (acpi_handle handle)
1079 {
1080         struct pci_bus *bus;
1081
1082         if (acpi_is_root_bridge(handle)) {
1083                 struct acpi_pci_root *root = acpi_pci_find_root(handle);
1084                 bus = root->bus;
1085         } else {
1086                 struct pci_dev *pdev = acpi_get_pci_dev(handle);
1087                 bus = pdev->subordinate;
1088                 pci_dev_put(pdev);
1089         }
1090
1091         pci_bus_size_bridges(bus);
1092         pci_bus_assign_resources(bus);
1093         acpiphp_sanitize_bus(bus);
1094         acpiphp_set_hpp_values(bus);
1095         pci_enable_bridges(bus);
1096         return 0;
1097 }
1098
1099 static void handle_bridge_insertion(acpi_handle handle, u32 type)
1100 {
1101         struct acpi_device *device, *pdevice;
1102         acpi_handle phandle;
1103
1104         if ((type != ACPI_NOTIFY_BUS_CHECK) &&
1105                         (type != ACPI_NOTIFY_DEVICE_CHECK)) {
1106                 err("unexpected notification type %d\n", type);
1107                 return;
1108         }
1109
1110         acpi_get_parent(handle, &phandle);
1111         if (acpi_bus_get_device(phandle, &pdevice)) {
1112                 dbg("no parent device, assuming NULL\n");
1113                 pdevice = NULL;
1114         }
1115         if (acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE)) {
1116                 err("cannot add bridge to acpi list\n");
1117                 return;
1118         }
1119         if (!acpiphp_configure_bridge(handle) &&
1120                 !acpi_bus_start(device))
1121                 add_bridge(handle);
1122         else
1123                 err("cannot configure and start bridge\n");
1124
1125 }
1126
1127 /*
1128  * ACPI event handlers
1129  */
1130
1131 static acpi_status
1132 count_sub_bridges(acpi_handle handle, u32 lvl, void *context, void **rv)
1133 {
1134         int *count = (int *)context;
1135         struct acpiphp_bridge *bridge;
1136
1137         bridge = acpiphp_handle_to_bridge(handle);
1138         if (bridge)
1139                 (*count)++;
1140         return AE_OK ;
1141 }
1142
1143 static acpi_status
1144 check_sub_bridges(acpi_handle handle, u32 lvl, void *context, void **rv)
1145 {
1146         struct acpiphp_bridge *bridge;
1147         char objname[64];
1148         struct acpi_buffer buffer = { .length = sizeof(objname),
1149                                       .pointer = objname };
1150
1151         bridge = acpiphp_handle_to_bridge(handle);
1152         if (bridge) {
1153                 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1154                 dbg("%s: re-enumerating slots under %s\n",
1155                         __func__, objname);
1156                 acpiphp_check_bridge(bridge);
1157         }
1158         return AE_OK ;
1159 }
1160
1161 struct acpiphp_hp_work {
1162         struct work_struct work;
1163         acpi_handle handle;
1164         u32 type;
1165         void *context;
1166 };
1167
1168 static void alloc_acpiphp_hp_work(acpi_handle handle, u32 type,
1169                                   void *context,
1170                                   void (*func)(struct work_struct *work))
1171 {
1172         struct acpiphp_hp_work *hp_work;
1173         int ret;
1174
1175         hp_work = kmalloc(sizeof(*hp_work), GFP_KERNEL);
1176         if (!hp_work)
1177                 return;
1178
1179         hp_work->handle = handle;
1180         hp_work->type = type;
1181         hp_work->context = context;
1182
1183         INIT_WORK(&hp_work->work, func);
1184         ret = queue_work(kacpi_hotplug_wq, &hp_work->work);
1185         if (!ret)
1186                 kfree(hp_work);
1187 }
1188
1189 static void _handle_hotplug_event_bridge(struct work_struct *work)
1190 {
1191         struct acpiphp_bridge *bridge;
1192         char objname[64];
1193         struct acpi_buffer buffer = { .length = sizeof(objname),
1194                                       .pointer = objname };
1195         struct acpi_device *device;
1196         int num_sub_bridges = 0;
1197         struct acpiphp_hp_work *hp_work;
1198         acpi_handle handle;
1199         u32 type;
1200
1201         hp_work = container_of(work, struct acpiphp_hp_work, work);
1202         handle = hp_work->handle;
1203         type = hp_work->type;
1204
1205         if (acpi_bus_get_device(handle, &device)) {
1206                 /* This bridge must have just been physically inserted */
1207                 handle_bridge_insertion(handle, type);
1208                 goto out;
1209         }
1210
1211         bridge = acpiphp_handle_to_bridge(handle);
1212         if (type == ACPI_NOTIFY_BUS_CHECK) {
1213                 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, ACPI_UINT32_MAX,
1214                         count_sub_bridges, NULL, &num_sub_bridges, NULL);
1215         }
1216
1217         if (!bridge && !num_sub_bridges) {
1218                 err("cannot get bridge info\n");
1219                 goto out;
1220         }
1221
1222         acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1223
1224         switch (type) {
1225         case ACPI_NOTIFY_BUS_CHECK:
1226                 /* bus re-enumerate */
1227                 dbg("%s: Bus check notify on %s\n", __func__, objname);
1228                 if (bridge) {
1229                         dbg("%s: re-enumerating slots under %s\n",
1230                                 __func__, objname);
1231                         acpiphp_check_bridge(bridge);
1232                 }
1233                 if (num_sub_bridges)
1234                         acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
1235                                 ACPI_UINT32_MAX, check_sub_bridges, NULL, NULL, NULL);
1236                 break;
1237
1238         case ACPI_NOTIFY_DEVICE_CHECK:
1239                 /* device check */
1240                 dbg("%s: Device check notify on %s\n", __func__, objname);
1241                 acpiphp_check_bridge(bridge);
1242                 break;
1243
1244         case ACPI_NOTIFY_DEVICE_WAKE:
1245                 /* wake event */
1246                 dbg("%s: Device wake notify on %s\n", __func__, objname);
1247                 break;
1248
1249         case ACPI_NOTIFY_EJECT_REQUEST:
1250                 /* request device eject */
1251                 dbg("%s: Device eject notify on %s\n", __func__, objname);
1252                 if ((bridge->type != BRIDGE_TYPE_HOST) &&
1253                     (bridge->flags & BRIDGE_HAS_EJ0)) {
1254                         struct acpiphp_slot *slot;
1255                         slot = bridge->func->slot;
1256                         if (!acpiphp_disable_slot(slot))
1257                                 acpiphp_eject_slot(slot);
1258                 }
1259                 break;
1260
1261         case ACPI_NOTIFY_FREQUENCY_MISMATCH:
1262                 printk(KERN_ERR "Device %s cannot be configured due"
1263                                 " to a frequency mismatch\n", objname);
1264                 break;
1265
1266         case ACPI_NOTIFY_BUS_MODE_MISMATCH:
1267                 printk(KERN_ERR "Device %s cannot be configured due"
1268                                 " to a bus mode mismatch\n", objname);
1269                 break;
1270
1271         case ACPI_NOTIFY_POWER_FAULT:
1272                 printk(KERN_ERR "Device %s has suffered a power fault\n",
1273                                 objname);
1274                 break;
1275
1276         default:
1277                 warn("notify_handler: unknown event type 0x%x for %s\n", type, objname);
1278                 break;
1279         }
1280
1281 out:
1282         kfree(hp_work); /* allocated in handle_hotplug_event_bridge */
1283 }
1284
1285 /**
1286  * handle_hotplug_event_bridge - handle ACPI event on bridges
1287  * @handle: Notify()'ed acpi_handle
1288  * @type: Notify code
1289  * @context: pointer to acpiphp_bridge structure
1290  *
1291  * Handles ACPI event notification on {host,p2p} bridges.
1292  */
1293 static void handle_hotplug_event_bridge(acpi_handle handle, u32 type,
1294                                         void *context)
1295 {
1296         /*
1297          * Currently the code adds all hotplug events to the kacpid_wq
1298          * queue when it should add hotplug events to the kacpi_hotplug_wq.
1299          * The proper way to fix this is to reorganize the code so that
1300          * drivers (dock, etc.) do not call acpi_os_execute(), etc.
1301          * For now just re-add this work to the kacpi_hotplug_wq so we
1302          * don't deadlock on hotplug actions.
1303          */
1304         alloc_acpiphp_hp_work(handle, type, context,
1305                               _handle_hotplug_event_bridge);
1306 }
1307
1308 static void _handle_hotplug_event_func(struct work_struct *work)
1309 {
1310         struct acpiphp_func *func;
1311         char objname[64];
1312         struct acpi_buffer buffer = { .length = sizeof(objname),
1313                                       .pointer = objname };
1314         struct acpiphp_hp_work *hp_work;
1315         acpi_handle handle;
1316         u32 type;
1317         void *context;
1318
1319         hp_work = container_of(work, struct acpiphp_hp_work, work);
1320         handle = hp_work->handle;
1321         type = hp_work->type;
1322         context = hp_work->context;
1323
1324         acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1325
1326         func = (struct acpiphp_func *)context;
1327
1328         switch (type) {
1329         case ACPI_NOTIFY_BUS_CHECK:
1330                 /* bus re-enumerate */
1331                 dbg("%s: Bus check notify on %s\n", __func__, objname);
1332                 acpiphp_enable_slot(func->slot);
1333                 break;
1334
1335         case ACPI_NOTIFY_DEVICE_CHECK:
1336                 /* device check : re-enumerate from parent bus */
1337                 dbg("%s: Device check notify on %s\n", __func__, objname);
1338                 acpiphp_check_bridge(func->slot->bridge);
1339                 break;
1340
1341         case ACPI_NOTIFY_DEVICE_WAKE:
1342                 /* wake event */
1343                 dbg("%s: Device wake notify on %s\n", __func__, objname);
1344                 break;
1345
1346         case ACPI_NOTIFY_EJECT_REQUEST:
1347                 /* request device eject */
1348                 dbg("%s: Device eject notify on %s\n", __func__, objname);
1349                 if (!(acpiphp_disable_slot(func->slot)))
1350                         acpiphp_eject_slot(func->slot);
1351                 break;
1352
1353         default:
1354                 warn("notify_handler: unknown event type 0x%x for %s\n", type, objname);
1355                 break;
1356         }
1357
1358         kfree(hp_work); /* allocated in handle_hotplug_event_func */
1359 }
1360
1361 /**
1362  * handle_hotplug_event_func - handle ACPI event on functions (i.e. slots)
1363  * @handle: Notify()'ed acpi_handle
1364  * @type: Notify code
1365  * @context: pointer to acpiphp_func structure
1366  *
1367  * Handles ACPI event notification on slots.
1368  */
1369 static void handle_hotplug_event_func(acpi_handle handle, u32 type,
1370                                       void *context)
1371 {
1372         /*
1373          * Currently the code adds all hotplug events to the kacpid_wq
1374          * queue when it should add hotplug events to the kacpi_hotplug_wq.
1375          * The proper way to fix this is to reorganize the code so that
1376          * drivers (dock, etc.) do not call acpi_os_execute(), etc.
1377          * For now just re-add this work to the kacpi_hotplug_wq so we
1378          * don't deadlock on hotplug actions.
1379          */
1380         alloc_acpiphp_hp_work(handle, type, context,
1381                               _handle_hotplug_event_func);
1382 }
1383
1384 static acpi_status
1385 find_root_bridges(acpi_handle handle, u32 lvl, void *context, void **rv)
1386 {
1387         int *count = (int *)context;
1388
1389         if (!acpi_is_root_bridge(handle))
1390                 return AE_OK;
1391
1392         (*count)++;
1393         acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
1394                                     handle_hotplug_event_bridge, NULL);
1395
1396         return AE_OK ;
1397 }
1398
1399 static struct acpi_pci_driver acpi_pci_hp_driver = {
1400         .add =          add_bridge,
1401         .remove =       remove_bridge,
1402 };
1403
1404 /**
1405  * acpiphp_glue_init - initializes all PCI hotplug - ACPI glue data structures
1406  */
1407 int __init acpiphp_glue_init(void)
1408 {
1409         int num = 0;
1410
1411         acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
1412                         ACPI_UINT32_MAX, find_root_bridges, NULL, &num, NULL);
1413
1414         if (num <= 0)
1415                 return -1;
1416         else
1417                 acpi_pci_register_driver(&acpi_pci_hp_driver);
1418
1419         return 0;
1420 }
1421
1422
1423 /**
1424  * acpiphp_glue_exit - terminates all PCI hotplug - ACPI glue data structures
1425  *
1426  * This function frees all data allocated in acpiphp_glue_init().
1427  */
1428 void  acpiphp_glue_exit(void)
1429 {
1430         acpi_pci_unregister_driver(&acpi_pci_hp_driver);
1431 }
1432
1433
1434 /**
1435  * acpiphp_get_num_slots - count number of slots in a system
1436  */
1437 int __init acpiphp_get_num_slots(void)
1438 {
1439         struct acpiphp_bridge *bridge;
1440         int num_slots = 0;
1441
1442         list_for_each_entry(bridge, &bridge_list, list) {
1443                 dbg("Bus %04x:%02x has %d slot%s\n",
1444                                 pci_domain_nr(bridge->pci_bus),
1445                                 bridge->pci_bus->number, bridge->nr_slots,
1446                                 bridge->nr_slots == 1 ? "" : "s");
1447                 num_slots += bridge->nr_slots;
1448         }
1449
1450         dbg("Total %d slots\n", num_slots);
1451         return num_slots;
1452 }
1453
1454
1455 #if 0
1456 /**
1457  * acpiphp_for_each_slot - call function for each slot
1458  * @fn: callback function
1459  * @data: context to be passed to callback function
1460  */
1461 static int acpiphp_for_each_slot(acpiphp_callback fn, void *data)
1462 {
1463         struct list_head *node;
1464         struct acpiphp_bridge *bridge;
1465         struct acpiphp_slot *slot;
1466         int retval = 0;
1467
1468         list_for_each (node, &bridge_list) {
1469                 bridge = (struct acpiphp_bridge *)node;
1470                 for (slot = bridge->slots; slot; slot = slot->next) {
1471                         retval = fn(slot, data);
1472                         if (!retval)
1473                                 goto err_exit;
1474                 }
1475         }
1476
1477  err_exit:
1478         return retval;
1479 }
1480 #endif
1481
1482
1483 /**
1484  * acpiphp_enable_slot - power on slot
1485  * @slot: ACPI PHP slot
1486  */
1487 int acpiphp_enable_slot(struct acpiphp_slot *slot)
1488 {
1489         int retval;
1490
1491         mutex_lock(&slot->crit_sect);
1492
1493         /* wake up all functions */
1494         retval = power_on_slot(slot);
1495         if (retval)
1496                 goto err_exit;
1497
1498         if (get_slot_status(slot) == ACPI_STA_ALL) {
1499                 /* configure all functions */
1500                 retval = enable_device(slot);
1501                 if (retval)
1502                         power_off_slot(slot);
1503         } else {
1504                 dbg("%s: Slot status is not ACPI_STA_ALL\n", __func__);
1505                 power_off_slot(slot);
1506         }
1507
1508  err_exit:
1509         mutex_unlock(&slot->crit_sect);
1510         return retval;
1511 }
1512
1513 /**
1514  * acpiphp_disable_slot - power off slot
1515  * @slot: ACPI PHP slot
1516  */
1517 int acpiphp_disable_slot(struct acpiphp_slot *slot)
1518 {
1519         int retval = 0;
1520
1521         mutex_lock(&slot->crit_sect);
1522
1523         /* unconfigure all functions */
1524         retval = disable_device(slot);
1525         if (retval)
1526                 goto err_exit;
1527
1528         /* power off all functions */
1529         retval = power_off_slot(slot);
1530         if (retval)
1531                 goto err_exit;
1532
1533  err_exit:
1534         mutex_unlock(&slot->crit_sect);
1535         return retval;
1536 }
1537
1538
1539 /*
1540  * slot enabled:  1
1541  * slot disabled: 0
1542  */
1543 u8 acpiphp_get_power_status(struct acpiphp_slot *slot)
1544 {
1545         return (slot->flags & SLOT_POWEREDON);
1546 }
1547
1548
1549 /*
1550  * latch   open:  1
1551  * latch closed:  0
1552  */
1553 u8 acpiphp_get_latch_status(struct acpiphp_slot *slot)
1554 {
1555         unsigned int sta;
1556
1557         sta = get_slot_status(slot);
1558
1559         return (sta & ACPI_STA_SHOW_IN_UI) ? 0 : 1;
1560 }
1561
1562
1563 /*
1564  * adapter presence : 1
1565  *          absence : 0
1566  */
1567 u8 acpiphp_get_adapter_status(struct acpiphp_slot *slot)
1568 {
1569         unsigned int sta;
1570
1571         sta = get_slot_status(slot);
1572
1573         return (sta == 0) ? 0 : 1;
1574 }