Release 4.14 drivers/acpi/dock.c

/*
 *  dock.c - ACPI dock station driver
 *
 *  Copyright (C) 2006, 2014, Intel Corp.
 *  Author: Kristen Carlson Accardi <kristen.c.accardi@intel.com>
 *          Rafael J. Wysocki <rafael.j.wysocki@intel.com>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or (at
 *  your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#include <linux/kernel.h>
#include <linux/moduleparam.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/notifier.h>
#include <linux/platform_device.h>
#include <linux/jiffies.h>
#include <linux/stddef.h>
#include <linux/acpi.h>

#include "internal.h"

ACPI_MODULE_NAME("dock");


static bool immediate_undock = 1;
module_param(immediate_undock, bool, 0644);
MODULE_PARM_DESC(immediate_undock, "1 (default) will cause the driver to "
	"undock immediately when the undock button is pressed, 0 will cause"
	" the driver to wait for userspace to write the undock sysfs file "
	" before undocking");


struct dock_station {
	
acpi_handle handle;
	
unsigned long last_dock_time;
	
u32 flags;
	
struct list_head dependent_devices;

	
struct list_head sibling;
	
struct platform_device *dock_device;
};
static LIST_HEAD(dock_stations);

static int dock_station_count;


struct dock_dependent_device {
	
struct list_head list;
	
struct acpi_device *adev;
};


#define DOCK_DOCKING	0x00000001

#define DOCK_UNDOCKING  0x00000002

#define DOCK_IS_DOCK	0x00000010

#define DOCK_IS_ATA	0x00000020

#define DOCK_IS_BAT	0x00000040

#define DOCK_EVENT	3

#define UNDOCK_EVENT	2


enum dock_callback_type {
	
DOCK_CALL_HANDLER,
	
DOCK_CALL_FIXUP,
	
DOCK_CALL_UEVENT,
};

/*****************************************************************************
 *                         Dock Dependent device functions                   *
 *****************************************************************************/
/**
 * add_dock_dependent_device - associate a device with the dock station
 * @ds: Dock station.
 * @adev: Dependent ACPI device object.
 *
 * Add the dependent device to the dock's dependent device list.
 */


static int add_dock_dependent_device(struct dock_station *ds,
				     struct acpi_device *adev)
{
	struct dock_dependent_device *dd;

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

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

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Len Brown
53
72.60%
1
33.33%
Alexander Chiang
14
19.18%
1
33.33%
Rafael J. Wysocki
6
8.22%
1
33.33%
Total
73
100.00%
3
100.00%



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

	acpi_lock_hp_context();

	if (!adev->hp)
		goto out;

	if (cb_type == DOCK_CALL_FIXUP) {
		void (*fixup)(struct acpi_device *);

		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);

		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;
		}
	}

 out:
	acpi_unlock_hp_context();
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Rafael J. Wysocki
174
99.43%
5
83.33%
Len Brown
1
0.57%
1
16.67%
Total
175
100.00%
6
100.00%



static struct dock_station *find_dock_station(acpi_handle handle)
{
	struct dock_station *ds;

