1c8f7a62cSLen Brown /* 2c8f7a62cSLen Brown * dock.c - ACPI dock station driver 3c8f7a62cSLen Brown * 4c8f7a62cSLen Brown * Copyright (C) 2006 Kristen Carlson Accardi <kristen.c.accardi@intel.com> 5c8f7a62cSLen Brown * 6c8f7a62cSLen Brown * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7c8f7a62cSLen Brown * 8c8f7a62cSLen Brown * This program is free software; you can redistribute it and/or modify 9c8f7a62cSLen Brown * it under the terms of the GNU General Public License as published by 10c8f7a62cSLen Brown * the Free Software Foundation; either version 2 of the License, or (at 11c8f7a62cSLen Brown * your option) any later version. 12c8f7a62cSLen Brown * 13c8f7a62cSLen Brown * This program is distributed in the hope that it will be useful, but 14c8f7a62cSLen Brown * WITHOUT ANY WARRANTY; without even the implied warranty of 15c8f7a62cSLen Brown * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16c8f7a62cSLen Brown * General Public License for more details. 17c8f7a62cSLen Brown * 18c8f7a62cSLen Brown * You should have received a copy of the GNU General Public License along 19c8f7a62cSLen Brown * with this program; if not, write to the Free Software Foundation, Inc., 20c8f7a62cSLen Brown * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 21c8f7a62cSLen Brown * 22c8f7a62cSLen Brown * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 23c8f7a62cSLen Brown */ 24c8f7a62cSLen Brown 25c8f7a62cSLen Brown #include <linux/kernel.h> 26c8f7a62cSLen Brown #include <linux/module.h> 275a0e3ad6STejun Heo #include <linux/slab.h> 28c8f7a62cSLen Brown #include <linux/init.h> 29c8f7a62cSLen Brown #include <linux/types.h> 30c8f7a62cSLen Brown #include <linux/notifier.h> 31671adbecSKristen Carlson Accardi #include <linux/platform_device.h> 32914e2637SAl Viro #include <linux/jiffies.h> 3362a6d7fdSRandy Dunlap #include <linux/stddef.h> 34cd73018fSToshi Kani #include <linux/acpi.h> 35c8f7a62cSLen Brown #include <acpi/acpi_bus.h> 36c8f7a62cSLen Brown #include <acpi/acpi_drivers.h> 37c8f7a62cSLen Brown 38a192a958SLen Brown #define PREFIX "ACPI: " 39a192a958SLen Brown 407cda93e0SLen Brown #define ACPI_DOCK_DRIVER_DESCRIPTION "ACPI Dock Station Driver" 41c8f7a62cSLen Brown 42f52fd66dSLen Brown ACPI_MODULE_NAME("dock"); 43c8f7a62cSLen Brown MODULE_AUTHOR("Kristen Carlson Accardi"); 447cda93e0SLen Brown MODULE_DESCRIPTION(ACPI_DOCK_DRIVER_DESCRIPTION); 45c8f7a62cSLen Brown MODULE_LICENSE("GPL"); 46c8f7a62cSLen Brown 4790ab5ee9SRusty Russell static bool immediate_undock = 1; 48a0cd35fdSKristen Carlson Accardi module_param(immediate_undock, bool, 0644); 49a0cd35fdSKristen Carlson Accardi MODULE_PARM_DESC(immediate_undock, "1 (default) will cause the driver to " 50a0cd35fdSKristen Carlson Accardi "undock immediately when the undock button is pressed, 0 will cause" 51a0cd35fdSKristen Carlson Accardi " the driver to wait for userspace to write the undock sysfs file " 52a0cd35fdSKristen Carlson Accardi " before undocking"); 53a0cd35fdSKristen Carlson Accardi 54c8f7a62cSLen Brown static struct atomic_notifier_head dock_notifier_list; 55c8f7a62cSLen Brown 56a340af14SFrank Seidel static const struct acpi_device_id dock_device_ids[] = { 57a340af14SFrank Seidel {"LNXDOCK", 0}, 58a340af14SFrank Seidel {"", 0}, 59a340af14SFrank Seidel }; 60a340af14SFrank Seidel MODULE_DEVICE_TABLE(acpi, dock_device_ids); 61a340af14SFrank Seidel 62c8f7a62cSLen Brown struct dock_station { 63c8f7a62cSLen Brown acpi_handle handle; 64c8f7a62cSLen Brown unsigned long last_dock_time; 65c8f7a62cSLen Brown u32 flags; 66c8f7a62cSLen Brown struct list_head dependent_devices; 67db350b08SShaohua Li 6850d716e4SAlex Chiang struct list_head sibling; 69db350b08SShaohua Li struct platform_device *dock_device; 70c8f7a62cSLen Brown }; 71db350b08SShaohua Li static LIST_HEAD(dock_stations); 72db350b08SShaohua Li static int dock_station_count; 7321a31013SRafael J. Wysocki static DEFINE_MUTEX(hotplug_lock); 74c8f7a62cSLen Brown 75c8f7a62cSLen Brown struct dock_dependent_device { 76c8f7a62cSLen Brown struct list_head list; 77c8f7a62cSLen Brown acpi_handle handle; 7821a31013SRafael J. Wysocki const struct acpi_dock_ops *hp_ops; 7921a31013SRafael J. Wysocki void *hp_context; 8021a31013SRafael J. Wysocki unsigned int hp_refcount; 8121a31013SRafael J. Wysocki void (*hp_release)(void *); 82c8f7a62cSLen Brown }; 83c8f7a62cSLen Brown 84c8f7a62cSLen Brown #define DOCK_DOCKING 0x00000001 85a0cd35fdSKristen Carlson Accardi #define DOCK_UNDOCKING 0x00000002 86db350b08SShaohua Li #define DOCK_IS_DOCK 0x00000010 87db350b08SShaohua Li #define DOCK_IS_ATA 0x00000020 88db350b08SShaohua Li #define DOCK_IS_BAT 0x00000040 895669021eSKristen Carlson Accardi #define DOCK_EVENT 3 905669021eSKristen Carlson Accardi #define UNDOCK_EVENT 2 91c8f7a62cSLen Brown 92c8f7a62cSLen Brown /***************************************************************************** 93c8f7a62cSLen Brown * Dock Dependent device functions * 94c8f7a62cSLen Brown *****************************************************************************/ 95c8f7a62cSLen Brown /** 96f69cfdd2SAlex Chiang * add_dock_dependent_device - associate a device with the dock station 97f69cfdd2SAlex Chiang * @ds: The dock station 98f69cfdd2SAlex Chiang * @handle: handle of the dependent device 99c8f7a62cSLen Brown * 100f69cfdd2SAlex Chiang * Add the dependent device to the dock's dependent device list. 101c8f7a62cSLen Brown */ 102d423c083SJiang Liu static int __init 103f69cfdd2SAlex Chiang add_dock_dependent_device(struct dock_station *ds, acpi_handle handle) 104c8f7a62cSLen Brown { 105c8f7a62cSLen Brown struct dock_dependent_device *dd; 106c8f7a62cSLen Brown 107c8f7a62cSLen Brown dd = kzalloc(sizeof(*dd), GFP_KERNEL); 108f69cfdd2SAlex Chiang if (!dd) 109f69cfdd2SAlex Chiang return -ENOMEM; 110f69cfdd2SAlex Chiang 111c8f7a62cSLen Brown dd->handle = handle; 112c8f7a62cSLen Brown INIT_LIST_HEAD(&dd->list); 113c8f7a62cSLen Brown list_add_tail(&dd->list, &ds->dependent_devices); 114f69cfdd2SAlex Chiang 115f69cfdd2SAlex Chiang return 0; 116c8f7a62cSLen Brown } 117c8f7a62cSLen Brown 118c8f7a62cSLen Brown /** 11921a31013SRafael J. Wysocki * dock_init_hotplug - Initialize a hotplug device on a docking station. 12021a31013SRafael J. Wysocki * @dd: Dock-dependent device. 12121a31013SRafael J. Wysocki * @ops: Dock operations to attach to the dependent device. 12221a31013SRafael J. Wysocki * @context: Data to pass to the @ops callbacks and @release. 12321a31013SRafael J. Wysocki * @init: Optional initialization routine to run after setting up context. 12421a31013SRafael J. Wysocki * @release: Optional release routine to run on removal. 125c8f7a62cSLen Brown */ 12621a31013SRafael J. Wysocki static int dock_init_hotplug(struct dock_dependent_device *dd, 12721a31013SRafael J. Wysocki const struct acpi_dock_ops *ops, void *context, 12821a31013SRafael J. Wysocki void (*init)(void *), void (*release)(void *)) 129c8f7a62cSLen Brown { 13021a31013SRafael J. Wysocki int ret = 0; 13121a31013SRafael J. Wysocki 13221a31013SRafael J. Wysocki mutex_lock(&hotplug_lock); 1334ec24065SRafael J. Wysocki if (WARN_ON(dd->hp_context)) { 13421a31013SRafael J. Wysocki ret = -EEXIST; 13521a31013SRafael J. Wysocki } else { 13621a31013SRafael J. Wysocki dd->hp_refcount = 1; 13721a31013SRafael J. Wysocki dd->hp_ops = ops; 13821a31013SRafael J. Wysocki dd->hp_context = context; 13921a31013SRafael J. Wysocki dd->hp_release = release; 1404ec24065SRafael J. Wysocki if (init) 14121a31013SRafael J. Wysocki init(context); 1424ec24065SRafael J. Wysocki } 14321a31013SRafael J. Wysocki mutex_unlock(&hotplug_lock); 14421a31013SRafael J. Wysocki return ret; 145c8f7a62cSLen Brown } 146c8f7a62cSLen Brown 147c8f7a62cSLen Brown /** 14821a31013SRafael J. Wysocki * dock_release_hotplug - Decrement hotplug reference counter of dock device. 14921a31013SRafael J. Wysocki * @dd: Dock-dependent device. 150c8f7a62cSLen Brown * 15121a31013SRafael J. Wysocki * Decrement the reference counter of @dd and if 0, detach its hotplug 15221a31013SRafael J. Wysocki * operations from it, reset its context pointer and run the optional release 15321a31013SRafael J. Wysocki * routine if present. 154c8f7a62cSLen Brown */ 15521a31013SRafael J. Wysocki static void dock_release_hotplug(struct dock_dependent_device *dd) 156c8f7a62cSLen Brown { 15721a31013SRafael J. Wysocki mutex_lock(&hotplug_lock); 15821a31013SRafael J. Wysocki if (dd->hp_context && !--dd->hp_refcount) { 1594ec24065SRafael J. Wysocki void (*release)(void *) = dd->hp_release; 1604ec24065SRafael J. Wysocki void *context = dd->hp_context; 1614ec24065SRafael J. Wysocki 16221a31013SRafael J. Wysocki dd->hp_ops = NULL; 16321a31013SRafael J. Wysocki dd->hp_context = NULL; 16421a31013SRafael J. Wysocki dd->hp_release = NULL; 1654ec24065SRafael J. Wysocki if (release) 16621a31013SRafael J. Wysocki release(context); 1674ec24065SRafael J. Wysocki } 16821a31013SRafael J. Wysocki mutex_unlock(&hotplug_lock); 16921a31013SRafael J. Wysocki } 17021a31013SRafael J. Wysocki 17121a31013SRafael J. Wysocki static void dock_hotplug_event(struct dock_dependent_device *dd, u32 event, 17221a31013SRafael J. Wysocki bool uevent) 17321a31013SRafael J. Wysocki { 17421a31013SRafael J. Wysocki acpi_notify_handler cb = NULL; 17521a31013SRafael J. Wysocki bool run = false; 17621a31013SRafael J. Wysocki 17721a31013SRafael J. Wysocki mutex_lock(&hotplug_lock); 17821a31013SRafael J. Wysocki 17921a31013SRafael J. Wysocki if (dd->hp_context) { 18021a31013SRafael J. Wysocki run = true; 18121a31013SRafael J. Wysocki dd->hp_refcount++; 18221a31013SRafael J. Wysocki if (dd->hp_ops) 18321a31013SRafael J. Wysocki cb = uevent ? dd->hp_ops->uevent : dd->hp_ops->handler; 18421a31013SRafael J. Wysocki } 18521a31013SRafael J. Wysocki 18621a31013SRafael J. Wysocki mutex_unlock(&hotplug_lock); 18721a31013SRafael J. Wysocki 18821a31013SRafael J. Wysocki if (!run) 18921a31013SRafael J. Wysocki return; 19021a31013SRafael J. Wysocki 19121a31013SRafael J. Wysocki if (cb) 19221a31013SRafael J. Wysocki cb(dd->handle, event, dd->hp_context); 19321a31013SRafael J. Wysocki 19421a31013SRafael J. Wysocki dock_release_hotplug(dd); 195c8f7a62cSLen Brown } 196c8f7a62cSLen Brown 197c8f7a62cSLen Brown /** 198c8f7a62cSLen Brown * find_dock_dependent_device - get a device dependent on this dock 199c8f7a62cSLen Brown * @ds: the dock station 200c8f7a62cSLen Brown * @handle: the acpi_handle of the device we want 201c8f7a62cSLen Brown * 202c8f7a62cSLen Brown * iterate over the dependent device list for this dock. If the 203c8f7a62cSLen Brown * dependent device matches the handle, return. 204c8f7a62cSLen Brown */ 205c8f7a62cSLen Brown static struct dock_dependent_device * 206c8f7a62cSLen Brown find_dock_dependent_device(struct dock_station *ds, acpi_handle handle) 207c8f7a62cSLen Brown { 208c8f7a62cSLen Brown struct dock_dependent_device *dd; 209c8f7a62cSLen Brown 210ed633e70SJiang Liu list_for_each_entry(dd, &ds->dependent_devices, list) 211ed633e70SJiang Liu if (handle == dd->handle) 212c8f7a62cSLen Brown return dd; 213ed633e70SJiang Liu 214c8f7a62cSLen Brown return NULL; 215c8f7a62cSLen Brown } 216c8f7a62cSLen Brown 217c8f7a62cSLen Brown /***************************************************************************** 218c8f7a62cSLen Brown * Dock functions * 219c8f7a62cSLen Brown *****************************************************************************/ 220d423c083SJiang Liu static int __init is_battery(acpi_handle handle) 221db350b08SShaohua Li { 222db350b08SShaohua Li struct acpi_device_info *info; 223db350b08SShaohua Li int ret = 1; 224db350b08SShaohua Li 22515b8dd53SBob Moore if (!ACPI_SUCCESS(acpi_get_object_info(handle, &info))) 226db350b08SShaohua Li return 0; 227db350b08SShaohua Li if (!(info->valid & ACPI_VALID_HID)) 228db350b08SShaohua Li ret = 0; 229db350b08SShaohua Li else 23015b8dd53SBob Moore ret = !strcmp("PNP0C0A", info->hardware_id.string); 231db350b08SShaohua Li 23215b8dd53SBob Moore kfree(info); 233db350b08SShaohua Li return ret; 234db350b08SShaohua Li } 235db350b08SShaohua Li 236c9b5471fSJiang Liu /* Check whether ACPI object is an ejectable battery or disk bay */ 237c9b5471fSJiang Liu static bool __init is_ejectable_bay(acpi_handle handle) 238db350b08SShaohua Li { 239c9b5471fSJiang Liu if (acpi_has_method(handle, "_EJ0") && is_battery(handle)) 240c9b5471fSJiang Liu return true; 241747479a3SAlex Chiang 242c9b5471fSJiang Liu return acpi_bay_match(handle); 243db350b08SShaohua Li } 244db350b08SShaohua Li 245c8f7a62cSLen Brown /** 246c8f7a62cSLen Brown * is_dock_device - see if a device is on a dock station 247c8f7a62cSLen Brown * @handle: acpi handle of the device 248c8f7a62cSLen Brown * 249c8f7a62cSLen Brown * If this device is either the dock station itself, 250c8f7a62cSLen Brown * or is a device dependent on the dock station, then it 251c8f7a62cSLen Brown * is a dock device 252c8f7a62cSLen Brown */ 253c8f7a62cSLen Brown int is_dock_device(acpi_handle handle) 254c8f7a62cSLen Brown { 255db350b08SShaohua Li struct dock_station *dock_station; 256db350b08SShaohua Li 257db350b08SShaohua Li if (!dock_station_count) 258c8f7a62cSLen Brown return 0; 259c8f7a62cSLen Brown 260c9b5471fSJiang Liu if (acpi_dock_match(handle)) 261c8f7a62cSLen Brown return 1; 262747479a3SAlex Chiang 263747479a3SAlex Chiang list_for_each_entry(dock_station, &dock_stations, sibling) 264db350b08SShaohua Li if (find_dock_dependent_device(dock_station, handle)) 265db350b08SShaohua Li return 1; 266c8f7a62cSLen Brown 267c8f7a62cSLen Brown return 0; 268c8f7a62cSLen Brown } 269c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(is_dock_device); 270c8f7a62cSLen Brown 271c8f7a62cSLen Brown /** 272c8f7a62cSLen Brown * dock_present - see if the dock station is present. 273c8f7a62cSLen Brown * @ds: the dock station 274c8f7a62cSLen Brown * 275c8f7a62cSLen Brown * execute the _STA method. note that present does not 276c8f7a62cSLen Brown * imply that we are docked. 277c8f7a62cSLen Brown */ 278c8f7a62cSLen Brown static int dock_present(struct dock_station *ds) 279c8f7a62cSLen Brown { 28027663c58SMatthew Wilcox unsigned long long sta; 281c8f7a62cSLen Brown acpi_status status; 282c8f7a62cSLen Brown 283c8f7a62cSLen Brown if (ds) { 284c8f7a62cSLen Brown status = acpi_evaluate_integer(ds->handle, "_STA", NULL, &sta); 285c8f7a62cSLen Brown if (ACPI_SUCCESS(status) && sta) 286c8f7a62cSLen Brown return 1; 287c8f7a62cSLen Brown } 288c8f7a62cSLen Brown return 0; 289c8f7a62cSLen Brown } 290c8f7a62cSLen Brown 291c8f7a62cSLen Brown /** 292c8f7a62cSLen Brown * dock_create_acpi_device - add new devices to acpi 293c8f7a62cSLen Brown * @handle - handle of the device to add 294c8f7a62cSLen Brown * 295c8f7a62cSLen Brown * This function will create a new acpi_device for the given 296c8f7a62cSLen Brown * handle if one does not exist already. This should cause 297c8f7a62cSLen Brown * acpi to scan for drivers for the given devices, and call 298c8f7a62cSLen Brown * matching driver's add routine. 299c8f7a62cSLen Brown */ 300472d963bSJiang Liu static void dock_create_acpi_device(acpi_handle handle) 301c8f7a62cSLen Brown { 302747479a3SAlex Chiang struct acpi_device *device; 303c8f7a62cSLen Brown int ret; 304c8f7a62cSLen Brown 305c8f7a62cSLen Brown if (acpi_bus_get_device(handle, &device)) { 306c8f7a62cSLen Brown /* 307c8f7a62cSLen Brown * no device created for this object, 308c8f7a62cSLen Brown * so we should create one. 309c8f7a62cSLen Brown */ 310b8bd759aSRafael J. Wysocki ret = acpi_bus_scan(handle); 311636458deSRafael J. Wysocki if (ret) 312747479a3SAlex Chiang pr_debug("error adding bus, %x\n", -ret); 313c8f7a62cSLen Brown } 314c8f7a62cSLen Brown } 315c8f7a62cSLen Brown 316c8f7a62cSLen Brown /** 317c8f7a62cSLen Brown * dock_remove_acpi_device - remove the acpi_device struct from acpi 318c8f7a62cSLen Brown * @handle - the handle of the device to remove 319c8f7a62cSLen Brown * 320c8f7a62cSLen Brown * Tell acpi to remove the acpi_device. This should cause any loaded 321c8f7a62cSLen Brown * driver to have it's remove routine called. 322c8f7a62cSLen Brown */ 323c8f7a62cSLen Brown static void dock_remove_acpi_device(acpi_handle handle) 324c8f7a62cSLen Brown { 325c8f7a62cSLen Brown struct acpi_device *device; 326c8f7a62cSLen Brown 327bfee26dbSRafael J. Wysocki if (!acpi_bus_get_device(handle, &device)) 328bfee26dbSRafael J. Wysocki acpi_bus_trim(device); 329c8f7a62cSLen Brown } 330c8f7a62cSLen Brown 331c8f7a62cSLen Brown /** 33237f90877SRafael J. Wysocki * hot_remove_dock_devices - Remove dock station devices. 33337f90877SRafael J. Wysocki * @ds: Dock station. 33437f90877SRafael J. Wysocki */ 33537f90877SRafael J. Wysocki static void hot_remove_dock_devices(struct dock_station *ds) 33637f90877SRafael J. Wysocki { 33737f90877SRafael J. Wysocki struct dock_dependent_device *dd; 33837f90877SRafael J. Wysocki 33937f90877SRafael J. Wysocki /* 34037f90877SRafael J. Wysocki * Walk the list in reverse order so that devices that have been added 34137f90877SRafael J. Wysocki * last are removed first (in case there are some indirect dependencies 34237f90877SRafael J. Wysocki * between them). 34337f90877SRafael J. Wysocki */ 34437f90877SRafael J. Wysocki list_for_each_entry_reverse(dd, &ds->dependent_devices, list) 34537f90877SRafael J. Wysocki dock_hotplug_event(dd, ACPI_NOTIFY_EJECT_REQUEST, false); 34637f90877SRafael J. Wysocki 34737f90877SRafael J. Wysocki list_for_each_entry_reverse(dd, &ds->dependent_devices, list) 34837f90877SRafael J. Wysocki dock_remove_acpi_device(dd->handle); 34937f90877SRafael J. Wysocki } 35037f90877SRafael J. Wysocki 35137f90877SRafael J. Wysocki /** 35237f90877SRafael J. Wysocki * hotplug_dock_devices - Insert devices on a dock station. 353c8f7a62cSLen Brown * @ds: the dock station 35437f90877SRafael J. Wysocki * @event: either bus check or device check request 355c8f7a62cSLen Brown * 356c8f7a62cSLen Brown * Some devices on the dock station need to have drivers called 357c8f7a62cSLen Brown * to perform hotplug operations after a dock event has occurred. 358c8f7a62cSLen Brown * Traverse the list of dock devices that have registered a 359c8f7a62cSLen Brown * hotplug handler, and call the handler. 360c8f7a62cSLen Brown */ 361c8f7a62cSLen Brown static void hotplug_dock_devices(struct dock_station *ds, u32 event) 362c8f7a62cSLen Brown { 363c8f7a62cSLen Brown struct dock_dependent_device *dd; 364c8f7a62cSLen Brown 36537f90877SRafael J. Wysocki /* Call driver specific hotplug functions. */ 36621a31013SRafael J. Wysocki list_for_each_entry(dd, &ds->dependent_devices, list) 36721a31013SRafael J. Wysocki dock_hotplug_event(dd, event, false); 368c8f7a62cSLen Brown 369c8f7a62cSLen Brown /* 37037f90877SRafael J. Wysocki * Now make sure that an acpi_device is created for each dependent 37137f90877SRafael J. Wysocki * device. That will cause scan handlers to be attached to device 37237f90877SRafael J. Wysocki * objects or acpi_drivers to be stopped/started if they are present. 373c8f7a62cSLen Brown */ 37437f90877SRafael J. Wysocki list_for_each_entry(dd, &ds->dependent_devices, list) 375c8f7a62cSLen Brown dock_create_acpi_device(dd->handle); 376c8f7a62cSLen Brown } 377c8f7a62cSLen Brown 378c8f7a62cSLen Brown static void dock_event(struct dock_station *ds, u32 event, int num) 379c8f7a62cSLen Brown { 380db350b08SShaohua Li struct device *dev = &ds->dock_device->dev; 38166b56821SHolger Macht char event_string[13]; 38279a8f70bSKristen Carlson Accardi char *envp[] = { event_string, NULL }; 3831253f7aaSShaohua Li struct dock_dependent_device *dd; 38479a8f70bSKristen Carlson Accardi 38579a8f70bSKristen Carlson Accardi if (num == UNDOCK_EVENT) 38666b56821SHolger Macht sprintf(event_string, "EVENT=undock"); 38779a8f70bSKristen Carlson Accardi else 38866b56821SHolger Macht sprintf(event_string, "EVENT=dock"); 38979a8f70bSKristen Carlson Accardi 3905669021eSKristen Carlson Accardi /* 3918ea86e0bSKristen Carlson Accardi * Indicate that the status of the dock station has 3928ea86e0bSKristen Carlson Accardi * changed. 3935669021eSKristen Carlson Accardi */ 3941253f7aaSShaohua Li if (num == DOCK_EVENT) 3951253f7aaSShaohua Li kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp); 3961253f7aaSShaohua Li 39721a31013SRafael J. Wysocki list_for_each_entry(dd, &ds->dependent_devices, list) 39821a31013SRafael J. Wysocki dock_hotplug_event(dd, event, true); 399747479a3SAlex Chiang 4001253f7aaSShaohua Li if (num != DOCK_EVENT) 40179a8f70bSKristen Carlson Accardi kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp); 402c8f7a62cSLen Brown } 403c8f7a62cSLen Brown 404c8f7a62cSLen Brown /** 405c8f7a62cSLen Brown * handle_dock - handle a dock event 406c8f7a62cSLen Brown * @ds: the dock station 407c8f7a62cSLen Brown * @dock: to dock, or undock - that is the question 408c8f7a62cSLen Brown * 409c8f7a62cSLen Brown * Execute the _DCK method in response to an acpi event 410c8f7a62cSLen Brown */ 411c8f7a62cSLen Brown static void handle_dock(struct dock_station *ds, int dock) 412c8f7a62cSLen Brown { 413c8f7a62cSLen Brown acpi_status status; 414c8f7a62cSLen Brown struct acpi_object_list arg_list; 415c8f7a62cSLen Brown union acpi_object arg; 416c8f7a62cSLen Brown struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 417c8f7a62cSLen Brown 418cd73018fSToshi Kani acpi_handle_info(ds->handle, "%s\n", dock ? "docking" : "undocking"); 419c8f7a62cSLen Brown 420c8f7a62cSLen Brown /* _DCK method has one argument */ 421c8f7a62cSLen Brown arg_list.count = 1; 422c8f7a62cSLen Brown arg_list.pointer = &arg; 423c8f7a62cSLen Brown arg.type = ACPI_TYPE_INTEGER; 424c8f7a62cSLen Brown arg.integer.value = dock; 425c8f7a62cSLen Brown status = acpi_evaluate_object(ds->handle, "_DCK", &arg_list, &buffer); 426db350b08SShaohua Li if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) 427cd73018fSToshi Kani acpi_handle_err(ds->handle, "Failed to execute _DCK (0x%x)\n", 428cd73018fSToshi Kani status); 4290a918a94SThomas Renninger 430c8f7a62cSLen Brown kfree(buffer.pointer); 431c8f7a62cSLen Brown } 432c8f7a62cSLen Brown 433c8f7a62cSLen Brown static inline void dock(struct dock_station *ds) 434c8f7a62cSLen Brown { 435c8f7a62cSLen Brown handle_dock(ds, 1); 436c8f7a62cSLen Brown } 437c8f7a62cSLen Brown 438c8f7a62cSLen Brown static inline void undock(struct dock_station *ds) 439c8f7a62cSLen Brown { 440c8f7a62cSLen Brown handle_dock(ds, 0); 441c8f7a62cSLen Brown } 442c8f7a62cSLen Brown 443c8f7a62cSLen Brown static inline void begin_dock(struct dock_station *ds) 444c8f7a62cSLen Brown { 445c8f7a62cSLen Brown ds->flags |= DOCK_DOCKING; 446c8f7a62cSLen Brown } 447c8f7a62cSLen Brown 448c8f7a62cSLen Brown static inline void complete_dock(struct dock_station *ds) 449c8f7a62cSLen Brown { 450c8f7a62cSLen Brown ds->flags &= ~(DOCK_DOCKING); 451c8f7a62cSLen Brown ds->last_dock_time = jiffies; 452c8f7a62cSLen Brown } 453c8f7a62cSLen Brown 454a0cd35fdSKristen Carlson Accardi static inline void begin_undock(struct dock_station *ds) 455a0cd35fdSKristen Carlson Accardi { 456a0cd35fdSKristen Carlson Accardi ds->flags |= DOCK_UNDOCKING; 457a0cd35fdSKristen Carlson Accardi } 458a0cd35fdSKristen Carlson Accardi 459a0cd35fdSKristen Carlson Accardi static inline void complete_undock(struct dock_station *ds) 460a0cd35fdSKristen Carlson Accardi { 461a0cd35fdSKristen Carlson Accardi ds->flags &= ~(DOCK_UNDOCKING); 462a0cd35fdSKristen Carlson Accardi } 463a0cd35fdSKristen Carlson Accardi 464c8f7a62cSLen Brown /** 465c8f7a62cSLen Brown * dock_in_progress - see if we are in the middle of handling a dock event 466c8f7a62cSLen Brown * @ds: the dock station 467c8f7a62cSLen Brown * 468c8f7a62cSLen Brown * Sometimes while docking, false dock events can be sent to the driver 469c8f7a62cSLen Brown * because good connections aren't made or some other reason. Ignore these 470c8f7a62cSLen Brown * if we are in the middle of doing something. 471c8f7a62cSLen Brown */ 472c8f7a62cSLen Brown static int dock_in_progress(struct dock_station *ds) 473c8f7a62cSLen Brown { 474c8f7a62cSLen Brown if ((ds->flags & DOCK_DOCKING) || 475c8f7a62cSLen Brown time_before(jiffies, (ds->last_dock_time + HZ))) 476c8f7a62cSLen Brown return 1; 477c8f7a62cSLen Brown return 0; 478c8f7a62cSLen Brown } 479c8f7a62cSLen Brown 480c8f7a62cSLen Brown /** 481c8f7a62cSLen Brown * register_dock_notifier - add yourself to the dock notifier list 482c8f7a62cSLen Brown * @nb: the callers notifier block 483c8f7a62cSLen Brown * 484c8f7a62cSLen Brown * If a driver wishes to be notified about dock events, they can 485c8f7a62cSLen Brown * use this function to put a notifier block on the dock notifier list. 486c8f7a62cSLen Brown * this notifier call chain will be called after a dock event, but 487c8f7a62cSLen Brown * before hotplugging any new devices. 488c8f7a62cSLen Brown */ 489c8f7a62cSLen Brown int register_dock_notifier(struct notifier_block *nb) 490c8f7a62cSLen Brown { 491db350b08SShaohua Li if (!dock_station_count) 4922548c06bSPrarit Bhargava return -ENODEV; 4932548c06bSPrarit Bhargava 494c8f7a62cSLen Brown return atomic_notifier_chain_register(&dock_notifier_list, nb); 495c8f7a62cSLen Brown } 496c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(register_dock_notifier); 497c8f7a62cSLen Brown 498c8f7a62cSLen Brown /** 499c8f7a62cSLen Brown * unregister_dock_notifier - remove yourself from the dock notifier list 500c8f7a62cSLen Brown * @nb: the callers notifier block 501c8f7a62cSLen Brown */ 502c8f7a62cSLen Brown void unregister_dock_notifier(struct notifier_block *nb) 503c8f7a62cSLen Brown { 504db350b08SShaohua Li if (!dock_station_count) 5052548c06bSPrarit Bhargava return; 5062548c06bSPrarit Bhargava 507c8f7a62cSLen Brown atomic_notifier_chain_unregister(&dock_notifier_list, nb); 508c8f7a62cSLen Brown } 509c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(unregister_dock_notifier); 510c8f7a62cSLen Brown 511c8f7a62cSLen Brown /** 512c8f7a62cSLen Brown * register_hotplug_dock_device - register a hotplug function 513c8f7a62cSLen Brown * @handle: the handle of the device 5141253f7aaSShaohua Li * @ops: handlers to call after docking 515c8f7a62cSLen Brown * @context: device specific data 51621a31013SRafael J. Wysocki * @init: Optional initialization routine to run after registration 51721a31013SRafael J. Wysocki * @release: Optional release routine to run on unregistration 518c8f7a62cSLen Brown * 519c8f7a62cSLen Brown * If a driver would like to perform a hotplug operation after a dock 520c8f7a62cSLen Brown * event, they can register an acpi_notifiy_handler to be called by 521c8f7a62cSLen Brown * the dock driver after _DCK is executed. 522c8f7a62cSLen Brown */ 52321a31013SRafael J. Wysocki int register_hotplug_dock_device(acpi_handle handle, 52421a31013SRafael J. Wysocki const struct acpi_dock_ops *ops, void *context, 52521a31013SRafael J. Wysocki void (*init)(void *), void (*release)(void *)) 526c8f7a62cSLen Brown { 527c8f7a62cSLen Brown struct dock_dependent_device *dd; 528db350b08SShaohua Li struct dock_station *dock_station; 52961b83695SShaohua Li int ret = -EINVAL; 530c8f7a62cSLen Brown 53121a31013SRafael J. Wysocki if (WARN_ON(!context)) 53221a31013SRafael J. Wysocki return -EINVAL; 53321a31013SRafael J. Wysocki 534db350b08SShaohua Li if (!dock_station_count) 535c8f7a62cSLen Brown return -ENODEV; 536c8f7a62cSLen Brown 537c8f7a62cSLen Brown /* 538c8f7a62cSLen Brown * make sure this handle is for a device dependent on the dock, 539c8f7a62cSLen Brown * this would include the dock station itself 540c8f7a62cSLen Brown */ 54150d716e4SAlex Chiang list_for_each_entry(dock_station, &dock_stations, sibling) { 54261b83695SShaohua Li /* 54361b83695SShaohua Li * An ATA bay can be in a dock and itself can be ejected 5443ad2f3fbSDaniel Mack * separately, so there are two 'dock stations' which need the 54561b83695SShaohua Li * ops 54661b83695SShaohua Li */ 547c8f7a62cSLen Brown dd = find_dock_dependent_device(dock_station, handle); 54821a31013SRafael J. Wysocki if (dd && !dock_init_hotplug(dd, ops, context, init, release)) 54961b83695SShaohua Li ret = 0; 550c8f7a62cSLen Brown } 551c8f7a62cSLen Brown 55261b83695SShaohua Li return ret; 553c8f7a62cSLen Brown } 554c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(register_hotplug_dock_device); 555c8f7a62cSLen Brown 556c8f7a62cSLen Brown /** 557c8f7a62cSLen Brown * unregister_hotplug_dock_device - remove yourself from the hotplug list 558c8f7a62cSLen Brown * @handle: the acpi handle of the device 559c8f7a62cSLen Brown */ 560c8f7a62cSLen Brown void unregister_hotplug_dock_device(acpi_handle handle) 561c8f7a62cSLen Brown { 562c8f7a62cSLen Brown struct dock_dependent_device *dd; 563db350b08SShaohua Li struct dock_station *dock_station; 564c8f7a62cSLen Brown 565db350b08SShaohua Li if (!dock_station_count) 566c8f7a62cSLen Brown return; 567c8f7a62cSLen Brown 56850d716e4SAlex Chiang list_for_each_entry(dock_station, &dock_stations, sibling) { 569c8f7a62cSLen Brown dd = find_dock_dependent_device(dock_station, handle); 570c8f7a62cSLen Brown if (dd) 57121a31013SRafael J. Wysocki dock_release_hotplug(dd); 572c8f7a62cSLen Brown } 573db350b08SShaohua Li } 574c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(unregister_hotplug_dock_device); 575c8f7a62cSLen Brown 576c8f7a62cSLen Brown /** 577c80fdbe8Sbrandon@ifup.org * handle_eject_request - handle an undock request checking for error conditions 578c80fdbe8Sbrandon@ifup.org * 579c80fdbe8Sbrandon@ifup.org * Check to make sure the dock device is still present, then undock and 580c80fdbe8Sbrandon@ifup.org * hotremove all the devices that may need removing. 581c80fdbe8Sbrandon@ifup.org */ 582c80fdbe8Sbrandon@ifup.org static int handle_eject_request(struct dock_station *ds, u32 event) 583c80fdbe8Sbrandon@ifup.org { 584c80fdbe8Sbrandon@ifup.org if (dock_in_progress(ds)) 585c80fdbe8Sbrandon@ifup.org return -EBUSY; 586c80fdbe8Sbrandon@ifup.org 587c80fdbe8Sbrandon@ifup.org /* 588c80fdbe8Sbrandon@ifup.org * here we need to generate the undock 589c80fdbe8Sbrandon@ifup.org * event prior to actually doing the undock 590c80fdbe8Sbrandon@ifup.org * so that the device struct still exists. 591afd7301dSHolger Macht * Also, even send the dock event if the 592afd7301dSHolger Macht * device is not present anymore 593c80fdbe8Sbrandon@ifup.org */ 594c80fdbe8Sbrandon@ifup.org dock_event(ds, event, UNDOCK_EVENT); 595afd7301dSHolger Macht 59637f90877SRafael J. Wysocki hot_remove_dock_devices(ds); 597c80fdbe8Sbrandon@ifup.org undock(ds); 598c9b5471fSJiang Liu acpi_evaluate_lck(ds->handle, 0); 599c9b5471fSJiang Liu acpi_evaluate_ej0(ds->handle); 600c80fdbe8Sbrandon@ifup.org if (dock_present(ds)) { 601cd73018fSToshi Kani acpi_handle_err(ds->handle, "Unable to undock!\n"); 602c80fdbe8Sbrandon@ifup.org return -EBUSY; 603c80fdbe8Sbrandon@ifup.org } 604a0cd35fdSKristen Carlson Accardi complete_undock(ds); 605c80fdbe8Sbrandon@ifup.org return 0; 606c80fdbe8Sbrandon@ifup.org } 607c80fdbe8Sbrandon@ifup.org 608c80fdbe8Sbrandon@ifup.org /** 609c8f7a62cSLen Brown * dock_notify - act upon an acpi dock notification 610c8f7a62cSLen Brown * @handle: the dock station handle 611c8f7a62cSLen Brown * @event: the acpi event 612c8f7a62cSLen Brown * @data: our driver data struct 613c8f7a62cSLen Brown * 614c8f7a62cSLen Brown * If we are notified to dock, then check to see if the dock is 615c8f7a62cSLen Brown * present and then dock. Notify all drivers of the dock event, 616c80fdbe8Sbrandon@ifup.org * and then hotplug and devices that may need hotplugging. 617c8f7a62cSLen Brown */ 618c8f7a62cSLen Brown static void dock_notify(acpi_handle handle, u32 event, void *data) 619c8f7a62cSLen Brown { 62050dd0969SJan Engelhardt struct dock_station *ds = data; 6218b59560aSShaohua Li struct acpi_device *tmp; 622db350b08SShaohua Li int surprise_removal = 0; 623c8f7a62cSLen Brown 624db350b08SShaohua Li /* 625db350b08SShaohua Li * According to acpi spec 3.0a, if a DEVICE_CHECK notification 626db350b08SShaohua Li * is sent and _DCK is present, it is assumed to mean an undock 627db350b08SShaohua Li * request. 628db350b08SShaohua Li */ 629db350b08SShaohua Li if ((ds->flags & DOCK_IS_DOCK) && event == ACPI_NOTIFY_DEVICE_CHECK) 630db350b08SShaohua Li event = ACPI_NOTIFY_EJECT_REQUEST; 631db350b08SShaohua Li 632db350b08SShaohua Li /* 633db350b08SShaohua Li * dock station: BUS_CHECK - docked or surprise removal 634db350b08SShaohua Li * DEVICE_CHECK - undocked 635db350b08SShaohua Li * other device: BUS_CHECK/DEVICE_CHECK - added or surprise removal 636db350b08SShaohua Li * 637db350b08SShaohua Li * To simplify event handling, dock dependent device handler always 638db350b08SShaohua Li * get ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and 639db350b08SShaohua Li * ACPI_NOTIFY_EJECT_REQUEST for removal 640db350b08SShaohua Li */ 641c8f7a62cSLen Brown switch (event) { 642c8f7a62cSLen Brown case ACPI_NOTIFY_BUS_CHECK: 643db350b08SShaohua Li case ACPI_NOTIFY_DEVICE_CHECK: 6448b59560aSShaohua Li if (!dock_in_progress(ds) && acpi_bus_get_device(ds->handle, 6458b59560aSShaohua Li &tmp)) { 646c8f7a62cSLen Brown begin_dock(ds); 647c8f7a62cSLen Brown dock(ds); 648c8f7a62cSLen Brown if (!dock_present(ds)) { 649cd73018fSToshi Kani acpi_handle_err(handle, "Unable to dock!\n"); 6508b59560aSShaohua Li complete_dock(ds); 651c8f7a62cSLen Brown break; 652c8f7a62cSLen Brown } 653c8f7a62cSLen Brown atomic_notifier_call_chain(&dock_notifier_list, 654c8f7a62cSLen Brown event, NULL); 655c8f7a62cSLen Brown hotplug_dock_devices(ds, event); 656c8f7a62cSLen Brown complete_dock(ds); 657c8f7a62cSLen Brown dock_event(ds, event, DOCK_EVENT); 658c9b5471fSJiang Liu acpi_evaluate_lck(ds->handle, 1); 6593a37898dSLin Ming acpi_update_all_gpes(); 660c8f7a62cSLen Brown break; 661db350b08SShaohua Li } 662db350b08SShaohua Li if (dock_present(ds) || dock_in_progress(ds)) 663db350b08SShaohua Li break; 664db350b08SShaohua Li /* This is a surprise removal */ 665db350b08SShaohua Li surprise_removal = 1; 666db350b08SShaohua Li event = ACPI_NOTIFY_EJECT_REQUEST; 667db350b08SShaohua Li /* Fall back */ 668c8f7a62cSLen Brown case ACPI_NOTIFY_EJECT_REQUEST: 669a0cd35fdSKristen Carlson Accardi begin_undock(ds); 670f730ae18SShaohua Li if ((immediate_undock && !(ds->flags & DOCK_IS_ATA)) 671f730ae18SShaohua Li || surprise_removal) 672c80fdbe8Sbrandon@ifup.org handle_eject_request(ds, event); 673a0cd35fdSKristen Carlson Accardi else 674a0cd35fdSKristen Carlson Accardi dock_event(ds, event, UNDOCK_EVENT); 675c8f7a62cSLen Brown break; 676c8f7a62cSLen Brown default: 677cd73018fSToshi Kani acpi_handle_err(handle, "Unknown dock event %d\n", event); 678c8f7a62cSLen Brown } 679c8f7a62cSLen Brown } 680c8f7a62cSLen Brown 68119cd847aSZhang Rui struct dock_data { 68219cd847aSZhang Rui acpi_handle handle; 68319cd847aSZhang Rui unsigned long event; 68419cd847aSZhang Rui struct dock_station *ds; 68519cd847aSZhang Rui }; 68619cd847aSZhang Rui 68719cd847aSZhang Rui static void acpi_dock_deferred_cb(void *context) 68819cd847aSZhang Rui { 689747479a3SAlex Chiang struct dock_data *data = context; 69019cd847aSZhang Rui 6913757b948SRafael J. Wysocki acpi_scan_lock_acquire(); 69219cd847aSZhang Rui dock_notify(data->handle, data->event, data->ds); 6933757b948SRafael J. Wysocki acpi_scan_lock_release(); 69419cd847aSZhang Rui kfree(data); 69519cd847aSZhang Rui } 69619cd847aSZhang Rui 6976bd00a61SShaohua Li static int acpi_dock_notifier_call(struct notifier_block *this, 6986bd00a61SShaohua Li unsigned long event, void *data) 6996bd00a61SShaohua Li { 7006bd00a61SShaohua Li struct dock_station *dock_station; 701747479a3SAlex Chiang acpi_handle handle = data; 7026bd00a61SShaohua Li 7036bd00a61SShaohua Li if (event != ACPI_NOTIFY_BUS_CHECK && event != ACPI_NOTIFY_DEVICE_CHECK 7046bd00a61SShaohua Li && event != ACPI_NOTIFY_EJECT_REQUEST) 7056bd00a61SShaohua Li return 0; 7063757b948SRafael J. Wysocki 7073757b948SRafael J. Wysocki acpi_scan_lock_acquire(); 7083757b948SRafael J. Wysocki 70950d716e4SAlex Chiang list_for_each_entry(dock_station, &dock_stations, sibling) { 7106bd00a61SShaohua Li if (dock_station->handle == handle) { 711747479a3SAlex Chiang struct dock_data *dd; 7123757b948SRafael J. Wysocki acpi_status status; 71319cd847aSZhang Rui 714747479a3SAlex Chiang dd = kmalloc(sizeof(*dd), GFP_KERNEL); 715747479a3SAlex Chiang if (!dd) 7163757b948SRafael J. Wysocki break; 7173757b948SRafael J. Wysocki 718747479a3SAlex Chiang dd->handle = handle; 719747479a3SAlex Chiang dd->event = event; 720747479a3SAlex Chiang dd->ds = dock_station; 7213757b948SRafael J. Wysocki status = acpi_os_hotplug_execute(acpi_dock_deferred_cb, 7223757b948SRafael J. Wysocki dd); 7233757b948SRafael J. Wysocki if (ACPI_FAILURE(status)) 7243757b948SRafael J. Wysocki kfree(dd); 7253757b948SRafael J. Wysocki 7263757b948SRafael J. Wysocki break; 7276bd00a61SShaohua Li } 7286bd00a61SShaohua Li } 7293757b948SRafael J. Wysocki 7303757b948SRafael J. Wysocki acpi_scan_lock_release(); 7316bd00a61SShaohua Li return 0; 7326bd00a61SShaohua Li } 7336bd00a61SShaohua Li 7346bd00a61SShaohua Li static struct notifier_block dock_acpi_notifier = { 7356bd00a61SShaohua Li .notifier_call = acpi_dock_notifier_call, 7366bd00a61SShaohua Li }; 7376bd00a61SShaohua Li 738c8f7a62cSLen Brown /** 739c8f7a62cSLen Brown * find_dock_devices - find devices on the dock station 740c8f7a62cSLen Brown * @handle: the handle of the device we are examining 741c8f7a62cSLen Brown * @lvl: unused 742c8f7a62cSLen Brown * @context: the dock station private data 743c8f7a62cSLen Brown * @rv: unused 744c8f7a62cSLen Brown * 745c8f7a62cSLen Brown * This function is called by acpi_walk_namespace. It will 746c8f7a62cSLen Brown * check to see if an object has an _EJD method. If it does, then it 747c8f7a62cSLen Brown * will see if it is dependent on the dock station. 748c8f7a62cSLen Brown */ 74996c0a4d4SRafael J. Wysocki static acpi_status __init find_dock_devices(acpi_handle handle, u32 lvl, 75096c0a4d4SRafael J. Wysocki void *context, void **rv) 751c8f7a62cSLen Brown { 75250dd0969SJan Engelhardt struct dock_station *ds = context; 75396c0a4d4SRafael J. Wysocki acpi_handle ejd = NULL; 754c8f7a62cSLen Brown 75596c0a4d4SRafael J. Wysocki acpi_bus_get_ejd(handle, &ejd); 75696c0a4d4SRafael J. Wysocki if (ejd == ds->handle) 757f69cfdd2SAlex Chiang add_dock_dependent_device(ds, handle); 758f69cfdd2SAlex Chiang 759c8f7a62cSLen Brown return AE_OK; 760c8f7a62cSLen Brown } 761c8f7a62cSLen Brown 762c80fdbe8Sbrandon@ifup.org /* 763c80fdbe8Sbrandon@ifup.org * show_docked - read method for "docked" file in sysfs 764c80fdbe8Sbrandon@ifup.org */ 765c80fdbe8Sbrandon@ifup.org static ssize_t show_docked(struct device *dev, 766c80fdbe8Sbrandon@ifup.org struct device_attribute *attr, char *buf) 767c80fdbe8Sbrandon@ifup.org { 768fc5a9f88SHolger Macht struct acpi_device *tmp; 769fc5a9f88SHolger Macht 770fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 771c80fdbe8Sbrandon@ifup.org 77202df7349SYasuaki Ishimatsu if (!acpi_bus_get_device(dock_station->handle, &tmp)) 773fc5a9f88SHolger Macht return snprintf(buf, PAGE_SIZE, "1\n"); 774fc5a9f88SHolger Macht return snprintf(buf, PAGE_SIZE, "0\n"); 775c80fdbe8Sbrandon@ifup.org } 776e5685b9dSAdrian Bunk static DEVICE_ATTR(docked, S_IRUGO, show_docked, NULL); 777c80fdbe8Sbrandon@ifup.org 778c80fdbe8Sbrandon@ifup.org /* 779a0cd35fdSKristen Carlson Accardi * show_flags - read method for flags file in sysfs 780a0cd35fdSKristen Carlson Accardi */ 781a0cd35fdSKristen Carlson Accardi static ssize_t show_flags(struct device *dev, 782a0cd35fdSKristen Carlson Accardi struct device_attribute *attr, char *buf) 783a0cd35fdSKristen Carlson Accardi { 784fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 785a0cd35fdSKristen Carlson Accardi return snprintf(buf, PAGE_SIZE, "%d\n", dock_station->flags); 786a0cd35fdSKristen Carlson Accardi 787a0cd35fdSKristen Carlson Accardi } 788e5685b9dSAdrian Bunk static DEVICE_ATTR(flags, S_IRUGO, show_flags, NULL); 789a0cd35fdSKristen Carlson Accardi 790a0cd35fdSKristen Carlson Accardi /* 791c80fdbe8Sbrandon@ifup.org * write_undock - write method for "undock" file in sysfs 792c80fdbe8Sbrandon@ifup.org */ 793c80fdbe8Sbrandon@ifup.org static ssize_t write_undock(struct device *dev, struct device_attribute *attr, 794c80fdbe8Sbrandon@ifup.org const char *buf, size_t count) 795c80fdbe8Sbrandon@ifup.org { 796c80fdbe8Sbrandon@ifup.org int ret; 797fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 798c80fdbe8Sbrandon@ifup.org 799c80fdbe8Sbrandon@ifup.org if (!count) 800c80fdbe8Sbrandon@ifup.org return -EINVAL; 801c80fdbe8Sbrandon@ifup.org 8028112006fSRafael J. Wysocki acpi_scan_lock_acquire(); 8039171f834SHolger Macht begin_undock(dock_station); 804c80fdbe8Sbrandon@ifup.org ret = handle_eject_request(dock_station, ACPI_NOTIFY_EJECT_REQUEST); 8058112006fSRafael J. Wysocki acpi_scan_lock_release(); 806c80fdbe8Sbrandon@ifup.org return ret ? ret: count; 807c80fdbe8Sbrandon@ifup.org } 808e5685b9dSAdrian Bunk static DEVICE_ATTR(undock, S_IWUSR, NULL, write_undock); 809c80fdbe8Sbrandon@ifup.org 810ac122bb6SIlya A. Volynets-Evenbakh /* 811ac122bb6SIlya A. Volynets-Evenbakh * show_dock_uid - read method for "uid" file in sysfs 812ac122bb6SIlya A. Volynets-Evenbakh */ 813ac122bb6SIlya A. Volynets-Evenbakh static ssize_t show_dock_uid(struct device *dev, 814ac122bb6SIlya A. Volynets-Evenbakh struct device_attribute *attr, char *buf) 815ac122bb6SIlya A. Volynets-Evenbakh { 81627663c58SMatthew Wilcox unsigned long long lbuf; 817fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 81838ff4ffcSKristen Carlson Accardi acpi_status status = acpi_evaluate_integer(dock_station->handle, 81938ff4ffcSKristen Carlson Accardi "_UID", NULL, &lbuf); 82038ff4ffcSKristen Carlson Accardi if (ACPI_FAILURE(status)) 821ac122bb6SIlya A. Volynets-Evenbakh return 0; 82238ff4ffcSKristen Carlson Accardi 82327663c58SMatthew Wilcox return snprintf(buf, PAGE_SIZE, "%llx\n", lbuf); 824ac122bb6SIlya A. Volynets-Evenbakh } 825e5685b9dSAdrian Bunk static DEVICE_ATTR(uid, S_IRUGO, show_dock_uid, NULL); 826ac122bb6SIlya A. Volynets-Evenbakh 8278652b00fSShaohua Li static ssize_t show_dock_type(struct device *dev, 8288652b00fSShaohua Li struct device_attribute *attr, char *buf) 8298652b00fSShaohua Li { 830fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 8318652b00fSShaohua Li char *type; 8328652b00fSShaohua Li 8338652b00fSShaohua Li if (dock_station->flags & DOCK_IS_DOCK) 8348652b00fSShaohua Li type = "dock_station"; 8358652b00fSShaohua Li else if (dock_station->flags & DOCK_IS_ATA) 8368652b00fSShaohua Li type = "ata_bay"; 8378652b00fSShaohua Li else if (dock_station->flags & DOCK_IS_BAT) 8388652b00fSShaohua Li type = "battery_bay"; 8398652b00fSShaohua Li else 8408652b00fSShaohua Li type = "unknown"; 8418652b00fSShaohua Li 8428652b00fSShaohua Li return snprintf(buf, PAGE_SIZE, "%s\n", type); 8438652b00fSShaohua Li } 8448652b00fSShaohua Li static DEVICE_ATTR(type, S_IRUGO, show_dock_type, NULL); 8458652b00fSShaohua Li 8465f46c2f2SAlex Chiang static struct attribute *dock_attributes[] = { 8475f46c2f2SAlex Chiang &dev_attr_docked.attr, 8485f46c2f2SAlex Chiang &dev_attr_flags.attr, 8495f46c2f2SAlex Chiang &dev_attr_undock.attr, 8505f46c2f2SAlex Chiang &dev_attr_uid.attr, 8515f46c2f2SAlex Chiang &dev_attr_type.attr, 8525f46c2f2SAlex Chiang NULL 8535f46c2f2SAlex Chiang }; 8545f46c2f2SAlex Chiang 8555f46c2f2SAlex Chiang static struct attribute_group dock_attribute_group = { 8565f46c2f2SAlex Chiang .attrs = dock_attributes 8575f46c2f2SAlex Chiang }; 8585f46c2f2SAlex Chiang 859c8f7a62cSLen Brown /** 860c8f7a62cSLen Brown * dock_add - add a new dock station 861c8f7a62cSLen Brown * @handle: the dock station handle 862c8f7a62cSLen Brown * 863c8f7a62cSLen Brown * allocated and initialize a new dock station device. Find all devices 864c8f7a62cSLen Brown * that are on the dock station, and register for dock event notifications. 865c8f7a62cSLen Brown */ 866d38a5edfSUwe Kleine-König static int __init dock_add(acpi_handle handle) 867c8f7a62cSLen Brown { 868fe06fba2SAlex Chiang int ret, id; 869fe06fba2SAlex Chiang struct dock_station ds, *dock_station; 870747479a3SAlex Chiang struct platform_device *dd; 871c8f7a62cSLen Brown 872fe06fba2SAlex Chiang id = dock_station_count; 87349c6fb2eSAlex Chiang memset(&ds, 0, sizeof(ds)); 874747479a3SAlex Chiang dd = platform_device_register_data(NULL, "dock", id, &ds, sizeof(ds)); 875747479a3SAlex Chiang if (IS_ERR(dd)) 876747479a3SAlex Chiang return PTR_ERR(dd); 8779751cb72SAlex Chiang 878747479a3SAlex Chiang dock_station = dd->dev.platform_data; 879747479a3SAlex Chiang 880c8f7a62cSLen Brown dock_station->handle = handle; 881747479a3SAlex Chiang dock_station->dock_device = dd; 882c8f7a62cSLen Brown dock_station->last_dock_time = jiffies - HZ; 883c8f7a62cSLen Brown 884747479a3SAlex Chiang INIT_LIST_HEAD(&dock_station->sibling); 885747479a3SAlex Chiang INIT_LIST_HEAD(&dock_station->dependent_devices); 886a0cd35fdSKristen Carlson Accardi 8879ef2a9a9SKristen Carlson Accardi /* we want the dock device to send uevents */ 888747479a3SAlex Chiang dev_set_uevent_suppress(&dd->dev, 0); 8899ef2a9a9SKristen Carlson Accardi 890c9b5471fSJiang Liu if (acpi_dock_match(handle)) 891db350b08SShaohua Li dock_station->flags |= DOCK_IS_DOCK; 892c9b5471fSJiang Liu if (acpi_ata_match(handle)) 893db350b08SShaohua Li dock_station->flags |= DOCK_IS_ATA; 894db350b08SShaohua Li if (is_battery(handle)) 895db350b08SShaohua Li dock_station->flags |= DOCK_IS_BAT; 896db350b08SShaohua Li 897747479a3SAlex Chiang ret = sysfs_create_group(&dd->dev.kobj, &dock_attribute_group); 8988652b00fSShaohua Li if (ret) 8995f46c2f2SAlex Chiang goto err_unregister; 900671adbecSKristen Carlson Accardi 901c8f7a62cSLen Brown /* Find dependent devices */ 902c8f7a62cSLen Brown acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 9032263576cSLin Ming ACPI_UINT32_MAX, find_dock_devices, NULL, 9042263576cSLin Ming dock_station, NULL); 905c8f7a62cSLen Brown 906c8f7a62cSLen Brown /* add the dock station as a device dependent on itself */ 907f69cfdd2SAlex Chiang ret = add_dock_dependent_device(dock_station, handle); 908f69cfdd2SAlex Chiang if (ret) 9095f46c2f2SAlex Chiang goto err_rmgroup; 910c8f7a62cSLen Brown 911db350b08SShaohua Li dock_station_count++; 91250d716e4SAlex Chiang list_add(&dock_station->sibling, &dock_stations); 913c8f7a62cSLen Brown return 0; 914c8f7a62cSLen Brown 9155f46c2f2SAlex Chiang err_rmgroup: 916747479a3SAlex Chiang sysfs_remove_group(&dd->dev.kobj, &dock_attribute_group); 9175f46c2f2SAlex Chiang err_unregister: 918747479a3SAlex Chiang platform_device_unregister(dd); 919cd73018fSToshi Kani acpi_handle_err(handle, "%s encountered error %d\n", __func__, ret); 920c8f7a62cSLen Brown return ret; 921c8f7a62cSLen Brown } 922c8f7a62cSLen Brown 923c8f7a62cSLen Brown /** 9248ab0ab25SToshi Kani * find_dock_and_bay - look for dock stations and bays 925c8f7a62cSLen Brown * @handle: acpi handle of a device 926c8f7a62cSLen Brown * @lvl: unused 9278ab0ab25SToshi Kani * @context: unused 928c8f7a62cSLen Brown * @rv: unused 929c8f7a62cSLen Brown * 9308ab0ab25SToshi Kani * This is called by acpi_walk_namespace to look for dock stations and bays. 931c8f7a62cSLen Brown */ 932d38a5edfSUwe Kleine-König static __init acpi_status 9338ab0ab25SToshi Kani find_dock_and_bay(acpi_handle handle, u32 lvl, void *context, void **rv) 934c8f7a62cSLen Brown { 935c9b5471fSJiang Liu if (acpi_dock_match(handle) || is_ejectable_bay(handle)) 9361ee4d61fSZhang Rui dock_add(handle); 937747479a3SAlex Chiang 9381ee4d61fSZhang Rui return AE_OK; 939c8f7a62cSLen Brown } 940c8f7a62cSLen Brown 9412ce65fe8SRafael J. Wysocki void __init acpi_dock_init(void) 942c8f7a62cSLen Brown { 943816c2edaSLen Brown if (acpi_disabled) 9442ce65fe8SRafael J. Wysocki return; 945816c2edaSLen Brown 9468ab0ab25SToshi Kani /* look for dock stations and bays */ 947c8f7a62cSLen Brown acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 9488ab0ab25SToshi Kani ACPI_UINT32_MAX, find_dock_and_bay, NULL, NULL, NULL); 949c8f7a62cSLen Brown 950db350b08SShaohua Li if (!dock_station_count) { 951cd73018fSToshi Kani pr_info(PREFIX "No dock devices found.\n"); 9522ce65fe8SRafael J. Wysocki return; 953db350b08SShaohua Li } 954c8f7a62cSLen Brown 955f22ff552SJiang Liu ATOMIC_INIT_NOTIFIER_HEAD(&dock_notifier_list); 9566bd00a61SShaohua Li register_acpi_bus_notifier(&dock_acpi_notifier); 957cd73018fSToshi Kani pr_info(PREFIX "%s: %d docks/bays found\n", 958db350b08SShaohua Li ACPI_DOCK_DRIVER_DESCRIPTION, dock_station_count); 959c8f7a62cSLen Brown } 960