dock.c 27.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/*
 *  dock.c - ACPI dock station driver
 *
 *  Copyright (C) 2006 Kristen Carlson Accardi <kristen.c.accardi@intel.com>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or (at
 *  your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#include <linux/kernel.h>
#include <linux/module.h>
27
#include <linux/slab.h>
28 29 30
#include <linux/init.h>
#include <linux/types.h>
#include <linux/notifier.h>
31
#include <linux/platform_device.h>
32
#include <linux/jiffies.h>
33
#include <linux/stddef.h>
34
#include <linux/acpi.h>
35 36 37
#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>

38 39
#define PREFIX "ACPI: "

40
#define ACPI_DOCK_DRIVER_DESCRIPTION "ACPI Dock Station Driver"
41

42
ACPI_MODULE_NAME("dock");
43
MODULE_AUTHOR("Kristen Carlson Accardi");
44
MODULE_DESCRIPTION(ACPI_DOCK_DRIVER_DESCRIPTION);
45 46
MODULE_LICENSE("GPL");

47
static bool immediate_undock = 1;
48 49 50 51 52 53
module_param(immediate_undock, bool, 0644);
MODULE_PARM_DESC(immediate_undock, "1 (default) will cause the driver to "
	"undock immediately when the undock button is pressed, 0 will cause"
	" the driver to wait for userspace to write the undock sysfs file "
	" before undocking");

54 55
static struct atomic_notifier_head dock_notifier_list;

56 57 58 59 60 61
static const struct acpi_device_id dock_device_ids[] = {
	{"LNXDOCK", 0},
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, dock_device_ids);

62 63 64 65 66
struct dock_station {
	acpi_handle handle;
	unsigned long last_dock_time;
	u32 flags;
	spinlock_t dd_lock;
67
	struct mutex hp_lock;
68
	struct list_head dependent_devices;
69

Alex Chiang's avatar
Alex Chiang committed
70
	struct list_head sibling;
71
	struct platform_device *dock_device;
72
};
73 74
static LIST_HEAD(dock_stations);
static int dock_station_count;
75
static DEFINE_MUTEX(hotplug_lock);
76 77 78 79

struct dock_dependent_device {
	struct list_head list;
	acpi_handle handle;
80 81 82 83
	const struct acpi_dock_ops *hp_ops;
	void *hp_context;
	unsigned int hp_refcount;
	void (*hp_release)(void *);
84 85 86
};

#define DOCK_DOCKING	0x00000001
87
#define DOCK_UNDOCKING  0x00000002
88 89 90
#define DOCK_IS_DOCK	0x00000010
#define DOCK_IS_ATA	0x00000020
#define DOCK_IS_BAT	0x00000040
91 92
#define DOCK_EVENT	3
#define UNDOCK_EVENT	2
93 94 95 96 97

/*****************************************************************************
 *                         Dock Dependent device functions                   *
 *****************************************************************************/
/**
98 99 100
 * add_dock_dependent_device - associate a device with the dock station
 * @ds: The dock station
 * @handle: handle of the dependent device
101
 *
102
 * Add the dependent device to the dock's dependent device list.
103
 */
104 105
static int
add_dock_dependent_device(struct dock_station *ds, acpi_handle handle)
106 107 108 109
{
	struct dock_dependent_device *dd;

	dd = kzalloc(sizeof(*dd), GFP_KERNEL);
110 111 112 113 114
	if (!dd)
		return -ENOMEM;

	dd->handle = handle;
	INIT_LIST_HEAD(&dd->list);
115 116 117 118

	spin_lock(&ds->dd_lock);
	list_add_tail(&dd->list, &ds->dependent_devices);
	spin_unlock(&ds->dd_lock);
119 120

	return 0;
121 122 123
}

/**
124 125 126 127 128 129
 * dock_init_hotplug - Initialize a hotplug device on a docking station.
 * @dd: Dock-dependent device.
 * @ops: Dock operations to attach to the dependent device.
 * @context: Data to pass to the @ops callbacks and @release.
 * @init: Optional initialization routine to run after setting up context.
 * @release: Optional release routine to run on removal.
130
 */
131 132 133
static int dock_init_hotplug(struct dock_dependent_device *dd,
			     const struct acpi_dock_ops *ops, void *context,
			     void (*init)(void *), void (*release)(void *))
134
{
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
	int ret = 0;

	mutex_lock(&hotplug_lock);

	if (dd->hp_context) {
		ret = -EEXIST;
	} else {
		dd->hp_refcount = 1;
		dd->hp_ops = ops;
		dd->hp_context = context;
		dd->hp_release = release;
	}

	if (!WARN_ON(ret) && init)
		init(context);

	mutex_unlock(&hotplug_lock);
	return ret;
153 154 155
}

