bus.c 25.3 KB
Newer Older
L
Linus Torvalds 已提交
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 27
/*
 *  acpi_bus.c - ACPI Bus Driver ($Revision: 80 $)
 *
 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@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/module.h>
#include <linux/init.h>
#include <linux/ioport.h>
28
#include <linux/kernel.h>
L
Linus Torvalds 已提交
29 30 31 32 33
#include <linux/list.h>
#include <linux/sched.h>
#include <linux/pm.h>
#include <linux/device.h>
#include <linux/proc_fs.h>
34
#include <linux/acpi.h>
35
#include <linux/slab.h>
L
Linus Torvalds 已提交
36 37 38
#ifdef CONFIG_X86
#include <asm/mpspec.h>
#endif
39
#include <linux/pci.h>
L
Linus Torvalds 已提交
40 41
#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>
42
#include <acpi/apei.h>
43
#include <linux/dmi.h>
44
#include <linux/suspend.h>
L
Linus Torvalds 已提交
45

46 47
#include "internal.h"

L
Linus Torvalds 已提交
48
#define _COMPONENT		ACPI_BUS_COMPONENT
49
ACPI_MODULE_NAME("bus");
L
Linus Torvalds 已提交
50

L
Len Brown 已提交
51 52
struct acpi_device *acpi_root;
struct proc_dir_entry *acpi_root_dir;
L
Linus Torvalds 已提交
53 54 55 56
EXPORT_SYMBOL(acpi_root_dir);

#define STRUCT_TO_INT(s)	(*((int*)&s))

57

58
#ifdef CONFIG_X86
59 60 61 62 63 64 65 66 67 68
static int set_copy_dsdt(const struct dmi_system_id *id)
{
	printk(KERN_NOTICE "%s detected - "
		"force copy of DSDT to local memory\n", id->ident);
	acpi_gbl_copy_dsdt_locally = 1;
	return 0;
}

static struct dmi_system_id dsdt_dmi_table[] __initdata = {
	/*
69
	 * Invoke DSDT corruption work-around on all Toshiba Satellite.
70 71 72 73
	 * https://bugzilla.kernel.org/show_bug.cgi?id=14679
	 */
	{
	 .callback = set_copy_dsdt,
74
	 .ident = "TOSHIBA Satellite",
75 76
	 .matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
77
		DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"),
78
		},
79 80
	},
	{}
81
};
82 83 84 85 86
#else
static struct dmi_system_id dsdt_dmi_table[] __initdata = {
	{}
};
#endif
87

L
Linus Torvalds 已提交
88 89 90 91
/* --------------------------------------------------------------------------
                                Device Management
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
92
int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
L
Linus Torvalds 已提交
93
{
L
Len Brown 已提交
94
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
95 96 97


	if (!device)
98
		return -EINVAL;
L
Linus Torvalds 已提交
99 100 101

	/* TBD: Support fixed-feature devices */

L
Len Brown 已提交
102
	status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device);
L
Linus Torvalds 已提交
103
	if (ACPI_FAILURE(status) || !*device) {
104 105
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
				  handle));
106
		return -ENODEV;
L
Linus Torvalds 已提交
107 108
	}

109
	return 0;
L
Linus Torvalds 已提交
110
}
L
Len Brown 已提交
111

L
Linus Torvalds 已提交
112 113
EXPORT_SYMBOL(acpi_bus_get_device);

114 115
acpi_status acpi_bus_get_status_handle(acpi_handle handle,
				       unsigned long long *sta)
L
Linus Torvalds 已提交
116
{
117
	acpi_status status;
L
Len Brown 已提交
118

119 120 121
	status = acpi_evaluate_integer(handle, "_STA", NULL, sta);
	if (ACPI_SUCCESS(status))
		return AE_OK;
L
Linus Torvalds 已提交
122

123 124 125 126
	if (status == AE_NOT_FOUND) {
		*sta = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED |
		       ACPI_STA_DEVICE_UI      | ACPI_STA_DEVICE_FUNCTIONING;
		return AE_OK;
L
Linus Torvalds 已提交
127
	}
128 129
	return status;
}
L
Linus Torvalds 已提交
130

131 132 133 134 135 136 137 138 139 140
int acpi_bus_get_status(struct acpi_device *device)
{
	acpi_status status;
	unsigned long long sta;

	status = acpi_bus_get_status_handle(device->handle, &sta);
	if (ACPI_FAILURE(status))
		return -ENODEV;

	STRUCT_TO_INT(device->status) = (int) sta;
L
Linus Torvalds 已提交
141 142

	if (device->status.functional && !device->status.present) {
143 144 145 146
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]: "
		       "functional but not present;\n",
			device->pnp.bus_id,
			(u32) STRUCT_TO_INT(device->status)));
L
Linus Torvalds 已提交
147 148
	}

L
Len Brown 已提交
149 150 151
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n",
			  device->pnp.bus_id,
			  (u32) STRUCT_TO_INT(device->status)));
