scan.c 57.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6
/*
 * scan.c - support for transforming the ACPI namespace into individual objects
 */

#include <linux/module.h>
#include <linux/init.h>
7
#include <linux/slab.h>
8
#include <linux/kernel.h>
L
Linus Torvalds 已提交
9
#include <linux/acpi.h>
10 11
#include <linux/signal.h>
#include <linux/kthread.h>
12
#include <linux/dmi.h>
13
#include <linux/nls.h>
L
Linus Torvalds 已提交
14

15 16
#include <asm/pgtable.h>

17 18
#include "internal.h"

L
Linus Torvalds 已提交
19
#define _COMPONENT		ACPI_BUS_COMPONENT
20
ACPI_MODULE_NAME("scan");
L
Len Brown 已提交
21
extern struct acpi_device *acpi_root;
L
Linus Torvalds 已提交
22 23

#define ACPI_BUS_CLASS			"system_bus"
24
#define ACPI_BUS_HID			"LNXSYBUS"
L
Linus Torvalds 已提交
25 26
#define ACPI_BUS_DEVICE_NAME		"System Bus"

27 28
#define ACPI_IS_ROOT_DEVICE(device)    (!(device)->parent)

29 30
#define INVALID_ACPI_HANDLE	((acpi_handle)empty_zero_page)

31 32 33 34 35 36
/*
 * If set, devices will be hot-removed even if they cannot be put offline
 * gracefully (from the kernel's standpoint).
 */
bool acpi_force_hot_remove;

37
static const char *dummy_hid = "device";
38

39
static LIST_HEAD(acpi_bus_id_list);
40
static DEFINE_MUTEX(acpi_scan_lock);
41
static LIST_HEAD(acpi_scan_handlers_list);
42
DEFINE_MUTEX(acpi_device_lock);
L
Linus Torvalds 已提交
43
LIST_HEAD(acpi_wakeup_device_list);
44
static DEFINE_MUTEX(acpi_hp_context_lock);
L
Linus Torvalds 已提交
45

46
struct acpi_device_bus_id{
47
	char bus_id[15];
48 49
	unsigned int instance_no;
	struct list_head node;
L
Linus Torvalds 已提交
50
};
51

52 53 54 55 56 57 58 59 60 61 62 63
void acpi_scan_lock_acquire(void)
{
	mutex_lock(&acpi_scan_lock);
}
EXPORT_SYMBOL_GPL(acpi_scan_lock_acquire);

void acpi_scan_lock_release(void)
{
	mutex_unlock(&acpi_scan_lock);
}
EXPORT_SYMBOL_GPL(acpi_scan_lock_release);

64 65 66 67 68 69 70 71 72 73
void acpi_lock_hp_context(void)
{
	mutex_lock(&acpi_hp_context_lock);
}

void acpi_unlock_hp_context(void)
{
	mutex_unlock(&acpi_hp_context_lock);
}

74 75 76 77 78 79 80 81 82 83 84
void acpi_initialize_hp_context(struct acpi_device *adev,
				struct acpi_hotplug_context *hp,
				int (*notify)(struct acpi_device *, u32),
				void (*uevent)(struct acpi_device *, u32))
{
	acpi_lock_hp_context();
	acpi_set_hp_context(adev, hp, notify, uevent, NULL);
	acpi_unlock_hp_context();
}
EXPORT_SYMBOL_GPL(acpi_initialize_hp_context);

85 86 87 88 89 90 91 92 93
int acpi_scan_add_handler(struct acpi_scan_handler *handler)
{
	if (!handler || !handler->attach)
		return -EINVAL;

	list_add_tail(&handler->list_node, &acpi_scan_handlers_list);
	return 0;
}

94 95 96 97 98 99 100 101 102 103 104 105 106
int acpi_scan_add_handler_with_hotplug(struct acpi_scan_handler *handler,
				       const char *hotplug_profile_name)
{
	int error;

	error = acpi_scan_add_handler(handler);
	if (error)
		return error;

	acpi_sysfs_add_hotplug_profile(&handler->hotplug, hotplug_profile_name);
	return 0;
}

107 108 109 110
/*
 * Creates hid/cid(s) string needed for modalias and uevent
 * e.g. on a device with hid:IBM0001 and cid:ACPI0001 you get:
 * char *modalias: "acpi:IBM0001:ACPI0001"
111 112 113
 * Return: 0: no _HID and no _CID
 *         -EINVAL: output error
 *         -ENOMEM: output is truncated
114
*/
115 116 117
static int create_modalias(struct acpi_device *acpi_dev, char *modalias,
			   int size)
{
118
	int len;
119
	int count;
120
	struct acpi_hardware_id *id;
121

122 123 124
	if (list_empty(&acpi_dev->pnp.ids))
		return 0;

125
	len = snprintf(modalias, size, "acpi:");
126 127
	size -= len;

128 129
	list_for_each_entry(id, &acpi_dev->pnp.ids, list) {
		count = snprintf(&modalias[len], size, "%s:", id->id);
130 131 132 133
		if (count < 0)
			return EINVAL;
		if (count >= size)
			return -ENOMEM;
134 135 136 137
		len += count;
		size -= count;
	}

138 139 140 141
	modalias[len] = '\0';
	return len;
}

142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 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
/*
 * Creates uevent modalias field for ACPI enumerated devices.
 * Because the other buses does not support ACPI HIDs & CIDs.
 * e.g. for a device with hid:IBM0001 and cid:ACPI0001 you get:
 * "acpi:IBM0001:ACPI0001"
 */
int acpi_device_uevent_modalias(struct device *dev, struct kobj_uevent_env *env)
{
	struct acpi_device *acpi_dev;
	int len;

	acpi_dev = ACPI_COMPANION(dev);
	if (!acpi_dev)
		return -ENODEV;

	/* Fall back to bus specific way of modalias exporting */
	if (list_empty(&acpi_dev->pnp.ids))
		return -ENODEV;

	if (add_uevent_var(env, "MODALIAS="))
		return -ENOMEM;
	len = create_modalias(acpi_dev, &env->buf[env->buflen - 1],
				sizeof(env->buf) - env->buflen);
	if (len <= 0)
		return len;
	env->buflen += len;
	return 0;
}
EXPORT_SYMBOL_GPL(acpi_device_uevent_modalias);

/*
 * Creates modalias sysfs attribute for ACPI enumerated devices.
 * Because the other buses does not support ACPI HIDs & CIDs.
 * e.g. for a device with hid:IBM0001 and cid:ACPI0001 you get:
 * "acpi:IBM0001:ACPI0001"
 */
int acpi_device_modalias(struct device *dev, char *buf, int size)
{
	struct acpi_device *acpi_dev;
	int len;

	acpi_dev = ACPI_COMPANION(dev);
	if (!acpi_dev)
		return -ENODEV;

	/* Fall back to bus specific way of modalias exporting */
	if (list_empty(&acpi_dev->pnp.ids))
		return -ENODEV;

	len = create_modalias(acpi_dev, buf, size -1);
	if (len <= 0)
		return len;
	buf[len++] = '\n';
	return len;
}
EXPORT_SYMBOL_GPL(acpi_device_modalias);

199 200 201 202 203 204 205
static ssize_t
acpi_device_modalias_show(struct device *dev, struct device_attribute *attr, char *buf) {
	struct acpi_device *acpi_dev = to_acpi_device(dev);
	int len;

	len = create_modalias(acpi_dev, buf, 1024);
	if (len <= 0)
206
		return len;
207 208 209 210 211
	buf[len++] = '\n';
	return len;
}
static DEVICE_ATTR(modalias, 0444, acpi_device_modalias_show, NULL);

212
bool acpi_scan_is_offline(struct acpi_device *adev, bool uevent)
213 214 215 216 217 218 219 220
{
	struct acpi_device_physical_node *pn;
	bool offline = true;

	mutex_lock(&adev->physical_node_lock);

	list_for_each_entry(pn, &adev->physical_node_list, node)
		if (device_supports_offline(pn->dev) && !pn->dev->offline) {
221 222 223
			if (uevent)
				kobject_uevent(&pn->dev->kobj, KOBJ_CHANGE);

224 225 226 227 228 229 230 231
			offline = false;
			break;
		}

	mutex_unlock(&adev->physical_node_lock);
	return offline;
}

232 233
static acpi_status acpi_bus_offline(acpi_handle handle, u32 lvl, void *data,
				    void **ret_p)
234 235 236
{
	struct acpi_device *device = NULL;
	struct acpi_device_physical_node *pn;
237
	bool second_pass = (bool)data;
238 239 240 241 242
	acpi_status status = AE_OK;

	if (acpi_bus_get_device(handle, &device))
		return AE_OK;

243 244 245 246 247
	if (device->handler && !device->handler->hotplug.enabled) {
		*ret_p = &device->dev;
		return AE_SUPPORT;
	}

248 249 250 251 252
	mutex_lock(&device->physical_node_lock);

	list_for_each_entry(pn, &device->physical_node_list, node) {
		int ret;

253 254 255 256 257 258 259
		if (second_pass) {
			/* Skip devices offlined by the first pass. */
			if (pn->put_online)
				continue;
		} else {
			pn->put_online = false;
		}
260 261 262 263
		ret = device_offline(pn->dev);
		if (acpi_force_hot_remove)
			continue;

264 265 266 267 268 269 270 271
		if (ret >= 0) {
			pn->put_online = !ret;
		} else {
			*ret_p = pn->dev;
			if (second_pass) {
				status = AE_ERROR;
				break;
			}
272 273 274 275 276 277 278 279
		}
	}

	mutex_unlock(&device->physical_node_lock);

	return status;
}

280 281
static acpi_status acpi_bus_online(acpi_handle handle, u32 lvl, void *data,
				   void **ret_p)
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
{
	struct acpi_device *device = NULL;
	struct acpi_device_physical_node *pn;

	if (acpi_bus_get_device(handle, &device))
		return AE_OK;

	mutex_lock(&device->physical_node_lock);

	list_for_each_entry(pn, &device->physical_node_list, node)
		if (pn->put_online) {
			device_online(pn->dev);
			pn->put_online = false;
		}

	mutex_unlock(&device->physical_node_lock);

	return AE_OK;
}

302
static int acpi_scan_try_to_offline(struct acpi_device *device)
L
Linus Torvalds 已提交
303
{
304
	acpi_handle handle = device->handle;
305
	struct device *errdev = NULL;
306
	acpi_status status;
307

308 309 310 311 312 313 314 315 316
	/*
	 * Carry out two passes here and ignore errors in the first pass,
	 * because if the devices in question are memory blocks and
	 * CONFIG_MEMCG is set, one of the blocks may hold data structures
	 * that the other blocks depend on, but it is not known in advance which
	 * block holds them.
	 *
	 * If the first pass is successful, the second one isn't needed, though.
	 */
317 318 319 320 321 322 323 324 325 326
	status = acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
				     NULL, acpi_bus_offline, (void *)false,
				     (void **)&errdev);
	if (status == AE_SUPPORT) {
		dev_warn(errdev, "Offline disabled.\n");
		acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
				    acpi_bus_online, NULL, NULL, NULL);
		return -EPERM;
	}
	acpi_bus_offline(handle, 0, (void *)false, (void **)&errdev);
