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> 32c8f7a62cSLen Brown #include <acpi/acpi_bus.h> 33c8f7a62cSLen Brown #include <acpi/acpi_drivers.h> 34c8f7a62cSLen Brown 357cda93e0SLen Brown #define ACPI_DOCK_DRIVER_DESCRIPTION "ACPI Dock Station Driver" 36c8f7a62cSLen Brown 37f52fd66dSLen Brown ACPI_MODULE_NAME("dock"); 38c8f7a62cSLen Brown MODULE_AUTHOR("Kristen Carlson Accardi"); 397cda93e0SLen Brown MODULE_DESCRIPTION(ACPI_DOCK_DRIVER_DESCRIPTION); 40c8f7a62cSLen Brown MODULE_LICENSE("GPL"); 41c8f7a62cSLen Brown 42c8f7a62cSLen Brown static struct atomic_notifier_head dock_notifier_list; 43671adbecSKristen Carlson Accardi static struct platform_device dock_device; 44671adbecSKristen Carlson Accardi static char dock_device_name[] = "dock"; 45c8f7a62cSLen Brown 46c8f7a62cSLen Brown struct dock_station { 47c8f7a62cSLen Brown acpi_handle handle; 48c8f7a62cSLen Brown unsigned long last_dock_time; 49c8f7a62cSLen Brown u32 flags; 50c8f7a62cSLen Brown spinlock_t dd_lock; 518b0dc866SKristen Carlson Accardi struct mutex hp_lock; 52c8f7a62cSLen Brown struct list_head dependent_devices; 53c8f7a62cSLen Brown struct list_head hotplug_devices; 54c8f7a62cSLen Brown }; 55c8f7a62cSLen Brown 56c8f7a62cSLen Brown struct dock_dependent_device { 57c8f7a62cSLen Brown struct list_head list; 58c8f7a62cSLen Brown struct list_head hotplug_list; 59c8f7a62cSLen Brown acpi_handle handle; 60c8f7a62cSLen Brown acpi_notify_handler handler; 61c8f7a62cSLen Brown void *context; 62c8f7a62cSLen Brown }; 63c8f7a62cSLen Brown 64c8f7a62cSLen Brown #define DOCK_DOCKING 0x00000001 655669021eSKristen Carlson Accardi #define DOCK_EVENT 3 665669021eSKristen Carlson Accardi #define UNDOCK_EVENT 2 67c8f7a62cSLen Brown 68c8f7a62cSLen Brown static struct dock_station *dock_station; 69c8f7a62cSLen Brown 70c8f7a62cSLen Brown /***************************************************************************** 71c8f7a62cSLen Brown * Dock Dependent device functions * 72c8f7a62cSLen Brown *****************************************************************************/ 73c8f7a62cSLen Brown /** 74c8f7a62cSLen Brown * alloc_dock_dependent_device - allocate and init a dependent device 75c8f7a62cSLen Brown * @handle: the acpi_handle of the dependent device 76c8f7a62cSLen Brown * 77c8f7a62cSLen Brown * Allocate memory for a dependent device structure for a device referenced 78c8f7a62cSLen Brown * by the acpi handle 79c8f7a62cSLen Brown */ 80c8f7a62cSLen Brown static struct dock_dependent_device * 81c8f7a62cSLen Brown alloc_dock_dependent_device(acpi_handle handle) 82c8f7a62cSLen Brown { 83c8f7a62cSLen Brown struct dock_dependent_device *dd; 84c8f7a62cSLen Brown 85c8f7a62cSLen Brown dd = kzalloc(sizeof(*dd), GFP_KERNEL); 86c8f7a62cSLen Brown if (dd) { 87c8f7a62cSLen Brown dd->handle = handle; 88c8f7a62cSLen Brown INIT_LIST_HEAD(&dd->list); 89c8f7a62cSLen Brown INIT_LIST_HEAD(&dd->hotplug_list); 90c8f7a62cSLen Brown } 91c8f7a62cSLen Brown return dd; 92c8f7a62cSLen Brown } 93c8f7a62cSLen Brown 94c8f7a62cSLen Brown /** 95c8f7a62cSLen Brown * add_dock_dependent_device - associate a device with the dock station 96c8f7a62cSLen Brown * @ds: The dock station 97c8f7a62cSLen Brown * @dd: The dependent device 98c8f7a62cSLen Brown * 99c8f7a62cSLen Brown * Add the dependent device to the dock's dependent device list. 100c8f7a62cSLen Brown */ 101c8f7a62cSLen Brown static void 102c8f7a62cSLen Brown add_dock_dependent_device(struct dock_station *ds, 103c8f7a62cSLen Brown struct dock_dependent_device *dd) 104c8f7a62cSLen Brown { 105c8f7a62cSLen Brown spin_lock(&ds->dd_lock); 106c8f7a62cSLen Brown list_add_tail(&dd->list, &ds->dependent_devices); 107c8f7a62cSLen Brown spin_unlock(&ds->dd_lock); 108c8f7a62cSLen Brown } 109c8f7a62cSLen Brown 110c8f7a62cSLen Brown /** 111c8f7a62cSLen Brown * dock_add_hotplug_device - associate a hotplug handler with the dock station 112c8f7a62cSLen Brown * @ds: The dock station 113c8f7a62cSLen Brown * @dd: The dependent device struct 114c8f7a62cSLen Brown * 115c8f7a62cSLen Brown * Add the dependent device to the dock's hotplug device list 116c8f7a62cSLen Brown */ 117c8f7a62cSLen Brown static void 118c8f7a62cSLen Brown dock_add_hotplug_device(struct dock_station *ds, 119c8f7a62cSLen Brown struct dock_dependent_device *dd) 120c8f7a62cSLen Brown { 1218b0dc866SKristen Carlson Accardi mutex_lock(&ds->hp_lock); 122c8f7a62cSLen Brown list_add_tail(&dd->hotplug_list, &ds->hotplug_devices); 1238b0dc866SKristen Carlson Accardi mutex_unlock(&ds->hp_lock); 124c8f7a62cSLen Brown } 125c8f7a62cSLen Brown 126c8f7a62cSLen Brown /** 127c8f7a62cSLen Brown * dock_del_hotplug_device - remove a hotplug handler from the dock station 128c8f7a62cSLen Brown * @ds: The dock station 129c8f7a62cSLen Brown * @dd: the dependent device struct 130c8f7a62cSLen Brown * 131c8f7a62cSLen Brown * Delete the dependent device from the dock's hotplug device list 132c8f7a62cSLen Brown */ 133c8f7a62cSLen Brown static void 134c8f7a62cSLen Brown dock_del_hotplug_device(struct dock_station *ds, 135c8f7a62cSLen Brown struct dock_dependent_device *dd) 136c8f7a62cSLen Brown { 1378b0dc866SKristen Carlson Accardi mutex_lock(&ds->hp_lock); 138c8f7a62cSLen Brown list_del(&dd->hotplug_list); 1398b0dc866SKristen Carlson Accardi mutex_unlock(&ds->hp_lock); 140c8f7a62cSLen Brown } 141c8f7a62cSLen Brown 142c8f7a62cSLen Brown /** 143c8f7a62cSLen Brown * find_dock_dependent_device - get a device dependent on this dock 144c8f7a62cSLen Brown * @ds: the dock station 145c8f7a62cSLen Brown * @handle: the acpi_handle of the device we want 146c8f7a62cSLen Brown * 147c8f7a62cSLen Brown * iterate over the dependent device list for this dock. If the 148c8f7a62cSLen Brown * dependent device matches the handle, return. 149c8f7a62cSLen Brown */ 150c8f7a62cSLen Brown static struct dock_dependent_device * 151c8f7a62cSLen Brown find_dock_dependent_device(struct dock_station *ds, acpi_handle handle) 152c8f7a62cSLen Brown { 153c8f7a62cSLen Brown struct dock_dependent_device *dd; 154c8f7a62cSLen Brown 155c8f7a62cSLen Brown spin_lock(&ds->dd_lock); 156c8f7a62cSLen Brown list_for_each_entry(dd, &ds->dependent_devices, list) { 157c8f7a62cSLen Brown if (handle == dd->handle) { 158c8f7a62cSLen Brown spin_unlock(&ds->dd_lock); 159c8f7a62cSLen Brown return dd; 160c8f7a62cSLen Brown } 161c8f7a62cSLen Brown } 162c8f7a62cSLen Brown spin_unlock(&ds->dd_lock); 163c8f7a62cSLen Brown return NULL; 164c8f7a62cSLen Brown } 165c8f7a62cSLen Brown 166c8f7a62cSLen Brown /***************************************************************************** 167c8f7a62cSLen Brown * Dock functions * 168c8f7a62cSLen Brown *****************************************************************************/ 169c8f7a62cSLen Brown /** 170c8f7a62cSLen Brown * is_dock - see if a device is a dock station 171c8f7a62cSLen Brown * @handle: acpi handle of the device 172c8f7a62cSLen Brown * 173c8f7a62cSLen Brown * If an acpi object has a _DCK method, then it is by definition a dock 174c8f7a62cSLen Brown * station, so return true. 175c8f7a62cSLen Brown */ 176c8f7a62cSLen Brown static int is_dock(acpi_handle handle) 177c8f7a62cSLen Brown { 178c8f7a62cSLen Brown acpi_status status; 179c8f7a62cSLen Brown acpi_handle tmp; 180c8f7a62cSLen Brown 181c8f7a62cSLen Brown status = acpi_get_handle(handle, "_DCK", &tmp); 182c8f7a62cSLen Brown if (ACPI_FAILURE(status)) 183c8f7a62cSLen Brown return 0; 184c8f7a62cSLen Brown return 1; 185c8f7a62cSLen Brown } 186c8f7a62cSLen Brown 187c8f7a62cSLen Brown /** 188c8f7a62cSLen Brown * is_dock_device - see if a device is on a dock station 189c8f7a62cSLen Brown * @handle: acpi handle of the device 190c8f7a62cSLen Brown * 191c8f7a62cSLen Brown * If this device is either the dock station itself, 192c8f7a62cSLen Brown * or is a device dependent on the dock station, then it 193c8f7a62cSLen Brown * is a dock device 194c8f7a62cSLen Brown */ 195c8f7a62cSLen Brown int is_dock_device(acpi_handle handle) 196c8f7a62cSLen Brown { 197c8f7a62cSLen Brown if (!dock_station) 198c8f7a62cSLen Brown return 0; 199c8f7a62cSLen Brown 200c8f7a62cSLen Brown if (is_dock(handle) || find_dock_dependent_device(dock_station, handle)) 201c8f7a62cSLen Brown return 1; 202c8f7a62cSLen Brown 203c8f7a62cSLen Brown return 0; 204c8f7a62cSLen Brown } 205c8f7a62cSLen Brown 206c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(is_dock_device); 207c8f7a62cSLen Brown 208c8f7a62cSLen Brown /** 209c8f7a62cSLen Brown * dock_present - see if the dock station is present. 210c8f7a62cSLen Brown * @ds: the dock station 211c8f7a62cSLen Brown * 212c8f7a62cSLen Brown * execute the _STA method. note that present does not 213c8f7a62cSLen Brown * imply that we are docked. 214c8f7a62cSLen Brown */ 215c8f7a62cSLen Brown static int dock_present(struct dock_station *ds) 216c8f7a62cSLen Brown { 217c8f7a62cSLen Brown unsigned long sta; 218c8f7a62cSLen Brown acpi_status status; 219c8f7a62cSLen Brown 220c8f7a62cSLen Brown if (ds) { 221c8f7a62cSLen Brown status = acpi_evaluate_integer(ds->handle, "_STA", NULL, &sta); 222c8f7a62cSLen Brown if (ACPI_SUCCESS(status) && sta) 223c8f7a62cSLen Brown return 1; 224c8f7a62cSLen Brown } 225c8f7a62cSLen Brown return 0; 226c8f7a62cSLen Brown } 227c8f7a62cSLen Brown 228c8f7a62cSLen Brown 229c8f7a62cSLen Brown 230c8f7a62cSLen Brown /** 231c8f7a62cSLen Brown * dock_create_acpi_device - add new devices to acpi 232c8f7a62cSLen Brown * @handle - handle of the device to add 233c8f7a62cSLen Brown * 234c8f7a62cSLen Brown * This function will create a new acpi_device for the given 235c8f7a62cSLen Brown * handle if one does not exist already. This should cause 236c8f7a62cSLen Brown * acpi to scan for drivers for the given devices, and call 237c8f7a62cSLen Brown * matching driver's add routine. 238c8f7a62cSLen Brown * 239c8f7a62cSLen Brown * Returns a pointer to the acpi_device corresponding to the handle. 240c8f7a62cSLen Brown */ 241c8f7a62cSLen Brown static struct acpi_device * dock_create_acpi_device(acpi_handle handle) 242c8f7a62cSLen Brown { 243c8f7a62cSLen Brown struct acpi_device *device = NULL; 244c8f7a62cSLen Brown struct acpi_device *parent_device; 245c8f7a62cSLen Brown acpi_handle parent; 246c8f7a62cSLen Brown int ret; 247c8f7a62cSLen Brown 248c8f7a62cSLen Brown if (acpi_bus_get_device(handle, &device)) { 249c8f7a62cSLen Brown /* 250c8f7a62cSLen Brown * no device created for this object, 251c8f7a62cSLen Brown * so we should create one. 252c8f7a62cSLen Brown */ 253c8f7a62cSLen Brown acpi_get_parent(handle, &parent); 254c8f7a62cSLen Brown if (acpi_bus_get_device(parent, &parent_device)) 255c8f7a62cSLen Brown parent_device = NULL; 256c8f7a62cSLen Brown 257c8f7a62cSLen Brown ret = acpi_bus_add(&device, parent_device, handle, 258c8f7a62cSLen Brown ACPI_BUS_TYPE_DEVICE); 259c8f7a62cSLen Brown if (ret) { 260c8f7a62cSLen Brown pr_debug("error adding bus, %x\n", 261c8f7a62cSLen Brown -ret); 262c8f7a62cSLen Brown return NULL; 263c8f7a62cSLen Brown } 264c8f7a62cSLen Brown } 265c8f7a62cSLen Brown return device; 266c8f7a62cSLen Brown } 267c8f7a62cSLen Brown 268c8f7a62cSLen Brown /** 269c8f7a62cSLen Brown * dock_remove_acpi_device - remove the acpi_device struct from acpi 270c8f7a62cSLen Brown * @handle - the handle of the device to remove 271c8f7a62cSLen Brown * 272c8f7a62cSLen Brown * Tell acpi to remove the acpi_device. This should cause any loaded 273c8f7a62cSLen Brown * driver to have it's remove routine called. 274c8f7a62cSLen Brown */ 275c8f7a62cSLen Brown static void dock_remove_acpi_device(acpi_handle handle) 276c8f7a62cSLen Brown { 277c8f7a62cSLen Brown struct acpi_device *device; 278c8f7a62cSLen Brown int ret; 279c8f7a62cSLen Brown 280c8f7a62cSLen Brown if (!acpi_bus_get_device(handle, &device)) { 281c8f7a62cSLen Brown ret = acpi_bus_trim(device, 1); 282c8f7a62cSLen Brown if (ret) 283c8f7a62cSLen Brown pr_debug("error removing bus, %x\n", -ret); 284c8f7a62cSLen Brown } 285c8f7a62cSLen Brown } 286c8f7a62cSLen Brown 287c8f7a62cSLen Brown 288c8f7a62cSLen Brown /** 289c8f7a62cSLen Brown * hotplug_dock_devices - insert or remove devices on the dock station 290c8f7a62cSLen Brown * @ds: the dock station 291c8f7a62cSLen Brown * @event: either bus check or eject request 292c8f7a62cSLen Brown * 293c8f7a62cSLen Brown * Some devices on the dock station need to have drivers called 294c8f7a62cSLen Brown * to perform hotplug operations after a dock event has occurred. 295c8f7a62cSLen Brown * Traverse the list of dock devices that have registered a 296c8f7a62cSLen Brown * hotplug handler, and call the handler. 297c8f7a62cSLen Brown */ 298c8f7a62cSLen Brown static void hotplug_dock_devices(struct dock_station *ds, u32 event) 299c8f7a62cSLen Brown { 300c8f7a62cSLen Brown struct dock_dependent_device *dd; 301c8f7a62cSLen Brown 3028b0dc866SKristen Carlson Accardi mutex_lock(&ds->hp_lock); 303c8f7a62cSLen Brown 304c8f7a62cSLen Brown /* 305c8f7a62cSLen Brown * First call driver specific hotplug functions 306c8f7a62cSLen Brown */ 307c8f7a62cSLen Brown list_for_each_entry(dd, &ds->hotplug_devices, hotplug_list) { 308c8f7a62cSLen Brown if (dd->handler) 309c8f7a62cSLen Brown dd->handler(dd->handle, event, dd->context); 310c8f7a62cSLen Brown } 311c8f7a62cSLen Brown 312c8f7a62cSLen Brown /* 313c8f7a62cSLen Brown * Now make sure that an acpi_device is created for each 314c8f7a62cSLen Brown * dependent device, or removed if this is an eject request. 315c8f7a62cSLen Brown * This will cause acpi_drivers to be stopped/started if they 316c8f7a62cSLen Brown * exist 317c8f7a62cSLen Brown */ 318c8f7a62cSLen Brown list_for_each_entry(dd, &ds->dependent_devices, list) { 319c8f7a62cSLen Brown if (event == ACPI_NOTIFY_EJECT_REQUEST) 320c8f7a62cSLen Brown dock_remove_acpi_device(dd->handle); 321c8f7a62cSLen Brown else 322c8f7a62cSLen Brown dock_create_acpi_device(dd->handle); 323c8f7a62cSLen Brown } 3248b0dc866SKristen Carlson Accardi mutex_unlock(&ds->hp_lock); 325c8f7a62cSLen Brown } 326c8f7a62cSLen Brown 327c8f7a62cSLen Brown static void dock_event(struct dock_station *ds, u32 event, int num) 328c8f7a62cSLen Brown { 3298ea86e0bSKristen Carlson Accardi struct device *dev = &dock_device.dev; 3305669021eSKristen Carlson Accardi /* 3318ea86e0bSKristen Carlson Accardi * Indicate that the status of the dock station has 3328ea86e0bSKristen Carlson Accardi * changed. 3335669021eSKristen Carlson Accardi */ 3348ea86e0bSKristen Carlson Accardi kobject_uevent(&dev->kobj, KOBJ_CHANGE); 335c8f7a62cSLen Brown } 336c8f7a62cSLen Brown 337c8f7a62cSLen Brown /** 338c8f7a62cSLen Brown * eject_dock - respond to a dock eject request 339c8f7a62cSLen Brown * @ds: the dock station 340c8f7a62cSLen Brown * 341c8f7a62cSLen Brown * This is called after _DCK is called, to execute the dock station's 342c8f7a62cSLen Brown * _EJ0 method. 343c8f7a62cSLen Brown */ 344c8f7a62cSLen Brown static void eject_dock(struct dock_station *ds) 345c8f7a62cSLen Brown { 346c8f7a62cSLen Brown struct acpi_object_list arg_list; 347c8f7a62cSLen Brown union acpi_object arg; 348c8f7a62cSLen Brown acpi_status status; 349c8f7a62cSLen Brown acpi_handle tmp; 350c8f7a62cSLen Brown 351c8f7a62cSLen Brown /* all dock devices should have _EJ0, but check anyway */ 352c8f7a62cSLen Brown status = acpi_get_handle(ds->handle, "_EJ0", &tmp); 353c8f7a62cSLen Brown if (ACPI_FAILURE(status)) { 354c8f7a62cSLen Brown pr_debug("No _EJ0 support for dock device\n"); 355c8f7a62cSLen Brown return; 356c8f7a62cSLen Brown } 357c8f7a62cSLen Brown 358c8f7a62cSLen Brown arg_list.count = 1; 359c8f7a62cSLen Brown arg_list.pointer = &arg; 360c8f7a62cSLen Brown arg.type = ACPI_TYPE_INTEGER; 361c8f7a62cSLen Brown arg.integer.value = 1; 362c8f7a62cSLen Brown 363c8f7a62cSLen Brown if (ACPI_FAILURE(acpi_evaluate_object(ds->handle, "_EJ0", 364c8f7a62cSLen Brown &arg_list, NULL))) 365c8f7a62cSLen Brown pr_debug("Failed to evaluate _EJ0!\n"); 366c8f7a62cSLen Brown } 367c8f7a62cSLen Brown 368c8f7a62cSLen Brown /** 369c8f7a62cSLen Brown * handle_dock - handle a dock event 370c8f7a62cSLen Brown * @ds: the dock station 371c8f7a62cSLen Brown * @dock: to dock, or undock - that is the question 372c8f7a62cSLen Brown * 373c8f7a62cSLen Brown * Execute the _DCK method in response to an acpi event 374c8f7a62cSLen Brown */ 375c8f7a62cSLen Brown static void handle_dock(struct dock_station *ds, int dock) 376c8f7a62cSLen Brown { 377c8f7a62cSLen Brown acpi_status status; 378c8f7a62cSLen Brown struct acpi_object_list arg_list; 379c8f7a62cSLen Brown union acpi_object arg; 380c8f7a62cSLen Brown struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 381c8f7a62cSLen Brown struct acpi_buffer name_buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 382c8f7a62cSLen Brown union acpi_object *obj; 383c8f7a62cSLen Brown 384c8f7a62cSLen Brown acpi_get_name(ds->handle, ACPI_FULL_PATHNAME, &name_buffer); 385c8f7a62cSLen Brown obj = name_buffer.pointer; 386c8f7a62cSLen Brown 387c8f7a62cSLen Brown printk(KERN_INFO PREFIX "%s\n", dock ? "docking" : "undocking"); 388c8f7a62cSLen Brown 389c8f7a62cSLen Brown /* _DCK method has one argument */ 390c8f7a62cSLen Brown arg_list.count = 1; 391c8f7a62cSLen Brown arg_list.pointer = &arg; 392c8f7a62cSLen Brown arg.type = ACPI_TYPE_INTEGER; 393c8f7a62cSLen Brown arg.integer.value = dock; 394c8f7a62cSLen Brown status = acpi_evaluate_object(ds->handle, "_DCK", &arg_list, &buffer); 395c8f7a62cSLen Brown if (ACPI_FAILURE(status)) 396c8f7a62cSLen Brown pr_debug("%s: failed to execute _DCK\n", obj->string.pointer); 397c8f7a62cSLen Brown kfree(buffer.pointer); 398c8f7a62cSLen Brown kfree(name_buffer.pointer); 399c8f7a62cSLen Brown } 400c8f7a62cSLen Brown 401c8f7a62cSLen Brown static inline void dock(struct dock_station *ds) 402c8f7a62cSLen Brown { 403c8f7a62cSLen Brown handle_dock(ds, 1); 404c8f7a62cSLen Brown } 405c8f7a62cSLen Brown 406c8f7a62cSLen Brown static inline void undock(struct dock_station *ds) 407c8f7a62cSLen Brown { 408c8f7a62cSLen Brown handle_dock(ds, 0); 409c8f7a62cSLen Brown } 410c8f7a62cSLen Brown 411c8f7a62cSLen Brown static inline void begin_dock(struct dock_station *ds) 412c8f7a62cSLen Brown { 413c8f7a62cSLen Brown ds->flags |= DOCK_DOCKING; 414c8f7a62cSLen Brown } 415c8f7a62cSLen Brown 416c8f7a62cSLen Brown static inline void complete_dock(struct dock_station *ds) 417c8f7a62cSLen Brown { 418c8f7a62cSLen Brown ds->flags &= ~(DOCK_DOCKING); 419c8f7a62cSLen Brown ds->last_dock_time = jiffies; 420c8f7a62cSLen Brown } 421c8f7a62cSLen Brown 422c8f7a62cSLen Brown /** 423c8f7a62cSLen Brown * dock_in_progress - see if we are in the middle of handling a dock event 424c8f7a62cSLen Brown * @ds: the dock station 425c8f7a62cSLen Brown * 426c8f7a62cSLen Brown * Sometimes while docking, false dock events can be sent to the driver 427c8f7a62cSLen Brown * because good connections aren't made or some other reason. Ignore these 428c8f7a62cSLen Brown * if we are in the middle of doing something. 429c8f7a62cSLen Brown */ 430c8f7a62cSLen Brown static int dock_in_progress(struct dock_station *ds) 431c8f7a62cSLen Brown { 432c8f7a62cSLen Brown if ((ds->flags & DOCK_DOCKING) || 433c8f7a62cSLen Brown time_before(jiffies, (ds->last_dock_time + HZ))) 434c8f7a62cSLen Brown return 1; 435c8f7a62cSLen Brown return 0; 436c8f7a62cSLen Brown } 437c8f7a62cSLen Brown 438c8f7a62cSLen Brown /** 439c8f7a62cSLen Brown * register_dock_notifier - add yourself to the dock notifier list 440c8f7a62cSLen Brown * @nb: the callers notifier block 441c8f7a62cSLen Brown * 442c8f7a62cSLen Brown * If a driver wishes to be notified about dock events, they can 443c8f7a62cSLen Brown * use this function to put a notifier block on the dock notifier list. 444c8f7a62cSLen Brown * this notifier call chain will be called after a dock event, but 445c8f7a62cSLen Brown * before hotplugging any new devices. 446c8f7a62cSLen Brown */ 447c8f7a62cSLen Brown int register_dock_notifier(struct notifier_block *nb) 448c8f7a62cSLen Brown { 4492548c06bSPrarit Bhargava if (!dock_station) 4502548c06bSPrarit Bhargava return -ENODEV; 4512548c06bSPrarit Bhargava 452c8f7a62cSLen Brown return atomic_notifier_chain_register(&dock_notifier_list, nb); 453c8f7a62cSLen Brown } 454c8f7a62cSLen Brown 455c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(register_dock_notifier); 456c8f7a62cSLen Brown 457c8f7a62cSLen Brown /** 458c8f7a62cSLen Brown * unregister_dock_notifier - remove yourself from the dock notifier list 459c8f7a62cSLen Brown * @nb: the callers notifier block 460c8f7a62cSLen Brown */ 461c8f7a62cSLen Brown void unregister_dock_notifier(struct notifier_block *nb) 462c8f7a62cSLen Brown { 4632548c06bSPrarit Bhargava if (!dock_station) 4642548c06bSPrarit Bhargava return; 4652548c06bSPrarit Bhargava 466c8f7a62cSLen Brown atomic_notifier_chain_unregister(&dock_notifier_list, nb); 467c8f7a62cSLen Brown } 468c8f7a62cSLen Brown 469c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(unregister_dock_notifier); 470c8f7a62cSLen Brown 471c8f7a62cSLen Brown /** 472c8f7a62cSLen Brown * register_hotplug_dock_device - register a hotplug function 473c8f7a62cSLen Brown * @handle: the handle of the device 474c8f7a62cSLen Brown * @handler: the acpi_notifier_handler to call after docking 475c8f7a62cSLen Brown * @context: device specific data 476c8f7a62cSLen Brown * 477c8f7a62cSLen Brown * If a driver would like to perform a hotplug operation after a dock 478c8f7a62cSLen Brown * event, they can register an acpi_notifiy_handler to be called by 479c8f7a62cSLen Brown * the dock driver after _DCK is executed. 480c8f7a62cSLen Brown */ 481c8f7a62cSLen Brown int 482c8f7a62cSLen Brown register_hotplug_dock_device(acpi_handle handle, acpi_notify_handler handler, 483c8f7a62cSLen Brown void *context) 484c8f7a62cSLen Brown { 485c8f7a62cSLen Brown struct dock_dependent_device *dd; 486c8f7a62cSLen Brown 487c8f7a62cSLen Brown if (!dock_station) 488c8f7a62cSLen Brown return -ENODEV; 489c8f7a62cSLen Brown 490c8f7a62cSLen Brown /* 491c8f7a62cSLen Brown * make sure this handle is for a device dependent on the dock, 492c8f7a62cSLen Brown * this would include the dock station itself 493c8f7a62cSLen Brown */ 494c8f7a62cSLen Brown dd = find_dock_dependent_device(dock_station, handle); 495c8f7a62cSLen Brown if (dd) { 496c8f7a62cSLen Brown dd->handler = handler; 497c8f7a62cSLen Brown dd->context = context; 498c8f7a62cSLen Brown dock_add_hotplug_device(dock_station, dd); 499c8f7a62cSLen Brown return 0; 500c8f7a62cSLen Brown } 501c8f7a62cSLen Brown 502c8f7a62cSLen Brown return -EINVAL; 503c8f7a62cSLen Brown } 504c8f7a62cSLen Brown 505c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(register_hotplug_dock_device); 506c8f7a62cSLen Brown 507c8f7a62cSLen Brown /** 508c8f7a62cSLen Brown * unregister_hotplug_dock_device - remove yourself from the hotplug list 509c8f7a62cSLen Brown * @handle: the acpi handle of the device 510c8f7a62cSLen Brown */ 511c8f7a62cSLen Brown void unregister_hotplug_dock_device(acpi_handle handle) 512c8f7a62cSLen Brown { 513c8f7a62cSLen Brown struct dock_dependent_device *dd; 514c8f7a62cSLen Brown 515c8f7a62cSLen Brown if (!dock_station) 516c8f7a62cSLen Brown return; 517c8f7a62cSLen Brown 518c8f7a62cSLen Brown dd = find_dock_dependent_device(dock_station, handle); 519c8f7a62cSLen Brown if (dd) 520c8f7a62cSLen Brown dock_del_hotplug_device(dock_station, dd); 521c8f7a62cSLen Brown } 522c8f7a62cSLen Brown 523c8f7a62cSLen Brown EXPORT_SYMBOL_GPL(unregister_hotplug_dock_device); 524c8f7a62cSLen Brown 525c8f7a62cSLen Brown /** 526c80fdbe8Sbrandon@ifup.org * handle_eject_request - handle an undock request checking for error conditions 527c80fdbe8Sbrandon@ifup.org * 528c80fdbe8Sbrandon@ifup.org * Check to make sure the dock device is still present, then undock and 529c80fdbe8Sbrandon@ifup.org * hotremove all the devices that may need removing. 530c80fdbe8Sbrandon@ifup.org */ 531c80fdbe8Sbrandon@ifup.org static int handle_eject_request(struct dock_station *ds, u32 event) 532c80fdbe8Sbrandon@ifup.org { 533c80fdbe8Sbrandon@ifup.org if (!dock_present(ds)) 534c80fdbe8Sbrandon@ifup.org return -ENODEV; 535c80fdbe8Sbrandon@ifup.org 536c80fdbe8Sbrandon@ifup.org if (dock_in_progress(ds)) 537c80fdbe8Sbrandon@ifup.org return -EBUSY; 538c80fdbe8Sbrandon@ifup.org 539c80fdbe8Sbrandon@ifup.org /* 540c80fdbe8Sbrandon@ifup.org * here we need to generate the undock 541c80fdbe8Sbrandon@ifup.org * event prior to actually doing the undock 542c80fdbe8Sbrandon@ifup.org * so that the device struct still exists. 543c80fdbe8Sbrandon@ifup.org */ 544c80fdbe8Sbrandon@ifup.org dock_event(ds, event, UNDOCK_EVENT); 545c80fdbe8Sbrandon@ifup.org hotplug_dock_devices(ds, ACPI_NOTIFY_EJECT_REQUEST); 546c80fdbe8Sbrandon@ifup.org undock(ds); 547c80fdbe8Sbrandon@ifup.org eject_dock(ds); 548c80fdbe8Sbrandon@ifup.org if (dock_present(ds)) { 549c80fdbe8Sbrandon@ifup.org printk(KERN_ERR PREFIX "Unable to undock!\n"); 550c80fdbe8Sbrandon@ifup.org return -EBUSY; 551c80fdbe8Sbrandon@ifup.org } 552c80fdbe8Sbrandon@ifup.org 553c80fdbe8Sbrandon@ifup.org return 0; 554c80fdbe8Sbrandon@ifup.org } 555c80fdbe8Sbrandon@ifup.org 556c80fdbe8Sbrandon@ifup.org /** 557c8f7a62cSLen Brown * dock_notify - act upon an acpi dock notification 558c8f7a62cSLen Brown * @handle: the dock station handle 559c8f7a62cSLen Brown * @event: the acpi event 560c8f7a62cSLen Brown * @data: our driver data struct 561c8f7a62cSLen Brown * 562c8f7a62cSLen Brown * If we are notified to dock, then check to see if the dock is 563c8f7a62cSLen Brown * present and then dock. Notify all drivers of the dock event, 564c80fdbe8Sbrandon@ifup.org * and then hotplug and devices that may need hotplugging. 565c8f7a62cSLen Brown */ 566c8f7a62cSLen Brown static void dock_notify(acpi_handle handle, u32 event, void *data) 567c8f7a62cSLen Brown { 56850dd0969SJan Engelhardt struct dock_station *ds = data; 569c8f7a62cSLen Brown 570c8f7a62cSLen Brown switch (event) { 571c8f7a62cSLen Brown case ACPI_NOTIFY_BUS_CHECK: 572c8f7a62cSLen Brown if (!dock_in_progress(ds) && dock_present(ds)) { 573c8f7a62cSLen Brown begin_dock(ds); 574c8f7a62cSLen Brown dock(ds); 575c8f7a62cSLen Brown if (!dock_present(ds)) { 576c8f7a62cSLen Brown printk(KERN_ERR PREFIX "Unable to dock!\n"); 577c8f7a62cSLen Brown break; 578c8f7a62cSLen Brown } 579c8f7a62cSLen Brown atomic_notifier_call_chain(&dock_notifier_list, 580c8f7a62cSLen Brown event, NULL); 581c8f7a62cSLen Brown hotplug_dock_devices(ds, event); 582c8f7a62cSLen Brown complete_dock(ds); 583c8f7a62cSLen Brown dock_event(ds, event, DOCK_EVENT); 584c8f7a62cSLen Brown } 585c8f7a62cSLen Brown break; 586c8f7a62cSLen Brown case ACPI_NOTIFY_DEVICE_CHECK: 587c8f7a62cSLen Brown /* 588c8f7a62cSLen Brown * According to acpi spec 3.0a, if a DEVICE_CHECK notification 589c8f7a62cSLen Brown * is sent and _DCK is present, it is assumed to mean an 590c8f7a62cSLen Brown * undock request. This notify routine will only be called 591c8f7a62cSLen Brown * for objects defining _DCK, so we will fall through to eject 592c8f7a62cSLen Brown * request here. However, we will pass an eject request through 593c8f7a62cSLen Brown * to the driver who wish to hotplug. 594c8f7a62cSLen Brown */ 595c8f7a62cSLen Brown case ACPI_NOTIFY_EJECT_REQUEST: 596c80fdbe8Sbrandon@ifup.org handle_eject_request(ds, event); 597c8f7a62cSLen Brown break; 598c8f7a62cSLen Brown default: 599c8f7a62cSLen Brown printk(KERN_ERR PREFIX "Unknown dock event %d\n", event); 600c8f7a62cSLen Brown } 601c8f7a62cSLen Brown } 602c8f7a62cSLen Brown 603c8f7a62cSLen Brown /** 604c8f7a62cSLen Brown * find_dock_devices - find devices on the dock station 605c8f7a62cSLen Brown * @handle: the handle of the device we are examining 606c8f7a62cSLen Brown * @lvl: unused 607c8f7a62cSLen Brown * @context: the dock station private data 608c8f7a62cSLen Brown * @rv: unused 609c8f7a62cSLen Brown * 610c8f7a62cSLen Brown * This function is called by acpi_walk_namespace. It will 611c8f7a62cSLen Brown * check to see if an object has an _EJD method. If it does, then it 612c8f7a62cSLen Brown * will see if it is dependent on the dock station. 613c8f7a62cSLen Brown */ 614c8f7a62cSLen Brown static acpi_status 615c8f7a62cSLen Brown find_dock_devices(acpi_handle handle, u32 lvl, void *context, void **rv) 616c8f7a62cSLen Brown { 617c8f7a62cSLen Brown acpi_status status; 618fe9a2f77SKristen Carlson Accardi acpi_handle tmp, parent; 61950dd0969SJan Engelhardt struct dock_station *ds = context; 620c8f7a62cSLen Brown struct dock_dependent_device *dd; 621c8f7a62cSLen Brown 622c8f7a62cSLen Brown status = acpi_bus_get_ejd(handle, &tmp); 623fe9a2f77SKristen Carlson Accardi if (ACPI_FAILURE(status)) { 624fe9a2f77SKristen Carlson Accardi /* try the parent device as well */ 625fe9a2f77SKristen Carlson Accardi status = acpi_get_parent(handle, &parent); 626c8f7a62cSLen Brown if (ACPI_FAILURE(status)) 627fe9a2f77SKristen Carlson Accardi goto fdd_out; 628fe9a2f77SKristen Carlson Accardi /* see if parent is dependent on dock */ 629fe9a2f77SKristen Carlson Accardi status = acpi_bus_get_ejd(parent, &tmp); 630fe9a2f77SKristen Carlson Accardi if (ACPI_FAILURE(status)) 631fe9a2f77SKristen Carlson Accardi goto fdd_out; 632fe9a2f77SKristen Carlson Accardi } 633c8f7a62cSLen Brown 634c8f7a62cSLen Brown if (tmp == ds->handle) { 635c8f7a62cSLen Brown dd = alloc_dock_dependent_device(handle); 636c8f7a62cSLen Brown if (dd) 637c8f7a62cSLen Brown add_dock_dependent_device(ds, dd); 638c8f7a62cSLen Brown } 639fe9a2f77SKristen Carlson Accardi fdd_out: 640c8f7a62cSLen Brown return AE_OK; 641c8f7a62cSLen Brown } 642c8f7a62cSLen Brown 643c80fdbe8Sbrandon@ifup.org /* 644c80fdbe8Sbrandon@ifup.org * show_docked - read method for "docked" file in sysfs 645c80fdbe8Sbrandon@ifup.org */ 646c80fdbe8Sbrandon@ifup.org static ssize_t show_docked(struct device *dev, 647c80fdbe8Sbrandon@ifup.org struct device_attribute *attr, char *buf) 648c80fdbe8Sbrandon@ifup.org { 649c80fdbe8Sbrandon@ifup.org return snprintf(buf, PAGE_SIZE, "%d\n", dock_present(dock_station)); 650c80fdbe8Sbrandon@ifup.org 651c80fdbe8Sbrandon@ifup.org } 652c80fdbe8Sbrandon@ifup.org DEVICE_ATTR(docked, S_IRUGO, show_docked, NULL); 653c80fdbe8Sbrandon@ifup.org 654c80fdbe8Sbrandon@ifup.org /* 655c80fdbe8Sbrandon@ifup.org * write_undock - write method for "undock" file in sysfs 656c80fdbe8Sbrandon@ifup.org */ 657c80fdbe8Sbrandon@ifup.org static ssize_t write_undock(struct device *dev, struct device_attribute *attr, 658c80fdbe8Sbrandon@ifup.org const char *buf, size_t count) 659c80fdbe8Sbrandon@ifup.org { 660c80fdbe8Sbrandon@ifup.org int ret; 661c80fdbe8Sbrandon@ifup.org 662c80fdbe8Sbrandon@ifup.org if (!count) 663c80fdbe8Sbrandon@ifup.org return -EINVAL; 664c80fdbe8Sbrandon@ifup.org 665c80fdbe8Sbrandon@ifup.org ret = handle_eject_request(dock_station, ACPI_NOTIFY_EJECT_REQUEST); 666c80fdbe8Sbrandon@ifup.org return ret ? ret: count; 667c80fdbe8Sbrandon@ifup.org } 668c80fdbe8Sbrandon@ifup.org DEVICE_ATTR(undock, S_IWUSR, NULL, write_undock); 669c80fdbe8Sbrandon@ifup.org 670ac122bb6SIlya A. Volynets-Evenbakh /* 671ac122bb6SIlya A. Volynets-Evenbakh * show_dock_uid - read method for "uid" file in sysfs 672ac122bb6SIlya A. Volynets-Evenbakh */ 673ac122bb6SIlya A. Volynets-Evenbakh static ssize_t show_dock_uid(struct device *dev, 674ac122bb6SIlya A. Volynets-Evenbakh struct device_attribute *attr, char *buf) 675ac122bb6SIlya A. Volynets-Evenbakh { 676ac122bb6SIlya A. Volynets-Evenbakh unsigned long lbuf; 677ac122bb6SIlya A. Volynets-Evenbakh acpi_status status = acpi_evaluate_integer(dock_station->handle, "_UID", 0, &lbuf); 678ac122bb6SIlya A. Volynets-Evenbakh if(ACPI_FAILURE(status)) { 679ac122bb6SIlya A. Volynets-Evenbakh return 0; 680ac122bb6SIlya A. Volynets-Evenbakh } 681ac122bb6SIlya A. Volynets-Evenbakh return snprintf(buf, PAGE_SIZE, "%lx\n", lbuf); 682ac122bb6SIlya A. Volynets-Evenbakh } 683ac122bb6SIlya A. Volynets-Evenbakh DEVICE_ATTR(uid, S_IRUGO, show_dock_uid, NULL); 684ac122bb6SIlya A. Volynets-Evenbakh 685ac122bb6SIlya A. Volynets-Evenbakh 686ac122bb6SIlya A. Volynets-Evenbakh 687c8f7a62cSLen Brown /** 688c8f7a62cSLen Brown * dock_add - add a new dock station 689c8f7a62cSLen Brown * @handle: the dock station handle 690c8f7a62cSLen Brown * 691c8f7a62cSLen Brown * allocated and initialize a new dock station device. Find all devices 692c8f7a62cSLen Brown * that are on the dock station, and register for dock event notifications. 693c8f7a62cSLen Brown */ 694c8f7a62cSLen Brown static int dock_add(acpi_handle handle) 695c8f7a62cSLen Brown { 696c8f7a62cSLen Brown int ret; 697c8f7a62cSLen Brown acpi_status status; 698c8f7a62cSLen Brown struct dock_dependent_device *dd; 699c8f7a62cSLen Brown 700c8f7a62cSLen Brown /* allocate & initialize the dock_station private data */ 701c8f7a62cSLen Brown dock_station = kzalloc(sizeof(*dock_station), GFP_KERNEL); 702c8f7a62cSLen Brown if (!dock_station) 703c8f7a62cSLen Brown return -ENOMEM; 704c8f7a62cSLen Brown dock_station->handle = handle; 705c8f7a62cSLen Brown dock_station->last_dock_time = jiffies - HZ; 706c8f7a62cSLen Brown INIT_LIST_HEAD(&dock_station->dependent_devices); 707c8f7a62cSLen Brown INIT_LIST_HEAD(&dock_station->hotplug_devices); 708c8f7a62cSLen Brown spin_lock_init(&dock_station->dd_lock); 7098b0dc866SKristen Carlson Accardi mutex_init(&dock_station->hp_lock); 71007a18684SKristen Accardi ATOMIC_INIT_NOTIFIER_HEAD(&dock_notifier_list); 711c8f7a62cSLen Brown 712671adbecSKristen Carlson Accardi /* initialize platform device stuff */ 713671adbecSKristen Carlson Accardi dock_device.name = dock_device_name; 714671adbecSKristen Carlson Accardi ret = platform_device_register(&dock_device); 715671adbecSKristen Carlson Accardi if (ret) { 716e67beb37SLen Brown printk(KERN_ERR PREFIX "Error %d registering dock device\n", ret); 717671adbecSKristen Carlson Accardi kfree(dock_station); 718671adbecSKristen Carlson Accardi return ret; 719671adbecSKristen Carlson Accardi } 720c80fdbe8Sbrandon@ifup.org ret = device_create_file(&dock_device.dev, &dev_attr_docked); 721c80fdbe8Sbrandon@ifup.org if (ret) { 722c80fdbe8Sbrandon@ifup.org printk("Error %d adding sysfs file\n", ret); 723c80fdbe8Sbrandon@ifup.org platform_device_unregister(&dock_device); 724c80fdbe8Sbrandon@ifup.org kfree(dock_station); 725c80fdbe8Sbrandon@ifup.org return ret; 726c80fdbe8Sbrandon@ifup.org } 727c80fdbe8Sbrandon@ifup.org ret = device_create_file(&dock_device.dev, &dev_attr_undock); 728c80fdbe8Sbrandon@ifup.org if (ret) { 729c80fdbe8Sbrandon@ifup.org printk("Error %d adding sysfs file\n", ret); 730c80fdbe8Sbrandon@ifup.org device_remove_file(&dock_device.dev, &dev_attr_docked); 731c80fdbe8Sbrandon@ifup.org platform_device_unregister(&dock_device); 732c80fdbe8Sbrandon@ifup.org kfree(dock_station); 733c80fdbe8Sbrandon@ifup.org return ret; 734c80fdbe8Sbrandon@ifup.org } 735ac122bb6SIlya A. Volynets-Evenbakh ret = device_create_file(&dock_device.dev, &dev_attr_uid); 736ac122bb6SIlya A. Volynets-Evenbakh if (ret) { 737ac122bb6SIlya A. Volynets-Evenbakh printk("Error %d adding sysfs file\n", ret); 738ac122bb6SIlya A. Volynets-Evenbakh platform_device_unregister(&dock_device); 739ac122bb6SIlya A. Volynets-Evenbakh kfree(dock_station); 740ac122bb6SIlya A. Volynets-Evenbakh return ret; 741ac122bb6SIlya A. Volynets-Evenbakh } 742671adbecSKristen Carlson Accardi 743c8f7a62cSLen Brown /* Find dependent devices */ 744c8f7a62cSLen Brown acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 745c8f7a62cSLen Brown ACPI_UINT32_MAX, find_dock_devices, dock_station, 746c8f7a62cSLen Brown NULL); 747c8f7a62cSLen Brown 748c8f7a62cSLen Brown /* add the dock station as a device dependent on itself */ 749c8f7a62cSLen Brown dd = alloc_dock_dependent_device(handle); 750c8f7a62cSLen Brown if (!dd) { 751c8f7a62cSLen Brown kfree(dock_station); 752671adbecSKristen Carlson Accardi ret = -ENOMEM; 753671adbecSKristen Carlson Accardi goto dock_add_err_unregister; 754c8f7a62cSLen Brown } 755c8f7a62cSLen Brown add_dock_dependent_device(dock_station, dd); 756c8f7a62cSLen Brown 757c8f7a62cSLen Brown /* register for dock events */ 758c8f7a62cSLen Brown status = acpi_install_notify_handler(dock_station->handle, 759c8f7a62cSLen Brown ACPI_SYSTEM_NOTIFY, 760c8f7a62cSLen Brown dock_notify, dock_station); 761c8f7a62cSLen Brown 762c8f7a62cSLen Brown if (ACPI_FAILURE(status)) { 763c8f7a62cSLen Brown printk(KERN_ERR PREFIX "Error installing notify handler\n"); 764c8f7a62cSLen Brown ret = -ENODEV; 765c8f7a62cSLen Brown goto dock_add_err; 766c8f7a62cSLen Brown } 767c8f7a62cSLen Brown 7687cda93e0SLen Brown printk(KERN_INFO PREFIX "%s \n", ACPI_DOCK_DRIVER_DESCRIPTION); 769c8f7a62cSLen Brown 770c8f7a62cSLen Brown return 0; 771c8f7a62cSLen Brown 772c8f7a62cSLen Brown dock_add_err: 773c8f7a62cSLen Brown kfree(dd); 774671adbecSKristen Carlson Accardi dock_add_err_unregister: 775c80fdbe8Sbrandon@ifup.org device_remove_file(&dock_device.dev, &dev_attr_docked); 776c80fdbe8Sbrandon@ifup.org device_remove_file(&dock_device.dev, &dev_attr_undock); 777671adbecSKristen Carlson Accardi platform_device_unregister(&dock_device); 778671adbecSKristen Carlson Accardi kfree(dock_station); 779c8f7a62cSLen Brown return ret; 780c8f7a62cSLen Brown } 781c8f7a62cSLen Brown 782c8f7a62cSLen Brown /** 783c8f7a62cSLen Brown * dock_remove - free up resources related to the dock station 784c8f7a62cSLen Brown */ 785c8f7a62cSLen Brown static int dock_remove(void) 786c8f7a62cSLen Brown { 787c8f7a62cSLen Brown struct dock_dependent_device *dd, *tmp; 788c8f7a62cSLen Brown acpi_status status; 789c8f7a62cSLen Brown 790c8f7a62cSLen Brown if (!dock_station) 791c8f7a62cSLen Brown return 0; 792c8f7a62cSLen Brown 793c8f7a62cSLen Brown /* remove dependent devices */ 794c8f7a62cSLen Brown list_for_each_entry_safe(dd, tmp, &dock_station->dependent_devices, 795c8f7a62cSLen Brown list) 796c8f7a62cSLen Brown kfree(dd); 797c8f7a62cSLen Brown 798c8f7a62cSLen Brown /* remove dock notify handler */ 799c8f7a62cSLen Brown status = acpi_remove_notify_handler(dock_station->handle, 800c8f7a62cSLen Brown ACPI_SYSTEM_NOTIFY, 801c8f7a62cSLen Brown dock_notify); 802c8f7a62cSLen Brown if (ACPI_FAILURE(status)) 803c8f7a62cSLen Brown printk(KERN_ERR "Error removing notify handler\n"); 804c8f7a62cSLen Brown 805671adbecSKristen Carlson Accardi /* cleanup sysfs */ 806c80fdbe8Sbrandon@ifup.org device_remove_file(&dock_device.dev, &dev_attr_docked); 807c80fdbe8Sbrandon@ifup.org device_remove_file(&dock_device.dev, &dev_attr_undock); 808671adbecSKristen Carlson Accardi platform_device_unregister(&dock_device); 809671adbecSKristen Carlson Accardi 810c8f7a62cSLen Brown /* free dock station memory */ 811c8f7a62cSLen Brown kfree(dock_station); 812c8f7a62cSLen Brown return 0; 813c8f7a62cSLen Brown } 814c8f7a62cSLen Brown 815c8f7a62cSLen Brown /** 816c8f7a62cSLen Brown * find_dock - look for a dock station 817c8f7a62cSLen Brown * @handle: acpi handle of a device 818c8f7a62cSLen Brown * @lvl: unused 819c8f7a62cSLen Brown * @context: counter of dock stations found 820c8f7a62cSLen Brown * @rv: unused 821c8f7a62cSLen Brown * 822c8f7a62cSLen Brown * This is called by acpi_walk_namespace to look for dock stations. 823c8f7a62cSLen Brown */ 824c8f7a62cSLen Brown static acpi_status 825c8f7a62cSLen Brown find_dock(acpi_handle handle, u32 lvl, void *context, void **rv) 826c8f7a62cSLen Brown { 82750dd0969SJan Engelhardt int *count = context; 828c8f7a62cSLen Brown acpi_status status = AE_OK; 829c8f7a62cSLen Brown 830c8f7a62cSLen Brown if (is_dock(handle)) { 831c8f7a62cSLen Brown if (dock_add(handle) >= 0) { 832c8f7a62cSLen Brown (*count)++; 833c8f7a62cSLen Brown status = AE_CTRL_TERMINATE; 834c8f7a62cSLen Brown } 835c8f7a62cSLen Brown } 836c8f7a62cSLen Brown return status; 837c8f7a62cSLen Brown } 838c8f7a62cSLen Brown 839c8f7a62cSLen Brown static int __init dock_init(void) 840c8f7a62cSLen Brown { 841c8f7a62cSLen Brown int num = 0; 842c8f7a62cSLen Brown 843c8f7a62cSLen Brown dock_station = NULL; 844c8f7a62cSLen Brown 845c8f7a62cSLen Brown /* look for a dock station */ 846c8f7a62cSLen Brown acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 847c8f7a62cSLen Brown ACPI_UINT32_MAX, find_dock, &num, NULL); 848c8f7a62cSLen Brown 849c8f7a62cSLen Brown if (!num) 8502548c06bSPrarit Bhargava printk(KERN_INFO "No dock devices found.\n"); 851c8f7a62cSLen Brown 852c8f7a62cSLen Brown return 0; 853c8f7a62cSLen Brown } 854c8f7a62cSLen Brown 855c8f7a62cSLen Brown static void __exit dock_exit(void) 856c8f7a62cSLen Brown { 857c8f7a62cSLen Brown dock_remove(); 858c8f7a62cSLen Brown } 859c8f7a62cSLen Brown 860c8f7a62cSLen Brown postcore_initcall(dock_init); 861c8f7a62cSLen Brown module_exit(dock_exit); 862