evmisc.c 17.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7
/******************************************************************************
 *
 * Module Name: evmisc - Miscellaneous event manager support functions
 *
 *****************************************************************************/

/*
L
Len Brown 已提交
8
 * Copyright (C) 2000 - 2008, Intel Corp.
L
Linus Torvalds 已提交
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer,
 *    without modification.
 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 *    substantially similar to the "NO WARRANTY" disclaimer below
 *    ("Disclaimer") and any redistribution must be conditioned upon
 *    including a substantially similar Disclaimer requirement for further
 *    binary redistribution.
 * 3. Neither the names of the above-listed copyright holders nor the names
 *    of any contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * NO WARRANTY
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 */

#include <acpi/acpi.h>
L
Len Brown 已提交
45 46 47 48
#include "accommon.h"
#include "acevents.h"
#include "acnamesp.h"
#include "acinterp.h"
L
Linus Torvalds 已提交
49 50

#define _COMPONENT          ACPI_EVENTS
L
Len Brown 已提交
51
ACPI_MODULE_NAME("evmisc")
L
Linus Torvalds 已提交
52

R
Robert Moore 已提交
53
/* Local prototypes */
L
Len Brown 已提交
54
static void ACPI_SYSTEM_XFACE acpi_ev_notify_dispatch(void *context);
R
Robert Moore 已提交
55

L
Len Brown 已提交
56
static u32 acpi_ev_global_lock_handler(void *context);
R
Robert Moore 已提交
57

58 59
static acpi_status acpi_ev_remove_global_lock_handler(void);

L
Linus Torvalds 已提交
60 61 62 63 64 65 66 67 68 69 70 71 72 73
/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_is_notify_object
 *
 * PARAMETERS:  Node            - Node to check
 *
 * RETURN:      TRUE if notifies allowed on this object
 *
 * DESCRIPTION: Check type of node for a object that supports notifies.
 *
 *              TBD: This could be replaced by a flag bit in the node.
 *
 ******************************************************************************/

L
Len Brown 已提交
74
u8 acpi_ev_is_notify_object(struct acpi_namespace_node *node)
L
Linus Torvalds 已提交
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
{
	switch (node->type) {
	case ACPI_TYPE_DEVICE:
	case ACPI_TYPE_PROCESSOR:
	case ACPI_TYPE_THERMAL:
		/*
		 * These are the ONLY objects that can receive ACPI notifications
		 */
		return (TRUE);

	default:
		return (FALSE);
	}
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_queue_notify_request
 *
 * PARAMETERS:  Node            - NS node for the notified object
 *              notify_value    - Value from the Notify() request
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Dispatch a device notification event to a previously
 *              installed handler.
 *
 ******************************************************************************/

acpi_status
L
Len Brown 已提交
105 106
acpi_ev_queue_notify_request(struct acpi_namespace_node * node,
			     u32 notify_value)
L
Linus Torvalds 已提交
107
{
L
Len Brown 已提交
108 109 110 111
	union acpi_operand_object *obj_desc;
	union acpi_operand_object *handler_obj = NULL;
	union acpi_generic_state *notify_info;
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
112

B
Bob Moore 已提交
113
	ACPI_FUNCTION_NAME(ev_queue_notify_request);
L
Linus Torvalds 已提交
114 115 116

	/*
	 * For value 3 (Ejection Request), some device method may need to be run.
R
Robert Moore 已提交
117 118
	 * For value 2 (Device Wake) if _PRW exists, the _PS0 method may need
	 *   to be run.
L
Linus Torvalds 已提交
119
	 * For value 0x80 (Status Change) on the power button or sleep button,
R
Robert Moore 已提交
120
	 *   initiate soft-off or sleep operation?
L
Linus Torvalds 已提交
121
	 */
L
Len Brown 已提交
122
	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Z
Zhang Rui 已提交
123 124 125
			  "Dispatching Notify on [%4.4s] Node %p Value 0x%2.2X (%s)\n",
			  acpi_ut_get_node_name(node), node, notify_value,
			  acpi_ut_get_notify_name(notify_value)));
L
Linus Torvalds 已提交
126 127 128

	/* Get the notify object attached to the NS Node */

