[ACPICA] Update to version 20171215. CORE-15222
[reactos.git] / drivers / bus / acpi / acpica / hardware / hwgpe.c
1 /******************************************************************************
2 *
3 * Module Name: hwgpe - Low level GPE enable/disable/clear functions
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2017, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44 #include "acpi.h"
45 #include "accommon.h"
46 #include "acevents.h"
47
48 #define _COMPONENT ACPI_HARDWARE
49 ACPI_MODULE_NAME ("hwgpe")
50
51 #if (!ACPI_REDUCED_HARDWARE) /* Entire module */
52
53 /* Local prototypes */
54
55 static ACPI_STATUS
56 AcpiHwEnableWakeupGpeBlock (
57 ACPI_GPE_XRUPT_INFO *GpeXruptInfo,
58 ACPI_GPE_BLOCK_INFO *GpeBlock,
59 void *Context);
60
61 static ACPI_STATUS
62 AcpiHwGpeEnableWrite (
63 UINT8 EnableMask,
64 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo);
65
66
67 /******************************************************************************
68 *
69 * FUNCTION: AcpiHwGetGpeRegisterBit
70 *
71 * PARAMETERS: GpeEventInfo - Info block for the GPE
72 *
73 * RETURN: Register mask with a one in the GPE bit position
74 *
75 * DESCRIPTION: Compute the register mask for this GPE. One bit is set in the
76 * correct position for the input GPE.
77 *
78 ******************************************************************************/
79
80 UINT32
81 AcpiHwGetGpeRegisterBit (
82 ACPI_GPE_EVENT_INFO *GpeEventInfo)
83 {
84
85 return ((UINT32) 1 <<
86 (GpeEventInfo->GpeNumber - GpeEventInfo->RegisterInfo->BaseGpeNumber));
87 }
88
89
90 /******************************************************************************
91 *
92 * FUNCTION: AcpiHwLowSetGpe
93 *
94 * PARAMETERS: GpeEventInfo - Info block for the GPE to be disabled
95 * Action - Enable or disable
96 *
97 * RETURN: Status
98 *
99 * DESCRIPTION: Enable or disable a single GPE in the parent enable register.
100 * The EnableMask field of the involved GPE register must be
101 * updated by the caller if necessary.
102 *
103 ******************************************************************************/
104
105 ACPI_STATUS
106 AcpiHwLowSetGpe (
107 ACPI_GPE_EVENT_INFO *GpeEventInfo,
108 UINT32 Action)
109 {
110 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
111 ACPI_STATUS Status = AE_OK;
112 UINT64 EnableMask;
113 UINT32 RegisterBit;
114
115
116 ACPI_FUNCTION_ENTRY ();
117
118
119 /* Get the info block for the entire GPE register */
120
121 GpeRegisterInfo = GpeEventInfo->RegisterInfo;
122 if (!GpeRegisterInfo)
123 {
124 return (AE_NOT_EXIST);
125 }
126
127 /* Get current value of the enable register that contains this GPE */
128
129 Status = AcpiHwRead (&EnableMask, &GpeRegisterInfo->EnableAddress);
130 if (ACPI_FAILURE (Status))
131 {
132 return (Status);
133 }
134
135 /* Set or clear just the bit that corresponds to this GPE */
136
137 RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
138 switch (Action)
139 {
140 case ACPI_GPE_CONDITIONAL_ENABLE:
141
142 /* Only enable if the corresponding EnableMask bit is set */
143
144 if (!(RegisterBit & GpeRegisterInfo->EnableMask))
145 {
146 return (AE_BAD_PARAMETER);
147 }
148
149 /*lint -fallthrough */
150
151 case ACPI_GPE_ENABLE:
152
153 ACPI_SET_BIT (EnableMask, RegisterBit);
154 break;
155
156 case ACPI_GPE_DISABLE:
157
158 ACPI_CLEAR_BIT (EnableMask, RegisterBit);
159 break;
160
161 default:
162
163 ACPI_ERROR ((AE_INFO, "Invalid GPE Action, %u", Action));
164 return (AE_BAD_PARAMETER);
165 }
166
167 if (!(RegisterBit & GpeRegisterInfo->MaskForRun))
168 {
169 /* Write the updated enable mask */
170
171 Status = AcpiHwWrite (EnableMask, &GpeRegisterInfo->EnableAddress);
172 }
173 return (Status);
174 }
175
176
177 /******************************************************************************
178 *
179 * FUNCTION: AcpiHwClearGpe
180 *
181 * PARAMETERS: GpeEventInfo - Info block for the GPE to be cleared
182 *
183 * RETURN: Status
184 *
185 * DESCRIPTION: Clear the status bit for a single GPE.
186 *
187 ******************************************************************************/
188
189 ACPI_STATUS
190 AcpiHwClearGpe (
191 ACPI_GPE_EVENT_INFO *GpeEventInfo)
192 {
193 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
194 ACPI_STATUS Status;
195 UINT32 RegisterBit;
196
197
198 ACPI_FUNCTION_ENTRY ();
199
200 /* Get the info block for the entire GPE register */
201
202 GpeRegisterInfo = GpeEventInfo->RegisterInfo;
203 if (!GpeRegisterInfo)
204 {
205 return (AE_NOT_EXIST);
206 }
207
208 /*
209 * Write a one to the appropriate bit in the status register to
210 * clear this GPE.
211 */
212 RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
213
214 Status = AcpiHwWrite (RegisterBit, &GpeRegisterInfo->StatusAddress);
215 return (Status);
216 }
217
218
219 /******************************************************************************
220 *
221 * FUNCTION: AcpiHwGetGpeStatus
222 *
223 * PARAMETERS: GpeEventInfo - Info block for the GPE to queried
224 * EventStatus - Where the GPE status is returned
225 *
226 * RETURN: Status
227 *
228 * DESCRIPTION: Return the status of a single GPE.
229 *
230 ******************************************************************************/
231
232 ACPI_STATUS
233 AcpiHwGetGpeStatus (
234 ACPI_GPE_EVENT_INFO *GpeEventInfo,
235 ACPI_EVENT_STATUS *EventStatus)
236 {
237 UINT64 InByte;
238 UINT32 RegisterBit;
239 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
240 ACPI_EVENT_STATUS LocalEventStatus = 0;
241 ACPI_STATUS Status;
242
243
244 ACPI_FUNCTION_ENTRY ();
245
246
247 if (!EventStatus)
248 {
249 return (AE_BAD_PARAMETER);
250 }
251
252 /* GPE currently handled? */
253
254 if (ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags) !=
255 ACPI_GPE_DISPATCH_NONE)
256 {
257 LocalEventStatus |= ACPI_EVENT_FLAG_HAS_HANDLER;
258 }
259
260 /* Get the info block for the entire GPE register */
261
262 GpeRegisterInfo = GpeEventInfo->RegisterInfo;
263
264 /* Get the register bitmask for this GPE */
265
266 RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
267
268 /* GPE currently enabled? (enabled for runtime?) */
269
270 if (RegisterBit & GpeRegisterInfo->EnableForRun)
271 {
272 LocalEventStatus |= ACPI_EVENT_FLAG_ENABLED;
273 }
274
275 /* GPE currently masked? (masked for runtime?) */
276
277 if (RegisterBit & GpeRegisterInfo->MaskForRun)
278 {
279 LocalEventStatus |= ACPI_EVENT_FLAG_MASKED;
280 }
281
282 /* GPE enabled for wake? */
283
284 if (RegisterBit & GpeRegisterInfo->EnableForWake)
285 {
286 LocalEventStatus |= ACPI_EVENT_FLAG_WAKE_ENABLED;
287 }
288
289 /* GPE currently enabled (enable bit == 1)? */
290
291 Status = AcpiHwRead (&InByte, &GpeRegisterInfo->EnableAddress);
292 if (ACPI_FAILURE (Status))
293 {
294 return (Status);
295 }
296
297 if (RegisterBit & InByte)
298 {
299 LocalEventStatus |= ACPI_EVENT_FLAG_ENABLE_SET;
300 }
301
302 /* GPE currently active (status bit == 1)? */
303
304 Status = AcpiHwRead (&InByte, &GpeRegisterInfo->StatusAddress);
305 if (ACPI_FAILURE (Status))
306 {
307 return (Status);
308 }
309
310 if (RegisterBit & InByte)
311 {
312 LocalEventStatus |= ACPI_EVENT_FLAG_STATUS_SET;
313 }
314
315 /* Set return value */
316
317 (*EventStatus) = LocalEventStatus;
318 return (AE_OK);
319 }
320
321
322 /******************************************************************************
323 *
324 * FUNCTION: AcpiHwGpeEnableWrite
325 *
326 * PARAMETERS: EnableMask - Bit mask to write to the GPE register
327 * GpeRegisterInfo - Gpe Register info
328 *
329 * RETURN: Status
330 *
331 * DESCRIPTION: Write the enable mask byte to the given GPE register.
332 *
333 ******************************************************************************/
334
335 static ACPI_STATUS
336 AcpiHwGpeEnableWrite (
337 UINT8 EnableMask,
338 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo)
339 {
340 ACPI_STATUS Status;
341
342
343 GpeRegisterInfo->EnableMask = EnableMask;
344
345 Status = AcpiHwWrite (EnableMask, &GpeRegisterInfo->EnableAddress);
346 return (Status);
347 }
348
349
350 /******************************************************************************
351 *
352 * FUNCTION: AcpiHwDisableGpeBlock
353 *
354 * PARAMETERS: GpeXruptInfo - GPE Interrupt info
355 * GpeBlock - Gpe Block info
356 *
357 * RETURN: Status
358 *
359 * DESCRIPTION: Disable all GPEs within a single GPE block
360 *
361 ******************************************************************************/
362
363 ACPI_STATUS
364 AcpiHwDisableGpeBlock (
365 ACPI_GPE_XRUPT_INFO *GpeXruptInfo,
366 ACPI_GPE_BLOCK_INFO *GpeBlock,
367 void *Context)
368 {
369 UINT32 i;
370 ACPI_STATUS Status;
371
372
373 /* Examine each GPE Register within the block */
374
375 for (i = 0; i < GpeBlock->RegisterCount; i++)
376 {
377 /* Disable all GPEs in this register */
378
379 Status = AcpiHwGpeEnableWrite (0x00, &GpeBlock->RegisterInfo[i]);
380 if (ACPI_FAILURE (Status))
381 {
382 return (Status);
383 }
384 }
385
386 return (AE_OK);
387 }
388
389
390 /******************************************************************************
391 *
392 * FUNCTION: AcpiHwClearGpeBlock
393 *
394 * PARAMETERS: GpeXruptInfo - GPE Interrupt info
395 * GpeBlock - Gpe Block info
396 *
397 * RETURN: Status
398 *
399 * DESCRIPTION: Clear status bits for all GPEs within a single GPE block
400 *
401 ******************************************************************************/
402
403 ACPI_STATUS
404 AcpiHwClearGpeBlock (
405 ACPI_GPE_XRUPT_INFO *GpeXruptInfo,
406 ACPI_GPE_BLOCK_INFO *GpeBlock,
407 void *Context)
408 {
409 UINT32 i;
410 ACPI_STATUS Status;
411
412
413 /* Examine each GPE Register within the block */
414
415 for (i = 0; i < GpeBlock->RegisterCount; i++)
416 {
417 /* Clear status on all GPEs in this register */
418
419 Status = AcpiHwWrite (0xFF, &GpeBlock->RegisterInfo[i].StatusAddress);
420 if (ACPI_FAILURE (Status))
421 {
422 return (Status);
423 }
424 }
425
426 return (AE_OK);
427 }
428
429
430 /******************************************************************************
431 *
432 * FUNCTION: AcpiHwEnableRuntimeGpeBlock
433 *
434 * PARAMETERS: GpeXruptInfo - GPE Interrupt info
435 * GpeBlock - Gpe Block info
436 *
437 * RETURN: Status
438 *
439 * DESCRIPTION: Enable all "runtime" GPEs within a single GPE block. Includes
440 * combination wake/run GPEs.
441 *
442 ******************************************************************************/
443
444 ACPI_STATUS
445 AcpiHwEnableRuntimeGpeBlock (
446 ACPI_GPE_XRUPT_INFO *GpeXruptInfo,
447 ACPI_GPE_BLOCK_INFO *GpeBlock,
448 void *Context)
449 {
450 UINT32 i;
451 ACPI_STATUS Status;
452 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
453 UINT8 EnableMask;
454
455
456 /* NOTE: assumes that all GPEs are currently disabled */
457
458 /* Examine each GPE Register within the block */
459
460 for (i = 0; i < GpeBlock->RegisterCount; i++)
461 {
462 GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
463 if (!GpeRegisterInfo->EnableForRun)
464 {
465 continue;
466 }
467
468 /* Enable all "runtime" GPEs in this register */
469
470 EnableMask = GpeRegisterInfo->EnableForRun &
471 ~GpeRegisterInfo->MaskForRun;
472 Status = AcpiHwGpeEnableWrite (EnableMask, GpeRegisterInfo);
473 if (ACPI_FAILURE (Status))
474 {
475 return (Status);
476 }
477 }
478
479 return (AE_OK);
480 }
481
482
483 /******************************************************************************
484 *
485 * FUNCTION: AcpiHwEnableWakeupGpeBlock
486 *
487 * PARAMETERS: GpeXruptInfo - GPE Interrupt info
488 * GpeBlock - Gpe Block info
489 *
490 * RETURN: Status
491 *
492 * DESCRIPTION: Enable all "wake" GPEs within a single GPE block. Includes
493 * combination wake/run GPEs.
494 *
495 ******************************************************************************/
496
497 static ACPI_STATUS
498 AcpiHwEnableWakeupGpeBlock (
499 ACPI_GPE_XRUPT_INFO *GpeXruptInfo,
500 ACPI_GPE_BLOCK_INFO *GpeBlock,
501 void *Context)
502 {
503 UINT32 i;
504 ACPI_STATUS Status;
505 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
506
507
508 /* Examine each GPE Register within the block */
509
510 for (i = 0; i < GpeBlock->RegisterCount; i++)
511 {
512 GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
513
514 /*
515 * Enable all "wake" GPEs in this register and disable the
516 * remaining ones.
517 */
518 Status = AcpiHwGpeEnableWrite (GpeRegisterInfo->EnableForWake,
519 GpeRegisterInfo);
520 if (ACPI_FAILURE (Status))
521 {
522 return (Status);
523 }
524 }
525
526 return (AE_OK);
527 }
528
529
530 /******************************************************************************
531 *
532 * FUNCTION: AcpiHwDisableAllGpes
533 *
534 * PARAMETERS: None
535 *
536 * RETURN: Status
537 *
538 * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
539 *
540 ******************************************************************************/
541
542 ACPI_STATUS
543 AcpiHwDisableAllGpes (
544 void)
545 {
546 ACPI_STATUS Status;
547
548
549 ACPI_FUNCTION_TRACE (HwDisableAllGpes);
550
551
552 Status = AcpiEvWalkGpeList (AcpiHwDisableGpeBlock, NULL);
553 Status = AcpiEvWalkGpeList (AcpiHwClearGpeBlock, NULL);
554 return_ACPI_STATUS (Status);
555 }
556
557
558 /******************************************************************************
559 *
560 * FUNCTION: AcpiHwEnableAllRuntimeGpes
561 *
562 * PARAMETERS: None
563 *
564 * RETURN: Status
565 *
566 * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
567 *
568 ******************************************************************************/
569
570 ACPI_STATUS
571 AcpiHwEnableAllRuntimeGpes (
572 void)
573 {
574 ACPI_STATUS Status;
575
576
577 ACPI_FUNCTION_TRACE (HwEnableAllRuntimeGpes);
578
579
580 Status = AcpiEvWalkGpeList (AcpiHwEnableRuntimeGpeBlock, NULL);
581 return_ACPI_STATUS (Status);
582 }
583
584
585 /******************************************************************************
586 *
587 * FUNCTION: AcpiHwEnableAllWakeupGpes
588 *
589 * PARAMETERS: None
590 *
591 * RETURN: Status
592 *
593 * DESCRIPTION: Enable all "wakeup" GPEs, in all GPE blocks
594 *
595 ******************************************************************************/
596
597 ACPI_STATUS
598 AcpiHwEnableAllWakeupGpes (
599 void)
600 {
601 ACPI_STATUS Status;
602
603
604 ACPI_FUNCTION_TRACE (HwEnableAllWakeupGpes);
605
606
607 Status = AcpiEvWalkGpeList (AcpiHwEnableWakeupGpeBlock, NULL);
608 return_ACPI_STATUS (Status);
609 }
610
611 #endif /* !ACPI_REDUCED_HARDWARE */