327 328
	if (errdev) {
		errdev = NULL;
329
		acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
330 331
				    NULL, acpi_bus_offline, (void *)true,
				    (void **)&errdev);
332
		if (!errdev || acpi_force_hot_remove)
333 334
			acpi_bus_offline(handle, 0, (void *)true,
					 (void **)&errdev);
335 336 337

		if (errdev && !acpi_force_hot_remove) {
			dev_warn(errdev, "Offline failed.\n");
338
			acpi_bus_online(handle, 0, NULL, NULL);
339
			acpi_walk_namespace(ACPI_TYPE_ANY, handle,
340 341
					    ACPI_UINT32_MAX, acpi_bus_online,
					    NULL, NULL, NULL);
342 343
			return -EBUSY;
		}
344
	}
345 346 347 348 349 350 351 352 353 354
	return 0;
}

static int acpi_scan_hot_remove(struct acpi_device *device)
{
	acpi_handle handle = device->handle;
	unsigned long long sta;
	acpi_status status;

	if (device->handler->hotplug.demand_offline && !acpi_force_hot_remove) {
355
		if (!acpi_scan_is_offline(device, true))
356 357 358 359 360 361
			return -EBUSY;
	} else {
		int error = acpi_scan_try_to_offline(device);
		if (error)
			return error;
	}
362

363
	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
364
		"Hot-removing device %s...\n", dev_name(&device->dev)));
365

366
	acpi_bus_trim(device);
367

368
	acpi_evaluate_lck(handle, 0);
L
Linus Torvalds 已提交
369 370 371
	/*
	 * TBD: _EJD support.
	 */
372 373 374 375 376
	status = acpi_evaluate_ej0(handle);
	if (status == AE_NOT_FOUND)
		return -ENODEV;
	else if (ACPI_FAILURE(status))
		return -EIO;
L
Linus Torvalds 已提交
377

378 379 380 381 382 383 384 385 386 387 388 389 390
	/*
	 * Verify if eject was indeed successful.  If not, log an error
	 * message.  No need to call _OST since _EJ0 call was made OK.
	 */
	status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
	if (ACPI_FAILURE(status)) {
		acpi_handle_warn(handle,
			"Status check after eject failed (0x%x)\n", status);
	} else if (sta & ACPI_STA_DEVICE_ENABLED) {
		acpi_handle_warn(handle,
			"Eject incomplete - status 0x%llx\n", sta);
	}

391 392
	return 0;
}
L
Linus Torvalds 已提交
393

394 395 396 397 398 399 400 401 402 403
static int acpi_scan_device_not_present(struct acpi_device *adev)
{
	if (!acpi_device_enumerated(adev)) {
		dev_warn(&adev->dev, "Still not present\n");
		return -EALREADY;
	}
	acpi_bus_trim(adev);
	return 0;
}

404
static int acpi_scan_device_check(struct acpi_device *adev)
405
{
406
	int error;
407

408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
	acpi_bus_get_status(adev);
	if (adev->status.present || adev->status.functional) {
		/*
		 * This function is only called for device objects for which
		 * matching scan handlers exist.  The only situation in which
		 * the scan handler is not attached to this device object yet
		 * is when the device has just appeared (either it wasn't
		 * present at all before or it was removed and then added
		 * again).
		 */
		if (adev->handler) {
			dev_warn(&adev->dev, "Already enumerated\n");
			return -EALREADY;
		}
		error = acpi_bus_scan(adev->handle);
		if (error) {
			dev_warn(&adev->dev, "Namespace scan failure\n");
			return error;
		}
		if (!adev->handler) {
			dev_warn(&adev->dev, "Enumeration failure\n");
			error = -ENODEV;
		}
	} else {
		error = acpi_scan_device_not_present(adev);
	}
	return error;
}

static int acpi_scan_bus_check(struct acpi_device *adev)
{
	struct acpi_scan_handler *handler = adev->handler;
	struct acpi_device *child;
	int error;

	acpi_bus_get_status(adev);
	if (!(adev->status.present || adev->status.functional)) {
		acpi_scan_device_not_present(adev);
		return 0;
	}
	if (handler && handler->hotplug.scan_dependent)
		return handler->hotplug.scan_dependent(adev);

451 452 453 454 455
	error = acpi_bus_scan(adev->handle);
	if (error) {
		dev_warn(&adev->dev, "Namespace scan failure\n");
		return error;
	}
456 457 458 459
	list_for_each_entry(child, &adev->children, node) {
		error = acpi_scan_bus_check(child);
		if (error)
			return error;
460 461
	}
	return 0;
462 463
}

464 465 466 467 468 469 470 471 472
static int acpi_generic_hotplug_event(struct acpi_device *adev, u32 type)
{
	switch (type) {
	case ACPI_NOTIFY_BUS_CHECK:
		return acpi_scan_bus_check(adev);
	case ACPI_NOTIFY_DEVICE_CHECK:
		return acpi_scan_device_check(adev);
	case ACPI_NOTIFY_EJECT_REQUEST:
	case ACPI_OST_EC_OSPM_EJECT:
473 474 475 476
		if (adev->handler && !adev->handler->hotplug.enabled) {
			dev_info(&adev->dev, "Eject disabled\n");
			return -EPERM;
		}
477 478
		acpi_evaluate_ost(adev->handle, ACPI_NOTIFY_EJECT_REQUEST,
				  ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
479 480 481 482 483
		return acpi_scan_hot_remove(adev);
	}
	return -EINVAL;
}

484
void acpi_device_hotplug(struct acpi_device *adev, u32 src)
485 486
{
	u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
487
	int error = -ENODEV;
488

489
	lock_device_hotplug();
490
	mutex_lock(&acpi_scan_lock);
491

492 493
	/*
	 * The device object's ACPI handle cannot become invalid as long as we
494
	 * are holding acpi_scan_lock, but it might have become invalid before
495 496 497
	 * that lock was acquired.
	 */
	if (adev->handle == INVALID_ACPI_HANDLE)
498
		goto err_out;
499

500 501 502
	if (adev->flags.is_dock_station) {
		error = dock_notify(adev, src);
	} else if (adev->flags.hotplug_notify) {
503
		error = acpi_generic_hotplug_event(adev, src);
504 505 506 507
		if (error == -EPERM) {
			ost_code = ACPI_OST_SC_EJECT_NOT_SUPPORTED;
			goto err_out;
		}
508
	} else {
509
		int (*notify)(struct acpi_device *, u32);
510 511

		acpi_lock_hp_context();
512
		notify = adev->hp ? adev->hp->notify : NULL;
513 514 515 516 517
		acpi_unlock_hp_context();
		/*
		 * There may be additional notify handlers for device objects
		 * without the .event() callback, so ignore them here.
		 */
518 519
		if (notify)
			error = notify(adev, src);
520 521
		else
			goto out;
522
	}
523 524
	if (!error)
		ost_code = ACPI_OST_SC_SUCCESS;
525

526
 err_out:
527
	acpi_evaluate_ost(adev->handle, src, ost_code, NULL);
528 529

 out:
530
	acpi_bus_put_acpi_device(adev);
531
	mutex_unlock(&acpi_scan_lock);
532
	unlock_device_hotplug();
533 534
}

535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560
static ssize_t real_power_state_show(struct device *dev,
				     struct device_attribute *attr, char *buf)
{
	struct acpi_device *adev = to_acpi_device(dev);
	int state;
	int ret;

	ret = acpi_device_get_power(adev, &state);
	if (ret)
		return ret;

	return sprintf(buf, "%s\n", acpi_power_state_string(state));
}

static DEVICE_ATTR(real_power_state, 0444, real_power_state_show, NULL);

static ssize_t power_state_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct acpi_device *adev = to_acpi_device(dev);

	return sprintf(buf, "%s\n", acpi_power_state_string(adev->power.state));
}

static DEVICE_ATTR(power_state, 0444, power_state_show, NULL);

L
Linus Torvalds 已提交
561
static ssize_t
P
Patrick Mochel 已提交
562 563
acpi_eject_store(struct device *d, struct device_attribute *attr,
		const char *buf, size_t count)
L
Linus Torvalds 已提交
564
{
P
Patrick Mochel 已提交
565
	struct acpi_device *acpi_device = to_acpi_device(d);
566 567
	acpi_object_type not_used;
	acpi_status status;
L
Linus Torvalds 已提交
568

569
	if (!count || buf[0] != '1')
L
Linus Torvalds 已提交
570 571
		return -EINVAL;

572 573 574 575 576 577 578 579 580
	if ((!acpi_device->handler || !acpi_device->handler->hotplug.enabled)
	    && !acpi_device->driver)
		return -ENODEV;

	status = acpi_get_type(acpi_device->handle, &not_used);
	if (ACPI_FAILURE(status) || !acpi_device->flags.ejectable)
		return -ENODEV;

	get_device(&acpi_device->dev);
581
	status = acpi_hotplug_schedule(acpi_device, ACPI_OST_EC_OSPM_EJECT);
582 583
	if (ACPI_SUCCESS(status))
		return count;
584

585
	put_device(&acpi_device->dev);
586 587
	acpi_evaluate_ost(acpi_device->handle, ACPI_OST_EC_OSPM_EJECT,
			  ACPI_OST_SC_NON_SPECIFIC_FAILURE, NULL);
588
	return status == AE_NO_MEMORY ? -ENOMEM : -EAGAIN;
L
Linus Torvalds 已提交
589 590
}

P
Patrick Mochel 已提交
591
static DEVICE_ATTR(eject, 0200, NULL, acpi_eject_store);
L
Linus Torvalds 已提交
592

593 594 595
static ssize_t
acpi_device_hid_show(struct device *dev, struct device_attribute *attr, char *buf) {
	struct acpi_device *acpi_dev = to_acpi_device(dev);
L
Linus Torvalds 已提交
596

597
	return sprintf(buf, "%s\n", acpi_device_hid(acpi_dev));
L
Linus Torvalds 已提交
598
}
599
static DEVICE_ATTR(hid, 0444, acpi_device_hid_show, NULL);
L
Linus Torvalds 已提交
600

601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619
static ssize_t acpi_device_uid_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
{
	struct acpi_device *acpi_dev = to_acpi_device(dev);

	return sprintf(buf, "%s\n", acpi_dev->pnp.unique_id);
}
static DEVICE_ATTR(uid, 0444, acpi_device_uid_show, NULL);

