bus.c 20.4 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>
L
Linus Torvalds 已提交
35 36 37
#ifdef CONFIG_X86
#include <asm/mpspec.h>
#endif
38
#include <linux/pci.h>
L
Linus Torvalds 已提交
39 40
#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>
41
#include <linux/dmi.h>
L
Linus Torvalds 已提交
42

43 44
#include "internal.h"

L
Linus Torvalds 已提交
45
#define _COMPONENT		ACPI_BUS_COMPONENT
46
ACPI_MODULE_NAME("bus");
L
Linus Torvalds 已提交
47

L
Len Brown 已提交
48 49
struct acpi_device *acpi_root;
struct proc_dir_entry *acpi_root_dir;
L
Linus Torvalds 已提交
50 51 52 53
EXPORT_SYMBOL(acpi_root_dir);

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

54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
static int set_power_nocheck(const struct dmi_system_id *id)
{
	printk(KERN_NOTICE PREFIX "%s detected - "
		"disable power check in power transistion\n", id->ident);
	acpi_power_nocheck = 1;
	return 0;
}
static struct dmi_system_id __cpuinitdata power_nocheck_dmi_table[] = {
	{
	set_power_nocheck, "HP Pavilion 05", {
	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
	DMI_MATCH(DMI_SYS_VENDOR, "HP Pavilion 05"),
	DMI_MATCH(DMI_PRODUCT_VERSION, "2001211RE101GLEND") }, NULL},
	{},
};


L
Linus Torvalds 已提交
71 72 73 74
/* --------------------------------------------------------------------------
                                Device Management
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
75
int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
L
Linus Torvalds 已提交
76
{
L
Len Brown 已提交
77
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
78 79 80


	if (!device)
81
		return -EINVAL;
L
Linus Torvalds 已提交
82 83 84

	/* TBD: Support fixed-feature devices */

L
Len Brown 已提交
85
	status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device);
L
Linus Torvalds 已提交
86
	if (ACPI_FAILURE(status) || !*device) {
87 88
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
				  handle));
89
		return -ENODEV;
L
Linus Torvalds 已提交
90 91
	}

92
	return 0;
L
Linus Torvalds 已提交
93
}
L
Len Brown 已提交
94

L
Linus Torvalds 已提交
95 96
EXPORT_SYMBOL(acpi_bus_get_device);

97 98
acpi_status acpi_bus_get_status_handle(acpi_handle handle,
				       unsigned long long *sta)
L
Linus Torvalds 已提交
99
{
100
	acpi_status status;
L
Len Brown 已提交
101

102 103 104
	status = acpi_evaluate_integer(handle, "_STA", NULL, sta);
	if (ACPI_SUCCESS(status))
		return AE_OK;
L
Linus Torvalds 已提交
105

106 107 108 109
	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 已提交
110
	}
111 112
	return status;
}
L
Linus Torvalds 已提交
113

114 115 116 117 118 119 120 121 122 123
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 已提交
124 125

	if (device->status.functional && !device->status.present) {
126 127 128 129
		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 已提交
130 131
	}

L
Len Brown 已提交
132 133 134
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n",
			  device->pnp.bus_id,
			  (u32) STRUCT_TO_INT(device->status)));
135
	return 0;
L
Linus Torvalds 已提交
136
}
L
Len Brown 已提交
137
EXPORT_SYMBOL(acpi_bus_get_status);
L
Linus Torvalds 已提交
138

Z
Zhang Rui 已提交
139
void acpi_bus_private_data_handler(acpi_handle handle,
140
				   void *context)