L
Len Brown 已提交
129
	obj_desc = acpi_ns_get_attached_object(node);
L
Linus Torvalds 已提交
130
	if (obj_desc) {
B
Bob Moore 已提交
131

L
Linus Torvalds 已提交
132 133 134
		/* We have the notify object, Get the right handler */

		switch (node->type) {
Z
Zhang Rui 已提交
135 136 137

			/* Notify allowed only on these types */

L
Linus Torvalds 已提交
138 139 140 141 142
		case ACPI_TYPE_DEVICE:
		case ACPI_TYPE_THERMAL:
		case ACPI_TYPE_PROCESSOR:

			if (notify_value <= ACPI_MAX_SYS_NOTIFY) {
L
Len Brown 已提交
143 144 145 146 147
				handler_obj =
				    obj_desc->common_notify.system_notify;
			} else {
				handler_obj =
				    obj_desc->common_notify.device_notify;
L
Linus Torvalds 已提交
148 149 150 151
			}
			break;

		default:
152

L
Linus Torvalds 已提交
153
			/* All other types are not supported */
154

L
Linus Torvalds 已提交
155 156 157 158
			return (AE_TYPE);
		}
	}

Z
Zhang Rui 已提交
159 160 161 162 163 164 165
	/*
	 * If there is any handler to run, schedule the dispatcher.
	 * Check for:
	 * 1) Global system notify handler
	 * 2) Global device notify handler
	 * 3) Per-device notify handler
	 */
166 167 168 169
	if ((acpi_gbl_system_notify.handler &&
	     (notify_value <= ACPI_MAX_SYS_NOTIFY)) ||
	    (acpi_gbl_device_notify.handler &&
	     (notify_value > ACPI_MAX_SYS_NOTIFY)) || handler_obj) {
L
Len Brown 已提交
170
		notify_info = acpi_ut_create_generic_state();
L
Linus Torvalds 已提交
171 172 173 174
		if (!notify_info) {
			return (AE_NO_MEMORY);
		}

Z
Zhang Rui 已提交
175 176
		if (!handler_obj) {
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
177 178
					  "Executing system notify handler for Notify (%4.4s, %X) "
					  "node %p\n",
Z
Zhang Rui 已提交
179 180 181 182
					  acpi_ut_get_node_name(node),
					  notify_value, node));
		}

B
Bob Moore 已提交
183 184
		notify_info->common.descriptor_type =
		    ACPI_DESC_TYPE_STATE_NOTIFY;
L
Len Brown 已提交
185 186
		notify_info->notify.node = node;
		notify_info->notify.value = (u16) notify_value;
L
Linus Torvalds 已提交
187 188
		notify_info->notify.handler_obj = handler_obj;

189 190 191 192 193 194
		status =
		    acpi_os_execute(OSL_NOTIFY_HANDLER, acpi_ev_notify_dispatch,
				    notify_info);
		if (ACPI_FAILURE(status)) {
			acpi_ut_delete_generic_state(notify_info);
		}
Z
Zhang Rui 已提交
195
	} else {
196 197
		/* There is no notify handler (per-device or system) for this device */

L
Len Brown 已提交
198
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Z
Zhang Rui 已提交
199
				  "No notify handler for Notify (%4.4s, %X) node %p\n",
L
Len Brown 已提交
200 201
				  acpi_ut_get_node_name(node), notify_value,
				  node));