/**
156 157
 * dock_release_hotplug - Decrement hotplug reference counter of dock device.
 * @dd: Dock-dependent device.
158
 *
159 160 161
 * Decrement the reference counter of @dd and if 0, detach its hotplug
 * operations from it, reset its context pointer and run the optional release
 * routine if present.
162
 */
163
static void dock_release_hotplug(struct dock_dependent_device *dd)
164
{
165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
	void (*release)(void *) = NULL;
	void *context = NULL;

	mutex_lock(&hotplug_lock);

	if (dd->hp_context && !--dd->hp_refcount) {
		dd->hp_ops = NULL;
		context = dd->hp_context;
		dd->hp_context = NULL;
		release = dd->hp_release;
		dd->hp_release = NULL;
	}

	if (release && context)
		release(context);

	mutex_unlock(&hotplug_lock);
}

static void dock_hotplug_event(struct dock_dependent_device *dd, u32 event,
			       bool uevent)
{
	acpi_notify_handler cb = NULL;
	bool run = false;

	mutex_lock(&hotplug_lock);

	if (dd->hp_context) {
		run = true;
		dd->hp_refcount++;
		if (dd->hp_ops)
			cb = uevent ? dd->hp_ops->uevent : dd->hp_ops->handler;
	}

	mutex_unlock(&hotplug_lock);

	if (!run)
		return;

	if (cb)
		cb(dd->handle, event, dd->hp_context);

	dock_release_hotplug(dd);
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254
}

/**
 * find_dock_dependent_device - get a device dependent on this dock
 * @ds: the dock station
 * @handle: the acpi_handle of the device we want
 *
 * iterate over the dependent device list for this dock.  If the
 * dependent device matches the handle, return.
 */
static struct dock_dependent_device *
find_dock_dependent_device(struct dock_station *ds, acpi_handle handle)
{
	struct dock_dependent_device *dd;

	spin_lock(&ds->dd_lock);
	list_for_each_entry(dd, &ds->dependent_devices, list) {
		if (handle == dd->handle) {
			spin_unlock(&ds->dd_lock);
			return dd;
		}
	}
	spin_unlock(&ds->dd_lock);
	return NULL;
}

/*****************************************************************************
 *                         Dock functions                                    *
 *****************************************************************************/
/**
 * is_dock - see if a device is a dock station
 * @handle: acpi handle of the device
 *
 * If an acpi object has a _DCK method, then it is by definition a dock
 * station, so return true.
 */
static int is_dock(acpi_handle handle)
{
	acpi_status status;
	acpi_handle tmp;

	status = acpi_get_handle(handle, "_DCK", &tmp);
	if (ACPI_FAILURE(status))
		return 0;
	return 1;
}

255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
static int is_ejectable(acpi_handle handle)
{
	acpi_status status;
	acpi_handle tmp;

	status = acpi_get_handle(handle, "_EJ0", &tmp);
	if (ACPI_FAILURE(status))
		return 0;
	return 1;
}

static int is_ata(acpi_handle handle)
{
	acpi_handle tmp;

	if ((ACPI_SUCCESS(acpi_get_handle(handle, "_GTF", &tmp))) ||
	   (ACPI_SUCCESS(acpi_get_handle(handle, "_GTM", &tmp))) ||
	   (ACPI_SUCCESS(acpi_get_handle(handle, "_STM", &tmp))) ||
	   (ACPI_SUCCESS(acpi_get_handle(handle, "_SDD", &tmp))))
		return 1;

	return 0;
}

static int is_battery(acpi_handle handle)
{
	struct acpi_device_info *info;
	int ret = 1;

284
	if (!ACPI_SUCCESS(acpi_get_object_info(handle, &info)))
285 286 287 288
		return 0;
	if (!(info->valid & ACPI_VALID_HID))
		ret = 0;
	else
289
		ret = !strcmp("PNP0C0A", info->hardware_id.string);
290

291
	kfree(info);
292 293 294 295 296 297
	return ret;
}

static int is_ejectable_bay(acpi_handle handle)
{
	acpi_handle phandle;
298

299 300 301 302 303 304 305 306 307
	if (!is_ejectable(handle))
		return 0;
	if (is_battery(handle) || is_ata(handle))
		return 1;
	if (!acpi_get_parent(handle, &phandle) && is_ata(phandle))
		return 1;
	return 0;
}

308 309 310 311 312 313 314 315 316 317
/**
 * is_dock_device - see if a device is on a dock station
 * @handle: acpi handle of the device
 *
 * If this device is either the dock station itself,
 * or is a device dependent on the dock station, then it
 * is a dock device
 */
