evgpeblk.c 34.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7
/******************************************************************************
 *
 * Module Name: evgpeblk - GPE block creation and initialization.
 *
 *****************************************************************************/

/*
B
Bob Moore 已提交
8
 * Copyright (C) 2000 - 2007, R. Byron Moore
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 45 46 47 48
 * 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>
#include <acpi/acevents.h>
#include <acpi/acnamesp.h>

#define _COMPONENT          ACPI_EVENTS
L
Len Brown 已提交
49
ACPI_MODULE_NAME("evgpeblk")
L
Linus Torvalds 已提交
50

R
Robert Moore 已提交
51 52
/* Local prototypes */
static acpi_status
L
Len Brown 已提交
53 54
acpi_ev_save_method_info(acpi_handle obj_handle,
			 u32 level, void *obj_desc, void **return_value);
R
Robert Moore 已提交
55 56

static acpi_status
L
Len Brown 已提交
57 58
acpi_ev_match_prw_and_gpe(acpi_handle obj_handle,
			  u32 level, void *info, void **return_value);
R
Robert Moore 已提交
59

L
Len Brown 已提交
60 61
static struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32
							       interrupt_number);
R
Robert Moore 已提交
62 63

static acpi_status
L
Len Brown 已提交
64
acpi_ev_delete_gpe_xrupt(struct acpi_gpe_xrupt_info *gpe_xrupt);
R
Robert Moore 已提交
65 66

static acpi_status
L
Len Brown 已提交
67 68
acpi_ev_install_gpe_block(struct acpi_gpe_block_info *gpe_block,
			  u32 interrupt_number);
R
Robert Moore 已提交
69 70

static acpi_status
L
Len Brown 已提交
71
acpi_ev_create_gpe_info_blocks(struct acpi_gpe_block_info *gpe_block);
L
Linus Torvalds 已提交
72 73 74 75 76 77 78 79 80

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_valid_gpe_event
 *
 * PARAMETERS:  gpe_event_info              - Info for this GPE
 *
 * RETURN:      TRUE if the gpe_event is valid
 *
B
Bob Moore 已提交
81
 * DESCRIPTION: Validate a GPE event. DO NOT CALL FROM INTERRUPT LEVEL.
L
Linus Torvalds 已提交
82 83 84 85 86
 *              Should be called only when the GPE lists are semaphore locked
 *              and not subject to change.
 *
 ******************************************************************************/

L
Len Brown 已提交
87
u8 acpi_ev_valid_gpe_event(struct acpi_gpe_event_info *gpe_event_info)
L
Linus Torvalds 已提交
88
{
L
Len Brown 已提交
89 90
	struct acpi_gpe_xrupt_info *gpe_xrupt_block;
	struct acpi_gpe_block_info *gpe_block;
L
Linus Torvalds 已提交
91

L
Len Brown 已提交
92
	ACPI_FUNCTION_ENTRY();
L
Linus Torvalds 已提交
93 94 95 96 97 98 99 100 101 102 103 104 105

	/* No need for spin lock since we are not changing any list elements */

	/* Walk the GPE interrupt levels */

	gpe_xrupt_block = acpi_gbl_gpe_xrupt_list_head;
	while (gpe_xrupt_block) {
		gpe_block = gpe_xrupt_block->gpe_block_list_head;

		/* Walk the GPE blocks on this interrupt level */

		while (gpe_block) {
			if ((&gpe_block->event_info[0] <= gpe_event_info) &&
L
Len Brown 已提交
106 107 108 109
			    (&gpe_block->
			     event_info[((acpi_size) gpe_block->
					 register_count) * 8] >
			     gpe_event_info)) {
L
Linus Torvalds 已提交
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
				return (TRUE);
			}

			gpe_block = gpe_block->next;
		}

		gpe_xrupt_block = gpe_xrupt_block->next;
	}

	return (FALSE);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_walk_gpe_list
 *
 * PARAMETERS:  gpe_walk_callback   - Routine called for each GPE block
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Walk the GPE lists.
 *
 ******************************************************************************/

B
Bob Moore 已提交
134
acpi_status acpi_ev_walk_gpe_list(acpi_gpe_callback gpe_walk_callback)
L
Linus Torvalds 已提交
135
{
L
Len Brown 已提交
136 137 138
	struct acpi_gpe_block_info *gpe_block;
	struct acpi_gpe_xrupt_info *gpe_xrupt_info;
	acpi_status status = AE_OK;
B
Bob Moore 已提交
139
	acpi_cpu_flags flags;
L
Linus Torvalds 已提交
140

B
Bob Moore 已提交
141
	ACPI_FUNCTION_TRACE(ev_walk_gpe_list);
L
Linus Torvalds 已提交
142

L
Len Brown 已提交
143
	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
L
Linus Torvalds 已提交
144 145 146 147 148

	/* Walk the interrupt level descriptor list */

	gpe_xrupt_info = acpi_gbl_gpe_xrupt_list_head;
	while (gpe_xrupt_info) {
B
Bob Moore 已提交
149

L
Linus Torvalds 已提交
150 151 152 153
		/* Walk all Gpe Blocks attached to this interrupt level */

		gpe_block = gpe_xrupt_info->gpe_block_list_head;
		while (gpe_block) {
B
Bob Moore 已提交
154

L
Linus Torvalds 已提交
155 156
			/* One callback per GPE block */

L
Len Brown 已提交
157 158
			status = gpe_walk_callback(gpe_xrupt_info, gpe_block);
			if (ACPI_FAILURE(status)) {
L
Linus Torvalds 已提交
159 160 161 162 163 164 165 166 167
				goto unlock_and_exit;
			}

			gpe_block = gpe_block->next;
		}

		gpe_xrupt_info = gpe_xrupt_info->next;
	}

L
Len Brown 已提交
168 169 170
      unlock_and_exit:
	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
	return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
171 172
}

R
Robert Moore 已提交
173
/*******************************************************************************
L
Linus Torvalds 已提交
174 175 176 177 178 179 180 181 182 183 184 185 186 187
 *
 * FUNCTION:    acpi_ev_delete_gpe_handlers
 *
 * PARAMETERS:  gpe_xrupt_info      - GPE Interrupt info
 *              gpe_block           - Gpe Block info
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Delete all Handler objects found in the GPE data structs.
 *              Used only prior to termination.
 *
 ******************************************************************************/

acpi_status
L
Len Brown 已提交
188 189
acpi_ev_delete_gpe_handlers(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
			    struct acpi_gpe_block_info *gpe_block)
L
Linus Torvalds 已提交
190
{
L
Len Brown 已提交
191 192 193
	struct acpi_gpe_event_info *gpe_event_info;
	acpi_native_uint i;
	acpi_native_uint j;
L
Linus Torvalds 已提交
194

B
Bob Moore 已提交
195
	ACPI_FUNCTION_TRACE(ev_delete_gpe_handlers);
L
Linus Torvalds 已提交
196 197 198 199

	/* Examine each GPE Register within the block */

	for (i = 0; i < gpe_block->register_count; i++) {
B
Bob Moore 已提交
200

L
Linus Torvalds 已提交
201 202 203
		/* Now look at the individual GPEs in this byte register */

		for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
L
Len Brown 已提交
204 205 206
			gpe_event_info =
			    &gpe_block->
			    event_info[(i * ACPI_GPE_REGISTER_WIDTH) + j];
L
Linus Torvalds 已提交
207

R
Robert Moore 已提交
208
			if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
L
Len Brown 已提交
209
			    ACPI_GPE_DISPATCH_HANDLER) {
B
Bob Moore 已提交
210
				ACPI_FREE(gpe_event_info->dispatch.handler);
L
Linus Torvalds 已提交
211
				gpe_event_info->dispatch.handler = NULL;
L
Len Brown 已提交
212 213
				gpe_event_info->flags &=
				    ~ACPI_GPE_DISPATCH_MASK;
L
Linus Torvalds 已提交
214 215 216 217
			}
		}
	}