static ssize_t acpi_device_adr_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
{
	struct acpi_device *acpi_dev = to_acpi_device(dev);

	return sprintf(buf, "0x%08x\n",
		       (unsigned int)(acpi_dev->pnp.bus_address));
}
static DEVICE_ATTR(adr, 0444, acpi_device_adr_show, NULL);

620 621 622 623 624
static ssize_t
acpi_device_path_show(struct device *dev, struct device_attribute *attr, char *buf) {
	struct acpi_device *acpi_dev = to_acpi_device(dev);
	struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL};
	int result;
L
Linus Torvalds 已提交
625

626
	result = acpi_get_name(acpi_dev->handle, ACPI_FULL_PATHNAME, &path);
627
	if (result)
628
		goto end;
L
Linus Torvalds 已提交
629

630 631
	result = sprintf(buf, "%s\n", (char*)path.pointer);
	kfree(path.pointer);
632
end:
633
	return result;
L
Linus Torvalds 已提交
634
}
635
static DEVICE_ATTR(path, 0444, acpi_device_path_show, NULL);
L
Linus Torvalds 已提交
636

637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
/* sysfs file that shows description text from the ACPI _STR method */
static ssize_t description_show(struct device *dev,
				struct device_attribute *attr,
				char *buf) {
	struct acpi_device *acpi_dev = to_acpi_device(dev);
	int result;

	if (acpi_dev->pnp.str_obj == NULL)
		return 0;

	/*
	 * The _STR object contains a Unicode identifier for a device.
	 * We need to convert to utf-8 so it can be displayed.
	 */
	result = utf16s_to_utf8s(
		(wchar_t *)acpi_dev->pnp.str_obj->buffer.pointer,
		acpi_dev->pnp.str_obj->buffer.length,
		UTF16_LITTLE_ENDIAN, buf,
		PAGE_SIZE);

	buf[result++] = '\n';

	return result;
}
static DEVICE_ATTR(description, 0444, description_show, NULL);

Y
Yasuaki Ishimatsu 已提交
663 664 665 666 667 668 669 670 671
static ssize_t
acpi_device_sun_show(struct device *dev, struct device_attribute *attr,
		     char *buf) {
	struct acpi_device *acpi_dev = to_acpi_device(dev);

	return sprintf(buf, "%lu\n", acpi_dev->pnp.sun);
}
static DEVICE_ATTR(sun, 0444, acpi_device_sun_show, NULL);

672 673 674 675 676 677 678 679 680 681 682 683 684 685
static ssize_t status_show(struct device *dev, struct device_attribute *attr,
				char *buf) {
	struct acpi_device *acpi_dev = to_acpi_device(dev);
	acpi_status status;
	unsigned long long sta;

	status = acpi_evaluate_integer(acpi_dev->handle, "_STA", NULL, &sta);
	if (ACPI_FAILURE(status))
		return -ENODEV;

	return sprintf(buf, "%llu\n", sta);
}
static DEVICE_ATTR_RO(status);

686
static int acpi_device_setup_files(struct acpi_device *dev)
L
Linus Torvalds 已提交
687
{
688
	struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
P
Patrick Mochel 已提交
689
	acpi_status status;
Y
Yasuaki Ishimatsu 已提交
690
	unsigned long long sun;
691
	int result = 0;
L
Linus Torvalds 已提交
692 693

	/*
694
	 * Devices gotten from FADT don't have a "path" attribute
L
Linus Torvalds 已提交
695
	 */
696
	if (dev->handle) {
697
		result = device_create_file(&dev->dev, &dev_attr_path);
698
		if (result)
699
			goto end;
L
Linus Torvalds 已提交
700 701
	}

702 703 704 705
	if (!list_empty(&dev->pnp.ids)) {
		result = device_create_file(&dev->dev, &dev_attr_hid);
		if (result)
			goto end;
L
Linus Torvalds 已提交
706

707 708 709 710
		result = device_create_file(&dev->dev, &dev_attr_modalias);
		if (result)
			goto end;
	}
711

712 713 714
	/*
	 * If device has _STR, 'description' file is created
	 */
715
	if (acpi_has_method(dev->handle, "_STR")) {
716 717 718 719 720 721 722 723 724 725
		status = acpi_evaluate_object(dev->handle, "_STR",
					NULL, &buffer);
		if (ACPI_FAILURE(status))
			buffer.pointer = NULL;
		dev->pnp.str_obj = buffer.pointer;
		result = device_create_file(&dev->dev, &dev_attr_description);
		if (result)
			goto end;
	}

726
	if (dev->pnp.type.bus_address)
727 728 729 730
		result = device_create_file(&dev->dev, &dev_attr_adr);
	if (dev->pnp.unique_id)
		result = device_create_file(&dev->dev, &dev_attr_uid);

Y
Yasuaki Ishimatsu 已提交
731 732 733 734 735 736 737 738 739 740
	status = acpi_evaluate_integer(dev->handle, "_SUN", NULL, &sun);
	if (ACPI_SUCCESS(status)) {
		dev->pnp.sun = (unsigned long)sun;
		result = device_create_file(&dev->dev, &dev_attr_sun);
		if (result)
			goto end;
	} else {
		dev->pnp.sun = (unsigned long)-1;
	}

741 742 743 744 745 746
	if (acpi_has_method(dev->handle, "_STA")) {
		result = device_create_file(&dev->dev, &dev_attr_status);
		if (result)
			goto end;
	}

747 748 749 750
        /*
         * If device has _EJ0, 'eject' file is created that is used to trigger
         * hot-removal function from userland.
         */
751
	if (acpi_has_method(dev->handle, "_EJ0")) {
752
		result = device_create_file(&dev->dev, &dev_attr_eject);
753 754 755 756 757 758 759 760 761 762 763 764 765 766
		if (result)
			return result;
	}

	if (dev->flags.power_manageable) {
		result = device_create_file(&dev->dev, &dev_attr_power_state);
		if (result)
			return result;

		if (dev->power.flags.power_resources)
			result = device_create_file(&dev->dev,
						    &dev_attr_real_power_state);
	}

767
end:
768
	return result;
L
Linus Torvalds 已提交
769 770
}

P
Patrick Mochel 已提交
771
static void acpi_device_remove_files(struct acpi_device *dev)
L
Linus Torvalds 已提交
772
{
773 774 775 776 777 778 779
	if (dev->flags.power_manageable) {
		device_remove_file(&dev->dev, &dev_attr_power_state);
		if (dev->power.flags.power_resources)
			device_remove_file(&dev->dev,
					   &dev_attr_real_power_state);
	}

P
Patrick Mochel 已提交
780
	/*
781 782
	 * If device has _STR, remove 'description' file
	 */
783
	if (acpi_has_method(dev->handle, "_STR")) {
784 785 786 787 788
		kfree(dev->pnp.str_obj);
		device_remove_file(&dev->dev, &dev_attr_description);
	}
	/*
	 * If device has _EJ0, remove 'eject' file.
P
Patrick Mochel 已提交
789
	 */
790
	if (acpi_has_method(dev->handle, "_EJ0"))
P
Patrick Mochel 已提交
791
		device_remove_file(&dev->dev, &dev_attr_eject);
L
Linus Torvalds 已提交
792

793
	if (acpi_has_method(dev->handle, "_SUN"))
Y
Yasuaki Ishimatsu 已提交
794 795
		device_remove_file(&dev->dev, &dev_attr_sun);

796 797
	if (dev->pnp.unique_id)
		device_remove_file(&dev->dev, &dev_attr_uid);
798
	if (dev->pnp.type.bus_address)
799
		device_remove_file(&dev->dev, &dev_attr_adr);
800 801
	device_remove_file(&dev->dev, &dev_attr_modalias);
	device_remove_file(&dev->dev, &dev_attr_hid);
802 803
	if (acpi_has_method(dev->handle, "_STA"))
		device_remove_file(&dev->dev, &dev_attr_status);
804
	if (dev->handle)
805
		device_remove_file(&dev->dev, &dev_attr_path);
L
Linus Torvalds 已提交
806 807
}
/* --------------------------------------------------------------------------
Z
Zhang Rui 已提交
808
			ACPI Bus operations
L
Linus Torvalds 已提交
809
   -------------------------------------------------------------------------- */
810

811 812
static const struct acpi_device_id *__acpi_match_device(
	struct acpi_device *device, const struct acpi_device_id *ids)
813 814
{
	const struct acpi_device_id *id;
815
	struct acpi_hardware_id *hwid;
816

817 818 819 820 821
	/*
	 * If the device is not present, it is unnecessary to load device
	 * driver for it.
	 */
	if (!device->status.present)
822
		return NULL;
823

824 825 826
	for (id = ids; id->id[0]; id++)
		list_for_each_entry(hwid, &device->pnp.ids, list)
			if (!strcmp((char *) id->id, hwid->id))
827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846
				return id;

	return NULL;
}

/**
 * acpi_match_device - Match a struct device against a given list of ACPI IDs
 * @ids: Array of struct acpi_device_id object to match against.
 * @dev: The device structure to match.
 *
 * Check if @dev has a valid ACPI handle and if there is a struct acpi_device
 * object for that handle and use that object to match against a given list of
 * device IDs.
 *
 * Return a pointer to the first matching ID on success or %NULL on failure.
 */
const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
					       const struct device *dev)
{
	struct acpi_device *adev;
847
	acpi_handle handle = ACPI_HANDLE(dev);
848

849
	if (!ids || !handle || acpi_bus_get_device(handle, &adev))
850 851 852 853 854
		return NULL;

	return __acpi_match_device(adev, ids);
}
EXPORT_SYMBOL_GPL(acpi_match_device);
855

856 857 858 859
int acpi_match_device_ids(struct acpi_device *device,
			  const struct acpi_device_id *ids)
{
	return __acpi_match_device(device, ids) ? 0 : -ENOENT;
860 861 862
}
EXPORT_SYMBOL(acpi_match_device_ids);

863 864 865 866
static void acpi_free_power_resources_lists(struct acpi_device *device)
{
	int i;

867 868 869
	if (device->wakeup.flags.valid)
		acpi_power_resources_list_free(&device->wakeup.resources);

870 871 872 873 874 875 876
	if (!device->flags.power_manageable)
		return;

	for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) {
		struct acpi_device_power_state *ps = &device->power.states[i];
		acpi_power_resources_list_free(&ps->resources);
	}
877 878
}

879
static void acpi_device_release(struct device *dev)
L
Linus Torvalds 已提交
880
{
881
	struct acpi_device *acpi_dev = to_acpi_device(dev);
L
Linus Torvalds 已提交
882

883
	acpi_free_pnp_ids(&acpi_dev->pnp);
884
	acpi_free_power_resources_lists(acpi_dev);
885
	kfree(acpi_dev);
L
Linus Torvalds 已提交
886 887
}

