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