Z
Zhang Rui 已提交
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
{
	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 已提交
164 165 166 167
/* --------------------------------------------------------------------------
                                 Power Management
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
168
int acpi_bus_get_power(acpi_handle handle, int *state)
L
Linus Torvalds 已提交
169
{
L
Len Brown 已提交
170 171 172
	int result = 0;
	acpi_status status = 0;
	struct acpi_device *device = NULL;
173
	unsigned long long psc = 0;
L
Linus Torvalds 已提交
174 175 176 177


	result = acpi_bus_get_device(handle, &device);
	if (result)
178
		return result;
L
Linus Torvalds 已提交
179 180 181 182 183 184 185 186 187

	*state = ACPI_STATE_UNKNOWN;

	if (!device->flags.power_manageable) {
		/* TBD: Non-recursive algorithm for walking up hierarchy */
		if (device->parent)
			*state = device->parent->power.state;
		else
			*state = ACPI_STATE_D0;
L
Len Brown 已提交
188
	} else {
L
Linus Torvalds 已提交
189
		/*
190
		 * Get the device's power state either directly (via _PSC) or
L
Linus Torvalds 已提交
191 192 193
		 * indirectly (via power resources).
		 */
		if (device->power.flags.explicit_get) {
L
Len Brown 已提交
194 195
			status = acpi_evaluate_integer(device->handle, "_PSC",
						       NULL, &psc);
L
Linus Torvalds 已提交
196
			if (ACPI_FAILURE(status))
197
				return -ENODEV;
L
Len Brown 已提交
198 199
			device->power.state = (int)psc;
		} else if (device->power.flags.power_resources) {
L
Linus Torvalds 已提交
200 201
			result = acpi_power_get_inferred_state(device);
			if (result)
202
				return result;
L
Linus Torvalds 已提交
203 204 205 206 207 208
		}

		*state = device->power.state;
	}

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

211
	return 0;
L
Linus Torvalds 已提交
212 213
}

L
Len Brown 已提交
214
EXPORT_SYMBOL(acpi_bus_get_power);
L
Linus Torvalds 已提交
215