L
Len Brown 已提交
218
	return_ACPI_STATUS(AE_OK);
L
Linus Torvalds 已提交
219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_save_method_info
 *
 * PARAMETERS:  Callback from walk_namespace
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Called from acpi_walk_namespace. Expects each object to be a
 *              control method under the _GPE portion of the namespace.
 *              Extract the name and GPE type from the object, saving this
 *              information for quick lookup during GPE dispatch
 *
 *              The name of each GPE control method is of the form:
 *              "_Lxx" or "_Exx"
 *              Where:
 *                  L      - means that the GPE is level triggered
 *                  E      - means that the GPE is edge triggered
 *                  xx     - is the GPE number [in HEX]
 *
 ******************************************************************************/

static acpi_status
L
Len Brown 已提交
244 245
acpi_ev_save_method_info(acpi_handle obj_handle,
			 u32 level, void *obj_desc, void **return_value)
L
Linus Torvalds 已提交
246
{
L
Len Brown 已提交
247 248 249 250 251 252
	struct acpi_gpe_block_info *gpe_block = (void *)obj_desc;
	struct acpi_gpe_event_info *gpe_event_info;
	u32 gpe_number;
	char name[ACPI_NAME_SIZE + 1];
	u8 type;
	acpi_status status;
L
Linus Torvalds 已提交
253

B
Bob Moore 已提交
254
	ACPI_FUNCTION_TRACE(ev_save_method_info);
L
Linus Torvalds 已提交
255 256 257 258 259 260

	/*
	 * _Lxx and _Exx GPE method support
	 *
	 * 1) Extract the name from the object and convert to a string
	 */
L
Len Brown 已提交
261 262 263
	ACPI_MOVE_32_TO_32(name,
			   &((struct acpi_namespace_node *)obj_handle)->name.
			   integer);
L
Linus Torvalds 已提交
264 265 266 267 268 269
	name[ACPI_NAME_SIZE] = 0;

	/*
	 * 2) Edge/Level determination is based on the 2nd character
	 *    of the method name
	 *
B
Bob Moore 已提交
270
	 * NOTE: Default GPE type is RUNTIME. May be changed later to WAKE
L
Linus Torvalds 已提交
271 272 273 274 275 276 277 278 279 280 281 282 283 284
	 * if a _PRW object is found that points to this GPE.
	 */
	switch (name[1]) {
	case 'L':
		type = ACPI_GPE_LEVEL_TRIGGERED;
		break;

	case 'E':
		type = ACPI_GPE_EDGE_TRIGGERED;
		break;

	default:
		/* Unknown method type, just ignore it! */

B
Bob Moore 已提交
285 286 287
		ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
				  "Ignoring unknown GPE method type: %s (name not of form _Lxx or _Exx)",
				  name));
L
Len Brown 已提交
288
		return_ACPI_STATUS(AE_OK);
L
Linus Torvalds 已提交
289 290 291 292
	}

	/* Convert the last two characters of the name to the GPE Number */

L
Len Brown 已提交
293
	gpe_number = ACPI_STRTOUL(&name[2], NULL, 16);
L
Linus Torvalds 已提交
294
	if (gpe_number == ACPI_UINT32_MAX) {
B
Bob Moore 已提交
295

L
Linus Torvalds 已提交
296 297
		/* Conversion failed; invalid method, just ignore it */

B
Bob Moore 已提交
298 299 300
		ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
				  "Could not extract GPE number from name: %s (name is not of form _Lxx or _Exx)",
				  name));
L
Len Brown 已提交
301
		return_ACPI_STATUS(AE_OK);
L
Linus Torvalds 已提交
302 303 304 305 306
	}

	/* Ensure that we have a valid GPE number for this GPE block */

	if ((gpe_number < gpe_block->block_base_number) ||
L
Len Brown 已提交
307 308 309
	    (gpe_number >=
	     (gpe_block->block_base_number +
	      (gpe_block->register_count * 8)))) {
L
Linus Torvalds 已提交
310 311 312 313 314
		/*
		 * Not valid for this GPE block, just ignore it
		 * However, it may be valid for a different GPE block, since GPE0 and GPE1
		 * methods both appear under \_GPE.
		 */
L
Len Brown 已提交
315
		return_ACPI_STATUS(AE_OK);
L
Linus Torvalds 已提交
316 317 318 319
	}

	/*
	 * Now we can add this information to the gpe_event_info block
B
Bob Moore 已提交
320
	 * for use during dispatch of this GPE. Default type is RUNTIME, although
L
Linus Torvalds 已提交
321 322
	 * this may change when the _PRW methods are executed later.
	 */
L
Len Brown 已提交
323 324
	gpe_event_info =
	    &gpe_block->event_info[gpe_number - gpe_block->block_base_number];
L
Linus Torvalds 已提交
325

B
Bob Moore 已提交
326 327
	gpe_event_info->flags = (u8)
	    (type | ACPI_GPE_DISPATCH_METHOD | ACPI_GPE_TYPE_RUNTIME);
L
Linus Torvalds 已提交
328

L
Len Brown 已提交
329 330
	gpe_event_info->dispatch.method_node =
	    (struct acpi_namespace_node *)obj_handle;
L
Linus Torvalds 已提交
331 332 333

	/* Update enable mask, but don't enable the HW GPE as of yet */

L
Len Brown 已提交
334
	status = acpi_ev_enable_gpe(gpe_event_info, FALSE);
L
Linus Torvalds 已提交
335

L
Len Brown 已提交
336 337 338 339
	ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
			  "Registered GPE method %s as GPE number 0x%.2X\n",
			  name, gpe_number));
	return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
340 341 342 343 344 345 346 347
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_match_prw_and_gpe
 *
 * PARAMETERS:  Callback from walk_namespace
 *