888
static int acpi_bus_match(struct device *dev, struct device_driver *drv)
Z
Zhang Rui 已提交
889
{
890 891
	struct acpi_device *acpi_dev = to_acpi_device(dev);
	struct acpi_driver *acpi_drv = to_acpi_driver(drv);
L
Linus Torvalds 已提交
892

893
	return acpi_dev->flags.match_driver
894
		&& !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
895
}
L
Linus Torvalds 已提交
896

897
static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
L
Linus Torvalds 已提交
898
{
899
	struct acpi_device *acpi_dev = to_acpi_device(dev);
900
	int len;
901

902 903 904
	if (list_empty(&acpi_dev->pnp.ids))
		return 0;

905 906 907 908
	if (add_uevent_var(env, "MODALIAS="))
		return -ENOMEM;
	len = create_modalias(acpi_dev, &env->buf[env->buflen - 1],
			      sizeof(env->buf) - env->buflen);
909 910
	if (len <= 0)
		return len;
911
	env->buflen += len;
Z
Zhang Rui 已提交
912
	return 0;
L
Linus Torvalds 已提交
913 914
}

915 916 917 918 919 920 921 922 923 924 925
static void acpi_device_notify(acpi_handle handle, u32 event, void *data)
{
	struct acpi_device *device = data;

	device->driver->ops.notify(device, event);
}

static acpi_status acpi_device_notify_fixed(void *data)
{
	struct acpi_device *device = data;

926 927
	/* Fixed hardware devices have no handles */
	acpi_device_notify(NULL, ACPI_FIXED_HARDWARE_EVENT, device);
928 929 930 931 932 933 934
	return AE_OK;
}

static int acpi_device_install_notify_handler(struct acpi_device *device)
{
	acpi_status status;

935
	if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
936 937 938 939
		status =
		    acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
						     acpi_device_notify_fixed,
						     device);
940
	else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957
		status =
		    acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
						     acpi_device_notify_fixed,
						     device);
	else
		status = acpi_install_notify_handler(device->handle,
						     ACPI_DEVICE_NOTIFY,
						     acpi_device_notify,
						     device);

	if (ACPI_FAILURE(status))
		return -EINVAL;
	return 0;
}

static void acpi_device_remove_notify_handler(struct acpi_device *device)
{
958
	if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
959 960
		acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
						acpi_device_notify_fixed);
961
	else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
962 963 964 965 966 967 968
		acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
						acpi_device_notify_fixed);
	else
		acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
					   acpi_device_notify);
}

969
static int acpi_device_probe(struct device *dev)
L
Linus Torvalds 已提交
970
{
971 972 973 974
	struct acpi_device *acpi_dev = to_acpi_device(dev);
	struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
	int ret;

975 976 977
	if (acpi_dev->handler)
		return -EINVAL;

978 979
	if (!acpi_drv->ops.add)
		return -ENOSYS;
980

981 982 983
	ret = acpi_drv->ops.add(acpi_dev);
	if (ret)
		return ret;
984

985 986 987 988 989 990 991 992 993 994 995 996 997 998 999
	acpi_dev->driver = acpi_drv;
	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
			  "Driver [%s] successfully bound to device [%s]\n",
			  acpi_drv->name, acpi_dev->pnp.bus_id));

	if (acpi_drv->ops.notify) {
		ret = acpi_device_install_notify_handler(acpi_dev);
		if (ret) {
			if (acpi_drv->ops.remove)
				acpi_drv->ops.remove(acpi_dev);

			acpi_dev->driver = NULL;
			acpi_dev->driver_data = NULL;
			return ret;
		}
1000
	}
1001 1002 1003 1004 1005

	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found driver [%s] for device [%s]\n",
			  acpi_drv->name, acpi_dev->pnp.bus_id));
	get_device(dev);
	return 0;
1006
}
L
Linus Torvalds 已提交
1007

1008 1009 1010 1011 1012 1013
static int acpi_device_remove(struct device * dev)
{
	struct acpi_device *acpi_dev = to_acpi_device(dev);
	struct acpi_driver *acpi_drv = acpi_dev->driver;

	if (acpi_drv) {
1014 1015
		if (acpi_drv->ops.notify)
			acpi_device_remove_notify_handler(acpi_dev);
1016
		if (acpi_drv->ops.remove)
1017
			acpi_drv->ops.remove(acpi_dev);
L
Linus Torvalds 已提交
1018
	}
1019
	acpi_dev->driver = NULL;
1020
	acpi_dev->driver_data = NULL;
L
Linus Torvalds 已提交
1021

1022
	put_device(dev);
Z
Zhang Rui 已提交
1023 1024
	return 0;
}
L
Linus Torvalds 已提交
1025

1026
struct bus_type acpi_bus_type = {
Z
Zhang Rui 已提交
1027
	.name		= "acpi",
1028 1029 1030 1031
	.match		= acpi_bus_match,
	.probe		= acpi_device_probe,
	.remove		= acpi_device_remove,
	.uevent		= acpi_device_uevent,
Z
Zhang Rui 已提交
1032 1033
};

1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094
static void acpi_device_del(struct acpi_device *device)
{
	mutex_lock(&acpi_device_lock);
	if (device->parent)
		list_del(&device->node);

	list_del(&device->wakeup_list);
	mutex_unlock(&acpi_device_lock);

	acpi_power_add_remove_device(device, false);
	acpi_device_remove_files(device);
	if (device->remove)
		device->remove(device);

	device_del(&device->dev);
}

static LIST_HEAD(acpi_device_del_list);
static DEFINE_MUTEX(acpi_device_del_lock);

static void acpi_device_del_work_fn(struct work_struct *work_not_used)
{
	for (;;) {
		struct acpi_device *adev;

		mutex_lock(&acpi_device_del_lock);

		if (list_empty(&acpi_device_del_list)) {
			mutex_unlock(&acpi_device_del_lock);
			break;
		}
		adev = list_first_entry(&acpi_device_del_list,
					struct acpi_device, del_list);
		list_del(&adev->del_list);

		mutex_unlock(&acpi_device_del_lock);

		acpi_device_del(adev);
		/*
		 * Drop references to all power resources that might have been
		 * used by the device.
		 */
		acpi_power_transition(adev, ACPI_STATE_D3_COLD);
		put_device(&adev->dev);
	}
}

/**
 * acpi_scan_drop_device - Drop an ACPI device object.
 * @handle: Handle of an ACPI namespace node, not used.
 * @context: Address of the ACPI device object to drop.
 *
 * This is invoked by acpi_ns_delete_node() during the removal of the ACPI
 * namespace node the device object pointed to by @context is attached to.
 *
 * The unregistration is carried out asynchronously to avoid running
 * acpi_device_del() under the ACPICA's namespace mutex and the list is used to
 * ensure the correct ordering (the device objects must be unregistered in the
 * same order in which the corresponding namespace nodes are deleted).
 */
static void acpi_scan_drop_device(acpi_handle handle, void *context)
1095
{
1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
	static DECLARE_WORK(work, acpi_device_del_work_fn);
	struct acpi_device *adev = context;

	mutex_lock(&acpi_device_del_lock);

	/*
	 * Use the ACPI hotplug workqueue which is ordered, so this work item
	 * won't run after any hotplug work items submitted subsequently.  That
	 * prevents attempts to register device objects identical to those being
	 * deleted from happening concurrently (such attempts result from
	 * hotplug events handled via the ACPI hotplug workqueue).  It also will
	 * run after all of the work items submitted previosuly, which helps
	 * those work items to ensure that they are not accessing stale device
	 * objects.
	 */
	if (list_empty(&acpi_device_del_list))
		acpi_queue_hotplug_work(&work);

	list_add_tail(&adev->del_list, &acpi_device_del_list);
	/* Make acpi_ns_validate_handle() return NULL for this handle. */
	adev->handle = INVALID_ACPI_HANDLE;

	mutex_unlock(&acpi_device_del_lock);
1119 1120
}

1121 1122
static int acpi_get_device_data(acpi_handle handle, struct acpi_device **device,
				void (*callback)(void *))
1123 1124 1125 1126 1127 1128
{
	acpi_status status;

	if (!device)
		return -EINVAL;

1129 1130
	status = acpi_get_data_full(handle, acpi_scan_drop_device,
				    (void **)device, callback);
1131 1132 1133 1134 1135 1136 1137
	if (ACPI_FAILURE(status) || !*device) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
				  handle));
		return -ENODEV;
	}
	return 0;
}
1138 1139 1140 1141 1142

int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
{
	return acpi_get_device_data(handle, device, NULL);
}
1143
EXPORT_SYMBOL(acpi_bus_get_device);
1144

1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
static void get_acpi_device(void *dev)
{
	if (dev)
		get_device(&((struct acpi_device *)dev)->dev);
}

struct acpi_device *acpi_bus_get_acpi_device(acpi_handle handle)
{
	struct acpi_device *adev = NULL;

	acpi_get_device_data(handle, &adev, get_acpi_device);
	return adev;
}

void acpi_bus_put_acpi_device(struct acpi_device *adev)
{
	put_device(&adev->dev);
}

1164 1165
int acpi_device_add(struct acpi_device *device,
		    void (*release)(struct device *))
L
Linus Torvalds 已提交
1166
{
L
Len Brown 已提交
1167
	int result;
1168 1169
	struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
	int found = 0;
1170

1171 1172 1173
	if (device->handle) {
		acpi_status status;

1174
		status = acpi_attach_data(device->handle, acpi_scan_drop_device,
1175 1176 1177 1178 1179 1180 1181 1182
					  device);
		if (ACPI_FAILURE(status)) {
			acpi_handle_err(device->handle,
					"Unable to attach device data\n");
			return -ENODEV;
		}
	}

Z
Zhang Rui 已提交
1183 1184 1185 1186 1187 1188 1189 1190
	/*
	 * Linkage
	 * -------
	 * Link this device to its parent and siblings.
	 */
	INIT_LIST_HEAD(&device->children);
	INIT_LIST_HEAD(&device->node);
	INIT_LIST_HEAD(&device->wakeup_list);
1191
	INIT_LIST_HEAD(&device->physical_node_list);
1192
	INIT_LIST_HEAD(&device->del_list);
1193
	mutex_init(&device->physical_node_lock);
L
Linus Torvalds 已提交
1194

1195 1196
	new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
	if (!new_bus_id) {
1197 1198 1199
		pr_err(PREFIX "Memory allocation error\n");
		result = -ENOMEM;
		goto err_detach;
L
Linus Torvalds 已提交
1200
	}
1201

1202
	mutex_lock(&acpi_device_lock);
1203 1204 1205 1206 1207
	/*
	 * Find suitable bus_id and instance number in acpi_bus_id_list
	 * If failed, create one and link it into acpi_bus_id_list
	 */
	list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) {
1208 1209 1210
		if (!strcmp(acpi_device_bus_id->bus_id,
			    acpi_device_hid(device))) {
			acpi_device_bus_id->instance_no++;
1211 1212 1213 1214
			found = 1;
			kfree(new_bus_id);
			break;
		}
L
Linus Torvalds 已提交
1215
	}