int is_dock_device(acpi_handle handle)
{
318 319 320
	struct dock_station *dock_station;

	if (!dock_station_count)
321 322
		return 0;

323
	if (is_dock(handle))
324
		return 1;
325 326

	list_for_each_entry(dock_station, &dock_stations, sibling)
327 328
		if (find_dock_dependent_device(dock_station, handle))
			return 1;
329 330 331 332 333 334 335 336 337 338 339 340 341 342

	return 0;
}
EXPORT_SYMBOL_GPL(is_dock_device);

/**
 * dock_present - see if the dock station is present.
 * @ds: the dock station
 *
 * execute the _STA method.  note that present does not
 * imply that we are docked.
 */
static int dock_present(struct dock_station *ds)
{
343
	unsigned long long sta;
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
	acpi_status status;

	if (ds) {
		status = acpi_evaluate_integer(ds->handle, "_STA", NULL, &sta);
		if (ACPI_SUCCESS(status) && sta)
			return 1;
	}
	return 0;
}

/**
 * dock_create_acpi_device - add new devices to acpi
 * @handle - handle of the device to add
 *
 *  This function will create a new acpi_device for the given
 *  handle if one does not exist already.  This should cause
 *  acpi to scan for drivers for the given devices, and call
 *  matching driver's add routine.
 *
 *  Returns a pointer to the acpi_device corresponding to the handle.
 */
static struct acpi_device * dock_create_acpi_device(acpi_handle handle)
{
367
	struct acpi_device *device;
368 369 370 371 372 373 374
	int ret;

	if (acpi_bus_get_device(handle, &device)) {
		/*
		 * no device created for this object,
		 * so we should create one.
		 */
375
		ret = acpi_bus_scan(handle);
376
		if (ret)
377
			pr_debug("error adding bus, %x\n", -ret);
378 379

		acpi_bus_get_device(handle, &device);
380 381 382 383 384 385 386 387 388 389 390 391 392 393 394
	}
	return device;
}

/**
 * dock_remove_acpi_device - remove the acpi_device struct from acpi
 * @handle - the handle of the device to remove
 *
 *  Tell acpi to remove the acpi_device.  This should cause any loaded
 *  driver to have it's remove routine called.
 */
static void dock_remove_acpi_device(acpi_handle handle)
{
	struct acpi_device *device;

395 396
	if (!acpi_bus_get_device(handle, &device))
		acpi_bus_trim(device);
397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412
}

/**
 * hotplug_dock_devices - insert or remove devices on the dock station
 * @ds: the dock station
 * @event: either bus check or eject request
 *
 * Some devices on the dock station need to have drivers called
 * to perform hotplug operations after a dock event has occurred.
 * Traverse the list of dock devices that have registered a
 * hotplug handler, and call the handler.
 */
static void hotplug_dock_devices(struct dock_station *ds, u32 event)
{
	struct dock_dependent_device *dd;

413
	mutex_lock(&ds->hp_lock);
414 415 416 417

	/*
	 * First call driver specific hotplug functions
	 */
418 419
	list_for_each_entry(dd, &ds->dependent_devices, list)
		dock_hotplug_event(dd, event, false);
420 421 422 423 424 425 426 427 428 429 430 431 432

	/*
	 * Now make sure that an acpi_device is created for each
	 * dependent device, or removed if this is an eject request.
	 * This will cause acpi_drivers to be stopped/started if they
	 * exist
	 */
	list_for_each_entry(dd, &ds->dependent_devices, list) {
		if (event == ACPI_NOTIFY_EJECT_REQUEST)
			dock_remove_acpi_device(dd->handle);
		else
			dock_create_acpi_device(dd->handle);
	}
433
	mutex_unlock(&ds->hp_lock);
434 435 436 437
}

static void dock_event(struct dock_station *ds, u32 event, int num)
{
438
	struct device *dev = &ds->dock_device->dev;
439
	char event_string[13];
440
	char *envp[] = { event_string, NULL };
441
	struct dock_dependent_device *dd;
442 443

	if (num == UNDOCK_EVENT)
444
		sprintf(event_string, "EVENT=undock");
445
	else
446
		sprintf(event_string, "EVENT=dock");
447

448
	/*
449 450
	 * Indicate that the status of the dock station has
	 * changed.
451
	 */
452 453 454
	if (num == DOCK_EVENT)
		kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);

455 456
	list_for_each_entry(dd, &ds->dependent_devices, list)
		dock_hotplug_event(dd, event, true);
457

458 459
	if (num != DOCK_EVENT)
		kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);
460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
}

