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