152
	return 0;
L
Linus Torvalds 已提交
153
}
L
Len Brown 已提交
154
EXPORT_SYMBOL(acpi_bus_get_status);
L
Linus Torvalds 已提交
155

Z
Zhang Rui 已提交
156
void acpi_bus_private_data_handler(acpi_handle handle,
157
				   void *context)
Z
Zhang Rui 已提交
158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
{
	return;
}
EXPORT_SYMBOL(acpi_bus_private_data_handler);

int acpi_bus_get_private_data(acpi_handle handle, void **data)
{
	acpi_status status = AE_OK;

	if (!*data)
		return -EINVAL;

	status = acpi_get_data(handle, acpi_bus_private_data_handler, data);
	if (ACPI_FAILURE(status) || !*data) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
				handle));
		return -ENODEV;
	}

	return 0;
}
EXPORT_SYMBOL(acpi_bus_get_private_data);

L
Linus Torvalds 已提交
181 182 183 184
/* --------------------------------------------------------------------------
                                 Power Management
   -------------------------------------------------------------------------- */

185
static int __acpi_bus_get_power(struct acpi_device *device, int *state)
L
Linus Torvalds 已提交
186
{
L
Len Brown 已提交
187 188
	int result = 0;
	acpi_status status = 0;
189
	unsigned long long psc = 0;
L
Linus Torvalds 已提交
190

191 192
	if (!device || !state)
		return -EINVAL;
L
Linus Torvalds 已提交
193 194 195

	*state = ACPI_STATE_UNKNOWN;

196
	if (device->flags.power_manageable) {
L
Linus Torvalds 已提交
197
		/*
198
		 * Get the device's power state either directly (via _PSC) or
L
Linus Torvalds 已提交
199 200
		 * indirectly (via power resources).
		 */
201
		if (device->power.flags.power_resources) {
202
			result = acpi_power_get_inferred_state(device, state);
203 204 205
			if (result)
				return result;
		} else if (device->power.flags.explicit_get) {
L
Len Brown 已提交
206 207
			status = acpi_evaluate_integer(device->handle, "_PSC",
						       NULL, &psc);
L
Linus Torvalds 已提交
208
			if (ACPI_FAILURE(status))
209
				return -ENODEV;
210
			*state = (int)psc;
L
Linus Torvalds 已提交
211
		}
212 213 214 215
	} else {
		/* TBD: Non-recursive algorithm for walking up hierarchy. */
		*state = device->parent ?
			device->parent->power.state : ACPI_STATE_D0;
L
Linus Torvalds 已提交
216 217 218
	}

	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is D%d\n",
219
			  device->pnp.bus_id, *state));
L
Linus Torvalds 已提交
220

221
	return 0;
L
Linus Torvalds 已提交
222 223
}

224

225
static int __acpi_bus_set_power(struct acpi_device *device, int state)
L
Linus Torvalds 已提交
226
{
L
Len Brown 已提交
227 228 229
	int result = 0;
	acpi_status status = AE_OK;
	char object_name[5] = { '_', 'P', 'S', '0' + state, '\0' };
L
Linus Torvalds 已提交
230

L
Lin Ming 已提交
231
	if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
232
		return -EINVAL;
L
Linus Torvalds 已提交
233 234 235

	/* Make sure this is a valid target state */

236
	if (state == device->power.state) {
237 238 239
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n",
				  state));
		return 0;
L
Linus Torvalds 已提交
240
	}
241

L
Linus Torvalds 已提交
242
	if (!device->power.states[state].flags.valid) {
243
		printk(KERN_WARNING PREFIX "Device does not support D%d\n", state);
244
		return -ENODEV;
L
Linus Torvalds 已提交
245 246
	}
	if (device->parent && (state < device->parent->power.state)) {
247
		printk(KERN_WARNING PREFIX
248
			      "Cannot set device to a higher-powered"
249
			      " state than parent\n");
250
		return -ENODEV;
L
Linus Torvalds 已提交
251 252
	}

253 254 255 256
	/* For D3cold we should execute _PS3, not _PS4. */
	if (state == ACPI_STATE_D3_COLD)
		object_name[3] = '3';

L
Linus Torvalds 已提交
257 258 259 260 261 262
	/*
	 * Transition Power
	 * ----------------
	 * On transitions to a high-powered state we first apply power (via
	 * power resources) then evalute _PSx.  Conversly for transitions to
	 * a lower-powered state.
263
	 */