/**
 * eject_dock - respond to a dock eject request
 * @ds: the dock station
 *
 * This is called after _DCK is called, to execute the dock station's
 * _EJ0 method.
 */
static void eject_dock(struct dock_station *ds)
{
	struct acpi_object_list arg_list;
	union acpi_object arg;
	acpi_status status;
	acpi_handle tmp;

	/* all dock devices should have _EJ0, but check anyway */
	status = acpi_get_handle(ds->handle, "_EJ0", &tmp);
	if (ACPI_FAILURE(status)) {
		pr_debug("No _EJ0 support for dock device\n");
		return;
	}

	arg_list.count = 1;
	arg_list.pointer = &arg;
	arg.type = ACPI_TYPE_INTEGER;
	arg.integer.value = 1;

488 489
	status = acpi_evaluate_object(ds->handle, "_EJ0", &arg_list, NULL);
	if (ACPI_FAILURE(status))
490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506
		pr_debug("Failed to evaluate _EJ0!\n");
}

/**
 * handle_dock - handle a dock event
 * @ds: the dock station
 * @dock: to dock, or undock - that is the question
 *
 * Execute the _DCK method in response to an acpi event
 */
static void handle_dock(struct dock_station *ds, int dock)
{
	acpi_status status;
	struct acpi_object_list arg_list;
	union acpi_object arg;
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };

507
	acpi_handle_info(ds->handle, "%s\n", dock ? "docking" : "undocking");
508 509 510 511 512 513 514

	/* _DCK method has one argument */
	arg_list.count = 1;
	arg_list.pointer = &arg;
	arg.type = ACPI_TYPE_INTEGER;
	arg.integer.value = dock;
	status = acpi_evaluate_object(ds->handle, "_DCK", &arg_list, &buffer);
515
	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND)
516 517
		acpi_handle_err(ds->handle, "Failed to execute _DCK (0x%x)\n",
				status);
518

519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542
	kfree(buffer.pointer);
}

static inline void dock(struct dock_station *ds)
{
	handle_dock(ds, 1);
}

static inline void undock(struct dock_station *ds)
{
	handle_dock(ds, 0);
}

static inline void begin_dock(struct dock_station *ds)
{
	ds->flags |= DOCK_DOCKING;
}

static inline void complete_dock(struct dock_station *ds)
{
	ds->flags &= ~(DOCK_DOCKING);
	ds->last_dock_time = jiffies;
}

543 544 545 546 547 548 549 550 551 552
static inline void begin_undock(struct dock_station *ds)
{
	ds->flags |= DOCK_UNDOCKING;
}

static inline void complete_undock(struct dock_station *ds)
{
	ds->flags &= ~(DOCK_UNDOCKING);
}

Shaohua Li's avatar
Shaohua Li committed
553 554 555 556 557 558 559 560 561 562 563 564 565
static void dock_lock(struct dock_station *ds, int lock)
{
	struct acpi_object_list arg_list;
	union acpi_object arg;
	acpi_status status;

	arg_list.count = 1;
	arg_list.pointer = &arg;
	arg.type = ACPI_TYPE_INTEGER;
	arg.integer.value = !!lock;
	status = acpi_evaluate_object(ds->handle, "_LCK", &arg_list, NULL);
	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
		if (lock)
566 567
			acpi_handle_warn(ds->handle,
				"Locking device failed (0x%x)\n", status);
Shaohua Li's avatar
Shaohua Li committed
568
		else
569 570
			acpi_handle_warn(ds->handle,
				"Unlocking device failed (0x%x)\n", status);
Shaohua Li's avatar
Shaohua Li committed
571 572 573
	}
}

574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
/**
 * dock_in_progress - see if we are in the middle of handling a dock event
 * @ds: the dock station
 *
 * Sometimes while docking, false dock events can be sent to the driver
 * because good connections aren't made or some other reason.  Ignore these
 * if we are in the middle of doing something.
 */
static int dock_in_progress(struct dock_station *ds)
{
	if ((ds->flags & DOCK_DOCKING) ||
	    time_before(jiffies, (ds->last_dock_time + HZ)))
		return 1;
	return 0;
}

/**
 * register_dock_notifier - add yourself to the dock notifier list
 * @nb: the callers notifier block
 *
 * If a driver wishes to be notified about dock events, they can
 * use this function to put a notifier block on the dock notifier list.
 * this notifier call chain will be called after a dock event, but
 * before hotplugging any new devices.
 */
int register_dock_notifier(struct notifier_block *nb)
{
601
	if (!dock_station_count)
602 603
		return -ENODEV;

604 605 606 607 608 609 610 611 612 613
	return atomic_notifier_chain_register(&dock_notifier_list, nb);
}
EXPORT_SYMBOL_GPL(register_dock_notifier);