B
Bob Moore 已提交
348
 * RETURN:      Status. NOTE: We ignore errors so that the _PRW walk is
L
Linus Torvalds 已提交
349 350 351
 *              not aborted on a single _PRW failure.
 *
 * DESCRIPTION: Called from acpi_walk_namespace. Expects each object to be a
B
Bob Moore 已提交
352
 *              Device. Run the _PRW method. If present, extract the GPE
L
Linus Torvalds 已提交
353 354 355 356 357
 *              number and mark the GPE as a WAKE GPE.
 *
 ******************************************************************************/

static acpi_status
L
Len Brown 已提交
358 359
acpi_ev_match_prw_and_gpe(acpi_handle obj_handle,
			  u32 level, void *info, void **return_value)
L
Linus Torvalds 已提交
360
{
L
Len Brown 已提交
361 362 363 364 365 366 367 368 369 370
	struct acpi_gpe_walk_info *gpe_info = (void *)info;
	struct acpi_namespace_node *gpe_device;
	struct acpi_gpe_block_info *gpe_block;
	struct acpi_namespace_node *target_gpe_device;
	struct acpi_gpe_event_info *gpe_event_info;
	union acpi_operand_object *pkg_desc;
	union acpi_operand_object *obj_desc;
	u32 gpe_number;
	acpi_status status;

B
Bob Moore 已提交
371
	ACPI_FUNCTION_TRACE(ev_match_prw_and_gpe);
L
Linus Torvalds 已提交
372 373 374

	/* Check for a _PRW method under this device */

L
Len Brown 已提交
375 376 377
	status = acpi_ut_evaluate_object(obj_handle, METHOD_NAME__PRW,
					 ACPI_BTYPE_PACKAGE, &pkg_desc);
	if (ACPI_FAILURE(status)) {
B
Bob Moore 已提交
378

L
Linus Torvalds 已提交
379 380
		/* Ignore all errors from _PRW, we don't want to abort the subsystem */

L
Len Brown 已提交
381
		return_ACPI_STATUS(AE_OK);
L
Linus Torvalds 已提交
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400
	}

	/* The returned _PRW package must have at least two elements */

	if (pkg_desc->package.count < 2) {
		goto cleanup;
	}

	/* Extract pointers from the input context */

	gpe_device = gpe_info->gpe_device;
	gpe_block = gpe_info->gpe_block;

	/*
	 * The _PRW object must return a package, we are only interested
	 * in the first element
	 */
	obj_desc = pkg_desc->package.elements[0];

L
Len Brown 已提交
401
	if (ACPI_GET_OBJECT_TYPE(obj_desc) == ACPI_TYPE_INTEGER) {
B
Bob Moore 已提交
402

L
Linus Torvalds 已提交
403 404 405 406 407 408 409
		/* Use FADT-defined GPE device (from definition of _PRW) */

		target_gpe_device = acpi_gbl_fadt_gpe_device;

		/* Integer is the GPE number in the FADT described GPE blocks */

		gpe_number = (u32) obj_desc->integer.value;
L
Len Brown 已提交
410
	} else if (ACPI_GET_OBJECT_TYPE(obj_desc) == ACPI_TYPE_PACKAGE) {
B
Bob Moore 已提交
411

L
Linus Torvalds 已提交
412 413 414
		/* Package contains a GPE reference and GPE number within a GPE block */

		if ((obj_desc->package.count < 2) ||
L
Len Brown 已提交
415 416 417 418
		    (ACPI_GET_OBJECT_TYPE(obj_desc->package.elements[0]) !=
		     ACPI_TYPE_LOCAL_REFERENCE)
		    || (ACPI_GET_OBJECT_TYPE(obj_desc->package.elements[1]) !=
			ACPI_TYPE_INTEGER)) {
L
Linus Torvalds 已提交
419 420 421 422 423
			goto cleanup;
		}

		/* Get GPE block reference and decode */

L
Len Brown 已提交
424 425
		target_gpe_device =
		    obj_desc->package.elements[0]->reference.node;
L
Linus Torvalds 已提交
426
		gpe_number = (u32) obj_desc->package.elements[1]->integer.value;
L
Len Brown 已提交
427
	} else {
L
Linus Torvalds 已提交
428 429 430 431 432 433 434 435 436 437 438 439 440 441
		/* Unknown type, just ignore it */

		goto cleanup;
	}

	/*
	 * Is this GPE within this block?
	 *
	 * TRUE iff these conditions are true:
	 *     1) The GPE devices match.
	 *     2) The GPE index(number) is within the range of the Gpe Block
	 *          associated with the GPE device.
	 */
	if ((gpe_device == target_gpe_device) &&
L
Len Brown 已提交
442 443 444 445 446 447
	    (gpe_number >= gpe_block->block_base_number) &&
	    (gpe_number <
	     gpe_block->block_base_number + (gpe_block->register_count * 8))) {
		gpe_event_info =
		    &gpe_block->event_info[gpe_number -
					   gpe_block->block_base_number];
L
Linus Torvalds 已提交
448 449 450

		/* Mark GPE for WAKE-ONLY but WAKE_DISABLED */

L
Len Brown 已提交
451 452
		gpe_event_info->flags &=
		    ~(ACPI_GPE_WAKE_ENABLED | ACPI_GPE_RUN_ENABLED);
B
Bob Moore 已提交
453

L
Len Brown 已提交
454 455 456
		status =
		    acpi_ev_set_gpe_type(gpe_event_info, ACPI_GPE_TYPE_WAKE);
		if (ACPI_FAILURE(status)) {
L
Linus Torvalds 已提交
457 458
			goto cleanup;
		}
L
Len Brown 已提交
459 460 461
		status =
		    acpi_ev_update_gpe_enable_masks(gpe_event_info,
						    ACPI_GPE_DISABLE);
L
Linus Torvalds 已提交
462 463
	}

L
Len Brown 已提交
464 465 466
      cleanup:
	acpi_ut_remove_reference(pkg_desc);
	return_ACPI_STATUS(AE_OK);
L
Linus Torvalds 已提交
467 468 469 470 471 472
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_get_gpe_xrupt_block
 *
473
 * PARAMETERS:  interrupt_number     - Interrupt for a GPE block
L
Linus Torvalds 已提交
474 475 476
 *
 * RETURN:      A GPE interrupt block
 *
B
Bob Moore 已提交
477
 * DESCRIPTION: Get or Create a GPE interrupt block. There is one interrupt
L
Linus Torvalds 已提交
478 479 480 481 482 483
 *              block per unique interrupt level used for GPEs.
 *              Should be called only when the GPE lists are semaphore locked
 *              and not subject to change.
 *
 ******************************************************************************/

L
Len Brown 已提交
484 485
static struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32
							       interrupt_number)