1216
	if (!found) {
1217
		acpi_device_bus_id = new_bus_id;
1218
		strcpy(acpi_device_bus_id->bus_id, acpi_device_hid(device));
1219 1220
		acpi_device_bus_id->instance_no = 0;
		list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
L
Linus Torvalds 已提交
1221
	}
1222
	dev_set_name(&device->dev, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no);
L
Linus Torvalds 已提交
1223

L
Len Brown 已提交
1224
	if (device->parent)
Z
Zhang Rui 已提交
1225
		list_add_tail(&device->node, &device->parent->children);
L
Len Brown 已提交
1226

Z
Zhang Rui 已提交
1227 1228
	if (device->wakeup.flags.valid)
		list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list);
1229
	mutex_unlock(&acpi_device_lock);
L
Linus Torvalds 已提交
1230

1231
	if (device->parent)
1232
		device->dev.parent = &device->parent->dev;
1233
	device->dev.bus = &acpi_bus_type;
1234
	device->dev.release = release;
1235
	result = device_add(&device->dev);
1236
	if (result) {
1237
		dev_err(&device->dev, "Error registering device\n");
1238
		goto err;
L
Linus Torvalds 已提交
1239 1240
	}

1241
	result = acpi_device_setup_files(device);
1242
	if (result)
1243 1244
		printk(KERN_ERR PREFIX "Error creating sysfs interface for device %s\n",
		       dev_name(&device->dev));
L
Linus Torvalds 已提交
1245 1246

	return 0;
1247 1248

 err:
1249
	mutex_lock(&acpi_device_lock);
L
Len Brown 已提交
1250
	if (device->parent)
1251 1252
		list_del(&device->node);
	list_del(&device->wakeup_list);
1253
	mutex_unlock(&acpi_device_lock);
1254 1255

 err_detach:
1256
	acpi_detach_data(device->handle, acpi_scan_drop_device);
1257
	return result;
L
Linus Torvalds 已提交
1258 1259
}

Z
Zhang Rui 已提交
1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
/* --------------------------------------------------------------------------
                                 Driver Management
   -------------------------------------------------------------------------- */
/**
 * acpi_bus_register_driver - register a driver with the ACPI bus
 * @driver: driver being registered
 *
 * Registers a driver with the ACPI bus.  Searches the namespace for all
 * devices that match the driver's criteria and binds.  Returns zero for
 * success or a negative error status for failure.
 */
int acpi_bus_register_driver(struct acpi_driver *driver)
L
Linus Torvalds 已提交
1272
{
1273
	int ret;
L
Linus Torvalds 已提交
1274

Z
Zhang Rui 已提交
1275 1276
	if (acpi_disabled)
		return -ENODEV;
1277 1278 1279
	driver->drv.name = driver->name;
	driver->drv.bus = &acpi_bus_type;
	driver->drv.owner = driver->owner;
L
Linus Torvalds 已提交
1280

1281 1282
	ret = driver_register(&driver->drv);
	return ret;
Z
Zhang Rui 已提交
1283
}
L
Linus Torvalds 已提交
1284

Z
Zhang Rui 已提交
1285 1286 1287
EXPORT_SYMBOL(acpi_bus_register_driver);

/**
1288
 * acpi_bus_unregister_driver - unregisters a driver with the ACPI bus
Z
Zhang Rui 已提交
1289 1290 1291 1292 1293 1294 1295
 * @driver: driver to unregister
 *
 * Unregisters a driver with the ACPI bus.  Searches the namespace for all
 * devices that match the driver's criteria and unbinds.
 */
void acpi_bus_unregister_driver(struct acpi_driver *driver)
{
1296
	driver_unregister(&driver->drv);
Z
Zhang Rui 已提交
1297 1298 1299 1300 1301 1302 1303
}

EXPORT_SYMBOL(acpi_bus_unregister_driver);

/* --------------------------------------------------------------------------
                                 Device Enumeration
   -------------------------------------------------------------------------- */
1304 1305
static struct acpi_device *acpi_bus_get_parent(acpi_handle handle)
{
1306
	struct acpi_device *device = NULL;
1307 1308 1309 1310 1311 1312 1313
	acpi_status status;

	/*
	 * Fixed hardware devices do not appear in the namespace and do not
	 * have handles, but we fabricate acpi_devices for them, so we have
	 * to deal with them specially.
	 */
1314
	if (!handle)
1315 1316 1317 1318 1319
		return acpi_root;

	do {
		status = acpi_get_parent(handle, &handle);
		if (ACPI_FAILURE(status))
1320 1321 1322
			return status == AE_NULL_ENTRY ? NULL : acpi_root;
	} while (acpi_bus_get_device(handle, &device));
	return device;
1323 1324
}

Z
Zhang Rui 已提交
1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
acpi_status
acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
{
	acpi_status status;
	acpi_handle tmp;
	struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
	union acpi_object *obj;

	status = acpi_get_handle(handle, "_EJD", &tmp);
	if (ACPI_FAILURE(status))
		return status;

	status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer);
	if (ACPI_SUCCESS(status)) {
		obj = buffer.pointer;
1340 1341
		status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer,
					 ejd);
Z
Zhang Rui 已提交
1342 1343 1344 1345 1346 1347
		kfree(buffer.pointer);
	}
	return status;
}
EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);

1348 1349
static int acpi_bus_extract_wakeup_device_power_package(acpi_handle handle,
					struct acpi_device_wakeup *wakeup)
Z
Zhang Rui 已提交
1350
{
1351 1352
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *package = NULL;
Z
Zhang Rui 已提交
1353
	union acpi_object *element = NULL;
1354
	acpi_status status;
1355
	int err = -ENODATA;
Z
Zhang Rui 已提交
1356

1357
	if (!wakeup)
1358
		return -EINVAL;
Z
Zhang Rui 已提交
1359

1360
	INIT_LIST_HEAD(&wakeup->resources);
Z
Zhang Rui 已提交
1361

1362 1363 1364 1365
	/* _PRW */
	status = acpi_evaluate_object(handle, "_PRW", NULL, &buffer);
	if (ACPI_FAILURE(status)) {
		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW"));
1366
		return err;
1367 1368 1369 1370
	}

	package = (union acpi_object *)buffer.pointer;

1371
	if (!package || package->package.count < 2)
1372 1373
		goto out;

Z
Zhang Rui 已提交
1374
	element = &(package->package.elements[0]);
1375
	if (!element)
1376
		goto out;
1377

Z
Zhang Rui 已提交
1378 1379 1380 1381
	if (element->type == ACPI_TYPE_PACKAGE) {
		if ((element->package.count < 2) ||
		    (element->package.elements[0].type !=
		     ACPI_TYPE_LOCAL_REFERENCE)
1382
		    || (element->package.elements[1].type != ACPI_TYPE_INTEGER))
1383
			goto out;
1384

1385
		wakeup->gpe_device =
Z
Zhang Rui 已提交
1386
		    element->package.elements[0].reference.handle;
1387
		wakeup->gpe_number =
Z
Zhang Rui 已提交
1388 1389
		    (u32) element->package.elements[1].integer.value;
	} else if (element->type == ACPI_TYPE_INTEGER) {
1390 1391 1392 1393 1394
		wakeup->gpe_device = NULL;
		wakeup->gpe_number = element->integer.value;
	} else {
		goto out;
	}
Z
Zhang Rui 已提交
1395 1396

	element = &(package->package.elements[1]);
1397
	if (element->type != ACPI_TYPE_INTEGER)
1398
		goto out;
1399

1400
	wakeup->sleep_state = element->integer.value;
Z
Zhang Rui 已提交
1401

1402 1403
	err = acpi_extract_power_resources(package, 2, &wakeup->resources);
	if (err)
1404
		goto out;
Z
Zhang Rui 已提交
1405

1406 1407
	if (!list_empty(&wakeup->resources)) {
		int sleep_state;
Z
Zhang Rui 已提交
1408

1409 1410 1411 1412 1413 1414 1415 1416
		err = acpi_power_wakeup_list_init(&wakeup->resources,
						  &sleep_state);
		if (err) {
			acpi_handle_warn(handle, "Retrieving current states "
					 "of wakeup power resources failed\n");
			acpi_power_resources_list_free(&wakeup->resources);
			goto out;
		}
1417 1418 1419 1420 1421 1422 1423
		if (sleep_state < wakeup->sleep_state) {
			acpi_handle_warn(handle, "Overriding _PRW sleep state "
					 "(S%d) by S%d from power resources\n",
					 (int)wakeup->sleep_state, sleep_state);
			wakeup->sleep_state = sleep_state;
		}
	}
L
Lin Ming 已提交
1424
	acpi_setup_gpe_for_wake(handle, wakeup->gpe_device, wakeup->gpe_number);
1425

1426 1427
 out:
	kfree(buffer.pointer);
1428
	return err;
L
Linus Torvalds 已提交
1429 1430
}

1431
static void acpi_bus_set_run_wake_flags(struct acpi_device *device)
L
Linus Torvalds 已提交
1432
{
1433 1434
	struct acpi_device_id button_device_ids[] = {
		{"PNP0C0C", 0},
1435
		{"PNP0C0D", 0},
1436 1437 1438
		{"PNP0C0E", 0},
		{"", 0},
	};
1439 1440 1441
	acpi_status status;
	acpi_event_status event_status;

1442
	device->wakeup.flags.notifier_present = 0;
1443 1444 1445 1446

	/* Power button, Lid switch always enable wakeup */
	if (!acpi_match_device_ids(device, button_device_ids)) {
		device->wakeup.flags.run_wake = 1;
1447 1448 1449 1450 1451
		if (!acpi_match_device_ids(device, &button_device_ids[1])) {
			/* Do not use Lid/sleep button for S5 wakeup */
			if (device->wakeup.sleep_state == ACPI_STATE_S5)
				device->wakeup.sleep_state = ACPI_STATE_S4;
		}
1452
		device_set_wakeup_capable(&device->dev, true);
1453 1454 1455
		return;
	}

1456 1457 1458
	status = acpi_get_gpe_status(device->wakeup.gpe_device,
					device->wakeup.gpe_number,
						&event_status);
1459 1460 1461 1462 1463
	if (status == AE_OK)
		device->wakeup.flags.run_wake =
				!!(event_status & ACPI_EVENT_FLAG_HANDLE);
}