/**
 * unregister_dock_notifier - remove yourself from the dock notifier list
 * @nb: the callers notifier block
 */
void unregister_dock_notifier(struct notifier_block *nb)
{
614
	if (!dock_station_count)
615 616
		return;

617 618 619 620 621 622 623
	atomic_notifier_chain_unregister(&dock_notifier_list, nb);
}
EXPORT_SYMBOL_GPL(unregister_dock_notifier);

/**
 * register_hotplug_dock_device - register a hotplug function
 * @handle: the handle of the device
624
 * @ops: handlers to call after docking
625
 * @context: device specific data
626 627
 * @init: Optional initialization routine to run after registration
 * @release: Optional release routine to run on unregistration
628 629 630 631 632
 *
 * If a driver would like to perform a hotplug operation after a dock
 * event, they can register an acpi_notifiy_handler to be called by
 * the dock driver after _DCK is executed.
 */
633 634 635
int register_hotplug_dock_device(acpi_handle handle,
				 const struct acpi_dock_ops *ops, void *context,
				 void (*init)(void *), void (*release)(void *))
636 637
{
	struct dock_dependent_device *dd;
638
	struct dock_station *dock_station;
639
	int ret = -EINVAL;
640

641 642 643
	if (WARN_ON(!context))
		return -EINVAL;

644
	if (!dock_station_count)
645 646 647 648 649 650
		return -ENODEV;

	/*
	 * make sure this handle is for a device dependent on the dock,
	 * this would include the dock station itself
	 */
Alex Chiang's avatar
Alex Chiang committed
651
	list_for_each_entry(dock_station, &dock_stations, sibling) {
652 653
		/*
		 * An ATA bay can be in a dock and itself can be ejected
654
		 * separately, so there are two 'dock stations' which need the
655 656
		 * ops
		 */
657
		dd = find_dock_dependent_device(dock_station, handle);
658
		if (dd && !dock_init_hotplug(dd, ops, context, init, release))
659
			ret = 0;
660 661
	}

662
	return ret;
663 664 665 666 667 668 669 670 671 672
}
EXPORT_SYMBOL_GPL(register_hotplug_dock_device);

/**
 * unregister_hotplug_dock_device - remove yourself from the hotplug list
 * @handle: the acpi handle of the device
 */
void unregister_hotplug_dock_device(acpi_handle handle)
{
	struct dock_dependent_device *dd;
673
	struct dock_station *dock_station;
674

675
	if (!dock_station_count)
676 677
		return;

Alex Chiang's avatar
Alex Chiang committed
678
	list_for_each_entry(dock_station, &dock_stations, sibling) {
679 680
		dd = find_dock_dependent_device(dock_station, handle);
		if (dd)
681
			dock_release_hotplug(dd);
682
	}
683 684 685
}
EXPORT_SYMBOL_GPL(unregister_hotplug_dock_device);

686 687 688 689 690 691 692 693 694 695 696 697 698 699 700
/**
 * handle_eject_request - handle an undock request checking for error conditions
 *
 * Check to make sure the dock device is still present, then undock and
 * hotremove all the devices that may need removing.
 */
static int handle_eject_request(struct dock_station *ds, u32 event)
{
	if (dock_in_progress(ds))
		return -EBUSY;

	/*
	 * here we need to generate the undock
	 * event prior to actually doing the undock
	 * so that the device struct still exists.
701 702
	 * Also, even send the dock event if the
	 * device is not present anymore
703 704
	 */
	dock_event(ds, event, UNDOCK_EVENT);
705

706 707
	hotplug_dock_devices(ds, ACPI_NOTIFY_EJECT_REQUEST);
	undock(ds);
Shaohua Li's avatar
Shaohua Li committed
708
	dock_lock(ds, 0);
709 710
	eject_dock(ds);
	if (dock_present(ds)) {
711
		acpi_handle_err(ds->handle, "Unable to undock!\n");
712 713
		return -EBUSY;
	}
714
	complete_undock(ds);
715 716 717
	return 0;
}

718 719 720 721 722 723 724 725
/**
 * dock_notify - act upon an acpi dock notification
 * @handle: the dock station handle
 * @event: the acpi event
 * @data: our driver data struct
 *
 * If we are notified to dock, then check to see if the dock is
 * present and then dock.  Notify all drivers of the dock event,
726
 * and then hotplug and devices that may need hotplugging.
727 728 729
 */