L
Len Brown 已提交
216
int acpi_bus_set_power(acpi_handle handle, int state)
L
Linus Torvalds 已提交
217
{
L
Len Brown 已提交
218 219 220 221
	int result = 0;
	acpi_status status = AE_OK;
	struct acpi_device *device = NULL;
	char object_name[5] = { '_', 'P', 'S', '0' + state, '\0' };
L
Linus Torvalds 已提交
222 223 224 225


	result = acpi_bus_get_device(handle, &device);
	if (result)
226
		return result;
L
Linus Torvalds 已提交
227 228

	if ((state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
229
		return -EINVAL;
L
Linus Torvalds 已提交
230 231 232 233

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

	if (!device->flags.power_manageable) {
234
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device `[%s]' is not power manageable\n",
235
				kobject_name(&device->dev.kobj)));
236
		return -ENODEV;
L
Linus Torvalds 已提交
237
	}
238
	/*
239
	 * Get device's current power state
240
	 */
241 242 243 244 245 246 247 248 249 250 251 252 253
	if (!acpi_power_nocheck) {
		/*
		 * Maybe the incorrect power state is returned on the bogus
		 * bios, which is different with the real power state.
		 * For example: the bios returns D0 state and the real power
		 * state is D3. OS expects to set the device to D0 state. In
		 * such case if OS uses the power state returned by the BIOS,
		 * the device can't be transisted to the correct power state.
		 * So if the acpi_power_nocheck is set, it is unnecessary to
		 * get the power state by calling acpi_bus_get_power.
		 */
		acpi_bus_get_power(device->handle, &device->power.state);
	}
254
	if ((state == device->power.state) && !device->flags.force_power_state) {
255 256 257
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n",
				  state));
		return 0;
L
Linus Torvalds 已提交
258
	}
259

L
Linus Torvalds 已提交
260
	if (!device->power.states[state].flags.valid) {
261
		printk(KERN_WARNING PREFIX "Device does not support D%d\n", state);
262
		return -ENODEV;
L
Linus Torvalds 已提交
263 264
	}
	if (device->parent && (state < device->parent->power.state)) {
265
		printk(KERN_WARNING PREFIX
266
			      "Cannot set device to a higher-powered"
267
			      " state than parent\n");
268
		return -ENODEV;
L
Linus Torvalds 已提交
269 270 271 272 273 274 275 276
	}

	/*
	 * 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.
277
	 */
L
Linus Torvalds 已提交
278 279 280 281 282 283 284
	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 已提交
285 286
			status = acpi_evaluate_object(device->handle,
						      object_name, NULL, NULL);
L
Linus Torvalds 已提交
287 288 289 290 291
			if (ACPI_FAILURE(status)) {
				result = -ENODEV;
				goto end;
			}
		}
L
Len Brown 已提交
292
	} else {
L
Linus Torvalds 已提交
293
		if (device->power.states[state].flags.explicit_set) {
L
Len Brown 已提交
294 295
			status = acpi_evaluate_object(device->handle,
						      object_name, NULL, NULL);
L
Linus Torvalds 已提交
296 297 298 299 300 301 302 303 304 305 306 307
			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 已提交
308
      end:
L
Linus Torvalds 已提交
309
	if (result)
310
		printk(KERN_WARNING PREFIX
L
Len Brown 已提交
311
			      "Device [%s] failed to transition to D%d\n",
312
			      device->pnp.bus_id, state);
313 314
	else {
		device->power.state = state;
L
Len Brown 已提交
315 316 317
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Device [%s] transitioned to D%d\n",
				  device->pnp.bus_id, state));
318
	}
L
Linus Torvalds 已提交
319

320
	return result;
L
Linus Torvalds 已提交
321 322
}

L
Len Brown 已提交
323
EXPORT_SYMBOL(acpi_bus_set_power);
L
Linus Torvalds 已提交
324

325 326 327 328 329 330 331 332 333 334 335
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);

336 337 338 339 340 341 342 343 344 345 346
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);

L
Linus Torvalds 已提交
347 348 349 350
/* --------------------------------------------------------------------------
                                Event Management
   -------------------------------------------------------------------------- */

351
#ifdef CONFIG_ACPI_PROC_EVENT
L
Linus Torvalds 已提交
352 353 354 355 356
static DEFINE_SPINLOCK(acpi_bus_event_lock);

LIST_HEAD(acpi_bus_event_list);
DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue);

L
Len Brown 已提交
357
extern int event_is_open;
L
Linus Torvalds 已提交
358

359
int acpi_bus_generate_proc_event4(const char *device_class, const char *bus_id, u8 type, int data)
L
Linus Torvalds 已提交
360
{
361
	struct acpi_bus_event *event;
L
Len Brown 已提交
362
	unsigned long flags = 0;
L
Linus Torvalds 已提交
363 364 365

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

	event = kmalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC);
	if (!event)
370
		return -ENOMEM;
L
Linus Torvalds 已提交
371

372 373
	strcpy(event->device_class, device_class);
	strcpy(event->bus_id, bus_id);
L
Linus Torvalds 已提交
374 375 376 377 378 379 380 381 382
	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);

383
	return 0;
384 385 386 387 388 389 390 391 392 393 394

}

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 已提交
395
}
L
Len Brown 已提交
396

397
EXPORT_SYMBOL(acpi_bus_generate_proc_event);
L
Linus Torvalds 已提交
398

L
Len Brown 已提交
399
int acpi_bus_receive_event(struct acpi_bus_event *event)
L
Linus Torvalds 已提交
400
{
L
Len Brown 已提交
401 402
	unsigned long flags = 0;
	struct acpi_bus_event *entry = NULL;
L
Linus Torvalds 已提交
403 404 405 406 407

	DECLARE_WAITQUEUE(wait, current);


	if (!event)
408
		return -EINVAL;
L
Linus Torvalds 已提交
409 410 411 412 413 414 415 416 417 418 419 420 421

	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))
422
			return -ERESTARTSYS;
L
Linus Torvalds 已提交
423 424 425
	}

	spin_lock_irqsave(&acpi_bus_event_lock, flags);
426 427 428
	if (!list_empty(&acpi_bus_event_list)) {
		entry = list_entry(acpi_bus_event_list.next,
				   struct acpi_bus_event, node);
L
Linus Torvalds 已提交
429
		list_del(&entry->node);
430
	}
L
Linus Torvalds 已提交
431 432 433
	spin_unlock_irqrestore(&acpi_bus_event_lock, flags);

	if (!entry)
434
		return -ENODEV;
L
Linus Torvalds 已提交
435 436 437 438 439

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

	kfree(entry);

440
	return 0;
L
Linus Torvalds 已提交
441 442
}

443
#endif	/* CONFIG_ACPI_PROC_EVENT */
L
Linus Torvalds 已提交
444 445 446 447 448

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

449
static void acpi_bus_check_device(acpi_handle handle)
L
Linus Torvalds 已提交
450
{
451
	struct acpi_device *device;
452
	acpi_status status;
L
Linus Torvalds 已提交
453 454
	struct acpi_device_status old_status;

455 456
	if (acpi_bus_get_device(handle, &device))
		return;
L
Linus Torvalds 已提交
457
	if (!device)
458
		return;
L
Linus Torvalds 已提交
459 460 461 462 463 464 465 466 467

	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;
468
		return;
L
Linus Torvalds 已提交
469 470 471 472
	}

	status = acpi_bus_get_status(device);
	if (ACPI_FAILURE(status))
473
		return;
L
Linus Torvalds 已提交
474 475

	if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status))
476
		return;
L
Linus Torvalds 已提交
477 478 479 480 481 482 483

	/*
	 * 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 已提交
484
	} else if (!(device->status.present) && (old_status.present)) {
L
Linus Torvalds 已提交
485 486 487 488 489
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n"));
		/* TBD: Handle device removal */
	}
}

490
static void acpi_bus_check_scope(acpi_handle handle)
L
Linus Torvalds 已提交
491 492
{
	/* Status Change? */
493
	acpi_bus_check_device(handle);
L
Linus Torvalds 已提交
494 495 496 497 498 499 500

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

501 502 503 504 505 506 507 508 509 510 511 512 513
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 已提交
514 515 516 517 518
/**
 * acpi_bus_notify
 * ---------------
 * Callback for all 'system-level' device notifications (values 0x00-0x7F).
 */
L
Len Brown 已提交
519
static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
L
Linus Torvalds 已提交
520
{
L
Len Brown 已提交
521
	struct acpi_device *device = NULL;
522
	struct acpi_driver *driver;
L
Linus Torvalds 已提交
523

524 525 526
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Notification %#02x to handle %p\n",
			  type, handle));

527 528
	blocking_notifier_call_chain(&acpi_bus_notify_list,
		type, (void *)handle);
L
Linus Torvalds 已提交
529 530 531 532

	switch (type) {

	case ACPI_NOTIFY_BUS_CHECK:
533
		acpi_bus_check_scope(handle);
534
		/*
L
Linus Torvalds 已提交
535
		 * TBD: We'll need to outsource certain events to non-ACPI
L
Len Brown 已提交
536
		 *      drivers via the device manager (device.c).
L
Linus Torvalds 已提交
537 538 539 540
		 */
		break;

	case ACPI_NOTIFY_DEVICE_CHECK:
541
		acpi_bus_check_device(handle);
542
		/*
L
Linus Torvalds 已提交
543
		 * TBD: We'll need to outsource certain events to non-ACPI
L
Len Brown 已提交
544
		 *      drivers via the device manager (device.c).
L
Linus Torvalds 已提交
545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572
		 */
		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 已提交
573 574 575
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Received unknown/unsupported notification [%08x]\n",
				  type));
L
Linus Torvalds 已提交
576 577 578
		break;
	}

579 580 581 582 583 584 585
	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 已提交
586 587 588 589 590 591
}

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

L
Len Brown 已提交
592
static int __init acpi_bus_init_irq(void)
L
Linus Torvalds 已提交
593
{
L
Len Brown 已提交
594 595 596 597
	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 已提交
598 599


600
	/*
L
Linus Torvalds 已提交
601 602 603 604 605 606 607 608 609 610 611 612 613 614
	 * 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 已提交
615 616 617
	case ACPI_IRQ_MODEL_PLATFORM:
		message = "platform specific model";
		break;
L
Linus Torvalds 已提交
618 619
	default:
		printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
620
		return -ENODEV;
L
Linus Torvalds 已提交
621 622 623 624 625 626 627 628
	}

	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)) {
629
		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC"));
630
		return -ENODEV;
L
Linus Torvalds 已提交
631 632
	}

633
	return 0;
L
Linus Torvalds 已提交
634 635
}

636
u8 acpi_gbl_permanent_mmap;
637 638


L
Len Brown 已提交
639
void __init acpi_early_init(void)
L
Linus Torvalds 已提交
640
{
L
Len Brown 已提交
641
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
642 643

	if (acpi_disabled)
644
		return;
L
Linus Torvalds 已提交
645

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

L
Linus Torvalds 已提交
648 649 650 651
	/* enable workarounds, unless strict ACPI spec. compliance */
	if (!acpi_strict)
		acpi_gbl_enable_interpreter_slack = TRUE;

652 653 654 655 656 657 658 659 660
	acpi_gbl_permanent_mmap = 1;

	status = acpi_reallocate_root_table();
	if (ACPI_FAILURE(status)) {
		printk(KERN_ERR PREFIX
		       "Unable to reallocate ACPI tables\n");
		goto error0;
	}

L
Linus Torvalds 已提交
661 662
	status = acpi_initialize_subsystem();
	if (ACPI_FAILURE(status)) {
L
Len Brown 已提交
663 664
		printk(KERN_ERR PREFIX
		       "Unable to initialize the ACPI Interpreter\n");
L
Linus Torvalds 已提交
665 666 667 668 669
		goto error0;
	}

	status = acpi_load_tables();
	if (ACPI_FAILURE(status)) {
L
Len Brown 已提交
670 671
		printk(KERN_ERR PREFIX
		       "Unable to load the System Description Tables\n");
L
Linus Torvalds 已提交
672 673 674 675 676 677
		goto error0;
	}

#ifdef CONFIG_X86
	if (!acpi_ioapic) {
		/* compatible (0) means level (3) */
678 679 680 681
		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 已提交
682
		/* Set PIC-mode SCI trigger type */
683
		acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt,
684
					 (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2);
L
Linus Torvalds 已提交
685 686
	} else {
		/*
687
		 * now that acpi_gbl_FADT is initialized,
L
Linus Torvalds 已提交
688 689
		 * update it with result from INT_SRC_OVR parsing
		 */
690
		acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi;
L
Linus Torvalds 已提交
691 692 693
	}
#endif

L
Len Brown 已提交
694 695 696 697
	status =
	    acpi_enable_subsystem(~
				  (ACPI_NO_HARDWARE_INIT |
				   ACPI_NO_ACPI_ENABLE));
L
Linus Torvalds 已提交
698 699 700 701 702
	if (ACPI_FAILURE(status)) {
		printk(KERN_ERR PREFIX "Unable to enable ACPI\n");
		goto error0;
	}

703
	return;
L
Linus Torvalds 已提交
704

L
Len Brown 已提交
705
      error0:
L
Linus Torvalds 已提交
706
	disable_acpi();
707
	return;
L
Linus Torvalds 已提交
708 709
}

L
Len Brown 已提交
710
static int __init acpi_bus_init(void)
L
Linus Torvalds 已提交
711
{
L
Len Brown 已提交
712 713 714
	int result = 0;
	acpi_status status = AE_OK;
	extern acpi_status acpi_os_initialize1(void);
L
Linus Torvalds 已提交
715

716
	acpi_os_initialize1();
L
Linus Torvalds 已提交
717

L
Len Brown 已提交
718 719
	status =
	    acpi_enable_subsystem(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE);
L
Linus Torvalds 已提交
720
	if (ACPI_FAILURE(status)) {
L
Len Brown 已提交
721 722
		printk(KERN_ERR PREFIX
		       "Unable to start the ACPI Interpreter\n");
L
Linus Torvalds 已提交
723 724 725 726 727 728 729 730
		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).
	 *
731
	 * This is accomplished by looking for the ECDT table, and getting
L
Linus Torvalds 已提交
732 733 734 735 736 737 738 739 740 741 742
	 * the EC parameters out of that.
	 */
	status = acpi_ec_ecdt_probe();
	/* Ignore result. Not having an ECDT is not fatal. */

	status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
	if (ACPI_FAILURE(status)) {
		printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n");
		goto error1;
	}

743 744 745 746 747 748
	/*
	 * 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 已提交
749 750
	printk(KERN_INFO PREFIX "Interpreter enabled\n");

751 752 753
	/* Initialize sleep structures */
	acpi_sleep_init();

L
Linus Torvalds 已提交
754 755 756 757 758 759 760 761 762 763
	/*
	 * 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 已提交
764 765 766
	status =
	    acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
					&acpi_bus_notify, NULL);
L
Linus Torvalds 已提交
767
	if (ACPI_FAILURE(status)) {
L
Len Brown 已提交
768 769
		printk(KERN_ERR PREFIX
		       "Unable to register for device notifications\n");
L
Linus Torvalds 已提交
770 771 772 773 774 775 776 777
		goto error1;
	}

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

778
	return 0;
L
Linus Torvalds 已提交
779 780

	/* Mimic structured exception handling */
L
Len Brown 已提交
781
      error1:
L
Linus Torvalds 已提交
782
	acpi_terminate();
783
	return -ENODEV;
L
Linus Torvalds 已提交
784 785
}

786
struct kobject *acpi_kobj;
L
Linus Torvalds 已提交
787

L
Len Brown 已提交
788
static int __init acpi_init(void)
L
Linus Torvalds 已提交
789
{
L
Len Brown 已提交
790
	int result = 0;
L
Linus Torvalds 已提交
791 792 793 794


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

798
	acpi_kobj = kobject_create_and_add("acpi", firmware_kobj);
799
	if (!acpi_kobj) {
800
		printk(KERN_WARNING "%s: kset create error\n", __func__);
801 802
		acpi_kobj = NULL;
	}
L
Linus Torvalds 已提交
803

804
	init_acpi_device_notify();
L
Linus Torvalds 已提交
805 806 807
	result = acpi_bus_init();

	if (!result) {
808
		pci_mmcfg_late_init();
809 810
		if (!(pm_flags & PM_APM))
			pm_flags |= PM_ACPI;
L
Linus Torvalds 已提交
811
		else {
L
Len Brown 已提交
812 813
			printk(KERN_INFO PREFIX
			       "APM is already active, exiting\n");
L
Linus Torvalds 已提交
814 815 816 817 818
			disable_acpi();
			result = -ENODEV;
		}
	} else
		disable_acpi();
819 820 821 822

	if (acpi_disabled)
		return result;

823 824 825 826 827
	/*
	 * If the laptop falls into the DMI check table, the power state check
	 * will be disabled in the course of device power transistion.
	 */
	dmi_check_system(power_nocheck_dmi_table);
828 829

	acpi_scan_init();
830
	acpi_ec_init();
831
	acpi_power_init();
832
	acpi_system_init();
833
	acpi_debug_init();
834
	acpi_sleep_proc_init();
835
	acpi_wakeup_device_init();
836
	return result;
L
Linus Torvalds 已提交
837 838 839
}

subsys_initcall(acpi_init);