L
Linus Torvalds 已提交
202 203 204 205 206 207 208 209 210
	}

	return (status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_notify_dispatch
 *
R
Robert Moore 已提交
211
 * PARAMETERS:  Context         - To be passed to the notify handler
L
Linus Torvalds 已提交
212 213 214 215 216 217 218 219
 *
 * RETURN:      None.
 *
 * DESCRIPTION: Dispatch a device notification event to a previously
 *              installed handler.
 *
 ******************************************************************************/

L
Len Brown 已提交
220
static void ACPI_SYSTEM_XFACE acpi_ev_notify_dispatch(void *context)
L
Linus Torvalds 已提交
221
{
L
Len Brown 已提交
222 223 224 225 226
	union acpi_generic_state *notify_info =
	    (union acpi_generic_state *)context;
	acpi_notify_handler global_handler = NULL;
	void *global_context = NULL;
	union acpi_operand_object *handler_obj;
L
Linus Torvalds 已提交
227

L
Len Brown 已提交
228
	ACPI_FUNCTION_ENTRY();
L
Linus Torvalds 已提交
229 230

	/*
231 232
	 * We will invoke a global notify handler if installed. This is done
	 * _before_ we invoke the per-device handler attached to the device.
L
Linus Torvalds 已提交
233 234
	 */
	if (notify_info->notify.value <= ACPI_MAX_SYS_NOTIFY) {
B
Bob Moore 已提交
235

L
Linus Torvalds 已提交
236 237 238 239 240 241
		/* Global system notification handler */

		if (acpi_gbl_system_notify.handler) {
			global_handler = acpi_gbl_system_notify.handler;
			global_context = acpi_gbl_system_notify.context;
		}
L
Len Brown 已提交
242
	} else {
L
Linus Torvalds 已提交
243 244 245 246 247 248 249 250 251 252 253
		/* Global driver notification handler */

		if (acpi_gbl_device_notify.handler) {
			global_handler = acpi_gbl_device_notify.handler;
			global_context = acpi_gbl_device_notify.context;
		}
	}

	/* Invoke the system handler first, if present */

	if (global_handler) {
L
Len Brown 已提交
254 255
		global_handler(notify_info->notify.node,
			       notify_info->notify.value, global_context);
L
Linus Torvalds 已提交
256 257 258 259 260 261
	}

	/* Now invoke the per-device handler, if present */

	handler_obj = notify_info->notify.handler_obj;
	if (handler_obj) {
L
Len Brown 已提交
262 263 264
		handler_obj->notify.handler(notify_info->notify.node,
					    notify_info->notify.value,
					    handler_obj->notify.context);
L
Linus Torvalds 已提交
265 266 267 268
	}

	/* All done with the info object */

L
Len Brown 已提交
269
	acpi_ut_delete_generic_state(notify_info);
L
Linus Torvalds 已提交
270 271 272 273 274 275 276 277
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_global_lock_handler
 *
 * PARAMETERS:  Context         - From thread interface, not used
 *
278
 * RETURN:      ACPI_INTERRUPT_HANDLED
L
Linus Torvalds 已提交
279 280
 *
 * DESCRIPTION: Invoked directly from the SCI handler when a global lock
281 282 283 284 285 286
 *              release interrupt occurs. Attempt to acquire the global lock,
 *              if successful, signal the thread waiting for the lock.
 *
 * NOTE: Assumes that the semaphore can be signaled from interrupt level. If
 * this is not possible for some reason, a separate thread will have to be
 * scheduled to do this.
L
Linus Torvalds 已提交
287 288 289
 *
 ******************************************************************************/

L
Len Brown 已提交
290
static u32 acpi_ev_global_lock_handler(void *context)
L
Linus Torvalds 已提交
291
{
L
Len Brown 已提交
292
	u8 acquired = FALSE;
L
Linus Torvalds 已提交
293 294

	/*
295 296
	 * Attempt to get the lock.
	 *
L
Linus Torvalds 已提交
297 298 299
	 * If we don't get it now, it will be marked pending and we will
	 * take another interrupt when it becomes free.
	 */
300
	ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_FACS, acquired);
L
Linus Torvalds 已提交
301
	if (acquired) {
B
Bob Moore 已提交
302

L
Linus Torvalds 已提交
303
		/* Got the lock, now wake all threads waiting for it */
304

L
Linus Torvalds 已提交
305
		acpi_gbl_global_lock_acquired = TRUE;
306 307
		/* Send a unit to the semaphore */

L
Len Brown 已提交
308 309 310
		if (ACPI_FAILURE
		    (acpi_os_signal_semaphore
		     (acpi_gbl_global_lock_semaphore, 1))) {
311 312 313
			ACPI_ERROR((AE_INFO,
				    "Could not signal Global Lock semaphore"));
		}
L
Linus Torvalds 已提交
314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
	}

	return (ACPI_INTERRUPT_HANDLED);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_init_global_lock_handler
 *
 * PARAMETERS:  None
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Install a handler for the global lock release event
 *
 ******************************************************************************/

L
Len Brown 已提交
331
acpi_status acpi_ev_init_global_lock_handler(void)
L
Linus Torvalds 已提交
332
{
L
Len Brown 已提交
333
	acpi_status status;
L
Linus Torvalds 已提交
334

B
Bob Moore 已提交
335
	ACPI_FUNCTION_TRACE(ev_init_global_lock_handler);
L
Linus Torvalds 已提交
336

337
	/* Attempt installation of the global lock handler */
338

L
Len Brown 已提交
339 340 341
	status = acpi_install_fixed_event_handler(ACPI_EVENT_GLOBAL,
						  acpi_ev_global_lock_handler,
						  NULL);
L
Linus Torvalds 已提交
342 343

	/*
344 345 346 347
	 * If the global lock does not exist on this platform, the attempt to
	 * enable GBL_STATUS will fail (the GBL_ENABLE bit will not stick).
	 * Map to AE_OK, but mark global lock as not present. Any attempt to
	 * actually use the global lock will be flagged with an error.
L
Linus Torvalds 已提交
348 349
	 */
	if (status == AE_NO_HARDWARE_RESPONSE) {
B
Bob Moore 已提交
350 351
		ACPI_ERROR((AE_INFO,
			    "No response from Global Lock hardware, disabling lock"));
352

L
Linus Torvalds 已提交
353
		acpi_gbl_global_lock_present = FALSE;
354
		return_ACPI_STATUS(AE_OK);
L
Linus Torvalds 已提交
355 356
	}

357
	acpi_gbl_global_lock_present = TRUE;
L
Len Brown 已提交
358
	return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
359 360
}

361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_remove_global_lock_handler
 *
 * PARAMETERS:  None
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Remove the handler for the Global Lock
 *
 ******************************************************************************/

static acpi_status acpi_ev_remove_global_lock_handler(void)
{
	acpi_status status;

	ACPI_FUNCTION_TRACE(ev_remove_global_lock_handler);

	acpi_gbl_global_lock_present = FALSE;
	status = acpi_remove_fixed_event_handler(ACPI_EVENT_GLOBAL,
						 acpi_ev_global_lock_handler);

	return_ACPI_STATUS(status);
}

L
Linus Torvalds 已提交
386 387 388 389 390 391 392 393 394 395
/******************************************************************************
 *
 * FUNCTION:    acpi_ev_acquire_global_lock
 *
 * PARAMETERS:  Timeout         - Max time to wait for the lock, in millisec.
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Attempt to gain ownership of the Global Lock.
 *
396 397 398 399 400 401 402 403 404 405
 * MUTEX:       Interpreter must be locked
 *
 * Note: The original implementation allowed multiple threads to "acquire" the
 * Global Lock, and the OS would hold the lock until the last thread had
 * released it. However, this could potentially starve the BIOS out of the
 * lock, especially in the case where there is a tight handshake between the
 * Embedded Controller driver and the BIOS. Therefore, this implementation
 * allows only one thread to acquire the HW Global Lock at a time, and makes
 * the global lock appear as a standard mutex on the OS side.
 *
L
Linus Torvalds 已提交
406
 *****************************************************************************/
407 408
static acpi_thread_id acpi_ev_global_lock_thread_id;
static int acpi_ev_global_lock_acquired;
L
Linus Torvalds 已提交
409

L
Len Brown 已提交
410
acpi_status acpi_ev_acquire_global_lock(u16 timeout)
L
Linus Torvalds 已提交
411
{
L
Len Brown 已提交
412 413
	acpi_status status = AE_OK;
	u8 acquired = FALSE;
L
Linus Torvalds 已提交
414

B
Bob Moore 已提交
415
	ACPI_FUNCTION_TRACE(ev_acquire_global_lock);
L
Linus Torvalds 已提交
416

417 418 419 420
	/*
	 * Only one thread can acquire the GL at a time, the global_lock_mutex
	 * enforces this. This interface releases the interpreter if we must wait.
	 */
421 422
	status = acpi_ex_system_wait_mutex(
			acpi_gbl_global_lock_mutex->mutex.os_mutex, 0);
423 424 425 426 427 428 429 430
	if (status == AE_TIME) {
		if (acpi_ev_global_lock_thread_id == acpi_os_get_thread_id()) {
			acpi_ev_global_lock_acquired++;
			return AE_OK;
		}
	}

	if (ACPI_FAILURE(status)) {
431 432 433
		status = acpi_ex_system_wait_mutex(
				acpi_gbl_global_lock_mutex->mutex.os_mutex,
				timeout);
434
	}
435 436
	if (ACPI_FAILURE(status)) {
		return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
437 438
	}

439 440 441
	acpi_ev_global_lock_thread_id = acpi_os_get_thread_id();
	acpi_ev_global_lock_acquired++;

R
Robert Moore 已提交
442
	/*
443 444 445 446 447 448 449 450 451 452 453 454 455
	 * Update the global lock handle and check for wraparound. The handle is
	 * only used for the external global lock interfaces, but it is updated
	 * here to properly handle the case where a single thread may acquire the
	 * lock via both the AML and the acpi_acquire_global_lock interfaces. The
	 * handle is therefore updated on the first acquire from a given thread
	 * regardless of where the acquisition request originated.
	 */
	acpi_gbl_global_lock_handle++;
	if (acpi_gbl_global_lock_handle == 0) {
		acpi_gbl_global_lock_handle = 1;
	}

	/*
456 457
	 * Make sure that a global lock actually exists. If not, just treat the
	 * lock as a standard mutex.
R
Robert Moore 已提交
458
	 */
459 460
	if (!acpi_gbl_global_lock_present) {
		acpi_gbl_global_lock_acquired = TRUE;
L
Len Brown 已提交
461
		return_ACPI_STATUS(AE_OK);
L
Linus Torvalds 已提交
462 463
	}

464
	/* Attempt to acquire the actual hardware lock */
L
Linus Torvalds 已提交
465

466
	ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_FACS, acquired);
L
Linus Torvalds 已提交
467
	if (acquired) {
B
Bob Moore 已提交
468

L
Len Brown 已提交
469
		/* We got the lock */
L
Linus Torvalds 已提交
470

L
Len Brown 已提交
471
		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
472
				  "Acquired hardware Global Lock\n"));
L
Linus Torvalds 已提交
473 474

		acpi_gbl_global_lock_acquired = TRUE;
L
Len Brown 已提交
475
		return_ACPI_STATUS(AE_OK);
L
Linus Torvalds 已提交
476 477 478
	}

	/*
479
	 * Did not get the lock. The pending bit was set above, and we must now
L
Linus Torvalds 已提交
480 481
	 * wait until we get the global lock released interrupt.
	 */
