Merge branch 'acpi-hotplug' (6621c5a6) · Commits · 戴 / test

drivers/acpi/bus.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -400,7 +400,7 @@ static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
		case ACPI_NOTIFY_BUS_CHECK:
		case ACPI_NOTIFY_DEVICE_CHECK:
		case ACPI_NOTIFY_EJECT_REQUEST:
		status = acpi_hotplug_execute(acpi_device_hotplug, adev, type);
		status = acpi_hotplug_schedule(adev, type);
		if (ACPI_SUCCESS(status))
		return;
		default:

drivers/acpi/container.c

+3 −0

Original line number	Diff line number	Diff line
		@@ -68,6 +68,9 @@ static int container_device_attach(struct acpi_device *adev,
		struct device *dev;
		int ret;

		if (adev->flags.is_dock_station)
		return 0;

		cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
		if (!cdev)
		return -ENOMEM;

drivers/acpi/dock.c

+109 −343

Original line number	Diff line number	Diff line
		/*
		* dock.c - ACPI dock station driver
		*
		* Copyright (C) 2006 Kristen Carlson Accardi <kristen.c.accardi@intel.com>
		* Copyright (C) 2006, 2014, Intel Corp.
		* Author: Kristen Carlson Accardi <kristen.c.accardi@intel.com>
		* Rafael J. Wysocki <rafael.j.wysocki@intel.com>
		*
		* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		*
		@@ -68,15 +70,10 @@ struct dock_station {
		};
		static LIST_HEAD(dock_stations);
		static int dock_station_count;
		static DEFINE_MUTEX(hotplug_lock);

		struct dock_dependent_device {
		struct list_head list;
		acpi_handle handle;
		const struct acpi_dock_ops *hp_ops;
		void *hp_context;
		unsigned int hp_refcount;
		void (hp_release)(void );
		struct acpi_device *adev;
		};

		#define DOCK_DOCKING 0x00000001
		@@ -98,13 +95,13 @@ enum dock_callback_type {
		*****************************************************************************/
		/**
		* add_dock_dependent_device - associate a device with the dock station
		* @ds: The dock station
		* @handle: handle of the dependent device
		* @ds: Dock station.
		* @adev: Dependent ACPI device object.
		*
		* Add the dependent device to the dock's dependent device list.
		*/
		static int __init
		add_dock_dependent_device(struct dock_station *ds, acpi_handle handle)
		static int add_dock_dependent_device(struct dock_station *ds,
		struct acpi_device *adev)
		{
		struct dock_dependent_device *dd;

		@@ -112,180 +109,120 @@ add_dock_dependent_device(struct dock_station *ds, acpi_handle handle)
		if (!dd)
		return -ENOMEM;

		dd->handle = handle;
		dd->adev = adev;
		INIT_LIST_HEAD(&dd->list);
		list_add_tail(&dd->list, &ds->dependent_devices);

		return 0;
		}

		static void remove_dock_dependent_devices(struct dock_station *ds)
		static void dock_hotplug_event(struct dock_dependent_device *dd, u32 event,
		enum dock_callback_type cb_type)
		{
		struct dock_dependent_device dd, aux;
		struct acpi_device *adev = dd->adev;

		list_for_each_entry_safe(dd, aux, &ds->dependent_devices, list) {
		list_del(&dd->list);
		kfree(dd);
		}
		}

		/**
		* dock_init_hotplug - Initialize a hotplug device on a docking station.
		* @dd: Dock-dependent device.
		* @ops: Dock operations to attach to the dependent device.
		* @context: Data to pass to the @ops callbacks and @release.
		* @init: Optional initialization routine to run after setting up context.
		* @release: Optional release routine to run on removal.
		*/
		static int dock_init_hotplug(struct dock_dependent_device *dd,
		const struct acpi_dock_ops ops, void context,
		void (init)(void ), void (release)(void ))
		{
		int ret = 0;
		acpi_lock_hp_context();

		mutex_lock(&hotplug_lock);
		if (WARN_ON(dd->hp_context)) {
		ret = -EEXIST;
		} else {
		dd->hp_refcount = 1;
		dd->hp_ops = ops;
		dd->hp_context = context;
		dd->hp_release = release;
		if (init)
		init(context);
		}
		mutex_unlock(&hotplug_lock);
		return ret;
		}
		if (!adev->hp)
		goto out;

		/**
		* dock_release_hotplug - Decrement hotplug reference counter of dock device.
		* @dd: Dock-dependent device.
		*
		* Decrement the reference counter of @dd and if 0, detach its hotplug
		* operations from it, reset its context pointer and run the optional release
		* routine if present.
		*/
		static void dock_release_hotplug(struct dock_dependent_device *dd)
		{
		mutex_lock(&hotplug_lock);
		if (dd->hp_context && !--dd->hp_refcount) {
		void (release)(void ) = dd->hp_release;
		void *context = dd->hp_context;
		if (cb_type == DOCK_CALL_FIXUP) {
		void (fixup)(struct acpi_device );

		dd->hp_ops = NULL;
		dd->hp_context = NULL;
		dd->hp_release = NULL;
		if (release)
		release(context);
		}
		mutex_unlock(&hotplug_lock);
		fixup = adev->hp->fixup;
		if (fixup) {
		acpi_unlock_hp_context();
		fixup(adev);
		return;
		}
		} else if (cb_type == DOCK_CALL_UEVENT) {
		void (uevent)(struct acpi_device , u32);

		static void dock_hotplug_event(struct dock_dependent_device *dd, u32 event,
		enum dock_callback_type cb_type)
		{
		acpi_notify_handler cb = NULL;
		bool run = false;

		mutex_lock(&hotplug_lock);

		if (dd->hp_context) {
		run = true;
		dd->hp_refcount++;
		if (dd->hp_ops) {
		switch (cb_type) {
		case DOCK_CALL_FIXUP:
		cb = dd->hp_ops->fixup;
		break;
		case DOCK_CALL_UEVENT:
		cb = dd->hp_ops->uevent;
		break;
		default:
		cb = dd->hp_ops->handler;
		uevent = adev->hp->uevent;
		if (uevent) {
		acpi_unlock_hp_context();
		uevent(adev, event);
		return;
		}
		} else {
		int (notify)(struct acpi_device , u32);

		notify = adev->hp->notify;
		if (notify) {
		acpi_unlock_hp_context();
		notify(adev, event);
		return;
		}
		}

		mutex_unlock(&hotplug_lock);
		out:
		acpi_unlock_hp_context();
		}

		if (!run)
		return;
		static struct dock_station *find_dock_station(acpi_handle handle)
		{
		struct dock_station *ds;

		if (cb)
		cb(dd->handle, event, dd->hp_context);
		list_for_each_entry(ds, &dock_stations, sibling)
		if (ds->handle == handle)
		return ds;

		dock_release_hotplug(dd);
		return NULL;
		}

		/**
		* find_dock_dependent_device - get a device dependent on this dock
		* @ds: the dock station
		* @handle: the acpi_handle of the device we want
		* @adev: ACPI device object to find.
		*
		* iterate over the dependent device list for this dock. If the
		* dependent device matches the handle, return.
		*/
		static struct dock_dependent_device *
		find_dock_dependent_device(struct dock_station *ds, acpi_handle handle)
		find_dock_dependent_device(struct dock_station ds, struct acpi_device adev)
		{
		struct dock_dependent_device *dd;

		list_for_each_entry(dd, &ds->dependent_devices, list)
		if (handle == dd->handle)
		if (adev == dd->adev)
		return dd;

		return NULL;
		}

		/*****************************************************************************
		* Dock functions *
		*****************************************************************************/
		static int __init is_battery(acpi_handle handle)
		void register_dock_dependent_device(struct acpi_device *adev,
		acpi_handle dshandle)
		{
		struct acpi_device_info *info;
		int ret = 1;

		if (!ACPI_SUCCESS(acpi_get_object_info(handle, &info)))
		return 0;
		if (!(info->valid & ACPI_VALID_HID))
		ret = 0;
		else
		ret = !strcmp("PNP0C0A", info->hardware_id.string);
		struct dock_station *ds = find_dock_station(dshandle);

		kfree(info);
		return ret;
		if (ds && !find_dock_dependent_device(ds, adev))
		add_dock_dependent_device(ds, adev);
		}

		/* Check whether ACPI object is an ejectable battery or disk bay */
		static bool __init is_ejectable_bay(acpi_handle handle)
		{
		if (acpi_has_method(handle, "_EJ0") && is_battery(handle))
		return true;

		return acpi_bay_match(handle);
		}
		/*****************************************************************************
		* Dock functions *
		*****************************************************************************/

		/**
		* is_dock_device - see if a device is on a dock station
		* @handle: acpi handle of the device
		* @adev: ACPI device object to check.
		*
		* If this device is either the dock station itself,
		* or is a device dependent on the dock station, then it
		* is a dock device
		*/
		int is_dock_device(acpi_handle handle)
		int is_dock_device(struct acpi_device *adev)
		{
		struct dock_station *dock_station;

		if (!dock_station_count)
		return 0;

		if (acpi_dock_match(handle))
		if (acpi_dock_match(adev->handle))
		return 1;

		list_for_each_entry(dock_station, &dock_stations, sibling)
		if (find_dock_dependent_device(dock_station, handle))
		if (find_dock_dependent_device(dock_station, adev))
		return 1;

		return 0;
		@@ -312,43 +249,6 @@ static int dock_present(struct dock_station *ds)
		return 0;
		}

		/**
		* dock_create_acpi_device - add new devices to acpi
		* @handle - handle of the device to add
		*
		* This function will create a new acpi_device for the given
		* handle if one does not exist already. This should cause
		* acpi to scan for drivers for the given devices, and call
		* matching driver's add routine.
		*/
		static void dock_create_acpi_device(acpi_handle handle)
		{
		struct acpi_device *device = NULL;
		int ret;

		acpi_bus_get_device(handle, &device);
		if (!acpi_device_enumerated(device)) {
		ret = acpi_bus_scan(handle);
		if (ret)
		pr_debug("error adding bus, %x\n", -ret);
		}
		}

		/**
		* dock_remove_acpi_device - remove the acpi_device struct from acpi
		* @handle - the handle of the device to remove
		*
		* Tell acpi to remove the acpi_device. This should cause any loaded
		* driver to have it's remove routine called.
		*/
		static void dock_remove_acpi_device(acpi_handle handle)
		{
		struct acpi_device *device;

		if (!acpi_bus_get_device(handle, &device))
		acpi_bus_trim(device);
		}

		/**
		* hot_remove_dock_devices - Remove dock station devices.
		* @ds: Dock station.
		@@ -366,7 +266,7 @@ static void hot_remove_dock_devices(struct dock_station *ds)
		dock_hotplug_event(dd, ACPI_NOTIFY_EJECT_REQUEST, false);

		list_for_each_entry_reverse(dd, &ds->dependent_devices, list)
		dock_remove_acpi_device(dd->handle);
		acpi_bus_trim(dd->adev);
		}

		/**
		@@ -392,12 +292,20 @@ static void hotplug_dock_devices(struct dock_station *ds, u32 event)
		dock_hotplug_event(dd, event, DOCK_CALL_HANDLER);

		/*
		* Now make sure that an acpi_device is created for each dependent
		* device. That will cause scan handlers to be attached to device
		* objects or acpi_drivers to be stopped/started if they are present.
		* Check if all devices have been enumerated already. If not, run
		* acpi_bus_scan() for them and that will cause scan handlers to be
		* attached to device objects or acpi_drivers to be stopped/started if
		* they are present.
		*/
		list_for_each_entry(dd, &ds->dependent_devices, list)
		dock_create_acpi_device(dd->handle);
		list_for_each_entry(dd, &ds->dependent_devices, list) {
		struct acpi_device *adev = dd->adev;

		if (!acpi_device_enumerated(adev)) {
		int ret = acpi_bus_scan(adev->handle);
		if (ret)
		dev_dbg(&adev->dev, "scan error %d\n", -ret);
		}
		}
		}

		static void dock_event(struct dock_station *ds, u32 event, int num)
		@@ -500,71 +408,6 @@ static int dock_in_progress(struct dock_station *ds)
		return 0;
		}

		/**
		* register_hotplug_dock_device - register a hotplug function
		* @handle: the handle of the device
		* @ops: handlers to call after docking
		* @context: device specific data
		* @init: Optional initialization routine to run after registration
		* @release: Optional release routine to run on unregistration
		*
		* If a driver would like to perform a hotplug operation after a dock
		* event, they can register an acpi_notifiy_handler to be called by
		* the dock driver after _DCK is executed.
		*/
		int register_hotplug_dock_device(acpi_handle handle,
		const struct acpi_dock_ops ops, void context,
		void (init)(void ), void (release)(void ))
		{
		struct dock_dependent_device *dd;
		struct dock_station *dock_station;
		int ret = -EINVAL;

		if (WARN_ON(!context))
		return -EINVAL;

		if (!dock_station_count)
		return -ENODEV;

		/*
		* make sure this handle is for a device dependent on the dock,
		* this would include the dock station itself
		*/
		list_for_each_entry(dock_station, &dock_stations, sibling) {
		/*
		* An ATA bay can be in a dock and itself can be ejected
		* separately, so there are two 'dock stations' which need the
		* ops
		*/
		dd = find_dock_dependent_device(dock_station, handle);
		if (dd && !dock_init_hotplug(dd, ops, context, init, release))
		ret = 0;
		}

		return ret;
		}
		EXPORT_SYMBOL_GPL(register_hotplug_dock_device);

		/**
		* unregister_hotplug_dock_device - remove yourself from the hotplug list
		* @handle: the acpi handle of the device
		*/
		void unregister_hotplug_dock_device(acpi_handle handle)
		{
		struct dock_dependent_device *dd;
		struct dock_station *dock_station;

		if (!dock_station_count)
		return;

		list_for_each_entry(dock_station, &dock_stations, sibling) {
		dd = find_dock_dependent_device(dock_station, handle);
		if (dd)
		dock_release_hotplug(dd);
		}
		}
		EXPORT_SYMBOL_GPL(unregister_hotplug_dock_device);

		/**
		* handle_eject_request - handle an undock request checking for error conditions
		*
		@@ -598,20 +441,23 @@ static int handle_eject_request(struct dock_station *ds, u32 event)
		}

		/**
		* dock_notify - act upon an acpi dock notification
		* @ds: dock station
		* @event: the acpi event
		* dock_notify - Handle ACPI dock notification.
		* @adev: Dock station's ACPI device object.
		* @event: Event code.
		*
		* If we are notified to dock, then check to see if the dock is
		* present and then dock. Notify all drivers of the dock event,
		* and then hotplug and devices that may need hotplugging.
		*/
		static void dock_notify(struct dock_station *ds, u32 event)
		int dock_notify(struct acpi_device *adev, u32 event)
		{
		acpi_handle handle = ds->handle;
		struct acpi_device *adev = NULL;
		acpi_handle handle = adev->handle;
		struct dock_station *ds = find_dock_station(handle);
		int surprise_removal = 0;

		if (!ds)
		return -ENODEV;

		/*
		* According to acpi spec 3.0a, if a DEVICE_CHECK notification
		* is sent and _DCK is present, it is assumed to mean an undock
		@@ -632,7 +478,6 @@ static void dock_notify(struct dock_station *ds, u32 event)
		switch (event) {
		case ACPI_NOTIFY_BUS_CHECK:
		case ACPI_NOTIFY_DEVICE_CHECK:
		acpi_bus_get_device(handle, &adev);
		if (!dock_in_progress(ds) && !acpi_device_enumerated(adev)) {
		begin_dock(ds);
		dock(ds);
		@@ -662,49 +507,8 @@ static void dock_notify(struct dock_station *ds, u32 event)
		else
		dock_event(ds, event, UNDOCK_EVENT);
		break;
		default:
		acpi_handle_err(handle, "Unknown dock event %d\n", event);
		}
		}

		static void acpi_dock_deferred_cb(void *data, u32 event)
		{
		acpi_scan_lock_acquire();
		dock_notify(data, event);
		acpi_scan_lock_release();
		}

		static void dock_notify_handler(acpi_handle handle, u32 event, void *data)
		{
		if (event != ACPI_NOTIFY_BUS_CHECK && event != ACPI_NOTIFY_DEVICE_CHECK
		&& event != ACPI_NOTIFY_EJECT_REQUEST)
		return;

		acpi_hotplug_execute(acpi_dock_deferred_cb, data, event);
		}

		/**
		* find_dock_devices - find devices on the dock station
		* @handle: the handle of the device we are examining
		* @lvl: unused
		* @context: the dock station private data
		* @rv: unused
		*
		* This function is called by acpi_walk_namespace. It will
		* check to see if an object has an _EJD method. If it does, then it
		* will see if it is dependent on the dock station.
		*/
		static acpi_status __init find_dock_devices(acpi_handle handle, u32 lvl,
		void context, void *rv)
		{
		struct dock_station *ds = context;
		acpi_handle ejd = NULL;

		acpi_bus_get_ejd(handle, &ejd);
		if (ejd == ds->handle)
		add_dock_dependent_device(ds, handle);

		return AE_OK;
		return 0;
		}

		/*
		@@ -803,23 +607,28 @@ static struct attribute_group dock_attribute_group = {
		};

		/**
		* dock_add - add a new dock station
		* @handle: the dock station handle
		* acpi_dock_add - Add a new dock station
		* @adev: Dock station ACPI device object.
		*
		* allocated and initialize a new dock station device. Find all devices
		* that are on the dock station, and register for dock event notifications.
		* allocated and initialize a new dock station device.
		*/
		static int __init dock_add(acpi_handle handle)
		void acpi_dock_add(struct acpi_device *adev)
		{
		struct dock_station *dock_station, ds = { NULL, };
		struct platform_device_info pdevinfo;
		acpi_handle handle = adev->handle;
		struct platform_device *dd;
		acpi_status status;
		int ret;

		dd = platform_device_register_data(NULL, "dock", dock_station_count,
		&ds, sizeof(ds));
		memset(&pdevinfo, 0, sizeof(pdevinfo));
		pdevinfo.name = "dock";
		pdevinfo.id = dock_station_count;
		pdevinfo.acpi_node.companion = adev;
		pdevinfo.data = &ds;
		pdevinfo.size_data = sizeof(ds);
		dd = platform_device_register_full(&pdevinfo);
		if (IS_ERR(dd))
		return PTR_ERR(dd);
		return;

		dock_station = dd->dev.platform_data;

		@@ -837,72 +646,29 @@ static int __init dock_add(acpi_handle handle)
		dock_station->flags \|= DOCK_IS_DOCK;
		if (acpi_ata_match(handle))
		dock_station->flags \|= DOCK_IS_ATA;
		if (is_battery(handle))
		if (acpi_device_is_battery(adev))
		dock_station->flags \|= DOCK_IS_BAT;

		ret = sysfs_create_group(&dd->dev.kobj, &dock_attribute_group);
		if (ret)
		goto err_unregister;

		/* Find dependent devices */
		acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
		ACPI_UINT32_MAX, find_dock_devices, NULL,
		dock_station, NULL);

		/* add the dock station as a device dependent on itself */
		ret = add_dock_dependent_device(dock_station, handle);
		ret = add_dock_dependent_device(dock_station, adev);
		if (ret)
		goto err_rmgroup;

		status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
		dock_notify_handler, dock_station);
		if (ACPI_FAILURE(status)) {
		ret = -ENODEV;
		goto err_rmgroup;
		}

		dock_station_count++;
		list_add(&dock_station->sibling, &dock_stations);
		return 0;
		adev->flags.is_dock_station = true;
		dev_info(&adev->dev, "ACPI dock station (docks/bays count: %d)\n",
		dock_station_count);
		return;

		err_rmgroup:
		remove_dock_dependent_devices(dock_station);
		sysfs_remove_group(&dd->dev.kobj, &dock_attribute_group);

		err_unregister:
		platform_device_unregister(dd);
		acpi_handle_err(handle, "%s encountered error %d\n", __func__, ret);
		return ret;
		}

		/**
		* find_dock_and_bay - look for dock stations and bays
		* @handle: acpi handle of a device
		* @lvl: unused
		* @context: unused
		* @rv: unused
		*
		* This is called by acpi_walk_namespace to look for dock stations and bays.
		*/
		static acpi_status __init
		find_dock_and_bay(acpi_handle handle, u32 lvl, void context, void *rv)
		{
		if (acpi_dock_match(handle) \|\| is_ejectable_bay(handle))
		dock_add(handle);

		return AE_OK;
		}

		void __init acpi_dock_init(void)
		{
		/* look for dock stations and bays */
		acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
		ACPI_UINT32_MAX, find_dock_and_bay, NULL, NULL, NULL);

		if (!dock_station_count) {
		pr_info(PREFIX "No dock devices found.\n");
		return;
		}

		pr_info(PREFIX "%s: %d docks/bays found\n",
		ACPI_DOCK_DRIVER_DESCRIPTION, dock_station_count);
		}

drivers/acpi/internal.h

+11 −3

Original line number	Diff line number	Diff line
		@@ -37,9 +37,15 @@ void acpi_container_init(void);
		static inline void acpi_container_init(void) {}
		#endif
		#ifdef CONFIG_ACPI_DOCK
		void acpi_dock_init(void);
		void register_dock_dependent_device(struct acpi_device *adev,
		acpi_handle dshandle);
		int dock_notify(struct acpi_device *adev, u32 event);
		void acpi_dock_add(struct acpi_device *adev);
		#else
		static inline void acpi_dock_init(void) {}
		static inline void register_dock_dependent_device(struct acpi_device *adev,
		acpi_handle dshandle) {}
		static inline int dock_notify(struct acpi_device *adev, u32 event) { return -ENODEV; }
		static inline void acpi_dock_add(struct acpi_device *adev) {}
		#endif
		#ifdef CONFIG_ACPI_HOTPLUG_MEMORY
		void acpi_memory_hotplug_init(void);
		@@ -72,8 +78,9 @@ void acpi_lpss_init(void);
		static inline void acpi_lpss_init(void) {}
		#endif

		acpi_status acpi_hotplug_schedule(struct acpi_device *adev, u32 src);
		bool acpi_queue_hotplug_work(struct work_struct *work);
		void acpi_device_hotplug(void *data, u32 src);
		void acpi_device_hotplug(struct acpi_device *adev, u32 src);
		bool acpi_scan_is_offline(struct acpi_device *adev, bool uevent);

		/* --------------------------------------------------------------------------
		@@ -91,6 +98,7 @@ void acpi_free_pnp_ids(struct acpi_device_pnp *pnp);
		int acpi_bind_one(struct device dev, struct acpi_device adev);
		int acpi_unbind_one(struct device *dev);
		bool acpi_device_is_present(struct acpi_device *adev);
		bool acpi_device_is_battery(struct acpi_device *adev);

		/* --------------------------------------------------------------------------
		Power Resource

drivers/acpi/osl.c

+6 −8

Original line number	Diff line number	Diff line
		@@ -1168,8 +1168,7 @@ void acpi_os_wait_events_complete(void)

		struct acpi_hp_work {
		struct work_struct work;
		acpi_hp_callback func;
		void *data;
		struct acpi_device *adev;
		u32 src;
		};

		@@ -1178,25 +1177,24 @@ static void acpi_hotplug_work_fn(struct work_struct *work)
		struct acpi_hp_work *hpw = container_of(work, struct acpi_hp_work, work);

		acpi_os_wait_events_complete();
		hpw->func(hpw->data, hpw->src);
		acpi_device_hotplug(hpw->adev, hpw->src);
		kfree(hpw);
		}

		acpi_status acpi_hotplug_execute(acpi_hp_callback func, void *data, u32 src)
		acpi_status acpi_hotplug_schedule(struct acpi_device *adev, u32 src)
		{
		struct acpi_hp_work *hpw;

		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
		"Scheduling function [%p(%p, %u)] for deferred execution.\n",
		func, data, src));
		"Scheduling hotplug event (%p, %u) for deferred execution.\n",
		adev, src));

		hpw = kmalloc(sizeof(*hpw), GFP_KERNEL);
		if (!hpw)
		return AE_NO_MEMORY;

		INIT_WORK(&hpw->work, acpi_hotplug_work_fn);
		hpw->func = func;
		hpw->data = data;
		hpw->adev = adev;
		hpw->src = src;
		/*
		* We can't run hotplug code in kacpid_wq/kacpid_notify_wq etc., because

Admin message