linux/drivers/pci/hotplug/acpiphp_glue.c
<<
>>
Prefs
   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
  56static LIST_HEAD(bridge_list);
  57
  58#define MY_NAME "acpiphp_glue"
  59
  60static void handle_hotplug_event_bridge (acpi_handle, u32, void *);
  61static void acpiphp_sanitize_bus(struct pci_bus *bus);
  62static void acpiphp_set_hpp_values(struct pci_bus *bus);
  63static 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 */
  66static acpi_status
  67is_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 */
  86static 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
 114static 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 */
 119static acpi_status
 120register_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 */
 276static 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 */
 287static 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 */
 324static 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
 343static 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 */
 380static 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 */
 401static 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 */
 440static acpi_status
 441find_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 */
 469static 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
 504static 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
 515static 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
 572static acpi_status
 573cleanup_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
 589static 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
 613static 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
 645static 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 */
 682static 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 */
 710static 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
 739acpiphp_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 */
 748static 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
 766static 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 */
 791static 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
 876static 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 */
 891static 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
 927err_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 */
 944static 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 */
 975int 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 */
1009static 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
1048static 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 */
1060static 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 */
1081static 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
1102static 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
1134static acpi_status
1135count_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
1146static acpi_status
1147check_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
1164struct acpiphp_hp_work {
1165        struct work_struct work;
1166        acpi_handle handle;
1167        u32 type;
1168        void *context;
1169};
1170
1171static 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
1192static 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
1284out:
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 */
1296static 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
1311static 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 */
1372static 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
1387static acpi_status
1388find_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
1402static 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 */
1410int __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 */
1431void  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 */
1440int __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 */
1464static 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 */
1490int 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 */
1520int 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 */
1546u8 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 */
1556u8 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 */
1570u8 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}
1578