1464
static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
1465
{
1466
	int err;
1467

1468
	/* Presence of _PRW indicates wake capable */
1469
	if (!acpi_has_method(device->handle, "_PRW"))
1470 1471
		return;

1472 1473 1474 1475
	err = acpi_bus_extract_wakeup_device_power_package(device->handle,
							   &device->wakeup);
	if (err) {
		dev_err(&device->dev, "_PRW evaluation error: %d\n", err);
1476
		return;
Z
Zhang Rui 已提交
1477
	}
L
Linus Torvalds 已提交
1478

Z
Zhang Rui 已提交
1479
	device->wakeup.flags.valid = 1;
1480
	device->wakeup.prepare_count = 0;
1481
	acpi_bus_set_run_wake_flags(device);
1482 1483 1484 1485 1486 1487
	/* Call _PSW/_DSW object to disable its ability to wake the sleeping
	 * system for the ACPI device with the _PRW object.
	 * The _PSW object is depreciated in ACPI 3.0 and is replaced by _DSW.
	 * So it is necessary to call _DSW object first. Only when it is not
	 * present will the _PSW object used.
	 */
1488 1489
	err = acpi_device_sleep_wake(device, 0, 0, 0);
	if (err)
1490 1491
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				"error in _DSW or _PSW evaluation\n"));
L
Linus Torvalds 已提交
1492 1493
}

1494 1495 1496
static void acpi_bus_init_power_state(struct acpi_device *device, int state)
{
	struct acpi_device_power_state *ps = &device->power.states[state];
1497 1498
	char pathname[5] = { '_', 'P', 'R', '0' + state, '\0' };
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1499
	acpi_status status;
1500

1501 1502
	INIT_LIST_HEAD(&ps->resources);

1503 1504 1505 1506 1507 1508 1509 1510
	/* Evaluate "_PRx" to get referenced power resources */
	status = acpi_evaluate_object(device->handle, pathname, NULL, &buffer);
	if (ACPI_SUCCESS(status)) {
		union acpi_object *package = buffer.pointer;

		if (buffer.length && package
		    && package->type == ACPI_TYPE_PACKAGE
		    && package->package.count) {
1511 1512 1513
			int err = acpi_extract_power_resources(package, 0,
							       &ps->resources);
			if (!err)
1514
				device->power.flags.power_resources = 1;
1515
		}
1516
		ACPI_FREE(buffer.pointer);
1517 1518 1519
	}

	/* Evaluate "_PSx" to see if we can do explicit sets */
1520
	pathname[2] = 'S';
1521
	if (acpi_has_method(device->handle, pathname))
1522 1523 1524 1525 1526 1527
		ps->flags.explicit_set = 1;

	/*
	 * State is valid if there are means to put the device into it.
	 * D3hot is only valid if _PR3 present.
	 */
1528
	if (!list_empty(&ps->resources)
1529 1530 1531 1532 1533 1534 1535 1536 1537
	    || (ps->flags.explicit_set && state < ACPI_STATE_D3_HOT)) {
		ps->flags.valid = 1;
		ps->flags.os_accessible = 1;
	}

	ps->power = -1;		/* Unknown - driver assigned */
	ps->latency = -1;	/* Unknown - driver assigned */
}

1538
static void acpi_bus_get_power_flags(struct acpi_device *device)
L
Linus Torvalds 已提交
1539
{
1540
	u32 i;
B
Bjorn Helgaas 已提交
1541

1542
	/* Presence of _PS0|_PR0 indicates 'power manageable' */
1543 1544 1545
	if (!acpi_has_method(device->handle, "_PS0") &&
	    !acpi_has_method(device->handle, "_PR0"))
		return;
B
Bjorn Helgaas 已提交
1546

1547
	device->flags.power_manageable = 1;
L
Len Brown 已提交
1548

Z
Zhang Rui 已提交
1549 1550 1551
	/*
	 * Power Management Flags
	 */
1552
	if (acpi_has_method(device->handle, "_PSC"))
Z
Zhang Rui 已提交
1553
		device->power.flags.explicit_get = 1;
1554
	if (acpi_has_method(device->handle, "_IRC"))
Z
Zhang Rui 已提交
1555
		device->power.flags.inrush_current = 1;
L
Linus Torvalds 已提交
1556

Z
Zhang Rui 已提交
1557 1558 1559
	/*
	 * Enumerate supported power management states
	 */
1560 1561
	for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++)
		acpi_bus_init_power_state(device, i);
1562

1563
	INIT_LIST_HEAD(&device->power.states[ACPI_STATE_D3_COLD].resources);
L
Linus Torvalds 已提交
1564

Z
Zhang Rui 已提交
1565 1566 1567
	/* Set defaults for D0 and D3 states (always valid) */
	device->power.states[ACPI_STATE_D0].flags.valid = 1;
	device->power.states[ACPI_STATE_D0].power = 100;
1568 1569
	device->power.states[ACPI_STATE_D3_COLD].flags.valid = 1;
	device->power.states[ACPI_STATE_D3_COLD].power = 0;
L
Len Brown 已提交
1570

1571 1572 1573 1574
	/* Set D3cold's explicit_set flag if _PS3 exists. */
	if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set)
		device->power.states[ACPI_STATE_D3_COLD].flags.explicit_set = 1;

1575 1576 1577 1578 1579
	/* Presence of _PS3 or _PRx means we can put the device into D3 cold */
	if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set ||
			device->power.flags.power_resources)
		device->power.states[ACPI_STATE_D3_COLD].flags.os_accessible = 1;

1580 1581 1582 1583
	if (acpi_bus_init_power(device)) {
		acpi_free_power_resources_lists(device);
		device->flags.power_manageable = 0;
	}
Z
Zhang Rui 已提交
1584
}
L
Len Brown 已提交
1585

1586
static void acpi_bus_get_flags(struct acpi_device *device)
L
Linus Torvalds 已提交
1587 1588
{
	/* Presence of _STA indicates 'dynamic_status' */
1589
	if (acpi_has_method(device->handle, "_STA"))
L
Linus Torvalds 已提交
1590 1591 1592
		device->flags.dynamic_status = 1;

	/* Presence of _RMV indicates 'removable' */
1593
	if (acpi_has_method(device->handle, "_RMV"))
L
Linus Torvalds 已提交
1594 1595 1596
		device->flags.removable = 1;

	/* Presence of _EJD|_EJ0 indicates 'ejectable' */
1597 1598
	if (acpi_has_method(device->handle, "_EJD") ||
	    acpi_has_method(device->handle, "_EJ0"))
L
Linus Torvalds 已提交
1599 1600 1601
		device->flags.ejectable = 1;
}

1602
static void acpi_device_get_busid(struct acpi_device *device)
L
Linus Torvalds 已提交
1603
{
L
Len Brown 已提交
1604 1605 1606
	char bus_id[5] = { '?', 0 };
	struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
	int i = 0;
L
Linus Torvalds 已提交
1607 1608 1609 1610 1611 1612 1613

	/*
	 * Bus ID
	 * ------
	 * The device's Bus ID is simply the object name.
	 * TBD: Shouldn't this value be unique (within the ACPI namespace)?
	 */
1614
	if (ACPI_IS_ROOT_DEVICE(device)) {
L
Linus Torvalds 已提交
1615
		strcpy(device->pnp.bus_id, "ACPI");
1616 1617 1618 1619
		return;
	}

	switch (device->device_type) {
L
Linus Torvalds 已提交
1620 1621 1622 1623 1624 1625 1626
	case ACPI_BUS_TYPE_POWER_BUTTON:
		strcpy(device->pnp.bus_id, "PWRF");
		break;
	case ACPI_BUS_TYPE_SLEEP_BUTTON:
		strcpy(device->pnp.bus_id, "SLPF");
		break;
	default:
1627
		acpi_get_name(device->handle, ACPI_SINGLE_NAME, &buffer);
L
Linus Torvalds 已提交
1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639
		/* Clean up trailing underscores (if any) */
		for (i = 3; i > 1; i--) {
			if (bus_id[i] == '_')
				bus_id[i] = '\0';
			else
				break;
		}
		strcpy(device->pnp.bus_id, bus_id);
		break;
	}
}

1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653
/*
 * acpi_ata_match - see if an acpi object is an ATA device
 *
 * If an acpi object has one of the ACPI ATA methods defined,
 * then we can safely call it an ATA device.
 */
bool acpi_ata_match(acpi_handle handle)
{
	return acpi_has_method(handle, "_GTF") ||
	       acpi_has_method(handle, "_GTM") ||
	       acpi_has_method(handle, "_STM") ||
	       acpi_has_method(handle, "_SDD");
}

1654
/*
1655
 * acpi_bay_match - see if an acpi object is an ejectable driver bay
1656 1657 1658 1659
 *
 * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
 * then we can safely call it an ejectable drive bay
 */
1660
bool acpi_bay_match(acpi_handle handle)
1661
{
1662 1663
	acpi_handle phandle;

1664
	if (!acpi_has_method(handle, "_EJ0"))
1665 1666 1667 1668 1669
		return false;
	if (acpi_ata_match(handle))
		return true;
	if (ACPI_FAILURE(acpi_get_parent(handle, &phandle)))
		return false;
1670

1671
	return acpi_ata_match(phandle);
1672 1673
}

1674
bool acpi_device_is_battery(struct acpi_device *adev)
1675
{
1676
	struct acpi_hardware_id *hwid;
1677

1678 1679 1680
	list_for_each_entry(hwid, &adev->pnp.ids, list)
		if (!strcmp("PNP0C0A", hwid->id))
			return true;
1681

1682
	return false;
1683 1684
}

1685
static bool is_ejectable_bay(struct acpi_device *adev)
1686
{
1687 1688 1689
	acpi_handle handle = adev->handle;

	if (acpi_has_method(handle, "_EJ0") && acpi_device_is_battery(adev))
1690 1691 1692 1693 1694
		return true;

	return acpi_bay_match(handle);
}

1695
/*
1696
 * acpi_dock_match - see if an acpi object has a _DCK method
1697
 */
1698
bool acpi_dock_match(acpi_handle handle)
1699
{
1700
	return acpi_has_method(handle, "_DCK");
1701 1702
}

1703
const char *acpi_device_hid(struct acpi_device *device)
1704
{
1705
	struct acpi_hardware_id *hid;
1706

1707 1708 1709
	if (list_empty(&device->pnp.ids))
		return dummy_hid;

1710 1711 1712 1713
	hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list);
	return hid->id;
}
EXPORT_SYMBOL(acpi_device_hid);
1714

