bus.c 18.5 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
#include <linux/list.h>
#include <linux/sched.h>
#include <linux/pm.h>
32
#include <linux/pm_legacy.h>
L
Linus Torvalds 已提交
33 34 35 36 37 38 39 40 41
#include <linux/device.h>
#include <linux/proc_fs.h>
#ifdef CONFIG_X86
#include <asm/mpspec.h>
#endif
#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>

#define _COMPONENT		ACPI_BUS_COMPONENT
L
Len Brown 已提交
42
ACPI_MODULE_NAME("acpi_bus")
L
Linus Torvalds 已提交
43 44 45 46
#ifdef	CONFIG_X86
extern void __init acpi_pic_sci_set_trigger(unsigned int irq, u16 trigger);
#endif

B
Bob Moore 已提交
47
struct fadt_descriptor acpi_fadt;
L
Linus Torvalds 已提交
48 49
EXPORT_SYMBOL(acpi_fadt);

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

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

/* --------------------------------------------------------------------------
                                Device Management
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
60
int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
L
Linus Torvalds 已提交
61
{
L
Len Brown 已提交
62
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
63 64 65


	if (!device)
66
		return -EINVAL;
L
Linus Torvalds 已提交
67 68 69

	/* TBD: Support fixed-feature devices */

L
Len Brown 已提交
70
	status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device);
L
Linus Torvalds 已提交
71
	if (ACPI_FAILURE(status) || !*device) {
72 73
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
				  handle));
74
		return -ENODEV;
L
Linus Torvalds 已提交
75 76
	}

77
	return 0;
L
Linus Torvalds 已提交
78
}
L
Len Brown 已提交
79

L
Linus Torvalds 已提交
80 81
EXPORT_SYMBOL(acpi_bus_get_device);

L
Len Brown 已提交
82
int acpi_bus_get_status(struct acpi_device *device)
L
Linus Torvalds 已提交
83
{
L
Len Brown 已提交
84 85 86
	acpi_status status = AE_OK;
	unsigned long sta = 0;

L
Linus Torvalds 已提交
87 88

	if (!device)
89
		return -EINVAL;
L
Linus Torvalds 已提交
90 91 92 93 94

	/*
	 * Evaluate _STA if present.
	 */
	if (device->flags.dynamic_status) {
L
Len Brown 已提交
95 96
		status =
		    acpi_evaluate_integer(device->handle, "_STA", NULL, &sta);
L
Linus Torvalds 已提交
97
		if (ACPI_FAILURE(status))
98
			return -ENODEV;
L
Len Brown 已提交
99
		STRUCT_TO_INT(device->status) = (int)sta;
L
Linus Torvalds 已提交
100 101 102 103 104 105 106 107 108 109 110 111 112
	}

	/*
	 * Otherwise we assume the status of our parent (unless we don't
	 * have one, in which case status is implied).
	 */
	else if (device->parent)
		device->status = device->parent->status;
	else
		STRUCT_TO_INT(device->status) = 0x0F;

	if (device->status.functional && !device->status.present) {
		printk(KERN_WARNING PREFIX "Device [%s] status [%08x]: "
L
Len Brown 已提交
113 114
		       "functional but not present; setting present\n",
		       device->pnp.bus_id, (u32) STRUCT_TO_INT(device->status));
L
Linus Torvalds 已提交
115 116 117
		device->status.present = 1;
	}

L
Len Brown 已提交
118 119 120
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n",
			  device->pnp.bus_id,
			  (u32) STRUCT_TO_INT(device->status)));
L
Linus Torvalds 已提交
121

122
	return 0;
L
Linus Torvalds 已提交
123 124
}

L
Len Brown 已提交
125
EXPORT_SYMBOL(acpi_bus_get_status);
L
Linus Torvalds 已提交
126 127 128 129 130

