Print this page
update to acpica-unix2-20131218
acpica-unix2-20130823
PANKOVs restructure
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/intel/io/acpica/events/evgpeblk.c
+++ new/usr/src/common/acpica/components/events/evgpeblk.c
1 1 /******************************************************************************
2 2 *
3 3 * Module Name: evgpeblk - GPE block creation and initialization.
4 4 *
5 5 *****************************************************************************/
6 6
7 7 /*
8 - * Copyright (C) 2000 - 2011, Intel Corp.
8 + * Copyright (C) 2000 - 2013, Intel Corp.
9 9 * All rights reserved.
10 10 *
11 11 * Redistribution and use in source and binary forms, with or without
12 12 * modification, are permitted provided that the following conditions
13 13 * are met:
14 14 * 1. Redistributions of source code must retain the above copyright
15 15 * notice, this list of conditions, and the following disclaimer,
16 16 * without modification.
17 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 18 * substantially similar to the "NO WARRANTY" disclaimer below
19 19 * ("Disclaimer") and any redistribution must be conditioned upon
20 20 * including a substantially similar Disclaimer requirement for further
21 21 * binary redistribution.
22 22 * 3. Neither the names of the above-listed copyright holders nor the names
23 23 * of any contributors may be used to endorse or promote products derived
24 24 * from this software without specific prior written permission.
25 25 *
26 26 * Alternatively, this software may be distributed under the terms of the
27 27 * GNU General Public License ("GPL") version 2 as published by the Free
28 28 * Software Foundation.
29 29 *
30 30 * NO WARRANTY
31 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 41 * POSSIBILITY OF SUCH DAMAGES.
|
↓ open down ↓ |
23 lines elided |
↑ open up ↑ |
42 42 */
43 43
44 44 #include "acpi.h"
45 45 #include "accommon.h"
46 46 #include "acevents.h"
47 47 #include "acnamesp.h"
48 48
49 49 #define _COMPONENT ACPI_EVENTS
50 50 ACPI_MODULE_NAME ("evgpeblk")
51 51
52 +#if (!ACPI_REDUCED_HARDWARE) /* Entire module */
53 +
52 54 /* Local prototypes */
53 55
54 56 static ACPI_STATUS
55 57 AcpiEvInstallGpeBlock (
56 58 ACPI_GPE_BLOCK_INFO *GpeBlock,
57 59 UINT32 InterruptNumber);
58 60
59 61 static ACPI_STATUS
60 62 AcpiEvCreateGpeInfoBlocks (
61 63 ACPI_GPE_BLOCK_INFO *GpeBlock);
62 64
63 65
64 66 /*******************************************************************************
65 67 *
66 68 * FUNCTION: AcpiEvInstallGpeBlock
67 69 *
68 70 * PARAMETERS: GpeBlock - New GPE block
69 71 * InterruptNumber - Xrupt to be associated with this
70 72 * GPE block
71 73 *
72 74 * RETURN: Status
73 75 *
74 76 * DESCRIPTION: Install new GPE block with mutex support
75 77 *
76 78 ******************************************************************************/
77 79
78 80 static ACPI_STATUS
79 81 AcpiEvInstallGpeBlock (
80 82 ACPI_GPE_BLOCK_INFO *GpeBlock,
81 83 UINT32 InterruptNumber)
82 84 {
83 85 ACPI_GPE_BLOCK_INFO *NextGpeBlock;
84 86 ACPI_GPE_XRUPT_INFO *GpeXruptBlock;
85 87 ACPI_STATUS Status;
86 88 ACPI_CPU_FLAGS Flags;
87 89
|
↓ open down ↓ |
26 lines elided |
↑ open up ↑ |
88 90
89 91 ACPI_FUNCTION_TRACE (EvInstallGpeBlock);
90 92
91 93
92 94 Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
93 95 if (ACPI_FAILURE (Status))
94 96 {
95 97 return_ACPI_STATUS (Status);
96 98 }
97 99
98 - GpeXruptBlock = AcpiEvGetGpeXruptBlock (InterruptNumber);
99 - if (!GpeXruptBlock)
100 + Status = AcpiEvGetGpeXruptBlock (InterruptNumber, &GpeXruptBlock);
101 + if (ACPI_FAILURE (Status))
100 102 {
101 - Status = AE_NO_MEMORY;
102 103 goto UnlockAndExit;
103 104 }
104 105
105 106 /* Install the new block at the end of the list with lock */
106 107
107 108 Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
108 109 if (GpeXruptBlock->GpeBlockListHead)
109 110 {
110 111 NextGpeBlock = GpeXruptBlock->GpeBlockListHead;
111 112 while (NextGpeBlock->Next)
112 113 {
113 114 NextGpeBlock = NextGpeBlock->Next;
114 115 }
115 116
116 117 NextGpeBlock->Next = GpeBlock;
117 118 GpeBlock->Previous = NextGpeBlock;
118 119 }
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
119 120 else
120 121 {
121 122 GpeXruptBlock->GpeBlockListHead = GpeBlock;
122 123 }
123 124
124 125 GpeBlock->XruptBlock = GpeXruptBlock;
125 126 AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
126 127
127 128
128 129 UnlockAndExit:
129 - Status = AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
130 + (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
130 131 return_ACPI_STATUS (Status);
131 132 }
132 133
133 134
134 135 /*******************************************************************************
135 136 *
136 137 * FUNCTION: AcpiEvDeleteGpeBlock
137 138 *
138 139 * PARAMETERS: GpeBlock - Existing GPE block
139 140 *
140 141 * RETURN: Status
141 142 *
142 143 * DESCRIPTION: Remove a GPE block
143 144 *
144 145 ******************************************************************************/
145 146
146 147 ACPI_STATUS
147 148 AcpiEvDeleteGpeBlock (
148 149 ACPI_GPE_BLOCK_INFO *GpeBlock)
149 150 {
150 151 ACPI_STATUS Status;
151 152 ACPI_CPU_FLAGS Flags;
152 153
153 154
154 155 ACPI_FUNCTION_TRACE (EvInstallGpeBlock);
155 156
156 157
157 158 Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
158 159 if (ACPI_FAILURE (Status))
159 160 {
160 161 return_ACPI_STATUS (Status);
161 162 }
162 163
163 164 /* Disable all GPEs in this block */
164 165
165 166 Status = AcpiHwDisableGpeBlock (GpeBlock->XruptBlock, GpeBlock, NULL);
166 167
167 168 if (!GpeBlock->Previous && !GpeBlock->Next)
168 169 {
169 170 /* This is the last GpeBlock on this interrupt */
170 171
171 172 Status = AcpiEvDeleteGpeXrupt (GpeBlock->XruptBlock);
172 173 if (ACPI_FAILURE (Status))
173 174 {
174 175 goto UnlockAndExit;
175 176 }
176 177 }
177 178 else
178 179 {
179 180 /* Remove the block on this interrupt with lock */
180 181
181 182 Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
182 183 if (GpeBlock->Previous)
183 184 {
184 185 GpeBlock->Previous->Next = GpeBlock->Next;
185 186 }
186 187 else
187 188 {
188 189 GpeBlock->XruptBlock->GpeBlockListHead = GpeBlock->Next;
189 190 }
190 191
191 192 if (GpeBlock->Next)
192 193 {
193 194 GpeBlock->Next->Previous = GpeBlock->Previous;
194 195 }
195 196 AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
196 197 }
197 198
198 199 AcpiCurrentGpeCount -= GpeBlock->GpeCount;
199 200
200 201 /* Free the GpeBlock */
201 202
202 203 ACPI_FREE (GpeBlock->RegisterInfo);
203 204 ACPI_FREE (GpeBlock->EventInfo);
204 205 ACPI_FREE (GpeBlock);
205 206
206 207 UnlockAndExit:
207 208 Status = AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
208 209 return_ACPI_STATUS (Status);
209 210 }
210 211
211 212
212 213 /*******************************************************************************
213 214 *
214 215 * FUNCTION: AcpiEvCreateGpeInfoBlocks
215 216 *
216 217 * PARAMETERS: GpeBlock - New GPE block
217 218 *
218 219 * RETURN: Status
219 220 *
220 221 * DESCRIPTION: Create the RegisterInfo and EventInfo blocks for this GPE block
221 222 *
222 223 ******************************************************************************/
223 224
224 225 static ACPI_STATUS
225 226 AcpiEvCreateGpeInfoBlocks (
226 227 ACPI_GPE_BLOCK_INFO *GpeBlock)
227 228 {
228 229 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo = NULL;
229 230 ACPI_GPE_EVENT_INFO *GpeEventInfo = NULL;
230 231 ACPI_GPE_EVENT_INFO *ThisEvent;
231 232 ACPI_GPE_REGISTER_INFO *ThisRegister;
232 233 UINT32 i;
233 234 UINT32 j;
234 235 ACPI_STATUS Status;
235 236
236 237
237 238 ACPI_FUNCTION_TRACE (EvCreateGpeInfoBlocks);
238 239
239 240
240 241 /* Allocate the GPE register information block */
241 242
242 243 GpeRegisterInfo = ACPI_ALLOCATE_ZEROED (
243 244 (ACPI_SIZE) GpeBlock->RegisterCount *
244 245 sizeof (ACPI_GPE_REGISTER_INFO));
245 246 if (!GpeRegisterInfo)
246 247 {
247 248 ACPI_ERROR ((AE_INFO,
248 249 "Could not allocate the GpeRegisterInfo table"));
249 250 return_ACPI_STATUS (AE_NO_MEMORY);
250 251 }
251 252
252 253 /*
253 254 * Allocate the GPE EventInfo block. There are eight distinct GPEs
254 255 * per register. Initialization to zeros is sufficient.
255 256 */
256 257 GpeEventInfo = ACPI_ALLOCATE_ZEROED ((ACPI_SIZE) GpeBlock->GpeCount *
257 258 sizeof (ACPI_GPE_EVENT_INFO));
258 259 if (!GpeEventInfo)
259 260 {
260 261 ACPI_ERROR ((AE_INFO,
261 262 "Could not allocate the GpeEventInfo table"));
262 263 Status = AE_NO_MEMORY;
263 264 goto ErrorExit;
264 265 }
265 266
266 267 /* Save the new Info arrays in the GPE block */
267 268
268 269 GpeBlock->RegisterInfo = GpeRegisterInfo;
269 270 GpeBlock->EventInfo = GpeEventInfo;
270 271
271 272 /*
272 273 * Initialize the GPE Register and Event structures. A goal of these
273 274 * tables is to hide the fact that there are two separate GPE register
274 275 * sets in a given GPE hardware block, the status registers occupy the
275 276 * first half, and the enable registers occupy the second half.
276 277 */
277 278 ThisRegister = GpeRegisterInfo;
278 279 ThisEvent = GpeEventInfo;
279 280
280 281 for (i = 0; i < GpeBlock->RegisterCount; i++)
281 282 {
282 283 /* Init the RegisterInfo for this GPE register (8 GPEs) */
283 284
284 285 ThisRegister->BaseGpeNumber = (UINT8) (GpeBlock->BlockBaseNumber +
285 286 (i * ACPI_GPE_REGISTER_WIDTH));
286 287
287 288 ThisRegister->StatusAddress.Address =
288 289 GpeBlock->BlockAddress.Address + i;
289 290
290 291 ThisRegister->EnableAddress.Address =
291 292 GpeBlock->BlockAddress.Address + i + GpeBlock->RegisterCount;
292 293
293 294 ThisRegister->StatusAddress.SpaceId = GpeBlock->BlockAddress.SpaceId;
294 295 ThisRegister->EnableAddress.SpaceId = GpeBlock->BlockAddress.SpaceId;
295 296 ThisRegister->StatusAddress.BitWidth = ACPI_GPE_REGISTER_WIDTH;
296 297 ThisRegister->EnableAddress.BitWidth = ACPI_GPE_REGISTER_WIDTH;
297 298 ThisRegister->StatusAddress.BitOffset = 0;
298 299 ThisRegister->EnableAddress.BitOffset = 0;
299 300
300 301 /* Init the EventInfo for each GPE within this register */
301 302
302 303 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
303 304 {
304 305 ThisEvent->GpeNumber = (UINT8) (ThisRegister->BaseGpeNumber + j);
305 306 ThisEvent->RegisterInfo = ThisRegister;
306 307 ThisEvent++;
307 308 }
308 309
309 310 /* Disable all GPEs within this register */
310 311
311 312 Status = AcpiHwWrite (0x00, &ThisRegister->EnableAddress);
312 313 if (ACPI_FAILURE (Status))
313 314 {
314 315 goto ErrorExit;
315 316 }
316 317
317 318 /* Clear any pending GPE events within this register */
318 319
319 320 Status = AcpiHwWrite (0xFF, &ThisRegister->StatusAddress);
320 321 if (ACPI_FAILURE (Status))
321 322 {
322 323 goto ErrorExit;
323 324 }
324 325
325 326 ThisRegister++;
326 327 }
327 328
328 329 return_ACPI_STATUS (AE_OK);
329 330
330 331
331 332 ErrorExit:
332 333 if (GpeRegisterInfo)
333 334 {
334 335 ACPI_FREE (GpeRegisterInfo);
335 336 }
336 337 if (GpeEventInfo)
337 338 {
338 339 ACPI_FREE (GpeEventInfo);
339 340 }
340 341
341 342 return_ACPI_STATUS (Status);
342 343 }
343 344
344 345
345 346 /*******************************************************************************
346 347 *
347 348 * FUNCTION: AcpiEvCreateGpeBlock
348 349 *
349 350 * PARAMETERS: GpeDevice - Handle to the parent GPE block
350 351 * GpeBlockAddress - Address and SpaceID
351 352 * RegisterCount - Number of GPE register pairs in the block
352 353 * GpeBlockBaseNumber - Starting GPE number for the block
353 354 * InterruptNumber - H/W interrupt for the block
354 355 * ReturnGpeBlock - Where the new block descriptor is returned
355 356 *
356 357 * RETURN: Status
357 358 *
358 359 * DESCRIPTION: Create and Install a block of GPE registers. All GPEs within
359 360 * the block are disabled at exit.
360 361 * Note: Assumes namespace is locked.
361 362 *
362 363 ******************************************************************************/
363 364
364 365 ACPI_STATUS
365 366 AcpiEvCreateGpeBlock (
366 367 ACPI_NAMESPACE_NODE *GpeDevice,
367 368 ACPI_GENERIC_ADDRESS *GpeBlockAddress,
368 369 UINT32 RegisterCount,
369 370 UINT8 GpeBlockBaseNumber,
370 371 UINT32 InterruptNumber,
371 372 ACPI_GPE_BLOCK_INFO **ReturnGpeBlock)
372 373 {
373 374 ACPI_STATUS Status;
374 375 ACPI_GPE_BLOCK_INFO *GpeBlock;
375 376 ACPI_GPE_WALK_INFO WalkInfo;
376 377
377 378
378 379 ACPI_FUNCTION_TRACE (EvCreateGpeBlock);
379 380
380 381
381 382 if (!RegisterCount)
382 383 {
383 384 return_ACPI_STATUS (AE_OK);
384 385 }
385 386
386 387 /* Allocate a new GPE block */
387 388
388 389 GpeBlock = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_GPE_BLOCK_INFO));
389 390 if (!GpeBlock)
390 391 {
391 392 return_ACPI_STATUS (AE_NO_MEMORY);
392 393 }
393 394
394 395 /* Initialize the new GPE block */
395 396
396 397 GpeBlock->Node = GpeDevice;
397 398 GpeBlock->GpeCount = (UINT16) (RegisterCount * ACPI_GPE_REGISTER_WIDTH);
398 399 GpeBlock->Initialized = FALSE;
399 400 GpeBlock->RegisterCount = RegisterCount;
400 401 GpeBlock->BlockBaseNumber = GpeBlockBaseNumber;
401 402
402 403 ACPI_MEMCPY (&GpeBlock->BlockAddress, GpeBlockAddress,
403 404 sizeof (ACPI_GENERIC_ADDRESS));
404 405
405 406 /*
406 407 * Create the RegisterInfo and EventInfo sub-structures
407 408 * Note: disables and clears all GPEs in the block
408 409 */
409 410 Status = AcpiEvCreateGpeInfoBlocks (GpeBlock);
410 411 if (ACPI_FAILURE (Status))
|
↓ open down ↓ |
271 lines elided |
↑ open up ↑ |
411 412 {
412 413 ACPI_FREE (GpeBlock);
413 414 return_ACPI_STATUS (Status);
414 415 }
415 416
416 417 /* Install the new block in the global lists */
417 418
418 419 Status = AcpiEvInstallGpeBlock (GpeBlock, InterruptNumber);
419 420 if (ACPI_FAILURE (Status))
420 421 {
422 + ACPI_FREE (GpeBlock->RegisterInfo);
423 + ACPI_FREE (GpeBlock->EventInfo);
421 424 ACPI_FREE (GpeBlock);
422 425 return_ACPI_STATUS (Status);
423 426 }
424 427
425 428 AcpiGbl_AllGpesInitialized = FALSE;
426 429
427 430 /* Find all GPE methods (_Lxx or_Exx) for this block */
428 431
429 432 WalkInfo.GpeBlock = GpeBlock;
430 433 WalkInfo.GpeDevice = GpeDevice;
431 434 WalkInfo.ExecuteByOwnerId = FALSE;
432 435
433 436 Status = AcpiNsWalkNamespace (ACPI_TYPE_METHOD, GpeDevice,
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
434 437 ACPI_UINT32_MAX, ACPI_NS_WALK_NO_UNLOCK,
435 438 AcpiEvMatchGpeMethod, NULL, &WalkInfo, NULL);
436 439
437 440 /* Return the new block */
438 441
439 442 if (ReturnGpeBlock)
440 443 {
441 444 (*ReturnGpeBlock) = GpeBlock;
442 445 }
443 446
444 - ACPI_DEBUG_PRINT ((ACPI_DB_INIT,
445 - "GPE %02X to %02X [%4.4s] %u regs on int 0x%X\n",
447 + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT,
448 + " Initialized GPE %02X to %02X [%4.4s] %u regs on interrupt 0x%X\n",
446 449 (UINT32) GpeBlock->BlockBaseNumber,
447 450 (UINT32) (GpeBlock->BlockBaseNumber + (GpeBlock->GpeCount - 1)),
448 451 GpeDevice->Name.Ascii, GpeBlock->RegisterCount,
449 452 InterruptNumber));
450 453
451 454 /* Update global count of currently available GPEs */
452 455
453 456 AcpiCurrentGpeCount += GpeBlock->GpeCount;
454 457 return_ACPI_STATUS (AE_OK);
455 458 }
456 459
457 460
458 461 /*******************************************************************************
459 462 *
460 463 * FUNCTION: AcpiEvInitializeGpeBlock
461 464 *
462 465 * PARAMETERS: ACPI_GPE_CALLBACK
463 466 *
464 467 * RETURN: Status
465 468 *
466 469 * DESCRIPTION: Initialize and enable a GPE block. Enable GPEs that have
467 470 * associated methods.
468 471 * Note: Assumes namespace is locked.
469 472 *
470 473 ******************************************************************************/
471 474
472 475 ACPI_STATUS
473 476 AcpiEvInitializeGpeBlock (
474 477 ACPI_GPE_XRUPT_INFO *GpeXruptInfo,
475 478 ACPI_GPE_BLOCK_INFO *GpeBlock,
476 479 void *Ignored)
477 480 {
478 481 ACPI_STATUS Status;
479 482 ACPI_GPE_EVENT_INFO *GpeEventInfo;
480 483 UINT32 GpeEnabledCount;
481 484 UINT32 GpeIndex;
482 485 UINT32 i;
483 486 UINT32 j;
484 487
485 488
486 489 ACPI_FUNCTION_TRACE (EvInitializeGpeBlock);
487 490
488 491
489 492 /*
490 493 * Ignore a null GPE block (e.g., if no GPE block 1 exists), and
491 494 * any GPE blocks that have been initialized already.
492 495 */
493 496 if (!GpeBlock || GpeBlock->Initialized)
494 497 {
495 498 return_ACPI_STATUS (AE_OK);
496 499 }
497 500
498 501 /*
499 502 * Enable all GPEs that have a corresponding method and have the
500 503 * ACPI_GPE_CAN_WAKE flag unset. Any other GPEs within this block
501 504 * must be enabled via the acpi_enable_gpe() interface.
502 505 */
503 506 GpeEnabledCount = 0;
504 507
505 508 for (i = 0; i < GpeBlock->RegisterCount; i++)
506 509 {
507 510 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
508 511 {
509 512 /* Get the info block for this particular GPE */
510 513
511 514 GpeIndex = (i * ACPI_GPE_REGISTER_WIDTH) + j;
512 515 GpeEventInfo = &GpeBlock->EventInfo[GpeIndex];
513 516
514 517 /*
515 518 * Ignore GPEs that have no corresponding _Lxx/_Exx method
516 519 * and GPEs that are used to wake the system
517 520 */
518 521 if (((GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK) == ACPI_GPE_DISPATCH_NONE) ||
519 522 ((GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK) == ACPI_GPE_DISPATCH_HANDLER) ||
520 523 (GpeEventInfo->Flags & ACPI_GPE_CAN_WAKE))
521 524 {
522 525 continue;
523 526 }
524 527
525 528 Status = AcpiEvAddGpeReference (GpeEventInfo);
526 529 if (ACPI_FAILURE (Status))
527 530 {
528 531 ACPI_EXCEPTION ((AE_INFO, Status,
529 532 "Could not enable GPE 0x%02X",
|
↓ open down ↓ |
74 lines elided |
↑ open up ↑ |
530 533 GpeIndex + GpeBlock->BlockBaseNumber));
531 534 continue;
532 535 }
533 536
534 537 GpeEnabledCount++;
535 538 }
536 539 }
537 540
538 541 if (GpeEnabledCount)
539 542 {
540 - ACPI_DEBUG_PRINT ((ACPI_DB_INIT,
541 - "Enabled %u GPEs in this block\n", GpeEnabledCount));
543 + ACPI_INFO ((AE_INFO,
544 + "Enabled %u GPEs in block %02X to %02X", GpeEnabledCount,
545 + (UINT32) GpeBlock->BlockBaseNumber,
546 + (UINT32) (GpeBlock->BlockBaseNumber + (GpeBlock->GpeCount - 1))));
542 547 }
543 548
544 549 GpeBlock->Initialized = TRUE;
545 550 return_ACPI_STATUS (AE_OK);
546 551 }
547 552
553 +#endif /* !ACPI_REDUCED_HARDWARE */
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX