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