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

/*
8
 * Copyright (C) 2000 - 2010, 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) {
262 263 264 265 266 267 268 269 270
		struct acpi_object_notify_handler *notifier;

		notifier = &handler_obj->notify;
		while (notifier) {
			notifier->handler(notify_info->notify.node,
					  notify_info->notify.value,
					  notifier->context);
			notifier = notifier->next;
		}
L
Linus Torvalds 已提交
271 272 273 274
	}

	/* All done with the info object */

L
Len Brown 已提交
275
	acpi_ut_delete_generic_state(notify_info);
L
Linus Torvalds 已提交
276 277 278 279 280 281 282 283
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_global_lock_handler
 *
 * PARAMETERS:  Context         - From thread interface, not used
 *
284
 * RETURN:      ACPI_INTERRUPT_HANDLED
L
Linus Torvalds 已提交
285 286
 *
 * DESCRIPTION: Invoked directly from the SCI handler when a global lock
287 288
 *              release interrupt occurs.  If there's a thread waiting for
 *              the global lock, signal it.
289 290 291 292
 *
 * 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 已提交
293 294
 *
 ******************************************************************************/
295 296 297
static u8 acpi_ev_global_lock_pending;
static spinlock_t _acpi_ev_global_lock_pending_lock;
#define acpi_ev_global_lock_pending_lock &_acpi_ev_global_lock_pending_lock
L
Linus Torvalds 已提交
298

L
Len Brown 已提交
299
static u32 acpi_ev_global_lock_handler(void *context)
L
Linus Torvalds 已提交
300
{
301 302
	acpi_status status;
	acpi_cpu_flags flags;
L
Linus Torvalds 已提交
303

304
	flags = acpi_os_acquire_lock(acpi_ev_global_lock_pending_lock);
B
Bob Moore 已提交
305

306 307 308
	if (!acpi_ev_global_lock_pending) {
		goto out;
	}
309

310
	/* Send a unit to the semaphore */
311

312 313 314
	status = acpi_os_signal_semaphore(acpi_gbl_global_lock_semaphore, 1);
	if (ACPI_FAILURE(status)) {
		ACPI_ERROR((AE_INFO, "Could not signal Global Lock semaphore"));
L
Linus Torvalds 已提交
315 316
	}

317 318 319 320 321
	acpi_ev_global_lock_pending = FALSE;

 out:
	acpi_os_release_lock(acpi_ev_global_lock_pending_lock, flags);

L
Linus Torvalds 已提交
322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
	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 已提交
337
acpi_status acpi_ev_init_global_lock_handler(void)
L
Linus Torvalds 已提交
338
{
L
Len Brown 已提交
339
	acpi_status status;
L
Linus Torvalds 已提交
340

B
Bob Moore 已提交
341
	ACPI_FUNCTION_TRACE(ev_init_global_lock_handler);
L
Linus Torvalds 已提交
342

343
	/* Attempt installation of the global lock handler */
344

L
Len Brown 已提交
345 346 347
	status = acpi_install_fixed_event_handler(ACPI_EVENT_GLOBAL,
						  acpi_ev_global_lock_handler,
						  NULL);
L
Linus Torvalds 已提交
348 349

	/*
350 351 352 353
	 * 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 已提交
354 355
	 */
	if (status == AE_NO_HARDWARE_RESPONSE) {
B
Bob Moore 已提交
356 357
		ACPI_ERROR((AE_INFO,
			    "No response from Global Lock hardware, disabling lock"));
358

L
Linus Torvalds 已提交
359
		acpi_gbl_global_lock_present = FALSE;
360
		return_ACPI_STATUS(AE_OK);
L
Linus Torvalds 已提交
361 362
	}

363
	acpi_gbl_global_lock_present = TRUE;
L
Len Brown 已提交
364
	return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
365 366
}

367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391
/*******************************************************************************
 *
 * 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 已提交
392 393 394 395 396 397 398 399 400 401
/******************************************************************************
 *
 * 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.
 *
402 403 404 405 406 407 408 409 410 411
 * 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 已提交
412
 *****************************************************************************/
413 414
static acpi_thread_id acpi_ev_global_lock_thread_id;
static int acpi_ev_global_lock_acquired;
L
Linus Torvalds 已提交
415

L
Len Brown 已提交
416
acpi_status acpi_ev_acquire_global_lock(u16 timeout)
L
Linus Torvalds 已提交
417
{
418
	acpi_cpu_flags flags;
L
Len Brown 已提交
419 420
	acpi_status status = AE_OK;
	u8 acquired = FALSE;
L
Linus Torvalds 已提交
421

B
Bob Moore 已提交
422
	ACPI_FUNCTION_TRACE(ev_acquire_global_lock);
L
Linus Torvalds 已提交
423

424 425 426 427
	/*
	 * 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.
	 */
428 429
	status = acpi_ex_system_wait_mutex(
			acpi_gbl_global_lock_mutex->mutex.os_mutex, 0);
430 431 432 433 434 435 436 437
	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)) {
438 439 440
		status = acpi_ex_system_wait_mutex(
				acpi_gbl_global_lock_mutex->mutex.os_mutex,
				timeout);
441
	}
