Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

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