1715
static void acpi_add_id(struct acpi_device_pnp *pnp, const char *dev_id)
1716 1717
{
	struct acpi_hardware_id *id;
1718

1719 1720 1721
	id = kmalloc(sizeof(*id), GFP_KERNEL);
	if (!id)
		return;
1722

T
Thomas Meyer 已提交
1723
	id->id = kstrdup(dev_id, GFP_KERNEL);
1724 1725 1726
	if (!id->id) {
		kfree(id);
		return;
1727 1728
	}

1729 1730
	list_add_tail(&id->list, &pnp->ids);
	pnp->type.hardware_id = 1;
1731 1732
}

1733 1734 1735 1736 1737
/*
 * Old IBM workstations have a DSDT bug wherein the SMBus object
 * lacks the SMBUS01 HID and the methods do not have the necessary "_"
 * prefix.  Work around this.
 */
1738
static bool acpi_ibm_smbus_match(acpi_handle handle)
1739
{
1740 1741
	char node_name[ACPI_PATH_SEGMENT_LENGTH];
	struct acpi_buffer path = { sizeof(node_name), node_name };
1742 1743

	if (!dmi_name_in_vendors("IBM"))
1744
		return false;
1745 1746

	/* Look for SMBS object */
1747 1748 1749
	if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &path)) ||
	    strcmp("SMBS", path.pointer))
		return false;
1750 1751

	/* Does it have the necessary (but misnamed) methods? */
1752 1753 1754
	if (acpi_has_method(handle, "SBI") &&
	    acpi_has_method(handle, "SBR") &&
	    acpi_has_method(handle, "SBW"))
1755 1756 1757
		return true;

	return false;
1758 1759
}

1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773
static bool acpi_object_is_system_bus(acpi_handle handle)
{
	acpi_handle tmp;

	if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_SB", &tmp)) &&
	    tmp == handle)
		return true;
	if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_TZ", &tmp)) &&
	    tmp == handle)
		return true;

	return false;
}

1774 1775
static void acpi_set_pnp_ids(acpi_handle handle, struct acpi_device_pnp *pnp,
				int device_type)
L
Linus Torvalds 已提交
1776
{
L
Len Brown 已提交
1777
	acpi_status status;
1778
	struct acpi_device_info *info;
1779
	struct acpi_pnp_device_id_list *cid_list;
1780
	int i;
L
Linus Torvalds 已提交
1781

1782
	switch (device_type) {
L
Linus Torvalds 已提交
1783
	case ACPI_BUS_TYPE_DEVICE:
1784 1785
		if (handle == ACPI_ROOT_OBJECT) {
			acpi_add_id(pnp, ACPI_SYSTEM_HID);
1786 1787 1788
			break;
		}

1789
		status = acpi_get_object_info(handle, &info);
L
Linus Torvalds 已提交
1790
		if (ACPI_FAILURE(status)) {
1791 1792
			pr_err(PREFIX "%s: Error reading device info\n",
					__func__);
L
Linus Torvalds 已提交
1793 1794 1795 1796
			return;
		}

		if (info->valid & ACPI_VALID_HID)
1797
			acpi_add_id(pnp, info->hardware_id.string);
1798
		if (info->valid & ACPI_VALID_CID) {
1799
			cid_list = &info->compatible_id_list;
1800
			for (i = 0; i < cid_list->count; i++)
1801
				acpi_add_id(pnp, cid_list->ids[i].string);
1802
		}
L
Linus Torvalds 已提交
1803
		if (info->valid & ACPI_VALID_ADR) {
1804 1805
			pnp->bus_address = info->address;
			pnp->type.bus_address = 1;
L
Linus Torvalds 已提交
1806
		}
1807
		if (info->valid & ACPI_VALID_UID)
1808
			pnp->unique_id = kstrdup(info->unique_id.string,
1809
							GFP_KERNEL);
1810

1811 1812
		kfree(info);

1813 1814 1815 1816
		/*
		 * Some devices don't reliably have _HIDs & _CIDs, so add
		 * synthetic HIDs to make sure drivers can find them.
		 */
1817 1818
		if (acpi_is_video_device(handle))
			acpi_add_id(pnp, ACPI_VIDEO_HID);
1819
		else if (acpi_bay_match(handle))
1820
			acpi_add_id(pnp, ACPI_BAY_HID);
1821
		else if (acpi_dock_match(handle))
1822
			acpi_add_id(pnp, ACPI_DOCK_HID);
1823
		else if (acpi_ibm_smbus_match(handle))
1824
			acpi_add_id(pnp, ACPI_SMBUS_IBM_HID);
1825 1826 1827 1828
		else if (list_empty(&pnp->ids) &&
			 acpi_object_is_system_bus(handle)) {
			/* \_SB, \_TZ, LNXSYBUS */
			acpi_add_id(pnp, ACPI_BUS_HID);
1829 1830
			strcpy(pnp->device_name, ACPI_BUS_DEVICE_NAME);
			strcpy(pnp->device_class, ACPI_BUS_CLASS);
1831
		}
1832

L
Linus Torvalds 已提交
1833 1834
		break;
	case ACPI_BUS_TYPE_POWER:
1835
		acpi_add_id(pnp, ACPI_POWER_HID);
L
Linus Torvalds 已提交
1836 1837
		break;
	case ACPI_BUS_TYPE_PROCESSOR:
1838
		acpi_add_id(pnp, ACPI_PROCESSOR_OBJECT_HID);
L
Linus Torvalds 已提交
1839 1840
		break;
	case ACPI_BUS_TYPE_THERMAL:
1841
		acpi_add_id(pnp, ACPI_THERMAL_HID);
L
Linus Torvalds 已提交
1842 1843
		break;
	case ACPI_BUS_TYPE_POWER_BUTTON:
1844
		acpi_add_id(pnp, ACPI_BUTTON_HID_POWERF);
L
Linus Torvalds 已提交
1845 1846
		break;
	case ACPI_BUS_TYPE_SLEEP_BUTTON:
1847
		acpi_add_id(pnp, ACPI_BUTTON_HID_SLEEPF);
L
Linus Torvalds 已提交
1848 1849 1850 1851
		break;
	}
}

1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862
void acpi_free_pnp_ids(struct acpi_device_pnp *pnp)
{
	struct acpi_hardware_id *id, *tmp;

	list_for_each_entry_safe(id, tmp, &pnp->ids, list) {
		kfree(id->id);
		kfree(id);
	}
	kfree(pnp->unique_id);
}

1863 1864
void acpi_init_device_object(struct acpi_device *device, acpi_handle handle,
			     int type, unsigned long long sta)
L
Linus Torvalds 已提交
1865
{
1866 1867 1868 1869
	INIT_LIST_HEAD(&device->pnp.ids);
	device->device_type = type;
	device->handle = handle;
	device->parent = acpi_bus_get_parent(handle);
1870
	acpi_set_device_status(device, sta);
1871
	acpi_device_get_busid(device);
1872
	acpi_set_pnp_ids(handle, &device->pnp, type);
1873
	acpi_bus_get_flags(device);
1874
	device->flags.match_driver = false;
1875 1876
	device->flags.initialized = true;
	device->flags.visited = false;
1877 1878 1879
	device_initialize(&device->dev);
	dev_set_uevent_suppress(&device->dev, true);
}
1880

1881 1882 1883 1884
void acpi_device_add_finalize(struct acpi_device *device)
{
	dev_set_uevent_suppress(&device->dev, false);
	kobject_uevent(&device->dev.kobj, KOBJ_ADD);
L
Linus Torvalds 已提交
1885 1886
}

1887 1888
static int acpi_add_single_object(struct acpi_device **child,
				  acpi_handle handle, int type,
1889
				  unsigned long long sta)
L
Linus Torvalds 已提交
1890
{
1891 1892
	int result;
	struct acpi_device *device;
1893
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
L
Linus Torvalds 已提交
1894

1895
	device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
L
Linus Torvalds 已提交
1896
	if (!device) {
1897
		printk(KERN_ERR PREFIX "Memory allocation error\n");
1898
		return -ENOMEM;
L
Linus Torvalds 已提交
1899 1900
	}

1901 1902
	acpi_init_device_object(device, handle, type, sta);
	acpi_bus_get_power_flags(device);
1903
	acpi_bus_get_wakeup_device_flags(device);
L
Linus Torvalds 已提交
1904

1905
	result = acpi_device_add(device, acpi_device_release);
1906
	if (result) {
1907
		acpi_device_release(&device->dev);
1908 1909
		return result;
	}
L
Linus Torvalds 已提交
1910

1911
	acpi_power_add_remove_device(device, true);
1912
	acpi_device_add_finalize(device);
1913 1914 1915 1916 1917 1918 1919
	acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Added %s [%s] parent %s\n",
		dev_name(&device->dev), (char *) buffer.pointer,
		device->parent ? dev_name(&device->parent->dev) : "(null)"));
	kfree(buffer.pointer);
	*child = device;
	return 0;
1920 1921
}

1922 1923
static int acpi_bus_type_and_status(acpi_handle handle, int *type,
				    unsigned long long *sta)
L
Linus Torvalds 已提交
1924
{
1925 1926
	acpi_status status;
	acpi_object_type acpi_type;
L
Linus Torvalds 已提交
1927

1928
	status = acpi_get_type(handle, &acpi_type);
1929
	if (ACPI_FAILURE(status))
1930
		return -ENODEV;
L
Len Brown 已提交
1931

1932
	switch (acpi_type) {
1933 1934
	case ACPI_TYPE_ANY:		/* for ACPI_ROOT_OBJECT */
	case ACPI_TYPE_DEVICE:
1935 1936 1937 1938
		*type = ACPI_BUS_TYPE_DEVICE;
		status = acpi_bus_get_status_handle(handle, sta);
		if (ACPI_FAILURE(status))
			return -ENODEV;
1939 1940
		break;
	case ACPI_TYPE_PROCESSOR:
1941 1942 1943 1944
		*type = ACPI_BUS_TYPE_PROCESSOR;
		status = acpi_bus_get_status_handle(handle, sta);
		if (ACPI_FAILURE(status))
			return -ENODEV;
1945 1946
		break;
	case ACPI_TYPE_THERMAL:
1947 1948
		*type = ACPI_BUS_TYPE_THERMAL;
		*sta = ACPI_STA_DEFAULT;
1949 1950
		break;
	case ACPI_TYPE_POWER:
1951 1952
		*type = ACPI_BUS_TYPE_POWER;
		*sta = ACPI_STA_DEFAULT;
1953 1954
		break;
	default:
1955
		return -ENODEV;
1956
	}
L
Linus Torvalds 已提交
1957

1958 1959 1960
	return 0;
}

1961 1962 1963 1964 1965 1966 1967 1968 1969
bool acpi_device_is_present(struct acpi_device *adev)
{
	if (adev->status.present || adev->status.functional)
		return true;

	adev->flags.initialized = false;
	return false;
}

