SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/acpi/dock.c

   1 /*
   2  *  dock.c - ACPI dock station driver
   3  *
   4  *  Copyright (C) 2006 Kristen Carlson Accardi <kristen.c.accardi@intel.com>
   5  *
   6  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or (at
  11  *  your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful, but
  14  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *  General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License along
  19  *  with this program; if not, write to the Free Software Foundation, Inc.,
  20  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  21  *
  22  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  23  */
  24
  25 #include <linux/kernel.h>
  26 #include <linux/module.h>
  27 #include <linux/init.h>
  28 #include <linux/types.h>
  29 #include <linux/notifier.h>
  30 #include <linux/platform_device.h>
  31 #include <linux/jiffies.h>
  32 #include <linux/stddef.h>
  33 #include <acpi/acpi_bus.h>
  34 #include <acpi/acpi_drivers.h>
  35
  36 #define PREFIX "ACPI: "
  37
  38 #define ACPI_DOCK_DRIVER_DESCRIPTION "ACPI Dock Station Driver"
  39
  40 ACPI_MODULE_NAME("dock");
  41 MODULE_AUTHOR("Kristen Carlson Accardi");
  42 MODULE_DESCRIPTION(ACPI_DOCK_DRIVER_DESCRIPTION);
  43 MODULE_LICENSE("GPL");
  44
  45 static int immediate_undock = 1;
  46 module_param(immediate_undock, bool, 0644);
  47 MODULE_PARM_DESC(immediate_undock, "1 (default) will cause the driver to "
  48         "undock immediately when the undock button is pressed, 0 will cause"
  49         " the driver to wait for userspace to write the undock sysfs file "
  50         " before undocking");
  51
  52 static struct atomic_notifier_head dock_notifier_list;
  53 static char dock_device_name[] = "dock";
  54
  55 static const struct acpi_device_id dock_device_ids[] = {
  56         {"LNXDOCK", 0},
  57         {"", 0},
  58 };
  59 MODULE_DEVICE_TABLE(acpi, dock_device_ids);
  60
  61 struct dock_station {
  62         acpi_handle handle;
  63         unsigned long last_dock_time;
  64         u32 flags;
  65         spinlock_t dd_lock;
  66         struct mutex hp_lock;
  67         struct list_head dependent_devices;
  68         struct list_head hotplug_devices;
  69
  70         struct list_head sibiling;
  71         struct platform_device *dock_device;
  72 };
  73 static LIST_HEAD(dock_stations);
  74 static int dock_station_count;
  75
  76 struct dock_dependent_device {
  77         struct list_head list;
  78         struct list_head hotplug_list;
  79         acpi_handle handle;
  80         struct acpi_dock_ops *ops;
  81         void *context;
  82 };
  83
  84 #define DOCK_DOCKING    0x00000001
  85 #define DOCK_UNDOCKING  0x00000002
  86 #define DOCK_IS_DOCK    0x00000010
  87 #define DOCK_IS_ATA     0x00000020
  88 #define DOCK_IS_BAT     0x00000040
  89 #define DOCK_EVENT      3
  90 #define UNDOCK_EVENT    2
  91
  92 /*****************************************************************************
  93  *                         Dock Dependent device functions                   *
  94  *****************************************************************************/
  95 /**
  96  *  alloc_dock_dependent_device - allocate and init a dependent device
  97  *  @handle: the acpi_handle of the dependent device
  98  *
  99  *  Allocate memory for a dependent device structure for a device referenced
 100  *  by the acpi handle
 101  */
 102 static struct dock_dependent_device *
 103 alloc_dock_dependent_device(acpi_handle handle)
 104 {
 105         struct dock_dependent_device *dd;
 106
 107         dd = kzalloc(sizeof(*dd), GFP_KERNEL);
 108         if (dd) {
 109                 dd->handle = handle;
 110                 INIT_LIST_HEAD(&dd->list);
 111                 INIT_LIST_HEAD(&dd->hotplug_list);
 112         }
 113         return dd;
 114 }
 115
 116 /**
 117  * add_dock_dependent_device - associate a device with the dock station
 118  * @ds: The dock station
 119  * @dd: The dependent device
 120  *
 121  * Add the dependent device to the dock's dependent device list.
 122  */
 123 static void
 124 add_dock_dependent_device(struct dock_station *ds,
 125                           struct dock_dependent_device *dd)
 126 {
 127         spin_lock(&ds->dd_lock);
 128         list_add_tail(&dd->list, &ds->dependent_devices);
 129         spin_unlock(&ds->dd_lock);
 130 }
 131
 132 /**
 133  * dock_add_hotplug_device - associate a hotplug handler with the dock station
 134  * @ds: The dock station
 135  * @dd: The dependent device struct
 136  *
 137  * Add the dependent device to the dock's hotplug device list
 138  */
 139 static void
 140 dock_add_hotplug_device(struct dock_station *ds,
 141                         struct dock_dependent_device *dd)
 142 {
 143         mutex_lock(&ds->hp_lock);
 144         list_add_tail(&dd->hotplug_list, &ds->hotplug_devices);
 145         mutex_unlock(&ds->hp_lock);
 146 }
 147
 148 /**
 149  * dock_del_hotplug_device - remove a hotplug handler from the dock station
 150  * @ds: The dock station
 151  * @dd: the dependent device struct
 152  *
 153  * Delete the dependent device from the dock's hotplug device list
 154  */
 155 static void
 156 dock_del_hotplug_device(struct dock_station *ds,
 157                         struct dock_dependent_device *dd)
 158 {
 159         mutex_lock(&ds->hp_lock);
 160         list_del(&dd->hotplug_list);
 161         mutex_unlock(&ds->hp_lock);
 162 }
 163
 164 /**
 165  * find_dock_dependent_device - get a device dependent on this dock
 166  * @ds: the dock station
 167  * @handle: the acpi_handle of the device we want
 168  *
 169  * iterate over the dependent device list for this dock.  If the
 170  * dependent device matches the handle, return.
 171  */
 172 static struct dock_dependent_device *
 173 find_dock_dependent_device(struct dock_station *ds, acpi_handle handle)
 174 {
 175         struct dock_dependent_device *dd;
 176
 177         spin_lock(&ds->dd_lock);
 178         list_for_each_entry(dd, &ds->dependent_devices, list) {
 179                 if (handle == dd->handle) {
 180                         spin_unlock(&ds->dd_lock);
 181                         return dd;
 182                 }
 183         }
 184         spin_unlock(&ds->dd_lock);
 185         return NULL;
 186 }
 187
 188 /*****************************************************************************
 189  *                         Dock functions                                    *
 190  *****************************************************************************/
 191 /**
 192  * is_dock - see if a device is a dock station
 193  * @handle: acpi handle of the device
 194  *
 195  * If an acpi object has a _DCK method, then it is by definition a dock
 196  * station, so return true.
 197  */
 198 static int is_dock(acpi_handle handle)
 199 {
 200         acpi_status status;
 201         acpi_handle tmp;
 202
 203         status = acpi_get_handle(handle, "_DCK", &tmp);
 204         if (ACPI_FAILURE(status))
 205                 return 0;
 206         return 1;
 207 }
 208
 209 static int is_ejectable(acpi_handle handle)
 210 {
 211         acpi_status status;
 212         acpi_handle tmp;
 213
 214         status = acpi_get_handle(handle, "_EJ0", &tmp);
 215         if (ACPI_FAILURE(status))
 216                 return 0;
 217         return 1;
 218 }
 219
 220 static int is_ata(acpi_handle handle)
 221 {
 222         acpi_handle tmp;
 223
 224         if ((ACPI_SUCCESS(acpi_get_handle(handle, "_GTF", &tmp))) ||
 225            (ACPI_SUCCESS(acpi_get_handle(handle, "_GTM", &tmp))) ||
 226            (ACPI_SUCCESS(acpi_get_handle(handle, "_STM", &tmp))) ||
 227            (ACPI_SUCCESS(acpi_get_handle(handle, "_SDD", &tmp))))
 228                 return 1;
 229
 230         return 0;
 231 }
 232
 233 static int is_battery(acpi_handle handle)
 234 {
 235         struct acpi_device_info *info;
 236         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
 237         int ret = 1;
 238
 239         if (!ACPI_SUCCESS(acpi_get_object_info(handle, &buffer)))
 240                 return 0;
 241         info = buffer.pointer;
 242         if (!(info->valid & ACPI_VALID_HID))
 243                 ret = 0;
 244         else
 245                 ret = !strcmp("PNP0C0A", info->hardware_id.value);
 246
 247         kfree(buffer.pointer);
 248         return ret;
 249 }
 250
 251 static int is_ejectable_bay(acpi_handle handle)
 252 {
 253         acpi_handle phandle;
 254         if (!is_ejectable(handle))
 255                 return 0;
 256         if (is_battery(handle) || is_ata(handle))
 257                 return 1;
 258         if (!acpi_get_parent(handle, &phandle) && is_ata(phandle))
 259                 return 1;
 260         return 0;
 261 }
 262
 263 /**
 264  * is_dock_device - see if a device is on a dock station
 265  * @handle: acpi handle of the device
 266  *
 267  * If this device is either the dock station itself,
 268  * or is a device dependent on the dock station, then it
 269  * is a dock device
 270  */
 271 int is_dock_device(acpi_handle handle)
 272 {
 273         struct dock_station *dock_station;
 274
 275         if (!dock_station_count)
 276                 return 0;
 277
 278         if (is_dock(handle))
 279                 return 1;
 280         list_for_each_entry(dock_station, &dock_stations, sibiling) {
 281                 if (find_dock_dependent_device(dock_station, handle))
 282                         return 1;
 283         }
 284
 285         return 0;
 286 }
 287
 288 EXPORT_SYMBOL_GPL(is_dock_device);
 289
 290 /**
 291  * dock_present - see if the dock station is present.
 292  * @ds: the dock station
 293  *
 294  * execute the _STA method.  note that present does not
 295  * imply that we are docked.
 296  */
 297 static int dock_present(struct dock_station *ds)
 298 {
 299         unsigned long long sta;
 300         acpi_status status;
 301
 302         if (ds) {
 303                 status = acpi_evaluate_integer(ds->handle, "_STA", NULL, &sta);
 304                 if (ACPI_SUCCESS(status) && sta)
 305                         return 1;
 306         }
 307         return 0;
 308 }
 309
 310
 311
 312 /**
 313  * dock_create_acpi_device - add new devices to acpi
 314  * @handle - handle of the device to add
 315  *
 316  *  This function will create a new acpi_device for the given
 317  *  handle if one does not exist already.  This should cause
 318  *  acpi to scan for drivers for the given devices, and call
 319  *  matching driver's add routine.
 320  *
 321  *  Returns a pointer to the acpi_device corresponding to the handle.
 322  */
 323 static struct acpi_device * dock_create_acpi_device(acpi_handle handle)
 324 {
 325         struct acpi_device *device = NULL;
 326         struct acpi_device *parent_device;
 327         acpi_handle parent;
 328         int ret;
 329
 330         if (acpi_bus_get_device(handle, &device)) {
 331                 /*
 332                  * no device created for this object,
 333                  * so we should create one.
 334                  */
 335                 acpi_get_parent(handle, &parent);
 336                 if (acpi_bus_get_device(parent, &parent_device))
 337                         parent_device = NULL;
 338
 339                 ret = acpi_bus_add(&device, parent_device, handle,
 340                         ACPI_BUS_TYPE_DEVICE);
 341                 if (ret) {
 342                         pr_debug("error adding bus, %x\n",
 343                                 -ret);
 344                         return NULL;
 345                 }
 346         }
 347         return device;
 348 }
 349
 350 /**
 351  * dock_remove_acpi_device - remove the acpi_device struct from acpi
 352  * @handle - the handle of the device to remove
 353  *
 354  *  Tell acpi to remove the acpi_device.  This should cause any loaded
 355  *  driver to have it's remove routine called.
 356  */
 357 static void dock_remove_acpi_device(acpi_handle handle)
 358 {
 359         struct acpi_device *device;
 360         int ret;
 361
 362         if (!acpi_bus_get_device(handle, &device)) {
 363                 ret = acpi_bus_trim(device, 1);
 364                 if (ret)
 365                         pr_debug("error removing bus, %x\n", -ret);
 366         }
 367 }
 368
 369
 370 /**
 371  * hotplug_dock_devices - insert or remove devices on the dock station
 372  * @ds: the dock station
 373  * @event: either bus check or eject request
 374  *
 375  * Some devices on the dock station need to have drivers called
 376  * to perform hotplug operations after a dock event has occurred.
 377  * Traverse the list of dock devices that have registered a
 378  * hotplug handler, and call the handler.
 379  */
 380 static void hotplug_dock_devices(struct dock_station *ds, u32 event)
 381 {
 382         struct dock_dependent_device *dd;
 383
 384         mutex_lock(&ds->hp_lock);
 385
 386         /*
 387          * First call driver specific hotplug functions
 388          */
 389         list_for_each_entry(dd, &ds->hotplug_devices, hotplug_list) {
 390                 if (dd->ops && dd->ops->handler)
 391                         dd->ops->handler(dd->handle, event, dd->context);
 392         }
 393
 394         /*
 395          * Now make sure that an acpi_device is created for each
 396          * dependent device, or removed if this is an eject request.
 397          * This will cause acpi_drivers to be stopped/started if they
 398          * exist
 399          */
 400         list_for_each_entry(dd, &ds->dependent_devices, list) {
 401                 if (event == ACPI_NOTIFY_EJECT_REQUEST)
 402                         dock_remove_acpi_device(dd->handle);
 403                 else
 404                         dock_create_acpi_device(dd->handle);
 405         }
 406         mutex_unlock(&ds->hp_lock);
 407 }
 408
 409 static void dock_event(struct dock_station *ds, u32 event, int num)
 410 {
 411         struct device *dev = &ds->dock_device->dev;
 412         char event_string[13];
 413         char *envp[] = { event_string, NULL };
 414         struct dock_dependent_device *dd;
 415
 416         if (num == UNDOCK_EVENT)
 417                 sprintf(event_string, "EVENT=undock");
 418         else
 419                 sprintf(event_string, "EVENT=dock");
 420
 421         /*
 422          * Indicate that the status of the dock station has
 423          * changed.
 424          */
 425         if (num == DOCK_EVENT)
 426                 kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);
 427
 428         list_for_each_entry(dd, &ds->hotplug_devices, hotplug_list)
 429                 if (dd->ops && dd->ops->uevent)
 430                         dd->ops->uevent(dd->handle, event, dd->context);
 431         if (num != DOCK_EVENT)
 432                 kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);
 433 }
 434
 435 /**
 436  * eject_dock - respond to a dock eject request
 437  * @ds: the dock station
 438  *
 439  * This is called after _DCK is called, to execute the dock station's
 440  * _EJ0 method.
 441  */
 442 static void eject_dock(struct dock_station *ds)
 443 {
 444         struct acpi_object_list arg_list;
 445         union acpi_object arg;
 446         acpi_status status;
 447         acpi_handle tmp;
 448
 449         /* all dock devices should have _EJ0, but check anyway */
 450         status = acpi_get_handle(ds->handle, "_EJ0", &tmp);
 451         if (ACPI_FAILURE(status)) {
 452                 pr_debug("No _EJ0 support for dock device\n");
 453                 return;
 454         }
 455
 456         arg_list.count = 1;
 457         arg_list.pointer = &arg;
 458         arg.type = ACPI_TYPE_INTEGER;
 459         arg.integer.value = 1;
 460
 461         if (ACPI_FAILURE(acpi_evaluate_object(ds->handle, "_EJ0",
 462                                               &arg_list, NULL)))
 463                 pr_debug("Failed to evaluate _EJ0!\n");
 464 }
 465
 466 /**
 467  * handle_dock - handle a dock event
 468  * @ds: the dock station
 469  * @dock: to dock, or undock - that is the question
 470  *
 471  * Execute the _DCK method in response to an acpi event
 472  */
 473 static void handle_dock(struct dock_station *ds, int dock)
 474 {
 475         acpi_status status;
 476         struct acpi_object_list arg_list;
 477         union acpi_object arg;
 478         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 479         struct acpi_buffer name_buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 480
 481         acpi_get_name(ds->handle, ACPI_FULL_PATHNAME, &name_buffer);
 482
 483         printk(KERN_INFO PREFIX "%s - %s\n",
 484                 (char *)name_buffer.pointer, dock ? "docking" : "undocking");
 485
 486         /* _DCK method has one argument */
 487         arg_list.count = 1;
 488         arg_list.pointer = &arg;
 489         arg.type = ACPI_TYPE_INTEGER;
 490         arg.integer.value = dock;
 491         status = acpi_evaluate_object(ds->handle, "_DCK", &arg_list, &buffer);
 492         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND)
 493                 ACPI_EXCEPTION((AE_INFO, status, "%s - failed to execute"
 494                         " _DCK\n", (char *)name_buffer.pointer));
 495
 496         kfree(buffer.pointer);
 497         kfree(name_buffer.pointer);
 498 }
 499
 500 static inline void dock(struct dock_station *ds)
 501 {
 502         handle_dock(ds, 1);
 503 }
 504
 505 static inline void undock(struct dock_station *ds)
 506 {
 507         handle_dock(ds, 0);
 508 }
 509
 510 static inline void begin_dock(struct dock_station *ds)
 511 {
 512         ds->flags |= DOCK_DOCKING;
 513 }
 514
 515 static inline void complete_dock(struct dock_station *ds)
 516 {
 517         ds->flags &= ~(DOCK_DOCKING);
 518         ds->last_dock_time = jiffies;
 519 }
 520
 521 static inline void begin_undock(struct dock_station *ds)
 522 {
 523         ds->flags |= DOCK_UNDOCKING;
 524 }
 525
 526 static inline void complete_undock(struct dock_station *ds)
 527 {
 528         ds->flags &= ~(DOCK_UNDOCKING);
 529 }
 530
 531 static void dock_lock(struct dock_station *ds, int lock)
 532 {
 533         struct acpi_object_list arg_list;
 534         union acpi_object arg;
 535         acpi_status status;
 536
 537         arg_list.count = 1;
 538         arg_list.pointer = &arg;
 539         arg.type = ACPI_TYPE_INTEGER;
 540         arg.integer.value = !!lock;
 541         status = acpi_evaluate_object(ds->handle, "_LCK", &arg_list, NULL);
 542         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 543                 if (lock)
 544                         printk(KERN_WARNING PREFIX "Locking device failed\n");
 545                 else
 546                         printk(KERN_WARNING PREFIX "Unlocking device failed\n");
 547         }
 548 }
 549
 550 /**
 551  * dock_in_progress - see if we are in the middle of handling a dock event
 552  * @ds: the dock station
 553  *
 554  * Sometimes while docking, false dock events can be sent to the driver
 555  * because good connections aren't made or some other reason.  Ignore these
 556  * if we are in the middle of doing something.
 557  */
 558 static int dock_in_progress(struct dock_station *ds)
 559 {
 560         if ((ds->flags & DOCK_DOCKING) ||
 561             time_before(jiffies, (ds->last_dock_time + HZ)))
 562                 return 1;
 563         return 0;
 564 }
 565
 566 /**
 567  * register_dock_notifier - add yourself to the dock notifier list
 568  * @nb: the callers notifier block
 569  *
 570  * If a driver wishes to be notified about dock events, they can
 571  * use this function to put a notifier block on the dock notifier list.
 572  * this notifier call chain will be called after a dock event, but
 573  * before hotplugging any new devices.
 574  */
 575 int register_dock_notifier(struct notifier_block *nb)
 576 {
 577         if (!dock_station_count)
 578                 return -ENODEV;
 579
 580         return atomic_notifier_chain_register(&dock_notifier_list, nb);
 581 }
 582
 583 EXPORT_SYMBOL_GPL(register_dock_notifier);
 584
 585 /**
 586  * unregister_dock_notifier - remove yourself from the dock notifier list
 587  * @nb: the callers notifier block
 588  */
 589 void unregister_dock_notifier(struct notifier_block *nb)
 590 {
 591         if (!dock_station_count)
 592                 return;
 593
 594         atomic_notifier_chain_unregister(&dock_notifier_list, nb);
 595 }
 596
 597 EXPORT_SYMBOL_GPL(unregister_dock_notifier);
 598
 599 /**
 600  * register_hotplug_dock_device - register a hotplug function
 601  * @handle: the handle of the device
 602  * @ops: handlers to call after docking
 603  * @context: device specific data
 604  *
 605  * If a driver would like to perform a hotplug operation after a dock
 606  * event, they can register an acpi_notifiy_handler to be called by
 607  * the dock driver after _DCK is executed.
 608  */
 609 int
 610 register_hotplug_dock_device(acpi_handle handle, struct acpi_dock_ops *ops,
 611                              void *context)
 612 {
 613         struct dock_dependent_device *dd;
 614         struct dock_station *dock_station;
 615         int ret = -EINVAL;
 616
 617         if (!dock_station_count)
 618                 return -ENODEV;
 619
 620         /*
 621          * make sure this handle is for a device dependent on the dock,
 622          * this would include the dock station itself
 623          */
 624         list_for_each_entry(dock_station, &dock_stations, sibiling) {
 625                 /*
 626                  * An ATA bay can be in a dock and itself can be ejected
 627                  * seperately, so there are two 'dock stations' which need the
 628                  * ops
 629                  */
 630                 dd = find_dock_dependent_device(dock_station, handle);
 631                 if (dd) {
 632                         dd->ops = ops;
 633                         dd->context = context;
 634                         dock_add_hotplug_device(dock_station, dd);
 635                         ret = 0;
 636                 }
 637         }
 638
 639         return ret;
 640 }
 641
 642 EXPORT_SYMBOL_GPL(register_hotplug_dock_device);
 643
 644 /**
 645  * unregister_hotplug_dock_device - remove yourself from the hotplug list
 646  * @handle: the acpi handle of the device
 647  */
 648 void unregister_hotplug_dock_device(acpi_handle handle)
 649 {
 650         struct dock_dependent_device *dd;
 651         struct dock_station *dock_station;
 652
 653         if (!dock_station_count)
 654                 return;
 655
 656         list_for_each_entry(dock_station, &dock_stations, sibiling) {
 657                 dd = find_dock_dependent_device(dock_station, handle);
 658                 if (dd)
 659                         dock_del_hotplug_device(dock_station, dd);
 660         }
 661 }
 662
 663 EXPORT_SYMBOL_GPL(unregister_hotplug_dock_device);
 664
 665 /**
 666  * handle_eject_request - handle an undock request checking for error conditions
 667  *
 668  * Check to make sure the dock device is still present, then undock and
 669  * hotremove all the devices that may need removing.
 670  */
 671 static int handle_eject_request(struct dock_station *ds, u32 event)
 672 {
 673         if (dock_in_progress(ds))
 674                 return -EBUSY;
 675
 676         /*
 677          * here we need to generate the undock
 678          * event prior to actually doing the undock
 679          * so that the device struct still exists.
 680          * Also, even send the dock event if the
 681          * device is not present anymore
 682          */
 683         dock_event(ds, event, UNDOCK_EVENT);
 684
 685         hotplug_dock_devices(ds, ACPI_NOTIFY_EJECT_REQUEST);
 686         undock(ds);
 687         dock_lock(ds, 0);
 688         eject_dock(ds);
 689         if (dock_present(ds)) {
 690                 printk(KERN_ERR PREFIX "Unable to undock!\n");
 691                 return -EBUSY;
 692         }
 693         complete_undock(ds);
 694         return 0;
 695 }
 696
 697 /**
 698  * dock_notify - act upon an acpi dock notification
 699  * @handle: the dock station handle
 700  * @event: the acpi event
 701  * @data: our driver data struct
 702  *
 703  * If we are notified to dock, then check to see if the dock is
 704  * present and then dock.  Notify all drivers of the dock event,
 705  * and then hotplug and devices that may need hotplugging.
 706  */
 707 static void dock_notify(acpi_handle handle, u32 event, void *data)
 708 {
 709         struct dock_station *ds = data;
 710         struct acpi_device *tmp;
 711         int surprise_removal = 0;
 712
 713         /*
 714          * According to acpi spec 3.0a, if a DEVICE_CHECK notification
 715          * is sent and _DCK is present, it is assumed to mean an undock
 716          * request.
 717          */
 718         if ((ds->flags & DOCK_IS_DOCK) && event == ACPI_NOTIFY_DEVICE_CHECK)
 719                 event = ACPI_NOTIFY_EJECT_REQUEST;
 720
 721         /*
 722          * dock station: BUS_CHECK - docked or surprise removal
 723          *               DEVICE_CHECK - undocked
 724          * other device: BUS_CHECK/DEVICE_CHECK - added or surprise removal
 725          *
 726          * To simplify event handling, dock dependent device handler always
 727          * get ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and
 728          * ACPI_NOTIFY_EJECT_REQUEST for removal
 729          */
 730         switch (event) {
 731         case ACPI_NOTIFY_BUS_CHECK:
 732         case ACPI_NOTIFY_DEVICE_CHECK:
 733                 if (!dock_in_progress(ds) && acpi_bus_get_device(ds->handle,
 734                    &tmp)) {
 735                         begin_dock(ds);
 736                         dock(ds);
 737                         if (!dock_present(ds)) {
 738                                 printk(KERN_ERR PREFIX "Unable to dock!\n");
 739                                 complete_dock(ds);
 740                                 break;
 741                         }
 742                         atomic_notifier_call_chain(&dock_notifier_list,
 743                                                    event, NULL);
 744                         hotplug_dock_devices(ds, event);
 745                         complete_dock(ds);
 746                         dock_event(ds, event, DOCK_EVENT);
 747                         dock_lock(ds, 1);
 748                         break;
 749                 }
 750                 if (dock_present(ds) || dock_in_progress(ds))
 751                         break;
 752                 /* This is a surprise removal */
 753                 surprise_removal = 1;
 754                 event = ACPI_NOTIFY_EJECT_REQUEST;
 755                 /* Fall back */
 756         case ACPI_NOTIFY_EJECT_REQUEST:
 757                 begin_undock(ds);
 758                 if ((immediate_undock && !(ds->flags & DOCK_IS_ATA))
 759                    || surprise_removal)
 760                         handle_eject_request(ds, event);
 761                 else
 762                         dock_event(ds, event, UNDOCK_EVENT);
 763                 break;
 764         default:
 765                 printk(KERN_ERR PREFIX "Unknown dock event %d\n", event);
 766         }
 767 }
 768
 769 struct dock_data {
 770         acpi_handle handle;
 771         unsigned long event;
 772         struct dock_station *ds;
 773 };
 774
 775 static void acpi_dock_deferred_cb(void *context)
 776 {
 777         struct dock_data *data = (struct dock_data *)context;
 778
 779         dock_notify(data->handle, data->event, data->ds);
 780         kfree(data);
 781 }
 782
 783 static int acpi_dock_notifier_call(struct notifier_block *this,
 784         unsigned long event, void *data)
 785 {
 786         struct dock_station *dock_station;
 787         acpi_handle handle = (acpi_handle)data;
 788
 789         if (event != ACPI_NOTIFY_BUS_CHECK && event != ACPI_NOTIFY_DEVICE_CHECK
 790            && event != ACPI_NOTIFY_EJECT_REQUEST)
 791                 return 0;
 792         list_for_each_entry(dock_station, &dock_stations, sibiling) {
 793                 if (dock_station->handle == handle) {
 794                         struct dock_data *dock_data;
 795
 796                         dock_data = kmalloc(sizeof(*dock_data), GFP_KERNEL);
 797                         if (!dock_data)
 798                                 return 0;
 799                         dock_data->handle = handle;
 800                         dock_data->event = event;
 801                         dock_data->ds = dock_station;
 802                         acpi_os_hotplug_execute(acpi_dock_deferred_cb,
 803                                 dock_data);
 804                         return 0 ;
 805                 }
 806         }
 807         return 0;
 808 }
 809
 810 static struct notifier_block dock_acpi_notifier = {
 811         .notifier_call = acpi_dock_notifier_call,
 812 };
 813
 814 /**
 815  * find_dock_devices - find devices on the dock station
 816  * @handle: the handle of the device we are examining
 817  * @lvl: unused
 818  * @context: the dock station private data
 819  * @rv: unused
 820  *
 821  * This function is called by acpi_walk_namespace.  It will
 822  * check to see if an object has an _EJD method.  If it does, then it
 823  * will see if it is dependent on the dock station.
 824  */
 825 static acpi_status
 826 find_dock_devices(acpi_handle handle, u32 lvl, void *context, void **rv)
 827 {
 828         acpi_status status;
 829         acpi_handle tmp, parent;
 830         struct dock_station *ds = context;
 831         struct dock_dependent_device *dd;
 832
 833         status = acpi_bus_get_ejd(handle, &tmp);
 834         if (ACPI_FAILURE(status)) {
 835                 /* try the parent device as well */
 836                 status = acpi_get_parent(handle, &parent);
 837                 if (ACPI_FAILURE(status))
 838                         goto fdd_out;
 839                 /* see if parent is dependent on dock */
 840                 status = acpi_bus_get_ejd(parent, &tmp);
 841                 if (ACPI_FAILURE(status))
 842                         goto fdd_out;
 843         }
 844
 845         if (tmp == ds->handle) {
 846                 dd = alloc_dock_dependent_device(handle);
 847                 if (dd)
 848                         add_dock_dependent_device(ds, dd);
 849         }
 850 fdd_out:
 851         return AE_OK;
 852 }
 853
 854 /*
 855  * show_docked - read method for "docked" file in sysfs
 856  */
 857 static ssize_t show_docked(struct device *dev,
 858                            struct device_attribute *attr, char *buf)
 859 {
 860         struct acpi_device *tmp;
 861
 862         struct dock_station *dock_station = *((struct dock_station **)
 863                 dev->platform_data);
 864
 865         if (ACPI_SUCCESS(acpi_bus_get_device(dock_station->handle, &tmp)))
 866                 return snprintf(buf, PAGE_SIZE, "1\n");
 867         return snprintf(buf, PAGE_SIZE, "0\n");
 868 }
 869 static DEVICE_ATTR(docked, S_IRUGO, show_docked, NULL);
 870
 871 /*
 872  * show_flags - read method for flags file in sysfs
 873  */
 874 static ssize_t show_flags(struct device *dev,
 875                           struct device_attribute *attr, char *buf)
 876 {
 877         struct dock_station *dock_station = *((struct dock_station **)
 878                 dev->platform_data);
 879         return snprintf(buf, PAGE_SIZE, "%d\n", dock_station->flags);
 880
 881 }
 882 static DEVICE_ATTR(flags, S_IRUGO, show_flags, NULL);
 883
 884 /*
 885  * write_undock - write method for "undock" file in sysfs
 886  */
 887 static ssize_t write_undock(struct device *dev, struct device_attribute *attr,
 888                            const char *buf, size_t count)
 889 {
 890         int ret;
 891         struct dock_station *dock_station = *((struct dock_station **)
 892                 dev->platform_data);
 893
 894         if (!count)
 895                 return -EINVAL;
 896
 897         begin_undock(dock_station);
 898         ret = handle_eject_request(dock_station, ACPI_NOTIFY_EJECT_REQUEST);
 899         return ret ? ret: count;
 900 }
 901 static DEVICE_ATTR(undock, S_IWUSR, NULL, write_undock);
 902
 903 /*
 904  * show_dock_uid - read method for "uid" file in sysfs
 905  */
 906 static ssize_t show_dock_uid(struct device *dev,
 907                              struct device_attribute *attr, char *buf)
 908 {
 909         unsigned long long lbuf;
 910         struct dock_station *dock_station = *((struct dock_station **)
 911                 dev->platform_data);
 912         acpi_status status = acpi_evaluate_integer(dock_station->handle,
 913                                         "_UID", NULL, &lbuf);
 914         if (ACPI_FAILURE(status))
 915             return 0;
 916
 917         return snprintf(buf, PAGE_SIZE, "%llx\n", lbuf);
 918 }
 919 static DEVICE_ATTR(uid, S_IRUGO, show_dock_uid, NULL);
 920
 921 static ssize_t show_dock_type(struct device *dev,
 922                 struct device_attribute *attr, char *buf)
 923 {
 924         struct dock_station *dock_station = *((struct dock_station **)
 925                 dev->platform_data);
 926         char *type;
 927
 928         if (dock_station->flags & DOCK_IS_DOCK)
 929                 type = "dock_station";
 930         else if (dock_station->flags & DOCK_IS_ATA)
 931                 type = "ata_bay";
 932         else if (dock_station->flags & DOCK_IS_BAT)
 933                 type = "battery_bay";
 934         else
 935                 type = "unknown";
 936
 937         return snprintf(buf, PAGE_SIZE, "%s\n", type);
 938 }
 939 static DEVICE_ATTR(type, S_IRUGO, show_dock_type, NULL);
 940
 941 /**
 942  * dock_add - add a new dock station
 943  * @handle: the dock station handle
 944  *
 945  * allocated and initialize a new dock station device.  Find all devices
 946  * that are on the dock station, and register for dock event notifications.
 947  */
 948 static int dock_add(acpi_handle handle)
 949 {
 950         int ret;
 951         struct dock_dependent_device *dd;
 952         struct dock_station *dock_station;
 953         struct platform_device *dock_device;
 954
 955         /* allocate & initialize the dock_station private data */
 956         dock_station = kzalloc(sizeof(*dock_station), GFP_KERNEL);
 957         if (!dock_station)
 958                 return -ENOMEM;
 959         dock_station->handle = handle;
 960         dock_station->last_dock_time = jiffies - HZ;
 961         INIT_LIST_HEAD(&dock_station->dependent_devices);
 962         INIT_LIST_HEAD(&dock_station->hotplug_devices);
 963         INIT_LIST_HEAD(&dock_station->sibiling);
 964         spin_lock_init(&dock_station->dd_lock);
 965         mutex_init(&dock_station->hp_lock);
 966         ATOMIC_INIT_NOTIFIER_HEAD(&dock_notifier_list);
 967
 968         /* initialize platform device stuff */
 969         dock_station->dock_device =
 970                 platform_device_register_simple(dock_device_name,
 971                         dock_station_count, NULL, 0);
 972         dock_device = dock_station->dock_device;
 973         if (IS_ERR(dock_device)) {
 974                 kfree(dock_station);
 975                 dock_station = NULL;
 976                 return PTR_ERR(dock_device);
 977         }
 978         platform_device_add_data(dock_device, &dock_station,
 979                 sizeof(struct dock_station *));
 980
 981         /* we want the dock device to send uevents */
 982         dev_set_uevent_suppress(&dock_device->dev, 0);
 983
 984         if (is_dock(handle))
 985                 dock_station->flags |= DOCK_IS_DOCK;
 986         if (is_ata(handle))
 987                 dock_station->flags |= DOCK_IS_ATA;
 988         if (is_battery(handle))
 989                 dock_station->flags |= DOCK_IS_BAT;
 990
 991         ret = device_create_file(&dock_device->dev, &dev_attr_docked);
 992         if (ret) {
 993                 printk(KERN_ERR "Error %d adding sysfs file\n", ret);
 994                 platform_device_unregister(dock_device);
 995                 kfree(dock_station);
 996                 dock_station = NULL;
 997                 return ret;
 998         }
 999         ret = device_create_file(&dock_device->dev, &dev_attr_undock);
1000         if (ret) {
1001                 printk(KERN_ERR "Error %d adding sysfs file\n", ret);
1002                 device_remove_file(&dock_device->dev, &dev_attr_docked);
1003                 platform_device_unregister(dock_device);
1004                 kfree(dock_station);
1005                 dock_station = NULL;
1006                 return ret;
1007         }
1008         ret = device_create_file(&dock_device->dev, &dev_attr_uid);
1009         if (ret) {
1010                 printk(KERN_ERR "Error %d adding sysfs file\n", ret);
1011                 device_remove_file(&dock_device->dev, &dev_attr_docked);
1012                 device_remove_file(&dock_device->dev, &dev_attr_undock);
1013                 platform_device_unregister(dock_device);
1014                 kfree(dock_station);
1015                 dock_station = NULL;
1016                 return ret;
1017         }
1018         ret = device_create_file(&dock_device->dev, &dev_attr_flags);
1019         if (ret) {
1020                 printk(KERN_ERR "Error %d adding sysfs file\n", ret);
1021                 device_remove_file(&dock_device->dev, &dev_attr_docked);
1022                 device_remove_file(&dock_device->dev, &dev_attr_undock);
1023                 device_remove_file(&dock_device->dev, &dev_attr_uid);
1024                 platform_device_unregister(dock_device);
1025                 kfree(dock_station);
1026                 dock_station = NULL;
1027                 return ret;
1028         }
1029         ret = device_create_file(&dock_device->dev, &dev_attr_type);
1030         if (ret)
1031                 printk(KERN_ERR"Error %d adding sysfs file\n", ret);
1032
1033         /* Find dependent devices */
1034         acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
1035                             ACPI_UINT32_MAX, find_dock_devices, dock_station,
1036                             NULL);
1037
1038         /* add the dock station as a device dependent on itself */
1039         dd = alloc_dock_dependent_device(handle);
1040         if (!dd) {
1041                 kfree(dock_station);
1042                 dock_station = NULL;
1043                 ret = -ENOMEM;
1044                 goto dock_add_err_unregister;
1045         }
1046         add_dock_dependent_device(dock_station, dd);
1047
1048         dock_station_count++;
1049         list_add(&dock_station->sibiling, &dock_stations);
1050         return 0;
1051
1052 dock_add_err_unregister:
1053         device_remove_file(&dock_device->dev, &dev_attr_type);
1054         device_remove_file(&dock_device->dev, &dev_attr_docked);
1055         device_remove_file(&dock_device->dev, &dev_attr_undock);
1056         device_remove_file(&dock_device->dev, &dev_attr_uid);
1057         device_remove_file(&dock_device->dev, &dev_attr_flags);
1058         platform_device_unregister(dock_device);
1059         kfree(dock_station);
1060         dock_station = NULL;
1061         return ret;
1062 }
1063
1064 /**
1065  * dock_remove - free up resources related to the dock station
1066  */
1067 static int dock_remove(struct dock_station *dock_station)
1068 {
1069         struct dock_dependent_device *dd, *tmp;
1070         struct platform_device *dock_device = dock_station->dock_device;
1071
1072         if (!dock_station_count)
1073                 return 0;
1074
1075         /* remove dependent devices */
1076         list_for_each_entry_safe(dd, tmp, &dock_station->dependent_devices,
1077                                  list)
1078             kfree(dd);
1079
1080         /* cleanup sysfs */
1081         device_remove_file(&dock_device->dev, &dev_attr_type);
1082         device_remove_file(&dock_device->dev, &dev_attr_docked);
1083         device_remove_file(&dock_device->dev, &dev_attr_undock);
1084         device_remove_file(&dock_device->dev, &dev_attr_uid);
1085         device_remove_file(&dock_device->dev, &dev_attr_flags);
1086         platform_device_unregister(dock_device);
1087
1088         /* free dock station memory */
1089         kfree(dock_station);
1090         dock_station = NULL;
1091         return 0;
1092 }
1093
1094 /**
1095  * find_dock - look for a dock station
1096  * @handle: acpi handle of a device
1097  * @lvl: unused
1098  * @context: counter of dock stations found
1099  * @rv: unused
1100  *
1101  * This is called by acpi_walk_namespace to look for dock stations.
1102  */
1103 static acpi_status
1104 find_dock(acpi_handle handle, u32 lvl, void *context, void **rv)
1105 {
1106         acpi_status status = AE_OK;
1107
1108         if (is_dock(handle)) {
1109                 if (dock_add(handle) >= 0) {
1110                         status = AE_CTRL_TERMINATE;
1111                 }
1112         }
1113         return status;
1114 }
1115
1116 static acpi_status
1117 find_bay(acpi_handle handle, u32 lvl, void *context, void **rv)
1118 {
1119         /* If bay is a dock, it's already handled */
1120         if (is_ejectable_bay(handle) && !is_dock(handle))
1121                 dock_add(handle);
1122         return AE_OK;
1123 }
1124
1125 static int __init dock_init(void)
1126 {
1127         if (acpi_disabled)
1128                 return 0;
1129
1130         /* look for a dock station */
1131         acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
1132                             ACPI_UINT32_MAX, find_dock, NULL, NULL);
1133
1134         /* look for bay */
1135         acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
1136                         ACPI_UINT32_MAX, find_bay, NULL, NULL);
1137         if (!dock_station_count) {
1138                 printk(KERN_INFO PREFIX "No dock devices found.\n");
1139                 return 0;
1140         }
1141
1142         register_acpi_bus_notifier(&dock_acpi_notifier);
1143         printk(KERN_INFO PREFIX "%s: %d docks/bays found\n",
1144                 ACPI_DOCK_DRIVER_DESCRIPTION, dock_station_count);
1145         return 0;
1146 }
1147
1148 static void __exit dock_exit(void)
1149 {
1150         struct dock_station *dock_station;
1151         struct dock_station *tmp;
1152
1153         unregister_acpi_bus_notifier(&dock_acpi_notifier);
1154         list_for_each_entry_safe(dock_station, tmp, &dock_stations, sibiling)
1155                 dock_remove(dock_station);
1156 }
1157
1158 /*
1159  * Must be called before drivers of devices in dock, otherwise we can't know
1160  * which devices are in a dock
1161  */
1162 subsys_initcall(dock_init);
1163 module_exit(dock_exit);