L
Linus Torvalds 已提交
264 265 266 267 268 269 270
	if (state < device->power.state) {
		if (device->power.flags.power_resources) {
			result = acpi_power_transition(device, state);
			if (result)
				goto end;
		}
		if (device->power.states[state].flags.explicit_set) {
L
Len Brown 已提交
271 272
			status = acpi_evaluate_object(device->handle,
						      object_name, NULL, NULL);
L
Linus Torvalds 已提交
273 274 275 276 277
			if (ACPI_FAILURE(status)) {
				result = -ENODEV;
				goto end;
			}
		}
L
Len Brown 已提交
278
	} else {
L
Linus Torvalds 已提交
279
		if (device->power.states[state].flags.explicit_set) {
L
Len Brown 已提交
280 281
			status = acpi_evaluate_object(device->handle,
						      object_name, NULL, NULL);
L
Linus Torvalds 已提交
282 283 284 285 286 287 288 289 290 291 292 293
			if (ACPI_FAILURE(status)) {
				result = -ENODEV;
				goto end;
			}
		}
		if (device->power.flags.power_resources) {
			result = acpi_power_transition(device, state);
			if (result)
				goto end;
		}
	}

L
Len Brown 已提交
294
      end:
L
Linus Torvalds 已提交
295
	if (result)
296
		printk(KERN_WARNING PREFIX
L
Len Brown 已提交
297
			      "Device [%s] failed to transition to D%d\n",
298
			      device->pnp.bus_id, state);
299 300
	else {
		device->power.state = state;
L
Len Brown 已提交
301 302 303
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Device [%s] transitioned to D%d\n",
				  device->pnp.bus_id, state));
304
	}
L
Linus Torvalds 已提交
305

306
	return result;
L
Linus Torvalds 已提交
307 308
}

309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327

int acpi_bus_set_power(acpi_handle handle, int state)
{
	struct acpi_device *device;
	int result;

	result = acpi_bus_get_device(handle, &device);
	if (result)
		return result;

	if (!device->flags.power_manageable) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				"Device [%s] is not power manageable\n",
				dev_name(&device->dev)));
		return -ENODEV;
	}

	return __acpi_bus_set_power(device, state);
}
L
Len Brown 已提交
328
EXPORT_SYMBOL(acpi_bus_set_power);
L
Linus Torvalds 已提交
329

330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354

int acpi_bus_init_power(struct acpi_device *device)
{
	int state;
	int result;

	if (!device)
		return -EINVAL;

	device->power.state = ACPI_STATE_UNKNOWN;

	result = __acpi_bus_get_power(device, &state);
	if (result)
		return result;

	if (device->power.flags.power_resources)
		result = acpi_power_on_resources(device, state);

	if (!result)
		device->power.state = state;

	return result;
}


355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377
int acpi_bus_update_power(acpi_handle handle, int *state_p)
{
	struct acpi_device *device;
	int state;
	int result;

	result = acpi_bus_get_device(handle, &device);
	if (result)
		return result;

	result = __acpi_bus_get_power(device, &state);
	if (result)
		return result;

	result = __acpi_bus_set_power(device, state);
	if (!result && state_p)
		*state_p = state;

	return result;
}
EXPORT_SYMBOL_GPL(acpi_bus_update_power);


378 379 380 381 382 383 384 385 386 387 388
bool acpi_bus_power_manageable(acpi_handle handle)
{
	struct acpi_device *device;
	int result;

	result = acpi_bus_get_device(handle, &device);
	return result ? false : device->flags.power_manageable;
}

EXPORT_SYMBOL(acpi_bus_power_manageable);

389 390 391 392 393 394 395 396 397 398 399
bool acpi_bus_can_wakeup(acpi_handle handle)
{
	struct acpi_device *device;
	int result;

	result = acpi_bus_get_device(handle, &device);
	return result ? false : device->wakeup.flags.valid;
}

EXPORT_SYMBOL(acpi_bus_can_wakeup);

S
Shaohua Li 已提交
400 401 402 403 404 405 406 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
static void acpi_print_osc_error(acpi_handle handle,
	struct acpi_osc_context *context, char *error)
{
	struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER};
	int i;

	if (ACPI_FAILURE(acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer)))
		printk(KERN_DEBUG "%s\n", error);
	else {
		printk(KERN_DEBUG "%s:%s\n", (char *)buffer.pointer, error);
		kfree(buffer.pointer);
	}
	printk(KERN_DEBUG"_OSC request data:");
	for (i = 0; i < context->cap.length; i += sizeof(u32))
		printk("%x ", *((u32 *)(context->cap.pointer + i)));
	printk("\n");
}

static acpi_status acpi_str_to_uuid(char *str, u8 *uuid)
{
	int i;
	static int opc_map_to_uuid[16] = {6, 4, 2, 0, 11, 9, 16, 14, 19, 21,
		24, 26, 28, 30, 32, 34};

	if (strlen(str) != 36)
		return AE_BAD_PARAMETER;
	for (i = 0; i < 36; i++) {
		if (i == 8 || i == 13 || i == 18 || i == 23) {
			if (str[i] != '-')
				return AE_BAD_PARAMETER;
		} else if (!isxdigit(str[i]))
			return AE_BAD_PARAMETER;
	}
	for (i = 0; i < 16; i++) {
434 435
		uuid[i] = hex_to_bin(str[opc_map_to_uuid[i]]) << 4;
		uuid[i] |= hex_to_bin(str[opc_map_to_uuid[i] + 1]);
S
Shaohua Li 已提交
436 437 438 439 440 441 442 443 444 445 446 447
	}
	return AE_OK;
}

acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context)
{
	acpi_status status;
	struct acpi_object_list input;
	union acpi_object in_params[4];
	union acpi_object *out_obj;
	u8 uuid[16];
	u32 errors;
448
	struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
S
Shaohua Li 已提交
449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470

	if (!context)
		return AE_ERROR;
	if (ACPI_FAILURE(acpi_str_to_uuid(context->uuid_str, uuid)))
		return AE_ERROR;
	context->ret.length = ACPI_ALLOCATE_BUFFER;
	context->ret.pointer = NULL;

	/* Setting up input parameters */
	input.count = 4;
	input.pointer = in_params;
	in_params[0].type 		= ACPI_TYPE_BUFFER;
	in_params[0].buffer.length 	= 16;
	in_params[0].buffer.pointer	= uuid;
	in_params[1].type 		= ACPI_TYPE_INTEGER;
	in_params[1].integer.value 	= context->rev;
	in_params[2].type 		= ACPI_TYPE_INTEGER;
	in_params[2].integer.value	= context->cap.length/sizeof(u32);
	in_params[3].type		= ACPI_TYPE_BUFFER;
	in_params[3].buffer.length 	= context->cap.length;
	in_params[3].buffer.pointer 	= context->cap.pointer;

471
	status = acpi_evaluate_object(handle, "_OSC", &input, &output);
S
Shaohua Li 已提交
472 473 474
	if (ACPI_FAILURE(status))
		return status;

475
	if (!output.length)
S
Shaohua Li 已提交
476 477
		return AE_NULL_OBJECT;

478 479 480
	out_obj = output.pointer;
	if (out_obj->type != ACPI_TYPE_BUFFER
		|| out_obj->buffer.length != context->cap.length) {
S
Shaohua Li 已提交
481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
		acpi_print_osc_error(handle, context,
			"_OSC evaluation returned wrong type");
		status = AE_TYPE;
		goto out_kfree;
	}
	/* Need to ignore the bit0 in result code */
	errors = *((u32 *)out_obj->buffer.pointer) & ~(1 << 0);
	if (errors) {
		if (errors & OSC_REQUEST_ERROR)
			acpi_print_osc_error(handle, context,
				"_OSC request failed");
		if (errors & OSC_INVALID_UUID_ERROR)
			acpi_print_osc_error(handle, context,
				"_OSC invalid UUID");
		if (errors & OSC_INVALID_REVISION_ERROR)
			acpi_print_osc_error(handle, context,
				"_OSC invalid revision");
		if (errors & OSC_CAPABILITIES_MASK_ERROR) {
			if (((u32 *)context->cap.pointer)[OSC_QUERY_TYPE]
			    & OSC_QUERY_ENABLE)
				goto out_success;
			status = AE_SUPPORT;
			goto out_kfree;
		}
		status = AE_ERROR;
		goto out_kfree;
	}
out_success:
509 510 511 512 513 514 515 516 517
	context->ret.length = out_obj->buffer.length;
	context->ret.pointer = kmalloc(context->ret.length, GFP_KERNEL);
	if (!context->ret.pointer) {
		status =  AE_NO_MEMORY;
		goto out_kfree;
	}
	memcpy(context->ret.pointer, out_obj->buffer.pointer,
		context->ret.length);
	status =  AE_OK;
S
Shaohua Li 已提交
518 519

out_kfree:
520 521 522
	kfree(output.pointer);
	if (status != AE_OK)
		context->ret.pointer = NULL;
S
Shaohua Li 已提交
523 524 525 526
	return status;
}
EXPORT_SYMBOL(acpi_run_osc);

527
bool osc_sb_apei_support_acked;
S
Shaohua Li 已提交
528 529 530 531 532 533 534 535 536 537 538 539 540 541
static u8 sb_uuid_str[] = "0811B06E-4A27-44F9-8D60-3CBBC22E7B48";
static void acpi_bus_osc_support(void)
{
	u32 capbuf[2];
	struct acpi_osc_context context = {
		.uuid_str = sb_uuid_str,
		.rev = 1,
		.cap.length = 8,
		.cap.pointer = capbuf,
	};
	acpi_handle handle;

	capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;
	capbuf[OSC_SUPPORT_TYPE] = OSC_SB_PR3_SUPPORT; /* _PR3 is in use */
542 543
#if defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR) ||\
			defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR_MODULE)
S
Shaohua Li 已提交
544 545
	capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_PAD_SUPPORT;
#endif
546 547 548 549

#if defined(CONFIG_ACPI_PROCESSOR) || defined(CONFIG_ACPI_PROCESSOR_MODULE)
	capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_PPC_OST_SUPPORT;
#endif
550 551 552

	if (!ghes_disable)
		capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_APEI_SUPPORT;