1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986
static bool acpi_scan_handler_matching(struct acpi_scan_handler *handler,
				       char *idstr,
				       const struct acpi_device_id **matchid)
{
	const struct acpi_device_id *devid;

	for (devid = handler->ids; devid->id[0]; devid++)
		if (!strcmp((char *)devid->id, idstr)) {
			if (matchid)
				*matchid = devid;

			return true;
		}

	return false;
}

1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998
static struct acpi_scan_handler *acpi_scan_match_handler(char *idstr,
					const struct acpi_device_id **matchid)
{
	struct acpi_scan_handler *handler;

	list_for_each_entry(handler, &acpi_scan_handlers_list, list_node)
		if (acpi_scan_handler_matching(handler, idstr, matchid))
			return handler;

	return NULL;
}

1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010
void acpi_scan_hotplug_enabled(struct acpi_hotplug_profile *hotplug, bool val)
{
	if (!!hotplug->enabled == !!val)
		return;

	mutex_lock(&acpi_scan_lock);

	hotplug->enabled = val;

	mutex_unlock(&acpi_scan_lock);
}

2011
static void acpi_scan_init_hotplug(struct acpi_device *adev)
2012
{
2013
	struct acpi_hardware_id *hwid;
2014

2015
	if (acpi_dock_match(adev->handle) || is_ejectable_bay(adev)) {
2016 2017 2018
		acpi_dock_add(adev);
		return;
	}
2019 2020
	list_for_each_entry(hwid, &adev->pnp.ids, list) {
		struct acpi_scan_handler *handler;
2021

2022
		handler = acpi_scan_match_handler(hwid->id, NULL);
2023 2024 2025 2026
		if (handler) {
			adev->flags.hotplug_notify = true;
			break;
		}
2027
	}
2028 2029
}

2030 2031
static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl_not_used,
				      void *not_used, void **return_value)
2032
{
2033
	struct acpi_device *device = NULL;
2034 2035 2036 2037
	int type;
	unsigned long long sta;
	int result;

2038 2039 2040 2041
	acpi_bus_get_device(handle, &device);
	if (device)
		goto out;

2042 2043 2044 2045
	result = acpi_bus_type_and_status(handle, &type, &sta);
	if (result)
		return AE_OK;

2046 2047 2048 2049 2050
	if (type == ACPI_BUS_TYPE_POWER) {
		acpi_add_power_resource(handle);
		return AE_OK;
	}

2051
	acpi_add_single_object(&device, handle, type, sta);
2052
	if (!device)
2053
		return AE_CTRL_DEPTH;
L
Linus Torvalds 已提交
2054

2055 2056
	acpi_scan_init_hotplug(device);

2057
 out:
2058 2059
	if (!*return_value)
		*return_value = device;
2060

2061 2062
	return AE_OK;
}
2063

2064
static int acpi_scan_attach_handler(struct acpi_device *device)
2065
{
2066 2067
	struct acpi_hardware_id *hwid;
	int ret = 0;
2068

2069
	list_for_each_entry(hwid, &device->pnp.ids, list) {
2070
		const struct acpi_device_id *devid;
2071
		struct acpi_scan_handler *handler;
2072

2073 2074
		handler = acpi_scan_match_handler(hwid->id, &devid);
		if (handler) {
2075
			device->handler = handler;
2076
			ret = handler->attach(device, devid);
2077
			if (ret > 0)
2078
				break;
2079 2080 2081

			device->handler = NULL;
			if (ret < 0)
2082
				break;
2083 2084 2085 2086 2087
		}
	}
	return ret;
}

2088
static void acpi_bus_attach(struct acpi_device *device)
2089
{
2090
	struct acpi_device *child;
2091
	acpi_handle ejd;
2092
	int ret;
2093

2094 2095 2096
	if (ACPI_SUCCESS(acpi_bus_get_ejd(device->handle, &ejd)))
		register_dock_dependent_device(device, ejd);

2097
	acpi_bus_get_status(device);
2098
	/* Skip devices that are not present. */
2099 2100 2101 2102
	if (!acpi_device_is_present(device)) {
		device->flags.visited = false;
		return;
	}
2103
	if (device->handler)
2104
		goto ok;
2105

2106 2107 2108 2109
	if (!device->flags.initialized) {
		acpi_bus_update_power(device, NULL);
		device->flags.initialized = true;
	}
2110
	device->flags.visited = false;
2111
	ret = acpi_scan_attach_handler(device);
2112
	if (ret < 0)
2113
		return;
2114 2115

	device->flags.match_driver = true;
2116 2117 2118 2119 2120
	if (!ret) {
		ret = device_attach(&device->dev);
		if (ret < 0)
			return;
	}
2121 2122
	device->flags.visited = true;

2123 2124 2125
 ok:
	list_for_each_entry(child, &device->children, node)
		acpi_bus_attach(child);
L
Linus Torvalds 已提交
2126 2127
}

2128
/**
2129
 * acpi_bus_scan - Add ACPI device node objects in a given namespace scope.
2130
 * @handle: Root of the namespace scope to scan.
2131
 *
2132 2133
 * Scan a given ACPI tree (probably recently hot-plugged) and create and add
 * found devices.
2134
 *
2135 2136 2137 2138
 * If no devices were found, -ENODEV is returned, but it does not mean that
 * there has been a real error.  There just have been no suitable ACPI objects
 * in the table trunk from which the kernel could create a device and add an
 * appropriate driver.
2139 2140
 *
 * Must be called under acpi_scan_lock.
2141
 */
2142
int acpi_bus_scan(acpi_handle handle)
2143
{
2144
	void *device = NULL;
2145

2146 2147 2148
	if (ACPI_SUCCESS(acpi_bus_check_add(handle, 0, NULL, &device)))
		acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
				    acpi_bus_check_add, NULL, NULL, &device);
2149

2150 2151 2152
	if (device) {
		acpi_bus_attach(device);
		return 0;
2153
	}
2154
	return -ENODEV;
2155
}
2156
EXPORT_SYMBOL(acpi_bus_scan);
L
Linus Torvalds 已提交
2157

2158
/**
2159 2160
 * acpi_bus_trim - Detach scan handlers and drivers from ACPI device objects.
 * @adev: Root of the ACPI namespace scope to walk.
2161 2162 2163
 *
 * Must be called under acpi_scan_lock.
 */
2164
void acpi_bus_trim(struct acpi_device *adev)
L
Linus Torvalds 已提交
2165
{
2166 2167 2168 2169 2170 2171
	struct acpi_scan_handler *handler = adev->handler;
	struct acpi_device *child;

	list_for_each_entry_reverse(child, &adev->children, node)
		acpi_bus_trim(child);

2172
	adev->flags.match_driver = false;
2173 2174 2175 2176 2177 2178 2179 2180
	if (handler) {
		if (handler->detach)
			handler->detach(adev);

		adev->handler = NULL;
	} else {
		device_release_driver(&adev->dev);
	}
2181
	/*
2182 2183
	 * Most likely, the device is going away, so put it into D3cold before
	 * that.
2184
	 */
2185 2186 2187
	acpi_device_set_power(adev, ACPI_STATE_D3_COLD);
	adev->flags.initialized = false;
	adev->flags.visited = false;
L
Linus Torvalds 已提交
2188
}
2189 2190
EXPORT_SYMBOL_GPL(acpi_bus_trim);

2191
static int acpi_bus_scan_fixed(void)
L
Linus Torvalds 已提交
2192
{
L
Len Brown 已提交
2193
	int result = 0;
L
Li Shaohua 已提交
2194

L
Linus Torvalds 已提交
2195 2196 2197
	/*
	 * Enumerate all fixed-feature devices.
	 */
2198 2199 2200
	if (!(acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON)) {
		struct acpi_device *device = NULL;

2201
		result = acpi_add_single_object(&device, NULL,
L
Li Shaohua 已提交
2202
						ACPI_BUS_TYPE_POWER_BUTTON,
2203 2204 2205 2206
						ACPI_STA_DEFAULT);
		if (result)
			return result;

2207
		device->flags.match_driver = true;
2208 2209 2210 2211
		result = device_attach(&device->dev);
		if (result < 0)
			return result;

2212
		device_init_wakeup(&device->dev, true);
2213
	}
L
Linus Torvalds 已提交
2214

2215 2216 2217
	if (!(acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON)) {
		struct acpi_device *device = NULL;

2218
		result = acpi_add_single_object(&device, NULL,
L
Li Shaohua 已提交
2219
						ACPI_BUS_TYPE_SLEEP_BUTTON,
2220 2221 2222 2223
						ACPI_STA_DEFAULT);
		if (result)
			return result;

2224
		device->flags.match_driver = true;
2225
		result = device_attach(&device->dev);
2226
	}
L
Linus Torvalds 已提交
2227

2228
	return result < 0 ? result : 0;
L
Linus Torvalds 已提交
2229 2230
}

2231
int __init acpi_scan_init(void)
L
Linus Torvalds 已提交
2232 2233 2234
{
	int result;

2235 2236 2237 2238 2239 2240
	result = bus_register(&acpi_bus_type);
	if (result) {
		/* We don't want to quit even if we failed to add suspend/resume */
		printk(KERN_ERR PREFIX "Could not register bus type\n");
	}

2241
	acpi_pci_root_init();
2242
	acpi_pci_link_init();
2243
	acpi_processor_init();
2244
	acpi_platform_init();
2245
	acpi_lpss_init();
2246
	acpi_cmos_rtc_init();
2247
	acpi_container_init();
2248
	acpi_memory_hotplug_init();
2249

2250
	mutex_lock(&acpi_scan_lock);
L
Linus Torvalds 已提交
2251 2252 2253
	/*
	 * Enumerate devices in the ACPI namespace.
	 */
2254 2255
	result = acpi_bus_scan(ACPI_ROOT_OBJECT);
	if (result)
2256
		goto out;
L
Linus Torvalds 已提交
2257

2258
	result = acpi_bus_get_device(ACPI_ROOT_OBJECT, &acpi_root);
L
Linus Torvalds 已提交
2259
	if (result)
2260
		goto out;
L
Linus Torvalds 已提交
2261

2262 2263
	result = acpi_bus_scan_fixed();
	if (result) {
2264 2265 2266
		acpi_detach_data(acpi_root->handle, acpi_scan_drop_device);
		acpi_device_del(acpi_root);
		put_device(&acpi_root->dev);
2267
		goto out;
2268
	}
L
Linus Torvalds 已提交
2269

2270
	acpi_update_all_gpes();
2271 2272 2273 2274

 out:
	mutex_unlock(&acpi_scan_lock);
	return result;
L
Linus Torvalds 已提交
2275
}