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 363f9eed5cSRashika #include "internal.h" 373f9eed5cSRashika 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 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 struct list_head dependent_devices; 65db350b08SShaohua Li 6650d716e4SAlex Chiang struct list_head sibling; 67db350b08SShaohua Li struct platform_device *dock_device; 68c8f7a62cSLen Brown }; 69db350b08SShaohua Li static LIST_HEAD(dock_stations); 70db350b08SShaohua Li static int dock_station_count; 71c8f7a62cSLen Brown 72c8f7a62cSLen Brown struct dock_dependent_device { 73c8f7a62cSLen Brown struct list_head list; 743b52b21fSRafael J. Wysocki struct acpi_device *adev; 75c8f7a62cSLen Brown }; 76c8f7a62cSLen Brown 77c8f7a62cSLen Brown #define DOCK_DOCKING 0x00000001 78a0cd35fdSKristen Carlson Accardi #define DOCK_UNDOCKING 0x00000002 79db350b08SShaohua Li #define DOCK_IS_DOCK 0x00000010 80db350b08SShaohua Li #define DOCK_IS_ATA 0x00000020 81db350b08SShaohua Li #define DOCK_IS_BAT 0x00000040 825669021eSKristen Carlson Accardi #define DOCK_EVENT 3 835669021eSKristen Carlson Accardi #define UNDOCK_EVENT 2 84c8f7a62cSLen Brown 85f09ce741SRafael J. Wysocki enum dock_callback_type { 86f09ce741SRafael J. Wysocki DOCK_CALL_HANDLER, 87f09ce741SRafael J. Wysocki DOCK_CALL_FIXUP, 88f09ce741SRafael J. Wysocki DOCK_CALL_UEVENT, 89f09ce741SRafael J. Wysocki }; 90f09ce741SRafael J. Wysocki 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 963b52b21fSRafael J. Wysocki * @ds: Dock station. 973b52b21fSRafael J. Wysocki * @adev: Dependent ACPI device object. 98c8f7a62cSLen Brown * 99f69cfdd2SAlex Chiang * Add the dependent device to the dock's dependent device list. 100c8f7a62cSLen Brown */ 1013b52b21fSRafael J. Wysocki static int add_dock_dependent_device(struct dock_station *ds, 1023b52b21fSRafael J. Wysocki struct acpi_device *adev) 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 1103b52b21fSRafael J. Wysocki dd->adev = adev; 111c8f7a62cSLen Brown INIT_LIST_HEAD(&dd->list); 112c8f7a62cSLen Brown list_add_tail(&dd->list, &ds->dependent_devices); 113f69cfdd2SAlex Chiang 114f69cfdd2SAlex Chiang return 0; 115c8f7a62cSLen Brown } 116c8f7a62cSLen Brown 117a30c4c5eSRafael J. Wysocki static void remove_dock_dependent_devices(struct dock_station *ds) 118a30c4c5eSRafael J. Wysocki { 119a30c4c5eSRafael J. Wysocki struct dock_dependent_device *dd, *aux; 120a30c4c5eSRafael J. Wysocki 121a30c4c5eSRafael J. Wysocki list_for_each_entry_safe(dd, aux, &ds->dependent_devices, list) { 122a30c4c5eSRafael J. Wysocki list_del(&dd->list); 123a30c4c5eSRafael J. Wysocki kfree(dd); 124a30c4c5eSRafael J. Wysocki } 125a30c4c5eSRafael J. Wysocki } 126a30c4c5eSRafael J. Wysocki 12721a31013SRafael J. Wysocki static void dock_hotplug_event(struct dock_dependent_device *dd, u32 event, 128f09ce741SRafael J. Wysocki enum dock_callback_type cb_type) 12921a31013SRafael J. Wysocki { 130edf5bf34SRafael J. Wysocki struct acpi_device *adev = dd->adev; 13121a31013SRafael J. Wysocki 132edf5bf34SRafael J. Wysocki acpi_lock_hp_context(); 133edf5bf34SRafael J. Wysocki 134edf5bf34SRafael J. Wysocki if (!adev->hp) 1352f16817dSRafael J. Wysocki goto out; 136edf5bf34SRafael J. Wysocki 137edf5bf34SRafael J. Wysocki if (cb_type == DOCK_CALL_FIXUP) { 138edf5bf34SRafael J. Wysocki void (*fixup)(struct acpi_device *); 139edf5bf34SRafael J. Wysocki 140edf5bf34SRafael J. Wysocki fixup = adev->hp->fixup; 141edf5bf34SRafael J. Wysocki if (fixup) { 142edf5bf34SRafael J. Wysocki acpi_unlock_hp_context(); 143edf5bf34SRafael J. Wysocki fixup(adev); 144edf5bf34SRafael J. Wysocki return; 145edf5bf34SRafael J. Wysocki } 146be27b3dcSRafael J. Wysocki } else if (cb_type == DOCK_CALL_UEVENT) { 147be27b3dcSRafael J. Wysocki void (*uevent)(struct acpi_device *, u32); 148be27b3dcSRafael J. Wysocki 149be27b3dcSRafael J. Wysocki uevent = adev->hp->uevent; 150be27b3dcSRafael J. Wysocki if (uevent) { 151be27b3dcSRafael J. Wysocki acpi_unlock_hp_context(); 152be27b3dcSRafael J. Wysocki uevent(adev, event); 153be27b3dcSRafael J. Wysocki return; 154be27b3dcSRafael J. Wysocki } 155edf5bf34SRafael J. Wysocki } else { 156edf5bf34SRafael J. Wysocki int (*notify)(struct acpi_device *, u32); 157edf5bf34SRafael J. Wysocki 158be27b3dcSRafael J. Wysocki notify = adev->hp->notify; 159edf5bf34SRafael J. Wysocki if (notify) { 160edf5bf34SRafael J. Wysocki acpi_unlock_hp_context(); 161edf5bf34SRafael J. Wysocki notify(adev, event); 162edf5bf34SRafael J. Wysocki return; 163edf5bf34SRafael J. Wysocki } 164edf5bf34SRafael J. Wysocki } 165edf5bf34SRafael J. Wysocki 1662f16817dSRafael J. Wysocki out: 167edf5bf34SRafael J. Wysocki acpi_unlock_hp_context(); 168c8f7a62cSLen Brown } 169c8f7a62cSLen Brown 1701e2380cdSRafael J. Wysocki static struct dock_station *find_dock_station(acpi_handle handle) 1711e2380cdSRafael J. Wysocki { 1721e2380cdSRafael J. Wysocki struct dock_station *ds; 1731e2380cdSRafael J. Wysocki 1741e2380cdSRafael J. Wysocki list_for_each_entry(ds, &dock_stations, sibling) 1751e2380cdSRafael J. Wysocki if (ds->handle == handle) 1761e2380cdSRafael J. Wysocki return ds; 1771e2380cdSRafael J. Wysocki 1781e2380cdSRafael J. Wysocki return NULL; 1791e2380cdSRafael J. Wysocki } 1801e2380cdSRafael J. Wysocki 181c8f7a62cSLen Brown /** 182c8f7a62cSLen Brown * find_dock_dependent_device - get a device dependent on this dock 183c8f7a62cSLen Brown * @ds: the dock station 1843b52b21fSRafael J. Wysocki * @adev: ACPI device object to find. 185c8f7a62cSLen Brown * 186c8f7a62cSLen Brown * iterate over the dependent device list for this dock. If the 187c8f7a62cSLen Brown * dependent device matches the handle, return. 188c8f7a62cSLen Brown */ 189c8f7a62cSLen Brown static struct dock_dependent_device * 1903b52b21fSRafael J. Wysocki find_dock_dependent_device(struct dock_station *ds, struct acpi_device *adev) 191c8f7a62cSLen Brown { 192c8f7a62cSLen Brown struct dock_dependent_device *dd; 193c8f7a62cSLen Brown 194ed633e70SJiang Liu list_for_each_entry(dd, &ds->dependent_devices, list) 1953b52b21fSRafael J. Wysocki if (adev == dd->adev) 196c8f7a62cSLen Brown return dd; 197ed633e70SJiang Liu 198c8f7a62cSLen Brown return NULL; 199c8f7a62cSLen Brown } 200c8f7a62cSLen Brown 2011e2380cdSRafael J. Wysocki void register_dock_dependent_device(struct acpi_device *adev, 2021e2380cdSRafael J. Wysocki acpi_handle dshandle) 2031e2380cdSRafael J. Wysocki { 2041e2380cdSRafael J. Wysocki struct dock_station *ds = find_dock_station(dshandle); 2051e2380cdSRafael J. Wysocki 2063b52b21fSRafael J. Wysocki if (ds && !find_dock_dependent_device(ds, adev)) 2073b52b21fSRafael J. Wysocki add_dock_dependent_device(ds, adev); 2081e2380cdSRafael J. Wysocki } 2091e2380cdSRafael J. Wysocki 210c8f7a62cSLen Brown /***************************************************************************** 211c8f7a62cSLen Brown * Dock functions * 212c8f7a62cSLen Brown *****************************************************************************/ 213db350b08SShaohua Li 214c8f7a62cSLen Brown /** 215c8f7a62cSLen Brown * is_dock_device - see if a device is on a dock station 2163b52b21fSRafael J. Wysocki * @adev: ACPI device object to check. 217c8f7a62cSLen Brown * 218c8f7a62cSLen Brown * If this device is either the dock station itself, 219c8f7a62cSLen Brown * or is a device dependent on the dock station, then it 220c8f7a62cSLen Brown * is a dock device 221c8f7a62cSLen Brown */ 2223b52b21fSRafael J. Wysocki int is_dock_device(struct acpi_device *adev) 223c8f7a62cSLen Brown { 224db350b08SShaohua Li struct dock_station *dock_station; 225db350b08SShaohua Li 226db350b08SShaohua Li if (!dock_station_count) 227c8f7a62cSLen Brown return 0; 228c8f7a62cSLen Brown 2293b52b21fSRafael J. Wysocki if (acpi_dock_match(adev->handle)) 230c8f7a62cSLen Brown return 1; 231747479a3SAlex Chiang 232747479a3SAlex Chiang list_for_each_entry(dock_station, &dock_stations, sibling) 2333b52b21fSRafael J. Wysocki if (find_dock_dependent_device(dock_station, adev)) 234db350b08SShaohua Li return 1; 235c8f7a62cSLen Brown 236c8f7a62cSLen Brown return 0; 237c8f7a62cSLen Brown } 238c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(is_dock_device); 239c8f7a62cSLen Brown 240c8f7a62cSLen Brown /** 241c8f7a62cSLen Brown * dock_present - see if the dock station is present. 242c8f7a62cSLen Brown * @ds: the dock station 243c8f7a62cSLen Brown * 244c8f7a62cSLen Brown * execute the _STA method. note that present does not 245c8f7a62cSLen Brown * imply that we are docked. 246c8f7a62cSLen Brown */ 247c8f7a62cSLen Brown static int dock_present(struct dock_station *ds) 248c8f7a62cSLen Brown { 24927663c58SMatthew Wilcox unsigned long long sta; 250c8f7a62cSLen Brown acpi_status status; 251c8f7a62cSLen Brown 252c8f7a62cSLen Brown if (ds) { 253c8f7a62cSLen Brown status = acpi_evaluate_integer(ds->handle, "_STA", NULL, &sta); 254c8f7a62cSLen Brown if (ACPI_SUCCESS(status) && sta) 255c8f7a62cSLen Brown return 1; 256c8f7a62cSLen Brown } 257c8f7a62cSLen Brown return 0; 258c8f7a62cSLen Brown } 259c8f7a62cSLen Brown 260c8f7a62cSLen Brown /** 26137f90877SRafael J. Wysocki * hot_remove_dock_devices - Remove dock station devices. 26237f90877SRafael J. Wysocki * @ds: Dock station. 26337f90877SRafael J. Wysocki */ 26437f90877SRafael J. Wysocki static void hot_remove_dock_devices(struct dock_station *ds) 26537f90877SRafael J. Wysocki { 26637f90877SRafael J. Wysocki struct dock_dependent_device *dd; 26737f90877SRafael J. Wysocki 26837f90877SRafael J. Wysocki /* 26937f90877SRafael J. Wysocki * Walk the list in reverse order so that devices that have been added 27037f90877SRafael J. Wysocki * last are removed first (in case there are some indirect dependencies 27137f90877SRafael J. Wysocki * between them). 27237f90877SRafael J. Wysocki */ 27337f90877SRafael J. Wysocki list_for_each_entry_reverse(dd, &ds->dependent_devices, list) 27437f90877SRafael J. Wysocki dock_hotplug_event(dd, ACPI_NOTIFY_EJECT_REQUEST, false); 27537f90877SRafael J. Wysocki 27637f90877SRafael J. Wysocki list_for_each_entry_reverse(dd, &ds->dependent_devices, list) 2773b52b21fSRafael J. Wysocki acpi_bus_trim(dd->adev); 27837f90877SRafael J. Wysocki } 27937f90877SRafael J. Wysocki 28037f90877SRafael J. Wysocki /** 28137f90877SRafael J. Wysocki * hotplug_dock_devices - Insert devices on a dock station. 282c8f7a62cSLen Brown * @ds: the dock station 28337f90877SRafael J. Wysocki * @event: either bus check or device check request 284c8f7a62cSLen Brown * 285c8f7a62cSLen Brown * Some devices on the dock station need to have drivers called 286c8f7a62cSLen Brown * to perform hotplug operations after a dock event has occurred. 287c8f7a62cSLen Brown * Traverse the list of dock devices that have registered a 288c8f7a62cSLen Brown * hotplug handler, and call the handler. 289c8f7a62cSLen Brown */ 290c8f7a62cSLen Brown static void hotplug_dock_devices(struct dock_station *ds, u32 event) 291c8f7a62cSLen Brown { 292c8f7a62cSLen Brown struct dock_dependent_device *dd; 293c8f7a62cSLen Brown 294f09ce741SRafael J. Wysocki /* Call driver specific post-dock fixups. */ 295f09ce741SRafael J. Wysocki list_for_each_entry(dd, &ds->dependent_devices, list) 296f09ce741SRafael J. Wysocki dock_hotplug_event(dd, event, DOCK_CALL_FIXUP); 297f09ce741SRafael J. Wysocki 29837f90877SRafael J. Wysocki /* Call driver specific hotplug functions. */ 29921a31013SRafael J. Wysocki list_for_each_entry(dd, &ds->dependent_devices, list) 300f09ce741SRafael J. Wysocki dock_hotplug_event(dd, event, DOCK_CALL_HANDLER); 301c8f7a62cSLen Brown 302c8f7a62cSLen Brown /* 3033b52b21fSRafael J. Wysocki * Check if all devices have been enumerated already. If not, run 3043b52b21fSRafael J. Wysocki * acpi_bus_scan() for them and that will cause scan handlers to be 3053b52b21fSRafael J. Wysocki * attached to device objects or acpi_drivers to be stopped/started if 3063b52b21fSRafael J. Wysocki * they are present. 307c8f7a62cSLen Brown */ 3083b52b21fSRafael J. Wysocki list_for_each_entry(dd, &ds->dependent_devices, list) { 3093b52b21fSRafael J. Wysocki struct acpi_device *adev = dd->adev; 3103b52b21fSRafael J. Wysocki 3113b52b21fSRafael J. Wysocki if (!acpi_device_enumerated(adev)) { 3123b52b21fSRafael J. Wysocki int ret = acpi_bus_scan(adev->handle); 3133b52b21fSRafael J. Wysocki if (ret) 3143b52b21fSRafael J. Wysocki dev_dbg(&adev->dev, "scan error %d\n", -ret); 3153b52b21fSRafael J. Wysocki } 3163b52b21fSRafael J. Wysocki } 317c8f7a62cSLen Brown } 318c8f7a62cSLen Brown 319c8f7a62cSLen Brown static void dock_event(struct dock_station *ds, u32 event, int num) 320c8f7a62cSLen Brown { 321db350b08SShaohua Li struct device *dev = &ds->dock_device->dev; 32266b56821SHolger Macht char event_string[13]; 32379a8f70bSKristen Carlson Accardi char *envp[] = { event_string, NULL }; 3241253f7aaSShaohua Li struct dock_dependent_device *dd; 32579a8f70bSKristen Carlson Accardi 32679a8f70bSKristen Carlson Accardi if (num == UNDOCK_EVENT) 32766b56821SHolger Macht sprintf(event_string, "EVENT=undock"); 32879a8f70bSKristen Carlson Accardi else 32966b56821SHolger Macht sprintf(event_string, "EVENT=dock"); 33079a8f70bSKristen Carlson Accardi 3315669021eSKristen Carlson Accardi /* 3328ea86e0bSKristen Carlson Accardi * Indicate that the status of the dock station has 3338ea86e0bSKristen Carlson Accardi * changed. 3345669021eSKristen Carlson Accardi */ 3351253f7aaSShaohua Li if (num == DOCK_EVENT) 3361253f7aaSShaohua Li kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp); 3371253f7aaSShaohua Li 33821a31013SRafael J. Wysocki list_for_each_entry(dd, &ds->dependent_devices, list) 339f09ce741SRafael J. Wysocki dock_hotplug_event(dd, event, DOCK_CALL_UEVENT); 340747479a3SAlex Chiang 3411253f7aaSShaohua Li if (num != DOCK_EVENT) 34279a8f70bSKristen Carlson Accardi kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp); 343c8f7a62cSLen Brown } 344c8f7a62cSLen Brown 345c8f7a62cSLen Brown /** 346c8f7a62cSLen Brown * handle_dock - handle a dock event 347c8f7a62cSLen Brown * @ds: the dock station 348c8f7a62cSLen Brown * @dock: to dock, or undock - that is the question 349c8f7a62cSLen Brown * 350c8f7a62cSLen Brown * Execute the _DCK method in response to an acpi event 351c8f7a62cSLen Brown */ 352c8f7a62cSLen Brown static void handle_dock(struct dock_station *ds, int dock) 353c8f7a62cSLen Brown { 354c8f7a62cSLen Brown acpi_status status; 355c8f7a62cSLen Brown struct acpi_object_list arg_list; 356c8f7a62cSLen Brown union acpi_object arg; 3576a868e17SZhang Rui unsigned long long value; 358c8f7a62cSLen Brown 359cd73018fSToshi Kani acpi_handle_info(ds->handle, "%s\n", dock ? "docking" : "undocking"); 360c8f7a62cSLen Brown 361c8f7a62cSLen Brown /* _DCK method has one argument */ 362c8f7a62cSLen Brown arg_list.count = 1; 363c8f7a62cSLen Brown arg_list.pointer = &arg; 364c8f7a62cSLen Brown arg.type = ACPI_TYPE_INTEGER; 365c8f7a62cSLen Brown arg.integer.value = dock; 3666a868e17SZhang Rui status = acpi_evaluate_integer(ds->handle, "_DCK", &arg_list, &value); 367db350b08SShaohua Li if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) 368cd73018fSToshi Kani acpi_handle_err(ds->handle, "Failed to execute _DCK (0x%x)\n", 369cd73018fSToshi Kani status); 370c8f7a62cSLen Brown } 371c8f7a62cSLen Brown 372c8f7a62cSLen Brown static inline void dock(struct dock_station *ds) 373c8f7a62cSLen Brown { 374c8f7a62cSLen Brown handle_dock(ds, 1); 375c8f7a62cSLen Brown } 376c8f7a62cSLen Brown 377c8f7a62cSLen Brown static inline void undock(struct dock_station *ds) 378c8f7a62cSLen Brown { 379c8f7a62cSLen Brown handle_dock(ds, 0); 380c8f7a62cSLen Brown } 381c8f7a62cSLen Brown 382c8f7a62cSLen Brown static inline void begin_dock(struct dock_station *ds) 383c8f7a62cSLen Brown { 384c8f7a62cSLen Brown ds->flags |= DOCK_DOCKING; 385c8f7a62cSLen Brown } 386c8f7a62cSLen Brown 387c8f7a62cSLen Brown static inline void complete_dock(struct dock_station *ds) 388c8f7a62cSLen Brown { 389c8f7a62cSLen Brown ds->flags &= ~(DOCK_DOCKING); 390c8f7a62cSLen Brown ds->last_dock_time = jiffies; 391c8f7a62cSLen Brown } 392c8f7a62cSLen Brown 393a0cd35fdSKristen Carlson Accardi static inline void begin_undock(struct dock_station *ds) 394a0cd35fdSKristen Carlson Accardi { 395a0cd35fdSKristen Carlson Accardi ds->flags |= DOCK_UNDOCKING; 396a0cd35fdSKristen Carlson Accardi } 397a0cd35fdSKristen Carlson Accardi 398a0cd35fdSKristen Carlson Accardi static inline void complete_undock(struct dock_station *ds) 399a0cd35fdSKristen Carlson Accardi { 400a0cd35fdSKristen Carlson Accardi ds->flags &= ~(DOCK_UNDOCKING); 401a0cd35fdSKristen Carlson Accardi } 402a0cd35fdSKristen Carlson Accardi 403c8f7a62cSLen Brown /** 404c8f7a62cSLen Brown * dock_in_progress - see if we are in the middle of handling a dock event 405c8f7a62cSLen Brown * @ds: the dock station 406c8f7a62cSLen Brown * 407c8f7a62cSLen Brown * Sometimes while docking, false dock events can be sent to the driver 408c8f7a62cSLen Brown * because good connections aren't made or some other reason. Ignore these 409c8f7a62cSLen Brown * if we are in the middle of doing something. 410c8f7a62cSLen Brown */ 411c8f7a62cSLen Brown static int dock_in_progress(struct dock_station *ds) 412c8f7a62cSLen Brown { 413c8f7a62cSLen Brown if ((ds->flags & DOCK_DOCKING) || 414c8f7a62cSLen Brown time_before(jiffies, (ds->last_dock_time + HZ))) 415c8f7a62cSLen Brown return 1; 416c8f7a62cSLen Brown return 0; 417c8f7a62cSLen Brown } 418c8f7a62cSLen Brown 419c8f7a62cSLen Brown /** 420c80fdbe8Sbrandon@ifup.org * handle_eject_request - handle an undock request checking for error conditions 421c80fdbe8Sbrandon@ifup.org * 422c80fdbe8Sbrandon@ifup.org * Check to make sure the dock device is still present, then undock and 423c80fdbe8Sbrandon@ifup.org * hotremove all the devices that may need removing. 424c80fdbe8Sbrandon@ifup.org */ 425c80fdbe8Sbrandon@ifup.org static int handle_eject_request(struct dock_station *ds, u32 event) 426c80fdbe8Sbrandon@ifup.org { 427c80fdbe8Sbrandon@ifup.org if (dock_in_progress(ds)) 428c80fdbe8Sbrandon@ifup.org return -EBUSY; 429c80fdbe8Sbrandon@ifup.org 430c80fdbe8Sbrandon@ifup.org /* 431c80fdbe8Sbrandon@ifup.org * here we need to generate the undock 432c80fdbe8Sbrandon@ifup.org * event prior to actually doing the undock 433c80fdbe8Sbrandon@ifup.org * so that the device struct still exists. 434afd7301dSHolger Macht * Also, even send the dock event if the 435afd7301dSHolger Macht * device is not present anymore 436c80fdbe8Sbrandon@ifup.org */ 437c80fdbe8Sbrandon@ifup.org dock_event(ds, event, UNDOCK_EVENT); 438afd7301dSHolger Macht 43937f90877SRafael J. Wysocki hot_remove_dock_devices(ds); 440c80fdbe8Sbrandon@ifup.org undock(ds); 441c9b5471fSJiang Liu acpi_evaluate_lck(ds->handle, 0); 442c9b5471fSJiang Liu acpi_evaluate_ej0(ds->handle); 443c80fdbe8Sbrandon@ifup.org if (dock_present(ds)) { 444cd73018fSToshi Kani acpi_handle_err(ds->handle, "Unable to undock!\n"); 445c80fdbe8Sbrandon@ifup.org return -EBUSY; 446c80fdbe8Sbrandon@ifup.org } 447a0cd35fdSKristen Carlson Accardi complete_undock(ds); 448c80fdbe8Sbrandon@ifup.org return 0; 449c80fdbe8Sbrandon@ifup.org } 450c80fdbe8Sbrandon@ifup.org 451c80fdbe8Sbrandon@ifup.org /** 4521e2380cdSRafael J. Wysocki * dock_notify - Handle ACPI dock notification. 4531e2380cdSRafael J. Wysocki * @adev: Dock station's ACPI device object. 4541e2380cdSRafael J. Wysocki * @event: Event code. 455c8f7a62cSLen Brown * 456c8f7a62cSLen Brown * If we are notified to dock, then check to see if the dock is 457c8f7a62cSLen Brown * present and then dock. Notify all drivers of the dock event, 458c80fdbe8Sbrandon@ifup.org * and then hotplug and devices that may need hotplugging. 459c8f7a62cSLen Brown */ 4601e2380cdSRafael J. Wysocki int dock_notify(struct acpi_device *adev, u32 event) 461c8f7a62cSLen Brown { 4621e2380cdSRafael J. Wysocki acpi_handle handle = adev->handle; 4631e2380cdSRafael J. Wysocki struct dock_station *ds = find_dock_station(handle); 464db350b08SShaohua Li int surprise_removal = 0; 465c8f7a62cSLen Brown 4661e2380cdSRafael J. Wysocki if (!ds) 4671e2380cdSRafael J. Wysocki return -ENODEV; 4681e2380cdSRafael J. Wysocki 469db350b08SShaohua Li /* 470db350b08SShaohua Li * According to acpi spec 3.0a, if a DEVICE_CHECK notification 471db350b08SShaohua Li * is sent and _DCK is present, it is assumed to mean an undock 472db350b08SShaohua Li * request. 473db350b08SShaohua Li */ 474db350b08SShaohua Li if ((ds->flags & DOCK_IS_DOCK) && event == ACPI_NOTIFY_DEVICE_CHECK) 475db350b08SShaohua Li event = ACPI_NOTIFY_EJECT_REQUEST; 476db350b08SShaohua Li 477db350b08SShaohua Li /* 478db350b08SShaohua Li * dock station: BUS_CHECK - docked or surprise removal 479db350b08SShaohua Li * DEVICE_CHECK - undocked 480db350b08SShaohua Li * other device: BUS_CHECK/DEVICE_CHECK - added or surprise removal 481db350b08SShaohua Li * 482db350b08SShaohua Li * To simplify event handling, dock dependent device handler always 483db350b08SShaohua Li * get ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and 484db350b08SShaohua Li * ACPI_NOTIFY_EJECT_REQUEST for removal 485db350b08SShaohua Li */ 486c8f7a62cSLen Brown switch (event) { 487c8f7a62cSLen Brown case ACPI_NOTIFY_BUS_CHECK: 488db350b08SShaohua Li case ACPI_NOTIFY_DEVICE_CHECK: 4890a8e5c3dSRafael J. Wysocki if (!dock_in_progress(ds) && !acpi_device_enumerated(adev)) { 490c8f7a62cSLen Brown begin_dock(ds); 491c8f7a62cSLen Brown dock(ds); 492c8f7a62cSLen Brown if (!dock_present(ds)) { 493cd73018fSToshi Kani acpi_handle_err(handle, "Unable to dock!\n"); 4948b59560aSShaohua Li complete_dock(ds); 495c8f7a62cSLen Brown break; 496c8f7a62cSLen Brown } 497c8f7a62cSLen Brown hotplug_dock_devices(ds, event); 498c8f7a62cSLen Brown complete_dock(ds); 499c8f7a62cSLen Brown dock_event(ds, event, DOCK_EVENT); 500c9b5471fSJiang Liu acpi_evaluate_lck(ds->handle, 1); 5013a37898dSLin Ming acpi_update_all_gpes(); 502c8f7a62cSLen Brown break; 503db350b08SShaohua Li } 504db350b08SShaohua Li if (dock_present(ds) || dock_in_progress(ds)) 505db350b08SShaohua Li break; 506db350b08SShaohua Li /* This is a surprise removal */ 507db350b08SShaohua Li surprise_removal = 1; 508db350b08SShaohua Li event = ACPI_NOTIFY_EJECT_REQUEST; 509db350b08SShaohua Li /* Fall back */ 510c8f7a62cSLen Brown case ACPI_NOTIFY_EJECT_REQUEST: 511a0cd35fdSKristen Carlson Accardi begin_undock(ds); 512f730ae18SShaohua Li if ((immediate_undock && !(ds->flags & DOCK_IS_ATA)) 513f730ae18SShaohua Li || surprise_removal) 514c80fdbe8Sbrandon@ifup.org handle_eject_request(ds, event); 515a0cd35fdSKristen Carlson Accardi else 516a0cd35fdSKristen Carlson Accardi dock_event(ds, event, UNDOCK_EVENT); 517c8f7a62cSLen Brown break; 518c8f7a62cSLen Brown } 5191e2380cdSRafael J. Wysocki return 0; 520c8f7a62cSLen Brown } 521c8f7a62cSLen Brown 522c80fdbe8Sbrandon@ifup.org /* 523c80fdbe8Sbrandon@ifup.org * show_docked - read method for "docked" file in sysfs 524c80fdbe8Sbrandon@ifup.org */ 525c80fdbe8Sbrandon@ifup.org static ssize_t show_docked(struct device *dev, 526c80fdbe8Sbrandon@ifup.org struct device_attribute *attr, char *buf) 527c80fdbe8Sbrandon@ifup.org { 528fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 529ab62f9cdSRafael J. Wysocki struct acpi_device *adev = NULL; 530c80fdbe8Sbrandon@ifup.org 531ab62f9cdSRafael J. Wysocki acpi_bus_get_device(dock_station->handle, &adev); 532ab62f9cdSRafael J. Wysocki return snprintf(buf, PAGE_SIZE, "%u\n", acpi_device_enumerated(adev)); 533c80fdbe8Sbrandon@ifup.org } 534e5685b9dSAdrian Bunk static DEVICE_ATTR(docked, S_IRUGO, show_docked, NULL); 535c80fdbe8Sbrandon@ifup.org 536c80fdbe8Sbrandon@ifup.org /* 537a0cd35fdSKristen Carlson Accardi * show_flags - read method for flags file in sysfs 538a0cd35fdSKristen Carlson Accardi */ 539a0cd35fdSKristen Carlson Accardi static ssize_t show_flags(struct device *dev, 540a0cd35fdSKristen Carlson Accardi struct device_attribute *attr, char *buf) 541a0cd35fdSKristen Carlson Accardi { 542fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 543a0cd35fdSKristen Carlson Accardi return snprintf(buf, PAGE_SIZE, "%d\n", dock_station->flags); 544a0cd35fdSKristen Carlson Accardi 545a0cd35fdSKristen Carlson Accardi } 546e5685b9dSAdrian Bunk static DEVICE_ATTR(flags, S_IRUGO, show_flags, NULL); 547a0cd35fdSKristen Carlson Accardi 548a0cd35fdSKristen Carlson Accardi /* 549c80fdbe8Sbrandon@ifup.org * write_undock - write method for "undock" file in sysfs 550c80fdbe8Sbrandon@ifup.org */ 551c80fdbe8Sbrandon@ifup.org static ssize_t write_undock(struct device *dev, struct device_attribute *attr, 552c80fdbe8Sbrandon@ifup.org const char *buf, size_t count) 553c80fdbe8Sbrandon@ifup.org { 554c80fdbe8Sbrandon@ifup.org int ret; 555fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 556c80fdbe8Sbrandon@ifup.org 557c80fdbe8Sbrandon@ifup.org if (!count) 558c80fdbe8Sbrandon@ifup.org return -EINVAL; 559c80fdbe8Sbrandon@ifup.org 5608112006fSRafael J. Wysocki acpi_scan_lock_acquire(); 5619171f834SHolger Macht begin_undock(dock_station); 562c80fdbe8Sbrandon@ifup.org ret = handle_eject_request(dock_station, ACPI_NOTIFY_EJECT_REQUEST); 5638112006fSRafael J. Wysocki acpi_scan_lock_release(); 564c80fdbe8Sbrandon@ifup.org return ret ? ret: count; 565c80fdbe8Sbrandon@ifup.org } 566e5685b9dSAdrian Bunk static DEVICE_ATTR(undock, S_IWUSR, NULL, write_undock); 567c80fdbe8Sbrandon@ifup.org 568ac122bb6SIlya A. Volynets-Evenbakh /* 569ac122bb6SIlya A. Volynets-Evenbakh * show_dock_uid - read method for "uid" file in sysfs 570ac122bb6SIlya A. Volynets-Evenbakh */ 571ac122bb6SIlya A. Volynets-Evenbakh static ssize_t show_dock_uid(struct device *dev, 572ac122bb6SIlya A. Volynets-Evenbakh struct device_attribute *attr, char *buf) 573ac122bb6SIlya A. Volynets-Evenbakh { 57427663c58SMatthew Wilcox unsigned long long lbuf; 575fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 57638ff4ffcSKristen Carlson Accardi acpi_status status = acpi_evaluate_integer(dock_station->handle, 57738ff4ffcSKristen Carlson Accardi "_UID", NULL, &lbuf); 57838ff4ffcSKristen Carlson Accardi if (ACPI_FAILURE(status)) 579ac122bb6SIlya A. Volynets-Evenbakh return 0; 58038ff4ffcSKristen Carlson Accardi 58127663c58SMatthew Wilcox return snprintf(buf, PAGE_SIZE, "%llx\n", lbuf); 582ac122bb6SIlya A. Volynets-Evenbakh } 583e5685b9dSAdrian Bunk static DEVICE_ATTR(uid, S_IRUGO, show_dock_uid, NULL); 584ac122bb6SIlya A. Volynets-Evenbakh 5858652b00fSShaohua Li static ssize_t show_dock_type(struct device *dev, 5868652b00fSShaohua Li struct device_attribute *attr, char *buf) 5878652b00fSShaohua Li { 588fe06fba2SAlex Chiang struct dock_station *dock_station = dev->platform_data; 5898652b00fSShaohua Li char *type; 5908652b00fSShaohua Li 5918652b00fSShaohua Li if (dock_station->flags & DOCK_IS_DOCK) 5928652b00fSShaohua Li type = "dock_station"; 5938652b00fSShaohua Li else if (dock_station->flags & DOCK_IS_ATA) 5948652b00fSShaohua Li type = "ata_bay"; 5958652b00fSShaohua Li else if (dock_station->flags & DOCK_IS_BAT) 5968652b00fSShaohua Li type = "battery_bay"; 5978652b00fSShaohua Li else 5988652b00fSShaohua Li type = "unknown"; 5998652b00fSShaohua Li 6008652b00fSShaohua Li return snprintf(buf, PAGE_SIZE, "%s\n", type); 6018652b00fSShaohua Li } 6028652b00fSShaohua Li static DEVICE_ATTR(type, S_IRUGO, show_dock_type, NULL); 6038652b00fSShaohua Li 6045f46c2f2SAlex Chiang static struct attribute *dock_attributes[] = { 6055f46c2f2SAlex Chiang &dev_attr_docked.attr, 6065f46c2f2SAlex Chiang &dev_attr_flags.attr, 6075f46c2f2SAlex Chiang &dev_attr_undock.attr, 6085f46c2f2SAlex Chiang &dev_attr_uid.attr, 6095f46c2f2SAlex Chiang &dev_attr_type.attr, 6105f46c2f2SAlex Chiang NULL 6115f46c2f2SAlex Chiang }; 6125f46c2f2SAlex Chiang 6135f46c2f2SAlex Chiang static struct attribute_group dock_attribute_group = { 6145f46c2f2SAlex Chiang .attrs = dock_attributes 6155f46c2f2SAlex Chiang }; 6165f46c2f2SAlex Chiang 617c8f7a62cSLen Brown /** 6181e2380cdSRafael J. Wysocki * acpi_dock_add - Add a new dock station 6191e2380cdSRafael J. Wysocki * @adev: Dock station ACPI device object. 620c8f7a62cSLen Brown * 6211e2380cdSRafael J. Wysocki * allocated and initialize a new dock station device. 622c8f7a62cSLen Brown */ 6231e2380cdSRafael J. Wysocki void acpi_dock_add(struct acpi_device *adev) 624c8f7a62cSLen Brown { 6252efbca4dSRafael J. Wysocki struct dock_station *dock_station, ds = { NULL, }; 626af887449SRafael J. Wysocki struct platform_device_info pdevinfo; 6271e2380cdSRafael J. Wysocki acpi_handle handle = adev->handle; 628747479a3SAlex Chiang struct platform_device *dd; 6292efbca4dSRafael J. Wysocki int ret; 630c8f7a62cSLen Brown 631af887449SRafael J. Wysocki memset(&pdevinfo, 0, sizeof(pdevinfo)); 632af887449SRafael J. Wysocki pdevinfo.name = "dock"; 633af887449SRafael J. Wysocki pdevinfo.id = dock_station_count; 634af887449SRafael J. Wysocki pdevinfo.acpi_node.companion = adev; 635af887449SRafael J. Wysocki pdevinfo.data = &ds; 636af887449SRafael J. Wysocki pdevinfo.size_data = sizeof(ds); 637af887449SRafael J. Wysocki dd = platform_device_register_full(&pdevinfo); 638747479a3SAlex Chiang if (IS_ERR(dd)) 6391e2380cdSRafael J. Wysocki return; 6409751cb72SAlex Chiang 641747479a3SAlex Chiang dock_station = dd->dev.platform_data; 642747479a3SAlex Chiang 643c8f7a62cSLen Brown dock_station->handle = handle; 644747479a3SAlex Chiang dock_station->dock_device = dd; 645c8f7a62cSLen Brown dock_station->last_dock_time = jiffies - HZ; 646c8f7a62cSLen Brown 647747479a3SAlex Chiang INIT_LIST_HEAD(&dock_station->sibling); 648747479a3SAlex Chiang INIT_LIST_HEAD(&dock_station->dependent_devices); 649a0cd35fdSKristen Carlson Accardi 6509ef2a9a9SKristen Carlson Accardi /* we want the dock device to send uevents */ 651747479a3SAlex Chiang dev_set_uevent_suppress(&dd->dev, 0); 6529ef2a9a9SKristen Carlson Accardi 653c9b5471fSJiang Liu if (acpi_dock_match(handle)) 654db350b08SShaohua Li dock_station->flags |= DOCK_IS_DOCK; 655c9b5471fSJiang Liu if (acpi_ata_match(handle)) 656db350b08SShaohua Li dock_station->flags |= DOCK_IS_ATA; 657b43109faSRafael J. Wysocki if (acpi_device_is_battery(adev)) 658db350b08SShaohua Li dock_station->flags |= DOCK_IS_BAT; 659db350b08SShaohua Li 660747479a3SAlex Chiang ret = sysfs_create_group(&dd->dev.kobj, &dock_attribute_group); 6618652b00fSShaohua Li if (ret) 6625f46c2f2SAlex Chiang goto err_unregister; 663671adbecSKristen Carlson Accardi 664c8f7a62cSLen Brown /* add the dock station as a device dependent on itself */ 6653b52b21fSRafael J. Wysocki ret = add_dock_dependent_device(dock_station, adev); 666f69cfdd2SAlex Chiang if (ret) 6675f46c2f2SAlex Chiang goto err_rmgroup; 668c8f7a62cSLen Brown 669db350b08SShaohua Li dock_station_count++; 67050d716e4SAlex Chiang list_add(&dock_station->sibling, &dock_stations); 6711e2380cdSRafael J. Wysocki adev->flags.is_dock_station = true; 6721e2380cdSRafael J. Wysocki dev_info(&adev->dev, "ACPI dock station (docks/bays count: %d)\n", 6731e2380cdSRafael J. Wysocki dock_station_count); 6741e2380cdSRafael J. Wysocki return; 675c8f7a62cSLen Brown 6765f46c2f2SAlex Chiang err_rmgroup: 677a30c4c5eSRafael J. Wysocki remove_dock_dependent_devices(dock_station); 678747479a3SAlex Chiang sysfs_remove_group(&dd->dev.kobj, &dock_attribute_group); 6795f46c2f2SAlex Chiang err_unregister: 680747479a3SAlex Chiang platform_device_unregister(dd); 681cd73018fSToshi Kani acpi_handle_err(handle, "%s encountered error %d\n", __func__, ret); 682c8f7a62cSLen Brown } 683