L
Linus Torvalds 已提交
486
{
L
Len Brown 已提交
487 488 489
	struct acpi_gpe_xrupt_info *next_gpe_xrupt;
	struct acpi_gpe_xrupt_info *gpe_xrupt;
	acpi_status status;
B
Bob Moore 已提交
490
	acpi_cpu_flags flags;
L
Linus Torvalds 已提交
491

B
Bob Moore 已提交
492
	ACPI_FUNCTION_TRACE(ev_get_gpe_xrupt_block);
L
Linus Torvalds 已提交
493

R
Robert Moore 已提交
494
	/* No need for lock since we are not changing any list elements here */
L
Linus Torvalds 已提交
495 496 497

	next_gpe_xrupt = acpi_gbl_gpe_xrupt_list_head;
	while (next_gpe_xrupt) {
498
		if (next_gpe_xrupt->interrupt_number == interrupt_number) {
L
Len Brown 已提交
499
			return_PTR(next_gpe_xrupt);
L
Linus Torvalds 已提交
500 501 502 503 504 505 506
		}

		next_gpe_xrupt = next_gpe_xrupt->next;
	}

	/* Not found, must allocate a new xrupt descriptor */

B
Bob Moore 已提交
507
	gpe_xrupt = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_xrupt_info));
L
Linus Torvalds 已提交
508
	if (!gpe_xrupt) {
L
Len Brown 已提交
509
		return_PTR(NULL);
L
Linus Torvalds 已提交
510 511
	}

512
	gpe_xrupt->interrupt_number = interrupt_number;
L
Linus Torvalds 已提交
513 514 515

	/* Install new interrupt descriptor with spin lock */

L
Len Brown 已提交
516
	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
L
Linus Torvalds 已提交
517 518 519 520 521 522 523 524
	if (acpi_gbl_gpe_xrupt_list_head) {
		next_gpe_xrupt = acpi_gbl_gpe_xrupt_list_head;
		while (next_gpe_xrupt->next) {
			next_gpe_xrupt = next_gpe_xrupt->next;
		}

		next_gpe_xrupt->next = gpe_xrupt;
		gpe_xrupt->previous = next_gpe_xrupt;
L
Len Brown 已提交
525
	} else {
L
Linus Torvalds 已提交
526 527
		acpi_gbl_gpe_xrupt_list_head = gpe_xrupt;
	}
L
Len Brown 已提交
528
	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
L
Linus Torvalds 已提交
529 530 531

	/* Install new interrupt handler if not SCI_INT */

532
	if (interrupt_number != acpi_gbl_FADT.sci_interrupt) {
L
Len Brown 已提交
533 534 535 536
		status = acpi_os_install_interrupt_handler(interrupt_number,
							   acpi_ev_gpe_xrupt_handler,
							   gpe_xrupt);
		if (ACPI_FAILURE(status)) {
B
Bob Moore 已提交
537 538 539
			ACPI_ERROR((AE_INFO,
				    "Could not install GPE interrupt handler at level 0x%X",
				    interrupt_number));
L
Len Brown 已提交
540
			return_PTR(NULL);
L
Linus Torvalds 已提交
541 542 543
		}
	}

L
Len Brown 已提交
544
	return_PTR(gpe_xrupt);
L
Linus Torvalds 已提交
545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_delete_gpe_xrupt
 *
 * PARAMETERS:  gpe_xrupt       - A GPE interrupt info block
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Remove and free a gpe_xrupt block. Remove an associated
 *              interrupt handler if not the SCI interrupt.
 *
 ******************************************************************************/