S
Shaohua Li 已提交
553 554
	if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)))
		return;
555 556 557 558 559
	if (ACPI_SUCCESS(acpi_run_osc(handle, &context))) {
		u32 *capbuf_ret = context.ret.pointer;
		if (context.ret.length > OSC_SUPPORT_TYPE)
			osc_sb_apei_support_acked =
				capbuf_ret[OSC_SUPPORT_TYPE] & OSC_SB_APEI_SUPPORT;
S
Shaohua Li 已提交
560
		kfree(context.ret.pointer);
561 562
	}
	/* do we need to check other returned cap? Sounds no */
S
Shaohua Li 已提交
563 564
}

L
Linus Torvalds 已提交
565 566 567 568
/* --------------------------------------------------------------------------
                                Event Management
   -------------------------------------------------------------------------- */

569
#ifdef CONFIG_ACPI_PROC_EVENT
L
Linus Torvalds 已提交
570 571 572 573 574
static DEFINE_SPINLOCK(acpi_bus_event_lock);

LIST_HEAD(acpi_bus_event_list);
DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue);

L
Len Brown 已提交
575
extern int event_is_open;
L
Linus Torvalds 已提交
576

577
int acpi_bus_generate_proc_event4(const char *device_class, const char *bus_id, u8 type, int data)
L
Linus Torvalds 已提交
578
{
579
	struct acpi_bus_event *event;
L
Len Brown 已提交
580
	unsigned long flags = 0;
L
Linus Torvalds 已提交
581 582 583

	/* drop event on the floor if no one's listening */
	if (!event_is_open)
584
		return 0;
L
Linus Torvalds 已提交
585

586
	event = kzalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC);
L
Linus Torvalds 已提交
587
	if (!event)
588
		return -ENOMEM;
L
Linus Torvalds 已提交
589

590 591
	strcpy(event->device_class, device_class);
	strcpy(event->bus_id, bus_id);
L
Linus Torvalds 已提交
592 593 594 595 596 597 598 599 600
	event->type = type;
	event->data = data;

	spin_lock_irqsave(&acpi_bus_event_lock, flags);
	list_add_tail(&event->node, &acpi_bus_event_list);
	spin_unlock_irqrestore(&acpi_bus_event_lock, flags);

	wake_up_interruptible(&acpi_bus_event_queue);

601
	return 0;
602 603 604 605 606 607 608 609 610 611 612

}

EXPORT_SYMBOL_GPL(acpi_bus_generate_proc_event4);

int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data)
{
	if (!device)
		return -EINVAL;
	return acpi_bus_generate_proc_event4(device->pnp.device_class,
					     device->pnp.bus_id, type, data);
L
Linus Torvalds 已提交
613
}
L
Len Brown 已提交
614

615
EXPORT_SYMBOL(acpi_bus_generate_proc_event);
L
Linus Torvalds 已提交
616

L
Len Brown 已提交
617
int acpi_bus_receive_event(struct acpi_bus_event *event)
L
Linus Torvalds 已提交
618
{
L
Len Brown 已提交
619 620
	unsigned long flags = 0;
	struct acpi_bus_event *entry = NULL;
L
Linus Torvalds 已提交
621 622 623 624 625

	DECLARE_WAITQUEUE(wait, current);


	if (!event)
626
		return -EINVAL;
L
Linus Torvalds 已提交
627 628 629 630 631 632 633 634 635 636 637 638 639

	if (list_empty(&acpi_bus_event_list)) {

		set_current_state(TASK_INTERRUPTIBLE);
		add_wait_queue(&acpi_bus_event_queue, &wait);

		if (list_empty(&acpi_bus_event_list))
			schedule();

		remove_wait_queue(&acpi_bus_event_queue, &wait);
		set_current_state(TASK_RUNNING);

		if (signal_pending(current))
640
			return -ERESTARTSYS;
L
Linus Torvalds 已提交
641 642 643
	}

	spin_lock_irqsave(&acpi_bus_event_lock, flags);
644 645 646
	if (!list_empty(&acpi_bus_event_list)) {
		entry = list_entry(acpi_bus_event_list.next,
				   struct acpi_bus_event, node);
L
Linus Torvalds 已提交
647
		list_del(&entry->node);
648
	}
L
Linus Torvalds 已提交
649 650 651
	spin_unlock_irqrestore(&acpi_bus_event_lock, flags);

	if (!entry)
652
		return -ENODEV;
L
Linus Torvalds 已提交
653 654 655 656 657

	memcpy(event, entry, sizeof(struct acpi_bus_event));

	kfree(entry);

658
	return 0;
L
Linus Torvalds 已提交
659 660
}

661
#endif	/* CONFIG_ACPI_PROC_EVENT */
L
Linus Torvalds 已提交
662 663 664 665 666

/* --------------------------------------------------------------------------
                             Notification Handling
   -------------------------------------------------------------------------- */