/* --------------------------------------------------------------------------
                                 Power Management
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
131
int acpi_bus_get_power(acpi_handle handle, int *state)
L
Linus Torvalds 已提交
132
{
L
Len Brown 已提交
133 134 135 136
	int result = 0;
	acpi_status status = 0;
	struct acpi_device *device = NULL;
	unsigned long psc = 0;
L
Linus Torvalds 已提交
137 138 139 140


	result = acpi_bus_get_device(handle, &device);
	if (result)
141
		return result;
L
Linus Torvalds 已提交
142 143 144 145 146 147 148 149 150

	*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 已提交
151
	} else {
L
Linus Torvalds 已提交
152 153 154 155 156
		/*
		 * Get the device's power state either directly (via _PSC) or 
		 * indirectly (via power resources).
		 */
		if (device->power.flags.explicit_get) {
L
Len Brown 已提交
157 158
			status = acpi_evaluate_integer(device->handle, "_PSC",
						       NULL, &psc);
L
Linus Torvalds 已提交
159
			if (ACPI_FAILURE(status))
160
				return -ENODEV;
L
Len Brown 已提交
161 162
			device->power.state = (int)psc;
		} else if (device->power.flags.power_resources) {
L
Linus Torvalds 已提交
163 164
			result = acpi_power_get_inferred_state(device);
			if (result)
165
				return result;
L
Linus Torvalds 已提交
166 167 168 169 170 171
		}

		*state = device->power.state;
	}

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

174
	return 0;
L
Linus Torvalds 已提交
175 176
}

L
Len Brown 已提交
177
EXPORT_SYMBOL(acpi_bus_get_power);
L
Linus Torvalds 已提交
178

