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 spinlock_t dd_lock; 678b0dc866SKristen Carlson Accardi struct mutex hp_lock; 68c8f7a62cSLen Brown struct list_head dependent_devices; 69db350b08SShaohua Li 7050d716e4SAlex Chiang struct list_head sibling; 71db350b08SShaohua Li struct platform_device *dock_device; 72c8f7a62cSLen Brown }; 73db350b08SShaohua Li static LIST_HEAD(dock_stations); 74db350b08SShaohua Li static int dock_station_count; 7521a31013SRafael J. Wysocki static DEFINE_MUTEX(hotplug_lock); 76c8f7a62cSLen Brown 77c8f7a62cSLen Brown struct dock_dependent_device { 78c8f7a62cSLen Brown struct list_head list; 79c8f7a62cSLen Brown acpi_handle handle; 8021a31013SRafael J. Wysocki const struct acpi_dock_ops *hp_ops; 8121a31013SRafael J. Wysocki void *hp_context; 8221a31013SRafael J. Wysocki unsigned int hp_refcount; 8321a31013SRafael J. Wysocki void (*hp_release)(void *); 84c8f7a62cSLen Brown }; 85c8f7a62cSLen Brown 86c8f7a62cSLen Brown #define DOCK_DOCKING 0x00000001 87a0cd35fdSKristen Carlson Accardi #define DOCK_UNDOCKING 0x00000002 88db350b08SShaohua Li #define DOCK_IS_DOCK 0x00000010 89db350b08SShaohua Li #define DOCK_IS_ATA 0x00000020 90db350b08SShaohua Li #define DOCK_IS_BAT 0x00000040 915669021eSKristen Carlson Accardi #define DOCK_EVENT 3 925669021eSKristen Carlson Accardi #define UNDOCK_EVENT 2 93c8f7a62cSLen Brown 94c8f7a62cSLen Brown /***************************************************************************** 95c8f7a62cSLen Brown * Dock Dependent device functions * 96c8f7a62cSLen Brown *****************************************************************************/ 97c8f7a62cSLen Brown /** 98f69cfdd2SAlex Chiang * add_dock_dependent_device - associate a device with the dock station 99f69cfdd2SAlex Chiang * @ds: The dock station 100f69cfdd2SAlex Chiang * @handle: handle of the dependent device 101c8f7a62cSLen Brown * 102f69cfdd2SAlex Chiang * Add the dependent device to the dock's dependent device list. 103c8f7a62cSLen Brown */ 104f69cfdd2SAlex Chiang static int 105f69cfdd2SAlex Chiang add_dock_dependent_device(struct dock_station *ds, acpi_handle handle) 106c8f7a62cSLen Brown { 107c8f7a62cSLen Brown struct dock_dependent_device *dd; 108c8f7a62cSLen Brown 109c8f7a62cSLen Brown dd = kzalloc(sizeof(*dd), GFP_KERNEL); 110f69cfdd2SAlex Chiang if (!dd) 111f69cfdd2SAlex Chiang return -ENOMEM; 112f69cfdd2SAlex Chiang 113c8f7a62cSLen Brown dd->handle = handle; 114c8f7a62cSLen Brown INIT_LIST_HEAD(&dd->list); 115c8f7a62cSLen Brown 116c8f7a62cSLen Brown spin_lock(&ds->dd_lock); 117c8f7a62cSLen Brown list_add_tail(&dd->list, &ds->dependent_devices); 118c8f7a62cSLen Brown spin_unlock(&ds->dd_lock); 119f69cfdd2SAlex Chiang 120f69cfdd2SAlex Chiang return 0; 121c8f7a62cSLen Brown } 122c8f7a62cSLen Brown 123c8f7a62cSLen Brown /** 12421a31013SRafael J. Wysocki * dock_init_hotplug - Initialize a hotplug device on a docking station. 12521a31013SRafael J. Wysocki * @dd: Dock-dependent device. 12621a31013SRafael J. Wysocki * @ops: Dock operations to attach to the dependent device. 12721a31013SRafael J. Wysocki * @context: Data to pass to the @ops callbacks and @release. 12821a31013SRafael J. Wysocki * @init: Optional initialization routine to run after setting up context. 12921a31013SRafael J. Wysocki * @release: Optional release routine to run on removal. 130c8f7a62cSLen Brown */ 13121a31013SRafael J. Wysocki static int dock_init_hotplug(struct dock_dependent_device *dd, 13221a31013SRafael J. Wysocki const struct acpi_dock_ops *ops, void *context, 13321a31013SRafael J. Wysocki void (*init)(void *), void (*release)(void *)) 134c8f7a62cSLen Brown { 13521a31013SRafael J. Wysocki int ret = 0; 13621a31013SRafael J. Wysocki 13721a31013SRafael J. Wysocki mutex_lock(&hotplug_lock); 13821a31013SRafael J. Wysocki 13921a31013SRafael J. Wysocki if (dd->hp_context) { 14021a31013SRafael J. Wysocki ret = -EEXIST; 14121a31013SRafael J. Wysocki } else { 14221a31013SRafael J. Wysocki dd->hp_refcount = 1; 14321a31013SRafael J. Wysocki dd->hp_ops = ops; 14421a31013SRafael J. Wysocki dd->hp_context = context; 14521a31013SRafael J. Wysocki dd->hp_release = release; 14621a31013SRafael J. Wysocki } 14721a31013SRafael J. Wysocki 14821a31013SRafael J. Wysocki if (!WARN_ON(ret) && init) 14921a31013SRafael J. Wysocki init(context); 15021a31013SRafael J. Wysocki 15121a31013SRafael J. Wysocki mutex_unlock(&hotplug_lock); 15221a31013SRafael J. Wysocki return ret; 153c8f7a62cSLen Brown } 154c8f7a62cSLen Brown 155c8f7a62cSLen Brown /** 15621a31013SRafael J. Wysocki * dock_release_hotplug - Decrement hotplug reference counter of dock device. 15721a31013SRafael J. Wysocki * @dd: Dock-dependent device. 158c8f7a62cSLen Brown * 15921a31013SRafael J. Wysocki * Decrement the reference counter of @dd and if 0, detach its hotplug 16021a31013SRafael J. Wysocki * operations from it, reset its context pointer and run the optional release 16121a31013SRafael J. Wysocki * routine if present. 162c8f7a62cSLen Brown */ 16321a31013SRafael J. Wysocki static void dock_release_hotplug(struct dock_dependent_device *dd) 164c8f7a62cSLen Brown { 16521a31013SRafael J. Wysocki void (*release)(void *) = NULL; 16621a31013SRafael J. Wysocki void *context = NULL; 16721a31013SRafael J. Wysocki 16821a31013SRafael J. Wysocki mutex_lock(&hotplug_lock); 16921a31013SRafael J. Wysocki 17021a31013SRafael J. Wysocki if (dd->hp_context && !--dd->hp_refcount) { 17121a31013SRafael J. Wysocki dd->hp_ops = NULL; 17221a31013SRafael J. Wysocki context = dd->hp_context; 17321a31013SRafael J. Wysocki dd->hp_context = NULL; 17421a31013SRafael J. Wysocki release = dd->hp_release; 17521a31013SRafael J. Wysocki dd->hp_release = NULL; 17621a31013SRafael J. Wysocki } 17721a31013SRafael J. Wysocki 17821a31013SRafael J. Wysocki if (release && context) 17921a31013SRafael J. Wysocki release(context); 18021a31013SRafael J. Wysocki 18121a31013SRafael J. Wysocki mutex_unlock(&hotplug_lock); 18221a31013SRafael J. Wysocki } 18321a31013SRafael J. Wysocki 18421a31013SRafael J. Wysocki static void dock_hotplug_event(struct dock_dependent_device *dd, u32 event, 18521a31013SRafael J. Wysocki bool uevent) 18621a31013SRafael J. Wysocki { 18721a31013SRafael J. Wysocki acpi_notify_handler cb = NULL; 18821a31013SRafael J. Wysocki bool run = false; 18921a31013SRafael J. Wysocki 19021a31013SRafael J. Wysocki mutex_lock(&hotplug_lock); 19121a31013SRafael J. Wysocki 19221a31013SRafael J. Wysocki if (dd->hp_context) { 19321a31013SRafael J. Wysocki run = true; 19421a31013SRafael J. Wysocki dd->hp_refcount++; 19521a31013SRafael J. Wysocki if (dd->hp_ops) 19621a31013SRafael J. Wysocki cb = uevent ? dd->hp_ops->uevent : dd->hp_ops->handler; 19721a31013SRafael J. Wysocki } 19821a31013SRafael J. Wysocki 19921a31013SRafael J. Wysocki mutex_unlock(&hotplug_lock); 20021a31013SRafael J. Wysocki 20121a31013SRafael J. Wysocki if (!run) 20221a31013SRafael J. Wysocki return; 20321a31013SRafael J. Wysocki 20421a31013SRafael J. Wysocki if (cb) 20521a31013SRafael J. Wysocki cb(dd->handle, event, dd->hp_context); 20621a31013SRafael J. Wysocki 20721a31013SRafael J. Wysocki dock_release_hotplug(dd); 208c8f7a62cSLen Brown } 209c8f7a62cSLen Brown 210c8f7a62cSLen Brown /** 211c8f7a62cSLen Brown * find_dock_dependent_device - get a device dependent on this dock 212c8f7a62cSLen Brown * @ds: the dock station 213c8f7a62cSLen Brown * @handle: the acpi_handle of the device we want 214c8f7a62cSLen Brown * 215c8f7a62cSLen Brown * iterate over the dependent device list for this dock. If the 216c8f7a62cSLen Brown * dependent device matches the handle, return. 217c8f7a62cSLen Brown */ 218c8f7a62cSLen Brown static struct dock_dependent_device * 219c8f7a62cSLen Brown find_dock_dependent_device(struct dock_station *ds, acpi_handle handle) 220c8f7a62cSLen Brown { 221c8f7a62cSLen Brown struct dock_dependent_device *dd; 222c8f7a62cSLen Brown 223c8f7a62cSLen Brown spin_lock(&ds->dd_lock); 224c8f7a62cSLen Brown list_for_each_entry(dd, &ds->dependent_devices, list) { 225c8f7a62cSLen Brown if (handle == dd->handle) { 226c8f7a62cSLen Brown spin_unlock(&ds->dd_lock); 227c8f7a62cSLen Brown return dd; 228c8f7a62cSLen Brown } 229c8f7a62cSLen Brown } 230c8f7a62cSLen Brown spin_unlock(&ds->dd_lock); 231c8f7a62cSLen Brown return NULL; 232c8f7a62cSLen Brown } 233c8f7a62cSLen Brown 234c8f7a62cSLen Brown /***************************************************************************** 235c8f7a62cSLen Brown * Dock functions * 236c8f7a62cSLen Brown *****************************************************************************/ 237c8f7a62cSLen Brown /** 238c8f7a62cSLen Brown * is_dock - see if a device is a dock station 239c8f7a62cSLen Brown * @handle: acpi handle of the device 240c8f7a62cSLen Brown * 241c8f7a62cSLen Brown * If an acpi object has a _DCK method, then it is by definition a dock 242c8f7a62cSLen Brown * station, so return true. 243c8f7a62cSLen Brown */ 244c8f7a62cSLen Brown static int is_dock(acpi_handle handle) 245c8f7a62cSLen Brown { 246c8f7a62cSLen Brown acpi_status status; 247c8f7a62cSLen Brown acpi_handle tmp; 248c8f7a62cSLen Brown 249c8f7a62cSLen Brown status = acpi_get_handle(handle, "_DCK", &tmp); 250c8f7a62cSLen Brown if (ACPI_FAILURE(status)) 251c8f7a62cSLen Brown return 0; 252c8f7a62cSLen Brown return 1; 253c8f7a62cSLen Brown } 254c8f7a62cSLen Brown 255db350b08SShaohua Li static int is_ejectable(acpi_handle handle) 256db350b08SShaohua Li { 257db350b08SShaohua Li acpi_status status; 258db350b08SShaohua Li acpi_handle tmp; 259db350b08SShaohua Li 260db350b08SShaohua Li status = acpi_get_handle(handle, "_EJ0", &tmp); 261db350b08SShaohua Li if (ACPI_FAILURE(status)) 262db350b08SShaohua Li return 0; 263db350b08SShaohua Li return 1; 264db350b08SShaohua Li } 265db350b08SShaohua Li 266db350b08SShaohua Li static int is_ata(acpi_handle handle) 267db350b08SShaohua Li { 268db350b08SShaohua Li acpi_handle tmp; 269db350b08SShaohua Li 270db350b08SShaohua Li if ((ACPI_SUCCESS(acpi_get_handle(handle, "_GTF", &tmp))) || 271db350b08SShaohua Li (ACPI_SUCCESS(acpi_get_handle(handle, "_GTM", &tmp))) || 272db350b08SShaohua Li (ACPI_SUCCESS(acpi_get_handle(handle, "_STM", &tmp))) || 273db350b08SShaohua Li (ACPI_SUCCESS(acpi_get_handle(handle, "_SDD", &tmp)))) 274db350b08SShaohua Li return 1; 275db350b08SShaohua Li 276db350b08SShaohua Li return 0; 277db350b08SShaohua Li } 278db350b08SShaohua Li 279db350b08SShaohua Li static int is_battery(acpi_handle handle) 280db350b08SShaohua Li { 281db350b08SShaohua Li struct acpi_device_info *info; 282db350b08SShaohua Li int ret = 1; 283db350b08SShaohua Li 28415b8dd53SBob Moore if (!ACPI_SUCCESS(acpi_get_object_info(handle, &info))) 285db350b08SShaohua Li return 0; 286db350b08SShaohua Li if (!(info->valid & ACPI_VALID_HID)) 287db350b08SShaohua Li ret = 0; 288db350b08SShaohua Li else 28915b8dd53SBob Moore ret = !strcmp("PNP0C0A", info->hardware_id.string); 290db350b08SShaohua Li 29115b8dd53SBob Moore kfree(info); 292db350b08SShaohua Li return ret; 293db350b08SShaohua Li } 294db350b08SShaohua Li 295db350b08SShaohua Li static int is_ejectable_bay(acpi_handle handle) 296db350b08SShaohua Li { 297db350b08SShaohua Li acpi_handle phandle; 298747479a3SAlex Chiang 299db350b08SShaohua Li if (!is_ejectable(handle)) 300db350b08SShaohua Li return 0; 301db350b08SShaohua Li if (is_battery(handle) || is_ata(handle)) 302db350b08SShaohua Li return 1; 303db350b08SShaohua Li if (!acpi_get_parent(handle, &phandle) && is_ata(phandle)) 304db350b08SShaohua Li return 1; 305db350b08SShaohua Li return 0; 306db350b08SShaohua Li } 307db350b08SShaohua Li 308c8f7a62cSLen Brown /** 309c8f7a62cSLen Brown * is_dock_device - see if a device is on a dock station 310c8f7a62cSLen Brown * @handle: acpi handle of the device 311c8f7a62cSLen Brown * 312c8f7a62cSLen Brown * If this device is either the dock station itself, 313c8f7a62cSLen Brown * or is a device dependent on the dock station, then it 314c8f7a62cSLen Brown * is a dock device 315c8f7a62cSLen Brown */ 316c8f7a62cSLen Brown int is_dock_device(acpi_handle handle) 317c8f7a62cSLen Brown { 318db350b08SShaohua Li struct dock_station *dock_station; 319db350b08SShaohua Li 320db350b08SShaohua Li if (!dock_station_count) 321c8f7a62cSLen Brown return 0; 322c8f7a62cSLen Brown 323db350b08SShaohua Li if (is_dock(handle)) 324c8f7a62cSLen Brown return 1; 325747479a3SAlex Chiang 326747479a3SAlex Chiang list_for_each_entry(dock_station, &dock_stations, sibling) 327db350b08SShaohua Li if (find_dock_dependent_device(dock_station, handle)) 328db350b08SShaohua Li return 1; 329c8f7a62cSLen Brown 330c8f7a62cSLen Brown return 0; 331c8f7a62cSLen Brown } 332c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(is_dock_device); 333c8f7a62cSLen Brown 334c8f7a62cSLen Brown /** 335c8f7a62cSLen Brown * dock_present - see if the dock station is present. 336c8f7a62cSLen Brown * @ds: the dock station 337c8f7a62cSLen Brown * 338c8f7a62cSLen Brown * execute the _STA method. note that present does not 339c8f7a62cSLen Brown * imply that we are docked. 340c8f7a62cSLen Brown */ 341c8f7a62cSLen Brown static int dock_present(struct dock_station *ds) 342c8f7a62cSLen Brown { 34327663c58SMatthew Wilcox unsigned long long sta; 344c8f7a62cSLen Brown acpi_status status; 345c8f7a62cSLen Brown 346c8f7a62cSLen Brown if (ds) { 347c8f7a62cSLen Brown status = acpi_evaluate_integer(ds->handle, "_STA", NULL, &sta); 348c8f7a62cSLen Brown if (ACPI_SUCCESS(status) && sta) 349c8f7a62cSLen Brown return 1; 350c8f7a62cSLen Brown } 351c8f7a62cSLen Brown return 0; 352c8f7a62cSLen Brown } 353c8f7a62cSLen Brown 354c8f7a62cSLen Brown /** 355c8f7a62cSLen Brown * dock_create_acpi_device - add new devices to acpi 356c8f7a62cSLen Brown * @handle - handle of the device to add 357c8f7a62cSLen Brown * 358c8f7a62cSLen Brown * This function will create a new acpi_device for the given 359c8f7a62cSLen Brown * handle if one does not exist already. This should cause 360c8f7a62cSLen Brown * acpi to scan for drivers for the given devices, and call 361c8f7a62cSLen Brown * matching driver's add routine. 362c8f7a62cSLen Brown * 363c8f7a62cSLen Brown * Returns a pointer to the acpi_device corresponding to the handle. 364c8f7a62cSLen Brown */ 365c8f7a62cSLen Brown static struct acpi_device * dock_create_acpi_device(acpi_handle handle) 366c8f7a62cSLen Brown { 367747479a3SAlex Chiang struct acpi_device *device; 368c8f7a62cSLen Brown int ret; 369c8f7a62cSLen Brown 370c8f7a62cSLen Brown if (acpi_bus_get_device(handle, &device)) { 371c8f7a62cSLen Brown /* 372c8f7a62cSLen Brown * no device created for this object, 373c8f7a62cSLen Brown * so we should create one. 374c8f7a62cSLen Brown */ 375b8bd759aSRafael J. Wysocki ret = acpi_bus_scan(handle); 376636458deSRafael J. Wysocki if (ret) 377747479a3SAlex Chiang pr_debug("error adding bus, %x\n", -ret); 3780cd6ac52SRafael J. Wysocki 3790cd6ac52SRafael J. Wysocki acpi_bus_get_device(handle, &device); 380c8f7a62cSLen Brown } 381c8f7a62cSLen Brown return device; 382c8f7a62cSLen Brown } 383c8f7a62cSLen Brown 384c8f7a62cSLen Brown /** 385c8f7a62cSLen Brown * dock_remove_acpi_device - remove the acpi_device struct from acpi 386c8f7a62cSLen Brown * @handle - the handle of the device to remove 387c8f7a62cSLen Brown * 388c8f7a62cSLen Brown * Tell acpi to remove the acpi_device. This should cause any loaded 389c8f7a62cSLen Brown * driver to have it's remove routine called. 390c8f7a62cSLen Brown */ 391c8f7a62cSLen Brown static void dock_remove_acpi_device(acpi_handle handle) 392c8f7a62cSLen Brown { 393c8f7a62cSLen Brown struct acpi_device *device; 394c8f7a62cSLen Brown 395bfee26dbSRafael J. Wysocki if (!acpi_bus_get_device(handle, &device)) 396bfee26dbSRafael J. Wysocki acpi_bus_trim(device); 397c8f7a62cSLen Brown } 398c8f7a62cSLen Brown 399c8f7a62cSLen Brown /** 400c8f7a62cSLen Brown * hotplug_dock_devices - insert or remove devices on the dock station 401c8f7a62cSLen Brown * @ds: the dock station 402c8f7a62cSLen Brown * @event: either bus check or eject request 403c8f7a62cSLen Brown * 404c8f7a62cSLen Brown * Some devices on the dock station need to have drivers called 405c8f7a62cSLen Brown * to perform hotplug operations after a dock event has occurred. 406c8f7a62cSLen Brown * Traverse the list of dock devices that have registered a 407c8f7a62cSLen Brown * hotplug handler, and call the handler. 408c8f7a62cSLen Brown */ 409c8f7a62cSLen Brown static void hotplug_dock_devices(struct dock_station *ds, u32 event) 410c8f7a62cSLen Brown { 411c8f7a62cSLen Brown struct dock_dependent_device *dd; 412c8f7a62cSLen Brown 4138b0dc866SKristen Carlson Accardi mutex_lock(&ds->hp_lock); 414c8f7a62cSLen Brown 415c8f7a62cSLen Brown /* 416c8f7a62cSLen Brown * First call driver specific hotplug functions 417c8f7a62cSLen Brown */ 41821a31013SRafael J. Wysocki list_for_each_entry(dd, &ds->dependent_devices, list) 41921a31013SRafael J. Wysocki dock_hotplug_event(dd, event, false); 420c8f7a62cSLen Brown 421c8f7a62cSLen Brown /* 422c8f7a62cSLen Brown * Now make sure that an acpi_device is created for each 423c8f7a62cSLen Brown * dependent device, or removed if this is an eject request. 424c8f7a62cSLen Brown * This will cause acpi_drivers to be stopped/started if they 425c8f7a62cSLen Brown * exist 426c8f7a62cSLen Brown */ 427c8f7a62cSLen Brown list_for_each_entry(dd, &ds->dependent_devices, list) { 428c8f7a62cSLen Brown if (event == ACPI_NOTIFY_EJECT_REQUEST) 429c8f7a62cSLen Brown dock_remove_acpi_device(dd->handle); 430c8f7a62cSLen Brown else 431c8f7a62cSLen Brown dock_create_acpi_device(dd->handle); 432c8f7a62cSLen Brown } 4338b0dc866SKristen Carlson Accardi mutex_unlock(&ds->hp_lock); 434c8f7a62cSLen Brown } 435c8f7a62cSLen Brown 436c8f7a62cSLen Brown static void dock_event(struct dock_station *ds, u32 event, int num) 437c8f7a62cSLen Brown { 438db350b08SShaohua Li struct device *dev = &ds->dock_device->dev; 43966b56821SHolger Macht char event_string[13]; 44079a8f70bSKristen Carlson Accardi char *envp[] = { event_string, NULL }; 4411253f7aaSShaohua Li struct dock_dependent_device *dd; 44279a8f70bSKristen Carlson Accardi 44379a8f70bSKristen Carlson Accardi if (num == UNDOCK_EVENT) 44466b56821SHolger Macht sprintf(event_string, "EVENT=undock"); 44579a8f70bSKristen Carlson Accardi else 44666b56821SHolger Macht sprintf(event_string, "EVENT=dock"); 44779a8f70bSKristen Carlson Accardi 4485669021eSKristen Carlson Accardi /* 4498ea86e0bSKristen Carlson Accardi * Indicate that the status of the dock station has 4508ea86e0bSKristen Carlson Accardi * changed. 4515669021eSKristen Carlson Accardi */ 4521253f7aaSShaohua Li if (num == DOCK_EVENT) 4531253f7aaSShaohua Li kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp); 4541253f7aaSShaohua Li 45521a31013SRafael J. Wysocki list_for_each_entry(dd, &ds->dependent_devices, list) 45621a31013SRafael J. Wysocki dock_hotplug_event(dd, event, true); 457747479a3SAlex Chiang 4581253f7aaSShaohua Li if (num != DOCK_EVENT) 45979a8f70bSKristen Carlson Accardi kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp); 460c8f7a62cSLen Brown } 461c8f7a62cSLen Brown 462c8f7a62cSLen Brown /** 463c8f7a62cSLen Brown * eject_dock - respond to a dock eject request 464c8f7a62cSLen Brown * @ds: the dock station 465c8f7a62cSLen Brown * 466c8f7a62cSLen Brown * This is called after _DCK is called, to execute the dock station's 467c8f7a62cSLen Brown * _EJ0 method. 468c8f7a62cSLen Brown */ 469c8f7a62cSLen Brown static void eject_dock(struct dock_station *ds) 470c8f7a62cSLen Brown { 471c8f7a62cSLen Brown struct acpi_object_list arg_list; 472c8f7a62cSLen Brown union acpi_object arg; 473c8f7a62cSLen Brown acpi_status status; 474c8f7a62cSLen Brown acpi_handle tmp; 475c8f7a62cSLen Brown 476c8f7a62cSLen Brown /* all dock devices should have _EJ0, but check anyway */ 477c8f7a62cSLen Brown status = acpi_get_handle(ds->handle, "_EJ0", &tmp); 478c8f7a62cSLen Brown if (ACPI_FAILURE(status)) { 479c8f7a62cSLen Brown pr_debug("No _EJ0 support for dock device\n"); 480c8f7a62cSLen Brown return; 481c8f7a62cSLen Brown } 482c8f7a62cSLen Brown 483c8f7a62cSLen Brown arg_list.count = 1; 484c8f7a62cSLen Brown arg_list.pointer = &arg; 485c8f7a62cSLen Brown arg.type = ACPI_TYPE_INTEGER; 486c8f7a62cSLen Brown arg.integer.value = 1; 487c8f7a62cSLen Brown 488747479a3SAlex Chiang status = acpi_evaluate_object(ds->handle, "_EJ0", &arg_list, NULL); 489747479a3SAlex Chiang if (ACPI_FAILURE(status)) 490c8f7a62cSLen Brown pr_debug("Failed to evaluate _EJ0!\n"); 491c8f7a62cSLen Brown } 492c8f7a62cSLen Brown 493c8f7a62cSLen Brown /** 494c8f7a62cSLen Brown * handle_dock - handle a dock event 495c8f7a62cSLen Brown * @ds: the dock station 496c8f7a62cSLen Brown * @dock: to dock, or undock - that is the question 497c8f7a62cSLen Brown * 498c8f7a62cSLen Brown * Execute the _DCK method in response to an acpi event 499c8f7a62cSLen Brown */ 500c8f7a62cSLen Brown static void handle_dock(struct dock_station *ds, int dock) 501c8f7a62cSLen Brown { 502c8f7a62cSLen Brown acpi_status status; 503c8f7a62cSLen Brown struct acpi_object_list arg_list; 504c8f7a62cSLen Brown union acpi_object arg; 505c8f7a62cSLen Brown struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 506c8f7a62cSLen Brown 507cd73018fSToshi Kani acpi_handle_info(ds->handle, "%s\n", dock ? "docking" : "undocking"); 508c8f7a62cSLen Brown 509c8f7a62cSLen Brown /* _DCK method has one argument */ 510c8f7a62cSLen Brown arg_list.count = 1; 511c8f7a62cSLen Brown arg_list.pointer = &arg; 512c8f7a62cSLen Brown arg.type = ACPI_TYPE_INTEGER; 513c8f7a62cSLen Brown arg.integer.value = dock; 514c8f7a62cSLen Brown status = acpi_evaluate_object(ds->handle, "_DCK", &arg_list, &buffer); 515db350b08SShaohua Li if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) 516cd73018fSToshi Kani acpi_handle_err(ds->handle, "Failed to execute _DCK (0x%x)\n", 517cd73018fSToshi Kani status); 5180a918a94SThomas Renninger 519c8f7a62cSLen Brown kfree(buffer.pointer); 520c8f7a62cSLen Brown } 521c8f7a62cSLen Brown 522c8f7a62cSLen Brown static inline void dock(struct dock_station *ds) 523c8f7a62cSLen Brown { 524c8f7a62cSLen Brown handle_dock(ds, 1); 525c8f7a62cSLen Brown } 526c8f7a62cSLen Brown 527c8f7a62cSLen Brown static inline void undock(struct dock_station *ds) 528c8f7a62cSLen Brown { 529c8f7a62cSLen Brown handle_dock(ds, 0); 530c8f7a62cSLen Brown } 531c8f7a62cSLen Brown 532c8f7a62cSLen Brown static inline void begin_dock(struct dock_station *ds) 533c8f7a62cSLen Brown { 534c8f7a62cSLen Brown ds->flags |= DOCK_DOCKING; 535c8f7a62cSLen Brown } 536c8f7a62cSLen Brown 537c8f7a62cSLen Brown static inline void complete_dock(struct dock_station *ds) 538c8f7a62cSLen Brown { 539c8f7a62cSLen Brown ds->flags &= ~(DOCK_DOCKING); 540c8f7a62cSLen Brown ds->last_dock_time = jiffies; 541c8f7a62cSLen Brown } 542c8f7a62cSLen Brown 543a0cd35fdSKristen Carlson Accardi static inline void begin_undock(struct dock_station *ds) 544a0cd35fdSKristen Carlson Accardi { 545a0cd35fdSKristen Carlson Accardi ds->flags |= DOCK_UNDOCKING; 546a0cd35fdSKristen Carlson Accardi } 547a0cd35fdSKristen Carlson Accardi 548a0cd35fdSKristen Carlson Accardi static inline void complete_undock(struct dock_station *ds) 549a0cd35fdSKristen Carlson Accardi { 550a0cd35fdSKristen Carlson Accardi ds->flags &= ~(DOCK_UNDOCKING); 551a0cd35fdSKristen Carlson Accardi } 552a0cd35fdSKristen Carlson Accardi 553406f692dSShaohua Li static void dock_lock(struct dock_station *ds, int lock) 554406f692dSShaohua Li { 555406f692dSShaohua Li struct acpi_object_list arg_list; 556406f692dSShaohua Li union acpi_object arg; 557406f692dSShaohua Li acpi_status status; 558406f692dSShaohua Li 559406f692dSShaohua Li arg_list.count = 1; 560406f692dSShaohua Li arg_list.pointer = &arg; 561406f692dSShaohua Li arg.type = ACPI_TYPE_INTEGER; 562406f692dSShaohua Li arg.integer.value = !!lock; 563406f692dSShaohua Li status = acpi_evaluate_object(ds->handle, "_LCK", &arg_list, NULL); 564406f692dSShaohua Li if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 565406f692dSShaohua Li if (lock) 566cd73018fSToshi Kani acpi_handle_warn(ds->handle, 567cd73018fSToshi Kani "Locking device failed (0x%x)\n", status); 568406f692dSShaohua Li else 569cd73018fSToshi Kani acpi_handle_warn(ds->handle, 570cd73018fSToshi Kani "Unlocking device failed (0x%x)\n", status); 571406f692dSShaohua Li } 572406f692dSShaohua Li } 573406f692dSShaohua Li 574c8f7a62cSLen Brown /** 575c8f7a62cSLen Brown * dock_in_progress - see if we are in the middle of handling a dock event 576c8f7a62cSLen Brown * @ds: the dock station 577c8f7a62cSLen Brown * 578c8f7a62cSLen Brown * Sometimes while docking, false dock events can be sent to the driver 579c8f7a62cSLen Brown * because good connections aren't made or some other reason. Ignore these 580c8f7a62cSLen Brown * if we are in the middle of doing something. 581c8f7a62cSLen Brown */ 582c8f7a62cSLen Brown static int dock_in_progress(struct dock_station *ds) 583c8f7a62cSLen Brown { 584c8f7a62cSLen Brown if ((ds->flags & DOCK_DOCKING) || 585c8f7a62cSLen Brown time_before(jiffies, (ds->last_dock_time + HZ))) 586c8f7a62cSLen Brown return 1; 587c8f7a62cSLen Brown return 0; 588c8f7a62cSLen Brown } 589c8f7a62cSLen Brown 590c8f7a62cSLen Brown /** 591c8f7a62cSLen Brown * register_dock_notifier - add yourself to the dock notifier list 592c8f7a62cSLen Brown * @nb: the callers notifier block 593c8f7a62cSLen Brown * 594c8f7a62cSLen Brown * If a driver wishes to be notified about dock events, they can 595c8f7a62cSLen Brown * use this function to put a notifier block on the dock notifier list. 596c8f7a62cSLen Brown * this notifier call chain will be called after a dock event, but 597c8f7a62cSLen Brown * before hotplugging any new devices. 598c8f7a62cSLen Brown */ 599c8f7a62cSLen Brown int register_dock_notifier(struct notifier_block *nb) 600c8f7a62cSLen Brown { 601db350b08SShaohua Li if (!dock_station_count) 6022548c06bSPrarit Bhargava return -ENODEV; 6032548c06bSPrarit Bhargava 604c8f7a62cSLen Brown return atomic_notifier_chain_register(&dock_notifier_list, nb); 605c8f7a62cSLen Brown } 606c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(register_dock_notifier); 607c8f7a62cSLen Brown 608c8f7a62cSLen Brown /** 609c8f7a62cSLen Brown * unregister_dock_notifier - remove yourself from the dock notifier list 610c8f7a62cSLen Brown * @nb: the callers notifier block 611c8f7a62cSLen Brown */ 612c8f7a62cSLen Brown void unregister_dock_notifier(struct notifier_block *nb) 613c8f7a62cSLen Brown { 614db350b08SShaohua Li if (!dock_station_count) 6152548c06bSPrarit Bhargava return; 6162548c06bSPrarit Bhargava 617c8f7a62cSLen Brown atomic_notifier_chain_unregister(&dock_notifier_list, nb); 618c8f7a62cSLen Brown } 619c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(unregister_dock_notifier); 620c8f7a62cSLen Brown 621c8f7a62cSLen Brown /** 622c8f7a62cSLen Brown * register_hotplug_dock_device - register a hotplug function 623c8f7a62cSLen Brown * @handle: the handle of the device 6241253f7aaSShaohua Li * @ops: handlers to call after docking 625c8f7a62cSLen Brown * @context: device specific data 62621a31013SRafael J. Wysocki * @init: Optional initialization routine to run after registration 62721a31013SRafael J. Wysocki * @release: Optional release routine to run on unregistration 628c8f7a62cSLen Brown * 629c8f7a62cSLen Brown * If a driver would like to perform a hotplug operation after a dock 630c8f7a62cSLen Brown * event, they can register an acpi_notifiy_handler to be called by 631c8f7a62cSLen Brown * the dock driver after _DCK is executed. 632c8f7a62cSLen Brown */ 63321a31013SRafael J. Wysocki int register_hotplug_dock_device(acpi_handle handle, 63421a31013SRafael J. Wysocki const struct acpi_dock_ops *ops, void *context, 63521a31013SRafael J. Wysocki void (*init)(void *), void (*release)(void *)) 636c8f7a62cSLen Brown { 637c8f7a62cSLen Brown struct dock_dependent_device *dd; 638db350b08SShaohua Li struct dock_station *dock_station; 63961b83695SShaohua Li int ret = -EINVAL; 640c8f7a62cSLen Brown 64121a31013SRafael J. Wysocki if (WARN_ON(!context)) 64221a31013SRafael J. Wysocki return -EINVAL; 64321a31013SRafael J. Wysocki 644db350b08SShaohua Li if (!dock_station_count) 645c8f7a62cSLen Brown return -ENODEV; 646c8f7a62cSLen Brown 647c8f7a62cSLen Brown /* 648c8f7a62cSLen Brown * make sure this handle is for a device dependent on the dock, 649c8f7a62cSLen Brown * this would include the dock station itself 650c8f7a62cSLen Brown */ 65150d716e4SAlex Chiang list_for_each_entry(dock_station, &dock_stations, sibling) { 65261b83695SShaohua Li /* 65361b83695SShaohua Li * An ATA bay can be in a dock and itself can be ejected 6543ad2f3fbSDaniel Mack * separately, so there are two 'dock stations' which need the 65561b83695SShaohua Li * ops 65661b83695SShaohua Li */ 657c8f7a62cSLen Brown dd = find_dock_dependent_device(dock_station, handle); 65821a31013SRafael J. Wysocki if (dd && !dock_init_hotplug(dd, ops, context, init, release)) 65961b83695SShaohua Li ret = 0; 660c8f7a62cSLen Brown } 661c8f7a62cSLen Brown 66261b83695SShaohua Li return ret; 663c8f7a62cSLen Brown } 664c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(register_hotplug_dock_device); 665c8f7a62cSLen Brown 666c8f7a62cSLen Brown /** 667c8f7a62cSLen Brown * unregister_hotplug_dock_device - remove yourself from the hotplug list 668c8f7a62cSLen Brown * @handle: the acpi handle of the device 669c8f7a62cSLen Brown */ 670c8f7a62cSLen Brown void unregister_hotplug_dock_device(acpi_handle handle) 671c8f7a62cSLen Brown { 672c8f7a62cSLen Brown struct dock_dependent_device *dd; 673db350b08SShaohua Li struct dock_station *dock_station; 674c8f7a62cSLen Brown 675db350b08SShaohua Li if (!dock_station_count) 676c8f7a62cSLen Brown return; 677c8f7a62cSLen Brown 67850d716e4SAlex Chiang list_for_each_entry(dock_station, &dock_stations, sibling) { 679c8f7a62cSLen Brown dd = find_dock_dependent_device(dock_station, handle); 680c8f7a62cSLen Brown if (dd) 68121a31013SRafael J. Wysocki dock_release_hotplug(dd); 682c8f7a62cSLen Brown } 683db350b08SShaohua Li } 684c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(unregister_hotplug_dock_device); 685c8f7a62cSLen Brown 686c8f7a62cSLen Brown /** 687c80fdbe8Sbrandon@ifup.org * handle_eject_request - handle an undock request checking for error conditions 688c80fdbe8Sbrandon@ifup.org * 689c80fdbe8Sbrandon@ifup.org * Check to make sure the dock device is still present, then undock and 690c80fdbe8Sbrandon@ifup.org * hotremove all the devices that may need removing. 691c80fdbe8Sbrandon@ifup.org */ 692c80fdbe8Sbrandon@ifup.org static int handle_eject_request(struct dock_station *ds, u32 event) 693c80fdbe8Sbrandon@ifup.org { 694c80fdbe8Sbrandon@ifup.org if (dock_in_progress(ds)) 695c80fdbe8Sbrandon@ifup.org return -EBUSY; 696c80fdbe8Sbrandon@ifup.org 697c80fdbe8Sbrandon@ifup.org /* 698c80fdbe8Sbrandon@ifup.org * here we need to generate the undock 699c80fdbe8Sbrandon@ifup.org * event prior to actually doing the undock 700c80fdbe8Sbrandon@ifup.org * so that the device struct still exists. 701afd7301dSHolger Macht * Also, even send the dock event if the 702afd7301dSHolger Macht * device is not present anymore 703c80fdbe8Sbrandon@ifup.org */ 704c80fdbe8Sbrandon@ifup.org dock_event(ds, event, UNDOCK_EVENT); 705afd7301dSHolger Macht 706c80fdbe8Sbrandon@ifup.org hotplug_dock_devices(ds, ACPI_NOTIFY_EJECT_REQUEST); 707c80fdbe8Sbrandon@ifup.org undock(ds); 708406f692dSShaohua Li dock_lock(ds, 0); 709c80fdbe8Sbrandon@ifup.org eject_dock(ds); 710c80fdbe8Sbrandon@ifup.org if (dock_present(ds)) { 711cd73018fSToshi Kani acpi_handle_err(ds->handle, "Unable to undock!\n"); 712c80fdbe8Sbrandon@ifup.org return -EBUSY; 713c80fdbe8Sbrandon@ifup.org } 714a0cd35fdSKristen Carlson Accardi complete_undock(ds); 715c80fdbe8Sbrandon@ifup.org return 0; 716c80fdbe8Sbrandon@ifup.org } 717c80fdbe8Sbrandon@ifup.org 718c80fdbe8Sbrandon@ifup.org /** 719c8f7a62cSLen Brown * dock_notify - act upon an acpi dock notification 720c8f7a62cSLen Brown * @handle: the dock station handle 721c8f7a62cSLen Brown * @event: the acpi event 722c8f7a62cSLen Brown * @data: our driver data struct 723c8f7a62cSLen Brown * 724c8f7a62cSLen Brown * If we are notified to dock, then check to see if the dock is 725c8f7a62cSLen Brown * present and then dock. Notify all drivers of the dock event, 726c80fdbe8Sbrandon@ifup.org * and then hotplug and devices that may need hotplugging. 727c8f7a62cSLen Brown */ 728c8f7a62cSLen Brown static void dock_notify(acpi_handle handle, u32 event, void *data) 729c8f7a62cSLen Brown { 73050dd0969SJan Engelhardt struct dock_station *ds = data; 7318b59560aSShaohua Li struct acpi_device *tmp; 732db350b08SShaohua Li int surprise_removal = 0; 733c8f7a62cSLen Brown 734db350b08SShaohua Li /* 735db350b08SShaohua Li * According to acpi spec 3.0a, if a DEVICE_CHECK notification 736db350b08SShaohua Li * is sent and _DCK is present, it is assumed to mean an undock 737db350b08SShaohua Li * request. 738db350b08SShaohua Li */ 739db350b08SShaohua Li if ((ds->flags & DOCK_IS_DOCK) && event == ACPI_NOTIFY_DEVICE_CHECK) 740db350b08SShaohua Li event = ACPI_NOTIFY_EJECT_REQUEST; 741db350b08SShaohua Li 742db350b08SShaohua Li /* 743db350b08SShaohua Li * dock station: BUS_CHECK - docked or surprise removal 744db350b08SShaohua Li * DEVICE_CHECK - undocked 745db350b08SShaohua Li * other device: BUS_CHECK/DEVICE_CHECK - added or surprise removal 746db350b08SShaohua Li * 747db350b08SShaohua Li * To simplify event handling, dock dependent device handler always 748db350b08SShaohua Li * get ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and 749db350b08SShaohua Li * ACPI_NOTIFY_EJECT_REQUEST for removal 750db350b08SShaohua Li */ 751c8f7a62cSLen Brown switch (event) { 752c8f7a62cSLen Brown case ACPI_NOTIFY_BUS_CHECK: 753db350b08SShaohua Li case ACPI_NOTIFY_DEVICE_CHECK: 7548b59560aSShaohua Li if (!dock_in_progress(ds) && acpi_bus_get_device(ds->handle, 7558b59560aSShaohua Li &tmp)) { 756c8f7a62cSLen Brown begin_dock(ds); 757c8f7a62cSLen Brown dock(ds); 758c8f7a62cSLen Brown if (!dock_present(ds)) { 759cd73018fSToshi Kani acpi_handle_err(handle, "Unable to dock!\n"); 7608b59560aSShaohua Li complete_dock(ds); 761c8f7a62cSLen Brown break; 762c8f7a62cSLen Brown } 763c8f7a62cSLen Brown atomic_notifier_call_chain(&dock_notifier_list, 764c8f7a62cSLen Brown event, NULL); 765c8f7a62cSLen Brown hotplug_dock_devices(ds, event); 766c8f7a62cSLen Brown complete_dock(ds); 767c8f7a62cSLen Brown dock_event(ds, event, DOCK_EVENT); 768406f692dSShaohua Li dock_lock(ds, 1); 7693a37898dSLin Ming acpi_update_all_gpes(); 770c8f7a62cSLen Brown break; 771db350b08SShaohua Li } 772db350b08SShaohua Li if (dock_present(ds) || dock_in_progress(ds)) 773db350b08SShaohua Li break; 774db350b08SShaohua Li /* This is a surprise removal */ 775db350b08SShaohua Li surprise_removal = 1; 776db350b08SShaohua Li event = ACPI_NOTIFY_EJECT_REQUEST; 777db350b08SShaohua Li /* Fall back */ 778c8f7a62cSLen Brown case ACPI_NOTIFY_EJECT_REQUEST: 779a0cd35fdSKristen Carlson Accardi begin_undock(ds); 780f730ae18SShaohua Li if ((immediate_undock && !(ds->flags & DOCK_IS_ATA)) 781f730ae18SShaohua Li || surprise_removal) 782c80fdbe8Sbrandon@ifup.org handle_eject_request(ds, event); 783a0cd35fdSKristen Carlson Accardi else 784a0cd35fdSKristen Carlson Accardi dock_event(ds, event, UNDOCK_EVENT); 785c8f7a62cSLen Brown break; 786c8f7a62cSLen Brown default: 787cd73018fSToshi Kani acpi_handle_err(handle, "Unknown dock event %d\n", event); 788c8f7a62cSLen Brown } 789c8f7a62cSLen Brown } 790c8f7a62cSLen Brown 79119cd847aSZhang Rui struct dock_data { 79219cd847aSZhang Rui acpi_handle handle; 79319cd847aSZhang Rui unsigned long event; 79419cd847aSZhang Rui struct dock_station *ds; 79519cd847aSZhang Rui }; 79619cd847aSZhang Rui 79719cd847aSZhang Rui static void acpi_dock_deferred_cb(void *context) 79819cd847aSZhang Rui { 799747479a3SAlex Chiang struct dock_data *data = context; 80019cd847aSZhang Rui 8013757b948SRafael J. Wysocki acpi_scan_lock_acquire(); 80219cd847aSZhang Rui dock_notify(data->handle, data->event, data->ds); 8033757b948SRafael J. Wysocki acpi_scan_lock_release(); 80419cd847aSZhang Rui kfree(data); 80519cd847aSZhang Rui } 80619cd847aSZhang Rui 8076bd00a61SShaohua Li static int acpi_dock_notifier_call(struct notifier_block *this, 8086bd00a61SShaohua Li unsigned long event, void *data) 8096bd00a61SShaohua Li { 8106bd00a61SShaohua Li struct dock_station *dock_station; 811747479a3SAlex Chiang acpi_handle handle = data; 8126bd00a61SShaohua Li 8136bd00a61SShaohua Li if (event != ACPI_NOTIFY_BUS_CHECK && event != ACPI_NOTIFY_DEVICE_CHECK 8146bd00a61SShaohua Li && event != ACPI_NOTIFY_EJECT_REQUEST) 8156bd00a61SShaohua Li return 0; 8163757b948SRafael J. Wysocki 8173757b948SRafael J. Wysocki acpi_scan_lock_acquire(); 8183757b948SRafael J. Wysocki 81950d716e4SAlex Chiang list_for_each_entry(dock_station, &dock_stations, sibling) { 8206bd00a61SShaohua Li if (dock_station->handle == handle) { 821747479a3SAlex Chiang struct dock_data *dd; 8223757b948SRafael J. Wysocki acpi_status status; 82319cd847aSZhang Rui 824747479a3SAlex Chiang dd = kmalloc(sizeof(*dd), GFP_KERNEL); 825747479a3SAlex Chiang if (!dd) 8263757b948SRafael J. Wysocki break; 8273757b948SRafael J. Wysocki 828747479a3SAlex Chiang dd->handle = handle; 829747479a3SAlex Chiang dd->event = event; 830747479a3SAlex Chiang dd->ds = dock_station; 8313757b948SRafael J. Wysocki status = acpi_os_hotplug_execute(acpi_dock_deferred_cb, 8323757b948SRafael J. Wysocki dd); 8333757b948SRafael J. Wysocki if (ACPI_FAILURE(status)) 8343757b948SRafael J. Wysocki kfree(dd); 8353757b948SRafael J. Wysocki 8363757b948SRafael J. Wysocki break; 8376bd00a61SShaohua Li } 8386bd00a61SShaohua Li } 8393757b948SRafael J. Wysocki 8403757b948SRafael J. Wysocki acpi_scan_lock_release(); 8416bd00a61SShaohua Li return 0; 8426bd00a61SShaohua Li } 8436bd00a61SShaohua Li 8446bd00a61SShaohua Li static struct notifier_block dock_acpi_notifier = { 8456bd00a61SShaohua Li .notifier_call = acpi_dock_notifier_call, 8466bd00a61SShaohua Li }; 8476bd00a61SShaohua Li 848c8f7a62cSLen Brown /** 849c8f7a62cSLen Brown * find_dock_devices - find devices on the dock station 850c8f7a62cSLen Brown * @handle: the handle of the device we are examining 851c8f7a62cSLen Brown * @lvl: unused 852c8f7a62cSLen Brown * @context: the dock station private data 853c8f7a62cSLen Brown * @rv: unused 854c8f7a62cSLen Brown * 855c8f7a62cSLen Brown * This function is called by acpi_walk_namespace. It will 856c8f7a62cSLen Brown * check to see if an object has an _EJD method. If it does, then it 857c8f7a62cSLen Brown * will see if it is dependent on the dock station. 858c8f7a62cSLen Brown */ 859c8f7a62cSLen Brown static acpi_status 860c8f7a62cSLen Brown find_dock_devices(acpi_handle handle, u32 lvl, void *context, void **rv) 861c8f7a62cSLen Brown { 862c8f7a62cSLen Brown acpi_status status; 863fe9a2f77SKristen Carlson Accardi acpi_handle tmp, parent; 86450dd0969SJan Engelhardt struct dock_station *ds = context; 865c8f7a62cSLen Brown 866c8f7a62cSLen Brown status = acpi_bus_get_ejd(handle, &tmp); 867fe9a2f77SKristen Carlson Accardi if (ACPI_FAILURE(status)) { 868fe9a2f77SKristen Carlson Accardi /* try the parent device as well */ 869fe9a2f77SKristen Carlson Accardi status = acpi_get_parent(handle, &parent); 870c8f7a62cSLen Brown if (ACPI_FAILURE(status)) 871fe9a2f77SKristen Carlson Accardi goto fdd_out; 872fe9a2f77SKristen Carlson Accardi /* see if parent is dependent on dock */ 873fe9a2f77SKristen Carlson Accardi status = acpi_bus_get_ejd(parent, &tmp); 874fe9a2f77SKristen Carlson Accardi if (ACPI_FAILURE(status)) 875fe9a2f77SKristen Carlson Accardi goto fdd_out; 876fe9a2f77SKristen Carlson Accardi } 877c8f7a62cSLen Brown 878f69cfdd2SAlex Chiang if (tmp == ds->handle) 879f69cfdd2SAlex Chiang add_dock_dependent_device(ds, handle); 880f69cfdd2SAlex Chiang 881fe9a2f77SKristen Carlson Accardi fdd_out: 882c8f7a62cSLen Brown return AE_OK; 883c8f7a62cSLen Brown } 884c8f7a62cSLen Brown 885c80fdbe8Sbrandon@ifup.org /* 886c80fdbe8Sbrandon@ifup.org * show_docked - read method for "docked" file in sysfs 887c80fdbe8Sbrandon@ifup.org */ 888c80fdbe8Sbrandon@ifup.org static ssize_t show_docked(struct device *dev, 889c80fdbe8Sbrandon@ifup.org struct device_attribute *attr, char *buf) 890c80fdbe8Sbrandon@ifup.org { 891fc5a9f88SHolger Macht struct acpi_device *tmp; 892fc5a9f88SHolger Macht 893fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 894c80fdbe8Sbrandon@ifup.org 89502df7349SYasuaki Ishimatsu if (!acpi_bus_get_device(dock_station->handle, &tmp)) 896fc5a9f88SHolger Macht return snprintf(buf, PAGE_SIZE, "1\n"); 897fc5a9f88SHolger Macht return snprintf(buf, PAGE_SIZE, "0\n"); 898c80fdbe8Sbrandon@ifup.org } 899e5685b9dSAdrian Bunk static DEVICE_ATTR(docked, S_IRUGO, show_docked, NULL); 900c80fdbe8Sbrandon@ifup.org 901c80fdbe8Sbrandon@ifup.org /* 902a0cd35fdSKristen Carlson Accardi * show_flags - read method for flags file in sysfs 903a0cd35fdSKristen Carlson Accardi */ 904a0cd35fdSKristen Carlson Accardi static ssize_t show_flags(struct device *dev, 905a0cd35fdSKristen Carlson Accardi struct device_attribute *attr, char *buf) 906a0cd35fdSKristen Carlson Accardi { 907fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 908a0cd35fdSKristen Carlson Accardi return snprintf(buf, PAGE_SIZE, "%d\n", dock_station->flags); 909a0cd35fdSKristen Carlson Accardi 910a0cd35fdSKristen Carlson Accardi } 911e5685b9dSAdrian Bunk static DEVICE_ATTR(flags, S_IRUGO, show_flags, NULL); 912a0cd35fdSKristen Carlson Accardi 913a0cd35fdSKristen Carlson Accardi /* 914c80fdbe8Sbrandon@ifup.org * write_undock - write method for "undock" file in sysfs 915c80fdbe8Sbrandon@ifup.org */ 916c80fdbe8Sbrandon@ifup.org static ssize_t write_undock(struct device *dev, struct device_attribute *attr, 917c80fdbe8Sbrandon@ifup.org const char *buf, size_t count) 918c80fdbe8Sbrandon@ifup.org { 919c80fdbe8Sbrandon@ifup.org int ret; 920fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 921c80fdbe8Sbrandon@ifup.org 922c80fdbe8Sbrandon@ifup.org if (!count) 923c80fdbe8Sbrandon@ifup.org return -EINVAL; 924c80fdbe8Sbrandon@ifup.org 9258112006fSRafael J. Wysocki acpi_scan_lock_acquire(); 9269171f834SHolger Macht begin_undock(dock_station); 927c80fdbe8Sbrandon@ifup.org ret = handle_eject_request(dock_station, ACPI_NOTIFY_EJECT_REQUEST); 9288112006fSRafael J. Wysocki acpi_scan_lock_release(); 929c80fdbe8Sbrandon@ifup.org return ret ? ret: count; 930c80fdbe8Sbrandon@ifup.org } 931e5685b9dSAdrian Bunk static DEVICE_ATTR(undock, S_IWUSR, NULL, write_undock); 932c80fdbe8Sbrandon@ifup.org 933ac122bb6SIlya A. Volynets-Evenbakh /* 934ac122bb6SIlya A. Volynets-Evenbakh * show_dock_uid - read method for "uid" file in sysfs 935ac122bb6SIlya A. Volynets-Evenbakh */ 936ac122bb6SIlya A. Volynets-Evenbakh static ssize_t show_dock_uid(struct device *dev, 937ac122bb6SIlya A. Volynets-Evenbakh struct device_attribute *attr, char *buf) 938ac122bb6SIlya A. Volynets-Evenbakh { 93927663c58SMatthew Wilcox unsigned long long lbuf; 940fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 94138ff4ffcSKristen Carlson Accardi acpi_status status = acpi_evaluate_integer(dock_station->handle, 94238ff4ffcSKristen Carlson Accardi "_UID", NULL, &lbuf); 94338ff4ffcSKristen Carlson Accardi if (ACPI_FAILURE(status)) 944ac122bb6SIlya A. Volynets-Evenbakh return 0; 94538ff4ffcSKristen Carlson Accardi 94627663c58SMatthew Wilcox return snprintf(buf, PAGE_SIZE, "%llx\n", lbuf); 947ac122bb6SIlya A. Volynets-Evenbakh } 948e5685b9dSAdrian Bunk static DEVICE_ATTR(uid, S_IRUGO, show_dock_uid, NULL); 949ac122bb6SIlya A. Volynets-Evenbakh 9508652b00fSShaohua Li static ssize_t show_dock_type(struct device *dev, 9518652b00fSShaohua Li struct device_attribute *attr, char *buf) 9528652b00fSShaohua Li { 953fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 9548652b00fSShaohua Li char *type; 9558652b00fSShaohua Li 9568652b00fSShaohua Li if (dock_station->flags & DOCK_IS_DOCK) 9578652b00fSShaohua Li type = "dock_station"; 9588652b00fSShaohua Li else if (dock_station->flags & DOCK_IS_ATA) 9598652b00fSShaohua Li type = "ata_bay"; 9608652b00fSShaohua Li else if (dock_station->flags & DOCK_IS_BAT) 9618652b00fSShaohua Li type = "battery_bay"; 9628652b00fSShaohua Li else 9638652b00fSShaohua Li type = "unknown"; 9648652b00fSShaohua Li 9658652b00fSShaohua Li return snprintf(buf, PAGE_SIZE, "%s\n", type); 9668652b00fSShaohua Li } 9678652b00fSShaohua Li static DEVICE_ATTR(type, S_IRUGO, show_dock_type, NULL); 9688652b00fSShaohua Li 9695f46c2f2SAlex Chiang static struct attribute *dock_attributes[] = { 9705f46c2f2SAlex Chiang &dev_attr_docked.attr, 9715f46c2f2SAlex Chiang &dev_attr_flags.attr, 9725f46c2f2SAlex Chiang &dev_attr_undock.attr, 9735f46c2f2SAlex Chiang &dev_attr_uid.attr, 9745f46c2f2SAlex Chiang &dev_attr_type.attr, 9755f46c2f2SAlex Chiang NULL 9765f46c2f2SAlex Chiang }; 9775f46c2f2SAlex Chiang 9785f46c2f2SAlex Chiang static struct attribute_group dock_attribute_group = { 9795f46c2f2SAlex Chiang .attrs = dock_attributes 9805f46c2f2SAlex Chiang }; 9815f46c2f2SAlex Chiang 982c8f7a62cSLen Brown /** 983c8f7a62cSLen Brown * dock_add - add a new dock station 984c8f7a62cSLen Brown * @handle: the dock station handle 985c8f7a62cSLen Brown * 986c8f7a62cSLen Brown * allocated and initialize a new dock station device. Find all devices 987c8f7a62cSLen Brown * that are on the dock station, and register for dock event notifications. 988c8f7a62cSLen Brown */ 989d38a5edfSUwe Kleine-König static int __init dock_add(acpi_handle handle) 990c8f7a62cSLen Brown { 991fe06fba2SAlex Chiang int ret, id; 992fe06fba2SAlex Chiang struct dock_station ds, *dock_station; 993747479a3SAlex Chiang struct platform_device *dd; 994c8f7a62cSLen Brown 995fe06fba2SAlex Chiang id = dock_station_count; 99649c6fb2eSAlex Chiang memset(&ds, 0, sizeof(ds)); 997747479a3SAlex Chiang dd = platform_device_register_data(NULL, "dock", id, &ds, sizeof(ds)); 998747479a3SAlex Chiang if (IS_ERR(dd)) 999747479a3SAlex Chiang return PTR_ERR(dd); 10009751cb72SAlex Chiang 1001747479a3SAlex Chiang dock_station = dd->dev.platform_data; 1002747479a3SAlex Chiang 1003c8f7a62cSLen Brown dock_station->handle = handle; 1004747479a3SAlex Chiang dock_station->dock_device = dd; 1005c8f7a62cSLen Brown dock_station->last_dock_time = jiffies - HZ; 1006c8f7a62cSLen Brown 1007c8f7a62cSLen Brown mutex_init(&dock_station->hp_lock); 1008747479a3SAlex Chiang spin_lock_init(&dock_station->dd_lock); 1009747479a3SAlex Chiang INIT_LIST_HEAD(&dock_station->sibling); 1010747479a3SAlex Chiang INIT_LIST_HEAD(&dock_station->dependent_devices); 1011a0cd35fdSKristen Carlson Accardi 10129ef2a9a9SKristen Carlson Accardi /* we want the dock device to send uevents */ 1013747479a3SAlex Chiang dev_set_uevent_suppress(&dd->dev, 0); 10149ef2a9a9SKristen Carlson Accardi 1015db350b08SShaohua Li if (is_dock(handle)) 1016db350b08SShaohua Li dock_station->flags |= DOCK_IS_DOCK; 1017db350b08SShaohua Li if (is_ata(handle)) 1018db350b08SShaohua Li dock_station->flags |= DOCK_IS_ATA; 1019db350b08SShaohua Li if (is_battery(handle)) 1020db350b08SShaohua Li dock_station->flags |= DOCK_IS_BAT; 1021db350b08SShaohua Li 1022747479a3SAlex Chiang ret = sysfs_create_group(&dd->dev.kobj, &dock_attribute_group); 10238652b00fSShaohua Li if (ret) 10245f46c2f2SAlex Chiang goto err_unregister; 1025671adbecSKristen Carlson Accardi 1026c8f7a62cSLen Brown /* Find dependent devices */ 1027c8f7a62cSLen Brown acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 10282263576cSLin Ming ACPI_UINT32_MAX, find_dock_devices, NULL, 10292263576cSLin Ming dock_station, NULL); 1030c8f7a62cSLen Brown 1031c8f7a62cSLen Brown /* add the dock station as a device dependent on itself */ 1032f69cfdd2SAlex Chiang ret = add_dock_dependent_device(dock_station, handle); 1033f69cfdd2SAlex Chiang if (ret) 10345f46c2f2SAlex Chiang goto err_rmgroup; 1035c8f7a62cSLen Brown 1036db350b08SShaohua Li dock_station_count++; 103750d716e4SAlex Chiang list_add(&dock_station->sibling, &dock_stations); 1038c8f7a62cSLen Brown return 0; 1039c8f7a62cSLen Brown 10405f46c2f2SAlex Chiang err_rmgroup: 1041747479a3SAlex Chiang sysfs_remove_group(&dd->dev.kobj, &dock_attribute_group); 10425f46c2f2SAlex Chiang err_unregister: 1043747479a3SAlex Chiang platform_device_unregister(dd); 1044cd73018fSToshi Kani acpi_handle_err(handle, "%s encountered error %d\n", __func__, ret); 1045c8f7a62cSLen Brown return ret; 1046c8f7a62cSLen Brown } 1047c8f7a62cSLen Brown 1048c8f7a62cSLen Brown /** 10498ab0ab25SToshi Kani * find_dock_and_bay - look for dock stations and bays 1050c8f7a62cSLen Brown * @handle: acpi handle of a device 1051c8f7a62cSLen Brown * @lvl: unused 10528ab0ab25SToshi Kani * @context: unused 1053c8f7a62cSLen Brown * @rv: unused 1054c8f7a62cSLen Brown * 10558ab0ab25SToshi Kani * This is called by acpi_walk_namespace to look for dock stations and bays. 1056c8f7a62cSLen Brown */ 1057d38a5edfSUwe Kleine-König static __init acpi_status 10588ab0ab25SToshi Kani find_dock_and_bay(acpi_handle handle, u32 lvl, void *context, void **rv) 1059c8f7a62cSLen Brown { 10608ab0ab25SToshi Kani if (is_dock(handle) || is_ejectable_bay(handle)) 10611ee4d61fSZhang Rui dock_add(handle); 1062747479a3SAlex Chiang 10631ee4d61fSZhang Rui return AE_OK; 1064c8f7a62cSLen Brown } 1065c8f7a62cSLen Brown 10662ce65fe8SRafael J. Wysocki void __init acpi_dock_init(void) 1067c8f7a62cSLen Brown { 1068816c2edaSLen Brown if (acpi_disabled) 10692ce65fe8SRafael J. Wysocki return; 1070816c2edaSLen Brown 10718ab0ab25SToshi Kani /* look for dock stations and bays */ 1072c8f7a62cSLen Brown acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 10738ab0ab25SToshi Kani ACPI_UINT32_MAX, find_dock_and_bay, NULL, NULL, NULL); 1074c8f7a62cSLen Brown 1075db350b08SShaohua Li if (!dock_station_count) { 1076cd73018fSToshi Kani pr_info(PREFIX "No dock devices found.\n"); 10772ce65fe8SRafael J. Wysocki return; 1078db350b08SShaohua Li } 1079c8f7a62cSLen Brown 1080f22ff552SJiang Liu ATOMIC_INIT_NOTIFIER_HEAD(&dock_notifier_list); 10816bd00a61SShaohua Li register_acpi_bus_notifier(&dock_acpi_notifier); 1082cd73018fSToshi Kani pr_info(PREFIX "%s: %d docks/bays found\n", 1083db350b08SShaohua Li ACPI_DOCK_DRIVER_DESCRIPTION, dock_station_count); 1084c8f7a62cSLen Brown } 1085