482
	ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Waiting for hardware Global Lock\n"));
L
Linus Torvalds 已提交
483 484

	/*
485 486
	 * Wait for handshake with the global lock interrupt handler.
	 * This interface releases the interpreter if we must wait.
L
Linus Torvalds 已提交
487
	 */
488 489
	status = acpi_ex_system_wait_semaphore(acpi_gbl_global_lock_semaphore,
					       ACPI_WAIT_FOREVER);
490

L
Len Brown 已提交
491
	return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
492 493 494 495 496 497 498 499 500 501 502 503 504 505
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_release_global_lock
 *
 * PARAMETERS:  None
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Releases ownership of the Global Lock.
 *
 ******************************************************************************/

L
Len Brown 已提交
506
acpi_status acpi_ev_release_global_lock(void)
L
Linus Torvalds 已提交
507
{
L
Len Brown 已提交
508 509
	u8 pending = FALSE;
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
510

B
Bob Moore 已提交
511
	ACPI_FUNCTION_TRACE(ev_release_global_lock);
L
Linus Torvalds 已提交
512

513
	/* Lock must be already acquired */
514 515

	if (!acpi_gbl_global_lock_acquired) {
B
Bob Moore 已提交
516
		ACPI_WARNING((AE_INFO,
517
			      "Cannot release the ACPI Global Lock, it has not been acquired"));
L
Len Brown 已提交
518
		return_ACPI_STATUS(AE_NOT_ACQUIRED);
L
Linus Torvalds 已提交
519 520
	}

521 522 523 524 525
	acpi_ev_global_lock_acquired--;
	if (acpi_ev_global_lock_acquired > 0) {
		return AE_OK;
	}

526
	if (acpi_gbl_global_lock_present) {
L
Linus Torvalds 已提交
527

528
		/* Allow any thread to release the lock */
B
Bob Moore 已提交
529

530
		ACPI_RELEASE_GLOBAL_LOCK(acpi_gbl_FACS, pending);
L
Linus Torvalds 已提交
531

532 533 534 535 536 537
		/*
		 * If the pending bit was set, we must write GBL_RLS to the control
		 * register
		 */
		if (pending) {
			status =
538
			    acpi_write_bit_register
539 540
			    (ACPI_BITREG_GLOBAL_LOCK_RELEASE,
			     ACPI_ENABLE_EVENT);
541 542 543 544
		}

		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
				  "Released hardware Global Lock\n"));