667
static void acpi_bus_check_device(acpi_handle handle)
L
Linus Torvalds 已提交
668
{
669
	struct acpi_device *device;
670
	acpi_status status;
L
Linus Torvalds 已提交
671 672
	struct acpi_device_status old_status;

673 674
	if (acpi_bus_get_device(handle, &device))
		return;
L
Linus Torvalds 已提交
675
	if (!device)
676
		return;
L
Linus Torvalds 已提交
677 678 679 680 681 682 683 684 685

	old_status = device->status;

	/*
	 * Make sure this device's parent is present before we go about
	 * messing with the device.
	 */
	if (device->parent && !device->parent->status.present) {
		device->status = device->parent->status;
686
		return;
L
Linus Torvalds 已提交
687 688 689 690
	}

	status = acpi_bus_get_status(device);
	if (ACPI_FAILURE(status))
691
		return;
L
Linus Torvalds 已提交
692 693

	if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status))
694
		return;
L
Linus Torvalds 已提交
695 696 697 698 699 700 701

	/*
	 * Device Insertion/Removal
	 */
	if ((device->status.present) && !(old_status.present)) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device insertion detected\n"));
		/* TBD: Handle device insertion */
L
Len Brown 已提交
702
	} else if (!(device->status.present) && (old_status.present)) {
L
Linus Torvalds 已提交
703 704 705 706 707
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n"));
		/* TBD: Handle device removal */
	}
}

708
static void acpi_bus_check_scope(acpi_handle handle)
L
Linus Torvalds 已提交
709 710
{
	/* Status Change? */
711
	acpi_bus_check_device(handle);
L
Linus Torvalds 已提交
712 713 714 715 716 717 718

	/*
	 * TBD: Enumerate child devices within this device's scope and
	 *       run acpi_bus_check_device()'s on them.
	 */
}

719 720 721 722 723 724 725 726 727 728 729 730 731
static BLOCKING_NOTIFIER_HEAD(acpi_bus_notify_list);
int register_acpi_bus_notifier(struct notifier_block *nb)
{
	return blocking_notifier_chain_register(&acpi_bus_notify_list, nb);
}
EXPORT_SYMBOL_GPL(register_acpi_bus_notifier);

void unregister_acpi_bus_notifier(struct notifier_block *nb)
{
	blocking_notifier_chain_unregister(&acpi_bus_notify_list, nb);
}
EXPORT_SYMBOL_GPL(unregister_acpi_bus_notifier);

L
Linus Torvalds 已提交
732 733 734 735 736
/**
 * acpi_bus_notify
 * ---------------
 * Callback for all 'system-level' device notifications (values 0x00-0x7F).
 */
L
Len Brown 已提交
737
static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
L
Linus Torvalds 已提交
738
{
L
Len Brown 已提交
739
	struct acpi_device *device = NULL;
740
	struct acpi_driver *driver;
L
Linus Torvalds 已提交
741

742 743 744
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Notification %#02x to handle %p\n",
			  type, handle));

745 746
	blocking_notifier_call_chain(&acpi_bus_notify_list,
		type, (void *)handle);
L
Linus Torvalds 已提交
747 748 749 750

	switch (type) {

	case ACPI_NOTIFY_BUS_CHECK:
751
		acpi_bus_check_scope(handle);
752
		/*
L
Linus Torvalds 已提交
753
		 * TBD: We'll need to outsource certain events to non-ACPI
L
Len Brown 已提交
754
		 *      drivers via the device manager (device.c).
L
Linus Torvalds 已提交
755 756 757 758
		 */
		break;

	case ACPI_NOTIFY_DEVICE_CHECK:
759
		acpi_bus_check_device(handle);
760
		/*
L
Linus Torvalds 已提交
761
		 * TBD: We'll need to outsource certain events to non-ACPI
L
Len Brown 已提交
762
		 *      drivers via the device manager (device.c).
L
Linus Torvalds 已提交
763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790
		 */
		break;

	case ACPI_NOTIFY_DEVICE_WAKE:
		/* TBD */
		break;

	case ACPI_NOTIFY_EJECT_REQUEST:
		/* TBD */
		break;

	case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
		/* TBD: Exactly what does 'light' mean? */
		break;

	case ACPI_NOTIFY_FREQUENCY_MISMATCH:
		/* TBD */
		break;

	case ACPI_NOTIFY_BUS_MODE_MISMATCH:
		/* TBD */
		break;

	case ACPI_NOTIFY_POWER_FAULT:
		/* TBD */
		break;

	default:
L
Len Brown 已提交
791 792 793
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Received unknown/unsupported notification [%08x]\n",
				  type));
L
Linus Torvalds 已提交
794 795 796
		break;
	}

797 798 799 800 801 802 803
	acpi_bus_get_device(handle, &device);
	if (device) {
		driver = device->driver;
		if (driver && driver->ops.notify &&
		    (driver->flags & ACPI_DRIVER_ALL_NOTIFY_EVENTS))
			driver->ops.notify(device, type);
	}