static void dock_notify(acpi_handle handle, u32 event, void *data)
{
730
	struct dock_station *ds = data;
731
	struct acpi_device *tmp;
732
	int surprise_removal = 0;
733

734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750
	/*
	 * According to acpi spec 3.0a, if a DEVICE_CHECK notification
	 * is sent and _DCK is present, it is assumed to mean an undock
	 * request.
	 */
	if ((ds->flags & DOCK_IS_DOCK) && event == ACPI_NOTIFY_DEVICE_CHECK)
		event = ACPI_NOTIFY_EJECT_REQUEST;

	/*
	 * dock station: BUS_CHECK - docked or surprise removal
	 *		 DEVICE_CHECK - undocked
	 * other device: BUS_CHECK/DEVICE_CHECK - added or surprise removal
	 *
	 * To simplify event handling, dock dependent device handler always
	 * get ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and
	 * ACPI_NOTIFY_EJECT_REQUEST for removal
	 */
751 752
	switch (event) {
	case ACPI_NOTIFY_BUS_CHECK:
753
	case ACPI_NOTIFY_DEVICE_CHECK:
754 755
		if (!dock_in_progress(ds) && acpi_bus_get_device(ds->handle,
		   &tmp)) {
756 757 758
			begin_dock(ds);
			dock(ds);
			if (!dock_present(ds)) {
759
				acpi_handle_err(handle, "Unable to dock!\n");
760
				complete_dock(ds);
761 762 763 764 765 766 767
				break;
			}
			atomic_notifier_call_chain(&dock_notifier_list,
						   event, NULL);
			hotplug_dock_devices(ds, event);
			complete_dock(ds);
			dock_event(ds, event, DOCK_EVENT);
Shaohua Li's avatar
Shaohua Li committed
768
			dock_lock(ds, 1);
769
			acpi_update_all_gpes();
770
			break;
771
		}
772 773 774 775 776 777
		if (dock_present(ds) || dock_in_progress(ds))
			break;
		/* This is a surprise removal */
		surprise_removal = 1;
		event = ACPI_NOTIFY_EJECT_REQUEST;
		/* Fall back */
778
	case ACPI_NOTIFY_EJECT_REQUEST:
779
		begin_undock(ds);
780 781
		if ((immediate_undock && !(ds->flags & DOCK_IS_ATA))
		   || surprise_removal)
782 783 784
			handle_eject_request(ds, event);
		else
			dock_event(ds, event, UNDOCK_EVENT);
785 786
		break;
	default:
787
		acpi_handle_err(handle, "Unknown dock event %d\n", event);
788 789 790
	}
}

Zhang Rui's avatar
Zhang Rui committed
791 792 793 794 795 796 797 798
struct dock_data {
	acpi_handle handle;
	unsigned long event;
	struct dock_station *ds;
};

static void acpi_dock_deferred_cb(void *context)
{
799
	struct dock_data *data = context;
Zhang Rui's avatar
Zhang Rui committed
800

801
	acpi_scan_lock_acquire();
Zhang Rui's avatar
Zhang Rui committed
802
	dock_notify(data->handle, data->event, data->ds);
803
	acpi_scan_lock_release();
Zhang Rui's avatar
Zhang Rui committed
804 805 806
	kfree(data);
}

807 808 809 810
static int acpi_dock_notifier_call(struct notifier_block *this,
	unsigned long event, void *data)
{
	struct dock_station *dock_station;
811
	acpi_handle handle = data;
812 813 814 815

	if (event != ACPI_NOTIFY_BUS_CHECK && event != ACPI_NOTIFY_DEVICE_CHECK
	   && event != ACPI_NOTIFY_EJECT_REQUEST)
		return 0;
816 817 818

	acpi_scan_lock_acquire();

Alex Chiang's avatar
Alex Chiang committed
819
	list_for_each_entry(dock_station, &dock_stations, sibling) {
820
		if (dock_station->handle == handle) {
821
			struct dock_data *dd;
822
			acpi_status status;
Zhang Rui's avatar
Zhang Rui committed
823

824 825
			dd = kmalloc(sizeof(*dd), GFP_KERNEL);
			if (!dd)
826 827
				break;

828 829 830
			dd->handle = handle;
			dd->event = event;
			dd->ds = dock_station;
831 832 833 834 835 836
			status = acpi_os_hotplug_execute(acpi_dock_deferred_cb,
							 dd);
			if (ACPI_FAILURE(status))
				kfree(dd);

			break;
837 838
		}
	}
839 840

	acpi_scan_lock_release();
841 842 843 844 845 846 847
	return 0;
}

static struct notifier_block dock_acpi_notifier = {
	.notifier_call = acpi_dock_notifier_call,
};