L
Linus Torvalds 已提交
545 546 547 548
	}

	acpi_gbl_global_lock_acquired = FALSE;

549
	/* Release the local GL mutex */
A
Al Viro 已提交
550
	acpi_ev_global_lock_thread_id = NULL;
551
	acpi_ev_global_lock_acquired = 0;
552
	acpi_os_release_mutex(acpi_gbl_global_lock_mutex->mutex.os_mutex);
L
Len Brown 已提交
553
	return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
554 555 556 557 558 559 560 561 562 563 564 565 566 567
}

/******************************************************************************
 *
 * FUNCTION:    acpi_ev_terminate
 *
 * PARAMETERS:  none
 *
 * RETURN:      none
 *
 * DESCRIPTION: Disable events and free memory allocated for table storage.
 *
 ******************************************************************************/

L
Len Brown 已提交
568
void acpi_ev_terminate(void)
L
Linus Torvalds 已提交
569
{
570
	u32 i;
L
Len Brown 已提交
571
	acpi_status status;
L
Linus Torvalds 已提交
572

B
Bob Moore 已提交
573
	ACPI_FUNCTION_TRACE(ev_terminate);
L
Linus Torvalds 已提交
574 575 576

	if (acpi_gbl_events_initialized) {
		/*
577 578
		 * Disable all event-related functionality. In all cases, on error,
		 * print a message but obviously we don't abort.
L
Linus Torvalds 已提交
579 580 581 582 583
		 */

		/* Disable all fixed events */

		for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) {
584
			status = acpi_disable_event(i, 0);
L
Len Brown 已提交
585
			if (ACPI_FAILURE(status)) {
B
Bob Moore 已提交
586 587 588
				ACPI_ERROR((AE_INFO,
					    "Could not disable fixed event %d",
					    (u32) i));
L
Linus Torvalds 已提交
589 590 591 592 593
			}
		}

		/* Disable all GPEs in all GPE blocks */

594
		status = acpi_ev_walk_gpe_list(acpi_hw_disable_gpe_block, NULL);
L
Linus Torvalds 已提交
595 596 597

		/* Remove SCI handler */

L
Len Brown 已提交
598
		status = acpi_ev_remove_sci_handler();
L
Linus Torvalds 已提交
599
		if (ACPI_FAILURE(status)) {
B
Bob Moore 已提交
600
			ACPI_ERROR((AE_INFO, "Could not remove SCI handler"));
L
Linus Torvalds 已提交
601
		}
602 603 604 605 606 607

		status = acpi_ev_remove_global_lock_handler();
		if (ACPI_FAILURE(status)) {
			ACPI_ERROR((AE_INFO,
				    "Could not remove Global Lock handler"));
		}
L
Linus Torvalds 已提交
608 609 610 611
	}

	/* Deallocate all handler objects installed within GPE info structs */

612
	status = acpi_ev_walk_gpe_list(acpi_ev_delete_gpe_handlers, NULL);
L
Linus Torvalds 已提交
613 614 615 616

	/* Return to original mode if necessary */

	if (acpi_gbl_original_mode == ACPI_SYS_MODE_LEGACY) {
L
Len Brown 已提交
617 618
		status = acpi_disable();
		if (ACPI_FAILURE(status)) {
B
Bob Moore 已提交
619
			ACPI_WARNING((AE_INFO, "AcpiDisable failed"));
L
Linus Torvalds 已提交
620 621 622 623
		}
	}
	return_VOID;
}