static acpi_status
L
Len Brown 已提交
561
acpi_ev_delete_gpe_xrupt(struct acpi_gpe_xrupt_info *gpe_xrupt)
L
Linus Torvalds 已提交
562
{
L
Len Brown 已提交
563
	acpi_status status;
B
Bob Moore 已提交
564
	acpi_cpu_flags flags;
L
Linus Torvalds 已提交
565

B
Bob Moore 已提交
566
	ACPI_FUNCTION_TRACE(ev_delete_gpe_xrupt);
L
Linus Torvalds 已提交
567 568 569

	/* We never want to remove the SCI interrupt handler */

570
	if (gpe_xrupt->interrupt_number == acpi_gbl_FADT.sci_interrupt) {
L
Linus Torvalds 已提交
571
		gpe_xrupt->gpe_block_list_head = NULL;
L
Len Brown 已提交
572
		return_ACPI_STATUS(AE_OK);
L
Linus Torvalds 已提交
573 574 575 576
	}

	/* Disable this interrupt */

B
Bob Moore 已提交
577 578 579
	status =
	    acpi_os_remove_interrupt_handler(gpe_xrupt->interrupt_number,
					     acpi_ev_gpe_xrupt_handler);
L
Len Brown 已提交
580 581
	if (ACPI_FAILURE(status)) {
		return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
582 583 584 585
	}

	/* Unlink the interrupt block with lock */

L
Len Brown 已提交
586
	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
L
Linus Torvalds 已提交
587 588 589 590 591 592 593
	if (gpe_xrupt->previous) {
		gpe_xrupt->previous->next = gpe_xrupt->next;
	}

	if (gpe_xrupt->next) {
		gpe_xrupt->next->previous = gpe_xrupt->previous;
	}
L
Len Brown 已提交
594
	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
L
Linus Torvalds 已提交
595 596 597

	/* Free the block */

B
Bob Moore 已提交
598
	ACPI_FREE(gpe_xrupt);
L
Len Brown 已提交
599
	return_ACPI_STATUS(AE_OK);
L
Linus Torvalds 已提交
600 601 602 603 604 605 606
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_install_gpe_block
 *
 * PARAMETERS:  gpe_block       - New GPE block
607
 *              interrupt_number - Xrupt to be associated with this GPE block
L
Linus Torvalds 已提交
608 609 610 611 612 613 614 615
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Install new GPE block with mutex support
 *
 ******************************************************************************/

static acpi_status
L
Len Brown 已提交
616 617
acpi_ev_install_gpe_block(struct acpi_gpe_block_info *gpe_block,
			  u32 interrupt_number)
L
Linus Torvalds 已提交
618
{
L
Len Brown 已提交
619 620 621
	struct acpi_gpe_block_info *next_gpe_block;
	struct acpi_gpe_xrupt_info *gpe_xrupt_block;
	acpi_status status;
B
Bob Moore 已提交
622
	acpi_cpu_flags flags;
L
Linus Torvalds 已提交
623

B
Bob Moore 已提交
624
	ACPI_FUNCTION_TRACE(ev_install_gpe_block);
L
Linus Torvalds 已提交
625

L
Len Brown 已提交
626 627 628
	status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
	if (ACPI_FAILURE(status)) {
		return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
629 630
	}

L
Len Brown 已提交
631
	gpe_xrupt_block = acpi_ev_get_gpe_xrupt_block(interrupt_number);
L
Linus Torvalds 已提交
632 633 634 635 636
	if (!gpe_xrupt_block) {
		status = AE_NO_MEMORY;
		goto unlock_and_exit;
	}

R
Robert Moore 已提交
637
	/* Install the new block at the end of the list with lock */
L
Linus Torvalds 已提交
638

L
Len Brown 已提交
639
	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
L
Linus Torvalds 已提交
640 641 642 643 644 645 646 647
	if (gpe_xrupt_block->gpe_block_list_head) {
		next_gpe_block = gpe_xrupt_block->gpe_block_list_head;
		while (next_gpe_block->next) {
			next_gpe_block = next_gpe_block->next;
		}

		next_gpe_block->next = gpe_block;
		gpe_block->previous = next_gpe_block;
L
Len Brown 已提交
648
	} else {
L
Linus Torvalds 已提交
649 650 651 652
		gpe_xrupt_block->gpe_block_list_head = gpe_block;
	}

	gpe_block->xrupt_block = gpe_xrupt_block;
L
Len Brown 已提交
653
	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
L
Linus Torvalds 已提交
654

L
Len Brown 已提交
655 656 657
      unlock_and_exit:
	status = acpi_ut_release_mutex(ACPI_MTX_EVENTS);
	return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
658 659 660 661 662 663 664 665 666 667 668 669 670 671
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_delete_gpe_block
 *
 * PARAMETERS:  gpe_block       - Existing GPE block
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Remove a GPE block
 *
 ******************************************************************************/

L
Len Brown 已提交
672
acpi_status acpi_ev_delete_gpe_block(struct acpi_gpe_block_info *gpe_block)
L
Linus Torvalds 已提交
673
{
L
Len Brown 已提交
674
	acpi_status status;
B
Bob Moore 已提交
675
	acpi_cpu_flags flags;
L
Linus Torvalds 已提交
676

B
Bob Moore 已提交
677
	ACPI_FUNCTION_TRACE(ev_install_gpe_block);
L
Linus Torvalds 已提交
678

L
Len Brown 已提交
679 680 681
	status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
	if (ACPI_FAILURE(status)) {
		return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
682 683 684 685
	}

	/* Disable all GPEs in this block */

L
Len Brown 已提交
686
	status = acpi_hw_disable_gpe_block(gpe_block->xrupt_block, gpe_block);
L
Linus Torvalds 已提交
687 688

	if (!gpe_block->previous && !gpe_block->next) {
B
Bob Moore 已提交
689

L
Linus Torvalds 已提交
690 691
		/* This is the last gpe_block on this interrupt */

L
Len Brown 已提交
692 693
		status = acpi_ev_delete_gpe_xrupt(gpe_block->xrupt_block);
		if (ACPI_FAILURE(status)) {
L
Linus Torvalds 已提交
694 695
			goto unlock_and_exit;
		}
L
Len Brown 已提交
696
	} else {
L
Linus Torvalds 已提交
697 698
		/* Remove the block on this interrupt with lock */

L
Len Brown 已提交
699
		flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
L
Linus Torvalds 已提交
700 701
		if (gpe_block->previous) {
			gpe_block->previous->next = gpe_block->next;
L
Len Brown 已提交
702 703 704
		} else {
			gpe_block->xrupt_block->gpe_block_list_head =
			    gpe_block->next;
L
Linus Torvalds 已提交
705 706 707 708 709
		}

		if (gpe_block->next) {
			gpe_block->next->previous = gpe_block->previous;
		}
L
Len Brown 已提交
710
		acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
L
Linus Torvalds 已提交
711 712 713 714
	}

	/* Free the gpe_block */

B
Bob Moore 已提交
715 716 717
	ACPI_FREE(gpe_block->register_info);
	ACPI_FREE(gpe_block->event_info);
	ACPI_FREE(gpe_block);
L
Linus Torvalds 已提交
718

L
Len Brown 已提交
719 720 721
      unlock_and_exit:
	status = acpi_ut_release_mutex(ACPI_MTX_EVENTS);
	return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
722 723 724 725 726 727 728 729 730 731 732 733 734 735 736
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_create_gpe_info_blocks
 *
 * PARAMETERS:  gpe_block   - New GPE block
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Create the register_info and event_info blocks for this GPE block
 *
 ******************************************************************************/

static acpi_status
L
Len Brown 已提交
737
acpi_ev_create_gpe_info_blocks(struct acpi_gpe_block_info *gpe_block)
L
Linus Torvalds 已提交
738
{
L
Len Brown 已提交
739 740 741 742 743 744 745
	struct acpi_gpe_register_info *gpe_register_info = NULL;
	struct acpi_gpe_event_info *gpe_event_info = NULL;
	struct acpi_gpe_event_info *this_event;
	struct acpi_gpe_register_info *this_register;
	acpi_native_uint i;
	acpi_native_uint j;
	acpi_status status;
L
Linus Torvalds 已提交
746

B
Bob Moore 已提交
747
	ACPI_FUNCTION_TRACE(ev_create_gpe_info_blocks);
L
Linus Torvalds 已提交
748 749 750

	/* Allocate the GPE register information block */

B
Bob Moore 已提交
751 752 753 754
	gpe_register_info = ACPI_ALLOCATE_ZEROED((acpi_size) gpe_block->
						 register_count *
						 sizeof(struct
							acpi_gpe_register_info));
L
Linus Torvalds 已提交
755
	if (!gpe_register_info) {
B
Bob Moore 已提交
756
		ACPI_ERROR((AE_INFO,
B
Bob Moore 已提交
757
			    "Could not allocate the GpeRegisterInfo table"));
L
Len Brown 已提交
758
		return_ACPI_STATUS(AE_NO_MEMORY);
L
Linus Torvalds 已提交
759 760 761 762
	}

	/*
	 * Allocate the GPE event_info block. There are eight distinct GPEs
B
Bob Moore 已提交
763
	 * per register. Initialization to zeros is sufficient.
L
Linus Torvalds 已提交
764
	 */
B
Bob Moore 已提交
765 766 767 768 769
	gpe_event_info = ACPI_ALLOCATE_ZEROED(((acpi_size) gpe_block->
					       register_count *
					       ACPI_GPE_REGISTER_WIDTH) *
					      sizeof(struct
						     acpi_gpe_event_info));
L
Linus Torvalds 已提交
770
	if (!gpe_event_info) {
B
Bob Moore 已提交
771
		ACPI_ERROR((AE_INFO,
B
Bob Moore 已提交
772
			    "Could not allocate the GpeEventInfo table"));
L
Linus Torvalds 已提交
773 774 775 776 777 778 779
		status = AE_NO_MEMORY;
		goto error_exit;
	}

	/* Save the new Info arrays in the GPE block */

	gpe_block->register_info = gpe_register_info;
L
Len Brown 已提交
780
	gpe_block->event_info = gpe_event_info;
L
Linus Torvalds 已提交
781 782

	/*
B
Bob Moore 已提交
783
	 * Initialize the GPE Register and Event structures. A goal of these
L
Linus Torvalds 已提交
784
	 * tables is to hide the fact that there are two separate GPE register sets
B
Bob Moore 已提交
785
	 * in a given GPE hardware block, the status registers occupy the first half,
L
Linus Torvalds 已提交
786 787 788
	 * and the enable registers occupy the second half.
	 */
	this_register = gpe_register_info;
L
Len Brown 已提交
789
	this_event = gpe_event_info;
L
Linus Torvalds 已提交
790 791

	for (i = 0; i < gpe_block->register_count; i++) {
B
Bob Moore 已提交
792

L
Linus Torvalds 已提交
793 794
		/* Init the register_info for this GPE register (8 GPEs) */

L
Len Brown 已提交
795 796 797 798
		this_register->base_gpe_number =
		    (u8) (gpe_block->block_base_number +
			  (i * ACPI_GPE_REGISTER_WIDTH));

B
Bob Moore 已提交
799 800
		this_register->status_address.address =
		    gpe_block->block_address.address + i;
L
Len Brown 已提交
801

B
Bob Moore 已提交
802 803 804
		this_register->enable_address.address =
		    gpe_block->block_address.address + i +
		    gpe_block->register_count;
L
Len Brown 已提交
805

806 807 808 809 810
		this_register->status_address.space_id =
		    gpe_block->block_address.space_id;
		this_register->enable_address.space_id =
		    gpe_block->block_address.space_id;
		this_register->status_address.bit_width =
L
Len Brown 已提交
811
		    ACPI_GPE_REGISTER_WIDTH;
812
		this_register->enable_address.bit_width =
L
Len Brown 已提交
813
		    ACPI_GPE_REGISTER_WIDTH;
814
		this_register->status_address.bit_offset =
L
Len Brown 已提交
815
		    ACPI_GPE_REGISTER_WIDTH;
816
		this_register->enable_address.bit_offset =
L
Len Brown 已提交
817
		    ACPI_GPE_REGISTER_WIDTH;
L
Linus Torvalds 已提交
818 819 820 821

		/* Init the event_info for each GPE within this register */

		for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
822 823
			this_event->gpe_number =
			    (u8) (this_register->base_gpe_number + j);
L
Linus Torvalds 已提交
824 825 826 827
			this_event->register_info = this_register;
			this_event++;
		}

B
Bob Moore 已提交
828 829
		/* Disable all GPEs within this register */

L
Len Brown 已提交
830 831 832 833
		status = acpi_hw_low_level_write(ACPI_GPE_REGISTER_WIDTH, 0x00,
						 &this_register->
						 enable_address);
		if (ACPI_FAILURE(status)) {
L
Linus Torvalds 已提交
834 835 836
			goto error_exit;
		}

B
Bob Moore 已提交
837 838
		/* Clear any pending GPE events within this register */

L
Len Brown 已提交
839 840 841 842
		status = acpi_hw_low_level_write(ACPI_GPE_REGISTER_WIDTH, 0xFF,
						 &this_register->
						 status_address);
		if (ACPI_FAILURE(status)) {
L
Linus Torvalds 已提交
843 844 845 846 847 848
			goto error_exit;
		}

		this_register++;
	}

L
Len Brown 已提交
849
	return_ACPI_STATUS(AE_OK);
L
Linus Torvalds 已提交
850

L
Len Brown 已提交
851
      error_exit:
L
Linus Torvalds 已提交
852
	if (gpe_register_info) {
B
Bob Moore 已提交
853
		ACPI_FREE(gpe_register_info);
L
Linus Torvalds 已提交
854 855
	}
	if (gpe_event_info) {
B
Bob Moore 已提交
856
		ACPI_FREE(gpe_event_info);
L
Linus Torvalds 已提交
857 858
	}

L
Len Brown 已提交
859
	return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
860 861 862 863 864 865 866 867 868 869
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_create_gpe_block
 *
 * PARAMETERS:  gpe_device          - Handle to the parent GPE block
 *              gpe_block_address   - Address and space_iD
 *              register_count      - Number of GPE register pairs in the block
 *              gpe_block_base_number - Starting GPE number for the block
870
 *              interrupt_number    - H/W interrupt for the block
L
Linus Torvalds 已提交
871 872 873 874
 *              return_gpe_block    - Where the new block descriptor is returned
 *
 * RETURN:      Status
 *
B
Bob Moore 已提交
875 876 877
 * DESCRIPTION: Create and Install a block of GPE registers. All GPEs within
 *              the block are disabled at exit.
 *              Note: Assumes namespace is locked.
L
Linus Torvalds 已提交
878 879 880 881
 *
 ******************************************************************************/

acpi_status
L
Len Brown 已提交
882 883 884 885 886 887
acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
			 struct acpi_generic_address *gpe_block_address,
			 u32 register_count,
			 u8 gpe_block_base_number,
			 u32 interrupt_number,
			 struct acpi_gpe_block_info **return_gpe_block)
L
Linus Torvalds 已提交
888
{
L
Len Brown 已提交
889
	acpi_status status;
B
Bob Moore 已提交
890
	struct acpi_gpe_block_info *gpe_block;
L
Linus Torvalds 已提交
891

B
Bob Moore 已提交
892
	ACPI_FUNCTION_TRACE(ev_create_gpe_block);
L
Linus Torvalds 已提交
893 894

	if (!register_count) {
L
Len Brown 已提交
895
		return_ACPI_STATUS(AE_OK);
L
Linus Torvalds 已提交
896 897 898 899
	}

	/* Allocate a new GPE block */

B
Bob Moore 已提交
900
	gpe_block = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_block_info));
L
Linus Torvalds 已提交
901
	if (!gpe_block) {
L
Len Brown 已提交
902
		return_ACPI_STATUS(AE_NO_MEMORY);
L
Linus Torvalds 已提交
903 904 905 906
	}

	/* Initialize the new GPE block */

B
Bob Moore 已提交
907
	gpe_block->node = gpe_device;
L
Linus Torvalds 已提交
908 909 910
	gpe_block->register_count = register_count;
	gpe_block->block_base_number = gpe_block_base_number;

L
Len Brown 已提交
911 912
	ACPI_MEMCPY(&gpe_block->block_address, gpe_block_address,
		    sizeof(struct acpi_generic_address));
L
Linus Torvalds 已提交
913

B
Bob Moore 已提交
914 915 916 917
	/*
	 * Create the register_info and event_info sub-structures
	 * Note: disables and clears all GPEs in the block
	 */
L
Len Brown 已提交
918 919
	status = acpi_ev_create_gpe_info_blocks(gpe_block);
	if (ACPI_FAILURE(status)) {
B
Bob Moore 已提交
920
		ACPI_FREE(gpe_block);
L
Len Brown 已提交
921
		return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
922 923
	}

B
Bob Moore 已提交
924
	/* Install the new block in the global lists */
L
Linus Torvalds 已提交
925

L
Len Brown 已提交
926 927
	status = acpi_ev_install_gpe_block(gpe_block, interrupt_number);
	if (ACPI_FAILURE(status)) {
B
Bob Moore 已提交
928
		ACPI_FREE(gpe_block);
L
Len Brown 已提交
929
		return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
930 931 932 933
	}

	/* Find all GPE methods (_Lxx, _Exx) for this block */

L
Len Brown 已提交
934 935 936 937
	status = acpi_ns_walk_namespace(ACPI_TYPE_METHOD, gpe_device,
					ACPI_UINT32_MAX, ACPI_NS_WALK_NO_UNLOCK,
					acpi_ev_save_method_info, gpe_block,
					NULL);
L
Linus Torvalds 已提交
938

B
Bob Moore 已提交
939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984
	/* Return the new block */

	if (return_gpe_block) {
		(*return_gpe_block) = gpe_block;
	}

	ACPI_DEBUG_PRINT((ACPI_DB_INIT,
			  "GPE %02X to %02X [%4.4s] %u regs on int 0x%X\n",
			  (u32) gpe_block->block_base_number,
			  (u32) (gpe_block->block_base_number +
				 ((gpe_block->register_count *
				   ACPI_GPE_REGISTER_WIDTH) - 1)),
			  gpe_device->name.ascii, gpe_block->register_count,
			  interrupt_number));

	return_ACPI_STATUS(AE_OK);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_initialize_gpe_block
 *
 * PARAMETERS:  gpe_device          - Handle to the parent GPE block
 *              gpe_block           - Gpe Block info
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Initialize and enable a GPE block. First find and run any
 *              _PRT methods associated with the block, then enable the
 *              appropriate GPEs.
 *              Note: Assumes namespace is locked.
 *
 ******************************************************************************/

acpi_status
acpi_ev_initialize_gpe_block(struct acpi_namespace_node *gpe_device,
			     struct acpi_gpe_block_info *gpe_block)
{
	acpi_status status;
	struct acpi_gpe_event_info *gpe_event_info;
	struct acpi_gpe_walk_info gpe_info;
	u32 wake_gpe_count;
	u32 gpe_enabled_count;
	acpi_native_uint i;
	acpi_native_uint j;

B
Bob Moore 已提交
985
	ACPI_FUNCTION_TRACE(ev_initialize_gpe_block);
B
Bob Moore 已提交
986 987 988 989 990 991 992

	/* Ignore a null GPE block (e.g., if no GPE block 1 exists) */

	if (!gpe_block) {
		return_ACPI_STATUS(AE_OK);
	}

L
Linus Torvalds 已提交
993
	/*
B
Bob Moore 已提交
994 995
	 * Runtime option: Should wake GPEs be enabled at runtime?  The default
	 * is no, they should only be enabled just as the machine goes to sleep.
L
Linus Torvalds 已提交
996 997 998
	 */
	if (acpi_gbl_leave_wake_gpes_disabled) {
		/*
B
Bob Moore 已提交
999 1000 1001 1002
		 * Differentiate runtime vs wake GPEs, via the _PRW control methods.
		 * Each GPE that has one or more _PRWs that reference it is by
		 * definition a wake GPE and will not be enabled while the machine
		 * is running.
L
Linus Torvalds 已提交
1003 1004 1005 1006
		 */
		gpe_info.gpe_block = gpe_block;
		gpe_info.gpe_device = gpe_device;

L
Len Brown 已提交
1007 1008 1009 1010 1011
		status =
		    acpi_ns_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
					   ACPI_UINT32_MAX, ACPI_NS_WALK_UNLOCK,
					   acpi_ev_match_prw_and_gpe, &gpe_info,
					   NULL);
L
Linus Torvalds 已提交
1012 1013 1014
	}

	/*
B
Bob Moore 已提交
1015 1016 1017 1018 1019 1020
	 * Enable all GPEs in this block that have these attributes:
	 * 1) are "runtime" or "run/wake" GPEs, and
	 * 2) have a corresponding _Lxx or _Exx method
	 *
	 * Any other GPEs within this block must be enabled via the acpi_enable_gpe()
	 * external interface.
L
Linus Torvalds 已提交
1021 1022 1023 1024 1025 1026
	 */
	wake_gpe_count = 0;
	gpe_enabled_count = 0;

	for (i = 0; i < gpe_block->register_count; i++) {
		for (j = 0; j < 8; j++) {
B
Bob Moore 已提交
1027

L
Linus Torvalds 已提交
1028 1029
			/* Get the info block for this particular GPE */

L
Len Brown 已提交
1030 1031 1032
			gpe_event_info =
			    &gpe_block->
			    event_info[(i * ACPI_GPE_REGISTER_WIDTH) + j];
L
Linus Torvalds 已提交
1033

L
Len Brown 已提交
1034 1035 1036 1037
			if (((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
			     ACPI_GPE_DISPATCH_METHOD)
			    && (gpe_event_info->
				flags & ACPI_GPE_TYPE_RUNTIME)) {
L
Linus Torvalds 已提交
1038 1039 1040 1041 1042 1043 1044 1045 1046
				gpe_enabled_count++;
			}

			if (gpe_event_info->flags & ACPI_GPE_TYPE_WAKE) {
				wake_gpe_count++;
			}
		}
	}

L
Len Brown 已提交
1047 1048 1049
	ACPI_DEBUG_PRINT((ACPI_DB_INIT,
			  "Found %u Wake, Enabled %u Runtime GPEs in this block\n",
			  wake_gpe_count, gpe_enabled_count));
L
Linus Torvalds 已提交
1050

B
Bob Moore 已提交
1051
	/* Enable all valid runtime GPEs found above */
L
Linus Torvalds 已提交
1052

B
Bob Moore 已提交
1053 1054
	status = acpi_hw_enable_runtime_gpe_block(NULL, gpe_block);
	if (ACPI_FAILURE(status)) {
B
Bob Moore 已提交
1055
		ACPI_ERROR((AE_INFO, "Could not enable GPEs in GpeBlock %p",
B
Bob Moore 已提交
1056
			    gpe_block));
L
Linus Torvalds 已提交
1057 1058
	}

B
Bob Moore 已提交
1059
	return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ev_gpe_initialize
 *
 * PARAMETERS:  None
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Initialize the GPE data structures
 *
 ******************************************************************************/

L
Len Brown 已提交
1074
acpi_status acpi_ev_gpe_initialize(void)
L
Linus Torvalds 已提交
1075
{
L
Len Brown 已提交
1076 1077 1078 1079
	u32 register_count0 = 0;
	u32 register_count1 = 0;
	u32 gpe_number_max = 0;
	acpi_status status;
L
Linus Torvalds 已提交
1080

B
Bob Moore 已提交
1081
	ACPI_FUNCTION_TRACE(ev_gpe_initialize);
L
Linus Torvalds 已提交
1082

L
Len Brown 已提交
1083 1084 1085
	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
	if (ACPI_FAILURE(status)) {
		return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112
	}

	/*
	 * Initialize the GPE Block(s) defined in the FADT
	 *
	 * Why the GPE register block lengths are divided by 2:  From the ACPI Spec,
	 * section "General-Purpose Event Registers", we have:
	 *
	 * "Each register block contains two registers of equal length
	 *  GPEx_STS and GPEx_EN (where x is 0 or 1). The length of the
	 *  GPE0_STS and GPE0_EN registers is equal to half the GPE0_LEN
	 *  The length of the GPE1_STS and GPE1_EN registers is equal to
	 *  half the GPE1_LEN. If a generic register block is not supported
	 *  then its respective block pointer and block length values in the
	 *  FADT table contain zeros. The GPE0_LEN and GPE1_LEN do not need
	 *  to be the same size."
	 */

	/*
	 * Determine the maximum GPE number for this machine.
	 *
	 * Note: both GPE0 and GPE1 are optional, and either can exist without
	 * the other.
	 *
	 * If EITHER the register length OR the block address are zero, then that
	 * particular block is not supported.
	 */
1113 1114
	if (acpi_gbl_FADT.gpe0_block_length &&
	    acpi_gbl_FADT.xgpe0_block.address) {
B
Bob Moore 已提交
1115

L
Linus Torvalds 已提交
1116 1117
		/* GPE block 0 exists (has both length and address > 0) */

1118
		register_count0 = (u16) (acpi_gbl_FADT.gpe0_block_length / 2);
L
Linus Torvalds 已提交
1119

L
Len Brown 已提交
1120 1121
		gpe_number_max =
		    (register_count0 * ACPI_GPE_REGISTER_WIDTH) - 1;
L
Linus Torvalds 已提交
1122 1123 1124

		/* Install GPE Block 0 */

L
Len Brown 已提交
1125
		status = acpi_ev_create_gpe_block(acpi_gbl_fadt_gpe_device,
1126
						  &acpi_gbl_FADT.xgpe0_block,
L
Len Brown 已提交
1127
						  register_count0, 0,
1128
						  acpi_gbl_FADT.sci_interrupt,
L
Len Brown 已提交
1129
						  &acpi_gbl_gpe_fadt_blocks[0]);
L
Linus Torvalds 已提交
1130

L
Len Brown 已提交
1131
		if (ACPI_FAILURE(status)) {
B
Bob Moore 已提交
1132 1133
			ACPI_EXCEPTION((AE_INFO, status,
					"Could not create GPE Block 0"));
L
Linus Torvalds 已提交
1134 1135 1136
		}
	}

1137 1138
	if (acpi_gbl_FADT.gpe1_block_length &&
	    acpi_gbl_FADT.xgpe1_block.address) {
B
Bob Moore 已提交
1139

L
Linus Torvalds 已提交
1140 1141
		/* GPE block 1 exists (has both length and address > 0) */

1142
		register_count1 = (u16) (acpi_gbl_FADT.gpe1_block_length / 2);
L
Linus Torvalds 已提交
1143 1144 1145 1146

		/* Check for GPE0/GPE1 overlap (if both banks exist) */

		if ((register_count0) &&
1147
		    (gpe_number_max >= acpi_gbl_FADT.gpe1_base)) {
B
Bob Moore 已提交
1148 1149
			ACPI_ERROR((AE_INFO,
				    "GPE0 block (GPE 0 to %d) overlaps the GPE1 block (GPE %d to %d) - Ignoring GPE1",
1150 1151
				    gpe_number_max, acpi_gbl_FADT.gpe1_base,
				    acpi_gbl_FADT.gpe1_base +
B
Bob Moore 已提交
1152 1153
				    ((register_count1 *
				      ACPI_GPE_REGISTER_WIDTH) - 1)));
L
Linus Torvalds 已提交
1154 1155 1156 1157

			/* Ignore GPE1 block by setting the register count to zero */

			register_count1 = 0;
L
Len Brown 已提交
1158
		} else {
L
Linus Torvalds 已提交
1159 1160
			/* Install GPE Block 1 */

L
Len Brown 已提交
1161 1162
			status =
			    acpi_ev_create_gpe_block(acpi_gbl_fadt_gpe_device,
1163
						     &acpi_gbl_FADT.xgpe1_block,
L
Len Brown 已提交
1164
						     register_count1,
1165 1166 1167
						     acpi_gbl_FADT.gpe1_base,
						     acpi_gbl_FADT.
						     sci_interrupt,
L
Len Brown 已提交
1168 1169 1170 1171
						     &acpi_gbl_gpe_fadt_blocks
						     [1]);

			if (ACPI_FAILURE(status)) {
B
Bob Moore 已提交
1172 1173
				ACPI_EXCEPTION((AE_INFO, status,
						"Could not create GPE Block 1"));
L
Linus Torvalds 已提交
1174 1175 1176 1177 1178 1179
			}

			/*
			 * GPE0 and GPE1 do not have to be contiguous in the GPE number
			 * space. However, GPE0 always starts at GPE number zero.
			 */
1180
			gpe_number_max = acpi_gbl_FADT.gpe1_base +
L
Len Brown 已提交
1181
			    ((register_count1 * ACPI_GPE_REGISTER_WIDTH) - 1);
L
Linus Torvalds 已提交
1182 1183 1184 1185 1186 1187
		}
	}

	/* Exit if there are no GPE registers */

	if ((register_count0 + register_count1) == 0) {
B
Bob Moore 已提交
1188

L
Linus Torvalds 已提交
1189 1190
		/* GPEs are not required by ACPI, this is OK */

L
Len Brown 已提交
1191 1192
		ACPI_DEBUG_PRINT((ACPI_DB_INIT,
				  "There are no GPE blocks defined in the FADT\n"));
L
Linus Torvalds 已提交
1193 1194 1195 1196 1197 1198 1199
		status = AE_OK;
		goto cleanup;
	}

	/* Check for Max GPE number out-of-range */

	if (gpe_number_max > ACPI_GPE_MAX) {
B
Bob Moore 已提交
1200 1201 1202
		ACPI_ERROR((AE_INFO,
			    "Maximum GPE number from FADT is too large: 0x%X",
			    gpe_number_max));
L
Linus Torvalds 已提交
1203 1204 1205 1206
		status = AE_BAD_VALUE;
		goto cleanup;
	}

L
Len Brown 已提交
1207 1208 1209
      cleanup:
	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
	return_ACPI_STATUS(AE_OK);
L
Linus Torvalds 已提交
1210
}