drivers/acpi/scan.c

   1 /*
   2  * scan.c - support for transforming the ACPI namespace into individual objects
   3  */
   4
   5 #include <linux/module.h>
   6 #include <linux/init.h>
   7 #include <linux/kernel.h>
   8 #include <linux/acpi.h>
   9 #include <linux/signal.h>
  10 #include <linux/kthread.h>
  11
  12 #include <acpi/acpi_drivers.h>
  13 #include <acpi/acinterp.h>      /* for acpi_ex_eisa_id_to_string() */
  14
  15 #define _COMPONENT              ACPI_BUS_COMPONENT
  16 ACPI_MODULE_NAME("scan");
  17 #define STRUCT_TO_INT(s)        (*((int*)&s))
  18 extern struct acpi_device *acpi_root;
  19
  20 #define ACPI_BUS_CLASS                  "system_bus"
  21 #define ACPI_BUS_HID                    "LNXSYBUS"
  22 #define ACPI_BUS_DEVICE_NAME            "System Bus"
  23
  24 static LIST_HEAD(acpi_device_list);
  25 static LIST_HEAD(acpi_bus_id_list);
  26 DEFINE_SPINLOCK(acpi_device_lock);
  27 LIST_HEAD(acpi_wakeup_device_list);
  28
  29 struct acpi_device_bus_id{
  30         char bus_id[15];
  31         unsigned int instance_no;
  32         struct list_head node;
  33 };
  34
  35 /*
  36  * Creates hid/cid(s) string needed for modalias and uevent
  37  * e.g. on a device with hid:IBM0001 and cid:ACPI0001 you get:
  38  * char *modalias: "acpi:IBM0001:ACPI0001"
  39 */
  40 static int create_modalias(struct acpi_device *acpi_dev, char *modalias,
  41                            int size)
  42 {
  43         int len;
  44         int count;
  45
  46         if (!acpi_dev->flags.hardware_id && !acpi_dev->flags.compatible_ids)
  47                 return -ENODEV;
  48
  49         len = snprintf(modalias, size, "acpi:");
  50         size -= len;
  51
  52         if (acpi_dev->flags.hardware_id) {
  53                 count = snprintf(&modalias[len], size, "%s:",
  54                                  acpi_dev->pnp.hardware_id);
  55                 if (count < 0 || count >= size)
  56                         return -EINVAL;
  57                 len += count;
  58                 size -= count;
  59         }
  60
  61         if (acpi_dev->flags.compatible_ids) {
  62                 struct acpi_compatible_id_list *cid_list;
  63                 int i;
  64
  65                 cid_list = acpi_dev->pnp.cid_list;
  66                 for (i = 0; i < cid_list->count; i++) {
  67                         count = snprintf(&modalias[len], size, "%s:",
  68                                          cid_list->id[i].value);
  69                         if (count < 0 || count >= size) {
  70                                 printk(KERN_ERR PREFIX "%s cid[%i] exceeds event buffer size",
  71                                        acpi_dev->pnp.device_name, i);
  72                                 break;
  73                         }
  74                         len += count;
  75                         size -= count;
  76                 }
  77         }
  78
  79         modalias[len] = '\0';
  80         return len;
  81 }
  82
  83 static ssize_t
  84 acpi_device_modalias_show(struct device *dev, struct device_attribute *attr, char *buf) {
  85         struct acpi_device *acpi_dev = to_acpi_device(dev);
  86         int len;
  87
  88         /* Device has no HID and no CID or string is >1024 */
  89         len = create_modalias(acpi_dev, buf, 1024);
  90         if (len <= 0)
  91                 return 0;
  92         buf[len++] = '\n';
  93         return len;
  94 }
  95 static DEVICE_ATTR(modalias, 0444, acpi_device_modalias_show, NULL);
  96
  97 static int acpi_bus_hot_remove_device(void *context)
  98 {
  99         struct acpi_device *device;
 100         acpi_handle handle = context;
 101         struct acpi_object_list arg_list;
 102         union acpi_object arg;
 103         acpi_status status = AE_OK;
 104
 105         if (acpi_bus_get_device(handle, &device))
 106                 return 0;
 107
 108         if (!device)
 109                 return 0;
 110
 111         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 112                 "Hot-removing device %s...\n", device->dev.bus_id));
 113
 114
 115         if (acpi_bus_trim(device, 1)) {
 116                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 117                                 "Removing device failed\n"));
 118                 return -1;
 119         }
 120
 121         /* power off device */
 122         status = acpi_evaluate_object(handle, "_PS3", NULL, NULL);
 123         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND)
 124                 ACPI_DEBUG_PRINT((ACPI_DB_WARN,
 125                                 "Power-off device failed\n"));
 126
 127         if (device->flags.lockable) {
 128                 arg_list.count = 1;
 129                 arg_list.pointer = &arg;
 130                 arg.type = ACPI_TYPE_INTEGER;
 131                 arg.integer.value = 0;
 132                 acpi_evaluate_object(handle, "_LCK", &arg_list, NULL);
 133         }
 134
 135         arg_list.count = 1;
 136         arg_list.pointer = &arg;
 137         arg.type = ACPI_TYPE_INTEGER;
 138         arg.integer.value = 1;
 139
 140         /*
 141          * TBD: _EJD support.
 142          */
 143         status = acpi_evaluate_object(handle, "_EJ0", &arg_list, NULL);
 144         if (ACPI_FAILURE(status))
 145                 return -ENODEV;
 146
 147         return 0;
 148 }
 149
 150 static ssize_t
 151 acpi_eject_store(struct device *d, struct device_attribute *attr,
 152                 const char *buf, size_t count)
 153 {
 154         int ret = count;
 155         acpi_status status;
 156         acpi_object_type type = 0;
 157         struct acpi_device *acpi_device = to_acpi_device(d);
 158         struct task_struct *task;
 159
 160         if ((!count) || (buf[0] != '1')) {
 161                 return -EINVAL;
 162         }
 163 #ifndef FORCE_EJECT
 164         if (acpi_device->driver == NULL) {
 165                 ret = -ENODEV;
 166                 goto err;
 167         }
 168 #endif
 169         status = acpi_get_type(acpi_device->handle, &type);
 170         if (ACPI_FAILURE(status) || (!acpi_device->flags.ejectable)) {
 171                 ret = -ENODEV;
 172                 goto err;
 173         }
 174
 175         /* remove the device in another thread to fix the deadlock issue */
 176         task = kthread_run(acpi_bus_hot_remove_device,
 177                                 acpi_device->handle, "acpi_hot_remove_device");
 178         if (IS_ERR(task))
 179                 ret = PTR_ERR(task);
 180 err:
 181         return ret;
 182 }
 183
 184 static DEVICE_ATTR(eject, 0200, NULL, acpi_eject_store);
 185
 186 static ssize_t
 187 acpi_device_hid_show(struct device *dev, struct device_attribute *attr, char *buf) {
 188         struct acpi_device *acpi_dev = to_acpi_device(dev);
 189
 190         return sprintf(buf, "%s\n", acpi_dev->pnp.hardware_id);
 191 }
 192 static DEVICE_ATTR(hid, 0444, acpi_device_hid_show, NULL);
 193
 194 static ssize_t
 195 acpi_device_path_show(struct device *dev, struct device_attribute *attr, char *buf) {
 196         struct acpi_device *acpi_dev = to_acpi_device(dev);
 197         struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL};
 198         int result;
 199
 200         result = acpi_get_name(acpi_dev->handle, ACPI_FULL_PATHNAME, &path);
 201         if(result)
 202                 goto end;
 203
 204         result = sprintf(buf, "%s\n", (char*)path.pointer);
 205         kfree(path.pointer);
 206   end:
 207         return result;
 208 }
 209 static DEVICE_ATTR(path, 0444, acpi_device_path_show, NULL);
 210
 211 static int acpi_device_setup_files(struct acpi_device *dev)
 212 {
 213         acpi_status status;
 214         acpi_handle temp;
 215         int result = 0;
 216
 217         /*
 218          * Devices gotten from FADT don't have a "path" attribute
 219          */
 220         if(dev->handle) {
 221                 result = device_create_file(&dev->dev, &dev_attr_path);
 222                 if(result)
 223                         goto end;
 224         }
 225
 226         if(dev->flags.hardware_id) {
 227                 result = device_create_file(&dev->dev, &dev_attr_hid);
 228                 if(result)
 229                         goto end;
 230         }
 231
 232         if (dev->flags.hardware_id || dev->flags.compatible_ids){
 233                 result = device_create_file(&dev->dev, &dev_attr_modalias);
 234                 if(result)
 235                         goto end;
 236         }
 237
 238         /*
 239          * If device has _EJ0, 'eject' file is created that is used to trigger
 240          * hot-removal function from userland.
 241          */
 242         status = acpi_get_handle(dev->handle, "_EJ0", &temp);
 243         if (ACPI_SUCCESS(status))
 244                 result = device_create_file(&dev->dev, &dev_attr_eject);
 245   end:
 246         return result;
 247 }
 248
 249 static void acpi_device_remove_files(struct acpi_device *dev)
 250 {
 251         acpi_status status;
 252         acpi_handle temp;
 253
 254         /*
 255          * If device has _EJ0, 'eject' file is created that is used to trigger
 256          * hot-removal function from userland.
 257          */
 258         status = acpi_get_handle(dev->handle, "_EJ0", &temp);
 259         if (ACPI_SUCCESS(status))
 260                 device_remove_file(&dev->dev, &dev_attr_eject);
 261
 262         if (dev->flags.hardware_id || dev->flags.compatible_ids)
 263                 device_remove_file(&dev->dev, &dev_attr_modalias);
 264
 265         if(dev->flags.hardware_id)
 266                 device_remove_file(&dev->dev, &dev_attr_hid);
 267         if(dev->handle)
 268                 device_remove_file(&dev->dev, &dev_attr_path);
 269 }
 270 /* --------------------------------------------------------------------------
 271                         ACPI Bus operations
 272    -------------------------------------------------------------------------- */
 273
 274 int acpi_match_device_ids(struct acpi_device *device,
 275                           const struct acpi_device_id *ids)
 276 {
 277         const struct acpi_device_id *id;
 278
 279         /*
 280          * If the device is not present, it is unnecessary to load device
 281          * driver for it.
 282          */
 283         if (!device->status.present)
 284                 return -ENODEV;
 285
 286         if (device->flags.hardware_id) {
 287                 for (id = ids; id->id[0]; id++) {
 288                         if (!strcmp((char*)id->id, device->pnp.hardware_id))
 289                                 return 0;
 290                 }
 291         }
 292
 293         if (device->flags.compatible_ids) {
 294                 struct acpi_compatible_id_list *cid_list = device->pnp.cid_list;
 295                 int i;
 296
 297                 for (id = ids; id->id[0]; id++) {
 298                         /* compare multiple _CID entries against driver ids */
 299                         for (i = 0; i < cid_list->count; i++) {
 300                                 if (!strcmp((char*)id->id,
 301                                             cid_list->id[i].value))
 302                                         return 0;
 303                         }
 304                 }
 305         }
 306
 307         return -ENOENT;
 308 }
 309 EXPORT_SYMBOL(acpi_match_device_ids);
 310
 311 static void acpi_device_release(struct device *dev)
 312 {
 313         struct acpi_device *acpi_dev = to_acpi_device(dev);
 314
 315         kfree(acpi_dev->pnp.cid_list);
 316         kfree(acpi_dev);
 317 }
 318
 319 static int acpi_device_suspend(struct device *dev, pm_message_t state)
 320 {
 321         struct acpi_device *acpi_dev = to_acpi_device(dev);
 322         struct acpi_driver *acpi_drv = acpi_dev->driver;
 323
 324         if (acpi_drv && acpi_drv->ops.suspend)
 325                 return acpi_drv->ops.suspend(acpi_dev, state);
 326         return 0;
 327 }
 328
 329 static int acpi_device_resume(struct device *dev)
 330 {
 331         struct acpi_device *acpi_dev = to_acpi_device(dev);
 332         struct acpi_driver *acpi_drv = acpi_dev->driver;
 333
 334         if (acpi_drv && acpi_drv->ops.resume)
 335                 return acpi_drv->ops.resume(acpi_dev);
 336         return 0;
 337 }
 338
 339 static int acpi_bus_match(struct device *dev, struct device_driver *drv)
 340 {
 341         struct acpi_device *acpi_dev = to_acpi_device(dev);
 342         struct acpi_driver *acpi_drv = to_acpi_driver(drv);
 343
 344         return !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
 345 }
 346
 347 static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
 348 {
 349         struct acpi_device *acpi_dev = to_acpi_device(dev);
 350         int len;
 351
 352         if (add_uevent_var(env, "MODALIAS="))
 353                 return -ENOMEM;
 354         len = create_modalias(acpi_dev, &env->buf[env->buflen - 1],
 355                               sizeof(env->buf) - env->buflen);
 356         if (len >= (sizeof(env->buf) - env->buflen))
 357                 return -ENOMEM;
 358         env->buflen += len;
 359         return 0;
 360 }
 361
 362 static int acpi_bus_driver_init(struct acpi_device *, struct acpi_driver *);
 363 static int acpi_start_single_object(struct acpi_device *);
 364 static int acpi_device_probe(struct device * dev)
 365 {
 366         struct acpi_device *acpi_dev = to_acpi_device(dev);
 367         struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
 368         int ret;
 369
 370         ret = acpi_bus_driver_init(acpi_dev, acpi_drv);
 371         if (!ret) {
 372                 if (acpi_dev->bus_ops.acpi_op_start)
 373                         acpi_start_single_object(acpi_dev);
 374                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 375                         "Found driver [%s] for device [%s]\n",
 376                         acpi_drv->name, acpi_dev->pnp.bus_id));
 377                 get_device(dev);
 378         }
 379         return ret;
 380 }
 381
 382 static int acpi_device_remove(struct device * dev)
 383 {
 384         struct acpi_device *acpi_dev = to_acpi_device(dev);
 385         struct acpi_driver *acpi_drv = acpi_dev->driver;
 386
 387         if (acpi_drv) {
 388                 if (acpi_drv->ops.stop)
 389                         acpi_drv->ops.stop(acpi_dev, acpi_dev->removal_type);
 390                 if (acpi_drv->ops.remove)
 391                         acpi_drv->ops.remove(acpi_dev, acpi_dev->removal_type);
 392         }
 393         acpi_dev->driver = NULL;
 394         acpi_driver_data(dev) = NULL;
 395
 396         put_device(dev);
 397         return 0;
 398 }
 399
 400 static void acpi_device_shutdown(struct device *dev)
 401 {
 402         struct acpi_device *acpi_dev = to_acpi_device(dev);
 403         struct acpi_driver *acpi_drv = acpi_dev->driver;
 404
 405         if (acpi_drv && acpi_drv->ops.shutdown)
 406                 acpi_drv->ops.shutdown(acpi_dev);
 407
 408         return ;
 409 }
 410
 411 struct bus_type acpi_bus_type = {
 412         .name           = "acpi",
 413         .suspend        = acpi_device_suspend,
 414         .resume         = acpi_device_resume,
 415         .shutdown       = acpi_device_shutdown,
 416         .match          = acpi_bus_match,
 417         .probe          = acpi_device_probe,
 418         .remove         = acpi_device_remove,
 419         .uevent         = acpi_device_uevent,
 420 };
 421
 422 static int acpi_device_register(struct acpi_device *device,
 423                                  struct acpi_device *parent)
 424 {
 425         int result;
 426         struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
 427         int found = 0;
 428         /*
 429          * Linkage
 430          * -------
 431          * Link this device to its parent and siblings.
 432          */
 433         INIT_LIST_HEAD(&device->children);
 434         INIT_LIST_HEAD(&device->node);
 435         INIT_LIST_HEAD(&device->g_list);
 436         INIT_LIST_HEAD(&device->wakeup_list);
 437
 438         new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
 439         if (!new_bus_id) {
 440                 printk(KERN_ERR PREFIX "Memory allocation error\n");
 441                 return -ENOMEM;
 442         }
 443
 444         spin_lock(&acpi_device_lock);
 445         /*
 446          * Find suitable bus_id and instance number in acpi_bus_id_list
 447          * If failed, create one and link it into acpi_bus_id_list
 448          */
 449         list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) {
 450                 if(!strcmp(acpi_device_bus_id->bus_id, device->flags.hardware_id? device->pnp.hardware_id : "device")) {
 451                         acpi_device_bus_id->instance_no ++;
 452                         found = 1;
 453                         kfree(new_bus_id);
 454                         break;
 455                 }
 456         }
 457         if(!found) {
 458                 acpi_device_bus_id = new_bus_id;
 459                 strcpy(acpi_device_bus_id->bus_id, device->flags.hardware_id ? device->pnp.hardware_id : "device");
 460                 acpi_device_bus_id->instance_no = 0;
 461                 list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
 462         }
 463         sprintf(device->dev.bus_id, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no);
 464
 465         if (device->parent) {
 466                 list_add_tail(&device->node, &device->parent->children);
 467                 list_add_tail(&device->g_list, &device->parent->g_list);
 468         } else
 469                 list_add_tail(&device->g_list, &acpi_device_list);
 470         if (device->wakeup.flags.valid)
 471                 list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list);
 472         spin_unlock(&acpi_device_lock);
 473
 474         if (device->parent)
 475                 device->dev.parent = &parent->dev;
 476         device->dev.bus = &acpi_bus_type;
 477         device_initialize(&device->dev);
 478         device->dev.release = &acpi_device_release;
 479         result = device_add(&device->dev);
 480         if(result) {
 481                 dev_err(&device->dev, "Error adding device\n");
 482                 goto end;
 483         }
 484
 485         result = acpi_device_setup_files(device);
 486         if(result)
 487                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error creating sysfs interface for device %s\n", device->dev.bus_id));
 488
 489         device->removal_type = ACPI_BUS_REMOVAL_NORMAL;
 490         return 0;
 491   end:
 492         spin_lock(&acpi_device_lock);
 493         if (device->parent) {
 494                 list_del(&device->node);
 495                 list_del(&device->g_list);
 496         } else
 497                 list_del(&device->g_list);
 498         list_del(&device->wakeup_list);
 499         spin_unlock(&acpi_device_lock);
 500         return result;
 501 }
 502
 503 static void acpi_device_unregister(struct acpi_device *device, int type)
 504 {
 505         spin_lock(&acpi_device_lock);
 506         if (device->parent) {
 507                 list_del(&device->node);
 508                 list_del(&device->g_list);
 509         } else
 510                 list_del(&device->g_list);
 511
 512         list_del(&device->wakeup_list);
 513         spin_unlock(&acpi_device_lock);
 514
 515         acpi_detach_data(device->handle, acpi_bus_data_handler);
 516
 517         acpi_device_remove_files(device);
 518         device_unregister(&device->dev);
 519 }
 520
 521 /* --------------------------------------------------------------------------
 522                                  Driver Management
 523    -------------------------------------------------------------------------- */
 524 /**
 525  * acpi_bus_driver_init - add a device to a driver
 526  * @device: the device to add and initialize
 527  * @driver: driver for the device
 528  *
 529  * Used to initialize a device via its device driver.  Called whenever a
 530  * driver is bound to a device.  Invokes the driver's add() ops.
 531  */
 532 static int
 533 acpi_bus_driver_init(struct acpi_device *device, struct acpi_driver *driver)
 534 {
 535         int result = 0;
 536
 537
 538         if (!device || !driver)
 539                 return -EINVAL;
 540
 541         if (!driver->ops.add)
 542                 return -ENOSYS;
 543
 544         result = driver->ops.add(device);
 545         if (result) {
 546                 device->driver = NULL;
 547                 acpi_driver_data(device) = NULL;
 548                 return result;
 549         }
 550
 551         device->driver = driver;
 552
 553         /*
 554          * TBD - Configuration Management: Assign resources to device based
 555          * upon possible configuration and currently allocated resources.
 556          */
 557
 558         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 559                           "Driver successfully bound to device\n"));
 560         return 0;
 561 }
 562
 563 static int acpi_start_single_object(struct acpi_device *device)
 564 {
 565         int result = 0;
 566         struct acpi_driver *driver;
 567
 568
 569         if (!(driver = device->driver))
 570                 return 0;
 571
 572         if (driver->ops.start) {
 573                 result = driver->ops.start(device);
 574                 if (result && driver->ops.remove)
 575                         driver->ops.remove(device, ACPI_BUS_REMOVAL_NORMAL);
 576         }
 577
 578         return result;
 579 }
 580
 581 /**
 582  * acpi_bus_register_driver - register a driver with the ACPI bus
 583  * @driver: driver being registered
 584  *
 585  * Registers a driver with the ACPI bus.  Searches the namespace for all
 586  * devices that match the driver's criteria and binds.  Returns zero for
 587  * success or a negative error status for failure.
 588  */
 589 int acpi_bus_register_driver(struct acpi_driver *driver)
 590 {
 591         int ret;
 592
 593         if (acpi_disabled)
 594                 return -ENODEV;
 595         driver->drv.name = driver->name;
 596         driver->drv.bus = &acpi_bus_type;
 597         driver->drv.owner = driver->owner;
 598
 599         ret = driver_register(&driver->drv);
 600         return ret;
 601 }
 602
 603 EXPORT_SYMBOL(acpi_bus_register_driver);
 604
 605 /**
 606  * acpi_bus_unregister_driver - unregisters a driver with the APIC bus
 607  * @driver: driver to unregister
 608  *
 609  * Unregisters a driver with the ACPI bus.  Searches the namespace for all
 610  * devices that match the driver's criteria and unbinds.
 611  */
 612 void acpi_bus_unregister_driver(struct acpi_driver *driver)
 613 {
 614         driver_unregister(&driver->drv);
 615 }
 616
 617 EXPORT_SYMBOL(acpi_bus_unregister_driver);
 618
 619 /* --------------------------------------------------------------------------
 620                                  Device Enumeration
 621    -------------------------------------------------------------------------- */
 622 acpi_status
 623 acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
 624 {
 625         acpi_status status;
 626         acpi_handle tmp;
 627         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
 628         union acpi_object *obj;
 629
 630         status = acpi_get_handle(handle, "_EJD", &tmp);
 631         if (ACPI_FAILURE(status))
 632                 return status;
 633
 634         status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer);
 635         if (ACPI_SUCCESS(status)) {
 636                 obj = buffer.pointer;
 637                 status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer,
 638                                          ejd);
 639                 kfree(buffer.pointer);
 640         }
 641         return status;
 642 }
 643 EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
 644
 645 void acpi_bus_data_handler(acpi_handle handle, u32 function, void *context)
 646 {
 647
 648         /* TBD */
 649
 650         return;
 651 }
 652
 653 static int acpi_bus_get_perf_flags(struct acpi_device *device)
 654 {
 655         device->performance.state = ACPI_STATE_UNKNOWN;
 656         return 0;
 657 }
 658
 659 static acpi_status
 660 acpi_bus_extract_wakeup_device_power_package(struct acpi_device *device,
 661                                              union acpi_object *package)
 662 {
 663         int i = 0;
 664         union acpi_object *element = NULL;
 665
 666         if (!device || !package || (package->package.count < 2))
 667                 return AE_BAD_PARAMETER;
 668
 669         element = &(package->package.elements[0]);
 670         if (!element)
 671                 return AE_BAD_PARAMETER;
 672         if (element->type == ACPI_TYPE_PACKAGE) {
 673                 if ((element->package.count < 2) ||
 674                     (element->package.elements[0].type !=
 675                      ACPI_TYPE_LOCAL_REFERENCE)
 676                     || (element->package.elements[1].type != ACPI_TYPE_INTEGER))
 677                         return AE_BAD_DATA;
 678                 device->wakeup.gpe_device =
 679                     element->package.elements[0].reference.handle;
 680                 device->wakeup.gpe_number =
 681                     (u32) element->package.elements[1].integer.value;
 682         } else if (element->type == ACPI_TYPE_INTEGER) {
 683                 device->wakeup.gpe_number = element->integer.value;
 684         } else
 685                 return AE_BAD_DATA;
 686
 687         element = &(package->package.elements[1]);
 688         if (element->type != ACPI_TYPE_INTEGER) {
 689                 return AE_BAD_DATA;
 690         }
 691         device->wakeup.sleep_state = element->integer.value;
 692
 693         if ((package->package.count - 2) > ACPI_MAX_HANDLES) {
 694                 return AE_NO_MEMORY;
 695         }
 696         device->wakeup.resources.count = package->package.count - 2;
 697         for (i = 0; i < device->wakeup.resources.count; i++) {
 698                 element = &(package->package.elements[i + 2]);
 699                 if (element->type != ACPI_TYPE_LOCAL_REFERENCE)
 700                         return AE_BAD_DATA;
 701
 702                 device->wakeup.resources.handles[i] = element->reference.handle;
 703         }
 704
 705         return AE_OK;
 706 }
 707
 708 static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
 709 {
 710         acpi_status status = 0;
 711         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 712         union acpi_object *package = NULL;
 713         int psw_error;
 714
 715         struct acpi_device_id button_device_ids[] = {
 716                 {"PNP0C0D", 0},
 717                 {"PNP0C0C", 0},
 718                 {"PNP0C0E", 0},
 719                 {"", 0},
 720         };
 721
 722         /* _PRW */
 723         status = acpi_evaluate_object(device->handle, "_PRW", NULL, &buffer);
 724         if (ACPI_FAILURE(status)) {
 725                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW"));
 726                 goto end;
 727         }
 728
 729         package = (union acpi_object *)buffer.pointer;
 730         status = acpi_bus_extract_wakeup_device_power_package(device, package);
 731         if (ACPI_FAILURE(status)) {
 732                 ACPI_EXCEPTION((AE_INFO, status, "Extracting _PRW package"));
 733                 goto end;
 734         }
 735
 736         kfree(buffer.pointer);
 737
 738         device->wakeup.flags.valid = 1;
 739         /* Call _PSW/_DSW object to disable its ability to wake the sleeping
 740          * system for the ACPI device with the _PRW object.
 741          * The _PSW object is depreciated in ACPI 3.0 and is replaced by _DSW.
 742          * So it is necessary to call _DSW object first. Only when it is not
 743          * present will the _PSW object used.
 744          */
 745         psw_error = acpi_device_sleep_wake(device, 0, 0, 0);
 746         if (psw_error)
 747                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 748                                 "error in _DSW or _PSW evaluation\n"));
 749
 750         /* Power button, Lid switch always enable wakeup */
 751         if (!acpi_match_device_ids(device, button_device_ids))
 752                 device->wakeup.flags.run_wake = 1;
 753
 754       end:
 755         if (ACPI_FAILURE(status))
 756                 device->flags.wake_capable = 0;
 757         return 0;
 758 }
 759
 760 static int acpi_bus_get_power_flags(struct acpi_device *device)
 761 {
 762         acpi_status status = 0;
 763         acpi_handle handle = NULL;
 764         u32 i = 0;
 765
 766
 767         /*
 768          * Power Management Flags
 769          */
 770         status = acpi_get_handle(device->handle, "_PSC", &handle);
 771         if (ACPI_SUCCESS(status))
 772                 device->power.flags.explicit_get = 1;
 773         status = acpi_get_handle(device->handle, "_IRC", &handle);
 774         if (ACPI_SUCCESS(status))
 775                 device->power.flags.inrush_current = 1;
 776
 777         /*
 778          * Enumerate supported power management states
 779          */
 780         for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3; i++) {
 781                 struct acpi_device_power_state *ps = &device->power.states[i];
 782                 char object_name[5] = { '_', 'P', 'R', '0' + i, '\0' };
 783
 784                 /* Evaluate "_PRx" to se if power resources are referenced */
 785                 acpi_evaluate_reference(device->handle, object_name, NULL,
 786                                         &ps->resources);
 787                 if (ps->resources.count) {
 788                         device->power.flags.power_resources = 1;
 789                         ps->flags.valid = 1;
 790                 }
 791
 792                 /* Evaluate "_PSx" to see if we can do explicit sets */
 793                 object_name[2] = 'S';
 794                 status = acpi_get_handle(device->handle, object_name, &handle);
 795                 if (ACPI_SUCCESS(status)) {
 796                         ps->flags.explicit_set = 1;
 797                         ps->flags.valid = 1;
 798                 }
 799
 800                 /* State is valid if we have some power control */
 801                 if (ps->resources.count || ps->flags.explicit_set)
 802                         ps->flags.valid = 1;
 803
 804                 ps->power = -1; /* Unknown - driver assigned */
 805                 ps->latency = -1;       /* Unknown - driver assigned */
 806         }
 807
 808         /* Set defaults for D0 and D3 states (always valid) */
 809         device->power.states[ACPI_STATE_D0].flags.valid = 1;
 810         device->power.states[ACPI_STATE_D0].power = 100;
 811         device->power.states[ACPI_STATE_D3].flags.valid = 1;
 812         device->power.states[ACPI_STATE_D3].power = 0;
 813
 814         /* TBD: System wake support and resource requirements. */
 815
 816         device->power.state = ACPI_STATE_UNKNOWN;
 817         acpi_bus_get_power(device->handle, &(device->power.state));
 818
 819         return 0;
 820 }
 821
 822 static int acpi_bus_get_flags(struct acpi_device *device)
 823 {
 824         acpi_status status = AE_OK;
 825         acpi_handle temp = NULL;
 826
 827
 828         /* Presence of _STA indicates 'dynamic_status' */
 829         status = acpi_get_handle(device->handle, "_STA", &temp);
 830         if (ACPI_SUCCESS(status))
 831                 device->flags.dynamic_status = 1;
 832
 833         /* Presence of _CID indicates 'compatible_ids' */
 834         status = acpi_get_handle(device->handle, "_CID", &temp);
 835         if (ACPI_SUCCESS(status))
 836                 device->flags.compatible_ids = 1;
 837
 838         /* Presence of _RMV indicates 'removable' */
 839         status = acpi_get_handle(device->handle, "_RMV", &temp);
 840         if (ACPI_SUCCESS(status))
 841                 device->flags.removable = 1;
 842
 843         /* Presence of _EJD|_EJ0 indicates 'ejectable' */
 844         status = acpi_get_handle(device->handle, "_EJD", &temp);
 845         if (ACPI_SUCCESS(status))
 846                 device->flags.ejectable = 1;
 847         else {
 848                 status = acpi_get_handle(device->handle, "_EJ0", &temp);
 849                 if (ACPI_SUCCESS(status))
 850                         device->flags.ejectable = 1;
 851         }
 852
 853         /* Presence of _LCK indicates 'lockable' */
 854         status = acpi_get_handle(device->handle, "_LCK", &temp);
 855         if (ACPI_SUCCESS(status))
 856                 device->flags.lockable = 1;
 857
 858         /* Presence of _PS0|_PR0 indicates 'power manageable' */
 859         status = acpi_get_handle(device->handle, "_PS0", &temp);
 860         if (ACPI_FAILURE(status))
 861                 status = acpi_get_handle(device->handle, "_PR0", &temp);
 862         if (ACPI_SUCCESS(status))
 863                 device->flags.power_manageable = 1;
 864
 865         /* Presence of _PRW indicates wake capable */
 866         status = acpi_get_handle(device->handle, "_PRW", &temp);
 867         if (ACPI_SUCCESS(status))
 868                 device->flags.wake_capable = 1;
 869
 870         /* TBD: Performance management */
 871
 872         return 0;
 873 }
 874
 875 static void acpi_device_get_busid(struct acpi_device *device,
 876                                   acpi_handle handle, int type)
 877 {
 878         char bus_id[5] = { '?', 0 };
 879         struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
 880         int i = 0;
 881
 882         /*
 883          * Bus ID
 884          * ------
 885          * The device's Bus ID is simply the object name.
 886          * TBD: Shouldn't this value be unique (within the ACPI namespace)?
 887          */
 888         switch (type) {
 889         case ACPI_BUS_TYPE_SYSTEM:
 890                 strcpy(device->pnp.bus_id, "ACPI");
 891                 break;
 892         case ACPI_BUS_TYPE_POWER_BUTTON:
 893                 strcpy(device->pnp.bus_id, "PWRF");
 894                 break;
 895         case ACPI_BUS_TYPE_SLEEP_BUTTON:
 896                 strcpy(device->pnp.bus_id, "SLPF");
 897                 break;
 898         default:
 899                 acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
 900                 /* Clean up trailing underscores (if any) */
 901                 for (i = 3; i > 1; i--) {
 902                         if (bus_id[i] == '_')
 903                                 bus_id[i] = '\0';
 904                         else
 905                                 break;
 906                 }
 907                 strcpy(device->pnp.bus_id, bus_id);
 908                 break;
 909         }
 910 }
 911
 912 static int
 913 acpi_video_bus_match(struct acpi_device *device)
 914 {
 915         acpi_handle h_dummy;
 916
 917         if (!device)
 918                 return -EINVAL;
 919
 920         /* Since there is no HID, CID for ACPI Video drivers, we have
 921          * to check well known required nodes for each feature we support.
 922          */
 923
 924         /* Does this device able to support video switching ? */
 925         if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_DOD", &h_dummy)) &&
 926             ACPI_SUCCESS(acpi_get_handle(device->handle, "_DOS", &h_dummy)))
 927                 return 0;
 928
 929         /* Does this device able to retrieve a video ROM ? */
 930         if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_ROM", &h_dummy)))
 931                 return 0;
 932
 933         /* Does this device able to configure which video head to be POSTed ? */
 934         if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_VPO", &h_dummy)) &&
 935             ACPI_SUCCESS(acpi_get_handle(device->handle, "_GPD", &h_dummy)) &&
 936             ACPI_SUCCESS(acpi_get_handle(device->handle, "_SPD", &h_dummy)))
 937                 return 0;
 938
 939         return -ENODEV;
 940 }
 941
 942 /*
 943  * acpi_bay_match - see if a device is an ejectable driver bay
 944  *
 945  * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
 946  * then we can safely call it an ejectable drive bay
 947  */
 948 static int acpi_bay_match(struct acpi_device *device){
 949         acpi_status status;
 950         acpi_handle handle;
 951         acpi_handle tmp;
 952         acpi_handle phandle;
 953
 954         handle = device->handle;
 955
 956         status = acpi_get_handle(handle, "_EJ0", &tmp);
 957         if (ACPI_FAILURE(status))
 958                 return -ENODEV;
 959
 960         if ((ACPI_SUCCESS(acpi_get_handle(handle, "_GTF", &tmp))) ||
 961                 (ACPI_SUCCESS(acpi_get_handle(handle, "_GTM", &tmp))) ||
 962                 (ACPI_SUCCESS(acpi_get_handle(handle, "_STM", &tmp))) ||
 963                 (ACPI_SUCCESS(acpi_get_handle(handle, "_SDD", &tmp))))
 964                 return 0;
 965
 966         if (acpi_get_parent(handle, &phandle))
 967                 return -ENODEV;
 968
 969         if ((ACPI_SUCCESS(acpi_get_handle(phandle, "_GTF", &tmp))) ||
 970                 (ACPI_SUCCESS(acpi_get_handle(phandle, "_GTM", &tmp))) ||
 971                 (ACPI_SUCCESS(acpi_get_handle(phandle, "_STM", &tmp))) ||
 972                 (ACPI_SUCCESS(acpi_get_handle(phandle, "_SDD", &tmp))))
 973                 return 0;
 974
 975         return -ENODEV;
 976 }
 977
 978 /*
 979  * acpi_dock_match - see if a device has a _DCK method
 980  */
 981 static int acpi_dock_match(struct acpi_device *device)
 982 {
 983         acpi_handle tmp;
 984         return acpi_get_handle(device->handle, "_DCK", &tmp);
 985 }
 986
 987 static void acpi_device_set_id(struct acpi_device *device,
 988                                struct acpi_device *parent, acpi_handle handle,
 989                                int type)
 990 {
 991         struct acpi_device_info *info;
 992         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 993         char *hid = NULL;
 994         char *uid = NULL;
 995         struct acpi_compatible_id_list *cid_list = NULL;
 996         const char *cid_add = NULL;
 997         acpi_status status;
 998
 999         switch (type) {
1000         case ACPI_BUS_TYPE_DEVICE:
1001                 status = acpi_get_object_info(handle, &buffer);
1002                 if (ACPI_FAILURE(status)) {
1003                         printk(KERN_ERR PREFIX "%s: Error reading device info\n", __func__);
1004                         return;
1005                 }
1006
1007                 info = buffer.pointer;
1008                 if (info->valid & ACPI_VALID_HID)
1009                         hid = info->hardware_id.value;
1010                 if (info->valid & ACPI_VALID_UID)
1011                         uid = info->unique_id.value;
1012                 if (info->valid & ACPI_VALID_CID)
1013                         cid_list = &info->compatibility_id;
1014                 if (info->valid & ACPI_VALID_ADR) {
1015                         device->pnp.bus_address = info->address;
1016                         device->flags.bus_address = 1;
1017                 }
1018
1019                 /* If we have a video/bay/dock device, add our selfdefined
1020                    HID to the CID list. Like that the video/bay/dock drivers
1021                    will get autoloaded and the device might still match
1022                    against another driver.
1023                 */
1024                 if (ACPI_SUCCESS(acpi_video_bus_match(device)))
1025                         cid_add = ACPI_VIDEO_HID;
1026                 else if (ACPI_SUCCESS(acpi_bay_match(device)))
1027                         cid_add = ACPI_BAY_HID;
1028                 else if (ACPI_SUCCESS(acpi_dock_match(device)))
1029                         cid_add = ACPI_DOCK_HID;
1030
1031                 break;
1032         case ACPI_BUS_TYPE_POWER:
1033                 hid = ACPI_POWER_HID;
1034                 break;
1035         case ACPI_BUS_TYPE_PROCESSOR:
1036                 hid = ACPI_PROCESSOR_HID;
1037                 break;
1038         case ACPI_BUS_TYPE_SYSTEM:
1039                 hid = ACPI_SYSTEM_HID;
1040                 break;
1041         case ACPI_BUS_TYPE_THERMAL:
1042                 hid = ACPI_THERMAL_HID;
1043                 break;
1044         case ACPI_BUS_TYPE_POWER_BUTTON:
1045                 hid = ACPI_BUTTON_HID_POWERF;
1046                 break;
1047         case ACPI_BUS_TYPE_SLEEP_BUTTON:
1048                 hid = ACPI_BUTTON_HID_SLEEPF;
1049                 break;
1050         }
1051
1052         /*
1053          * \_SB
1054          * ----
1055          * Fix for the system root bus device -- the only root-level device.
1056          */
1057         if (((acpi_handle)parent == ACPI_ROOT_OBJECT) && (type == ACPI_BUS_TYPE_DEVICE)) {
1058                 hid = ACPI_BUS_HID;
1059                 strcpy(device->pnp.device_name, ACPI_BUS_DEVICE_NAME);
1060                 strcpy(device->pnp.device_class, ACPI_BUS_CLASS);
1061         }
1062
1063         if (hid) {
1064                 strcpy(device->pnp.hardware_id, hid);
1065                 device->flags.hardware_id = 1;
1066         }
1067         if (uid) {
1068                 strcpy(device->pnp.unique_id, uid);
1069                 device->flags.unique_id = 1;
1070         }
1071         if (cid_list || cid_add) {
1072                 struct  acpi_compatible_id_list *list;
1073                 int size = 0;
1074                 int count = 0;
1075
1076                 if (cid_list) {
1077                         size = cid_list->size;
1078                 } else if (cid_add) {
1079                         size = sizeof(struct acpi_compatible_id_list);
1080                         cid_list = ACPI_ALLOCATE_ZEROED((acpi_size) size);
1081                         if (!cid_list) {
1082                                 printk(KERN_ERR "Memory allocation error\n");
1083                                 kfree(buffer.pointer);
1084                                 return;
1085                         } else {
1086                                 cid_list->count = 0;
1087                                 cid_list->size = size;
1088                         }
1089                 }
1090                 if (cid_add)
1091                         size += sizeof(struct acpi_compatible_id);
1092                 list = kmalloc(size, GFP_KERNEL);
1093
1094                 if (list) {
1095                         if (cid_list) {
1096                                 memcpy(list, cid_list, cid_list->size);
1097                                 count = cid_list->count;
1098                         }
1099                         if (cid_add) {
1100                                 strncpy(list->id[count].value, cid_add,
1101                                         ACPI_MAX_CID_LENGTH);
1102                                 count++;
1103                                 device->flags.compatible_ids = 1;
1104                         }
1105                         list->size = size;
1106                         list->count = count;
1107                         device->pnp.cid_list = list;
1108                 } else
1109                         printk(KERN_ERR PREFIX "Memory allocation error\n");
1110         }
1111
1112         kfree(buffer.pointer);
1113 }
1114
1115 static int acpi_device_set_context(struct acpi_device *device, int type)
1116 {
1117         acpi_status status = AE_OK;
1118         int result = 0;
1119         /*
1120          * Context
1121          * -------
1122          * Attach this 'struct acpi_device' to the ACPI object.  This makes
1123          * resolutions from handle->device very efficient.  Note that we need
1124          * to be careful with fixed-feature devices as they all attach to the
1125          * root object.
1126          */
1127         if (type != ACPI_BUS_TYPE_POWER_BUTTON &&
1128             type != ACPI_BUS_TYPE_SLEEP_BUTTON) {
1129                 status = acpi_attach_data(device->handle,
1130                                           acpi_bus_data_handler, device);
1131
1132                 if (ACPI_FAILURE(status)) {
1133                         printk(KERN_ERR PREFIX "Error attaching device data\n");
1134                         result = -ENODEV;
1135                 }
1136         }
1137         return result;
1138 }
1139
1140 static int acpi_bus_remove(struct acpi_device *dev, int rmdevice)
1141 {
1142         if (!dev)
1143                 return -EINVAL;
1144
1145         dev->removal_type = ACPI_BUS_REMOVAL_EJECT;
1146         device_release_driver(&dev->dev);
1147
1148         if (!rmdevice)
1149                 return 0;
1150
1151         /*
1152          * unbind _ADR-Based Devices when hot removal
1153          */
1154         if (dev->flags.bus_address) {
1155                 if ((dev->parent) && (dev->parent->ops.unbind))
1156                         dev->parent->ops.unbind(dev);
1157         }
1158         acpi_device_unregister(dev, ACPI_BUS_REMOVAL_EJECT);
1159
1160         return 0;
1161 }
1162
1163 static int
1164 acpi_is_child_device(struct acpi_device *device,
1165                         int (*matcher)(struct acpi_device *))
1166 {
1167         int result = -ENODEV;
1168
1169         do {
1170                 if (ACPI_SUCCESS(matcher(device)))
1171                         return AE_OK;
1172         } while ((device = device->parent));
1173
1174         return result;
1175 }
1176
1177 static int
1178 acpi_add_single_object(struct acpi_device **child,
1179                        struct acpi_device *parent, acpi_handle handle, int type,
1180                         struct acpi_bus_ops *ops)
1181 {
1182         int result = 0;
1183         struct acpi_device *device = NULL;
1184
1185
1186         if (!child)
1187                 return -EINVAL;
1188
1189         device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
1190         if (!device) {
1191                 printk(KERN_ERR PREFIX "Memory allocation error\n");
1192                 return -ENOMEM;
1193         }
1194
1195         device->handle = handle;
1196         device->parent = parent;
1197         device->bus_ops = *ops; /* workround for not call .start */
1198
1199
1200         acpi_device_get_busid(device, handle, type);
1201
1202         /*
1203          * Flags
1204          * -----
1205          * Get prior to calling acpi_bus_get_status() so we know whether
1206          * or not _STA is present.  Note that we only look for object
1207          * handles -- cannot evaluate objects until we know the device is
1208          * present and properly initialized.
1209          */
1210         result = acpi_bus_get_flags(device);
1211         if (result)
1212                 goto end;
1213
1214         /*
1215          * Status
1216          * ------
1217          * See if the device is present.  We always assume that non-Device
1218          * and non-Processor objects (e.g. thermal zones, power resources,
1219          * etc.) are present, functioning, etc. (at least when parent object
1220          * is present).  Note that _STA has a different meaning for some
1221          * objects (e.g. power resources) so we need to be careful how we use
1222          * it.
1223          */
1224         switch (type) {
1225         case ACPI_BUS_TYPE_PROCESSOR:
1226         case ACPI_BUS_TYPE_DEVICE:
1227                 result = acpi_bus_get_status(device);
1228                 if (ACPI_FAILURE(result)) {
1229                         result = -ENODEV;
1230                         goto end;
1231                 }
1232                 /*
1233                  * When the device is neither present nor functional, the
1234                  * device should not be added to Linux ACPI device tree.
1235                  * When the status of the device is not present but functinal,
1236                  * it should be added to Linux ACPI tree. For example : bay
1237                  * device , dock device.
1238                  * In such conditions it is unncessary to check whether it is
1239                  * bay device or dock device.
1240                  */
1241                 if (!device->status.present && !device->status.functional) {
1242                         result = -ENODEV;
1243                         goto end;
1244                 }
1245                 break;
1246         default:
1247                 STRUCT_TO_INT(device->status) =
1248                     ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED |
1249                     ACPI_STA_DEVICE_UI      | ACPI_STA_DEVICE_FUNCTIONING;
1250                 break;
1251         }
1252
1253         /*
1254          * Initialize Device
1255          * -----------------
1256          * TBD: Synch with Core's enumeration/initialization process.
1257          */
1258
1259         /*
1260          * Hardware ID, Unique ID, & Bus Address
1261          * -------------------------------------
1262          */
1263         acpi_device_set_id(device, parent, handle, type);
1264
1265         /*
1266          * The ACPI device is attached to acpi handle before getting
1267          * the power/wakeup/peformance flags. Otherwise OS can't get
1268          * the corresponding ACPI device by the acpi handle in the course
1269          * of getting the power/wakeup/performance flags.
1270          */
1271         result = acpi_device_set_context(device, type);
1272         if (result)
1273                 goto end;
1274
1275         /*
1276          * Power Management
1277          * ----------------
1278          */
1279         if (device->flags.power_manageable) {
1280                 result = acpi_bus_get_power_flags(device);
1281                 if (result)
1282                         goto end;
1283         }
1284
1285         /*
1286          * Wakeup device management
1287          *-----------------------
1288          */
1289         if (device->flags.wake_capable) {
1290                 result = acpi_bus_get_wakeup_device_flags(device);
1291                 if (result)
1292                         goto end;
1293         }
1294
1295         /*
1296          * Performance Management
1297          * ----------------------
1298          */
1299         if (device->flags.performance_manageable) {
1300                 result = acpi_bus_get_perf_flags(device);
1301                 if (result)
1302                         goto end;
1303         }
1304
1305
1306         result = acpi_device_register(device, parent);
1307
1308         /*
1309          * Bind _ADR-Based Devices when hot add
1310          */
1311         if (device->flags.bus_address) {
1312                 if (device->parent && device->parent->ops.bind)
1313                         device->parent->ops.bind(device);
1314         }
1315
1316       end:
1317         if (!result)
1318                 *child = device;
1319         else {
1320                 kfree(device->pnp.cid_list);
1321                 kfree(device);
1322         }
1323
1324         return result;
1325 }
1326
1327 static int acpi_bus_scan(struct acpi_device *start, struct acpi_bus_ops *ops)
1328 {
1329         acpi_status status = AE_OK;
1330         struct acpi_device *parent = NULL;
1331         struct acpi_device *child = NULL;
1332         acpi_handle phandle = NULL;
1333         acpi_handle chandle = NULL;
1334         acpi_object_type type = 0;
1335         u32 level = 1;
1336
1337
1338         if (!start)
1339                 return -EINVAL;
1340
1341         parent = start;
1342         phandle = start->handle;
1343
1344         /*
1345          * Parse through the ACPI namespace, identify all 'devices', and
1346          * create a new 'struct acpi_device' for each.
1347          */
1348         while ((level > 0) && parent) {
1349
1350                 status = acpi_get_next_object(ACPI_TYPE_ANY, phandle,
1351                                               chandle, &chandle);
1352
1353                 /*
1354                  * If this scope is exhausted then move our way back up.
1355                  */
1356                 if (ACPI_FAILURE(status)) {
1357                         level--;
1358                         chandle = phandle;
1359                         acpi_get_parent(phandle, &phandle);
1360                         if (parent->parent)
1361                                 parent = parent->parent;
1362                         continue;
1363                 }
1364
1365                 status = acpi_get_type(chandle, &type);
1366                 if (ACPI_FAILURE(status))
1367                         continue;
1368
1369                 /*
1370                  * If this is a scope object then parse it (depth-first).
1371                  */
1372                 if (type == ACPI_TYPE_LOCAL_SCOPE) {
1373                         level++;
1374                         phandle = chandle;
1375                         chandle = NULL;
1376                         continue;
1377                 }
1378
1379                 /*
1380                  * We're only interested in objects that we consider 'devices'.
1381                  */
1382                 switch (type) {
1383                 case ACPI_TYPE_DEVICE:
1384                         type = ACPI_BUS_TYPE_DEVICE;
1385                         break;
1386                 case ACPI_TYPE_PROCESSOR:
1387                         type = ACPI_BUS_TYPE_PROCESSOR;
1388                         break;
1389                 case ACPI_TYPE_THERMAL:
1390                         type = ACPI_BUS_TYPE_THERMAL;
1391                         break;
1392                 case ACPI_TYPE_POWER:
1393                         type = ACPI_BUS_TYPE_POWER;
1394                         break;
1395                 default:
1396                         continue;
1397                 }
1398
1399                 if (ops->acpi_op_add)
1400                         status = acpi_add_single_object(&child, parent,
1401                                 chandle, type, ops);
1402                 else
1403                         status = acpi_bus_get_device(chandle, &child);
1404
1405                 if (ACPI_FAILURE(status))
1406                         continue;
1407
1408                 if (ops->acpi_op_start && !(ops->acpi_op_add)) {
1409                         status = acpi_start_single_object(child);
1410                         if (ACPI_FAILURE(status))
1411                                 continue;
1412                 }
1413
1414                 /*
1415                  * If the device is present, enabled, and functioning then
1416                  * parse its scope (depth-first).  Note that we need to
1417                  * represent absent devices to facilitate PnP notifications
1418                  * -- but only the subtree head (not all of its children,
1419                  * which will be enumerated when the parent is inserted).
1420                  *
1421                  * TBD: Need notifications and other detection mechanisms
1422                  *      in place before we can fully implement this.
1423                  */
1424                  /*
1425                  * When the device is not present but functional, it is also
1426                  * necessary to scan the children of this device.
1427                  */
1428                 if (child->status.present || (!child->status.present &&
1429                                         child->status.functional)) {
1430                         status = acpi_get_next_object(ACPI_TYPE_ANY, chandle,
1431                                                       NULL, NULL);
1432                         if (ACPI_SUCCESS(status)) {
1433                                 level++;
1434                                 phandle = chandle;
1435                                 chandle = NULL;
1436                                 parent = child;
1437                         }
1438                 }
1439         }
1440
1441         return 0;
1442 }
1443
1444 int
1445 acpi_bus_add(struct acpi_device **child,
1446              struct acpi_device *parent, acpi_handle handle, int type)
1447 {
1448         int result;
1449         struct acpi_bus_ops ops;
1450
1451         memset(&ops, 0, sizeof(ops));
1452         ops.acpi_op_add = 1;
1453
1454         result = acpi_add_single_object(child, parent, handle, type, &ops);
1455         if (!result)
1456                 result = acpi_bus_scan(*child, &ops);
1457
1458         return result;
1459 }
1460
1461 EXPORT_SYMBOL(acpi_bus_add);
1462
1463 int acpi_bus_start(struct acpi_device *device)
1464 {
1465         int result;
1466         struct acpi_bus_ops ops;
1467
1468
1469         if (!device)
1470                 return -EINVAL;
1471
1472         result = acpi_start_single_object(device);
1473         if (!result) {
1474                 memset(&ops, 0, sizeof(ops));
1475                 ops.acpi_op_start = 1;
1476                 result = acpi_bus_scan(device, &ops);
1477         }
1478         return result;
1479 }
1480
1481 EXPORT_SYMBOL(acpi_bus_start);
1482
1483 int acpi_bus_trim(struct acpi_device *start, int rmdevice)
1484 {
1485         acpi_status status;
1486         struct acpi_device *parent, *child;
1487         acpi_handle phandle, chandle;
1488         acpi_object_type type;
1489         u32 level = 1;
1490         int err = 0;
1491
1492         parent = start;
1493         phandle = start->handle;
1494         child = chandle = NULL;
1495
1496         while ((level > 0) && parent && (!err)) {
1497                 status = acpi_get_next_object(ACPI_TYPE_ANY, phandle,
1498                                               chandle, &chandle);
1499
1500                 /*
1501                  * If this scope is exhausted then move our way back up.
1502                  */
1503                 if (ACPI_FAILURE(status)) {
1504                         level--;
1505                         chandle = phandle;
1506                         acpi_get_parent(phandle, &phandle);
1507                         child = parent;
1508                         parent = parent->parent;
1509
1510                         if (level == 0)
1511                                 err = acpi_bus_remove(child, rmdevice);
1512                         else
1513                                 err = acpi_bus_remove(child, 1);
1514
1515                         continue;
1516                 }
1517
1518                 status = acpi_get_type(chandle, &type);
1519                 if (ACPI_FAILURE(status)) {
1520                         continue;
1521                 }
1522                 /*
1523                  * If there is a device corresponding to chandle then
1524                  * parse it (depth-first).
1525                  */
1526                 if (acpi_bus_get_device(chandle, &child) == 0) {
1527                         level++;
1528                         phandle = chandle;
1529                         chandle = NULL;
1530                         parent = child;
1531                 }
1532                 continue;
1533         }
1534         return err;
1535 }
1536 EXPORT_SYMBOL_GPL(acpi_bus_trim);
1537
1538
1539 static int acpi_bus_scan_fixed(struct acpi_device *root)
1540 {
1541         int result = 0;
1542         struct acpi_device *device = NULL;
1543         struct acpi_bus_ops ops;
1544
1545         if (!root)
1546                 return -ENODEV;
1547
1548         memset(&ops, 0, sizeof(ops));
1549         ops.acpi_op_add = 1;
1550         ops.acpi_op_start = 1;
1551
1552         /*
1553          * Enumerate all fixed-feature devices.
1554          */
1555         if ((acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON) == 0) {
1556                 result = acpi_add_single_object(&device, acpi_root,
1557                                                 NULL,
1558                                                 ACPI_BUS_TYPE_POWER_BUTTON,
1559                                                 &ops);
1560         }
1561
1562         if ((acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON) == 0) {
1563                 result = acpi_add_single_object(&device, acpi_root,
1564                                                 NULL,
1565                                                 ACPI_BUS_TYPE_SLEEP_BUTTON,
1566                                                 &ops);
1567         }
1568
1569         return result;
1570 }
1571
1572 int __init acpi_boot_ec_enable(void);
1573
1574 static int __init acpi_scan_init(void)
1575 {
1576         int result;
1577         struct acpi_bus_ops ops;
1578
1579
1580         if (acpi_disabled)
1581                 return 0;
1582
1583         memset(&ops, 0, sizeof(ops));
1584         ops.acpi_op_add = 1;
1585         ops.acpi_op_start = 1;
1586
1587         result = bus_register(&acpi_bus_type);
1588         if (result) {
1589                 /* We don't want to quit even if we failed to add suspend/resume */
1590                 printk(KERN_ERR PREFIX "Could not register bus type\n");
1591         }
1592
1593         /*
1594          * Create the root device in the bus's device tree
1595          */
1596         result = acpi_add_single_object(&acpi_root, NULL, ACPI_ROOT_OBJECT,
1597                                         ACPI_BUS_TYPE_SYSTEM, &ops);
1598         if (result)
1599                 goto Done;
1600
1601         /*
1602          * Enumerate devices in the ACPI namespace.
1603          */
1604         result = acpi_bus_scan_fixed(acpi_root);
1605
1606         /* EC region might be needed at bus_scan, so enable it now */
1607         acpi_boot_ec_enable();
1608
1609         if (!result)
1610                 result = acpi_bus_scan(acpi_root, &ops);
1611
1612         if (result)
1613                 acpi_device_unregister(acpi_root, ACPI_BUS_REMOVAL_NORMAL);
1614
1615       Done:
1616         return result;
1617 }
1618
1619 subsys_initcall(acpi_scan_init);