1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 *  dock.c - ACPI dock station driver
4 *
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>
8 */
9
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>
20
21#include "internal.h"
22
23static bool immediate_undock = 1;
24module_param(immediate_undock, bool, 0644);
25MODULE_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 "
28	" before undocking");
29
30struct dock_station {
31	acpi_handle handle;
32	unsigned long last_dock_time;
33	u32 flags;
34	struct list_head dependent_devices;
35
36	struct list_head sibling;
37	struct platform_device *dock_device;
38};
39static LIST_HEAD(dock_stations);
40static int dock_station_count;
41
42struct dock_dependent_device {
43	struct list_head list;
44	struct acpi_device *adev;
45};
46
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
52#define DOCK_EVENT	3
53#define UNDOCK_EVENT	2
54
55enum dock_callback_type {
56	DOCK_CALL_HANDLER,
57	DOCK_CALL_FIXUP,
58	DOCK_CALL_UEVENT,
59};
60
61/*****************************************************************************
62 *                         Dock Dependent device functions                   *
63 *****************************************************************************/
64/**
65 * add_dock_dependent_device - associate a device with the dock station
66 * @ds: Dock station.
67 * @adev: Dependent ACPI device object.
68 *
69 * Add the dependent device to the dock's dependent device list.
70 */
71static int add_dock_dependent_device(struct dock_station *ds,
72				     struct acpi_device *adev)
73{
74	struct dock_dependent_device *dd;
75
76	dd = kzalloc(sizeof(*dd), GFP_KERNEL);
77	if (!dd)
78		return -ENOMEM;
79
80	dd->adev = adev;
81	INIT_LIST_HEAD(&dd->list);
82	list_add_tail(&dd->list, &ds->dependent_devices);
83
84	return 0;
85}
86
87static void dock_hotplug_event(struct dock_dependent_device *dd, u32 event,
88			       enum dock_callback_type cb_type)
89{
90	struct acpi_device *adev = dd->adev;
91
92	acpi_lock_hp_context();
93
94	if (!adev->hp)
95		goto out;
96
97	if (cb_type == DOCK_CALL_FIXUP) {
98		void (*fixup)(struct acpi_device *);
99
100		fixup = adev->hp->fixup;
101		if (fixup) {
102			acpi_unlock_hp_context();
103			fixup(adev);
104			return;
105		}
106	} else if (cb_type == DOCK_CALL_UEVENT) {
107		void (*uevent)(struct acpi_device *, u32);
108
109		uevent = adev->hp->uevent;
110		if (uevent) {
111			acpi_unlock_hp_context();
112			uevent(adev, event);
113			return;
114		}
115	} else {
116		int (*notify)(struct acpi_device *, u32);
117
118		notify = adev->hp->notify;
119		if (notify) {
120			acpi_unlock_hp_context();
121			notify(adev, event);
122			return;
123		}
124	}
125
126 out:
127	acpi_unlock_hp_context();
128}
129
130static struct dock_station *find_dock_station(acpi_handle handle)
131{
132	struct dock_station *ds;
133
134	list_for_each_entry(ds, &dock_stations, sibling)
135		if (ds->handle == handle)
136			return ds;
137
138	return NULL;
139}
140
141/**
142 * find_dock_dependent_device - get a device dependent on this dock
143 * @ds: the dock station
144 * @adev: ACPI device object to find.
145 *
146 * iterate over the dependent device list for this dock.  If the
147 * dependent device matches the handle, return.
148 */
149static struct dock_dependent_device *
150find_dock_dependent_device(struct dock_station *ds, struct acpi_device *adev)
151{
152	struct dock_dependent_device *dd;
153
154	list_for_each_entry(dd, &ds->dependent_devices, list)
155		if (adev == dd->adev)
156			return dd;
157
158	return NULL;
159}
160
161void register_dock_dependent_device(struct acpi_device *adev,
162				    acpi_handle dshandle)
163{
164	struct dock_station *ds = find_dock_station(dshandle);
165
166	if (ds && !find_dock_dependent_device(ds, adev))
167		add_dock_dependent_device(ds, adev);
168}
169
170/*****************************************************************************
171 *                         Dock functions                                    *
172 *****************************************************************************/
173
174/**
175 * is_dock_device - see if a device is on a dock station
176 * @adev: ACPI device object to check.
177 *
178 * If this device is either the dock station itself,
179 * or is a device dependent on the dock station, then it
180 * is a dock device
181 */
182int is_dock_device(struct acpi_device *adev)
183{
184	struct dock_station *dock_station;
185
186	if (!dock_station_count)
187		return 0;
188
189	if (acpi_dock_match(adev->handle))
190		return 1;
191
192	list_for_each_entry(dock_station, &dock_stations, sibling)
193		if (find_dock_dependent_device(dock_station, adev))
194			return 1;
195
196	return 0;
197}
198EXPORT_SYMBOL_GPL(is_dock_device);
199
200/**
201 * dock_present - see if the dock station is present.
202 * @ds: the dock station
203 *
204 * execute the _STA method.  note that present does not
205 * imply that we are docked.
206 */
207static int dock_present(struct dock_station *ds)
208{
209	unsigned long long sta;
210	acpi_status status;
211
212	if (ds) {
213		status = acpi_evaluate_integer(ds->handle, "_STA", NULL, &sta);
214		if (ACPI_SUCCESS(status) && sta)
215			return 1;
216	}
217	return 0;
218}
219
220/**
221 * hot_remove_dock_devices - Remove dock station devices.
222 * @ds: Dock station.
223 */
224static void hot_remove_dock_devices(struct dock_station *ds)
225{
226	struct dock_dependent_device *dd;
227
228	/*
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
231	 * between them).
232	 */
233	list_for_each_entry_reverse(dd, &ds->dependent_devices, list)
234		dock_hotplug_event(dd, ACPI_NOTIFY_EJECT_REQUEST,
235				   DOCK_CALL_HANDLER);
236
237	list_for_each_entry_reverse(dd, &ds->dependent_devices, list)
238		acpi_bus_trim(dd->adev);
239}
240
241/**
242 * hotplug_dock_devices - Insert devices on a dock station.
243 * @ds: the dock station
244 * @event: either bus check or device check request
245 *
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.
250 */
251static void hotplug_dock_devices(struct dock_station *ds, u32 event)
252{
253	struct dock_dependent_device *dd;
254
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);
258
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);
262
263	/*
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
267	 * they are present.
268	 */
269	list_for_each_entry(dd, &ds->dependent_devices, list) {
270		struct acpi_device *adev = dd->adev;
271
272		if (!acpi_device_enumerated(adev)) {
273			int ret = acpi_bus_scan(adev->handle);
274
275			if (ret)
276				dev_dbg(&adev->dev, "scan error %d\n", -ret);
277		}
278	}
279}
280
281static void dock_event(struct dock_station *ds, u32 event, int num)
282{
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;
287
288	if (num == UNDOCK_EVENT)
289		sprintf(event_string, "EVENT=undock");
290	else
291		sprintf(event_string, "EVENT=dock");
292
293	/*
294	 * Indicate that the status of the dock station has
295	 * changed.
296	 */
297	if (num == DOCK_EVENT)
298		kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);
299
300	list_for_each_entry(dd, &ds->dependent_devices, list)
301		dock_hotplug_event(dd, event, DOCK_CALL_UEVENT);
302
303	if (num != DOCK_EVENT)
304		kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);
305}
306
307/**
308 * handle_dock - handle a dock event
309 * @ds: the dock station
310 * @dock: to dock, or undock - that is the question
311 *
312 * Execute the _DCK method in response to an acpi event
313 */
314static void handle_dock(struct dock_station *ds, int dock)
315{
316	acpi_status status;
317	struct acpi_object_list arg_list;
318	union acpi_object arg;
319	unsigned long long value;
320
321	acpi_handle_info(ds->handle, "%s\n", dock ? "docking" : "undocking");
322
323	/* _DCK method has one argument */
324	arg_list.count = 1;
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",
331				status);
332}
333
334static inline void dock(struct dock_station *ds)
335{
336	handle_dock(ds, 1);
337}
338
339static inline void undock(struct dock_station *ds)
340{
341	handle_dock(ds, 0);
342}
343
344static inline void begin_dock(struct dock_station *ds)
345{
346	ds->flags |= DOCK_DOCKING;
347}
348
349static inline void complete_dock(struct dock_station *ds)
350{
351	ds->flags &= ~(DOCK_DOCKING);
352	ds->last_dock_time = jiffies;
353}
354
355static inline void begin_undock(struct dock_station *ds)
356{
357	ds->flags |= DOCK_UNDOCKING;
358}
359
360static inline void complete_undock(struct dock_station *ds)
361{
362	ds->flags &= ~(DOCK_UNDOCKING);
363}
364
365/**
366 * dock_in_progress - see if we are in the middle of handling a dock event
367 * @ds: the dock station
368 *
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.
372 */
373static int dock_in_progress(struct dock_station *ds)
374{
375	if ((ds->flags & DOCK_DOCKING) ||
376	    time_before(jiffies, (ds->last_dock_time + HZ)))
377		return 1;
378	return 0;
379}
380
381/**
382 * handle_eject_request - handle an undock request checking for error conditions
383 * @ds: The dock station to undock.
384 * @event: The ACPI event number associated with the undock request.
385 *
386 * Check to make sure the dock device is still present, then undock and
387 * hotremove all the devices that may need removing.
388 */
389static int handle_eject_request(struct dock_station *ds, u32 event)
390{
391	if (dock_in_progress(ds))
392		return -EBUSY;
393
394	/*
395	 * here we need to generate the undock
396	 * event prior to actually doing the undock
397	 * so that the device struct still exists.
398	 * Also, even send the dock event if the
399	 * device is not present anymore
400	 */
401	dock_event(ds, event, UNDOCK_EVENT);
402
403	hot_remove_dock_devices(ds);
404	undock(ds);
405	acpi_evaluate_lck(ds->handle, 0);
406	acpi_evaluate_ej0(ds->handle);
407	if (dock_present(ds)) {
408		acpi_handle_err(ds->handle, "Unable to undock!\n");
409		return -EBUSY;
410	}
411	complete_undock(ds);
412	return 0;
413}
414
415/**
416 * dock_notify - Handle ACPI dock notification.
417 * @adev: Dock station's ACPI device object.
418 * @event: Event code.
419 *
420 * If we are notified to dock, then check to see if the dock is
421 * present and then dock.  Notify all drivers of the dock event,
422 * and then hotplug and devices that may need hotplugging.
423 */
424int dock_notify(struct acpi_device *adev, u32 event)
425{
426	acpi_handle handle = adev->handle;
427	struct dock_station *ds = find_dock_station(handle);
428	int surprise_removal = 0;
429
430	if (!ds)
431		return -ENODEV;
432
433	/*
434	 * According to acpi spec 3.0a, if a DEVICE_CHECK notification
435	 * is sent and _DCK is present, it is assumed to mean an undock
436	 * request.
437	 */
438	if ((ds->flags & DOCK_IS_DOCK) && event == ACPI_NOTIFY_DEVICE_CHECK)
439		event = ACPI_NOTIFY_EJECT_REQUEST;
440
441	/*
442	 * dock station: BUS_CHECK - docked or surprise removal
443	 *		 DEVICE_CHECK - undocked
444	 * other device: BUS_CHECK/DEVICE_CHECK - added or surprise removal
445	 *
446	 * To simplify event handling, dock dependent device handler always
447	 * get ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and
448	 * ACPI_NOTIFY_EJECT_REQUEST for removal
449	 */
450	switch (event) {
451	case ACPI_NOTIFY_BUS_CHECK:
452	case ACPI_NOTIFY_DEVICE_CHECK:
453		if (!dock_in_progress(ds) && !acpi_device_enumerated(adev)) {
454			begin_dock(ds);
455			dock(ds);
456			if (!dock_present(ds)) {
457				acpi_handle_err(handle, "Unable to dock!\n");
458				complete_dock(ds);
459				break;
460			}
461			hotplug_dock_devices(ds, event);
462			complete_dock(ds);
463			dock_event(ds, event, DOCK_EVENT);
464			acpi_evaluate_lck(ds->handle, 1);
465			acpi_update_all_gpes();
466			break;
467		}
468		if (dock_present(ds) || dock_in_progress(ds))
469			break;
470		/* This is a surprise removal */
471		surprise_removal = 1;
472		event = ACPI_NOTIFY_EJECT_REQUEST;
473		/* Fall back */
474		fallthrough;
475	case ACPI_NOTIFY_EJECT_REQUEST:
476		begin_undock(ds);
477		if ((immediate_undock && !(ds->flags & DOCK_IS_ATA))
478		   || surprise_removal)
479			handle_eject_request(ds, event);
480		else
481			dock_event(ds, event, UNDOCK_EVENT);
482		break;
483	}
484	return 0;
485}
486
487/*
488 * show_docked - read method for "docked" file in sysfs
489 */
490static ssize_t docked_show(struct device *dev,
491			   struct device_attribute *attr, char *buf)
492{
493	struct dock_station *dock_station = dev->platform_data;
494	struct acpi_device *adev = acpi_fetch_acpi_dev(dock_station->handle);
495
496	return sysfs_emit(buf, "%u\n", acpi_device_enumerated(adev));
497}
498static DEVICE_ATTR_RO(docked);
499
500/*
501 * show_flags - read method for flags file in sysfs
502 */
503static ssize_t flags_show(struct device *dev,
504			  struct device_attribute *attr, char *buf)
505{
506	struct dock_station *dock_station = dev->platform_data;
507
508	return sysfs_emit(buf, "%d\n", dock_station->flags);
509
510}
511static DEVICE_ATTR_RO(flags);
512
513/*
514 * write_undock - write method for "undock" file in sysfs
515 */
516static ssize_t undock_store(struct device *dev, struct device_attribute *attr,
517			    const char *buf, size_t count)
518{
519	int ret;
520	struct dock_station *dock_station = dev->platform_data;
521
522	if (!count)
523		return -EINVAL;
524
525	acpi_scan_lock_acquire();
526	begin_undock(dock_station);
527	ret = handle_eject_request(dock_station, ACPI_NOTIFY_EJECT_REQUEST);
528	acpi_scan_lock_release();
529	return ret ? ret : count;
530}
531static DEVICE_ATTR_WO(undock);
532
533/*
534 * show_dock_uid - read method for "uid" file in sysfs
535 */
536static ssize_t uid_show(struct device *dev,
537			struct device_attribute *attr, char *buf)
538{
539	unsigned long long lbuf;
540	struct dock_station *dock_station = dev->platform_data;
541
542	acpi_status status = acpi_evaluate_integer(dock_station->handle,
543					"_UID", NULL, &lbuf);
544	if (ACPI_FAILURE(status))
545		return 0;
546
547	return sysfs_emit(buf, "%llx\n", lbuf);
548}
549static DEVICE_ATTR_RO(uid);
550
551static ssize_t type_show(struct device *dev,
552			 struct device_attribute *attr, char *buf)
553{
554	struct dock_station *dock_station = dev->platform_data;
555	char *type;
556
557	if (dock_station->flags & DOCK_IS_DOCK)
558		type = "dock_station";
559	else if (dock_station->flags & DOCK_IS_ATA)
560		type = "ata_bay";
561	else if (dock_station->flags & DOCK_IS_BAT)
562		type = "battery_bay";
563	else
564		type = "unknown";
565
566	return sysfs_emit(buf, "%s\n", type);
567}
568static DEVICE_ATTR_RO(type);
569
570static struct attribute *dock_attributes[] = {
571	&dev_attr_docked.attr,
572	&dev_attr_flags.attr,
573	&dev_attr_undock.attr,
574	&dev_attr_uid.attr,
575	&dev_attr_type.attr,
576	NULL
577};
578
579static const struct attribute_group dock_attribute_group = {
580	.attrs = dock_attributes
581};
582
583/**
584 * acpi_dock_add - Add a new dock station
585 * @adev: Dock station ACPI device object.
586 *
587 * allocated and initialize a new dock station device.
588 */
589void acpi_dock_add(struct acpi_device *adev)
590{
591	struct dock_station *dock_station, ds = { NULL, };
592	struct platform_device_info pdevinfo;
593	acpi_handle handle = adev->handle;
594	struct platform_device *dd;
595	int ret;
596
597	memset(&pdevinfo, 0, sizeof(pdevinfo));
598	pdevinfo.name = "dock";
599	pdevinfo.id = dock_station_count;
600	pdevinfo.fwnode = acpi_fwnode_handle(adev);
601	pdevinfo.data = &ds;
602	pdevinfo.size_data = sizeof(ds);
603	dd = platform_device_register_full(&pdevinfo);
604	if (IS_ERR(dd))
605		return;
606
607	dock_station = dd->dev.platform_data;
608
609	dock_station->handle = handle;
610	dock_station->dock_device = dd;
611	dock_station->last_dock_time = jiffies - HZ;
612
613	INIT_LIST_HEAD(&dock_station->sibling);
614	INIT_LIST_HEAD(&dock_station->dependent_devices);
615
616	/* we want the dock device to send uevents */
617	dev_set_uevent_suppress(&dd->dev, 0);
618
619	if (acpi_dock_match(handle))
620		dock_station->flags |= DOCK_IS_DOCK;
621	if (acpi_ata_match(handle))
622		dock_station->flags |= DOCK_IS_ATA;
623	if (acpi_device_is_battery(adev))
624		dock_station->flags |= DOCK_IS_BAT;
625
626	ret = sysfs_create_group(&dd->dev.kobj, &dock_attribute_group);
627	if (ret)
628		goto err_unregister;
629
630	/* add the dock station as a device dependent on itself */
631	ret = add_dock_dependent_device(dock_station, adev);
632	if (ret)
633		goto err_rmgroup;
634
635	dock_station_count++;
636	list_add(&dock_station->sibling, &dock_stations);
637	adev->flags.is_dock_station = true;
638	dev_info(&adev->dev, "ACPI dock station (docks/bays count: %d)\n",
639		 dock_station_count);
640	return;
641
642err_rmgroup:
643	sysfs_remove_group(&dd->dev.kobj, &dock_attribute_group);
644
645err_unregister:
646	platform_device_unregister(dd);
647	acpi_handle_err(handle, "%s encountered error %d\n", __func__, ret);
648}
649