xref: /titanic_41/usr/src/uts/intel/io/acpica/events/evgpeblk.c (revision de5d74c22760a6d2cefd94d0e7f0fd87214fb71f)
1 /******************************************************************************
2  *
3  * Module Name: evgpeblk - GPE block creation and initialization.
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2016, 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 #include "acnamesp.h"
48 
49 #define _COMPONENT          ACPI_EVENTS
50         ACPI_MODULE_NAME    ("evgpeblk")
51 
52 #if (!ACPI_REDUCED_HARDWARE) /* Entire module */
53 
54 /* Local prototypes */
55 
56 static ACPI_STATUS
57 AcpiEvInstallGpeBlock (
58     ACPI_GPE_BLOCK_INFO     *GpeBlock,
59     UINT32                  InterruptNumber);
60 
61 static ACPI_STATUS
62 AcpiEvCreateGpeInfoBlocks (
63     ACPI_GPE_BLOCK_INFO     *GpeBlock);
64 
65 
66 /*******************************************************************************
67  *
68  * FUNCTION:    AcpiEvInstallGpeBlock
69  *
70  * PARAMETERS:  GpeBlock                - New GPE block
71  *              InterruptNumber         - Xrupt to be associated with this
72  *                                        GPE block
73  *
74  * RETURN:      Status
75  *
76  * DESCRIPTION: Install new GPE block with mutex support
77  *
78  ******************************************************************************/
79 
80 static ACPI_STATUS
AcpiEvInstallGpeBlock(ACPI_GPE_BLOCK_INFO * GpeBlock,UINT32 InterruptNumber)81 AcpiEvInstallGpeBlock (
82     ACPI_GPE_BLOCK_INFO     *GpeBlock,
83     UINT32                  InterruptNumber)
84 {
85     ACPI_GPE_BLOCK_INFO     *NextGpeBlock;
86     ACPI_GPE_XRUPT_INFO     *GpeXruptBlock;
87     ACPI_STATUS             Status;
88     ACPI_CPU_FLAGS          Flags;
89 
90 
91     ACPI_FUNCTION_TRACE (EvInstallGpeBlock);
92 
93 
94     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
95     if (ACPI_FAILURE (Status))
96     {
97         return_ACPI_STATUS (Status);
98     }
99 
100     Status = AcpiEvGetGpeXruptBlock (InterruptNumber, &GpeXruptBlock);
101     if (ACPI_FAILURE (Status))
102     {
103         goto UnlockAndExit;
104     }
105 
106     /* Install the new block at the end of the list with lock */
107 
108     Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
109     if (GpeXruptBlock->GpeBlockListHead)
110     {
111         NextGpeBlock = GpeXruptBlock->GpeBlockListHead;
112         while (NextGpeBlock->Next)
113         {
114             NextGpeBlock = NextGpeBlock->Next;
115         }
116 
117         NextGpeBlock->Next = GpeBlock;
118         GpeBlock->Previous = NextGpeBlock;
119     }
120     else
121     {
122         GpeXruptBlock->GpeBlockListHead = GpeBlock;
123     }
124 
125     GpeBlock->XruptBlock = GpeXruptBlock;
126     AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
127 
128 
129 UnlockAndExit:
130     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
131     return_ACPI_STATUS (Status);
132 }
133 
134 
135 /*******************************************************************************
136  *
137  * FUNCTION:    AcpiEvDeleteGpeBlock
138  *
139  * PARAMETERS:  GpeBlock            - Existing GPE block
140  *
141  * RETURN:      Status
142  *
143  * DESCRIPTION: Remove a GPE block
144  *
145  ******************************************************************************/
146 
147 ACPI_STATUS
AcpiEvDeleteGpeBlock(ACPI_GPE_BLOCK_INFO * GpeBlock)148 AcpiEvDeleteGpeBlock (
149     ACPI_GPE_BLOCK_INFO     *GpeBlock)
150 {
151     ACPI_STATUS             Status;
152     ACPI_CPU_FLAGS          Flags;
153 
154 
155     ACPI_FUNCTION_TRACE (EvInstallGpeBlock);
156 
157 
158     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
159     if (ACPI_FAILURE (Status))
160     {
161         return_ACPI_STATUS (Status);
162     }
163 
164     /* Disable all GPEs in this block */
165 
166     Status = AcpiHwDisableGpeBlock (GpeBlock->XruptBlock, GpeBlock, NULL);
167 
168     if (!GpeBlock->Previous && !GpeBlock->Next)
169     {
170         /* This is the last GpeBlock on this interrupt */
171 
172         Status = AcpiEvDeleteGpeXrupt (GpeBlock->XruptBlock);
173         if (ACPI_FAILURE (Status))
174         {
175             goto UnlockAndExit;
176         }
177     }
178     else
179     {
180         /* Remove the block on this interrupt with lock */
181 
182         Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
183         if (GpeBlock->Previous)
184         {
185             GpeBlock->Previous->Next = GpeBlock->Next;
186         }
187         else
188         {
189             GpeBlock->XruptBlock->GpeBlockListHead = GpeBlock->Next;
190         }
191 
192         if (GpeBlock->Next)
193         {
194             GpeBlock->Next->Previous = GpeBlock->Previous;
195         }
196 
197         AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
198     }
199 
200     AcpiCurrentGpeCount -= GpeBlock->GpeCount;
201 
202     /* Free the GpeBlock */
203 
204     ACPI_FREE (GpeBlock->RegisterInfo);
205     ACPI_FREE (GpeBlock->EventInfo);
206     ACPI_FREE (GpeBlock);
207 
208 UnlockAndExit:
209     Status = AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
210     return_ACPI_STATUS (Status);
211 }
212 
213 
214 /*******************************************************************************
215  *
216  * FUNCTION:    AcpiEvCreateGpeInfoBlocks
217  *
218  * PARAMETERS:  GpeBlock    - New GPE block
219  *
220  * RETURN:      Status
221  *
222  * DESCRIPTION: Create the RegisterInfo and EventInfo blocks for this GPE block
223  *
224  ******************************************************************************/
225 
226 static ACPI_STATUS
AcpiEvCreateGpeInfoBlocks(ACPI_GPE_BLOCK_INFO * GpeBlock)227 AcpiEvCreateGpeInfoBlocks (
228     ACPI_GPE_BLOCK_INFO     *GpeBlock)
229 {
230     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo = NULL;
231     ACPI_GPE_EVENT_INFO     *GpeEventInfo = NULL;
232     ACPI_GPE_EVENT_INFO     *ThisEvent;
233     ACPI_GPE_REGISTER_INFO  *ThisRegister;
234     UINT32                  i;
235     UINT32                  j;
236     ACPI_STATUS             Status;
237 
238 
239     ACPI_FUNCTION_TRACE (EvCreateGpeInfoBlocks);
240 
241 
242     /* Allocate the GPE register information block */
243 
244     GpeRegisterInfo = ACPI_ALLOCATE_ZEROED (
245         (ACPI_SIZE) GpeBlock->RegisterCount *
246         sizeof (ACPI_GPE_REGISTER_INFO));
247     if (!GpeRegisterInfo)
248     {
249         ACPI_ERROR ((AE_INFO,
250             "Could not allocate the GpeRegisterInfo table"));
251         return_ACPI_STATUS (AE_NO_MEMORY);
252     }
253 
254     /*
255      * Allocate the GPE EventInfo block. There are eight distinct GPEs
256      * per register. Initialization to zeros is sufficient.
257      */
258     GpeEventInfo = ACPI_ALLOCATE_ZEROED ((ACPI_SIZE) GpeBlock->GpeCount *
259         sizeof (ACPI_GPE_EVENT_INFO));
260     if (!GpeEventInfo)
261     {
262         ACPI_ERROR ((AE_INFO,
263             "Could not allocate the GpeEventInfo table"));
264         Status = AE_NO_MEMORY;
265         goto ErrorExit;
266     }
267 
268     /* Save the new Info arrays in the GPE block */
269 
270     GpeBlock->RegisterInfo = GpeRegisterInfo;
271     GpeBlock->EventInfo = GpeEventInfo;
272 
273     /*
274      * Initialize the GPE Register and Event structures. A goal of these
275      * tables is to hide the fact that there are two separate GPE register
276      * sets in a given GPE hardware block, the status registers occupy the
277      * first half, and the enable registers occupy the second half.
278      */
279     ThisRegister = GpeRegisterInfo;
280     ThisEvent = GpeEventInfo;
281 
282     for (i = 0; i < GpeBlock->RegisterCount; i++)
283     {
284         /* Init the RegisterInfo for this GPE register (8 GPEs) */
285 
286         ThisRegister->BaseGpeNumber = (UINT16)
287             (GpeBlock->BlockBaseNumber + (i * ACPI_GPE_REGISTER_WIDTH));
288 
289         ThisRegister->StatusAddress.Address =
290             GpeBlock->Address + i;
291 
292         ThisRegister->EnableAddress.Address =
293             GpeBlock->Address + i + GpeBlock->RegisterCount;
294 
295         ThisRegister->StatusAddress.SpaceId   = GpeBlock->SpaceId;
296         ThisRegister->EnableAddress.SpaceId   = GpeBlock->SpaceId;
297         ThisRegister->StatusAddress.BitWidth  = ACPI_GPE_REGISTER_WIDTH;
298         ThisRegister->EnableAddress.BitWidth  = ACPI_GPE_REGISTER_WIDTH;
299         ThisRegister->StatusAddress.BitOffset = 0;
300         ThisRegister->EnableAddress.BitOffset = 0;
301 
302         /* Init the EventInfo for each GPE within this register */
303 
304         for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
305         {
306             ThisEvent->GpeNumber = (UINT8) (ThisRegister->BaseGpeNumber + j);
307             ThisEvent->RegisterInfo = ThisRegister;
308             ThisEvent++;
309         }
310 
311         /* Disable all GPEs within this register */
312 
313         Status = AcpiHwWrite (0x00, &ThisRegister->EnableAddress);
314         if (ACPI_FAILURE (Status))
315         {
316             goto ErrorExit;
317         }
318 
319         /* Clear any pending GPE events within this register */
320 
321         Status = AcpiHwWrite (0xFF, &ThisRegister->StatusAddress);
322         if (ACPI_FAILURE (Status))
323         {
324             goto ErrorExit;
325         }
326 
327         ThisRegister++;
328     }
329 
330     return_ACPI_STATUS (AE_OK);
331 
332 
333 ErrorExit:
334     if (GpeRegisterInfo)
335     {
336         ACPI_FREE (GpeRegisterInfo);
337     }
338     if (GpeEventInfo)
339     {
340         ACPI_FREE (GpeEventInfo);
341     }
342 
343     return_ACPI_STATUS (Status);
344 }
345 
346 
347 /*******************************************************************************
348  *
349  * FUNCTION:    AcpiEvCreateGpeBlock
350  *
351  * PARAMETERS:  GpeDevice           - Handle to the parent GPE block
352  *              GpeBlockAddress     - Address and SpaceID
353  *              RegisterCount       - Number of GPE register pairs in the block
354  *              GpeBlockBaseNumber  - Starting GPE number for the block
355  *              InterruptNumber     - H/W interrupt for the block
356  *              ReturnGpeBlock      - Where the new block descriptor is returned
357  *
358  * RETURN:      Status
359  *
360  * DESCRIPTION: Create and Install a block of GPE registers. All GPEs within
361  *              the block are disabled at exit.
362  *              Note: Assumes namespace is locked.
363  *
364  ******************************************************************************/
365 
366 ACPI_STATUS
AcpiEvCreateGpeBlock(ACPI_NAMESPACE_NODE * GpeDevice,UINT64 Address,UINT8 SpaceId,UINT32 RegisterCount,UINT16 GpeBlockBaseNumber,UINT32 InterruptNumber,ACPI_GPE_BLOCK_INFO ** ReturnGpeBlock)367 AcpiEvCreateGpeBlock (
368     ACPI_NAMESPACE_NODE     *GpeDevice,
369     UINT64                  Address,
370     UINT8                   SpaceId,
371     UINT32                  RegisterCount,
372     UINT16                  GpeBlockBaseNumber,
373     UINT32                  InterruptNumber,
374     ACPI_GPE_BLOCK_INFO     **ReturnGpeBlock)
375 {
376     ACPI_STATUS             Status;
377     ACPI_GPE_BLOCK_INFO     *GpeBlock;
378     ACPI_GPE_WALK_INFO      WalkInfo;
379 
380 
381     ACPI_FUNCTION_TRACE (EvCreateGpeBlock);
382 
383 
384     if (!RegisterCount)
385     {
386         return_ACPI_STATUS (AE_OK);
387     }
388 
389     /* Allocate a new GPE block */
390 
391     GpeBlock = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_GPE_BLOCK_INFO));
392     if (!GpeBlock)
393     {
394         return_ACPI_STATUS (AE_NO_MEMORY);
395     }
396 
397     /* Initialize the new GPE block */
398 
399     GpeBlock->Address = Address;
400     GpeBlock->SpaceId = SpaceId;
401     GpeBlock->Node = GpeDevice;
402     GpeBlock->GpeCount = (UINT16) (RegisterCount * ACPI_GPE_REGISTER_WIDTH);
403     GpeBlock->Initialized = FALSE;
404     GpeBlock->RegisterCount = RegisterCount;
405     GpeBlock->BlockBaseNumber = GpeBlockBaseNumber;
406 
407     /*
408      * Create the RegisterInfo and EventInfo sub-structures
409      * Note: disables and clears all GPEs in the block
410      */
411     Status = AcpiEvCreateGpeInfoBlocks (GpeBlock);
412     if (ACPI_FAILURE (Status))
413     {
414         ACPI_FREE (GpeBlock);
415         return_ACPI_STATUS (Status);
416     }
417 
418     /* Install the new block in the global lists */
419 
420     Status = AcpiEvInstallGpeBlock (GpeBlock, InterruptNumber);
421     if (ACPI_FAILURE (Status))
422     {
423         ACPI_FREE (GpeBlock->RegisterInfo);
424         ACPI_FREE (GpeBlock->EventInfo);
425         ACPI_FREE (GpeBlock);
426         return_ACPI_STATUS (Status);
427     }
428 
429     AcpiGbl_AllGpesInitialized = FALSE;
430 
431     /* Find all GPE methods (_Lxx or_Exx) for this block */
432 
433     WalkInfo.GpeBlock = GpeBlock;
434     WalkInfo.GpeDevice = GpeDevice;
435     WalkInfo.ExecuteByOwnerId = FALSE;
436 
437     Status = AcpiNsWalkNamespace (ACPI_TYPE_METHOD, GpeDevice,
438         ACPI_UINT32_MAX, ACPI_NS_WALK_NO_UNLOCK,
439         AcpiEvMatchGpeMethod, NULL, &WalkInfo, NULL);
440 
441     /* Return the new block */
442 
443     if (ReturnGpeBlock)
444     {
445         (*ReturnGpeBlock) = GpeBlock;
446     }
447 
448     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT,
449         "    Initialized GPE %02X to %02X [%4.4s] %u regs on interrupt 0x%X%s\n",
450         (UINT32) GpeBlock->BlockBaseNumber,
451         (UINT32) (GpeBlock->BlockBaseNumber + (GpeBlock->GpeCount - 1)),
452         GpeDevice->Name.Ascii, GpeBlock->RegisterCount, InterruptNumber,
453         InterruptNumber == AcpiGbl_FADT.SciInterrupt ? " (SCI)" : ""));
454 
455     /* Update global count of currently available GPEs */
456 
457     AcpiCurrentGpeCount += GpeBlock->GpeCount;
458     return_ACPI_STATUS (AE_OK);
459 }
460 
461 
462 /*******************************************************************************
463  *
464  * FUNCTION:    AcpiEvInitializeGpeBlock
465  *
466  * PARAMETERS:  ACPI_GPE_CALLBACK
467  *
468  * RETURN:      Status
469  *
470  * DESCRIPTION: Initialize and enable a GPE block. Enable GPEs that have
471  *              associated methods.
472  *              Note: Assumes namespace is locked.
473  *
474  ******************************************************************************/
475 
476 ACPI_STATUS
AcpiEvInitializeGpeBlock(ACPI_GPE_XRUPT_INFO * GpeXruptInfo,ACPI_GPE_BLOCK_INFO * GpeBlock,void * Ignored)477 AcpiEvInitializeGpeBlock (
478     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
479     ACPI_GPE_BLOCK_INFO     *GpeBlock,
480     void                    *Ignored)
481 {
482     ACPI_STATUS             Status;
483     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
484     UINT32                  GpeEnabledCount;
485     UINT32                  GpeIndex;
486     UINT32                  i;
487     UINT32                  j;
488 
489 
490     ACPI_FUNCTION_TRACE (EvInitializeGpeBlock);
491 
492 
493     /*
494      * Ignore a null GPE block (e.g., if no GPE block 1 exists), and
495      * any GPE blocks that have been initialized already.
496      */
497     if (!GpeBlock || GpeBlock->Initialized)
498     {
499         return_ACPI_STATUS (AE_OK);
500     }
501 
502     /*
503      * Enable all GPEs that have a corresponding method and have the
504      * ACPI_GPE_CAN_WAKE flag unset. Any other GPEs within this block
505      * must be enabled via the acpi_enable_gpe() interface.
506      */
507     GpeEnabledCount = 0;
508 
509     for (i = 0; i < GpeBlock->RegisterCount; i++)
510     {
511         for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
512         {
513             /* Get the info block for this particular GPE */
514 
515             GpeIndex = (i * ACPI_GPE_REGISTER_WIDTH) + j;
516             GpeEventInfo = &GpeBlock->EventInfo[GpeIndex];
517 
518             /*
519              * Ignore GPEs that have no corresponding _Lxx/_Exx method
520              * and GPEs that are used to wake the system
521              */
522             if ((ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags) == ACPI_GPE_DISPATCH_NONE) ||
523                 (ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags) == ACPI_GPE_DISPATCH_HANDLER) ||
524                 (ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags) == ACPI_GPE_DISPATCH_RAW_HANDLER) ||
525                 (GpeEventInfo->Flags & ACPI_GPE_CAN_WAKE))
526             {
527                 continue;
528             }
529 
530             Status = AcpiEvAddGpeReference (GpeEventInfo);
531             if (ACPI_FAILURE (Status))
532             {
533                 ACPI_EXCEPTION ((AE_INFO, Status,
534                     "Could not enable GPE 0x%02X",
535                     GpeIndex + GpeBlock->BlockBaseNumber));
536                 continue;
537             }
538 
539             GpeEnabledCount++;
540         }
541     }
542 
543     if (GpeEnabledCount)
544     {
545         ACPI_INFO ((
546             "Enabled %u GPEs in block %02X to %02X", GpeEnabledCount,
547             (UINT32) GpeBlock->BlockBaseNumber,
548             (UINT32) (GpeBlock->BlockBaseNumber + (GpeBlock->GpeCount - 1))));
549     }
550 
551     GpeBlock->Initialized = TRUE;
552     return_ACPI_STATUS (AE_OK);
553 }
554 
555 #endif /* !ACPI_REDUCED_HARDWARE */
556