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; 69c8f7a62cSLen Brown struct list_head hotplug_devices; 70db350b08SShaohua Li 7150d716e4SAlex Chiang struct list_head sibling; 72db350b08SShaohua Li struct platform_device *dock_device; 73c8f7a62cSLen Brown }; 74db350b08SShaohua Li static LIST_HEAD(dock_stations); 75db350b08SShaohua Li static int dock_station_count; 76c8f7a62cSLen Brown 77c8f7a62cSLen Brown struct dock_dependent_device { 78c8f7a62cSLen Brown struct list_head list; 79c8f7a62cSLen Brown struct list_head hotplug_list; 80c8f7a62cSLen Brown acpi_handle handle; 819c8b04beSVasiliy Kulikov const struct acpi_dock_ops *ops; 82c8f7a62cSLen Brown void *context; 83c8f7a62cSLen Brown }; 84c8f7a62cSLen Brown 85c8f7a62cSLen Brown #define DOCK_DOCKING 0x00000001 86a0cd35fdSKristen Carlson Accardi #define DOCK_UNDOCKING 0x00000002 87db350b08SShaohua Li #define DOCK_IS_DOCK 0x00000010 88db350b08SShaohua Li #define DOCK_IS_ATA 0x00000020 89db350b08SShaohua Li #define DOCK_IS_BAT 0x00000040 905669021eSKristen Carlson Accardi #define DOCK_EVENT 3 915669021eSKristen Carlson Accardi #define UNDOCK_EVENT 2 92c8f7a62cSLen Brown 93c8f7a62cSLen Brown /***************************************************************************** 94c8f7a62cSLen Brown * Dock Dependent device functions * 95c8f7a62cSLen Brown *****************************************************************************/ 96c8f7a62cSLen Brown /** 97f69cfdd2SAlex Chiang * add_dock_dependent_device - associate a device with the dock station 98f69cfdd2SAlex Chiang * @ds: The dock station 99f69cfdd2SAlex Chiang * @handle: handle of the dependent device 100c8f7a62cSLen Brown * 101f69cfdd2SAlex Chiang * Add the dependent device to the dock's dependent device list. 102c8f7a62cSLen Brown */ 103f69cfdd2SAlex Chiang static int 104f69cfdd2SAlex Chiang add_dock_dependent_device(struct dock_station *ds, acpi_handle handle) 105c8f7a62cSLen Brown { 106c8f7a62cSLen Brown struct dock_dependent_device *dd; 107c8f7a62cSLen Brown 108c8f7a62cSLen Brown dd = kzalloc(sizeof(*dd), GFP_KERNEL); 109f69cfdd2SAlex Chiang if (!dd) 110f69cfdd2SAlex Chiang return -ENOMEM; 111f69cfdd2SAlex Chiang 112c8f7a62cSLen Brown dd->handle = handle; 113c8f7a62cSLen Brown INIT_LIST_HEAD(&dd->list); 114c8f7a62cSLen Brown INIT_LIST_HEAD(&dd->hotplug_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 /** 124c8f7a62cSLen Brown * dock_add_hotplug_device - associate a hotplug handler with the dock station 125c8f7a62cSLen Brown * @ds: The dock station 126c8f7a62cSLen Brown * @dd: The dependent device struct 127c8f7a62cSLen Brown * 128c8f7a62cSLen Brown * Add the dependent device to the dock's hotplug device list 129c8f7a62cSLen Brown */ 130c8f7a62cSLen Brown static void 131c8f7a62cSLen Brown dock_add_hotplug_device(struct dock_station *ds, 132c8f7a62cSLen Brown struct dock_dependent_device *dd) 133c8f7a62cSLen Brown { 1348b0dc866SKristen Carlson Accardi mutex_lock(&ds->hp_lock); 135c8f7a62cSLen Brown list_add_tail(&dd->hotplug_list, &ds->hotplug_devices); 1368b0dc866SKristen Carlson Accardi mutex_unlock(&ds->hp_lock); 137c8f7a62cSLen Brown } 138c8f7a62cSLen Brown 139c8f7a62cSLen Brown /** 140c8f7a62cSLen Brown * dock_del_hotplug_device - remove a hotplug handler from the dock station 141c8f7a62cSLen Brown * @ds: The dock station 142c8f7a62cSLen Brown * @dd: the dependent device struct 143c8f7a62cSLen Brown * 144c8f7a62cSLen Brown * Delete the dependent device from the dock's hotplug device list 145c8f7a62cSLen Brown */ 146c8f7a62cSLen Brown static void 147c8f7a62cSLen Brown dock_del_hotplug_device(struct dock_station *ds, 148c8f7a62cSLen Brown struct dock_dependent_device *dd) 149c8f7a62cSLen Brown { 1508b0dc866SKristen Carlson Accardi mutex_lock(&ds->hp_lock); 151c8f7a62cSLen Brown list_del(&dd->hotplug_list); 1528b0dc866SKristen Carlson Accardi mutex_unlock(&ds->hp_lock); 153c8f7a62cSLen Brown } 154c8f7a62cSLen Brown 155c8f7a62cSLen Brown /** 156c8f7a62cSLen Brown * find_dock_dependent_device - get a device dependent on this dock 157c8f7a62cSLen Brown * @ds: the dock station 158c8f7a62cSLen Brown * @handle: the acpi_handle of the device we want 159c8f7a62cSLen Brown * 160c8f7a62cSLen Brown * iterate over the dependent device list for this dock. If the 161c8f7a62cSLen Brown * dependent device matches the handle, return. 162c8f7a62cSLen Brown */ 163c8f7a62cSLen Brown static struct dock_dependent_device * 164c8f7a62cSLen Brown find_dock_dependent_device(struct dock_station *ds, acpi_handle handle) 165c8f7a62cSLen Brown { 166c8f7a62cSLen Brown struct dock_dependent_device *dd; 167c8f7a62cSLen Brown 168c8f7a62cSLen Brown spin_lock(&ds->dd_lock); 169c8f7a62cSLen Brown list_for_each_entry(dd, &ds->dependent_devices, list) { 170c8f7a62cSLen Brown if (handle == dd->handle) { 171c8f7a62cSLen Brown spin_unlock(&ds->dd_lock); 172c8f7a62cSLen Brown return dd; 173c8f7a62cSLen Brown } 174c8f7a62cSLen Brown } 175c8f7a62cSLen Brown spin_unlock(&ds->dd_lock); 176c8f7a62cSLen Brown return NULL; 177c8f7a62cSLen Brown } 178c8f7a62cSLen Brown 179c8f7a62cSLen Brown /***************************************************************************** 180c8f7a62cSLen Brown * Dock functions * 181c8f7a62cSLen Brown *****************************************************************************/ 182c8f7a62cSLen Brown /** 183c8f7a62cSLen Brown * is_dock - see if a device is a dock station 184c8f7a62cSLen Brown * @handle: acpi handle of the device 185c8f7a62cSLen Brown * 186c8f7a62cSLen Brown * If an acpi object has a _DCK method, then it is by definition a dock 187c8f7a62cSLen Brown * station, so return true. 188c8f7a62cSLen Brown */ 189c8f7a62cSLen Brown static int is_dock(acpi_handle handle) 190c8f7a62cSLen Brown { 191c8f7a62cSLen Brown acpi_status status; 192c8f7a62cSLen Brown acpi_handle tmp; 193c8f7a62cSLen Brown 194c8f7a62cSLen Brown status = acpi_get_handle(handle, "_DCK", &tmp); 195c8f7a62cSLen Brown if (ACPI_FAILURE(status)) 196c8f7a62cSLen Brown return 0; 197c8f7a62cSLen Brown return 1; 198c8f7a62cSLen Brown } 199c8f7a62cSLen Brown 200db350b08SShaohua Li static int is_ejectable(acpi_handle handle) 201db350b08SShaohua Li { 202db350b08SShaohua Li acpi_status status; 203db350b08SShaohua Li acpi_handle tmp; 204db350b08SShaohua Li 205db350b08SShaohua Li status = acpi_get_handle(handle, "_EJ0", &tmp); 206db350b08SShaohua Li if (ACPI_FAILURE(status)) 207db350b08SShaohua Li return 0; 208db350b08SShaohua Li return 1; 209db350b08SShaohua Li } 210db350b08SShaohua Li 211db350b08SShaohua Li static int is_ata(acpi_handle handle) 212db350b08SShaohua Li { 213db350b08SShaohua Li acpi_handle tmp; 214db350b08SShaohua Li 215db350b08SShaohua Li if ((ACPI_SUCCESS(acpi_get_handle(handle, "_GTF", &tmp))) || 216db350b08SShaohua Li (ACPI_SUCCESS(acpi_get_handle(handle, "_GTM", &tmp))) || 217db350b08SShaohua Li (ACPI_SUCCESS(acpi_get_handle(handle, "_STM", &tmp))) || 218db350b08SShaohua Li (ACPI_SUCCESS(acpi_get_handle(handle, "_SDD", &tmp)))) 219db350b08SShaohua Li return 1; 220db350b08SShaohua Li 221db350b08SShaohua Li return 0; 222db350b08SShaohua Li } 223db350b08SShaohua Li 224db350b08SShaohua Li static int is_battery(acpi_handle handle) 225db350b08SShaohua Li { 226db350b08SShaohua Li struct acpi_device_info *info; 227db350b08SShaohua Li int ret = 1; 228db350b08SShaohua Li 22915b8dd53SBob Moore if (!ACPI_SUCCESS(acpi_get_object_info(handle, &info))) 230db350b08SShaohua Li return 0; 231db350b08SShaohua Li if (!(info->valid & ACPI_VALID_HID)) 232db350b08SShaohua Li ret = 0; 233db350b08SShaohua Li else 23415b8dd53SBob Moore ret = !strcmp("PNP0C0A", info->hardware_id.string); 235db350b08SShaohua Li 23615b8dd53SBob Moore kfree(info); 237db350b08SShaohua Li return ret; 238db350b08SShaohua Li } 239db350b08SShaohua Li 240db350b08SShaohua Li static int is_ejectable_bay(acpi_handle handle) 241db350b08SShaohua Li { 242db350b08SShaohua Li acpi_handle phandle; 243747479a3SAlex Chiang 244db350b08SShaohua Li if (!is_ejectable(handle)) 245db350b08SShaohua Li return 0; 246db350b08SShaohua Li if (is_battery(handle) || is_ata(handle)) 247db350b08SShaohua Li return 1; 248db350b08SShaohua Li if (!acpi_get_parent(handle, &phandle) && is_ata(phandle)) 249db350b08SShaohua Li return 1; 250db350b08SShaohua Li return 0; 251db350b08SShaohua Li } 252db350b08SShaohua Li 253c8f7a62cSLen Brown /** 254c8f7a62cSLen Brown * is_dock_device - see if a device is on a dock station 255c8f7a62cSLen Brown * @handle: acpi handle of the device 256c8f7a62cSLen Brown * 257c8f7a62cSLen Brown * If this device is either the dock station itself, 258c8f7a62cSLen Brown * or is a device dependent on the dock station, then it 259c8f7a62cSLen Brown * is a dock device 260c8f7a62cSLen Brown */ 261c8f7a62cSLen Brown int is_dock_device(acpi_handle handle) 262c8f7a62cSLen Brown { 263db350b08SShaohua Li struct dock_station *dock_station; 264db350b08SShaohua Li 265db350b08SShaohua Li if (!dock_station_count) 266c8f7a62cSLen Brown return 0; 267c8f7a62cSLen Brown 268db350b08SShaohua Li if (is_dock(handle)) 269c8f7a62cSLen Brown return 1; 270747479a3SAlex Chiang 271747479a3SAlex Chiang list_for_each_entry(dock_station, &dock_stations, sibling) 272db350b08SShaohua Li if (find_dock_dependent_device(dock_station, handle)) 273db350b08SShaohua Li return 1; 274c8f7a62cSLen Brown 275c8f7a62cSLen Brown return 0; 276c8f7a62cSLen Brown } 277c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(is_dock_device); 278c8f7a62cSLen Brown 279c8f7a62cSLen Brown /** 280c8f7a62cSLen Brown * dock_present - see if the dock station is present. 281c8f7a62cSLen Brown * @ds: the dock station 282c8f7a62cSLen Brown * 283c8f7a62cSLen Brown * execute the _STA method. note that present does not 284c8f7a62cSLen Brown * imply that we are docked. 285c8f7a62cSLen Brown */ 286c8f7a62cSLen Brown static int dock_present(struct dock_station *ds) 287c8f7a62cSLen Brown { 28827663c58SMatthew Wilcox unsigned long long sta; 289c8f7a62cSLen Brown acpi_status status; 290c8f7a62cSLen Brown 291c8f7a62cSLen Brown if (ds) { 292c8f7a62cSLen Brown status = acpi_evaluate_integer(ds->handle, "_STA", NULL, &sta); 293c8f7a62cSLen Brown if (ACPI_SUCCESS(status) && sta) 294c8f7a62cSLen Brown return 1; 295c8f7a62cSLen Brown } 296c8f7a62cSLen Brown return 0; 297c8f7a62cSLen Brown } 298c8f7a62cSLen Brown 299c8f7a62cSLen Brown /** 300c8f7a62cSLen Brown * dock_create_acpi_device - add new devices to acpi 301c8f7a62cSLen Brown * @handle - handle of the device to add 302c8f7a62cSLen Brown * 303c8f7a62cSLen Brown * This function will create a new acpi_device for the given 304c8f7a62cSLen Brown * handle if one does not exist already. This should cause 305c8f7a62cSLen Brown * acpi to scan for drivers for the given devices, and call 306c8f7a62cSLen Brown * matching driver's add routine. 307c8f7a62cSLen Brown * 308c8f7a62cSLen Brown * Returns a pointer to the acpi_device corresponding to the handle. 309c8f7a62cSLen Brown */ 310c8f7a62cSLen Brown static struct acpi_device * dock_create_acpi_device(acpi_handle handle) 311c8f7a62cSLen Brown { 312747479a3SAlex Chiang struct acpi_device *device; 313c8f7a62cSLen Brown int ret; 314c8f7a62cSLen Brown 315c8f7a62cSLen Brown if (acpi_bus_get_device(handle, &device)) { 316c8f7a62cSLen Brown /* 317c8f7a62cSLen Brown * no device created for this object, 318c8f7a62cSLen Brown * so we should create one. 319c8f7a62cSLen Brown */ 3200cd6ac52SRafael J. Wysocki ret = acpi_bus_add(handle); 321636458deSRafael J. Wysocki if (ret) 322747479a3SAlex Chiang pr_debug("error adding bus, %x\n", -ret); 3230cd6ac52SRafael J. Wysocki 3240cd6ac52SRafael J. Wysocki acpi_bus_get_device(handle, &device); 325c8f7a62cSLen Brown } 326c8f7a62cSLen Brown return device; 327c8f7a62cSLen Brown } 328c8f7a62cSLen Brown 329c8f7a62cSLen Brown /** 330c8f7a62cSLen Brown * dock_remove_acpi_device - remove the acpi_device struct from acpi 331c8f7a62cSLen Brown * @handle - the handle of the device to remove 332c8f7a62cSLen Brown * 333c8f7a62cSLen Brown * Tell acpi to remove the acpi_device. This should cause any loaded 334c8f7a62cSLen Brown * driver to have it's remove routine called. 335c8f7a62cSLen Brown */ 336c8f7a62cSLen Brown static void dock_remove_acpi_device(acpi_handle handle) 337c8f7a62cSLen Brown { 338c8f7a62cSLen Brown struct acpi_device *device; 339c8f7a62cSLen Brown int ret; 340c8f7a62cSLen Brown 341c8f7a62cSLen Brown if (!acpi_bus_get_device(handle, &device)) { 342c8f7a62cSLen Brown ret = acpi_bus_trim(device, 1); 343c8f7a62cSLen Brown if (ret) 344c8f7a62cSLen Brown pr_debug("error removing bus, %x\n", -ret); 345c8f7a62cSLen Brown } 346c8f7a62cSLen Brown } 347c8f7a62cSLen Brown 348c8f7a62cSLen Brown /** 349c8f7a62cSLen Brown * hotplug_dock_devices - insert or remove devices on the dock station 350c8f7a62cSLen Brown * @ds: the dock station 351c8f7a62cSLen Brown * @event: either bus check or eject request 352c8f7a62cSLen Brown * 353c8f7a62cSLen Brown * Some devices on the dock station need to have drivers called 354c8f7a62cSLen Brown * to perform hotplug operations after a dock event has occurred. 355c8f7a62cSLen Brown * Traverse the list of dock devices that have registered a 356c8f7a62cSLen Brown * hotplug handler, and call the handler. 357c8f7a62cSLen Brown */ 358c8f7a62cSLen Brown static void hotplug_dock_devices(struct dock_station *ds, u32 event) 359c8f7a62cSLen Brown { 360c8f7a62cSLen Brown struct dock_dependent_device *dd; 361c8f7a62cSLen Brown 3628b0dc866SKristen Carlson Accardi mutex_lock(&ds->hp_lock); 363c8f7a62cSLen Brown 364c8f7a62cSLen Brown /* 365c8f7a62cSLen Brown * First call driver specific hotplug functions 366c8f7a62cSLen Brown */ 367747479a3SAlex Chiang list_for_each_entry(dd, &ds->hotplug_devices, hotplug_list) 3681253f7aaSShaohua Li if (dd->ops && dd->ops->handler) 3691253f7aaSShaohua Li dd->ops->handler(dd->handle, event, dd->context); 370c8f7a62cSLen Brown 371c8f7a62cSLen Brown /* 372c8f7a62cSLen Brown * Now make sure that an acpi_device is created for each 373c8f7a62cSLen Brown * dependent device, or removed if this is an eject request. 374c8f7a62cSLen Brown * This will cause acpi_drivers to be stopped/started if they 375c8f7a62cSLen Brown * exist 376c8f7a62cSLen Brown */ 377c8f7a62cSLen Brown list_for_each_entry(dd, &ds->dependent_devices, list) { 378c8f7a62cSLen Brown if (event == ACPI_NOTIFY_EJECT_REQUEST) 379c8f7a62cSLen Brown dock_remove_acpi_device(dd->handle); 380c8f7a62cSLen Brown else 381c8f7a62cSLen Brown dock_create_acpi_device(dd->handle); 382c8f7a62cSLen Brown } 3838b0dc866SKristen Carlson Accardi mutex_unlock(&ds->hp_lock); 384c8f7a62cSLen Brown } 385c8f7a62cSLen Brown 386c8f7a62cSLen Brown static void dock_event(struct dock_station *ds, u32 event, int num) 387c8f7a62cSLen Brown { 388db350b08SShaohua Li struct device *dev = &ds->dock_device->dev; 38966b56821SHolger Macht char event_string[13]; 39079a8f70bSKristen Carlson Accardi char *envp[] = { event_string, NULL }; 3911253f7aaSShaohua Li struct dock_dependent_device *dd; 39279a8f70bSKristen Carlson Accardi 39379a8f70bSKristen Carlson Accardi if (num == UNDOCK_EVENT) 39466b56821SHolger Macht sprintf(event_string, "EVENT=undock"); 39579a8f70bSKristen Carlson Accardi else 39666b56821SHolger Macht sprintf(event_string, "EVENT=dock"); 39779a8f70bSKristen Carlson Accardi 3985669021eSKristen Carlson Accardi /* 3998ea86e0bSKristen Carlson Accardi * Indicate that the status of the dock station has 4008ea86e0bSKristen Carlson Accardi * changed. 4015669021eSKristen Carlson Accardi */ 4021253f7aaSShaohua Li if (num == DOCK_EVENT) 4031253f7aaSShaohua Li kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp); 4041253f7aaSShaohua Li 4051253f7aaSShaohua Li list_for_each_entry(dd, &ds->hotplug_devices, hotplug_list) 4061253f7aaSShaohua Li if (dd->ops && dd->ops->uevent) 4071253f7aaSShaohua Li dd->ops->uevent(dd->handle, event, dd->context); 408747479a3SAlex Chiang 4091253f7aaSShaohua Li if (num != DOCK_EVENT) 41079a8f70bSKristen Carlson Accardi kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp); 411c8f7a62cSLen Brown } 412c8f7a62cSLen Brown 413c8f7a62cSLen Brown /** 414c8f7a62cSLen Brown * eject_dock - respond to a dock eject request 415c8f7a62cSLen Brown * @ds: the dock station 416c8f7a62cSLen Brown * 417c8f7a62cSLen Brown * This is called after _DCK is called, to execute the dock station's 418c8f7a62cSLen Brown * _EJ0 method. 419c8f7a62cSLen Brown */ 420c8f7a62cSLen Brown static void eject_dock(struct dock_station *ds) 421c8f7a62cSLen Brown { 422c8f7a62cSLen Brown struct acpi_object_list arg_list; 423c8f7a62cSLen Brown union acpi_object arg; 424c8f7a62cSLen Brown acpi_status status; 425c8f7a62cSLen Brown acpi_handle tmp; 426c8f7a62cSLen Brown 427c8f7a62cSLen Brown /* all dock devices should have _EJ0, but check anyway */ 428c8f7a62cSLen Brown status = acpi_get_handle(ds->handle, "_EJ0", &tmp); 429c8f7a62cSLen Brown if (ACPI_FAILURE(status)) { 430c8f7a62cSLen Brown pr_debug("No _EJ0 support for dock device\n"); 431c8f7a62cSLen Brown return; 432c8f7a62cSLen Brown } 433c8f7a62cSLen Brown 434c8f7a62cSLen Brown arg_list.count = 1; 435c8f7a62cSLen Brown arg_list.pointer = &arg; 436c8f7a62cSLen Brown arg.type = ACPI_TYPE_INTEGER; 437c8f7a62cSLen Brown arg.integer.value = 1; 438c8f7a62cSLen Brown 439747479a3SAlex Chiang status = acpi_evaluate_object(ds->handle, "_EJ0", &arg_list, NULL); 440747479a3SAlex Chiang if (ACPI_FAILURE(status)) 441c8f7a62cSLen Brown pr_debug("Failed to evaluate _EJ0!\n"); 442c8f7a62cSLen Brown } 443c8f7a62cSLen Brown 444c8f7a62cSLen Brown /** 445c8f7a62cSLen Brown * handle_dock - handle a dock event 446c8f7a62cSLen Brown * @ds: the dock station 447c8f7a62cSLen Brown * @dock: to dock, or undock - that is the question 448c8f7a62cSLen Brown * 449c8f7a62cSLen Brown * Execute the _DCK method in response to an acpi event 450c8f7a62cSLen Brown */ 451c8f7a62cSLen Brown static void handle_dock(struct dock_station *ds, int dock) 452c8f7a62cSLen Brown { 453c8f7a62cSLen Brown acpi_status status; 454c8f7a62cSLen Brown struct acpi_object_list arg_list; 455c8f7a62cSLen Brown union acpi_object arg; 456c8f7a62cSLen Brown struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 457c8f7a62cSLen Brown 458cd73018fSToshi Kani acpi_handle_info(ds->handle, "%s\n", dock ? "docking" : "undocking"); 459c8f7a62cSLen Brown 460c8f7a62cSLen Brown /* _DCK method has one argument */ 461c8f7a62cSLen Brown arg_list.count = 1; 462c8f7a62cSLen Brown arg_list.pointer = &arg; 463c8f7a62cSLen Brown arg.type = ACPI_TYPE_INTEGER; 464c8f7a62cSLen Brown arg.integer.value = dock; 465c8f7a62cSLen Brown status = acpi_evaluate_object(ds->handle, "_DCK", &arg_list, &buffer); 466db350b08SShaohua Li if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) 467cd73018fSToshi Kani acpi_handle_err(ds->handle, "Failed to execute _DCK (0x%x)\n", 468cd73018fSToshi Kani status); 4690a918a94SThomas Renninger 470c8f7a62cSLen Brown kfree(buffer.pointer); 471c8f7a62cSLen Brown } 472c8f7a62cSLen Brown 473c8f7a62cSLen Brown static inline void dock(struct dock_station *ds) 474c8f7a62cSLen Brown { 475c8f7a62cSLen Brown handle_dock(ds, 1); 476c8f7a62cSLen Brown } 477c8f7a62cSLen Brown 478c8f7a62cSLen Brown static inline void undock(struct dock_station *ds) 479c8f7a62cSLen Brown { 480c8f7a62cSLen Brown handle_dock(ds, 0); 481c8f7a62cSLen Brown } 482c8f7a62cSLen Brown 483c8f7a62cSLen Brown static inline void begin_dock(struct dock_station *ds) 484c8f7a62cSLen Brown { 485c8f7a62cSLen Brown ds->flags |= DOCK_DOCKING; 486c8f7a62cSLen Brown } 487c8f7a62cSLen Brown 488c8f7a62cSLen Brown static inline void complete_dock(struct dock_station *ds) 489c8f7a62cSLen Brown { 490c8f7a62cSLen Brown ds->flags &= ~(DOCK_DOCKING); 491c8f7a62cSLen Brown ds->last_dock_time = jiffies; 492c8f7a62cSLen Brown } 493c8f7a62cSLen Brown 494a0cd35fdSKristen Carlson Accardi static inline void begin_undock(struct dock_station *ds) 495a0cd35fdSKristen Carlson Accardi { 496a0cd35fdSKristen Carlson Accardi ds->flags |= DOCK_UNDOCKING; 497a0cd35fdSKristen Carlson Accardi } 498a0cd35fdSKristen Carlson Accardi 499a0cd35fdSKristen Carlson Accardi static inline void complete_undock(struct dock_station *ds) 500a0cd35fdSKristen Carlson Accardi { 501a0cd35fdSKristen Carlson Accardi ds->flags &= ~(DOCK_UNDOCKING); 502a0cd35fdSKristen Carlson Accardi } 503a0cd35fdSKristen Carlson Accardi 504406f692dSShaohua Li static void dock_lock(struct dock_station *ds, int lock) 505406f692dSShaohua Li { 506406f692dSShaohua Li struct acpi_object_list arg_list; 507406f692dSShaohua Li union acpi_object arg; 508406f692dSShaohua Li acpi_status status; 509406f692dSShaohua Li 510406f692dSShaohua Li arg_list.count = 1; 511406f692dSShaohua Li arg_list.pointer = &arg; 512406f692dSShaohua Li arg.type = ACPI_TYPE_INTEGER; 513406f692dSShaohua Li arg.integer.value = !!lock; 514406f692dSShaohua Li status = acpi_evaluate_object(ds->handle, "_LCK", &arg_list, NULL); 515406f692dSShaohua Li if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 516406f692dSShaohua Li if (lock) 517cd73018fSToshi Kani acpi_handle_warn(ds->handle, 518cd73018fSToshi Kani "Locking device failed (0x%x)\n", status); 519406f692dSShaohua Li else 520cd73018fSToshi Kani acpi_handle_warn(ds->handle, 521cd73018fSToshi Kani "Unlocking device failed (0x%x)\n", status); 522406f692dSShaohua Li } 523406f692dSShaohua Li } 524406f692dSShaohua Li 525c8f7a62cSLen Brown /** 526c8f7a62cSLen Brown * dock_in_progress - see if we are in the middle of handling a dock event 527c8f7a62cSLen Brown * @ds: the dock station 528c8f7a62cSLen Brown * 529c8f7a62cSLen Brown * Sometimes while docking, false dock events can be sent to the driver 530c8f7a62cSLen Brown * because good connections aren't made or some other reason. Ignore these 531c8f7a62cSLen Brown * if we are in the middle of doing something. 532c8f7a62cSLen Brown */ 533c8f7a62cSLen Brown static int dock_in_progress(struct dock_station *ds) 534c8f7a62cSLen Brown { 535c8f7a62cSLen Brown if ((ds->flags & DOCK_DOCKING) || 536c8f7a62cSLen Brown time_before(jiffies, (ds->last_dock_time + HZ))) 537c8f7a62cSLen Brown return 1; 538c8f7a62cSLen Brown return 0; 539c8f7a62cSLen Brown } 540c8f7a62cSLen Brown 541c8f7a62cSLen Brown /** 542c8f7a62cSLen Brown * register_dock_notifier - add yourself to the dock notifier list 543c8f7a62cSLen Brown * @nb: the callers notifier block 544c8f7a62cSLen Brown * 545c8f7a62cSLen Brown * If a driver wishes to be notified about dock events, they can 546c8f7a62cSLen Brown * use this function to put a notifier block on the dock notifier list. 547c8f7a62cSLen Brown * this notifier call chain will be called after a dock event, but 548c8f7a62cSLen Brown * before hotplugging any new devices. 549c8f7a62cSLen Brown */ 550c8f7a62cSLen Brown int register_dock_notifier(struct notifier_block *nb) 551c8f7a62cSLen Brown { 552db350b08SShaohua Li if (!dock_station_count) 5532548c06bSPrarit Bhargava return -ENODEV; 5542548c06bSPrarit Bhargava 555c8f7a62cSLen Brown return atomic_notifier_chain_register(&dock_notifier_list, nb); 556c8f7a62cSLen Brown } 557c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(register_dock_notifier); 558c8f7a62cSLen Brown 559c8f7a62cSLen Brown /** 560c8f7a62cSLen Brown * unregister_dock_notifier - remove yourself from the dock notifier list 561c8f7a62cSLen Brown * @nb: the callers notifier block 562c8f7a62cSLen Brown */ 563c8f7a62cSLen Brown void unregister_dock_notifier(struct notifier_block *nb) 564c8f7a62cSLen Brown { 565db350b08SShaohua Li if (!dock_station_count) 5662548c06bSPrarit Bhargava return; 5672548c06bSPrarit Bhargava 568c8f7a62cSLen Brown atomic_notifier_chain_unregister(&dock_notifier_list, nb); 569c8f7a62cSLen Brown } 570c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(unregister_dock_notifier); 571c8f7a62cSLen Brown 572c8f7a62cSLen Brown /** 573c8f7a62cSLen Brown * register_hotplug_dock_device - register a hotplug function 574c8f7a62cSLen Brown * @handle: the handle of the device 5751253f7aaSShaohua Li * @ops: handlers to call after docking 576c8f7a62cSLen Brown * @context: device specific data 577c8f7a62cSLen Brown * 578c8f7a62cSLen Brown * If a driver would like to perform a hotplug operation after a dock 579c8f7a62cSLen Brown * event, they can register an acpi_notifiy_handler to be called by 580c8f7a62cSLen Brown * the dock driver after _DCK is executed. 581c8f7a62cSLen Brown */ 582c8f7a62cSLen Brown int 5839c8b04beSVasiliy Kulikov register_hotplug_dock_device(acpi_handle handle, const struct acpi_dock_ops *ops, 584c8f7a62cSLen Brown void *context) 585c8f7a62cSLen Brown { 586c8f7a62cSLen Brown struct dock_dependent_device *dd; 587db350b08SShaohua Li struct dock_station *dock_station; 58861b83695SShaohua Li int ret = -EINVAL; 589c8f7a62cSLen Brown 590db350b08SShaohua Li if (!dock_station_count) 591c8f7a62cSLen Brown return -ENODEV; 592c8f7a62cSLen Brown 593c8f7a62cSLen Brown /* 594c8f7a62cSLen Brown * make sure this handle is for a device dependent on the dock, 595c8f7a62cSLen Brown * this would include the dock station itself 596c8f7a62cSLen Brown */ 59750d716e4SAlex Chiang list_for_each_entry(dock_station, &dock_stations, sibling) { 59861b83695SShaohua Li /* 59961b83695SShaohua Li * An ATA bay can be in a dock and itself can be ejected 6003ad2f3fbSDaniel Mack * separately, so there are two 'dock stations' which need the 60161b83695SShaohua Li * ops 60261b83695SShaohua Li */ 603c8f7a62cSLen Brown dd = find_dock_dependent_device(dock_station, handle); 604c8f7a62cSLen Brown if (dd) { 6051253f7aaSShaohua Li dd->ops = ops; 606c8f7a62cSLen Brown dd->context = context; 607c8f7a62cSLen Brown dock_add_hotplug_device(dock_station, dd); 60861b83695SShaohua Li ret = 0; 609c8f7a62cSLen Brown } 610db350b08SShaohua Li } 611c8f7a62cSLen Brown 61261b83695SShaohua Li return ret; 613c8f7a62cSLen Brown } 614c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(register_hotplug_dock_device); 615c8f7a62cSLen Brown 616c8f7a62cSLen Brown /** 617c8f7a62cSLen Brown * unregister_hotplug_dock_device - remove yourself from the hotplug list 618c8f7a62cSLen Brown * @handle: the acpi handle of the device 619c8f7a62cSLen Brown */ 620c8f7a62cSLen Brown void unregister_hotplug_dock_device(acpi_handle handle) 621c8f7a62cSLen Brown { 622c8f7a62cSLen Brown struct dock_dependent_device *dd; 623db350b08SShaohua Li struct dock_station *dock_station; 624c8f7a62cSLen Brown 625db350b08SShaohua Li if (!dock_station_count) 626c8f7a62cSLen Brown return; 627c8f7a62cSLen Brown 62850d716e4SAlex Chiang list_for_each_entry(dock_station, &dock_stations, sibling) { 629c8f7a62cSLen Brown dd = find_dock_dependent_device(dock_station, handle); 630c8f7a62cSLen Brown if (dd) 631c8f7a62cSLen Brown dock_del_hotplug_device(dock_station, dd); 632c8f7a62cSLen Brown } 633db350b08SShaohua Li } 634c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(unregister_hotplug_dock_device); 635c8f7a62cSLen Brown 636c8f7a62cSLen Brown /** 637c80fdbe8Sbrandon@ifup.org * handle_eject_request - handle an undock request checking for error conditions 638c80fdbe8Sbrandon@ifup.org * 639c80fdbe8Sbrandon@ifup.org * Check to make sure the dock device is still present, then undock and 640c80fdbe8Sbrandon@ifup.org * hotremove all the devices that may need removing. 641c80fdbe8Sbrandon@ifup.org */ 642c80fdbe8Sbrandon@ifup.org static int handle_eject_request(struct dock_station *ds, u32 event) 643c80fdbe8Sbrandon@ifup.org { 644c80fdbe8Sbrandon@ifup.org if (dock_in_progress(ds)) 645c80fdbe8Sbrandon@ifup.org return -EBUSY; 646c80fdbe8Sbrandon@ifup.org 647c80fdbe8Sbrandon@ifup.org /* 648c80fdbe8Sbrandon@ifup.org * here we need to generate the undock 649c80fdbe8Sbrandon@ifup.org * event prior to actually doing the undock 650c80fdbe8Sbrandon@ifup.org * so that the device struct still exists. 651afd7301dSHolger Macht * Also, even send the dock event if the 652afd7301dSHolger Macht * device is not present anymore 653c80fdbe8Sbrandon@ifup.org */ 654c80fdbe8Sbrandon@ifup.org dock_event(ds, event, UNDOCK_EVENT); 655afd7301dSHolger Macht 656c80fdbe8Sbrandon@ifup.org hotplug_dock_devices(ds, ACPI_NOTIFY_EJECT_REQUEST); 657c80fdbe8Sbrandon@ifup.org undock(ds); 658406f692dSShaohua Li dock_lock(ds, 0); 659c80fdbe8Sbrandon@ifup.org eject_dock(ds); 660c80fdbe8Sbrandon@ifup.org if (dock_present(ds)) { 661cd73018fSToshi Kani acpi_handle_err(ds->handle, "Unable to undock!\n"); 662c80fdbe8Sbrandon@ifup.org return -EBUSY; 663c80fdbe8Sbrandon@ifup.org } 664a0cd35fdSKristen Carlson Accardi complete_undock(ds); 665c80fdbe8Sbrandon@ifup.org return 0; 666c80fdbe8Sbrandon@ifup.org } 667c80fdbe8Sbrandon@ifup.org 668c80fdbe8Sbrandon@ifup.org /** 669c8f7a62cSLen Brown * dock_notify - act upon an acpi dock notification 670c8f7a62cSLen Brown * @handle: the dock station handle 671c8f7a62cSLen Brown * @event: the acpi event 672c8f7a62cSLen Brown * @data: our driver data struct 673c8f7a62cSLen Brown * 674c8f7a62cSLen Brown * If we are notified to dock, then check to see if the dock is 675c8f7a62cSLen Brown * present and then dock. Notify all drivers of the dock event, 676c80fdbe8Sbrandon@ifup.org * and then hotplug and devices that may need hotplugging. 677c8f7a62cSLen Brown */ 678c8f7a62cSLen Brown static void dock_notify(acpi_handle handle, u32 event, void *data) 679c8f7a62cSLen Brown { 68050dd0969SJan Engelhardt struct dock_station *ds = data; 6818b59560aSShaohua Li struct acpi_device *tmp; 682db350b08SShaohua Li int surprise_removal = 0; 683c8f7a62cSLen Brown 684db350b08SShaohua Li /* 685db350b08SShaohua Li * According to acpi spec 3.0a, if a DEVICE_CHECK notification 686db350b08SShaohua Li * is sent and _DCK is present, it is assumed to mean an undock 687db350b08SShaohua Li * request. 688db350b08SShaohua Li */ 689db350b08SShaohua Li if ((ds->flags & DOCK_IS_DOCK) && event == ACPI_NOTIFY_DEVICE_CHECK) 690db350b08SShaohua Li event = ACPI_NOTIFY_EJECT_REQUEST; 691db350b08SShaohua Li 692db350b08SShaohua Li /* 693db350b08SShaohua Li * dock station: BUS_CHECK - docked or surprise removal 694db350b08SShaohua Li * DEVICE_CHECK - undocked 695db350b08SShaohua Li * other device: BUS_CHECK/DEVICE_CHECK - added or surprise removal 696db350b08SShaohua Li * 697db350b08SShaohua Li * To simplify event handling, dock dependent device handler always 698db350b08SShaohua Li * get ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and 699db350b08SShaohua Li * ACPI_NOTIFY_EJECT_REQUEST for removal 700db350b08SShaohua Li */ 701c8f7a62cSLen Brown switch (event) { 702c8f7a62cSLen Brown case ACPI_NOTIFY_BUS_CHECK: 703db350b08SShaohua Li case ACPI_NOTIFY_DEVICE_CHECK: 7048b59560aSShaohua Li if (!dock_in_progress(ds) && acpi_bus_get_device(ds->handle, 7058b59560aSShaohua Li &tmp)) { 706c8f7a62cSLen Brown begin_dock(ds); 707c8f7a62cSLen Brown dock(ds); 708c8f7a62cSLen Brown if (!dock_present(ds)) { 709cd73018fSToshi Kani acpi_handle_err(handle, "Unable to dock!\n"); 7108b59560aSShaohua Li complete_dock(ds); 711c8f7a62cSLen Brown break; 712c8f7a62cSLen Brown } 713c8f7a62cSLen Brown atomic_notifier_call_chain(&dock_notifier_list, 714c8f7a62cSLen Brown event, NULL); 715c8f7a62cSLen Brown hotplug_dock_devices(ds, event); 716c8f7a62cSLen Brown complete_dock(ds); 717c8f7a62cSLen Brown dock_event(ds, event, DOCK_EVENT); 718406f692dSShaohua Li dock_lock(ds, 1); 7193a37898dSLin Ming acpi_update_all_gpes(); 720c8f7a62cSLen Brown break; 721db350b08SShaohua Li } 722db350b08SShaohua Li if (dock_present(ds) || dock_in_progress(ds)) 723db350b08SShaohua Li break; 724db350b08SShaohua Li /* This is a surprise removal */ 725db350b08SShaohua Li surprise_removal = 1; 726db350b08SShaohua Li event = ACPI_NOTIFY_EJECT_REQUEST; 727db350b08SShaohua Li /* Fall back */ 728c8f7a62cSLen Brown case ACPI_NOTIFY_EJECT_REQUEST: 729a0cd35fdSKristen Carlson Accardi begin_undock(ds); 730f730ae18SShaohua Li if ((immediate_undock && !(ds->flags & DOCK_IS_ATA)) 731f730ae18SShaohua Li || surprise_removal) 732c80fdbe8Sbrandon@ifup.org handle_eject_request(ds, event); 733a0cd35fdSKristen Carlson Accardi else 734a0cd35fdSKristen Carlson Accardi dock_event(ds, event, UNDOCK_EVENT); 735c8f7a62cSLen Brown break; 736c8f7a62cSLen Brown default: 737cd73018fSToshi Kani acpi_handle_err(handle, "Unknown dock event %d\n", event); 738c8f7a62cSLen Brown } 739c8f7a62cSLen Brown } 740c8f7a62cSLen Brown 74119cd847aSZhang Rui struct dock_data { 74219cd847aSZhang Rui acpi_handle handle; 74319cd847aSZhang Rui unsigned long event; 74419cd847aSZhang Rui struct dock_station *ds; 74519cd847aSZhang Rui }; 74619cd847aSZhang Rui 74719cd847aSZhang Rui static void acpi_dock_deferred_cb(void *context) 74819cd847aSZhang Rui { 749747479a3SAlex Chiang struct dock_data *data = context; 75019cd847aSZhang Rui 75119cd847aSZhang Rui dock_notify(data->handle, data->event, data->ds); 75219cd847aSZhang Rui kfree(data); 75319cd847aSZhang Rui } 75419cd847aSZhang Rui 7556bd00a61SShaohua Li static int acpi_dock_notifier_call(struct notifier_block *this, 7566bd00a61SShaohua Li unsigned long event, void *data) 7576bd00a61SShaohua Li { 7586bd00a61SShaohua Li struct dock_station *dock_station; 759747479a3SAlex Chiang acpi_handle handle = data; 7606bd00a61SShaohua Li 7616bd00a61SShaohua Li if (event != ACPI_NOTIFY_BUS_CHECK && event != ACPI_NOTIFY_DEVICE_CHECK 7626bd00a61SShaohua Li && event != ACPI_NOTIFY_EJECT_REQUEST) 7636bd00a61SShaohua Li return 0; 76450d716e4SAlex Chiang list_for_each_entry(dock_station, &dock_stations, sibling) { 7656bd00a61SShaohua Li if (dock_station->handle == handle) { 766747479a3SAlex Chiang struct dock_data *dd; 76719cd847aSZhang Rui 768747479a3SAlex Chiang dd = kmalloc(sizeof(*dd), GFP_KERNEL); 769747479a3SAlex Chiang if (!dd) 77019cd847aSZhang Rui return 0; 771747479a3SAlex Chiang dd->handle = handle; 772747479a3SAlex Chiang dd->event = event; 773747479a3SAlex Chiang dd->ds = dock_station; 774747479a3SAlex Chiang acpi_os_hotplug_execute(acpi_dock_deferred_cb, dd); 7756bd00a61SShaohua Li return 0 ; 7766bd00a61SShaohua Li } 7776bd00a61SShaohua Li } 7786bd00a61SShaohua Li return 0; 7796bd00a61SShaohua Li } 7806bd00a61SShaohua Li 7816bd00a61SShaohua Li static struct notifier_block dock_acpi_notifier = { 7826bd00a61SShaohua Li .notifier_call = acpi_dock_notifier_call, 7836bd00a61SShaohua Li }; 7846bd00a61SShaohua Li 785c8f7a62cSLen Brown /** 786c8f7a62cSLen Brown * find_dock_devices - find devices on the dock station 787c8f7a62cSLen Brown * @handle: the handle of the device we are examining 788c8f7a62cSLen Brown * @lvl: unused 789c8f7a62cSLen Brown * @context: the dock station private data 790c8f7a62cSLen Brown * @rv: unused 791c8f7a62cSLen Brown * 792c8f7a62cSLen Brown * This function is called by acpi_walk_namespace. It will 793c8f7a62cSLen Brown * check to see if an object has an _EJD method. If it does, then it 794c8f7a62cSLen Brown * will see if it is dependent on the dock station. 795c8f7a62cSLen Brown */ 796c8f7a62cSLen Brown static acpi_status 797c8f7a62cSLen Brown find_dock_devices(acpi_handle handle, u32 lvl, void *context, void **rv) 798c8f7a62cSLen Brown { 799c8f7a62cSLen Brown acpi_status status; 800fe9a2f77SKristen Carlson Accardi acpi_handle tmp, parent; 80150dd0969SJan Engelhardt struct dock_station *ds = context; 802c8f7a62cSLen Brown 803c8f7a62cSLen Brown status = acpi_bus_get_ejd(handle, &tmp); 804fe9a2f77SKristen Carlson Accardi if (ACPI_FAILURE(status)) { 805fe9a2f77SKristen Carlson Accardi /* try the parent device as well */ 806fe9a2f77SKristen Carlson Accardi status = acpi_get_parent(handle, &parent); 807c8f7a62cSLen Brown if (ACPI_FAILURE(status)) 808fe9a2f77SKristen Carlson Accardi goto fdd_out; 809fe9a2f77SKristen Carlson Accardi /* see if parent is dependent on dock */ 810fe9a2f77SKristen Carlson Accardi status = acpi_bus_get_ejd(parent, &tmp); 811fe9a2f77SKristen Carlson Accardi if (ACPI_FAILURE(status)) 812fe9a2f77SKristen Carlson Accardi goto fdd_out; 813fe9a2f77SKristen Carlson Accardi } 814c8f7a62cSLen Brown 815f69cfdd2SAlex Chiang if (tmp == ds->handle) 816f69cfdd2SAlex Chiang add_dock_dependent_device(ds, handle); 817f69cfdd2SAlex Chiang 818fe9a2f77SKristen Carlson Accardi fdd_out: 819c8f7a62cSLen Brown return AE_OK; 820c8f7a62cSLen Brown } 821c8f7a62cSLen Brown 822c80fdbe8Sbrandon@ifup.org /* 823c80fdbe8Sbrandon@ifup.org * show_docked - read method for "docked" file in sysfs 824c80fdbe8Sbrandon@ifup.org */ 825c80fdbe8Sbrandon@ifup.org static ssize_t show_docked(struct device *dev, 826c80fdbe8Sbrandon@ifup.org struct device_attribute *attr, char *buf) 827c80fdbe8Sbrandon@ifup.org { 828fc5a9f88SHolger Macht struct acpi_device *tmp; 829fc5a9f88SHolger Macht 830fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 831c80fdbe8Sbrandon@ifup.org 832fc5a9f88SHolger Macht if (ACPI_SUCCESS(acpi_bus_get_device(dock_station->handle, &tmp))) 833fc5a9f88SHolger Macht return snprintf(buf, PAGE_SIZE, "1\n"); 834fc5a9f88SHolger Macht return snprintf(buf, PAGE_SIZE, "0\n"); 835c80fdbe8Sbrandon@ifup.org } 836e5685b9dSAdrian Bunk static DEVICE_ATTR(docked, S_IRUGO, show_docked, NULL); 837c80fdbe8Sbrandon@ifup.org 838c80fdbe8Sbrandon@ifup.org /* 839a0cd35fdSKristen Carlson Accardi * show_flags - read method for flags file in sysfs 840a0cd35fdSKristen Carlson Accardi */ 841a0cd35fdSKristen Carlson Accardi static ssize_t show_flags(struct device *dev, 842a0cd35fdSKristen Carlson Accardi struct device_attribute *attr, char *buf) 843a0cd35fdSKristen Carlson Accardi { 844fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 845a0cd35fdSKristen Carlson Accardi return snprintf(buf, PAGE_SIZE, "%d\n", dock_station->flags); 846a0cd35fdSKristen Carlson Accardi 847a0cd35fdSKristen Carlson Accardi } 848e5685b9dSAdrian Bunk static DEVICE_ATTR(flags, S_IRUGO, show_flags, NULL); 849a0cd35fdSKristen Carlson Accardi 850a0cd35fdSKristen Carlson Accardi /* 851c80fdbe8Sbrandon@ifup.org * write_undock - write method for "undock" file in sysfs 852c80fdbe8Sbrandon@ifup.org */ 853c80fdbe8Sbrandon@ifup.org static ssize_t write_undock(struct device *dev, struct device_attribute *attr, 854c80fdbe8Sbrandon@ifup.org const char *buf, size_t count) 855c80fdbe8Sbrandon@ifup.org { 856c80fdbe8Sbrandon@ifup.org int ret; 857fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 858c80fdbe8Sbrandon@ifup.org 859c80fdbe8Sbrandon@ifup.org if (!count) 860c80fdbe8Sbrandon@ifup.org return -EINVAL; 861c80fdbe8Sbrandon@ifup.org 8629171f834SHolger Macht begin_undock(dock_station); 863c80fdbe8Sbrandon@ifup.org ret = handle_eject_request(dock_station, ACPI_NOTIFY_EJECT_REQUEST); 864c80fdbe8Sbrandon@ifup.org return ret ? ret: count; 865c80fdbe8Sbrandon@ifup.org } 866e5685b9dSAdrian Bunk static DEVICE_ATTR(undock, S_IWUSR, NULL, write_undock); 867c80fdbe8Sbrandon@ifup.org 868ac122bb6SIlya A. Volynets-Evenbakh /* 869ac122bb6SIlya A. Volynets-Evenbakh * show_dock_uid - read method for "uid" file in sysfs 870ac122bb6SIlya A. Volynets-Evenbakh */ 871ac122bb6SIlya A. Volynets-Evenbakh static ssize_t show_dock_uid(struct device *dev, 872ac122bb6SIlya A. Volynets-Evenbakh struct device_attribute *attr, char *buf) 873ac122bb6SIlya A. Volynets-Evenbakh { 87427663c58SMatthew Wilcox unsigned long long lbuf; 875fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 87638ff4ffcSKristen Carlson Accardi acpi_status status = acpi_evaluate_integer(dock_station->handle, 87738ff4ffcSKristen Carlson Accardi "_UID", NULL, &lbuf); 87838ff4ffcSKristen Carlson Accardi if (ACPI_FAILURE(status)) 879ac122bb6SIlya A. Volynets-Evenbakh return 0; 88038ff4ffcSKristen Carlson Accardi 88127663c58SMatthew Wilcox return snprintf(buf, PAGE_SIZE, "%llx\n", lbuf); 882ac122bb6SIlya A. Volynets-Evenbakh } 883e5685b9dSAdrian Bunk static DEVICE_ATTR(uid, S_IRUGO, show_dock_uid, NULL); 884ac122bb6SIlya A. Volynets-Evenbakh 8858652b00fSShaohua Li static ssize_t show_dock_type(struct device *dev, 8868652b00fSShaohua Li struct device_attribute *attr, char *buf) 8878652b00fSShaohua Li { 888fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 8898652b00fSShaohua Li char *type; 8908652b00fSShaohua Li 8918652b00fSShaohua Li if (dock_station->flags & DOCK_IS_DOCK) 8928652b00fSShaohua Li type = "dock_station"; 8938652b00fSShaohua Li else if (dock_station->flags & DOCK_IS_ATA) 8948652b00fSShaohua Li type = "ata_bay"; 8958652b00fSShaohua Li else if (dock_station->flags & DOCK_IS_BAT) 8968652b00fSShaohua Li type = "battery_bay"; 8978652b00fSShaohua Li else 8988652b00fSShaohua Li type = "unknown"; 8998652b00fSShaohua Li 9008652b00fSShaohua Li return snprintf(buf, PAGE_SIZE, "%s\n", type); 9018652b00fSShaohua Li } 9028652b00fSShaohua Li static DEVICE_ATTR(type, S_IRUGO, show_dock_type, NULL); 9038652b00fSShaohua Li 9045f46c2f2SAlex Chiang static struct attribute *dock_attributes[] = { 9055f46c2f2SAlex Chiang &dev_attr_docked.attr, 9065f46c2f2SAlex Chiang &dev_attr_flags.attr, 9075f46c2f2SAlex Chiang &dev_attr_undock.attr, 9085f46c2f2SAlex Chiang &dev_attr_uid.attr, 9095f46c2f2SAlex Chiang &dev_attr_type.attr, 9105f46c2f2SAlex Chiang NULL 9115f46c2f2SAlex Chiang }; 9125f46c2f2SAlex Chiang 9135f46c2f2SAlex Chiang static struct attribute_group dock_attribute_group = { 9145f46c2f2SAlex Chiang .attrs = dock_attributes 9155f46c2f2SAlex Chiang }; 9165f46c2f2SAlex Chiang 917c8f7a62cSLen Brown /** 918c8f7a62cSLen Brown * dock_add - add a new dock station 919c8f7a62cSLen Brown * @handle: the dock station handle 920c8f7a62cSLen Brown * 921c8f7a62cSLen Brown * allocated and initialize a new dock station device. Find all devices 922c8f7a62cSLen Brown * that are on the dock station, and register for dock event notifications. 923c8f7a62cSLen Brown */ 924d38a5edfSUwe Kleine-König static int __init dock_add(acpi_handle handle) 925c8f7a62cSLen Brown { 926fe06fba2SAlex Chiang int ret, id; 927fe06fba2SAlex Chiang struct dock_station ds, *dock_station; 928747479a3SAlex Chiang struct platform_device *dd; 929c8f7a62cSLen Brown 930fe06fba2SAlex Chiang id = dock_station_count; 93149c6fb2eSAlex Chiang memset(&ds, 0, sizeof(ds)); 932747479a3SAlex Chiang dd = platform_device_register_data(NULL, "dock", id, &ds, sizeof(ds)); 933747479a3SAlex Chiang if (IS_ERR(dd)) 934747479a3SAlex Chiang return PTR_ERR(dd); 9359751cb72SAlex Chiang 936747479a3SAlex Chiang dock_station = dd->dev.platform_data; 937747479a3SAlex Chiang 938c8f7a62cSLen Brown dock_station->handle = handle; 939747479a3SAlex Chiang dock_station->dock_device = dd; 940c8f7a62cSLen Brown dock_station->last_dock_time = jiffies - HZ; 941c8f7a62cSLen Brown 942c8f7a62cSLen Brown mutex_init(&dock_station->hp_lock); 943747479a3SAlex Chiang spin_lock_init(&dock_station->dd_lock); 944747479a3SAlex Chiang INIT_LIST_HEAD(&dock_station->sibling); 945747479a3SAlex Chiang INIT_LIST_HEAD(&dock_station->hotplug_devices); 946c8f7a62cSLen Brown ATOMIC_INIT_NOTIFIER_HEAD(&dock_notifier_list); 947747479a3SAlex Chiang INIT_LIST_HEAD(&dock_station->dependent_devices); 948a0cd35fdSKristen Carlson Accardi 9499ef2a9a9SKristen Carlson Accardi /* we want the dock device to send uevents */ 950747479a3SAlex Chiang dev_set_uevent_suppress(&dd->dev, 0); 9519ef2a9a9SKristen Carlson Accardi 952db350b08SShaohua Li if (is_dock(handle)) 953db350b08SShaohua Li dock_station->flags |= DOCK_IS_DOCK; 954db350b08SShaohua Li if (is_ata(handle)) 955db350b08SShaohua Li dock_station->flags |= DOCK_IS_ATA; 956db350b08SShaohua Li if (is_battery(handle)) 957db350b08SShaohua Li dock_station->flags |= DOCK_IS_BAT; 958db350b08SShaohua Li 959747479a3SAlex Chiang ret = sysfs_create_group(&dd->dev.kobj, &dock_attribute_group); 9608652b00fSShaohua Li if (ret) 9615f46c2f2SAlex Chiang goto err_unregister; 962671adbecSKristen Carlson Accardi 963c8f7a62cSLen Brown /* Find dependent devices */ 964c8f7a62cSLen Brown acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 9652263576cSLin Ming ACPI_UINT32_MAX, find_dock_devices, NULL, 9662263576cSLin Ming dock_station, NULL); 967c8f7a62cSLen Brown 968c8f7a62cSLen Brown /* add the dock station as a device dependent on itself */ 969f69cfdd2SAlex Chiang ret = add_dock_dependent_device(dock_station, handle); 970f69cfdd2SAlex Chiang if (ret) 9715f46c2f2SAlex Chiang goto err_rmgroup; 972c8f7a62cSLen Brown 973db350b08SShaohua Li dock_station_count++; 97450d716e4SAlex Chiang list_add(&dock_station->sibling, &dock_stations); 975c8f7a62cSLen Brown return 0; 976c8f7a62cSLen Brown 9775f46c2f2SAlex Chiang err_rmgroup: 978747479a3SAlex Chiang sysfs_remove_group(&dd->dev.kobj, &dock_attribute_group); 9795f46c2f2SAlex Chiang err_unregister: 980747479a3SAlex Chiang platform_device_unregister(dd); 981cd73018fSToshi Kani acpi_handle_err(handle, "%s encountered error %d\n", __func__, ret); 982c8f7a62cSLen Brown return ret; 983c8f7a62cSLen Brown } 984c8f7a62cSLen Brown 985c8f7a62cSLen Brown /** 986c8f7a62cSLen Brown * dock_remove - free up resources related to the dock station 987c8f7a62cSLen Brown */ 988747479a3SAlex Chiang static int dock_remove(struct dock_station *ds) 989c8f7a62cSLen Brown { 990c8f7a62cSLen Brown struct dock_dependent_device *dd, *tmp; 991747479a3SAlex Chiang struct platform_device *dock_device = ds->dock_device; 992c8f7a62cSLen Brown 993db350b08SShaohua Li if (!dock_station_count) 994c8f7a62cSLen Brown return 0; 995c8f7a62cSLen Brown 996c8f7a62cSLen Brown /* remove dependent devices */ 997747479a3SAlex Chiang list_for_each_entry_safe(dd, tmp, &ds->dependent_devices, list) 998c8f7a62cSLen Brown kfree(dd); 999c8f7a62cSLen Brown 1000747479a3SAlex Chiang list_del(&ds->sibling); 1001fe06fba2SAlex Chiang 1002671adbecSKristen Carlson Accardi /* cleanup sysfs */ 10035f46c2f2SAlex Chiang sysfs_remove_group(&dock_device->dev.kobj, &dock_attribute_group); 10040f6f2804SKristen Carlson Accardi platform_device_unregister(dock_device); 1005671adbecSKristen Carlson Accardi 1006c8f7a62cSLen Brown return 0; 1007c8f7a62cSLen Brown } 1008c8f7a62cSLen Brown 1009c8f7a62cSLen Brown /** 10108ab0ab25SToshi Kani * find_dock_and_bay - look for dock stations and bays 1011c8f7a62cSLen Brown * @handle: acpi handle of a device 1012c8f7a62cSLen Brown * @lvl: unused 10138ab0ab25SToshi Kani * @context: unused 1014c8f7a62cSLen Brown * @rv: unused 1015c8f7a62cSLen Brown * 10168ab0ab25SToshi Kani * This is called by acpi_walk_namespace to look for dock stations and bays. 1017c8f7a62cSLen Brown */ 1018d38a5edfSUwe Kleine-König static __init acpi_status 10198ab0ab25SToshi Kani find_dock_and_bay(acpi_handle handle, u32 lvl, void *context, void **rv) 1020c8f7a62cSLen Brown { 10218ab0ab25SToshi Kani if (is_dock(handle) || is_ejectable_bay(handle)) 10221ee4d61fSZhang Rui dock_add(handle); 1023747479a3SAlex Chiang 10241ee4d61fSZhang Rui return AE_OK; 1025c8f7a62cSLen Brown } 1026c8f7a62cSLen Brown 1027c8f7a62cSLen Brown static int __init dock_init(void) 1028c8f7a62cSLen Brown { 1029816c2edaSLen Brown if (acpi_disabled) 1030816c2edaSLen Brown return 0; 1031816c2edaSLen Brown 10328ab0ab25SToshi Kani /* look for dock stations and bays */ 1033c8f7a62cSLen Brown acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 10348ab0ab25SToshi Kani ACPI_UINT32_MAX, find_dock_and_bay, NULL, NULL, NULL); 1035c8f7a62cSLen Brown 1036db350b08SShaohua Li if (!dock_station_count) { 1037cd73018fSToshi Kani pr_info(PREFIX "No dock devices found.\n"); 1038db350b08SShaohua Li return 0; 1039db350b08SShaohua Li } 1040c8f7a62cSLen Brown 10416bd00a61SShaohua Li register_acpi_bus_notifier(&dock_acpi_notifier); 1042cd73018fSToshi Kani pr_info(PREFIX "%s: %d docks/bays found\n", 1043db350b08SShaohua Li ACPI_DOCK_DRIVER_DESCRIPTION, dock_station_count); 1044c8f7a62cSLen Brown return 0; 1045c8f7a62cSLen Brown } 1046c8f7a62cSLen Brown 1047c8f7a62cSLen Brown static void __exit dock_exit(void) 1048c8f7a62cSLen Brown { 1049747479a3SAlex Chiang struct dock_station *tmp, *dock_station; 1050db350b08SShaohua Li 10516bd00a61SShaohua Li unregister_acpi_bus_notifier(&dock_acpi_notifier); 105250d716e4SAlex Chiang list_for_each_entry_safe(dock_station, tmp, &dock_stations, sibling) 1053db350b08SShaohua Li dock_remove(dock_station); 1054c8f7a62cSLen Brown } 1055c8f7a62cSLen Brown 1056db350b08SShaohua Li /* 1057db350b08SShaohua Li * Must be called before drivers of devices in dock, otherwise we can't know 1058db350b08SShaohua Li * which devices are in a dock 1059db350b08SShaohua Li */ 1060db350b08SShaohua Li subsys_initcall(dock_init); 1061c8f7a62cSLen Brown module_exit(dock_exit); 1062