L
Linus Torvalds 已提交
804 805 806 807 808 809
}

/* --------------------------------------------------------------------------
                             Initialization/Cleanup
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
810
static int __init acpi_bus_init_irq(void)
L
Linus Torvalds 已提交
811
{
L
Len Brown 已提交
812 813 814 815
	acpi_status status = AE_OK;
	union acpi_object arg = { ACPI_TYPE_INTEGER };
	struct acpi_object_list arg_list = { 1, &arg };
	char *message = NULL;
L
Linus Torvalds 已提交
816 817


818
	/*
L
Linus Torvalds 已提交
819 820 821 822 823 824 825 826 827 828 829 830 831 832
	 * Let the system know what interrupt model we are using by
	 * evaluating the \_PIC object, if exists.
	 */

	switch (acpi_irq_model) {
	case ACPI_IRQ_MODEL_PIC:
		message = "PIC";
		break;
	case ACPI_IRQ_MODEL_IOAPIC:
		message = "IOAPIC";
		break;
	case ACPI_IRQ_MODEL_IOSAPIC:
		message = "IOSAPIC";
		break;
J
John Keller 已提交
833 834 835
	case ACPI_IRQ_MODEL_PLATFORM:
		message = "platform specific model";
		break;
L
Linus Torvalds 已提交
836 837
	default:
		printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
838
		return -ENODEV;
L
Linus Torvalds 已提交
839 840 841 842 843 844 845 846
	}

	printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message);

	arg.integer.value = acpi_irq_model;

	status = acpi_evaluate_object(NULL, "\\_PIC", &arg_list, NULL);
	if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
847
		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC"));
848
		return -ENODEV;
L
Linus Torvalds 已提交
849 850
	}

851
	return 0;
L
Linus Torvalds 已提交
852 853
}

854
u8 acpi_gbl_permanent_mmap;
855 856


L
Len Brown 已提交
857
void __init acpi_early_init(void)
L
Linus Torvalds 已提交
858
{
L
Len Brown 已提交
859
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
860 861

	if (acpi_disabled)
862
		return;
L
Linus Torvalds 已提交
863

B
Bob Moore 已提交
864 865
	printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION);

L
Linus Torvalds 已提交
866 867 868 869
	/* enable workarounds, unless strict ACPI spec. compliance */
	if (!acpi_strict)
		acpi_gbl_enable_interpreter_slack = TRUE;

870 871
	acpi_gbl_permanent_mmap = 1;

872 873 874 875 876 877
	/*
	 * If the machine falls into the DMI check table,
	 * DSDT will be copied to memory
	 */
	dmi_check_system(dsdt_dmi_table);

878 879 880 881 882 883 884
	status = acpi_reallocate_root_table();
	if (ACPI_FAILURE(status)) {
		printk(KERN_ERR PREFIX
		       "Unable to reallocate ACPI tables\n");
		goto error0;
	}

L
Linus Torvalds 已提交
885 886
	status = acpi_initialize_subsystem();
	if (ACPI_FAILURE(status)) {
L
Len Brown 已提交
887 888
		printk(KERN_ERR PREFIX
		       "Unable to initialize the ACPI Interpreter\n");
L
Linus Torvalds 已提交
889 890 891 892 893
		goto error0;
	}

	status = acpi_load_tables();
	if (ACPI_FAILURE(status)) {
L
Len Brown 已提交
894 895
		printk(KERN_ERR PREFIX
		       "Unable to load the System Description Tables\n");
L
Linus Torvalds 已提交
896 897 898 899 900 901
		goto error0;
	}

#ifdef CONFIG_X86
	if (!acpi_ioapic) {
		/* compatible (0) means level (3) */
902 903 904 905
		if (!(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)) {
			acpi_sci_flags &= ~ACPI_MADT_TRIGGER_MASK;
			acpi_sci_flags |= ACPI_MADT_TRIGGER_LEVEL;
		}
L
Linus Torvalds 已提交
906
		/* Set PIC-mode SCI trigger type */
907
		acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt,
908
					 (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2);
L
Linus Torvalds 已提交
909 910
	} else {
		/*
911
		 * now that acpi_gbl_FADT is initialized,
L
Linus Torvalds 已提交
912 913
		 * update it with result from INT_SRC_OVR parsing
		 */
914
		acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi;
L
Linus Torvalds 已提交
915 916 917
	}
#endif

918
	status = acpi_enable_subsystem(~ACPI_NO_ACPI_ENABLE);
L
Linus Torvalds 已提交
919 920 921 922 923
	if (ACPI_FAILURE(status)) {
		printk(KERN_ERR PREFIX "Unable to enable ACPI\n");
		goto error0;
	}

924
	return;
L
Linus Torvalds 已提交
925

L
Len Brown 已提交
926
      error0:
L
Linus Torvalds 已提交
927
	disable_acpi();
928
	return;
L
Linus Torvalds 已提交
929 930
}