	list_for_each_entry(ds, &dock_stations, sibling)
		if (ds->handle == handle)
			return ds;

	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Rafael J. Wysocki
38
100.00%
1
100.00%
Total
38
100.00%
1
100.00%

/**
 * find_dock_dependent_device - get a device dependent on this dock
 * @ds: the dock station
 * @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, struct acpi_device *adev)
{
	struct dock_dependent_device *dd;

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

	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Len Brown
39
86.67%
1
50.00%
Rafael J. Wysocki
6
13.33%
1
50.00%
Total
45
100.00%
2
100.00%



void register_dock_dependent_device(struct acpi_device *adev,
				    acpi_handle dshandle)
{
	struct dock_station *ds = find_dock_station(dshandle);

	if (ds && !find_dock_dependent_device(ds, adev))
		add_dock_dependent_device(ds, adev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Rafael J. Wysocki
23
54.76%
2
66.67%
David Shaohua Li
19
45.24%
1
33.33%
Total
42
100.00%
3
100.00%

/*****************************************************************************
 *                         Dock functions                                    *
 *****************************************************************************/

/**
 * is_dock_device - see if a device is on a dock station
 * @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(struct acpi_device *adev)
{
	struct dock_station *dock_station;

	if (!dock_station_count)
		return 0;

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

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

	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Len Brown
30
51.72%
1
20.00%
David Shaohua Li
19
32.76%
1
20.00%
Rafael J. Wysocki
7
12.07%
1
20.00%
Alexander Chiang
1
1.72%
1
20.00%
Jiang Liu
1
1.72%
1
20.00%
Total
58
100.00%
5
100.00%


EXPORT_SYMBOL_GPL(is_dock_device);

/**
 * dock_present - see if the dock station is present.
 * @ds: the dock station
 *
 * execute the _STA method.  note that present does not
 * imply that we are docked.
 */


static int dock_present(struct dock_station *ds)
{
	unsigned long long sta;
	acpi_status status;

	if (ds) {
		status = acpi_evaluate_integer(ds->handle, "_STA", NULL, &sta);
		if (ACPI_SUCCESS(status) && sta)
			return 1;
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Len Brown
56
100.00%
2
100.00%
Total
56
100.00%
2
100.00%

/**
 * hot_remove_dock_devices - Remove dock station devices.
 * @ds: Dock station.
 */


static void hot_remove_dock_devices(struct dock_station *ds)
{
	struct dock_dependent_device *dd;

	/*
         * Walk the list in reverse order so that devices that have been added
         * last are removed first (in case there are some indirect dependencies
         * between them).
         */
	list_for_each_entry_reverse(dd, &ds->dependent_devices, list)
		dock_hotplug_event(dd, ACPI_NOTIFY_EJECT_REQUEST, false);

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Rafael J. Wysocki
49
100.00%
2
100.00%
Total
49
100.00%
2
100.00%

/**
 * hotplug_dock_devices - Insert devices on a dock station.
 * @ds: the dock station
 * @event: either bus check or device check request
 *
 * Some devices on the dock station need to have drivers called
 * to perform hotplug operations after a dock event has occurred.
 * Traverse the list of dock devices that have registered a
 * hotplug handler, and call the handler.
 */


static void hotplug_dock_devices(struct dock_station *ds, u32 event)
{
	struct dock_dependent_device *dd;

	/* Call driver specific post-dock fixups. */
	list_for_each_entry(dd, &ds->dependent_devices, list)
		dock_hotplug_event(dd, event, DOCK_CALL_FIXUP);

	/* Call driver specific hotplug functions. */
	list_for_each_entry(dd, &ds->dependent_devices, list)
		dock_hotplug_event(dd, event, DOCK_CALL_HANDLER);

	/*
         * 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) {
		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);
		}
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Rafael J. Wysocki
67
59.82%
4
80.00%
Len Brown
45
40.18%
1
20.00%
Total
112
100.00%
5
100.00%



static void dock_event(struct dock_station *ds, u32 event, int num)
{
	struct device *dev = &ds->dock_device->dev;
	char event_string[13];
	char *envp[] = { event_string, NULL };
	struct dock_dependent_device *dd;

	if (num == UNDOCK_EVENT)
		sprintf(event_string, "EVENT=undock");
	else
		sprintf(event_string, "EVENT=dock");

	/*
         * Indicate that the status of the dock station has
         * changed.
         */
	if (num == DOCK_EVENT)
		kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);

	list_for_each_entry(dd, &ds->dependent_devices, list)
		dock_hotplug_event(dd, event, DOCK_CALL_UEVENT);

	if (num != DOCK_EVENT)
		kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Kristen Carlson Accardi
58
46.03%
3
33.33%
David Shaohua Li
44
34.92%
2
22.22%
Len Brown
17
13.49%
1
11.11%
Rafael J. Wysocki
4
3.17%
2
22.22%
Holger Macht
3
2.38%
1
11.11%
Total
126
100.00%
9
100.00%

/**
 * handle_dock - handle a dock event
 * @ds: the dock station
 * @dock: to dock, or undock - that is the question
 *
 * Execute the _DCK method in response to an acpi event
 */


static void handle_dock(struct dock_station *ds, int dock)
{
	acpi_status status;
	struct acpi_object_list arg_list;
	union acpi_object arg;
	unsigned long long value;

	acpi_handle_info(ds->handle, "%s\n", dock ? "docking" : "undocking");

	/* _DCK method has one argument */
	arg_list.count = 1;
	arg_list.pointer = &arg;
	arg.type = ACPI_TYPE_INTEGER;
	arg.integer.value = dock;
	status = acpi_evaluate_integer(ds->handle, "_DCK", &arg_list, &value);
	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND)
		acpi_handle_err(ds->handle, "Failed to execute _DCK (0x%x)\n",
				status);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Len Brown
87
77.68%
1
20.00%
Toshi Kani
13
11.61%
1
20.00%
Rui Zhang
6
5.36%
1
20.00%
David Shaohua Li
4
3.57%
1
20.00%
Thomas Renninger
2
1.79%
1
20.00%
Total
112
100.00%
5
100.00%



static inline void dock(struct dock_station *ds)
{
	handle_dock(ds, 1);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Len Brown
19
100.00%
1
100.00%
Total
19
100.00%
1
100.00%



static inline void undock(struct dock_station *ds)
{
	handle_dock(ds, 0);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Len Brown
19
100.00%
1
100.00%
Total
19
100.00%
1
100.00%



static inline void begin_dock(struct dock_station *ds)
{
	ds->flags |= DOCK_DOCKING;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Len Brown
18
100.00%
1
100.00%
Total
18
100.00%
1
100.00%



static inline void complete_dock(struct dock_station *ds)
{
	ds->flags &= ~(DOCK_DOCKING);
	ds->last_dock_time = jiffies;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Len Brown
27
100.00%
1
100.00%
Total
27
100.00%
1
100.00%



static inline void begin_undock(struct dock_station *ds)
{
	ds->flags |= DOCK_UNDOCKING;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Kristen Carlson Accardi
18
100.00%
1
100.00%
Total
18
100.00%
1
100.00%



static inline void complete_undock(struct dock_station *ds)
{
	ds->flags &= ~(DOCK_UNDOCKING);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Kristen Carlson Accardi
21
100.00%
1
100.00%
Total
21
100.00%
1
100.00%

/**
 * dock_in_progress - see if we are in the middle of handling a dock event
 * @ds: the dock station
 *
 * Sometimes while docking, false dock events can be sent to the driver
 * because good connections aren't made or some other reason.  Ignore these
 * if we are in the middle of doing something.
 */


static int dock_in_progress(struct dock_station *ds)
{
	if ((ds->flags & DOCK_DOCKING) ||
	    time_before(jiffies, (ds->last_dock_time + HZ)))
		return 1;
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Len Brown
40
100.00%
1
100.00%
Total
40
100.00%
1
100.00%

/**
 * handle_eject_request - handle an undock request checking for error conditions
 *
 * Check to make sure the dock device is still present, then undock and
 * hotremove all the devices that may need removing.
 */


static int handle_eject_request(struct dock_station *ds, u32 event)
{
	if (dock_in_progress(ds))
		return -EBUSY;

	/*
         * here we need to generate the undock
         * event prior to actually doing the undock
         * so that the device struct still exists.
         * Also, even send the dock event if the
         * device is not present anymore
         */
	dock_event(ds, event, UNDOCK_EVENT);

	hot_remove_dock_devices(ds);
	undock(ds);
	acpi_evaluate_lck(ds->handle, 0);
	acpi_evaluate_ej0(ds->handle);
	if (dock_present(ds)) {
		acpi_handle_err(ds->handle, "Unable to undock!\n");
		return -EBUSY;
	}
	complete_undock(ds);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Brandon Philips
66
72.53%
1
14.29%
David Shaohua Li
6
6.59%
1
14.29%
Toshi Kani
6
6.59%
1
14.29%
Jiang Liu
6
6.59%
1
14.29%
Kristen Carlson Accardi
5
5.49%
1
14.29%
Rafael J. Wysocki
1
1.10%
1
14.29%
Holger Macht
1
1.10%
1
14.29%
Total
91
100.00%
7
100.00%

/**
 * 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.
 */


int dock_notify(struct acpi_device *adev, u32 event)
{
	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
         * request.
         */
	if ((ds->flags & DOCK_IS_DOCK) && event == ACPI_NOTIFY_DEVICE_CHECK)
		event = ACPI_NOTIFY_EJECT_REQUEST;

	/*
         * dock station: BUS_CHECK - docked or surprise removal
         *               DEVICE_CHECK - undocked
         * other device: BUS_CHECK/DEVICE_CHECK - added or surprise removal
         *
         * To simplify event handling, dock dependent device handler always
         * get ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and
         * ACPI_NOTIFY_EJECT_REQUEST for removal
         */
	switch (event) {
	case ACPI_NOTIFY_BUS_CHECK:
	case ACPI_NOTIFY_DEVICE_CHECK:
		if (!dock_in_progress(ds) && !acpi_device_enumerated(adev)) {
			begin_dock(ds);
			dock(ds);
			if (!dock_present(ds)) {
				acpi_handle_err(handle, "Unable to dock!\n");
				complete_dock(ds);
				break;
			}
			hotplug_dock_devices(ds, event);
			complete_dock(ds);
			dock_event(ds, event, DOCK_EVENT);
			acpi_evaluate_lck(ds->handle, 1);
			acpi_update_all_gpes();
			break;
		}
		if (dock_present(ds) || dock_in_progress(ds))
			break;
		/* This is a surprise removal */
		surprise_removal = 1;
		event = ACPI_NOTIFY_EJECT_REQUEST;
		/* Fall back */
	case ACPI_NOTIFY_EJECT_REQUEST:
		begin_undock(ds);
		if ((immediate_undock && !(ds->flags & DOCK_IS_ATA))
		   || surprise_removal)
			handle_eject_request(ds, event);
		else
			dock_event(ds, event, UNDOCK_EVENT);
		break;
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Len Brown
89
39.04%
1
6.67%
David Shaohua Li
79
34.65%
5
33.33%
Rafael J. Wysocki
32
14.04%
4
26.67%
Kristen Carlson Accardi
19
8.33%
1
6.67%
Toshi Kani
4
1.75%
1
6.67%
Jiang Liu
3
1.32%
1
6.67%
Brandon Philips
1
0.44%
1
6.67%
Lin Ming
1
0.44%
1
6.67%
Total
228
100.00%
15
100.00%

/*
 * show_docked - read method for "docked" file in sysfs
 */


static ssize_t show_docked(struct device *dev,
			   struct device_attribute *attr, char *buf)
{
	struct dock_station *dock_station = dev->platform_data;
	struct acpi_device *adev = NULL;

	acpi_bus_get_device(dock_station->handle, &adev);
	return snprintf(buf, PAGE_SIZE, "%u\n", acpi_device_enumerated(adev));
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Brandon Philips
29
47.54%
1
25.00%
Rafael J. Wysocki
14
22.95%
1
25.00%
Holger Macht
9
14.75%
1
25.00%
David Shaohua Li
9
14.75%
1
25.00%
Total
61
100.00%
4
100.00%

static DEVICE_ATTR(docked, S_IRUGO, show_docked, NULL);

/*
 * show_flags - read method for flags file in sysfs
 */


static ssize_t show_flags(struct device *dev,
			  struct device_attribute *attr, char *buf)
{
	struct dock_station *dock_station = dev->platform_data;
	return snprintf(buf, PAGE_SIZE, "%d\n", dock_station->flags);

}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Kristen Carlson Accardi
34
79.07%
1
50.00%
David Shaohua Li
9
20.93%
1
50.00%
Total
43
100.00%
2
100.00%

static DEVICE_ATTR(flags, S_IRUGO, show_flags, NULL);

/*
 * write_undock - write method for "undock" file in sysfs
 */


static ssize_t write_undock(struct device *dev, struct device_attribute *attr,
			   const char *buf, size_t count)
{
	int ret;
	struct dock_station *dock_station = dev->platform_data;

	if (!count)
		return -EINVAL;

	acpi_scan_lock_acquire();
	begin_undock(dock_station);
	ret = handle_eject_request(dock_station, ACPI_NOTIFY_EJECT_REQUEST);
	acpi_scan_lock_release();
	return ret ? ret: count;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Brandon Philips
52
72.22%
1
25.00%
David Shaohua Li
9
12.50%
1
25.00%
Rafael J. Wysocki
6
8.33%
1
25.00%
Holger Macht
5
6.94%
1
25.00%
Total
72
100.00%
4
100.00%

static DEVICE_ATTR(undock, S_IWUSR, NULL, write_undock);

/*
 * show_dock_uid - read method for "uid" file in sysfs
 */


static ssize_t show_dock_uid(struct device *dev,
			     struct device_attribute *attr, char *buf)
{
	unsigned long long lbuf;
	struct dock_station *dock_station = dev->platform_data;
	acpi_status status = acpi_evaluate_integer(dock_station->handle,
					"_UID", NULL, &lbuf);
	if (ACPI_FAILURE(status))
	    return 0;

	return snprintf(buf, PAGE_SIZE, "%llx\n", lbuf);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Ilya A. Volynets-Evenbakh
61
83.56%
1
25.00%
David Shaohua Li
9
12.33%
1
25.00%
Matthew Wilcox
2
2.74%
1
25.00%
Randy Dunlap
1
1.37%
1
25.00%
Total
73
100.00%
4
100.00%

static DEVICE_ATTR(uid, S_IRUGO, show_dock_uid, NULL);



static ssize_t show_dock_type(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct dock_station *dock_station = dev->platform_data;
	char *type;

	if (dock_station->flags & DOCK_IS_DOCK)
		type = "dock_station";
	else if (dock_station->flags & DOCK_IS_ATA)
		type = "ata_bay";
	else if (dock_station->flags & DOCK_IS_BAT)
		type = "battery_bay";
	else
		type = "unknown";

	return snprintf(buf, PAGE_SIZE, "%s\n", type);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David Shaohua Li
88
100.00%
1
100.00%
Total
88
100.00%
1
100.00%

static DEVICE_ATTR(type, S_IRUGO, show_dock_type, NULL);


static struct attribute *dock_attributes[] = {
	&dev_attr_docked.attr,
	&dev_attr_flags.attr,
	&dev_attr_undock.attr,
	&dev_attr_uid.attr,
	&dev_attr_type.attr,
	NULL
};


static const struct attribute_group dock_attribute_group = {
	.attrs = dock_attributes
};

/**
 * acpi_dock_add - Add a new dock station
 * @adev: Dock station ACPI device object.
 *
 * allocated and initialize a new dock station device.
 */


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;
	int ret;

	memset(&pdevinfo, 0, sizeof(pdevinfo));
	pdevinfo.name = "dock";
	pdevinfo.id = dock_station_count;
	pdevinfo.fwnode = acpi_fwnode_handle(adev);
	pdevinfo.data = &ds;
	pdevinfo.size_data = sizeof(ds);
	dd = platform_device_register_full(&pdevinfo);
	if (IS_ERR(dd))
		return;

	dock_station = dd->dev.platform_data;

	dock_station->handle = handle;
	dock_station->dock_device = dd;
	dock_station->last_dock_time = jiffies - HZ;

	INIT_LIST_HEAD(&dock_station->sibling);
	INIT_LIST_HEAD(&dock_station->dependent_devices);

	/* we want the dock device to send uevents */
	dev_set_uevent_suppress(&dd->dev, 0);

	if (acpi_dock_match(handle))
		dock_station->flags |= DOCK_IS_DOCK;
	if (acpi_ata_match(handle))
		dock_station->flags |= DOCK_IS_ATA;
	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;

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

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

err_rmgroup:
	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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Rafael J. Wysocki
98
31.92%
6
26.09%
David Shaohua Li
76
24.76%
2
8.70%
Len Brown
52
16.94%
1
4.35%
Alexander Chiang
49
15.96%
6
26.09%
Kristen Carlson Accardi
13
4.23%
4
17.39%
Brandon Philips
9
2.93%
1
4.35%
Lei Ming
5
1.63%
1
4.35%
Toshi Kani
3
0.98%
1
4.35%
Jiang Liu
2
0.65%
1
4.35%
Total
307
100.00%
23
100.00%

Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Len Brown
661
28.79%
3
4.76%
Rafael J. Wysocki
547
23.82%
17
26.98%
David Shaohua Li
413
17.99%
7
11.11%
Kristen Carlson Accardi
213
9.28%
8
12.70%
Brandon Philips
182
7.93%
1
1.59%
Alexander Chiang
113
4.92%
6
9.52%
Ilya A. Volynets-Evenbakh
73
3.18%
1
1.59%
Toshi Kani
27
1.18%
1
1.59%
Holger Macht
18
0.78%
4
6.35%
Jiang Liu
12
0.52%
1
1.59%
Rui Zhang
6
0.26%
1
1.59%
Lei Ming
5
0.22%
1
1.59%
Randy Dunlap
4
0.17%
1
1.59%
Adrian Bunk
4
0.17%
1
1.59%
Al Viro
3
0.13%
1
1.59%
Tejun Heo
3
0.13%
1
1.59%
Rashika Kheria
3
0.13%
1
1.59%
Thomas Renninger
2
0.09%
1
1.59%
Matthew Wilcox
2
0.09%
1
1.59%
Paul Gortmaker
1
0.04%
1
1.59%
Amitoj Kaur Chawla
1
0.04%
1
1.59%
Jarkko Nikula
1
0.04%
1
1.59%
Rusty Russell
1
0.04%
1
1.59%
Lin Ming
1
0.04%
1
1.59%
Total
2296
100.00%
63
100.00%
Directory: drivers/acpi

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.