root/drivers/acpi/container.c

DEFINITIONS

1. acpi_container_offline
2. acpi_container_release
3. container_device_attach
4. container_device_detach
5. container_device_online
6. acpi_container_init
7. acpi_container_init

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * container.c  - ACPI Generic Container Driver
   4  *
   5  * Copyright (C) 2004 Anil S Keshavamurthy (anil.s.keshavamurthy@intel.com)
   6  * Copyright (C) 2004 Keiichiro Tokunaga (tokunaga.keiich@jp.fujitsu.com)
   7  * Copyright (C) 2004 Motoyuki Ito (motoyuki@soft.fujitsu.com)
   8  * Copyright (C) 2004 FUJITSU LIMITED
   9  * Copyright (C) 2004, 2013 Intel Corp.
  10  * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
  11  */
  12 #include <linux/acpi.h>
  13 #include <linux/container.h>
  14 
  15 #include "internal.h"
  16 
  17 #define _COMPONENT                      ACPI_CONTAINER_COMPONENT
  18 ACPI_MODULE_NAME("container");
  19 
  20 static const struct acpi_device_id container_device_ids[] = {
  21         {"ACPI0004", 0},
  22         {"PNP0A05", 0},
  23         {"PNP0A06", 0},
  24         {"", 0},
  25 };
  26 
  27 #ifdef CONFIG_ACPI_CONTAINER
  28 
  29 static int acpi_container_offline(struct container_dev *cdev)
  30 {
  31         struct acpi_device *adev = ACPI_COMPANION(&cdev->dev);
  32         struct acpi_device *child;
  33 
  34         /* Check all of the dependent devices' physical companions. */
  35         list_for_each_entry(child, &adev->children, node)
  36                 if (!acpi_scan_is_offline(child, false))
  37                         return -EBUSY;
  38 
  39         return 0;
  40 }
  41 
  42 static void acpi_container_release(struct device *dev)
  43 {
  44         kfree(to_container_dev(dev));
  45 }
  46 
  47 static int container_device_attach(struct acpi_device *adev,
  48                                    const struct acpi_device_id *not_used)
  49 {
  50         struct container_dev *cdev;
  51         struct device *dev;
  52         int ret;
  53 
  54         if (adev->flags.is_dock_station)
  55                 return 0;
  56 
  57         cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
  58         if (!cdev)
  59                 return -ENOMEM;
  60 
  61         cdev->offline = acpi_container_offline;
  62         dev = &cdev->dev;
  63         dev->bus = &container_subsys;
  64         dev_set_name(dev, "%s", dev_name(&adev->dev));
  65         ACPI_COMPANION_SET(dev, adev);
  66         dev->release = acpi_container_release;
  67         ret = device_register(dev);
  68         if (ret) {
  69                 put_device(dev);
  70                 return ret;
  71         }
  72         adev->driver_data = dev;
  73         return 1;
  74 }
  75 
  76 static void container_device_detach(struct acpi_device *adev)
  77 {
  78         struct device *dev = acpi_driver_data(adev);
  79 
  80         adev->driver_data = NULL;
  81         if (dev)
  82                 device_unregister(dev);
  83 }
  84 
  85 static void container_device_online(struct acpi_device *adev)
  86 {
  87         struct device *dev = acpi_driver_data(adev);
  88 
  89         kobject_uevent(&dev->kobj, KOBJ_ONLINE);
  90 }
  91 
  92 static struct acpi_scan_handler container_handler = {
  93         .ids = container_device_ids,
  94         .attach = container_device_attach,
  95         .detach = container_device_detach,
  96         .hotplug = {
  97                 .enabled = true,
  98                 .demand_offline = true,
  99                 .notify_online = container_device_online,
 100         },
 101 };
 102 
 103 void __init acpi_container_init(void)
 104 {
 105         acpi_scan_add_handler(&container_handler);
 106 }
 107 
 108 #else
 109 
 110 static struct acpi_scan_handler container_handler = {
 111         .ids = container_device_ids,
 112 };
 113 
 114 void __init acpi_container_init(void)
 115 {
 116         acpi_scan_add_handler_with_hotplug(&container_handler, "container");
 117 }
 118 
 119 #endif /* CONFIG_ACPI_CONTAINER */