442 443
	if (ACPI_FAILURE(status)) {
		return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
444 445
	}

446 447 448
	acpi_ev_global_lock_thread_id = acpi_os_get_thread_id();
	acpi_ev_global_lock_acquired++;

R
Robert Moore 已提交
449
	/*
450 451 452 453 454 455 456 457 458 459 460 461 462
	 * 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;
	}

	/*
463 464
	 * Make sure that a global lock actually exists. If not, just treat the
	 * lock as a standard mutex.
R
Robert Moore 已提交
465
	 */
466 467
	if (!acpi_gbl_global_lock_present) {
		acpi_gbl_global_lock_acquired = TRUE;
L
Len Brown 已提交
468
		return_ACPI_STATUS(AE_OK);
L
Linus Torvalds 已提交
469 470
	}

471 472 473 474 475
	flags = acpi_os_acquire_lock(acpi_ev_global_lock_pending_lock);

	do {

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

477 478 479 480 481 482 483 484
		ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_FACS, acquired);
		if (acquired) {
			acpi_gbl_global_lock_acquired = TRUE;

			ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
					  "Acquired hardware Global Lock\n"));
			break;
		}
B
Bob Moore 已提交
485

486
		acpi_ev_global_lock_pending = TRUE;
L
Linus Torvalds 已提交
487

488 489 490 491 492 493
		acpi_os_release_lock(acpi_ev_global_lock_pending_lock, flags);

		/*
		 * Did not get the lock. The pending bit was set above, and we
		 * must wait until we get the global lock released interrupt.
		 */
L
Len Brown 已提交
494
		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
495
				  "Waiting for hardware Global Lock\n"));
L
Linus Torvalds 已提交
496

497 498 499 500 501 502 503
		/*
		 * Wait for handshake with the global lock interrupt handler.
		 * This interface releases the interpreter if we must wait.
		 */
		status = acpi_ex_system_wait_semaphore(
						acpi_gbl_global_lock_semaphore,
						ACPI_WAIT_FOREVER);
L
Linus Torvalds 已提交
504

505
		flags = acpi_os_acquire_lock(acpi_ev_global_lock_pending_lock);
L
Linus Torvalds 已提交
506

507 508 509 510 511
	} while (ACPI_SUCCESS(status));

	acpi_ev_global_lock_pending = FALSE;

	acpi_os_release_lock(acpi_ev_global_lock_pending_lock, flags);
512

L
Len Brown 已提交
513
	return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
514 515 516 517 518 519 520 521 522 523 524 525 526 527
}

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

