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> 27c8f7a62cSLen Brown #include <linux/init.h> 28c8f7a62cSLen Brown #include <linux/types.h> 29c8f7a62cSLen Brown #include <linux/notifier.h> 30671adbecSKristen Carlson Accardi #include <linux/platform_device.h> 31914e2637SAl Viro #include <linux/jiffies.h> 3262a6d7fdSRandy Dunlap #include <linux/stddef.h> 33c8f7a62cSLen Brown #include <acpi/acpi_bus.h> 34c8f7a62cSLen Brown #include <acpi/acpi_drivers.h> 35c8f7a62cSLen Brown 36a192a958SLen Brown #define PREFIX "ACPI: " 37a192a958SLen Brown 387cda93e0SLen Brown #define ACPI_DOCK_DRIVER_DESCRIPTION "ACPI Dock Station Driver" 39c8f7a62cSLen Brown 40f52fd66dSLen Brown ACPI_MODULE_NAME("dock"); 41c8f7a62cSLen Brown MODULE_AUTHOR("Kristen Carlson Accardi"); 427cda93e0SLen Brown MODULE_DESCRIPTION(ACPI_DOCK_DRIVER_DESCRIPTION); 43c8f7a62cSLen Brown MODULE_LICENSE("GPL"); 44c8f7a62cSLen Brown 45a0cd35fdSKristen Carlson Accardi static int immediate_undock = 1; 46a0cd35fdSKristen Carlson Accardi module_param(immediate_undock, bool, 0644); 47a0cd35fdSKristen Carlson Accardi MODULE_PARM_DESC(immediate_undock, "1 (default) will cause the driver to " 48a0cd35fdSKristen Carlson Accardi "undock immediately when the undock button is pressed, 0 will cause" 49a0cd35fdSKristen Carlson Accardi " the driver to wait for userspace to write the undock sysfs file " 50a0cd35fdSKristen Carlson Accardi " before undocking"); 51a0cd35fdSKristen Carlson Accardi 52c8f7a62cSLen Brown static struct atomic_notifier_head dock_notifier_list; 53c8f7a62cSLen Brown 54a340af14SFrank Seidel static const struct acpi_device_id dock_device_ids[] = { 55a340af14SFrank Seidel {"LNXDOCK", 0}, 56a340af14SFrank Seidel {"", 0}, 57a340af14SFrank Seidel }; 58a340af14SFrank Seidel MODULE_DEVICE_TABLE(acpi, dock_device_ids); 59a340af14SFrank Seidel 60c8f7a62cSLen Brown struct dock_station { 61c8f7a62cSLen Brown acpi_handle handle; 62c8f7a62cSLen Brown unsigned long last_dock_time; 63c8f7a62cSLen Brown u32 flags; 64c8f7a62cSLen Brown spinlock_t dd_lock; 658b0dc866SKristen Carlson Accardi struct mutex hp_lock; 66c8f7a62cSLen Brown struct list_head dependent_devices; 67c8f7a62cSLen Brown struct list_head hotplug_devices; 68db350b08SShaohua Li 6950d716e4SAlex Chiang struct list_head sibling; 70db350b08SShaohua Li struct platform_device *dock_device; 71c8f7a62cSLen Brown }; 72db350b08SShaohua Li static LIST_HEAD(dock_stations); 73db350b08SShaohua Li static int dock_station_count; 74c8f7a62cSLen Brown 75c8f7a62cSLen Brown struct dock_dependent_device { 76c8f7a62cSLen Brown struct list_head list; 77c8f7a62cSLen Brown struct list_head hotplug_list; 78c8f7a62cSLen Brown acpi_handle handle; 791253f7aaSShaohua Li struct acpi_dock_ops *ops; 80c8f7a62cSLen Brown void *context; 81c8f7a62cSLen Brown }; 82c8f7a62cSLen Brown 83c8f7a62cSLen Brown #define DOCK_DOCKING 0x00000001 84a0cd35fdSKristen Carlson Accardi #define DOCK_UNDOCKING 0x00000002 85db350b08SShaohua Li #define DOCK_IS_DOCK 0x00000010 86db350b08SShaohua Li #define DOCK_IS_ATA 0x00000020 87db350b08SShaohua Li #define DOCK_IS_BAT 0x00000040 885669021eSKristen Carlson Accardi #define DOCK_EVENT 3 895669021eSKristen Carlson Accardi #define UNDOCK_EVENT 2 90c8f7a62cSLen Brown 91c8f7a62cSLen Brown /***************************************************************************** 92c8f7a62cSLen Brown * Dock Dependent device functions * 93c8f7a62cSLen Brown *****************************************************************************/ 94c8f7a62cSLen Brown /** 95f69cfdd2SAlex Chiang * add_dock_dependent_device - associate a device with the dock station 96f69cfdd2SAlex Chiang * @ds: The dock station 97f69cfdd2SAlex Chiang * @handle: handle of the dependent device 98c8f7a62cSLen Brown * 99f69cfdd2SAlex Chiang * Add the dependent device to the dock's dependent device list. 100c8f7a62cSLen Brown */ 101f69cfdd2SAlex Chiang static int 102f69cfdd2SAlex Chiang add_dock_dependent_device(struct dock_station *ds, acpi_handle handle) 103c8f7a62cSLen Brown { 104c8f7a62cSLen Brown struct dock_dependent_device *dd; 105c8f7a62cSLen Brown 106c8f7a62cSLen Brown dd = kzalloc(sizeof(*dd), GFP_KERNEL); 107f69cfdd2SAlex Chiang if (!dd) 108f69cfdd2SAlex Chiang return -ENOMEM; 109f69cfdd2SAlex Chiang 110c8f7a62cSLen Brown dd->handle = handle; 111c8f7a62cSLen Brown INIT_LIST_HEAD(&dd->list); 112c8f7a62cSLen Brown INIT_LIST_HEAD(&dd->hotplug_list); 113c8f7a62cSLen Brown 114c8f7a62cSLen Brown spin_lock(&ds->dd_lock); 115c8f7a62cSLen Brown list_add_tail(&dd->list, &ds->dependent_devices); 116c8f7a62cSLen Brown spin_unlock(&ds->dd_lock); 117f69cfdd2SAlex Chiang 118f69cfdd2SAlex Chiang return 0; 119c8f7a62cSLen Brown } 120c8f7a62cSLen Brown 121c8f7a62cSLen Brown /** 122c8f7a62cSLen Brown * dock_add_hotplug_device - associate a hotplug handler with the dock station 123c8f7a62cSLen Brown * @ds: The dock station 124c8f7a62cSLen Brown * @dd: The dependent device struct 125c8f7a62cSLen Brown * 126c8f7a62cSLen Brown * Add the dependent device to the dock's hotplug device list 127c8f7a62cSLen Brown */ 128c8f7a62cSLen Brown static void 129c8f7a62cSLen Brown dock_add_hotplug_device(struct dock_station *ds, 130c8f7a62cSLen Brown struct dock_dependent_device *dd) 131c8f7a62cSLen Brown { 1328b0dc866SKristen Carlson Accardi mutex_lock(&ds->hp_lock); 133c8f7a62cSLen Brown list_add_tail(&dd->hotplug_list, &ds->hotplug_devices); 1348b0dc866SKristen Carlson Accardi mutex_unlock(&ds->hp_lock); 135c8f7a62cSLen Brown } 136c8f7a62cSLen Brown 137c8f7a62cSLen Brown /** 138c8f7a62cSLen Brown * dock_del_hotplug_device - remove a hotplug handler from the dock station 139c8f7a62cSLen Brown * @ds: The dock station 140c8f7a62cSLen Brown * @dd: the dependent device struct 141c8f7a62cSLen Brown * 142c8f7a62cSLen Brown * Delete the dependent device from the dock's hotplug device list 143c8f7a62cSLen Brown */ 144c8f7a62cSLen Brown static void 145c8f7a62cSLen Brown dock_del_hotplug_device(struct dock_station *ds, 146c8f7a62cSLen Brown struct dock_dependent_device *dd) 147c8f7a62cSLen Brown { 1488b0dc866SKristen Carlson Accardi mutex_lock(&ds->hp_lock); 149c8f7a62cSLen Brown list_del(&dd->hotplug_list); 1508b0dc866SKristen Carlson Accardi mutex_unlock(&ds->hp_lock); 151c8f7a62cSLen Brown } 152c8f7a62cSLen Brown 153c8f7a62cSLen Brown /** 154c8f7a62cSLen Brown * find_dock_dependent_device - get a device dependent on this dock 155c8f7a62cSLen Brown * @ds: the dock station 156c8f7a62cSLen Brown * @handle: the acpi_handle of the device we want 157c8f7a62cSLen Brown * 158c8f7a62cSLen Brown * iterate over the dependent device list for this dock. If the 159c8f7a62cSLen Brown * dependent device matches the handle, return. 160c8f7a62cSLen Brown */ 161c8f7a62cSLen Brown static struct dock_dependent_device * 162c8f7a62cSLen Brown find_dock_dependent_device(struct dock_station *ds, acpi_handle handle) 163c8f7a62cSLen Brown { 164c8f7a62cSLen Brown struct dock_dependent_device *dd; 165c8f7a62cSLen Brown 166c8f7a62cSLen Brown spin_lock(&ds->dd_lock); 167c8f7a62cSLen Brown list_for_each_entry(dd, &ds->dependent_devices, list) { 168c8f7a62cSLen Brown if (handle == dd->handle) { 169c8f7a62cSLen Brown spin_unlock(&ds->dd_lock); 170c8f7a62cSLen Brown return dd; 171c8f7a62cSLen Brown } 172c8f7a62cSLen Brown } 173c8f7a62cSLen Brown spin_unlock(&ds->dd_lock); 174c8f7a62cSLen Brown return NULL; 175c8f7a62cSLen Brown } 176c8f7a62cSLen Brown 177c8f7a62cSLen Brown /***************************************************************************** 178c8f7a62cSLen Brown * Dock functions * 179c8f7a62cSLen Brown *****************************************************************************/ 180c8f7a62cSLen Brown /** 181c8f7a62cSLen Brown * is_dock - see if a device is a dock station 182c8f7a62cSLen Brown * @handle: acpi handle of the device 183c8f7a62cSLen Brown * 184c8f7a62cSLen Brown * If an acpi object has a _DCK method, then it is by definition a dock 185c8f7a62cSLen Brown * station, so return true. 186c8f7a62cSLen Brown */ 187c8f7a62cSLen Brown static int is_dock(acpi_handle handle) 188c8f7a62cSLen Brown { 189c8f7a62cSLen Brown acpi_status status; 190c8f7a62cSLen Brown acpi_handle tmp; 191c8f7a62cSLen Brown 192c8f7a62cSLen Brown status = acpi_get_handle(handle, "_DCK", &tmp); 193c8f7a62cSLen Brown if (ACPI_FAILURE(status)) 194c8f7a62cSLen Brown return 0; 195c8f7a62cSLen Brown return 1; 196c8f7a62cSLen Brown } 197c8f7a62cSLen Brown 198db350b08SShaohua Li static int is_ejectable(acpi_handle handle) 199db350b08SShaohua Li { 200db350b08SShaohua Li acpi_status status; 201db350b08SShaohua Li acpi_handle tmp; 202db350b08SShaohua Li 203db350b08SShaohua Li status = acpi_get_handle(handle, "_EJ0", &tmp); 204db350b08SShaohua Li if (ACPI_FAILURE(status)) 205db350b08SShaohua Li return 0; 206db350b08SShaohua Li return 1; 207db350b08SShaohua Li } 208db350b08SShaohua Li 209db350b08SShaohua Li static int is_ata(acpi_handle handle) 210db350b08SShaohua Li { 211db350b08SShaohua Li acpi_handle tmp; 212db350b08SShaohua Li 213db350b08SShaohua Li if ((ACPI_SUCCESS(acpi_get_handle(handle, "_GTF", &tmp))) || 214db350b08SShaohua Li (ACPI_SUCCESS(acpi_get_handle(handle, "_GTM", &tmp))) || 215db350b08SShaohua Li (ACPI_SUCCESS(acpi_get_handle(handle, "_STM", &tmp))) || 216db350b08SShaohua Li (ACPI_SUCCESS(acpi_get_handle(handle, "_SDD", &tmp)))) 217db350b08SShaohua Li return 1; 218db350b08SShaohua Li 219db350b08SShaohua Li return 0; 220db350b08SShaohua Li } 221db350b08SShaohua Li 222db350b08SShaohua Li static int is_battery(acpi_handle handle) 223db350b08SShaohua Li { 224db350b08SShaohua Li struct acpi_device_info *info; 225db350b08SShaohua Li int ret = 1; 226db350b08SShaohua Li 22715b8dd53SBob Moore if (!ACPI_SUCCESS(acpi_get_object_info(handle, &info))) 228db350b08SShaohua Li return 0; 229db350b08SShaohua Li if (!(info->valid & ACPI_VALID_HID)) 230db350b08SShaohua Li ret = 0; 231db350b08SShaohua Li else 23215b8dd53SBob Moore ret = !strcmp("PNP0C0A", info->hardware_id.string); 233db350b08SShaohua Li 23415b8dd53SBob Moore kfree(info); 235db350b08SShaohua Li return ret; 236db350b08SShaohua Li } 237db350b08SShaohua Li 238db350b08SShaohua Li static int is_ejectable_bay(acpi_handle handle) 239db350b08SShaohua Li { 240db350b08SShaohua Li acpi_handle phandle; 241db350b08SShaohua Li if (!is_ejectable(handle)) 242db350b08SShaohua Li return 0; 243db350b08SShaohua Li if (is_battery(handle) || is_ata(handle)) 244db350b08SShaohua Li return 1; 245db350b08SShaohua Li if (!acpi_get_parent(handle, &phandle) && is_ata(phandle)) 246db350b08SShaohua Li return 1; 247db350b08SShaohua Li return 0; 248db350b08SShaohua Li } 249db350b08SShaohua Li 250c8f7a62cSLen Brown /** 251c8f7a62cSLen Brown * is_dock_device - see if a device is on a dock station 252c8f7a62cSLen Brown * @handle: acpi handle of the device 253c8f7a62cSLen Brown * 254c8f7a62cSLen Brown * If this device is either the dock station itself, 255c8f7a62cSLen Brown * or is a device dependent on the dock station, then it 256c8f7a62cSLen Brown * is a dock device 257c8f7a62cSLen Brown */ 258c8f7a62cSLen Brown int is_dock_device(acpi_handle handle) 259c8f7a62cSLen Brown { 260db350b08SShaohua Li struct dock_station *dock_station; 261db350b08SShaohua Li 262db350b08SShaohua Li if (!dock_station_count) 263c8f7a62cSLen Brown return 0; 264c8f7a62cSLen Brown 265db350b08SShaohua Li if (is_dock(handle)) 266c8f7a62cSLen Brown return 1; 26750d716e4SAlex Chiang list_for_each_entry(dock_station, &dock_stations, sibling) { 268db350b08SShaohua Li if (find_dock_dependent_device(dock_station, handle)) 269db350b08SShaohua Li return 1; 270db350b08SShaohua Li } 271c8f7a62cSLen Brown 272c8f7a62cSLen Brown return 0; 273c8f7a62cSLen Brown } 274c8f7a62cSLen Brown 275c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(is_dock_device); 276c8f7a62cSLen Brown 277c8f7a62cSLen Brown /** 278c8f7a62cSLen Brown * dock_present - see if the dock station is present. 279c8f7a62cSLen Brown * @ds: the dock station 280c8f7a62cSLen Brown * 281c8f7a62cSLen Brown * execute the _STA method. note that present does not 282c8f7a62cSLen Brown * imply that we are docked. 283c8f7a62cSLen Brown */ 284c8f7a62cSLen Brown static int dock_present(struct dock_station *ds) 285c8f7a62cSLen Brown { 28627663c58SMatthew Wilcox unsigned long long sta; 287c8f7a62cSLen Brown acpi_status status; 288c8f7a62cSLen Brown 289c8f7a62cSLen Brown if (ds) { 290c8f7a62cSLen Brown status = acpi_evaluate_integer(ds->handle, "_STA", NULL, &sta); 291c8f7a62cSLen Brown if (ACPI_SUCCESS(status) && sta) 292c8f7a62cSLen Brown return 1; 293c8f7a62cSLen Brown } 294c8f7a62cSLen Brown return 0; 295c8f7a62cSLen Brown } 296c8f7a62cSLen Brown 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 { 312c8f7a62cSLen Brown struct acpi_device *device = NULL; 313c8f7a62cSLen Brown struct acpi_device *parent_device; 314c8f7a62cSLen Brown acpi_handle parent; 315c8f7a62cSLen Brown int ret; 316c8f7a62cSLen Brown 317c8f7a62cSLen Brown if (acpi_bus_get_device(handle, &device)) { 318c8f7a62cSLen Brown /* 319c8f7a62cSLen Brown * no device created for this object, 320c8f7a62cSLen Brown * so we should create one. 321c8f7a62cSLen Brown */ 322c8f7a62cSLen Brown acpi_get_parent(handle, &parent); 323c8f7a62cSLen Brown if (acpi_bus_get_device(parent, &parent_device)) 324c8f7a62cSLen Brown parent_device = NULL; 325c8f7a62cSLen Brown 326c8f7a62cSLen Brown ret = acpi_bus_add(&device, parent_device, handle, 327c8f7a62cSLen Brown ACPI_BUS_TYPE_DEVICE); 328c8f7a62cSLen Brown if (ret) { 329c8f7a62cSLen Brown pr_debug("error adding bus, %x\n", 330c8f7a62cSLen Brown -ret); 331c8f7a62cSLen Brown return NULL; 332c8f7a62cSLen Brown } 333c8f7a62cSLen Brown } 334c8f7a62cSLen Brown return device; 335c8f7a62cSLen Brown } 336c8f7a62cSLen Brown 337c8f7a62cSLen Brown /** 338c8f7a62cSLen Brown * dock_remove_acpi_device - remove the acpi_device struct from acpi 339c8f7a62cSLen Brown * @handle - the handle of the device to remove 340c8f7a62cSLen Brown * 341c8f7a62cSLen Brown * Tell acpi to remove the acpi_device. This should cause any loaded 342c8f7a62cSLen Brown * driver to have it's remove routine called. 343c8f7a62cSLen Brown */ 344c8f7a62cSLen Brown static void dock_remove_acpi_device(acpi_handle handle) 345c8f7a62cSLen Brown { 346c8f7a62cSLen Brown struct acpi_device *device; 347c8f7a62cSLen Brown int ret; 348c8f7a62cSLen Brown 349c8f7a62cSLen Brown if (!acpi_bus_get_device(handle, &device)) { 350c8f7a62cSLen Brown ret = acpi_bus_trim(device, 1); 351c8f7a62cSLen Brown if (ret) 352c8f7a62cSLen Brown pr_debug("error removing bus, %x\n", -ret); 353c8f7a62cSLen Brown } 354c8f7a62cSLen Brown } 355c8f7a62cSLen Brown 356c8f7a62cSLen Brown 357c8f7a62cSLen Brown /** 358c8f7a62cSLen Brown * hotplug_dock_devices - insert or remove devices on the dock station 359c8f7a62cSLen Brown * @ds: the dock station 360c8f7a62cSLen Brown * @event: either bus check or eject request 361c8f7a62cSLen Brown * 362c8f7a62cSLen Brown * Some devices on the dock station need to have drivers called 363c8f7a62cSLen Brown * to perform hotplug operations after a dock event has occurred. 364c8f7a62cSLen Brown * Traverse the list of dock devices that have registered a 365c8f7a62cSLen Brown * hotplug handler, and call the handler. 366c8f7a62cSLen Brown */ 367c8f7a62cSLen Brown static void hotplug_dock_devices(struct dock_station *ds, u32 event) 368c8f7a62cSLen Brown { 369c8f7a62cSLen Brown struct dock_dependent_device *dd; 370c8f7a62cSLen Brown 3718b0dc866SKristen Carlson Accardi mutex_lock(&ds->hp_lock); 372c8f7a62cSLen Brown 373c8f7a62cSLen Brown /* 374c8f7a62cSLen Brown * First call driver specific hotplug functions 375c8f7a62cSLen Brown */ 376c8f7a62cSLen Brown list_for_each_entry(dd, &ds->hotplug_devices, hotplug_list) { 3771253f7aaSShaohua Li if (dd->ops && dd->ops->handler) 3781253f7aaSShaohua Li dd->ops->handler(dd->handle, event, dd->context); 379c8f7a62cSLen Brown } 380c8f7a62cSLen Brown 381c8f7a62cSLen Brown /* 382c8f7a62cSLen Brown * Now make sure that an acpi_device is created for each 383c8f7a62cSLen Brown * dependent device, or removed if this is an eject request. 384c8f7a62cSLen Brown * This will cause acpi_drivers to be stopped/started if they 385c8f7a62cSLen Brown * exist 386c8f7a62cSLen Brown */ 387c8f7a62cSLen Brown list_for_each_entry(dd, &ds->dependent_devices, list) { 388c8f7a62cSLen Brown if (event == ACPI_NOTIFY_EJECT_REQUEST) 389c8f7a62cSLen Brown dock_remove_acpi_device(dd->handle); 390c8f7a62cSLen Brown else 391c8f7a62cSLen Brown dock_create_acpi_device(dd->handle); 392c8f7a62cSLen Brown } 3938b0dc866SKristen Carlson Accardi mutex_unlock(&ds->hp_lock); 394c8f7a62cSLen Brown } 395c8f7a62cSLen Brown 396c8f7a62cSLen Brown static void dock_event(struct dock_station *ds, u32 event, int num) 397c8f7a62cSLen Brown { 398db350b08SShaohua Li struct device *dev = &ds->dock_device->dev; 39966b56821SHolger Macht char event_string[13]; 40079a8f70bSKristen Carlson Accardi char *envp[] = { event_string, NULL }; 4011253f7aaSShaohua Li struct dock_dependent_device *dd; 40279a8f70bSKristen Carlson Accardi 40379a8f70bSKristen Carlson Accardi if (num == UNDOCK_EVENT) 40466b56821SHolger Macht sprintf(event_string, "EVENT=undock"); 40579a8f70bSKristen Carlson Accardi else 40666b56821SHolger Macht sprintf(event_string, "EVENT=dock"); 40779a8f70bSKristen Carlson Accardi 4085669021eSKristen Carlson Accardi /* 4098ea86e0bSKristen Carlson Accardi * Indicate that the status of the dock station has 4108ea86e0bSKristen Carlson Accardi * changed. 4115669021eSKristen Carlson Accardi */ 4121253f7aaSShaohua Li if (num == DOCK_EVENT) 4131253f7aaSShaohua Li kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp); 4141253f7aaSShaohua Li 4151253f7aaSShaohua Li list_for_each_entry(dd, &ds->hotplug_devices, hotplug_list) 4161253f7aaSShaohua Li if (dd->ops && dd->ops->uevent) 4171253f7aaSShaohua Li dd->ops->uevent(dd->handle, event, dd->context); 4181253f7aaSShaohua Li if (num != DOCK_EVENT) 41979a8f70bSKristen Carlson Accardi kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp); 420c8f7a62cSLen Brown } 421c8f7a62cSLen Brown 422c8f7a62cSLen Brown /** 423c8f7a62cSLen Brown * eject_dock - respond to a dock eject request 424c8f7a62cSLen Brown * @ds: the dock station 425c8f7a62cSLen Brown * 426c8f7a62cSLen Brown * This is called after _DCK is called, to execute the dock station's 427c8f7a62cSLen Brown * _EJ0 method. 428c8f7a62cSLen Brown */ 429c8f7a62cSLen Brown static void eject_dock(struct dock_station *ds) 430c8f7a62cSLen Brown { 431c8f7a62cSLen Brown struct acpi_object_list arg_list; 432c8f7a62cSLen Brown union acpi_object arg; 433c8f7a62cSLen Brown acpi_status status; 434c8f7a62cSLen Brown acpi_handle tmp; 435c8f7a62cSLen Brown 436c8f7a62cSLen Brown /* all dock devices should have _EJ0, but check anyway */ 437c8f7a62cSLen Brown status = acpi_get_handle(ds->handle, "_EJ0", &tmp); 438c8f7a62cSLen Brown if (ACPI_FAILURE(status)) { 439c8f7a62cSLen Brown pr_debug("No _EJ0 support for dock device\n"); 440c8f7a62cSLen Brown return; 441c8f7a62cSLen Brown } 442c8f7a62cSLen Brown 443c8f7a62cSLen Brown arg_list.count = 1; 444c8f7a62cSLen Brown arg_list.pointer = &arg; 445c8f7a62cSLen Brown arg.type = ACPI_TYPE_INTEGER; 446c8f7a62cSLen Brown arg.integer.value = 1; 447c8f7a62cSLen Brown 448c8f7a62cSLen Brown if (ACPI_FAILURE(acpi_evaluate_object(ds->handle, "_EJ0", 449c8f7a62cSLen Brown &arg_list, NULL))) 450c8f7a62cSLen Brown pr_debug("Failed to evaluate _EJ0!\n"); 451c8f7a62cSLen Brown } 452c8f7a62cSLen Brown 453c8f7a62cSLen Brown /** 454c8f7a62cSLen Brown * handle_dock - handle a dock event 455c8f7a62cSLen Brown * @ds: the dock station 456c8f7a62cSLen Brown * @dock: to dock, or undock - that is the question 457c8f7a62cSLen Brown * 458c8f7a62cSLen Brown * Execute the _DCK method in response to an acpi event 459c8f7a62cSLen Brown */ 460c8f7a62cSLen Brown static void handle_dock(struct dock_station *ds, int dock) 461c8f7a62cSLen Brown { 462c8f7a62cSLen Brown acpi_status status; 463c8f7a62cSLen Brown struct acpi_object_list arg_list; 464c8f7a62cSLen Brown union acpi_object arg; 465c8f7a62cSLen Brown struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 466c8f7a62cSLen Brown struct acpi_buffer name_buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 467c8f7a62cSLen Brown 468c8f7a62cSLen Brown acpi_get_name(ds->handle, ACPI_FULL_PATHNAME, &name_buffer); 469c8f7a62cSLen Brown 4709254bc84SDmitry Torokhov printk(KERN_INFO PREFIX "%s - %s\n", 4719254bc84SDmitry Torokhov (char *)name_buffer.pointer, dock ? "docking" : "undocking"); 472c8f7a62cSLen Brown 473c8f7a62cSLen Brown /* _DCK method has one argument */ 474c8f7a62cSLen Brown arg_list.count = 1; 475c8f7a62cSLen Brown arg_list.pointer = &arg; 476c8f7a62cSLen Brown arg.type = ACPI_TYPE_INTEGER; 477c8f7a62cSLen Brown arg.integer.value = dock; 478c8f7a62cSLen Brown status = acpi_evaluate_object(ds->handle, "_DCK", &arg_list, &buffer); 479db350b08SShaohua Li if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) 4800a918a94SThomas Renninger ACPI_EXCEPTION((AE_INFO, status, "%s - failed to execute" 4810a918a94SThomas Renninger " _DCK\n", (char *)name_buffer.pointer)); 4820a918a94SThomas Renninger 483c8f7a62cSLen Brown kfree(buffer.pointer); 484c8f7a62cSLen Brown kfree(name_buffer.pointer); 485c8f7a62cSLen Brown } 486c8f7a62cSLen Brown 487c8f7a62cSLen Brown static inline void dock(struct dock_station *ds) 488c8f7a62cSLen Brown { 489c8f7a62cSLen Brown handle_dock(ds, 1); 490c8f7a62cSLen Brown } 491c8f7a62cSLen Brown 492c8f7a62cSLen Brown static inline void undock(struct dock_station *ds) 493c8f7a62cSLen Brown { 494c8f7a62cSLen Brown handle_dock(ds, 0); 495c8f7a62cSLen Brown } 496c8f7a62cSLen Brown 497c8f7a62cSLen Brown static inline void begin_dock(struct dock_station *ds) 498c8f7a62cSLen Brown { 499c8f7a62cSLen Brown ds->flags |= DOCK_DOCKING; 500c8f7a62cSLen Brown } 501c8f7a62cSLen Brown 502c8f7a62cSLen Brown static inline void complete_dock(struct dock_station *ds) 503c8f7a62cSLen Brown { 504c8f7a62cSLen Brown ds->flags &= ~(DOCK_DOCKING); 505c8f7a62cSLen Brown ds->last_dock_time = jiffies; 506c8f7a62cSLen Brown } 507c8f7a62cSLen Brown 508a0cd35fdSKristen Carlson Accardi static inline void begin_undock(struct dock_station *ds) 509a0cd35fdSKristen Carlson Accardi { 510a0cd35fdSKristen Carlson Accardi ds->flags |= DOCK_UNDOCKING; 511a0cd35fdSKristen Carlson Accardi } 512a0cd35fdSKristen Carlson Accardi 513a0cd35fdSKristen Carlson Accardi static inline void complete_undock(struct dock_station *ds) 514a0cd35fdSKristen Carlson Accardi { 515a0cd35fdSKristen Carlson Accardi ds->flags &= ~(DOCK_UNDOCKING); 516a0cd35fdSKristen Carlson Accardi } 517a0cd35fdSKristen Carlson Accardi 518406f692dSShaohua Li static void dock_lock(struct dock_station *ds, int lock) 519406f692dSShaohua Li { 520406f692dSShaohua Li struct acpi_object_list arg_list; 521406f692dSShaohua Li union acpi_object arg; 522406f692dSShaohua Li acpi_status status; 523406f692dSShaohua Li 524406f692dSShaohua Li arg_list.count = 1; 525406f692dSShaohua Li arg_list.pointer = &arg; 526406f692dSShaohua Li arg.type = ACPI_TYPE_INTEGER; 527406f692dSShaohua Li arg.integer.value = !!lock; 528406f692dSShaohua Li status = acpi_evaluate_object(ds->handle, "_LCK", &arg_list, NULL); 529406f692dSShaohua Li if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 530406f692dSShaohua Li if (lock) 531406f692dSShaohua Li printk(KERN_WARNING PREFIX "Locking device failed\n"); 532406f692dSShaohua Li else 533406f692dSShaohua Li printk(KERN_WARNING PREFIX "Unlocking device failed\n"); 534406f692dSShaohua Li } 535406f692dSShaohua Li } 536406f692dSShaohua Li 537c8f7a62cSLen Brown /** 538c8f7a62cSLen Brown * dock_in_progress - see if we are in the middle of handling a dock event 539c8f7a62cSLen Brown * @ds: the dock station 540c8f7a62cSLen Brown * 541c8f7a62cSLen Brown * Sometimes while docking, false dock events can be sent to the driver 542c8f7a62cSLen Brown * because good connections aren't made or some other reason. Ignore these 543c8f7a62cSLen Brown * if we are in the middle of doing something. 544c8f7a62cSLen Brown */ 545c8f7a62cSLen Brown static int dock_in_progress(struct dock_station *ds) 546c8f7a62cSLen Brown { 547c8f7a62cSLen Brown if ((ds->flags & DOCK_DOCKING) || 548c8f7a62cSLen Brown time_before(jiffies, (ds->last_dock_time + HZ))) 549c8f7a62cSLen Brown return 1; 550c8f7a62cSLen Brown return 0; 551c8f7a62cSLen Brown } 552c8f7a62cSLen Brown 553c8f7a62cSLen Brown /** 554c8f7a62cSLen Brown * register_dock_notifier - add yourself to the dock notifier list 555c8f7a62cSLen Brown * @nb: the callers notifier block 556c8f7a62cSLen Brown * 557c8f7a62cSLen Brown * If a driver wishes to be notified about dock events, they can 558c8f7a62cSLen Brown * use this function to put a notifier block on the dock notifier list. 559c8f7a62cSLen Brown * this notifier call chain will be called after a dock event, but 560c8f7a62cSLen Brown * before hotplugging any new devices. 561c8f7a62cSLen Brown */ 562c8f7a62cSLen Brown int register_dock_notifier(struct notifier_block *nb) 563c8f7a62cSLen Brown { 564db350b08SShaohua Li if (!dock_station_count) 5652548c06bSPrarit Bhargava return -ENODEV; 5662548c06bSPrarit Bhargava 567c8f7a62cSLen Brown return atomic_notifier_chain_register(&dock_notifier_list, nb); 568c8f7a62cSLen Brown } 569c8f7a62cSLen Brown 570c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(register_dock_notifier); 571c8f7a62cSLen Brown 572c8f7a62cSLen Brown /** 573c8f7a62cSLen Brown * unregister_dock_notifier - remove yourself from the dock notifier list 574c8f7a62cSLen Brown * @nb: the callers notifier block 575c8f7a62cSLen Brown */ 576c8f7a62cSLen Brown void unregister_dock_notifier(struct notifier_block *nb) 577c8f7a62cSLen Brown { 578db350b08SShaohua Li if (!dock_station_count) 5792548c06bSPrarit Bhargava return; 5802548c06bSPrarit Bhargava 581c8f7a62cSLen Brown atomic_notifier_chain_unregister(&dock_notifier_list, nb); 582c8f7a62cSLen Brown } 583c8f7a62cSLen Brown 584c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(unregister_dock_notifier); 585c8f7a62cSLen Brown 586c8f7a62cSLen Brown /** 587c8f7a62cSLen Brown * register_hotplug_dock_device - register a hotplug function 588c8f7a62cSLen Brown * @handle: the handle of the device 5891253f7aaSShaohua Li * @ops: handlers to call after docking 590c8f7a62cSLen Brown * @context: device specific data 591c8f7a62cSLen Brown * 592c8f7a62cSLen Brown * If a driver would like to perform a hotplug operation after a dock 593c8f7a62cSLen Brown * event, they can register an acpi_notifiy_handler to be called by 594c8f7a62cSLen Brown * the dock driver after _DCK is executed. 595c8f7a62cSLen Brown */ 596c8f7a62cSLen Brown int 5971253f7aaSShaohua Li register_hotplug_dock_device(acpi_handle handle, struct acpi_dock_ops *ops, 598c8f7a62cSLen Brown void *context) 599c8f7a62cSLen Brown { 600c8f7a62cSLen Brown struct dock_dependent_device *dd; 601db350b08SShaohua Li struct dock_station *dock_station; 60261b83695SShaohua Li int ret = -EINVAL; 603c8f7a62cSLen Brown 604db350b08SShaohua Li if (!dock_station_count) 605c8f7a62cSLen Brown return -ENODEV; 606c8f7a62cSLen Brown 607c8f7a62cSLen Brown /* 608c8f7a62cSLen Brown * make sure this handle is for a device dependent on the dock, 609c8f7a62cSLen Brown * this would include the dock station itself 610c8f7a62cSLen Brown */ 61150d716e4SAlex Chiang list_for_each_entry(dock_station, &dock_stations, sibling) { 61261b83695SShaohua Li /* 61361b83695SShaohua Li * An ATA bay can be in a dock and itself can be ejected 61461b83695SShaohua Li * seperately, so there are two 'dock stations' which need the 61561b83695SShaohua Li * ops 61661b83695SShaohua Li */ 617c8f7a62cSLen Brown dd = find_dock_dependent_device(dock_station, handle); 618c8f7a62cSLen Brown if (dd) { 6191253f7aaSShaohua Li dd->ops = ops; 620c8f7a62cSLen Brown dd->context = context; 621c8f7a62cSLen Brown dock_add_hotplug_device(dock_station, dd); 62261b83695SShaohua Li ret = 0; 623c8f7a62cSLen Brown } 624db350b08SShaohua Li } 625c8f7a62cSLen Brown 62661b83695SShaohua Li return ret; 627c8f7a62cSLen Brown } 628c8f7a62cSLen Brown 629c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(register_hotplug_dock_device); 630c8f7a62cSLen Brown 631c8f7a62cSLen Brown /** 632c8f7a62cSLen Brown * unregister_hotplug_dock_device - remove yourself from the hotplug list 633c8f7a62cSLen Brown * @handle: the acpi handle of the device 634c8f7a62cSLen Brown */ 635c8f7a62cSLen Brown void unregister_hotplug_dock_device(acpi_handle handle) 636c8f7a62cSLen Brown { 637c8f7a62cSLen Brown struct dock_dependent_device *dd; 638db350b08SShaohua Li struct dock_station *dock_station; 639c8f7a62cSLen Brown 640db350b08SShaohua Li if (!dock_station_count) 641c8f7a62cSLen Brown return; 642c8f7a62cSLen Brown 64350d716e4SAlex Chiang list_for_each_entry(dock_station, &dock_stations, sibling) { 644c8f7a62cSLen Brown dd = find_dock_dependent_device(dock_station, handle); 645c8f7a62cSLen Brown if (dd) 646c8f7a62cSLen Brown dock_del_hotplug_device(dock_station, dd); 647c8f7a62cSLen Brown } 648db350b08SShaohua Li } 649c8f7a62cSLen Brown 650c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(unregister_hotplug_dock_device); 651c8f7a62cSLen Brown 652c8f7a62cSLen Brown /** 653c80fdbe8Sbrandon@ifup.org * handle_eject_request - handle an undock request checking for error conditions 654c80fdbe8Sbrandon@ifup.org * 655c80fdbe8Sbrandon@ifup.org * Check to make sure the dock device is still present, then undock and 656c80fdbe8Sbrandon@ifup.org * hotremove all the devices that may need removing. 657c80fdbe8Sbrandon@ifup.org */ 658c80fdbe8Sbrandon@ifup.org static int handle_eject_request(struct dock_station *ds, u32 event) 659c80fdbe8Sbrandon@ifup.org { 660c80fdbe8Sbrandon@ifup.org if (dock_in_progress(ds)) 661c80fdbe8Sbrandon@ifup.org return -EBUSY; 662c80fdbe8Sbrandon@ifup.org 663c80fdbe8Sbrandon@ifup.org /* 664c80fdbe8Sbrandon@ifup.org * here we need to generate the undock 665c80fdbe8Sbrandon@ifup.org * event prior to actually doing the undock 666c80fdbe8Sbrandon@ifup.org * so that the device struct still exists. 667afd7301dSHolger Macht * Also, even send the dock event if the 668afd7301dSHolger Macht * device is not present anymore 669c80fdbe8Sbrandon@ifup.org */ 670c80fdbe8Sbrandon@ifup.org dock_event(ds, event, UNDOCK_EVENT); 671afd7301dSHolger Macht 672c80fdbe8Sbrandon@ifup.org hotplug_dock_devices(ds, ACPI_NOTIFY_EJECT_REQUEST); 673c80fdbe8Sbrandon@ifup.org undock(ds); 674406f692dSShaohua Li dock_lock(ds, 0); 675c80fdbe8Sbrandon@ifup.org eject_dock(ds); 676c80fdbe8Sbrandon@ifup.org if (dock_present(ds)) { 677c80fdbe8Sbrandon@ifup.org printk(KERN_ERR PREFIX "Unable to undock!\n"); 678c80fdbe8Sbrandon@ifup.org return -EBUSY; 679c80fdbe8Sbrandon@ifup.org } 680a0cd35fdSKristen Carlson Accardi complete_undock(ds); 681c80fdbe8Sbrandon@ifup.org return 0; 682c80fdbe8Sbrandon@ifup.org } 683c80fdbe8Sbrandon@ifup.org 684c80fdbe8Sbrandon@ifup.org /** 685c8f7a62cSLen Brown * dock_notify - act upon an acpi dock notification 686c8f7a62cSLen Brown * @handle: the dock station handle 687c8f7a62cSLen Brown * @event: the acpi event 688c8f7a62cSLen Brown * @data: our driver data struct 689c8f7a62cSLen Brown * 690c8f7a62cSLen Brown * If we are notified to dock, then check to see if the dock is 691c8f7a62cSLen Brown * present and then dock. Notify all drivers of the dock event, 692c80fdbe8Sbrandon@ifup.org * and then hotplug and devices that may need hotplugging. 693c8f7a62cSLen Brown */ 694c8f7a62cSLen Brown static void dock_notify(acpi_handle handle, u32 event, void *data) 695c8f7a62cSLen Brown { 69650dd0969SJan Engelhardt struct dock_station *ds = data; 6978b59560aSShaohua Li struct acpi_device *tmp; 698db350b08SShaohua Li int surprise_removal = 0; 699c8f7a62cSLen Brown 700db350b08SShaohua Li /* 701db350b08SShaohua Li * According to acpi spec 3.0a, if a DEVICE_CHECK notification 702db350b08SShaohua Li * is sent and _DCK is present, it is assumed to mean an undock 703db350b08SShaohua Li * request. 704db350b08SShaohua Li */ 705db350b08SShaohua Li if ((ds->flags & DOCK_IS_DOCK) && event == ACPI_NOTIFY_DEVICE_CHECK) 706db350b08SShaohua Li event = ACPI_NOTIFY_EJECT_REQUEST; 707db350b08SShaohua Li 708db350b08SShaohua Li /* 709db350b08SShaohua Li * dock station: BUS_CHECK - docked or surprise removal 710db350b08SShaohua Li * DEVICE_CHECK - undocked 711db350b08SShaohua Li * other device: BUS_CHECK/DEVICE_CHECK - added or surprise removal 712db350b08SShaohua Li * 713db350b08SShaohua Li * To simplify event handling, dock dependent device handler always 714db350b08SShaohua Li * get ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and 715db350b08SShaohua Li * ACPI_NOTIFY_EJECT_REQUEST for removal 716db350b08SShaohua Li */ 717c8f7a62cSLen Brown switch (event) { 718c8f7a62cSLen Brown case ACPI_NOTIFY_BUS_CHECK: 719db350b08SShaohua Li case ACPI_NOTIFY_DEVICE_CHECK: 7208b59560aSShaohua Li if (!dock_in_progress(ds) && acpi_bus_get_device(ds->handle, 7218b59560aSShaohua Li &tmp)) { 722c8f7a62cSLen Brown begin_dock(ds); 723c8f7a62cSLen Brown dock(ds); 724c8f7a62cSLen Brown if (!dock_present(ds)) { 725c8f7a62cSLen Brown printk(KERN_ERR PREFIX "Unable to dock!\n"); 7268b59560aSShaohua Li complete_dock(ds); 727c8f7a62cSLen Brown break; 728c8f7a62cSLen Brown } 729c8f7a62cSLen Brown atomic_notifier_call_chain(&dock_notifier_list, 730c8f7a62cSLen Brown event, NULL); 731c8f7a62cSLen Brown hotplug_dock_devices(ds, event); 732c8f7a62cSLen Brown complete_dock(ds); 733c8f7a62cSLen Brown dock_event(ds, event, DOCK_EVENT); 734406f692dSShaohua Li dock_lock(ds, 1); 735c8f7a62cSLen Brown break; 736db350b08SShaohua Li } 737db350b08SShaohua Li if (dock_present(ds) || dock_in_progress(ds)) 738db350b08SShaohua Li break; 739db350b08SShaohua Li /* This is a surprise removal */ 740db350b08SShaohua Li surprise_removal = 1; 741db350b08SShaohua Li event = ACPI_NOTIFY_EJECT_REQUEST; 742db350b08SShaohua Li /* Fall back */ 743c8f7a62cSLen Brown case ACPI_NOTIFY_EJECT_REQUEST: 744a0cd35fdSKristen Carlson Accardi begin_undock(ds); 745f730ae18SShaohua Li if ((immediate_undock && !(ds->flags & DOCK_IS_ATA)) 746f730ae18SShaohua Li || surprise_removal) 747c80fdbe8Sbrandon@ifup.org handle_eject_request(ds, event); 748a0cd35fdSKristen Carlson Accardi else 749a0cd35fdSKristen Carlson Accardi dock_event(ds, event, UNDOCK_EVENT); 750c8f7a62cSLen Brown break; 751c8f7a62cSLen Brown default: 752c8f7a62cSLen Brown printk(KERN_ERR PREFIX "Unknown dock event %d\n", event); 753c8f7a62cSLen Brown } 754c8f7a62cSLen Brown } 755c8f7a62cSLen Brown 75619cd847aSZhang Rui struct dock_data { 75719cd847aSZhang Rui acpi_handle handle; 75819cd847aSZhang Rui unsigned long event; 75919cd847aSZhang Rui struct dock_station *ds; 76019cd847aSZhang Rui }; 76119cd847aSZhang Rui 76219cd847aSZhang Rui static void acpi_dock_deferred_cb(void *context) 76319cd847aSZhang Rui { 76419cd847aSZhang Rui struct dock_data *data = (struct dock_data *)context; 76519cd847aSZhang Rui 76619cd847aSZhang Rui dock_notify(data->handle, data->event, data->ds); 76719cd847aSZhang Rui kfree(data); 76819cd847aSZhang Rui } 76919cd847aSZhang Rui 7706bd00a61SShaohua Li static int acpi_dock_notifier_call(struct notifier_block *this, 7716bd00a61SShaohua Li unsigned long event, void *data) 7726bd00a61SShaohua Li { 7736bd00a61SShaohua Li struct dock_station *dock_station; 7746bd00a61SShaohua Li acpi_handle handle = (acpi_handle)data; 7756bd00a61SShaohua Li 7766bd00a61SShaohua Li if (event != ACPI_NOTIFY_BUS_CHECK && event != ACPI_NOTIFY_DEVICE_CHECK 7776bd00a61SShaohua Li && event != ACPI_NOTIFY_EJECT_REQUEST) 7786bd00a61SShaohua Li return 0; 77950d716e4SAlex Chiang list_for_each_entry(dock_station, &dock_stations, sibling) { 7806bd00a61SShaohua Li if (dock_station->handle == handle) { 78119cd847aSZhang Rui struct dock_data *dock_data; 78219cd847aSZhang Rui 78319cd847aSZhang Rui dock_data = kmalloc(sizeof(*dock_data), GFP_KERNEL); 78419cd847aSZhang Rui if (!dock_data) 78519cd847aSZhang Rui return 0; 78619cd847aSZhang Rui dock_data->handle = handle; 78719cd847aSZhang Rui dock_data->event = event; 78819cd847aSZhang Rui dock_data->ds = dock_station; 78919cd847aSZhang Rui acpi_os_hotplug_execute(acpi_dock_deferred_cb, 79019cd847aSZhang Rui dock_data); 7916bd00a61SShaohua Li return 0 ; 7926bd00a61SShaohua Li } 7936bd00a61SShaohua Li } 7946bd00a61SShaohua Li return 0; 7956bd00a61SShaohua Li } 7966bd00a61SShaohua Li 7976bd00a61SShaohua Li static struct notifier_block dock_acpi_notifier = { 7986bd00a61SShaohua Li .notifier_call = acpi_dock_notifier_call, 7996bd00a61SShaohua Li }; 8006bd00a61SShaohua Li 801c8f7a62cSLen Brown /** 802c8f7a62cSLen Brown * find_dock_devices - find devices on the dock station 803c8f7a62cSLen Brown * @handle: the handle of the device we are examining 804c8f7a62cSLen Brown * @lvl: unused 805c8f7a62cSLen Brown * @context: the dock station private data 806c8f7a62cSLen Brown * @rv: unused 807c8f7a62cSLen Brown * 808c8f7a62cSLen Brown * This function is called by acpi_walk_namespace. It will 809c8f7a62cSLen Brown * check to see if an object has an _EJD method. If it does, then it 810c8f7a62cSLen Brown * will see if it is dependent on the dock station. 811c8f7a62cSLen Brown */ 812c8f7a62cSLen Brown static acpi_status 813c8f7a62cSLen Brown find_dock_devices(acpi_handle handle, u32 lvl, void *context, void **rv) 814c8f7a62cSLen Brown { 815c8f7a62cSLen Brown acpi_status status; 816fe9a2f77SKristen Carlson Accardi acpi_handle tmp, parent; 81750dd0969SJan Engelhardt struct dock_station *ds = context; 818c8f7a62cSLen Brown 819c8f7a62cSLen Brown status = acpi_bus_get_ejd(handle, &tmp); 820fe9a2f77SKristen Carlson Accardi if (ACPI_FAILURE(status)) { 821fe9a2f77SKristen Carlson Accardi /* try the parent device as well */ 822fe9a2f77SKristen Carlson Accardi status = acpi_get_parent(handle, &parent); 823c8f7a62cSLen Brown if (ACPI_FAILURE(status)) 824fe9a2f77SKristen Carlson Accardi goto fdd_out; 825fe9a2f77SKristen Carlson Accardi /* see if parent is dependent on dock */ 826fe9a2f77SKristen Carlson Accardi status = acpi_bus_get_ejd(parent, &tmp); 827fe9a2f77SKristen Carlson Accardi if (ACPI_FAILURE(status)) 828fe9a2f77SKristen Carlson Accardi goto fdd_out; 829fe9a2f77SKristen Carlson Accardi } 830c8f7a62cSLen Brown 831f69cfdd2SAlex Chiang if (tmp == ds->handle) 832f69cfdd2SAlex Chiang add_dock_dependent_device(ds, handle); 833f69cfdd2SAlex Chiang 834fe9a2f77SKristen Carlson Accardi fdd_out: 835c8f7a62cSLen Brown return AE_OK; 836c8f7a62cSLen Brown } 837c8f7a62cSLen Brown 838c80fdbe8Sbrandon@ifup.org /* 839c80fdbe8Sbrandon@ifup.org * show_docked - read method for "docked" file in sysfs 840c80fdbe8Sbrandon@ifup.org */ 841c80fdbe8Sbrandon@ifup.org static ssize_t show_docked(struct device *dev, 842c80fdbe8Sbrandon@ifup.org struct device_attribute *attr, char *buf) 843c80fdbe8Sbrandon@ifup.org { 844fc5a9f88SHolger Macht struct acpi_device *tmp; 845fc5a9f88SHolger Macht 846fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 847c80fdbe8Sbrandon@ifup.org 848fc5a9f88SHolger Macht if (ACPI_SUCCESS(acpi_bus_get_device(dock_station->handle, &tmp))) 849fc5a9f88SHolger Macht return snprintf(buf, PAGE_SIZE, "1\n"); 850fc5a9f88SHolger Macht return snprintf(buf, PAGE_SIZE, "0\n"); 851c80fdbe8Sbrandon@ifup.org } 852e5685b9dSAdrian Bunk static DEVICE_ATTR(docked, S_IRUGO, show_docked, NULL); 853c80fdbe8Sbrandon@ifup.org 854c80fdbe8Sbrandon@ifup.org /* 855a0cd35fdSKristen Carlson Accardi * show_flags - read method for flags file in sysfs 856a0cd35fdSKristen Carlson Accardi */ 857a0cd35fdSKristen Carlson Accardi static ssize_t show_flags(struct device *dev, 858a0cd35fdSKristen Carlson Accardi struct device_attribute *attr, char *buf) 859a0cd35fdSKristen Carlson Accardi { 860fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 861a0cd35fdSKristen Carlson Accardi return snprintf(buf, PAGE_SIZE, "%d\n", dock_station->flags); 862a0cd35fdSKristen Carlson Accardi 863a0cd35fdSKristen Carlson Accardi } 864e5685b9dSAdrian Bunk static DEVICE_ATTR(flags, S_IRUGO, show_flags, NULL); 865a0cd35fdSKristen Carlson Accardi 866a0cd35fdSKristen Carlson Accardi /* 867c80fdbe8Sbrandon@ifup.org * write_undock - write method for "undock" file in sysfs 868c80fdbe8Sbrandon@ifup.org */ 869c80fdbe8Sbrandon@ifup.org static ssize_t write_undock(struct device *dev, struct device_attribute *attr, 870c80fdbe8Sbrandon@ifup.org const char *buf, size_t count) 871c80fdbe8Sbrandon@ifup.org { 872c80fdbe8Sbrandon@ifup.org int ret; 873fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 874c80fdbe8Sbrandon@ifup.org 875c80fdbe8Sbrandon@ifup.org if (!count) 876c80fdbe8Sbrandon@ifup.org return -EINVAL; 877c80fdbe8Sbrandon@ifup.org 8789171f834SHolger Macht begin_undock(dock_station); 879c80fdbe8Sbrandon@ifup.org ret = handle_eject_request(dock_station, ACPI_NOTIFY_EJECT_REQUEST); 880c80fdbe8Sbrandon@ifup.org return ret ? ret: count; 881c80fdbe8Sbrandon@ifup.org } 882e5685b9dSAdrian Bunk static DEVICE_ATTR(undock, S_IWUSR, NULL, write_undock); 883c80fdbe8Sbrandon@ifup.org 884ac122bb6SIlya A. Volynets-Evenbakh /* 885ac122bb6SIlya A. Volynets-Evenbakh * show_dock_uid - read method for "uid" file in sysfs 886ac122bb6SIlya A. Volynets-Evenbakh */ 887ac122bb6SIlya A. Volynets-Evenbakh static ssize_t show_dock_uid(struct device *dev, 888ac122bb6SIlya A. Volynets-Evenbakh struct device_attribute *attr, char *buf) 889ac122bb6SIlya A. Volynets-Evenbakh { 89027663c58SMatthew Wilcox unsigned long long lbuf; 891fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 89238ff4ffcSKristen Carlson Accardi acpi_status status = acpi_evaluate_integer(dock_station->handle, 89338ff4ffcSKristen Carlson Accardi "_UID", NULL, &lbuf); 89438ff4ffcSKristen Carlson Accardi if (ACPI_FAILURE(status)) 895ac122bb6SIlya A. Volynets-Evenbakh return 0; 89638ff4ffcSKristen Carlson Accardi 89727663c58SMatthew Wilcox return snprintf(buf, PAGE_SIZE, "%llx\n", lbuf); 898ac122bb6SIlya A. Volynets-Evenbakh } 899e5685b9dSAdrian Bunk static DEVICE_ATTR(uid, S_IRUGO, show_dock_uid, NULL); 900ac122bb6SIlya A. Volynets-Evenbakh 9018652b00fSShaohua Li static ssize_t show_dock_type(struct device *dev, 9028652b00fSShaohua Li struct device_attribute *attr, char *buf) 9038652b00fSShaohua Li { 904fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 9058652b00fSShaohua Li char *type; 9068652b00fSShaohua Li 9078652b00fSShaohua Li if (dock_station->flags & DOCK_IS_DOCK) 9088652b00fSShaohua Li type = "dock_station"; 9098652b00fSShaohua Li else if (dock_station->flags & DOCK_IS_ATA) 9108652b00fSShaohua Li type = "ata_bay"; 9118652b00fSShaohua Li else if (dock_station->flags & DOCK_IS_BAT) 9128652b00fSShaohua Li type = "battery_bay"; 9138652b00fSShaohua Li else 9148652b00fSShaohua Li type = "unknown"; 9158652b00fSShaohua Li 9168652b00fSShaohua Li return snprintf(buf, PAGE_SIZE, "%s\n", type); 9178652b00fSShaohua Li } 9188652b00fSShaohua Li static DEVICE_ATTR(type, S_IRUGO, show_dock_type, NULL); 9198652b00fSShaohua Li 9205f46c2f2SAlex Chiang static struct attribute *dock_attributes[] = { 9215f46c2f2SAlex Chiang &dev_attr_docked.attr, 9225f46c2f2SAlex Chiang &dev_attr_flags.attr, 9235f46c2f2SAlex Chiang &dev_attr_undock.attr, 9245f46c2f2SAlex Chiang &dev_attr_uid.attr, 9255f46c2f2SAlex Chiang &dev_attr_type.attr, 9265f46c2f2SAlex Chiang NULL 9275f46c2f2SAlex Chiang }; 9285f46c2f2SAlex Chiang 9295f46c2f2SAlex Chiang static struct attribute_group dock_attribute_group = { 9305f46c2f2SAlex Chiang .attrs = dock_attributes 9315f46c2f2SAlex Chiang }; 9325f46c2f2SAlex Chiang 933c8f7a62cSLen Brown /** 934c8f7a62cSLen Brown * dock_add - add a new dock station 935c8f7a62cSLen Brown * @handle: the dock station handle 936c8f7a62cSLen Brown * 937c8f7a62cSLen Brown * allocated and initialize a new dock station device. Find all devices 938c8f7a62cSLen Brown * that are on the dock station, and register for dock event notifications. 939c8f7a62cSLen Brown */ 940c8f7a62cSLen Brown static int dock_add(acpi_handle handle) 941c8f7a62cSLen Brown { 942fe06fba2SAlex Chiang int ret, id; 943fe06fba2SAlex Chiang struct dock_station ds, *dock_station; 944db350b08SShaohua Li struct platform_device *dock_device; 945c8f7a62cSLen Brown 946fe06fba2SAlex Chiang id = dock_station_count; 9479751cb72SAlex Chiang dock_device = 948fe06fba2SAlex Chiang platform_device_register_data(NULL, "dock", 949fe06fba2SAlex Chiang id, &ds, sizeof(ds)); 9509751cb72SAlex Chiang if (IS_ERR(dock_device)) 9519751cb72SAlex Chiang return PTR_ERR(dock_device); 9529751cb72SAlex Chiang 953fe06fba2SAlex Chiang dock_station = dock_device->dev.platform_data; 954c8f7a62cSLen Brown dock_station->handle = handle; 9559751cb72SAlex Chiang dock_station->dock_device = dock_device; 956c8f7a62cSLen Brown dock_station->last_dock_time = jiffies - HZ; 957c8f7a62cSLen Brown INIT_LIST_HEAD(&dock_station->dependent_devices); 958c8f7a62cSLen Brown INIT_LIST_HEAD(&dock_station->hotplug_devices); 95950d716e4SAlex Chiang INIT_LIST_HEAD(&dock_station->sibling); 960c8f7a62cSLen Brown spin_lock_init(&dock_station->dd_lock); 9618b0dc866SKristen Carlson Accardi mutex_init(&dock_station->hp_lock); 96207a18684SKristen Accardi ATOMIC_INIT_NOTIFIER_HEAD(&dock_notifier_list); 963c8f7a62cSLen Brown 9649ef2a9a9SKristen Carlson Accardi /* we want the dock device to send uevents */ 965f67f129eSMing Lei dev_set_uevent_suppress(&dock_device->dev, 0); 9669ef2a9a9SKristen Carlson Accardi 967db350b08SShaohua Li if (is_dock(handle)) 968db350b08SShaohua Li dock_station->flags |= DOCK_IS_DOCK; 969db350b08SShaohua Li if (is_ata(handle)) 970db350b08SShaohua Li dock_station->flags |= DOCK_IS_ATA; 971db350b08SShaohua Li if (is_battery(handle)) 972db350b08SShaohua Li dock_station->flags |= DOCK_IS_BAT; 973db350b08SShaohua Li 9745f46c2f2SAlex Chiang ret = sysfs_create_group(&dock_device->dev.kobj, &dock_attribute_group); 9758652b00fSShaohua Li if (ret) 9765f46c2f2SAlex Chiang goto err_unregister; 977671adbecSKristen Carlson Accardi 978c8f7a62cSLen Brown /* Find dependent devices */ 979c8f7a62cSLen Brown acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 980c8f7a62cSLen Brown ACPI_UINT32_MAX, find_dock_devices, dock_station, 981c8f7a62cSLen Brown NULL); 982c8f7a62cSLen Brown 983c8f7a62cSLen Brown /* add the dock station as a device dependent on itself */ 984f69cfdd2SAlex Chiang ret = add_dock_dependent_device(dock_station, handle); 985f69cfdd2SAlex Chiang if (ret) 9865f46c2f2SAlex Chiang goto err_rmgroup; 987c8f7a62cSLen Brown 988db350b08SShaohua Li dock_station_count++; 98950d716e4SAlex Chiang list_add(&dock_station->sibling, &dock_stations); 990c8f7a62cSLen Brown return 0; 991c8f7a62cSLen Brown 9925f46c2f2SAlex Chiang err_rmgroup: 9935f46c2f2SAlex Chiang sysfs_remove_group(&dock_device->dev.kobj, &dock_attribute_group); 9945f46c2f2SAlex Chiang err_unregister: 9950f6f2804SKristen Carlson Accardi platform_device_unregister(dock_device); 9965f46c2f2SAlex Chiang printk(KERN_ERR "%s encountered error %d\n", __func__, ret); 997c8f7a62cSLen Brown return ret; 998c8f7a62cSLen Brown } 999c8f7a62cSLen Brown 1000c8f7a62cSLen Brown /** 1001c8f7a62cSLen Brown * dock_remove - free up resources related to the dock station 1002c8f7a62cSLen Brown */ 1003db350b08SShaohua Li static int dock_remove(struct dock_station *dock_station) 1004c8f7a62cSLen Brown { 1005c8f7a62cSLen Brown struct dock_dependent_device *dd, *tmp; 1006db350b08SShaohua Li struct platform_device *dock_device = dock_station->dock_device; 1007c8f7a62cSLen Brown 1008db350b08SShaohua Li if (!dock_station_count) 1009c8f7a62cSLen Brown return 0; 1010c8f7a62cSLen Brown 1011c8f7a62cSLen Brown /* remove dependent devices */ 1012c8f7a62cSLen Brown list_for_each_entry_safe(dd, tmp, &dock_station->dependent_devices, 1013c8f7a62cSLen Brown list) 1014c8f7a62cSLen Brown kfree(dd); 1015c8f7a62cSLen Brown 1016fe06fba2SAlex Chiang list_del(&dock_station->sibling); 1017fe06fba2SAlex Chiang 1018671adbecSKristen Carlson Accardi /* cleanup sysfs */ 10195f46c2f2SAlex Chiang sysfs_remove_group(&dock_device->dev.kobj, &dock_attribute_group); 10200f6f2804SKristen Carlson Accardi platform_device_unregister(dock_device); 1021671adbecSKristen Carlson Accardi 1022c8f7a62cSLen Brown return 0; 1023c8f7a62cSLen Brown } 1024c8f7a62cSLen Brown 1025c8f7a62cSLen Brown /** 1026c8f7a62cSLen Brown * find_dock - look for a dock station 1027c8f7a62cSLen Brown * @handle: acpi handle of a device 1028c8f7a62cSLen Brown * @lvl: unused 1029c8f7a62cSLen Brown * @context: counter of dock stations found 1030c8f7a62cSLen Brown * @rv: unused 1031c8f7a62cSLen Brown * 1032c8f7a62cSLen Brown * This is called by acpi_walk_namespace to look for dock stations. 1033c8f7a62cSLen Brown */ 1034c8f7a62cSLen Brown static acpi_status 1035c8f7a62cSLen Brown find_dock(acpi_handle handle, u32 lvl, void *context, void **rv) 1036c8f7a62cSLen Brown { 1037c8f7a62cSLen Brown acpi_status status = AE_OK; 1038c8f7a62cSLen Brown 1039c8f7a62cSLen Brown if (is_dock(handle)) { 1040c8f7a62cSLen Brown if (dock_add(handle) >= 0) { 1041c8f7a62cSLen Brown status = AE_CTRL_TERMINATE; 1042c8f7a62cSLen Brown } 1043c8f7a62cSLen Brown } 1044c8f7a62cSLen Brown return status; 1045c8f7a62cSLen Brown } 1046c8f7a62cSLen Brown 1047db350b08SShaohua Li static acpi_status 1048db350b08SShaohua Li find_bay(acpi_handle handle, u32 lvl, void *context, void **rv) 1049db350b08SShaohua Li { 105061b83695SShaohua Li /* If bay is a dock, it's already handled */ 105161b83695SShaohua Li if (is_ejectable_bay(handle) && !is_dock(handle)) 1052db350b08SShaohua Li dock_add(handle); 1053db350b08SShaohua Li return AE_OK; 1054db350b08SShaohua Li } 1055db350b08SShaohua Li 1056c8f7a62cSLen Brown static int __init dock_init(void) 1057c8f7a62cSLen Brown { 1058816c2edaSLen Brown if (acpi_disabled) 1059816c2edaSLen Brown return 0; 1060816c2edaSLen Brown 1061c8f7a62cSLen Brown /* look for a dock station */ 1062c8f7a62cSLen Brown acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 1063db350b08SShaohua Li ACPI_UINT32_MAX, find_dock, NULL, NULL); 1064c8f7a62cSLen Brown 1065db350b08SShaohua Li /* look for bay */ 1066db350b08SShaohua Li acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 1067db350b08SShaohua Li ACPI_UINT32_MAX, find_bay, NULL, NULL); 1068db350b08SShaohua Li if (!dock_station_count) { 1069db350b08SShaohua Li printk(KERN_INFO PREFIX "No dock devices found.\n"); 1070db350b08SShaohua Li return 0; 1071db350b08SShaohua Li } 1072c8f7a62cSLen Brown 10736bd00a61SShaohua Li register_acpi_bus_notifier(&dock_acpi_notifier); 1074db350b08SShaohua Li printk(KERN_INFO PREFIX "%s: %d docks/bays found\n", 1075db350b08SShaohua Li ACPI_DOCK_DRIVER_DESCRIPTION, dock_station_count); 1076c8f7a62cSLen Brown return 0; 1077c8f7a62cSLen Brown } 1078c8f7a62cSLen Brown 1079c8f7a62cSLen Brown static void __exit dock_exit(void) 1080c8f7a62cSLen Brown { 1081db350b08SShaohua Li struct dock_station *dock_station; 1082f2407298SDan Carpenter struct dock_station *tmp; 1083db350b08SShaohua Li 10846bd00a61SShaohua Li unregister_acpi_bus_notifier(&dock_acpi_notifier); 108550d716e4SAlex Chiang list_for_each_entry_safe(dock_station, tmp, &dock_stations, sibling) 1086db350b08SShaohua Li dock_remove(dock_station); 1087c8f7a62cSLen Brown } 1088c8f7a62cSLen Brown 1089db350b08SShaohua Li /* 1090db350b08SShaohua Li * Must be called before drivers of devices in dock, otherwise we can't know 1091db350b08SShaohua Li * which devices are in a dock 1092db350b08SShaohua Li */ 1093db350b08SShaohua Li subsys_initcall(dock_init); 1094c8f7a62cSLen Brown module_exit(dock_exit); 1095