L
Len Brown 已提交
931
static int __init acpi_bus_init(void)
L
Linus Torvalds 已提交
932
{
L
Len Brown 已提交
933 934 935
	int result = 0;
	acpi_status status = AE_OK;
	extern acpi_status acpi_os_initialize1(void);
L
Linus Torvalds 已提交
936

937
	acpi_os_initialize1();
L
Linus Torvalds 已提交
938

939
	status = acpi_enable_subsystem(ACPI_NO_ACPI_ENABLE);
L
Linus Torvalds 已提交
940
	if (ACPI_FAILURE(status)) {
L
Len Brown 已提交
941 942
		printk(KERN_ERR PREFIX
		       "Unable to start the ACPI Interpreter\n");
L
Linus Torvalds 已提交
943 944 945 946 947 948 949 950
		goto error1;
	}

	/*
	 * ACPI 2.0 requires the EC driver to be loaded and work before
	 * the EC device is found in the namespace (i.e. before acpi_initialize_objects()
	 * is called).
	 *
951
	 * This is accomplished by looking for the ECDT table, and getting
L
Linus Torvalds 已提交
952 953 954 955 956
	 * the EC parameters out of that.
	 */
	status = acpi_ec_ecdt_probe();
	/* Ignore result. Not having an ECDT is not fatal. */

S
Shaohua Li 已提交
957 958
	acpi_bus_osc_support();

L
Linus Torvalds 已提交
959 960 961 962 963 964
	status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
	if (ACPI_FAILURE(status)) {
		printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n");
		goto error1;
	}

965 966 967 968 969 970
	/*
	 * _PDC control method may load dynamic SSDT tables,
	 * and we need to install the table handler before that.
	 */
	acpi_sysfs_init();

A
Alex Chiang 已提交
971 972
	acpi_early_processor_set_pdc();

973 974 975 976 977 978
	/*
	 * Maybe EC region is required at bus_scan/acpi_get_devices. So it
	 * is necessary to enable it as early as possible.
	 */
	acpi_boot_ec_enable();

L
Linus Torvalds 已提交
979 980
	printk(KERN_INFO PREFIX "Interpreter enabled\n");

981 982 983
	/* Initialize sleep structures */
	acpi_sleep_init();

L
Linus Torvalds 已提交
984 985 986 987 988 989 990 991 992 993
	/*
	 * Get the system interrupt model and evaluate \_PIC.
	 */
	result = acpi_bus_init_irq();
	if (result)
		goto error1;

	/*
	 * Register the for all standard device notifications.
	 */
L
Len Brown 已提交
994 995 996
	status =
	    acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
					&acpi_bus_notify, NULL);
L
Linus Torvalds 已提交
997
	if (ACPI_FAILURE(status)) {
L
Len Brown 已提交
998 999
		printk(KERN_ERR PREFIX
		       "Unable to register for device notifications\n");
L
Linus Torvalds 已提交
1000 1001 1002 1003 1004 1005 1006 1007
		goto error1;
	}

	/*
	 * Create the top ACPI proc directory
	 */
	acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);

1008
	return 0;
L
Linus Torvalds 已提交
1009 1010

	/* Mimic structured exception handling */
L
Len Brown 已提交
1011
      error1:
L
Linus Torvalds 已提交
1012
	acpi_terminate();
1013
	return -ENODEV;
L
Linus Torvalds 已提交
1014 1015
}

1016
struct kobject *acpi_kobj;
M
Matthew Garrett 已提交
1017
EXPORT_SYMBOL_GPL(acpi_kobj);
L
Linus Torvalds 已提交
1018

L
Len Brown 已提交
1019
static int __init acpi_init(void)
L
Linus Torvalds 已提交
1020
{
1021
	int result;
L
Linus Torvalds 已提交
1022 1023 1024

	if (acpi_disabled) {
		printk(KERN_INFO PREFIX "Interpreter disabled.\n");
1025
		return -ENODEV;
L
Linus Torvalds 已提交
1026 1027
	}

1028
	acpi_kobj = kobject_create_and_add("acpi", firmware_kobj);
1029
	if (!acpi_kobj) {
1030
		printk(KERN_WARNING "%s: kset create error\n", __func__);
1031 1032
		acpi_kobj = NULL;
	}
L
Linus Torvalds 已提交
1033

1034
	init_acpi_device_notify();
L
Linus Torvalds 已提交
1035
	result = acpi_bus_init();
1036
	if (result) {
L
Linus Torvalds 已提交
1037
		disable_acpi();
1038
		return result;
1039
	}
1040

1041
	pci_mmcfg_late_init();
1042
	acpi_scan_init();
1043
	acpi_ec_init();
1044
	acpi_debugfs_init();
1045
	acpi_sleep_proc_init();
1046
	acpi_wakeup_device_init();
1047
	return 0;
L
Linus Torvalds 已提交
1048 1049 1050
}

subsys_initcall(acpi_init);