848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
/**
 * find_dock_devices - find devices on the dock station
 * @handle: the handle of the device we are examining
 * @lvl: unused
 * @context: the dock station private data
 * @rv: unused
 *
 * This function is called by acpi_walk_namespace.  It will
 * check to see if an object has an _EJD method.  If it does, then it
 * will see if it is dependent on the dock station.
 */
static acpi_status
find_dock_devices(acpi_handle handle, u32 lvl, void *context, void **rv)
{
	acpi_status status;
863
	acpi_handle tmp, parent;
864
	struct dock_station *ds = context;
865 866

	status = acpi_bus_get_ejd(handle, &tmp);
867 868 869 870 871 872 873 874 875 876
	if (ACPI_FAILURE(status)) {
		/* try the parent device as well */
		status = acpi_get_parent(handle, &parent);
		if (ACPI_FAILURE(status))
			goto fdd_out;
		/* see if parent is dependent on dock */
		status = acpi_bus_get_ejd(parent, &tmp);
		if (ACPI_FAILURE(status))
			goto fdd_out;
	}
877

878 879 880
	if (tmp == ds->handle)
		add_dock_dependent_device(ds, handle);

881
fdd_out:
882 883 884
	return AE_OK;
}

885 886 887 888 889 890
/*
 * show_docked - read method for "docked" file in sysfs
 */
static ssize_t show_docked(struct device *dev,
			   struct device_attribute *attr, char *buf)
{
891 892
	struct acpi_device *tmp;

893
	struct dock_station *dock_station = dev->platform_data;
894

895
	if (!acpi_bus_get_device(dock_station->handle, &tmp))
896 897
		return snprintf(buf, PAGE_SIZE, "1\n");
	return snprintf(buf, PAGE_SIZE, "0\n");
898
}
Adrian Bunk's avatar
Adrian Bunk committed
899
static DEVICE_ATTR(docked, S_IRUGO, show_docked, NULL);
900

901 902 903 904 905 906
/*
 * show_flags - read method for flags file in sysfs
 */
static ssize_t show_flags(struct device *dev,
			  struct device_attribute *attr, char *buf)
{
907
	struct dock_station *dock_station = dev->platform_data;
908 909 910
	return snprintf(buf, PAGE_SIZE, "%d\n", dock_station->flags);

}
Adrian Bunk's avatar
Adrian Bunk committed
911
static DEVICE_ATTR(flags, S_IRUGO, show_flags, NULL);
912

913 914 915 916 917 918 919
/*
 * write_undock - write method for "undock" file in sysfs
 */
static ssize_t write_undock(struct device *dev, struct device_attribute *attr,
			   const char *buf, size_t count)
{
	int ret;
920
	struct dock_station *dock_station = dev->platform_data;
921 922 923 924

	if (!count)
		return -EINVAL;

925
	acpi_scan_lock_acquire();
926
	begin_undock(dock_station);
927
	ret = handle_eject_request(dock_station, ACPI_NOTIFY_EJECT_REQUEST);
928
	acpi_scan_lock_release();
929 930
	return ret ? ret: count;
}
Adrian Bunk's avatar
Adrian Bunk committed
931
static DEVICE_ATTR(undock, S_IWUSR, NULL, write_undock);
932

933 934 935 936 937 938
/*
 * show_dock_uid - read method for "uid" file in sysfs
 */
static ssize_t show_dock_uid(struct device *dev,
			     struct device_attribute *attr, char *buf)
{
939
	unsigned long long lbuf;
940
	struct dock_station *dock_station = dev->platform_data;
941 942 943
	acpi_status status = acpi_evaluate_integer(dock_station->handle,
					"_UID", NULL, &lbuf);
	if (ACPI_FAILURE(status))
944
	    return 0;
945

946
	return snprintf(buf, PAGE_SIZE, "%llx\n", lbuf);
947
}
Adrian Bunk's avatar
Adrian Bunk committed
948
static DEVICE_ATTR(uid, S_IRUGO, show_dock_uid, NULL);
949

Shaohua Li's avatar
Shaohua Li committed
950 951 952
static ssize_t show_dock_type(struct device *dev,
		struct device_attribute *attr, char *buf)
{
953
	struct dock_station *dock_station = dev->platform_data;
Shaohua Li's avatar
Shaohua Li committed
954 955 956 957 958 959 960 961 962 963 964 965 966 967 968
	char *type;

	if (dock_station->flags & DOCK_IS_DOCK)
		type = "dock_station";
	else if (dock_station->flags & DOCK_IS_ATA)
		type = "ata_bay";
	else if (dock_station->flags & DOCK_IS_BAT)
		type = "battery_bay";
	else
		type = "unknown";

	return snprintf(buf, PAGE_SIZE, "%s\n", type);
}
static DEVICE_ATTR(type, S_IRUGO, show_dock_type, NULL);

