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>
36 #define PREFIX "ACPI: "
38 #define ACPI_DOCK_DRIVER_DESCRIPTION "ACPI Dock Station Driver"
40 ACPI_MODULE_NAME("dock");
41 MODULE_AUTHOR("Kristen Carlson Accardi");
42 MODULE_DESCRIPTION(ACPI_DOCK_DRIVER_DESCRIPTION
);
43 MODULE_LICENSE("GPL");
45 static bool immediate_undock
= 1;
46 module_param(immediate_undock
, bool, 0644);
47 MODULE_PARM_DESC(immediate_undock
, "1 (default) will cause the driver to "
48 "undock immediately when the undock button is pressed, 0 will cause"
49 " the driver to wait for userspace to write the undock sysfs file "
52 static const struct acpi_device_id dock_device_ids
[] = {
56 MODULE_DEVICE_TABLE(acpi
, dock_device_ids
);
60 unsigned long last_dock_time
;
62 struct list_head dependent_devices
;
64 struct list_head sibling
;
65 struct platform_device
*dock_device
;
67 static LIST_HEAD(dock_stations
);
68 static int dock_station_count
;
69 static DEFINE_MUTEX(hotplug_lock
);
71 struct dock_dependent_device
{
72 struct list_head list
;
74 const struct acpi_dock_ops
*hp_ops
;
76 unsigned int hp_refcount
;
77 void (*hp_release
)(void *);
80 #define DOCK_DOCKING 0x00000001
81 #define DOCK_UNDOCKING 0x00000002
82 #define DOCK_IS_DOCK 0x00000010
83 #define DOCK_IS_ATA 0x00000020
84 #define DOCK_IS_BAT 0x00000040
86 #define UNDOCK_EVENT 2
88 enum dock_callback_type
{
94 /*****************************************************************************
95 * Dock Dependent device functions *
96 *****************************************************************************/
98 * add_dock_dependent_device - associate a device with the dock station
99 * @ds: The dock station
100 * @handle: handle of the dependent device
102 * Add the dependent device to the dock's dependent device list.
105 add_dock_dependent_device(struct dock_station
*ds
, acpi_handle handle
)
107 struct dock_dependent_device
*dd
;
109 dd
= kzalloc(sizeof(*dd
), GFP_KERNEL
);
114 INIT_LIST_HEAD(&dd
->list
);
115 list_add_tail(&dd
->list
, &ds
->dependent_devices
);
120 static void remove_dock_dependent_devices(struct dock_station
*ds
)
122 struct dock_dependent_device
*dd
, *aux
;
124 list_for_each_entry_safe(dd
, aux
, &ds
->dependent_devices
, list
) {
131 * dock_init_hotplug - Initialize a hotplug device on a docking station.
132 * @dd: Dock-dependent device.
133 * @ops: Dock operations to attach to the dependent device.
134 * @context: Data to pass to the @ops callbacks and @release.
135 * @init: Optional initialization routine to run after setting up context.
136 * @release: Optional release routine to run on removal.
138 static int dock_init_hotplug(struct dock_dependent_device
*dd
,
139 const struct acpi_dock_ops
*ops
, void *context
,
140 void (*init
)(void *), void (*release
)(void *))
144 mutex_lock(&hotplug_lock
);
145 if (WARN_ON(dd
->hp_context
)) {
150 dd
->hp_context
= context
;
151 dd
->hp_release
= release
;
155 mutex_unlock(&hotplug_lock
);
160 * dock_release_hotplug - Decrement hotplug reference counter of dock device.
161 * @dd: Dock-dependent device.
163 * Decrement the reference counter of @dd and if 0, detach its hotplug
164 * operations from it, reset its context pointer and run the optional release
165 * routine if present.
167 static void dock_release_hotplug(struct dock_dependent_device
*dd
)
169 mutex_lock(&hotplug_lock
);
170 if (dd
->hp_context
&& !--dd
->hp_refcount
) {
171 void (*release
)(void *) = dd
->hp_release
;
172 void *context
= dd
->hp_context
;
175 dd
->hp_context
= NULL
;
176 dd
->hp_release
= NULL
;
180 mutex_unlock(&hotplug_lock
);
183 static void dock_hotplug_event(struct dock_dependent_device
*dd
, u32 event
,
184 enum dock_callback_type cb_type
)
186 acpi_notify_handler cb
= NULL
;
189 mutex_lock(&hotplug_lock
);
191 if (dd
->hp_context
) {
196 case DOCK_CALL_FIXUP
:
197 cb
= dd
->hp_ops
->fixup
;
199 case DOCK_CALL_UEVENT
:
200 cb
= dd
->hp_ops
->uevent
;
203 cb
= dd
->hp_ops
->handler
;
208 mutex_unlock(&hotplug_lock
);
214 cb(dd
->handle
, event
, dd
->hp_context
);
216 dock_release_hotplug(dd
);
220 * find_dock_dependent_device - get a device dependent on this dock
221 * @ds: the dock station
222 * @handle: the acpi_handle of the device we want
224 * iterate over the dependent device list for this dock. If the
225 * dependent device matches the handle, return.
227 static struct dock_dependent_device
*
228 find_dock_dependent_device(struct dock_station
*ds
, acpi_handle handle
)
230 struct dock_dependent_device
*dd
;
232 list_for_each_entry(dd
, &ds
->dependent_devices
, list
)
233 if (handle
== dd
->handle
)
239 /*****************************************************************************
241 *****************************************************************************/
242 static int __init
is_battery(acpi_handle handle
)
244 struct acpi_device_info
*info
;
247 if (!ACPI_SUCCESS(acpi_get_object_info(handle
, &info
)))
249 if (!(info
->valid
& ACPI_VALID_HID
))
252 ret
= !strcmp("PNP0C0A", info
->hardware_id
.string
);
258 /* Check whether ACPI object is an ejectable battery or disk bay */
259 static bool __init
is_ejectable_bay(acpi_handle handle
)
261 if (acpi_has_method(handle
, "_EJ0") && is_battery(handle
))
264 return acpi_bay_match(handle
);
268 * is_dock_device - see if a device is on a dock station
269 * @handle: acpi handle of the device
271 * If this device is either the dock station itself,
272 * or is a device dependent on the dock station, then it
275 int is_dock_device(acpi_handle handle
)
277 struct dock_station
*dock_station
;
279 if (!dock_station_count
)
282 if (acpi_dock_match(handle
))
285 list_for_each_entry(dock_station
, &dock_stations
, sibling
)
286 if (find_dock_dependent_device(dock_station
, handle
))
291 EXPORT_SYMBOL_GPL(is_dock_device
);
294 * dock_present - see if the dock station is present.
295 * @ds: the dock station
297 * execute the _STA method. note that present does not
298 * imply that we are docked.
300 static int dock_present(struct dock_station
*ds
)
302 unsigned long long sta
;
306 status
= acpi_evaluate_integer(ds
->handle
, "_STA", NULL
, &sta
);
307 if (ACPI_SUCCESS(status
) && sta
)
314 * dock_create_acpi_device - add new devices to acpi
315 * @handle - handle of the device to add
317 * This function will create a new acpi_device for the given
318 * handle if one does not exist already. This should cause
319 * acpi to scan for drivers for the given devices, and call
320 * matching driver's add routine.
322 static void dock_create_acpi_device(acpi_handle handle
)
324 struct acpi_device
*device
= NULL
;
327 acpi_bus_get_device(handle
, &device
);
328 if (!acpi_device_enumerated(device
)) {
329 ret
= acpi_bus_scan(handle
);
331 pr_debug("error adding bus, %x\n", -ret
);
336 * dock_remove_acpi_device - remove the acpi_device struct from acpi
337 * @handle - the handle of the device to remove
339 * Tell acpi to remove the acpi_device. This should cause any loaded
340 * driver to have it's remove routine called.
342 static void dock_remove_acpi_device(acpi_handle handle
)
344 struct acpi_device
*device
;
346 if (!acpi_bus_get_device(handle
, &device
))
347 acpi_bus_trim(device
);
351 * hot_remove_dock_devices - Remove dock station devices.
354 static void hot_remove_dock_devices(struct dock_station
*ds
)
356 struct dock_dependent_device
*dd
;
359 * Walk the list in reverse order so that devices that have been added
360 * last are removed first (in case there are some indirect dependencies
363 list_for_each_entry_reverse(dd
, &ds
->dependent_devices
, list
)
364 dock_hotplug_event(dd
, ACPI_NOTIFY_EJECT_REQUEST
, false);
366 list_for_each_entry_reverse(dd
, &ds
->dependent_devices
, list
)
367 dock_remove_acpi_device(dd
->handle
);
371 * hotplug_dock_devices - Insert devices on a dock station.
372 * @ds: the dock station
373 * @event: either bus check or device check request
375 * Some devices on the dock station need to have drivers called
376 * to perform hotplug operations after a dock event has occurred.
377 * Traverse the list of dock devices that have registered a
378 * hotplug handler, and call the handler.
380 static void hotplug_dock_devices(struct dock_station
*ds
, u32 event
)
382 struct dock_dependent_device
*dd
;
384 /* Call driver specific post-dock fixups. */
385 list_for_each_entry(dd
, &ds
->dependent_devices
, list
)
386 dock_hotplug_event(dd
, event
, DOCK_CALL_FIXUP
);
388 /* Call driver specific hotplug functions. */
389 list_for_each_entry(dd
, &ds
->dependent_devices
, list
)
390 dock_hotplug_event(dd
, event
, DOCK_CALL_HANDLER
);
393 * Now make sure that an acpi_device is created for each dependent
394 * device. That will cause scan handlers to be attached to device
395 * objects or acpi_drivers to be stopped/started if they are present.
397 list_for_each_entry(dd
, &ds
->dependent_devices
, list
)
398 dock_create_acpi_device(dd
->handle
);
401 static void dock_event(struct dock_station
*ds
, u32 event
, int num
)
403 struct device
*dev
= &ds
->dock_device
->dev
;
404 char event_string
[13];
405 char *envp
[] = { event_string
, NULL
};
406 struct dock_dependent_device
*dd
;
408 if (num
== UNDOCK_EVENT
)
409 sprintf(event_string
, "EVENT=undock");
411 sprintf(event_string
, "EVENT=dock");
414 * Indicate that the status of the dock station has
417 if (num
== DOCK_EVENT
)
418 kobject_uevent_env(&dev
->kobj
, KOBJ_CHANGE
, envp
);
420 list_for_each_entry(dd
, &ds
->dependent_devices
, list
)
421 dock_hotplug_event(dd
, event
, DOCK_CALL_UEVENT
);
423 if (num
!= DOCK_EVENT
)
424 kobject_uevent_env(&dev
->kobj
, KOBJ_CHANGE
, envp
);
428 * handle_dock - handle a dock event
429 * @ds: the dock station
430 * @dock: to dock, or undock - that is the question
432 * Execute the _DCK method in response to an acpi event
434 static void handle_dock(struct dock_station
*ds
, int dock
)
437 struct acpi_object_list arg_list
;
438 union acpi_object arg
;
439 unsigned long long value
;
441 acpi_handle_info(ds
->handle
, "%s\n", dock
? "docking" : "undocking");
443 /* _DCK method has one argument */
445 arg_list
.pointer
= &arg
;
446 arg
.type
= ACPI_TYPE_INTEGER
;
447 arg
.integer
.value
= dock
;
448 status
= acpi_evaluate_integer(ds
->handle
, "_DCK", &arg_list
, &value
);
449 if (ACPI_FAILURE(status
) && status
!= AE_NOT_FOUND
)
450 acpi_handle_err(ds
->handle
, "Failed to execute _DCK (0x%x)\n",
454 static inline void dock(struct dock_station
*ds
)
459 static inline void undock(struct dock_station
*ds
)
464 static inline void begin_dock(struct dock_station
*ds
)
466 ds
->flags
|= DOCK_DOCKING
;
469 static inline void complete_dock(struct dock_station
*ds
)
471 ds
->flags
&= ~(DOCK_DOCKING
);
472 ds
->last_dock_time
= jiffies
;
475 static inline void begin_undock(struct dock_station
*ds
)
477 ds
->flags
|= DOCK_UNDOCKING
;
480 static inline void complete_undock(struct dock_station
*ds
)
482 ds
->flags
&= ~(DOCK_UNDOCKING
);
486 * dock_in_progress - see if we are in the middle of handling a dock event
487 * @ds: the dock station
489 * Sometimes while docking, false dock events can be sent to the driver
490 * because good connections aren't made or some other reason. Ignore these
491 * if we are in the middle of doing something.
493 static int dock_in_progress(struct dock_station
*ds
)
495 if ((ds
->flags
& DOCK_DOCKING
) ||
496 time_before(jiffies
, (ds
->last_dock_time
+ HZ
)))
502 * register_hotplug_dock_device - register a hotplug function
503 * @handle: the handle of the device
504 * @ops: handlers to call after docking
505 * @context: device specific data
506 * @init: Optional initialization routine to run after registration
507 * @release: Optional release routine to run on unregistration
509 * If a driver would like to perform a hotplug operation after a dock
510 * event, they can register an acpi_notifiy_handler to be called by
511 * the dock driver after _DCK is executed.
513 int register_hotplug_dock_device(acpi_handle handle
,
514 const struct acpi_dock_ops
*ops
, void *context
,
515 void (*init
)(void *), void (*release
)(void *))
517 struct dock_dependent_device
*dd
;
518 struct dock_station
*dock_station
;
521 if (WARN_ON(!context
))
524 if (!dock_station_count
)
528 * make sure this handle is for a device dependent on the dock,
529 * this would include the dock station itself
531 list_for_each_entry(dock_station
, &dock_stations
, sibling
) {
533 * An ATA bay can be in a dock and itself can be ejected
534 * separately, so there are two 'dock stations' which need the
537 dd
= find_dock_dependent_device(dock_station
, handle
);
538 if (dd
&& !dock_init_hotplug(dd
, ops
, context
, init
, release
))
544 EXPORT_SYMBOL_GPL(register_hotplug_dock_device
);
547 * unregister_hotplug_dock_device - remove yourself from the hotplug list
548 * @handle: the acpi handle of the device
550 void unregister_hotplug_dock_device(acpi_handle handle
)
552 struct dock_dependent_device
*dd
;
553 struct dock_station
*dock_station
;
555 if (!dock_station_count
)
558 list_for_each_entry(dock_station
, &dock_stations
, sibling
) {
559 dd
= find_dock_dependent_device(dock_station
, handle
);
561 dock_release_hotplug(dd
);
564 EXPORT_SYMBOL_GPL(unregister_hotplug_dock_device
);
567 * handle_eject_request - handle an undock request checking for error conditions
569 * Check to make sure the dock device is still present, then undock and
570 * hotremove all the devices that may need removing.
572 static int handle_eject_request(struct dock_station
*ds
, u32 event
)
574 if (dock_in_progress(ds
))
578 * here we need to generate the undock
579 * event prior to actually doing the undock
580 * so that the device struct still exists.
581 * Also, even send the dock event if the
582 * device is not present anymore
584 dock_event(ds
, event
, UNDOCK_EVENT
);
586 hot_remove_dock_devices(ds
);
588 acpi_evaluate_lck(ds
->handle
, 0);
589 acpi_evaluate_ej0(ds
->handle
);
590 if (dock_present(ds
)) {
591 acpi_handle_err(ds
->handle
, "Unable to undock!\n");
599 * dock_notify - act upon an acpi dock notification
601 * @event: the acpi event
603 * If we are notified to dock, then check to see if the dock is
604 * present and then dock. Notify all drivers of the dock event,
605 * and then hotplug and devices that may need hotplugging.
607 static void dock_notify(struct dock_station
*ds
, u32 event
)
609 acpi_handle handle
= ds
->handle
;
610 struct acpi_device
*ad
;
611 int surprise_removal
= 0;
614 * According to acpi spec 3.0a, if a DEVICE_CHECK notification
615 * is sent and _DCK is present, it is assumed to mean an undock
618 if ((ds
->flags
& DOCK_IS_DOCK
) && event
== ACPI_NOTIFY_DEVICE_CHECK
)
619 event
= ACPI_NOTIFY_EJECT_REQUEST
;
622 * dock station: BUS_CHECK - docked or surprise removal
623 * DEVICE_CHECK - undocked
624 * other device: BUS_CHECK/DEVICE_CHECK - added or surprise removal
626 * To simplify event handling, dock dependent device handler always
627 * get ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and
628 * ACPI_NOTIFY_EJECT_REQUEST for removal
631 case ACPI_NOTIFY_BUS_CHECK
:
632 case ACPI_NOTIFY_DEVICE_CHECK
:
633 if (!dock_in_progress(ds
) && acpi_bus_get_device(handle
, &ad
)) {
636 if (!dock_present(ds
)) {
637 acpi_handle_err(handle
, "Unable to dock!\n");
641 hotplug_dock_devices(ds
, event
);
643 dock_event(ds
, event
, DOCK_EVENT
);
644 acpi_evaluate_lck(ds
->handle
, 1);
645 acpi_update_all_gpes();
648 if (dock_present(ds
) || dock_in_progress(ds
))
650 /* This is a surprise removal */
651 surprise_removal
= 1;
652 event
= ACPI_NOTIFY_EJECT_REQUEST
;
654 case ACPI_NOTIFY_EJECT_REQUEST
:
656 if ((immediate_undock
&& !(ds
->flags
& DOCK_IS_ATA
))
658 handle_eject_request(ds
, event
);
660 dock_event(ds
, event
, UNDOCK_EVENT
);
663 acpi_handle_err(handle
, "Unknown dock event %d\n", event
);
667 static void acpi_dock_deferred_cb(void *data
, u32 event
)
669 acpi_scan_lock_acquire();
670 dock_notify(data
, event
);
671 acpi_scan_lock_release();
674 static void dock_notify_handler(acpi_handle handle
, u32 event
, void *data
)
676 if (event
!= ACPI_NOTIFY_BUS_CHECK
&& event
!= ACPI_NOTIFY_DEVICE_CHECK
677 && event
!= ACPI_NOTIFY_EJECT_REQUEST
)
680 acpi_hotplug_execute(acpi_dock_deferred_cb
, data
, event
);
684 * find_dock_devices - find devices on the dock station
685 * @handle: the handle of the device we are examining
687 * @context: the dock station private data
690 * This function is called by acpi_walk_namespace. It will
691 * check to see if an object has an _EJD method. If it does, then it
692 * will see if it is dependent on the dock station.
694 static acpi_status __init
find_dock_devices(acpi_handle handle
, u32 lvl
,
695 void *context
, void **rv
)
697 struct dock_station
*ds
= context
;
698 acpi_handle ejd
= NULL
;
700 acpi_bus_get_ejd(handle
, &ejd
);
701 if (ejd
== ds
->handle
)
702 add_dock_dependent_device(ds
, handle
);
708 * show_docked - read method for "docked" file in sysfs
710 static ssize_t
show_docked(struct device
*dev
,
711 struct device_attribute
*attr
, char *buf
)
713 struct acpi_device
*tmp
;
715 struct dock_station
*dock_station
= dev
->platform_data
;
717 if (!acpi_bus_get_device(dock_station
->handle
, &tmp
))
718 return snprintf(buf
, PAGE_SIZE
, "1\n");
719 return snprintf(buf
, PAGE_SIZE
, "0\n");
721 static DEVICE_ATTR(docked
, S_IRUGO
, show_docked
, NULL
);
724 * show_flags - read method for flags file in sysfs
726 static ssize_t
show_flags(struct device
*dev
,
727 struct device_attribute
*attr
, char *buf
)
729 struct dock_station
*dock_station
= dev
->platform_data
;
730 return snprintf(buf
, PAGE_SIZE
, "%d\n", dock_station
->flags
);
733 static DEVICE_ATTR(flags
, S_IRUGO
, show_flags
, NULL
);
736 * write_undock - write method for "undock" file in sysfs
738 static ssize_t
write_undock(struct device
*dev
, struct device_attribute
*attr
,
739 const char *buf
, size_t count
)
742 struct dock_station
*dock_station
= dev
->platform_data
;
747 acpi_scan_lock_acquire();
748 begin_undock(dock_station
);
749 ret
= handle_eject_request(dock_station
, ACPI_NOTIFY_EJECT_REQUEST
);
750 acpi_scan_lock_release();
751 return ret
? ret
: count
;
753 static DEVICE_ATTR(undock
, S_IWUSR
, NULL
, write_undock
);
756 * show_dock_uid - read method for "uid" file in sysfs
758 static ssize_t
show_dock_uid(struct device
*dev
,
759 struct device_attribute
*attr
, char *buf
)
761 unsigned long long lbuf
;
762 struct dock_station
*dock_station
= dev
->platform_data
;
763 acpi_status status
= acpi_evaluate_integer(dock_station
->handle
,
764 "_UID", NULL
, &lbuf
);
765 if (ACPI_FAILURE(status
))
768 return snprintf(buf
, PAGE_SIZE
, "%llx\n", lbuf
);
770 static DEVICE_ATTR(uid
, S_IRUGO
, show_dock_uid
, NULL
);
772 static ssize_t
show_dock_type(struct device
*dev
,
773 struct device_attribute
*attr
, char *buf
)
775 struct dock_station
*dock_station
= dev
->platform_data
;
778 if (dock_station
->flags
& DOCK_IS_DOCK
)
779 type
= "dock_station";
780 else if (dock_station
->flags
& DOCK_IS_ATA
)
782 else if (dock_station
->flags
& DOCK_IS_BAT
)
783 type
= "battery_bay";
787 return snprintf(buf
, PAGE_SIZE
, "%s\n", type
);
789 static DEVICE_ATTR(type
, S_IRUGO
, show_dock_type
, NULL
);
791 static struct attribute
*dock_attributes
[] = {
792 &dev_attr_docked
.attr
,
793 &dev_attr_flags
.attr
,
794 &dev_attr_undock
.attr
,
800 static struct attribute_group dock_attribute_group
= {
801 .attrs
= dock_attributes
805 * dock_add - add a new dock station
806 * @handle: the dock station handle
808 * allocated and initialize a new dock station device. Find all devices
809 * that are on the dock station, and register for dock event notifications.
811 static int __init
dock_add(acpi_handle handle
)
813 struct dock_station
*dock_station
, ds
= { NULL
, };
814 struct platform_device
*dd
;
818 dd
= platform_device_register_data(NULL
, "dock", dock_station_count
,
823 dock_station
= dd
->dev
.platform_data
;
825 dock_station
->handle
= handle
;
826 dock_station
->dock_device
= dd
;
827 dock_station
->last_dock_time
= jiffies
- HZ
;
829 INIT_LIST_HEAD(&dock_station
->sibling
);
830 INIT_LIST_HEAD(&dock_station
->dependent_devices
);
832 /* we want the dock device to send uevents */
833 dev_set_uevent_suppress(&dd
->dev
, 0);
835 if (acpi_dock_match(handle
))
836 dock_station
->flags
|= DOCK_IS_DOCK
;
837 if (acpi_ata_match(handle
))
838 dock_station
->flags
|= DOCK_IS_ATA
;
839 if (is_battery(handle
))
840 dock_station
->flags
|= DOCK_IS_BAT
;
842 ret
= sysfs_create_group(&dd
->dev
.kobj
, &dock_attribute_group
);
846 /* Find dependent devices */
847 acpi_walk_namespace(ACPI_TYPE_DEVICE
, ACPI_ROOT_OBJECT
,
848 ACPI_UINT32_MAX
, find_dock_devices
, NULL
,
851 /* add the dock station as a device dependent on itself */
852 ret
= add_dock_dependent_device(dock_station
, handle
);
856 status
= acpi_install_notify_handler(handle
, ACPI_SYSTEM_NOTIFY
,
857 dock_notify_handler
, dock_station
);
858 if (ACPI_FAILURE(status
)) {
863 dock_station_count
++;
864 list_add(&dock_station
->sibling
, &dock_stations
);
868 remove_dock_dependent_devices(dock_station
);
869 sysfs_remove_group(&dd
->dev
.kobj
, &dock_attribute_group
);
871 platform_device_unregister(dd
);
872 acpi_handle_err(handle
, "%s encountered error %d\n", __func__
, ret
);
877 * find_dock_and_bay - look for dock stations and bays
878 * @handle: acpi handle of a device
883 * This is called by acpi_walk_namespace to look for dock stations and bays.
885 static acpi_status __init
886 find_dock_and_bay(acpi_handle handle
, u32 lvl
, void *context
, void **rv
)
888 if (acpi_dock_match(handle
) || is_ejectable_bay(handle
))
894 void __init
acpi_dock_init(void)
899 /* look for dock stations and bays */
900 acpi_walk_namespace(ACPI_TYPE_DEVICE
, ACPI_ROOT_OBJECT
,
901 ACPI_UINT32_MAX
, find_dock_and_bay
, NULL
, NULL
, NULL
);
903 if (!dock_station_count
) {
904 pr_info(PREFIX
"No dock devices found.\n");
908 pr_info(PREFIX
"%s: %d docks/bays found\n",
909 ACPI_DOCK_DRIVER_DESCRIPTION
, dock_station_count
);