2 * dock.c - ACPI dock station driver
4 * Copyright (C) 2006 Kristen Carlson Accardi <kristen.c.accardi@intel.com>
6 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or (at
11 * your option) any later version.
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
22 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/slab.h>
28 #include <linux/init.h>
29 #include <linux/types.h>
30 #include <linux/notifier.h>
31 #include <linux/platform_device.h>
32 #include <linux/jiffies.h>
33 #include <linux/stddef.h>
34 #include <linux/acpi.h>
38 #define PREFIX "ACPI: "
40 #define ACPI_DOCK_DRIVER_DESCRIPTION "ACPI Dock Station Driver"
42 ACPI_MODULE_NAME("dock");
43 MODULE_AUTHOR("Kristen Carlson Accardi");
44 MODULE_DESCRIPTION(ACPI_DOCK_DRIVER_DESCRIPTION
);
45 MODULE_LICENSE("GPL");
47 static bool immediate_undock
= 1;
48 module_param(immediate_undock
, bool, 0644);
49 MODULE_PARM_DESC(immediate_undock
, "1 (default) will cause the driver to "
50 "undock immediately when the undock button is pressed, 0 will cause"
51 " the driver to wait for userspace to write the undock sysfs file "
54 static const struct acpi_device_id dock_device_ids
[] = {
58 MODULE_DEVICE_TABLE(acpi
, dock_device_ids
);
62 unsigned long last_dock_time
;
64 struct list_head dependent_devices
;
66 struct list_head sibling
;
67 struct platform_device
*dock_device
;
69 static LIST_HEAD(dock_stations
);
70 static int dock_station_count
;
71 static DEFINE_MUTEX(hotplug_lock
);
73 struct dock_dependent_device
{
74 struct list_head list
;
76 const struct acpi_dock_ops
*hp_ops
;
78 unsigned int hp_refcount
;
79 void (*hp_release
)(void *);
82 #define DOCK_DOCKING 0x00000001
83 #define DOCK_UNDOCKING 0x00000002
84 #define DOCK_IS_DOCK 0x00000010
85 #define DOCK_IS_ATA 0x00000020
86 #define DOCK_IS_BAT 0x00000040
88 #define UNDOCK_EVENT 2
90 enum dock_callback_type
{
96 /*****************************************************************************
97 * Dock Dependent device functions *
98 *****************************************************************************/
100 * add_dock_dependent_device - associate a device with the dock station
101 * @ds: The dock station
102 * @handle: handle of the dependent device
104 * Add the dependent device to the dock's dependent device list.
107 add_dock_dependent_device(struct dock_station
*ds
, acpi_handle handle
)
109 struct dock_dependent_device
*dd
;
111 dd
= kzalloc(sizeof(*dd
), GFP_KERNEL
);
116 INIT_LIST_HEAD(&dd
->list
);
117 list_add_tail(&dd
->list
, &ds
->dependent_devices
);
122 static void remove_dock_dependent_devices(struct dock_station
*ds
)
124 struct dock_dependent_device
*dd
, *aux
;
126 list_for_each_entry_safe(dd
, aux
, &ds
->dependent_devices
, list
) {
133 * dock_init_hotplug - Initialize a hotplug device on a docking station.
134 * @dd: Dock-dependent device.
135 * @ops: Dock operations to attach to the dependent device.
136 * @context: Data to pass to the @ops callbacks and @release.
137 * @init: Optional initialization routine to run after setting up context.
138 * @release: Optional release routine to run on removal.
140 static int dock_init_hotplug(struct dock_dependent_device
*dd
,
141 const struct acpi_dock_ops
*ops
, void *context
,
142 void (*init
)(void *), void (*release
)(void *))
146 mutex_lock(&hotplug_lock
);
147 if (WARN_ON(dd
->hp_context
)) {
152 dd
->hp_context
= context
;
153 dd
->hp_release
= release
;
157 mutex_unlock(&hotplug_lock
);
162 * dock_release_hotplug - Decrement hotplug reference counter of dock device.
163 * @dd: Dock-dependent device.
165 * Decrement the reference counter of @dd and if 0, detach its hotplug
166 * operations from it, reset its context pointer and run the optional release
167 * routine if present.
169 static void dock_release_hotplug(struct dock_dependent_device
*dd
)
171 mutex_lock(&hotplug_lock
);
172 if (dd
->hp_context
&& !--dd
->hp_refcount
) {
173 void (*release
)(void *) = dd
->hp_release
;
174 void *context
= dd
->hp_context
;
177 dd
->hp_context
= NULL
;
178 dd
->hp_release
= NULL
;
182 mutex_unlock(&hotplug_lock
);
185 static void dock_hotplug_event(struct dock_dependent_device
*dd
, u32 event
,
186 enum dock_callback_type cb_type
)
188 acpi_notify_handler cb
= NULL
;
191 mutex_lock(&hotplug_lock
);
193 if (dd
->hp_context
) {
198 case DOCK_CALL_FIXUP
:
199 cb
= dd
->hp_ops
->fixup
;
201 case DOCK_CALL_UEVENT
:
202 cb
= dd
->hp_ops
->uevent
;
205 cb
= dd
->hp_ops
->handler
;
210 mutex_unlock(&hotplug_lock
);
216 cb(dd
->handle
, event
, dd
->hp_context
);
218 dock_release_hotplug(dd
);
222 * find_dock_dependent_device - get a device dependent on this dock
223 * @ds: the dock station
224 * @handle: the acpi_handle of the device we want
226 * iterate over the dependent device list for this dock. If the
227 * dependent device matches the handle, return.
229 static struct dock_dependent_device
*
230 find_dock_dependent_device(struct dock_station
*ds
, acpi_handle handle
)
232 struct dock_dependent_device
*dd
;
234 list_for_each_entry(dd
, &ds
->dependent_devices
, list
)
235 if (handle
== dd
->handle
)
241 /*****************************************************************************
243 *****************************************************************************/
244 static int __init
is_battery(acpi_handle handle
)
246 struct acpi_device_info
*info
;
249 if (!ACPI_SUCCESS(acpi_get_object_info(handle
, &info
)))
251 if (!(info
->valid
& ACPI_VALID_HID
))
254 ret
= !strcmp("PNP0C0A", info
->hardware_id
.string
);
260 /* Check whether ACPI object is an ejectable battery or disk bay */
261 static bool __init
is_ejectable_bay(acpi_handle handle
)
263 if (acpi_has_method(handle
, "_EJ0") && is_battery(handle
))
266 return acpi_bay_match(handle
);
270 * is_dock_device - see if a device is on a dock station
271 * @handle: acpi handle of the device
273 * If this device is either the dock station itself,
274 * or is a device dependent on the dock station, then it
277 int is_dock_device(acpi_handle handle
)
279 struct dock_station
*dock_station
;
281 if (!dock_station_count
)
284 if (acpi_dock_match(handle
))
287 list_for_each_entry(dock_station
, &dock_stations
, sibling
)
288 if (find_dock_dependent_device(dock_station
, handle
))
293 EXPORT_SYMBOL_GPL(is_dock_device
);
296 * dock_present - see if the dock station is present.
297 * @ds: the dock station
299 * execute the _STA method. note that present does not
300 * imply that we are docked.
302 static int dock_present(struct dock_station
*ds
)
304 unsigned long long sta
;
308 status
= acpi_evaluate_integer(ds
->handle
, "_STA", NULL
, &sta
);
309 if (ACPI_SUCCESS(status
) && sta
)
316 * dock_create_acpi_device - add new devices to acpi
317 * @handle - handle of the device to add
319 * This function will create a new acpi_device for the given
320 * handle if one does not exist already. This should cause
321 * acpi to scan for drivers for the given devices, and call
322 * matching driver's add routine.
324 static void dock_create_acpi_device(acpi_handle handle
)
326 struct acpi_device
*device
= NULL
;
329 acpi_bus_get_device(handle
, &device
);
330 if (!acpi_device_enumerated(device
)) {
331 ret
= acpi_bus_scan(handle
);
333 pr_debug("error adding bus, %x\n", -ret
);
338 * dock_remove_acpi_device - remove the acpi_device struct from acpi
339 * @handle - the handle of the device to remove
341 * Tell acpi to remove the acpi_device. This should cause any loaded
342 * driver to have it's remove routine called.
344 static void dock_remove_acpi_device(acpi_handle handle
)
346 struct acpi_device
*device
;
348 if (!acpi_bus_get_device(handle
, &device
))
349 acpi_bus_trim(device
);
353 * hot_remove_dock_devices - Remove dock station devices.
356 static void hot_remove_dock_devices(struct dock_station
*ds
)
358 struct dock_dependent_device
*dd
;
361 * Walk the list in reverse order so that devices that have been added
362 * last are removed first (in case there are some indirect dependencies
365 list_for_each_entry_reverse(dd
, &ds
->dependent_devices
, list
)
366 dock_hotplug_event(dd
, ACPI_NOTIFY_EJECT_REQUEST
, false);
368 list_for_each_entry_reverse(dd
, &ds
->dependent_devices
, list
)
369 dock_remove_acpi_device(dd
->handle
);
373 * hotplug_dock_devices - Insert devices on a dock station.
374 * @ds: the dock station
375 * @event: either bus check or device check request
377 * Some devices on the dock station need to have drivers called
378 * to perform hotplug operations after a dock event has occurred.
379 * Traverse the list of dock devices that have registered a
380 * hotplug handler, and call the handler.
382 static void hotplug_dock_devices(struct dock_station
*ds
, u32 event
)
384 struct dock_dependent_device
*dd
;
386 /* Call driver specific post-dock fixups. */
387 list_for_each_entry(dd
, &ds
->dependent_devices
, list
)
388 dock_hotplug_event(dd
, event
, DOCK_CALL_FIXUP
);
390 /* Call driver specific hotplug functions. */
391 list_for_each_entry(dd
, &ds
->dependent_devices
, list
)
392 dock_hotplug_event(dd
, event
, DOCK_CALL_HANDLER
);
395 * Now make sure that an acpi_device is created for each dependent
396 * device. That will cause scan handlers to be attached to device
397 * objects or acpi_drivers to be stopped/started if they are present.
399 list_for_each_entry(dd
, &ds
->dependent_devices
, list
)
400 dock_create_acpi_device(dd
->handle
);
403 static void dock_event(struct dock_station
*ds
, u32 event
, int num
)
405 struct device
*dev
= &ds
->dock_device
->dev
;
406 char event_string
[13];
407 char *envp
[] = { event_string
, NULL
};
408 struct dock_dependent_device
*dd
;
410 if (num
== UNDOCK_EVENT
)
411 sprintf(event_string
, "EVENT=undock");
413 sprintf(event_string
, "EVENT=dock");
416 * Indicate that the status of the dock station has
419 if (num
== DOCK_EVENT
)
420 kobject_uevent_env(&dev
->kobj
, KOBJ_CHANGE
, envp
);
422 list_for_each_entry(dd
, &ds
->dependent_devices
, list
)
423 dock_hotplug_event(dd
, event
, DOCK_CALL_UEVENT
);
425 if (num
!= DOCK_EVENT
)
426 kobject_uevent_env(&dev
->kobj
, KOBJ_CHANGE
, envp
);
430 * handle_dock - handle a dock event
431 * @ds: the dock station
432 * @dock: to dock, or undock - that is the question
434 * Execute the _DCK method in response to an acpi event
436 static void handle_dock(struct dock_station
*ds
, int dock
)
439 struct acpi_object_list arg_list
;
440 union acpi_object arg
;
441 unsigned long long value
;
443 acpi_handle_info(ds
->handle
, "%s\n", dock
? "docking" : "undocking");
445 /* _DCK method has one argument */
447 arg_list
.pointer
= &arg
;
448 arg
.type
= ACPI_TYPE_INTEGER
;
449 arg
.integer
.value
= dock
;
450 status
= acpi_evaluate_integer(ds
->handle
, "_DCK", &arg_list
, &value
);
451 if (ACPI_FAILURE(status
) && status
!= AE_NOT_FOUND
)
452 acpi_handle_err(ds
->handle
, "Failed to execute _DCK (0x%x)\n",
456 static inline void dock(struct dock_station
*ds
)
461 static inline void undock(struct dock_station
*ds
)
466 static inline void begin_dock(struct dock_station
*ds
)
468 ds
->flags
|= DOCK_DOCKING
;
471 static inline void complete_dock(struct dock_station
*ds
)
473 ds
->flags
&= ~(DOCK_DOCKING
);
474 ds
->last_dock_time
= jiffies
;
477 static inline void begin_undock(struct dock_station
*ds
)
479 ds
->flags
|= DOCK_UNDOCKING
;
482 static inline void complete_undock(struct dock_station
*ds
)
484 ds
->flags
&= ~(DOCK_UNDOCKING
);
488 * dock_in_progress - see if we are in the middle of handling a dock event
489 * @ds: the dock station
491 * Sometimes while docking, false dock events can be sent to the driver
492 * because good connections aren't made or some other reason. Ignore these
493 * if we are in the middle of doing something.
495 static int dock_in_progress(struct dock_station
*ds
)
497 if ((ds
->flags
& DOCK_DOCKING
) ||
498 time_before(jiffies
, (ds
->last_dock_time
+ HZ
)))
504 * register_hotplug_dock_device - register a hotplug function
505 * @handle: the handle of the device
506 * @ops: handlers to call after docking
507 * @context: device specific data
508 * @init: Optional initialization routine to run after registration
509 * @release: Optional release routine to run on unregistration
511 * If a driver would like to perform a hotplug operation after a dock
512 * event, they can register an acpi_notifiy_handler to be called by
513 * the dock driver after _DCK is executed.
515 int register_hotplug_dock_device(acpi_handle handle
,
516 const struct acpi_dock_ops
*ops
, void *context
,
517 void (*init
)(void *), void (*release
)(void *))
519 struct dock_dependent_device
*dd
;
520 struct dock_station
*dock_station
;
523 if (WARN_ON(!context
))
526 if (!dock_station_count
)
530 * make sure this handle is for a device dependent on the dock,
531 * this would include the dock station itself
533 list_for_each_entry(dock_station
, &dock_stations
, sibling
) {
535 * An ATA bay can be in a dock and itself can be ejected
536 * separately, so there are two 'dock stations' which need the
539 dd
= find_dock_dependent_device(dock_station
, handle
);
540 if (dd
&& !dock_init_hotplug(dd
, ops
, context
, init
, release
))
546 EXPORT_SYMBOL_GPL(register_hotplug_dock_device
);
549 * unregister_hotplug_dock_device - remove yourself from the hotplug list
550 * @handle: the acpi handle of the device
552 void unregister_hotplug_dock_device(acpi_handle handle
)
554 struct dock_dependent_device
*dd
;
555 struct dock_station
*dock_station
;
557 if (!dock_station_count
)
560 list_for_each_entry(dock_station
, &dock_stations
, sibling
) {
561 dd
= find_dock_dependent_device(dock_station
, handle
);
563 dock_release_hotplug(dd
);
566 EXPORT_SYMBOL_GPL(unregister_hotplug_dock_device
);
569 * handle_eject_request - handle an undock request checking for error conditions
571 * Check to make sure the dock device is still present, then undock and
572 * hotremove all the devices that may need removing.
574 static int handle_eject_request(struct dock_station
*ds
, u32 event
)
576 if (dock_in_progress(ds
))
580 * here we need to generate the undock
581 * event prior to actually doing the undock
582 * so that the device struct still exists.
583 * Also, even send the dock event if the
584 * device is not present anymore
586 dock_event(ds
, event
, UNDOCK_EVENT
);
588 hot_remove_dock_devices(ds
);
590 acpi_evaluate_lck(ds
->handle
, 0);
591 acpi_evaluate_ej0(ds
->handle
);
592 if (dock_present(ds
)) {
593 acpi_handle_err(ds
->handle
, "Unable to undock!\n");
601 * dock_notify - act upon an acpi dock notification
603 * @event: the acpi event
605 * If we are notified to dock, then check to see if the dock is
606 * present and then dock. Notify all drivers of the dock event,
607 * and then hotplug and devices that may need hotplugging.
609 static void dock_notify(struct dock_station
*ds
, u32 event
)
611 acpi_handle handle
= ds
->handle
;
612 struct acpi_device
*ad
;
613 int surprise_removal
= 0;
616 * According to acpi spec 3.0a, if a DEVICE_CHECK notification
617 * is sent and _DCK is present, it is assumed to mean an undock
620 if ((ds
->flags
& DOCK_IS_DOCK
) && event
== ACPI_NOTIFY_DEVICE_CHECK
)
621 event
= ACPI_NOTIFY_EJECT_REQUEST
;
624 * dock station: BUS_CHECK - docked or surprise removal
625 * DEVICE_CHECK - undocked
626 * other device: BUS_CHECK/DEVICE_CHECK - added or surprise removal
628 * To simplify event handling, dock dependent device handler always
629 * get ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and
630 * ACPI_NOTIFY_EJECT_REQUEST for removal
633 case ACPI_NOTIFY_BUS_CHECK
:
634 case ACPI_NOTIFY_DEVICE_CHECK
:
635 if (!dock_in_progress(ds
) && acpi_bus_get_device(handle
, &ad
)) {
638 if (!dock_present(ds
)) {
639 acpi_handle_err(handle
, "Unable to dock!\n");
643 hotplug_dock_devices(ds
, event
);
645 dock_event(ds
, event
, DOCK_EVENT
);
646 acpi_evaluate_lck(ds
->handle
, 1);
647 acpi_update_all_gpes();
650 if (dock_present(ds
) || dock_in_progress(ds
))
652 /* This is a surprise removal */
653 surprise_removal
= 1;
654 event
= ACPI_NOTIFY_EJECT_REQUEST
;
656 case ACPI_NOTIFY_EJECT_REQUEST
:
658 if ((immediate_undock
&& !(ds
->flags
& DOCK_IS_ATA
))
660 handle_eject_request(ds
, event
);
662 dock_event(ds
, event
, UNDOCK_EVENT
);
665 acpi_handle_err(handle
, "Unknown dock event %d\n", event
);
669 static void acpi_dock_deferred_cb(void *data
, u32 event
)
671 acpi_scan_lock_acquire();
672 dock_notify(data
, event
);
673 acpi_scan_lock_release();
676 static void dock_notify_handler(acpi_handle handle
, u32 event
, void *data
)
678 if (event
!= ACPI_NOTIFY_BUS_CHECK
&& event
!= ACPI_NOTIFY_DEVICE_CHECK
679 && event
!= ACPI_NOTIFY_EJECT_REQUEST
)
682 acpi_hotplug_execute(acpi_dock_deferred_cb
, data
, event
);
686 * find_dock_devices - find devices on the dock station
687 * @handle: the handle of the device we are examining
689 * @context: the dock station private data
692 * This function is called by acpi_walk_namespace. It will
693 * check to see if an object has an _EJD method. If it does, then it
694 * will see if it is dependent on the dock station.
696 static acpi_status __init
find_dock_devices(acpi_handle handle
, u32 lvl
,
697 void *context
, void **rv
)
699 struct dock_station
*ds
= context
;
700 acpi_handle ejd
= NULL
;
702 acpi_bus_get_ejd(handle
, &ejd
);
703 if (ejd
== ds
->handle
)
704 add_dock_dependent_device(ds
, handle
);
710 * show_docked - read method for "docked" file in sysfs
712 static ssize_t
show_docked(struct device
*dev
,
713 struct device_attribute
*attr
, char *buf
)
715 struct acpi_device
*tmp
;
717 struct dock_station
*dock_station
= dev
->platform_data
;
719 if (!acpi_bus_get_device(dock_station
->handle
, &tmp
))
720 return snprintf(buf
, PAGE_SIZE
, "1\n");
721 return snprintf(buf
, PAGE_SIZE
, "0\n");
723 static DEVICE_ATTR(docked
, S_IRUGO
, show_docked
, NULL
);
726 * show_flags - read method for flags file in sysfs
728 static ssize_t
show_flags(struct device
*dev
,
729 struct device_attribute
*attr
, char *buf
)
731 struct dock_station
*dock_station
= dev
->platform_data
;
732 return snprintf(buf
, PAGE_SIZE
, "%d\n", dock_station
->flags
);
735 static DEVICE_ATTR(flags
, S_IRUGO
, show_flags
, NULL
);
738 * write_undock - write method for "undock" file in sysfs
740 static ssize_t
write_undock(struct device
*dev
, struct device_attribute
*attr
,
741 const char *buf
, size_t count
)
744 struct dock_station
*dock_station
= dev
->platform_data
;
749 acpi_scan_lock_acquire();
750 begin_undock(dock_station
);
751 ret
= handle_eject_request(dock_station
, ACPI_NOTIFY_EJECT_REQUEST
);
752 acpi_scan_lock_release();
753 return ret
? ret
: count
;
755 static DEVICE_ATTR(undock
, S_IWUSR
, NULL
, write_undock
);
758 * show_dock_uid - read method for "uid" file in sysfs
760 static ssize_t
show_dock_uid(struct device
*dev
,
761 struct device_attribute
*attr
, char *buf
)
763 unsigned long long lbuf
;
764 struct dock_station
*dock_station
= dev
->platform_data
;
765 acpi_status status
= acpi_evaluate_integer(dock_station
->handle
,
766 "_UID", NULL
, &lbuf
);
767 if (ACPI_FAILURE(status
))
770 return snprintf(buf
, PAGE_SIZE
, "%llx\n", lbuf
);
772 static DEVICE_ATTR(uid
, S_IRUGO
, show_dock_uid
, NULL
);
774 static ssize_t
show_dock_type(struct device
*dev
,
775 struct device_attribute
*attr
, char *buf
)
777 struct dock_station
*dock_station
= dev
->platform_data
;
780 if (dock_station
->flags
& DOCK_IS_DOCK
)
781 type
= "dock_station";
782 else if (dock_station
->flags
& DOCK_IS_ATA
)
784 else if (dock_station
->flags
& DOCK_IS_BAT
)
785 type
= "battery_bay";
789 return snprintf(buf
, PAGE_SIZE
, "%s\n", type
);
791 static DEVICE_ATTR(type
, S_IRUGO
, show_dock_type
, NULL
);
793 static struct attribute
*dock_attributes
[] = {
794 &dev_attr_docked
.attr
,
795 &dev_attr_flags
.attr
,
796 &dev_attr_undock
.attr
,
802 static struct attribute_group dock_attribute_group
= {
803 .attrs
= dock_attributes
807 * dock_add - add a new dock station
808 * @handle: the dock station handle
810 * allocated and initialize a new dock station device. Find all devices
811 * that are on the dock station, and register for dock event notifications.
813 static int __init
dock_add(acpi_handle handle
)
815 struct dock_station
*dock_station
, ds
= { NULL
, };
816 struct platform_device
*dd
;
820 dd
= platform_device_register_data(NULL
, "dock", dock_station_count
,
825 dock_station
= dd
->dev
.platform_data
;
827 dock_station
->handle
= handle
;
828 dock_station
->dock_device
= dd
;
829 dock_station
->last_dock_time
= jiffies
- HZ
;
831 INIT_LIST_HEAD(&dock_station
->sibling
);
832 INIT_LIST_HEAD(&dock_station
->dependent_devices
);
834 /* we want the dock device to send uevents */
835 dev_set_uevent_suppress(&dd
->dev
, 0);
837 if (acpi_dock_match(handle
))
838 dock_station
->flags
|= DOCK_IS_DOCK
;
839 if (acpi_ata_match(handle
))
840 dock_station
->flags
|= DOCK_IS_ATA
;
841 if (is_battery(handle
))
842 dock_station
->flags
|= DOCK_IS_BAT
;
844 ret
= sysfs_create_group(&dd
->dev
.kobj
, &dock_attribute_group
);
848 /* Find dependent devices */
849 acpi_walk_namespace(ACPI_TYPE_DEVICE
, ACPI_ROOT_OBJECT
,
850 ACPI_UINT32_MAX
, find_dock_devices
, NULL
,
853 /* add the dock station as a device dependent on itself */
854 ret
= add_dock_dependent_device(dock_station
, handle
);
858 status
= acpi_install_notify_handler(handle
, ACPI_SYSTEM_NOTIFY
,
859 dock_notify_handler
, dock_station
);
860 if (ACPI_FAILURE(status
)) {
865 dock_station_count
++;
866 list_add(&dock_station
->sibling
, &dock_stations
);
870 remove_dock_dependent_devices(dock_station
);
871 sysfs_remove_group(&dd
->dev
.kobj
, &dock_attribute_group
);
873 platform_device_unregister(dd
);
874 acpi_handle_err(handle
, "%s encountered error %d\n", __func__
, ret
);
879 * find_dock_and_bay - look for dock stations and bays
880 * @handle: acpi handle of a device
885 * This is called by acpi_walk_namespace to look for dock stations and bays.
887 static acpi_status __init
888 find_dock_and_bay(acpi_handle handle
, u32 lvl
, void *context
, void **rv
)
890 if (acpi_dock_match(handle
) || is_ejectable_bay(handle
))
896 void __init
acpi_dock_init(void)
898 /* look for dock stations and bays */
899 acpi_walk_namespace(ACPI_TYPE_DEVICE
, ACPI_ROOT_OBJECT
,
900 ACPI_UINT32_MAX
, find_dock_and_bay
, NULL
, NULL
, NULL
);
902 if (!dock_station_count
) {
903 pr_info(PREFIX
"No dock devices found.\n");
907 pr_info(PREFIX
"%s: %d docks/bays found\n",
908 ACPI_DOCK_DRIVER_DESCRIPTION
, dock_station_count
);