1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * dock.c - ACPI dock station driver
5 * Copyright (C) 2006, 2014, Intel Corp.
6 * Author: Kristen Carlson Accardi <kristen.c.accardi@intel.com>
7 * Rafael J. Wysocki <rafael.j.wysocki@intel.com>
10 #include <linux/kernel.h>
11 #include <linux/moduleparam.h>
12 #include <linux/slab.h>
13 #include <linux/init.h>
14 #include <linux/types.h>
15 #include <linux/notifier.h>
16 #include <linux/platform_device.h>
17 #include <linux/jiffies.h>
18 #include <linux/stddef.h>
19 #include <linux/acpi.h>
23 static bool immediate_undock
= 1;
24 module_param(immediate_undock
, bool, 0644);
25 MODULE_PARM_DESC(immediate_undock
, "1 (default) will cause the driver to "
26 "undock immediately when the undock button is pressed, 0 will cause"
27 " the driver to wait for userspace to write the undock sysfs file "
32 unsigned long last_dock_time
;
34 struct list_head dependent_devices
;
36 struct list_head sibling
;
37 struct platform_device
*dock_device
;
39 static LIST_HEAD(dock_stations
);
40 static int dock_station_count
;
42 struct dock_dependent_device
{
43 struct list_head list
;
44 struct acpi_device
*adev
;
47 #define DOCK_DOCKING 0x00000001
48 #define DOCK_UNDOCKING 0x00000002
49 #define DOCK_IS_DOCK 0x00000010
50 #define DOCK_IS_ATA 0x00000020
51 #define DOCK_IS_BAT 0x00000040
53 #define UNDOCK_EVENT 2
55 enum dock_callback_type
{
61 /*****************************************************************************
62 * Dock Dependent device functions *
63 *****************************************************************************/
65 * add_dock_dependent_device - associate a device with the dock station
67 * @adev: Dependent ACPI device object.
69 * Add the dependent device to the dock's dependent device list.
71 static int add_dock_dependent_device(struct dock_station
*ds
,
72 struct acpi_device
*adev
)
74 struct dock_dependent_device
*dd
;
76 dd
= kzalloc(sizeof(*dd
), GFP_KERNEL
);
81 INIT_LIST_HEAD(&dd
->list
);
82 list_add_tail(&dd
->list
, &ds
->dependent_devices
);
87 static void dock_hotplug_event(struct dock_dependent_device
*dd
, u32 event
,
88 enum dock_callback_type cb_type
)
90 struct acpi_device
*adev
= dd
->adev
;
92 acpi_lock_hp_context();
97 if (cb_type
== DOCK_CALL_FIXUP
) {
98 void (*fixup
)(struct acpi_device
*);
100 fixup
= adev
->hp
->fixup
;
102 acpi_unlock_hp_context();
106 } else if (cb_type
== DOCK_CALL_UEVENT
) {
107 void (*uevent
)(struct acpi_device
*, u32
);
109 uevent
= adev
->hp
->uevent
;
111 acpi_unlock_hp_context();
116 int (*notify
)(struct acpi_device
*, u32
);
118 notify
= adev
->hp
->notify
;
120 acpi_unlock_hp_context();
127 acpi_unlock_hp_context();
130 static struct dock_station
*find_dock_station(acpi_handle handle
)
132 struct dock_station
*ds
;
134 list_for_each_entry(ds
, &dock_stations
, sibling
)
135 if (ds
->handle
== handle
)
142 * find_dock_dependent_device - get a device dependent on this dock
143 * @ds: the dock station
144 * @adev: ACPI device object to find.
146 * iterate over the dependent device list for this dock. If the
147 * dependent device matches the handle, return.
149 static struct dock_dependent_device
*
150 find_dock_dependent_device(struct dock_station
*ds
, struct acpi_device
*adev
)
152 struct dock_dependent_device
*dd
;
154 list_for_each_entry(dd
, &ds
->dependent_devices
, list
)
155 if (adev
== dd
->adev
)
161 void register_dock_dependent_device(struct acpi_device
*adev
,
162 acpi_handle dshandle
)
164 struct dock_station
*ds
= find_dock_station(dshandle
);
166 if (ds
&& !find_dock_dependent_device(ds
, adev
))
167 add_dock_dependent_device(ds
, adev
);
170 /*****************************************************************************
172 *****************************************************************************/
175 * is_dock_device - see if a device is on a dock station
176 * @adev: ACPI device object to check.
178 * If this device is either the dock station itself,
179 * or is a device dependent on the dock station, then it
182 int is_dock_device(struct acpi_device
*adev
)
184 struct dock_station
*dock_station
;
186 if (!dock_station_count
)
189 if (acpi_dock_match(adev
->handle
))
192 list_for_each_entry(dock_station
, &dock_stations
, sibling
)
193 if (find_dock_dependent_device(dock_station
, adev
))
198 EXPORT_SYMBOL_GPL(is_dock_device
);
201 * dock_present - see if the dock station is present.
202 * @ds: the dock station
204 * execute the _STA method. note that present does not
205 * imply that we are docked.
207 static int dock_present(struct dock_station
*ds
)
209 unsigned long long sta
;
213 status
= acpi_evaluate_integer(ds
->handle
, "_STA", NULL
, &sta
);
214 if (ACPI_SUCCESS(status
) && sta
)
221 * hot_remove_dock_devices - Remove dock station devices.
224 static void hot_remove_dock_devices(struct dock_station
*ds
)
226 struct dock_dependent_device
*dd
;
229 * Walk the list in reverse order so that devices that have been added
230 * last are removed first (in case there are some indirect dependencies
233 list_for_each_entry_reverse(dd
, &ds
->dependent_devices
, list
)
234 dock_hotplug_event(dd
, ACPI_NOTIFY_EJECT_REQUEST
,
237 list_for_each_entry_reverse(dd
, &ds
->dependent_devices
, list
)
238 acpi_bus_trim(dd
->adev
);
242 * hotplug_dock_devices - Insert devices on a dock station.
243 * @ds: the dock station
244 * @event: either bus check or device check request
246 * Some devices on the dock station need to have drivers called
247 * to perform hotplug operations after a dock event has occurred.
248 * Traverse the list of dock devices that have registered a
249 * hotplug handler, and call the handler.
251 static void hotplug_dock_devices(struct dock_station
*ds
, u32 event
)
253 struct dock_dependent_device
*dd
;
255 /* Call driver specific post-dock fixups. */
256 list_for_each_entry(dd
, &ds
->dependent_devices
, list
)
257 dock_hotplug_event(dd
, event
, DOCK_CALL_FIXUP
);
259 /* Call driver specific hotplug functions. */
260 list_for_each_entry(dd
, &ds
->dependent_devices
, list
)
261 dock_hotplug_event(dd
, event
, DOCK_CALL_HANDLER
);
264 * Check if all devices have been enumerated already. If not, run
265 * acpi_bus_scan() for them and that will cause scan handlers to be
266 * attached to device objects or acpi_drivers to be stopped/started if
269 list_for_each_entry(dd
, &ds
->dependent_devices
, list
) {
270 struct acpi_device
*adev
= dd
->adev
;
272 if (!acpi_device_enumerated(adev
)) {
273 int ret
= acpi_bus_scan(adev
->handle
);
276 dev_dbg(&adev
->dev
, "scan error %d\n", -ret
);
281 static void dock_event(struct dock_station
*ds
, u32 event
, int num
)
283 struct device
*dev
= &ds
->dock_device
->dev
;
284 char event_string
[13];
285 char *envp
[] = { event_string
, NULL
};
286 struct dock_dependent_device
*dd
;
288 if (num
== UNDOCK_EVENT
)
289 sprintf(event_string
, "EVENT=undock");
291 sprintf(event_string
, "EVENT=dock");
294 * Indicate that the status of the dock station has
297 if (num
== DOCK_EVENT
)
298 kobject_uevent_env(&dev
->kobj
, KOBJ_CHANGE
, envp
);
300 list_for_each_entry(dd
, &ds
->dependent_devices
, list
)
301 dock_hotplug_event(dd
, event
, DOCK_CALL_UEVENT
);
303 if (num
!= DOCK_EVENT
)
304 kobject_uevent_env(&dev
->kobj
, KOBJ_CHANGE
, envp
);
308 * handle_dock - handle a dock event
309 * @ds: the dock station
310 * @dock: to dock, or undock - that is the question
312 * Execute the _DCK method in response to an acpi event
314 static void handle_dock(struct dock_station
*ds
, int dock
)
317 struct acpi_object_list arg_list
;
318 union acpi_object arg
;
319 unsigned long long value
;
321 acpi_handle_info(ds
->handle
, "%s\n", dock
? "docking" : "undocking");
323 /* _DCK method has one argument */
325 arg_list
.pointer
= &arg
;
326 arg
.type
= ACPI_TYPE_INTEGER
;
327 arg
.integer
.value
= dock
;
328 status
= acpi_evaluate_integer(ds
->handle
, "_DCK", &arg_list
, &value
);
329 if (ACPI_FAILURE(status
) && status
!= AE_NOT_FOUND
)
330 acpi_handle_err(ds
->handle
, "Failed to execute _DCK (0x%x)\n",
334 static inline void dock(struct dock_station
*ds
)
339 static inline void undock(struct dock_station
*ds
)
344 static inline void begin_dock(struct dock_station
*ds
)
346 ds
->flags
|= DOCK_DOCKING
;
349 static inline void complete_dock(struct dock_station
*ds
)
351 ds
->flags
&= ~(DOCK_DOCKING
);
352 ds
->last_dock_time
= jiffies
;
355 static inline void begin_undock(struct dock_station
*ds
)
357 ds
->flags
|= DOCK_UNDOCKING
;
360 static inline void complete_undock(struct dock_station
*ds
)
362 ds
->flags
&= ~(DOCK_UNDOCKING
);
366 * dock_in_progress - see if we are in the middle of handling a dock event
367 * @ds: the dock station
369 * Sometimes while docking, false dock events can be sent to the driver
370 * because good connections aren't made or some other reason. Ignore these
371 * if we are in the middle of doing something.
373 static int dock_in_progress(struct dock_station
*ds
)
375 if ((ds
->flags
& DOCK_DOCKING
) ||
376 time_before(jiffies
, (ds
->last_dock_time
+ HZ
)))
382 * handle_eject_request - handle an undock request checking for error conditions
384 * Check to make sure the dock device is still present, then undock and
385 * hotremove all the devices that may need removing.
387 static int handle_eject_request(struct dock_station
*ds
, u32 event
)
389 if (dock_in_progress(ds
))
393 * here we need to generate the undock
394 * event prior to actually doing the undock
395 * so that the device struct still exists.
396 * Also, even send the dock event if the
397 * device is not present anymore
399 dock_event(ds
, event
, UNDOCK_EVENT
);
401 hot_remove_dock_devices(ds
);
403 acpi_evaluate_lck(ds
->handle
, 0);
404 acpi_evaluate_ej0(ds
->handle
);
405 if (dock_present(ds
)) {
406 acpi_handle_err(ds
->handle
, "Unable to undock!\n");
414 * dock_notify - Handle ACPI dock notification.
415 * @adev: Dock station's ACPI device object.
416 * @event: Event code.
418 * If we are notified to dock, then check to see if the dock is
419 * present and then dock. Notify all drivers of the dock event,
420 * and then hotplug and devices that may need hotplugging.
422 int dock_notify(struct acpi_device
*adev
, u32 event
)
424 acpi_handle handle
= adev
->handle
;
425 struct dock_station
*ds
= find_dock_station(handle
);
426 int surprise_removal
= 0;
432 * According to acpi spec 3.0a, if a DEVICE_CHECK notification
433 * is sent and _DCK is present, it is assumed to mean an undock
436 if ((ds
->flags
& DOCK_IS_DOCK
) && event
== ACPI_NOTIFY_DEVICE_CHECK
)
437 event
= ACPI_NOTIFY_EJECT_REQUEST
;
440 * dock station: BUS_CHECK - docked or surprise removal
441 * DEVICE_CHECK - undocked
442 * other device: BUS_CHECK/DEVICE_CHECK - added or surprise removal
444 * To simplify event handling, dock dependent device handler always
445 * get ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and
446 * ACPI_NOTIFY_EJECT_REQUEST for removal
449 case ACPI_NOTIFY_BUS_CHECK
:
450 case ACPI_NOTIFY_DEVICE_CHECK
:
451 if (!dock_in_progress(ds
) && !acpi_device_enumerated(adev
)) {
454 if (!dock_present(ds
)) {
455 acpi_handle_err(handle
, "Unable to dock!\n");
459 hotplug_dock_devices(ds
, event
);
461 dock_event(ds
, event
, DOCK_EVENT
);
462 acpi_evaluate_lck(ds
->handle
, 1);
463 acpi_update_all_gpes();
466 if (dock_present(ds
) || dock_in_progress(ds
))
468 /* This is a surprise removal */
469 surprise_removal
= 1;
470 event
= ACPI_NOTIFY_EJECT_REQUEST
;
473 case ACPI_NOTIFY_EJECT_REQUEST
:
475 if ((immediate_undock
&& !(ds
->flags
& DOCK_IS_ATA
))
477 handle_eject_request(ds
, event
);
479 dock_event(ds
, event
, UNDOCK_EVENT
);
486 * show_docked - read method for "docked" file in sysfs
488 static ssize_t
docked_show(struct device
*dev
,
489 struct device_attribute
*attr
, char *buf
)
491 struct dock_station
*dock_station
= dev
->platform_data
;
492 struct acpi_device
*adev
= NULL
;
494 acpi_bus_get_device(dock_station
->handle
, &adev
);
495 return snprintf(buf
, PAGE_SIZE
, "%u\n", acpi_device_enumerated(adev
));
497 static DEVICE_ATTR_RO(docked
);
500 * show_flags - read method for flags file in sysfs
502 static ssize_t
flags_show(struct device
*dev
,
503 struct device_attribute
*attr
, char *buf
)
505 struct dock_station
*dock_station
= dev
->platform_data
;
507 return snprintf(buf
, PAGE_SIZE
, "%d\n", dock_station
->flags
);
510 static DEVICE_ATTR_RO(flags
);
513 * write_undock - write method for "undock" file in sysfs
515 static ssize_t
undock_store(struct device
*dev
, struct device_attribute
*attr
,
516 const char *buf
, size_t count
)
519 struct dock_station
*dock_station
= dev
->platform_data
;
524 acpi_scan_lock_acquire();
525 begin_undock(dock_station
);
526 ret
= handle_eject_request(dock_station
, ACPI_NOTIFY_EJECT_REQUEST
);
527 acpi_scan_lock_release();
528 return ret
? ret
: count
;
530 static DEVICE_ATTR_WO(undock
);
533 * show_dock_uid - read method for "uid" file in sysfs
535 static ssize_t
uid_show(struct device
*dev
,
536 struct device_attribute
*attr
, char *buf
)
538 unsigned long long lbuf
;
539 struct dock_station
*dock_station
= dev
->platform_data
;
541 acpi_status status
= acpi_evaluate_integer(dock_station
->handle
,
542 "_UID", NULL
, &lbuf
);
543 if (ACPI_FAILURE(status
))
546 return snprintf(buf
, PAGE_SIZE
, "%llx\n", lbuf
);
548 static DEVICE_ATTR_RO(uid
);
550 static ssize_t
type_show(struct device
*dev
,
551 struct device_attribute
*attr
, char *buf
)
553 struct dock_station
*dock_station
= dev
->platform_data
;
556 if (dock_station
->flags
& DOCK_IS_DOCK
)
557 type
= "dock_station";
558 else if (dock_station
->flags
& DOCK_IS_ATA
)
560 else if (dock_station
->flags
& DOCK_IS_BAT
)
561 type
= "battery_bay";
565 return snprintf(buf
, PAGE_SIZE
, "%s\n", type
);
567 static DEVICE_ATTR_RO(type
);
569 static struct attribute
*dock_attributes
[] = {
570 &dev_attr_docked
.attr
,
571 &dev_attr_flags
.attr
,
572 &dev_attr_undock
.attr
,
578 static const struct attribute_group dock_attribute_group
= {
579 .attrs
= dock_attributes
583 * acpi_dock_add - Add a new dock station
584 * @adev: Dock station ACPI device object.
586 * allocated and initialize a new dock station device.
588 void acpi_dock_add(struct acpi_device
*adev
)
590 struct dock_station
*dock_station
, ds
= { NULL
, };
591 struct platform_device_info pdevinfo
;
592 acpi_handle handle
= adev
->handle
;
593 struct platform_device
*dd
;
596 memset(&pdevinfo
, 0, sizeof(pdevinfo
));
597 pdevinfo
.name
= "dock";
598 pdevinfo
.id
= dock_station_count
;
599 pdevinfo
.fwnode
= acpi_fwnode_handle(adev
);
601 pdevinfo
.size_data
= sizeof(ds
);
602 dd
= platform_device_register_full(&pdevinfo
);
606 dock_station
= dd
->dev
.platform_data
;
608 dock_station
->handle
= handle
;
609 dock_station
->dock_device
= dd
;
610 dock_station
->last_dock_time
= jiffies
- HZ
;
612 INIT_LIST_HEAD(&dock_station
->sibling
);
613 INIT_LIST_HEAD(&dock_station
->dependent_devices
);
615 /* we want the dock device to send uevents */
616 dev_set_uevent_suppress(&dd
->dev
, 0);
618 if (acpi_dock_match(handle
))
619 dock_station
->flags
|= DOCK_IS_DOCK
;
620 if (acpi_ata_match(handle
))
621 dock_station
->flags
|= DOCK_IS_ATA
;
622 if (acpi_device_is_battery(adev
))
623 dock_station
->flags
|= DOCK_IS_BAT
;
625 ret
= sysfs_create_group(&dd
->dev
.kobj
, &dock_attribute_group
);
629 /* add the dock station as a device dependent on itself */
630 ret
= add_dock_dependent_device(dock_station
, adev
);
634 dock_station_count
++;
635 list_add(&dock_station
->sibling
, &dock_stations
);
636 adev
->flags
.is_dock_station
= true;
637 dev_info(&adev
->dev
, "ACPI dock station (docks/bays count: %d)\n",
642 sysfs_remove_group(&dd
->dev
.kobj
, &dock_attribute_group
);
645 platform_device_unregister(dd
);
646 acpi_handle_err(handle
, "%s encountered error %d\n", __func__
, ret
);