969 970 971 972 973 974 975 976 977 978 979 980 981
static struct attribute *dock_attributes[] = {
	&dev_attr_docked.attr,
	&dev_attr_flags.attr,
	&dev_attr_undock.attr,
	&dev_attr_uid.attr,
	&dev_attr_type.attr,
	NULL
};

static struct attribute_group dock_attribute_group = {
	.attrs = dock_attributes
};

982 983 984 985 986 987 988
/**
 * dock_add - add a new dock station
 * @handle: the dock station handle
 *
 * allocated and initialize a new dock station device.  Find all devices
 * that are on the dock station, and register for dock event notifications.
 */
989
static int __init dock_add(acpi_handle handle)
990
{
991 992
	int ret, id;
	struct dock_station ds, *dock_station;
993
	struct platform_device *dd;
994

995
	id = dock_station_count;
996
	memset(&ds, 0, sizeof(ds));
997 998 999 1000 1001
	dd = platform_device_register_data(NULL, "dock", id, &ds, sizeof(ds));
	if (IS_ERR(dd))
		return PTR_ERR(dd);

	dock_station = dd->dev.platform_data;
1002 1003

	dock_station->handle = handle;
1004
	dock_station->dock_device = dd;
1005
	dock_station->last_dock_time = jiffies - HZ;
1006

1007
	mutex_init(&dock_station->hp_lock);
1008 1009
	spin_lock_init(&dock_station->dd_lock);
	INIT_LIST_HEAD(&dock_station->sibling);
1010
	ATOMIC_INIT_NOTIFIER_HEAD(&dock_notifier_list);
1011
	INIT_LIST_HEAD(&dock_station->dependent_devices);
1012

1013
	/* we want the dock device to send uevents */
1014
	dev_set_uevent_suppress(&dd->dev, 0);
1015

1016 1017 1018 1019 1020 1021 1022
	if (is_dock(handle))
		dock_station->flags |= DOCK_IS_DOCK;
	if (is_ata(handle))
		dock_station->flags |= DOCK_IS_ATA;
	if (is_battery(handle))
		dock_station->flags |= DOCK_IS_BAT;

1023
	ret = sysfs_create_group(&dd->dev.kobj, &dock_attribute_group);
Shaohua Li's avatar
Shaohua Li committed
1024
	if (ret)
1025
		goto err_unregister;
1026

1027 1028
	/* Find dependent devices */
	acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
1029 1030
			    ACPI_UINT32_MAX, find_dock_devices, NULL,
			    dock_station, NULL);
1031 1032

	/* add the dock station as a device dependent on itself */
1033 1034
	ret = add_dock_dependent_device(dock_station, handle);
	if (ret)
1035
		goto err_rmgroup;
1036

1037
	dock_station_count++;
Alex Chiang's avatar
Alex Chiang committed
1038
	list_add(&dock_station->sibling, &dock_stations);
1039 1040
	return 0;

1041
err_rmgroup:
1042
	sysfs_remove_group(&dd->dev.kobj, &dock_attribute_group);
1043
err_unregister:
1044
	platform_device_unregister(dd);
1045
	acpi_handle_err(handle, "%s encountered error %d\n", __func__, ret);
1046 1047 1048 1049
	return ret;
}

/**
1050
 * find_dock_and_bay - look for dock stations and bays
1051 1052
 * @handle: acpi handle of a device
 * @lvl: unused
1053
 * @context: unused
1054 1055
 * @rv: unused
 *
1056
 * This is called by acpi_walk_namespace to look for dock stations and bays.
1057
 */
1058
static __init acpi_status
1059
find_dock_and_bay(acpi_handle handle, u32 lvl, void *context, void **rv)
1060
{
1061
	if (is_dock(handle) || is_ejectable_bay(handle))
1062
		dock_add(handle);
1063

1064
	return AE_OK;
1065 1066
}

1067
int __init acpi_dock_init(void)
1068
{
1069 1070 1071
	if (acpi_disabled)
		return 0;

1072
	/* look for dock stations and bays */
1073
	acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
1074
		ACPI_UINT32_MAX, find_dock_and_bay, NULL, NULL, NULL);
1075

1076
	if (!dock_station_count) {
1077
		pr_info(PREFIX "No dock devices found.\n");
1078 1079
		return 0;
	}
1080

1081
	register_acpi_bus_notifier(&dock_acpi_notifier);
1082
	pr_info(PREFIX "%s: %d docks/bays found\n",
1083
		ACPI_DOCK_DRIVER_DESCRIPTION, dock_station_count);
1084 1085
	return 0;
}