L
Len Brown 已提交
179
int acpi_bus_set_power(acpi_handle handle, int state)
L
Linus Torvalds 已提交
180
{
L
Len Brown 已提交
181 182 183 184
	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 已提交
185 186 187 188


	result = acpi_bus_get_device(handle, &device);
	if (result)
189
		return result;
L
Linus Torvalds 已提交
190 191

	if ((state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
192
		return -EINVAL;
L
Linus Torvalds 已提交
193 194 195 196

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

	if (!device->flags.power_manageable) {
197
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device `[%s]' is not power manageable\n",
198
				device->kobj.name));
199
		return -ENODEV;
L
Linus Torvalds 已提交
200
	}
201 202 203 204
	/*
	 * Get device's current power state if it's unknown
	 * This means device power state isn't initialized or previous setting failed
	 */
205 206 207 208 209 210
	if (!device->flags.force_power_state) {
		if (device->power.state == ACPI_STATE_UNKNOWN)
			acpi_bus_get_power(device->handle, &device->power.state);
		if (state == device->power.state) {
			ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n",
					  state));
211
			return 0;
212
		}
L
Linus Torvalds 已提交
213 214
	}
	if (!device->power.states[state].flags.valid) {
215
		printk(KERN_WARNING PREFIX "Device does not support D%d\n", state);
216
		return -ENODEV;
L
Linus Torvalds 已提交
217 218
	}
	if (device->parent && (state < device->parent->power.state)) {
219
		printk(KERN_WARNING PREFIX
220
			      "Cannot set device to a higher-powered"
221
			      " state than parent\n");
222
		return -ENODEV;
L
Linus Torvalds 已提交
223 224 225 226 227 228 229 230
	}

	/*
	 * 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.
231
	 */
L
Linus Torvalds 已提交
232 233 234 235 236 237 238
	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 已提交
239 240
			status = acpi_evaluate_object(device->handle,
						      object_name, NULL, NULL);
L
Linus Torvalds 已提交
241 242 243 244 245
			if (ACPI_FAILURE(status)) {
				result = -ENODEV;
				goto end;
			}
		}
L
Len Brown 已提交
246
	} else {
L
Linus Torvalds 已提交
247
		if (device->power.states[state].flags.explicit_set) {
L
Len Brown 已提交
248 249
			status = acpi_evaluate_object(device->handle,
						      object_name, NULL, NULL);
L
Linus Torvalds 已提交
250 251 252 253 254 255 256 257 258 259 260 261
			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 已提交
262
      end:
L
Linus Torvalds 已提交
263
	if (result)
264 265 266
		printk(KERN_WARNING PREFIX
			      "Transitioning device [%s] to D%d\n",
			      device->pnp.bus_id, state);
L
Linus Torvalds 已提交
267
	else
L
Len Brown 已提交
268 269 270
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Device [%s] transitioned to D%d\n",
				  device->pnp.bus_id, state));
L
Linus Torvalds 已提交
271

272
	return result;
L
Linus Torvalds 已提交
273 274
}

L
Len Brown 已提交
275
EXPORT_SYMBOL(acpi_bus_set_power);
L
Linus Torvalds 已提交
276 277 278 279 280 281 282 283 284 285

/* --------------------------------------------------------------------------
                                Event Management
   -------------------------------------------------------------------------- */

static DEFINE_SPINLOCK(acpi_bus_event_lock);

LIST_HEAD(acpi_bus_event_list);
DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue);

L
Len Brown 已提交
286
extern int event_is_open;
L
Linus Torvalds 已提交
287

L
Len Brown 已提交
288
int acpi_bus_generate_event(struct acpi_device *device, u8 type, int data)
L
Linus Torvalds 已提交
289
{
L
Len Brown 已提交
290 291
	struct acpi_bus_event *event = NULL;
	unsigned long flags = 0;
L
Linus Torvalds 已提交
292 293 294


	if (!device)
295
		return -EINVAL;
L
Linus Torvalds 已提交
296 297 298

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

	event = kmalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC);
	if (!event)
303
		return -ENOMEM;
L
Linus Torvalds 已提交
304 305 306 307 308 309 310 311 312 313 314 315

	strcpy(event->device_class, device->pnp.device_class);
	strcpy(event->bus_id, device->pnp.bus_id);
	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);

316
	return 0;
L
Linus Torvalds 已提交
317
}
L
Len Brown 已提交
318

L
Linus Torvalds 已提交
319 320
EXPORT_SYMBOL(acpi_bus_generate_event);

L
Len Brown 已提交
321
int acpi_bus_receive_event(struct acpi_bus_event *event)
L
Linus Torvalds 已提交
322
{
L
Len Brown 已提交
323 324
	unsigned long flags = 0;
	struct acpi_bus_event *entry = NULL;
L
Linus Torvalds 已提交
325 326 327 328 329

	DECLARE_WAITQUEUE(wait, current);


	if (!event)
330
		return -EINVAL;
L
Linus Torvalds 已提交
331 332 333 334 335 336 337 338 339 340 341 342 343

	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))
344
			return -ERESTARTSYS;
L
Linus Torvalds 已提交
345 346 347
	}

	spin_lock_irqsave(&acpi_bus_event_lock, flags);
L
Len Brown 已提交
348 349
	entry =
	    list_entry(acpi_bus_event_list.next, struct acpi_bus_event, node);
L
Linus Torvalds 已提交
350 351 352 353 354
	if (entry)
		list_del(&entry->node);
	spin_unlock_irqrestore(&acpi_bus_event_lock, flags);

	if (!entry)
355
		return -ENODEV;
L
Linus Torvalds 已提交
356 357 358 359 360

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

	kfree(entry);

361
	return 0;
L
Linus Torvalds 已提交
362 363
}

L
Len Brown 已提交
364
EXPORT_SYMBOL(acpi_bus_receive_event);
L
Linus Torvalds 已提交
365 366 367 368 369 370

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

static int
L
Len Brown 已提交
371
acpi_bus_check_device(struct acpi_device *device, int *status_changed)
L
Linus Torvalds 已提交
372
{
L
Len Brown 已提交
373
	acpi_status status = 0;
L
Linus Torvalds 已提交
374 375 376 377
	struct acpi_device_status old_status;


	if (!device)
378
		return -EINVAL;
L
Linus Torvalds 已提交
379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394

	if (status_changed)
		*status_changed = 0;

	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;
		if (STRUCT_TO_INT(old_status) != STRUCT_TO_INT(device->status)) {
			if (status_changed)
				*status_changed = 1;
		}
395
		return 0;
L
Linus Torvalds 已提交
396 397 398 399
	}

	status = acpi_bus_get_status(device);
	if (ACPI_FAILURE(status))
400
		return -ENODEV;
L
Linus Torvalds 已提交
401 402

	if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status))
403
		return 0;
L
Linus Torvalds 已提交
404 405 406

	if (status_changed)
		*status_changed = 1;
L
Len Brown 已提交
407

L
Linus Torvalds 已提交
408 409 410 411 412 413
	/*
	 * 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 已提交
414
	} else if (!(device->status.present) && (old_status.present)) {
L
Linus Torvalds 已提交
415 416 417 418
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n"));
		/* TBD: Handle device removal */
	}

419
	return 0;
L
Linus Torvalds 已提交
420 421
}

L
Len Brown 已提交
422
static int acpi_bus_check_scope(struct acpi_device *device)
L
Linus Torvalds 已提交
423
{
L
Len Brown 已提交
424 425
	int result = 0;
	int status_changed = 0;
L
Linus Torvalds 已提交
426 427 428


	if (!device)
429
		return -EINVAL;
L
Linus Torvalds 已提交
430 431 432 433

	/* Status Change? */
	result = acpi_bus_check_device(device, &status_changed);
	if (result)
434
		return result;
L
Linus Torvalds 已提交
435 436

	if (!status_changed)
437
		return 0;
L
Linus Torvalds 已提交
438 439 440 441 442 443

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

444
	return 0;
L
Linus Torvalds 已提交
445 446 447 448 449 450 451
}

/**
 * acpi_bus_notify
 * ---------------
 * Callback for all 'system-level' device notifications (values 0x00-0x7F).
 */
L
Len Brown 已提交
452
static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
L
Linus Torvalds 已提交
453
{
L
Len Brown 已提交
454 455
	int result = 0;
	struct acpi_device *device = NULL;
L
Linus Torvalds 已提交
456 457 458


	if (acpi_bus_get_device(handle, &device))
459
		return;
L
Linus Torvalds 已提交
460 461 462 463

	switch (type) {

	case ACPI_NOTIFY_BUS_CHECK:
L
Len Brown 已提交
464 465 466
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Received BUS CHECK notification for device [%s]\n",
				  device->pnp.bus_id));
L
Linus Torvalds 已提交
467 468 469
		result = acpi_bus_check_scope(device);
		/* 
		 * TBD: We'll need to outsource certain events to non-ACPI
L
Len Brown 已提交
470
		 *      drivers via the device manager (device.c).
L
Linus Torvalds 已提交
471 472 473 474
		 */
		break;

	case ACPI_NOTIFY_DEVICE_CHECK:
L
Len Brown 已提交
475 476 477
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Received DEVICE CHECK notification for device [%s]\n",
				  device->pnp.bus_id));
L
Linus Torvalds 已提交
478 479 480
		result = acpi_bus_check_device(device, NULL);
		/* 
		 * TBD: We'll need to outsource certain events to non-ACPI
L
Len Brown 已提交
481
		 *      drivers via the device manager (device.c).
L
Linus Torvalds 已提交
482 483 484 485
		 */
		break;

	case ACPI_NOTIFY_DEVICE_WAKE:
L
Len Brown 已提交
486 487 488
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Received DEVICE WAKE notification for device [%s]\n",
				  device->pnp.bus_id));
L
Linus Torvalds 已提交
489 490 491 492
		/* TBD */
		break;

	case ACPI_NOTIFY_EJECT_REQUEST:
L
Len Brown 已提交
493 494 495
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Received EJECT REQUEST notification for device [%s]\n",
				  device->pnp.bus_id));
L
Linus Torvalds 已提交
496 497 498 499
		/* TBD */
		break;

	case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
L
Len Brown 已提交
500 501 502
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Received DEVICE CHECK LIGHT notification for device [%s]\n",
				  device->pnp.bus_id));
L
Linus Torvalds 已提交
503 504 505 506
		/* TBD: Exactly what does 'light' mean? */
		break;

	case ACPI_NOTIFY_FREQUENCY_MISMATCH:
L
Len Brown 已提交
507 508 509
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Received FREQUENCY MISMATCH notification for device [%s]\n",
				  device->pnp.bus_id));
L
Linus Torvalds 已提交
510 511 512 513
		/* TBD */
		break;

	case ACPI_NOTIFY_BUS_MODE_MISMATCH:
L
Len Brown 已提交
514 515 516
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Received BUS MODE MISMATCH notification for device [%s]\n",
				  device->pnp.bus_id));
L
Linus Torvalds 已提交
517 518 519 520
		/* TBD */
		break;

	case ACPI_NOTIFY_POWER_FAULT:
L
Len Brown 已提交
521 522 523
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Received POWER FAULT notification for device [%s]\n",
				  device->pnp.bus_id));
L
Linus Torvalds 已提交
524 525 526 527
		/* TBD */
		break;

	default:
L
Len Brown 已提交
528 529 530
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Received unknown/unsupported notification [%08x]\n",
				  type));
L
Linus Torvalds 已提交
531 532 533
		break;
	}

534
	return;
L
Linus Torvalds 已提交
535 536 537 538 539 540
}

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

L
Len Brown 已提交
541
static int __init acpi_bus_init_irq(void)
L
Linus Torvalds 已提交
542
{
L
Len Brown 已提交
543 544 545 546
	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 已提交
547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563


	/* 
	 * 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 已提交
564 565 566
	case ACPI_IRQ_MODEL_PLATFORM:
		message = "platform specific model";
		break;
L
Linus Torvalds 已提交
567 568
	default:
		printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
569
		return -ENODEV;
L
Linus Torvalds 已提交
570 571 572 573 574 575 576 577
	}

	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)) {
578
		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC"));
579
		return -ENODEV;
L
Linus Torvalds 已提交
580 581
	}

582
	return 0;
L
Linus Torvalds 已提交
583 584
}

L
Len Brown 已提交
585
void __init acpi_early_init(void)
L
Linus Torvalds 已提交
586
{
L
Len Brown 已提交
587 588
	acpi_status status = AE_OK;
	struct acpi_buffer buffer = { sizeof(acpi_fadt), &acpi_fadt };
L
Linus Torvalds 已提交
589 590 591


	if (acpi_disabled)
592
		return;
L
Linus Torvalds 已提交
593

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

L
Linus Torvalds 已提交
596 597 598 599 600 601
	/* enable workarounds, unless strict ACPI spec. compliance */
	if (!acpi_strict)
		acpi_gbl_enable_interpreter_slack = TRUE;

	status = acpi_initialize_subsystem();
	if (ACPI_FAILURE(status)) {
L
Len Brown 已提交
602 603
		printk(KERN_ERR PREFIX
		       "Unable to initialize the ACPI Interpreter\n");
L
Linus Torvalds 已提交
604 605 606 607 608
		goto error0;
	}

	status = acpi_load_tables();
	if (ACPI_FAILURE(status)) {
L
Len Brown 已提交
609 610
		printk(KERN_ERR PREFIX
		       "Unable to load the System Description Tables\n");
L
Linus Torvalds 已提交
611 612 613 614 615 616
		goto error0;
	}

	/*
	 * Get a separate copy of the FADT for use by other drivers.
	 */
B
Bob Moore 已提交
617
	status = acpi_get_table(ACPI_TABLE_ID_FADT, 1, &buffer);
L
Linus Torvalds 已提交
618 619 620 621 622 623 624 625 626 627 628 629 630
	if (ACPI_FAILURE(status)) {
		printk(KERN_ERR PREFIX "Unable to get the FADT\n");
		goto error0;
	}
#ifdef CONFIG_X86
	if (!acpi_ioapic) {
		extern acpi_interrupt_flags acpi_sci_flags;

		/* compatible (0) means level (3) */
		if (acpi_sci_flags.trigger == 0)
			acpi_sci_flags.trigger = 3;

		/* Set PIC-mode SCI trigger type */
L
Len Brown 已提交
631 632
		acpi_pic_sci_set_trigger(acpi_fadt.sci_int,
					 acpi_sci_flags.trigger);
L
Linus Torvalds 已提交
633 634 635 636 637 638 639 640 641 642
	} else {
		extern int acpi_sci_override_gsi;
		/*
		 * now that acpi_fadt is initialized,
		 * update it with result from INT_SRC_OVR parsing
		 */
		acpi_fadt.sci_int = acpi_sci_override_gsi;
	}
#endif

L
Len Brown 已提交
643 644 645 646
	status =
	    acpi_enable_subsystem(~
				  (ACPI_NO_HARDWARE_INIT |
				   ACPI_NO_ACPI_ENABLE));
L
Linus Torvalds 已提交
647 648 649 650 651
	if (ACPI_FAILURE(status)) {
		printk(KERN_ERR PREFIX "Unable to enable ACPI\n");
		goto error0;
	}

652
	return;
L
Linus Torvalds 已提交
653

L
Len Brown 已提交
654
      error0:
L
Linus Torvalds 已提交
655
	disable_acpi();
656
	return;
L
Linus Torvalds 已提交
657 658
}

L
Len Brown 已提交
659
static int __init acpi_bus_init(void)
L
Linus Torvalds 已提交
660
{
L
Len Brown 已提交
661 662 663
	int result = 0;
	acpi_status status = AE_OK;
	extern acpi_status acpi_os_initialize1(void);
L
Linus Torvalds 已提交
664 665 666 667


	status = acpi_os_initialize1();

L
Len Brown 已提交
668 669
	status =
	    acpi_enable_subsystem(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE);
L
Linus Torvalds 已提交
670
	if (ACPI_FAILURE(status)) {
L
Len Brown 已提交
671 672
		printk(KERN_ERR PREFIX
		       "Unable to start the ACPI Interpreter\n");
L
Linus Torvalds 已提交
673 674 675 676
		goto error1;
	}

	if (ACPI_FAILURE(status)) {
L
Len Brown 已提交
677 678
		printk(KERN_ERR PREFIX
		       "Unable to initialize ACPI OS objects\n");
L
Linus Torvalds 已提交
679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711
		goto error1;
	}
#ifdef CONFIG_ACPI_EC
	/*
	 * 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).
	 *
	 * This is accomplished by looking for the ECDT table, and getting 
	 * the EC parameters out of that.
	 */
	status = acpi_ec_ecdt_probe();
	/* Ignore result. Not having an ECDT is not fatal. */
#endif

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

	printk(KERN_INFO PREFIX "Interpreter enabled\n");

	/*
	 * 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 已提交
712 713 714
	status =
	    acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
					&acpi_bus_notify, NULL);
L
Linus Torvalds 已提交
715
	if (ACPI_FAILURE(status)) {
L
Len Brown 已提交
716 717
		printk(KERN_ERR PREFIX
		       "Unable to register for device notifications\n");
L
Linus Torvalds 已提交
718 719 720 721 722 723 724 725
		goto error1;
	}

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

726
	return 0;
L
Linus Torvalds 已提交
727 728

	/* Mimic structured exception handling */
L
Len Brown 已提交
729
      error1:
L
Linus Torvalds 已提交
730
	acpi_terminate();
731
	return -ENODEV;
L
Linus Torvalds 已提交
732 733
}

L
Len Brown 已提交
734
decl_subsys(acpi, NULL, NULL);
L
Linus Torvalds 已提交
735

L
Len Brown 已提交
736
static int __init acpi_init(void)
L
Linus Torvalds 已提交
737
{
L
Len Brown 已提交
738
	int result = 0;
L
Linus Torvalds 已提交
739 740 741 742


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

746 747 748 749
	result = firmware_register(&acpi_subsys);
	if (result < 0)
		printk(KERN_WARNING "%s: firmware_register error: %d\n",
			__FUNCTION__, result);
L
Linus Torvalds 已提交
750 751 752 753

	result = acpi_bus_init();

	if (!result) {
754
#ifdef CONFIG_PM_LEGACY
L
Linus Torvalds 已提交
755 756 757
		if (!PM_IS_ACTIVE())
			pm_active = 1;
		else {
L
Len Brown 已提交
758 759
			printk(KERN_INFO PREFIX
			       "APM is already active, exiting\n");
L
Linus Torvalds 已提交
760 761 762 763 764 765 766
			disable_acpi();
			result = -ENODEV;
		}
#endif
	} else
		disable_acpi();

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

subsys_initcall(acpi_init);