L
Len Brown 已提交
528
acpi_status acpi_ev_release_global_lock(void)
L
Linus Torvalds 已提交
529
{
L
Len Brown 已提交
530 531
	u8 pending = FALSE;
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
532

B
Bob Moore 已提交
533
	ACPI_FUNCTION_TRACE(ev_release_global_lock);
L
Linus Torvalds 已提交
534

535
	/* Lock must be already acquired */
536 537

	if (!acpi_gbl_global_lock_acquired) {
B
Bob Moore 已提交
538
		ACPI_WARNING((AE_INFO,
539
			      "Cannot release the ACPI Global Lock, it has not been acquired"));
L
Len Brown 已提交
540
		return_ACPI_STATUS(AE_NOT_ACQUIRED);
L
Linus Torvalds 已提交
541 542
	}

543 544 545 546 547
	acpi_ev_global_lock_acquired--;
	if (acpi_ev_global_lock_acquired > 0) {
		return AE_OK;
	}

548
	if (acpi_gbl_global_lock_present) {
L
Linus Torvalds 已提交
549

550
		/* Allow any thread to release the lock */
B
Bob Moore 已提交
551

552
		ACPI_RELEASE_GLOBAL_LOCK(acpi_gbl_FACS, pending);
L
Linus Torvalds 已提交
553

554 555 556 557 558 559
		/*
		 * If the pending bit was set, we must write GBL_RLS to the control
		 * register
		 */
		if (pending) {
			status =
560
			    acpi_write_bit_register
561 562
			    (ACPI_BITREG_GLOBAL_LOCK_RELEASE,
			     ACPI_ENABLE_EVENT);
563 564 565 566
		}

		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
				  "Released hardware Global Lock\n"));
L
Linus Torvalds 已提交
567 568 569 570
	}

	acpi_gbl_global_lock_acquired = FALSE;

571
	/* Release the local GL mutex */
572
	acpi_ev_global_lock_thread_id = 0;
573
	acpi_ev_global_lock_acquired = 0;
574
	acpi_os_release_mutex(acpi_gbl_global_lock_mutex->mutex.os_mutex);
L
Len Brown 已提交
575
	return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
576 577 578 579 580 581 582 583 584 585 586 587 588 589
}

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

L
Len Brown 已提交
590
void acpi_ev_terminate(void)
L
Linus Torvalds 已提交
591
{
592
	u32 i;
L
Len Brown 已提交
593
	acpi_status status;
L
Linus Torvalds 已提交
594

B
Bob Moore 已提交
595
	ACPI_FUNCTION_TRACE(ev_terminate);
L
Linus Torvalds 已提交
596 597 598

	if (acpi_gbl_events_initialized) {
		/*
599 600
		 * Disable all event-related functionality. In all cases, on error,
		 * print a message but obviously we don't abort.
L
Linus Torvalds 已提交
601 602 603 604 605
		 */

		/* Disable all fixed events */

		for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) {
606
			status = acpi_disable_event(i, 0);
L
Len Brown 已提交
607
			if (ACPI_FAILURE(status)) {
B
Bob Moore 已提交
608
				ACPI_ERROR((AE_INFO,
609
					    "Could not disable fixed event %u",
B
Bob Moore 已提交
610
					    (u32) i));
L
Linus Torvalds 已提交
611 612 613 614 615
			}
		}

		/* Disable all GPEs in all GPE blocks */

616
		status = acpi_ev_walk_gpe_list(acpi_hw_disable_gpe_block, NULL);
L
Linus Torvalds 已提交
617 618 619

		/* Remove SCI handler */

L
Len Brown 已提交
620
		status = acpi_ev_remove_sci_handler();
L
Linus Torvalds 已提交
621
		if (ACPI_FAILURE(status)) {
B
Bob Moore 已提交
622
			ACPI_ERROR((AE_INFO, "Could not remove SCI handler"));
L
Linus Torvalds 已提交
623
		}
624 625 626 627 628 629

		status = acpi_ev_remove_global_lock_handler();
		if (ACPI_FAILURE(status)) {
			ACPI_ERROR((AE_INFO,
				    "Could not remove Global Lock handler"));
		}
L
Linus Torvalds 已提交
630 631 632 633
	}

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

634
	status = acpi_ev_walk_gpe_list(acpi_ev_delete_gpe_handlers, NULL);
L
Linus Torvalds 已提交
635 636 637 638

	/* Return to original mode if necessary */

	if (acpi_gbl_original_mode == ACPI_SYS_MODE_LEGACY) {
L
Len Brown 已提交
639 640
		status = acpi_disable();
		if (ACPI_FAILURE(status)) {
B
Bob Moore 已提交
641
			ACPI_WARNING((AE_INFO, "AcpiDisable failed"));
L
Linus Torvalds 已提交
642 643 644 645
		}
	}
	return_VOID;
}