1 /******************************************************************************
2 *
3 * Module Name: aehandlers - Various handlers for acpiexec
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2013, 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 "aecommon.h"
45
46 #define _COMPONENT ACPI_TOOLS
47 ACPI_MODULE_NAME ("aehandlers")
48
49 /* Local prototypes */
50
51 static void
52 AeNotifyHandler1 (
53 ACPI_HANDLE Device,
54 UINT32 Value,
55 void *Context);
56
57 static void
58 AeNotifyHandler2 (
59 ACPI_HANDLE Device,
60 UINT32 Value,
61 void *Context);
62
63 static void
64 AeCommonNotifyHandler (
65 ACPI_HANDLE Device,
66 UINT32 Value,
67 UINT32 HandlerId);
68
69 static void
70 AeDeviceNotifyHandler (
71 ACPI_HANDLE Device,
72 UINT32 Value,
73 void *Context);
74
75 static ACPI_STATUS
76 AeExceptionHandler (
77 ACPI_STATUS AmlStatus,
78 ACPI_NAME Name,
79 UINT16 Opcode,
80 UINT32 AmlOffset,
81 void *Context);
82
83 static ACPI_STATUS
84 AeTableHandler (
85 UINT32 Event,
86 void *Table,
87 void *Context);
88
89 static ACPI_STATUS
90 AeRegionInit (
91 ACPI_HANDLE RegionHandle,
92 UINT32 Function,
93 void *HandlerContext,
94 void **RegionContext);
95
96 static void
97 AeAttachedDataHandler (
98 ACPI_HANDLE Object,
99 void *Data);
100
101 static void
102 AeAttachedDataHandler2 (
103 ACPI_HANDLE Object,
104 void *Data);
105
106 static UINT32
107 AeInterfaceHandler (
108 ACPI_STRING InterfaceName,
109 UINT32 Supported);
110
111 static ACPI_STATUS
112 AeInstallEcHandler (
113 ACPI_HANDLE ObjHandle,
114 UINT32 Level,
115 void *Context,
116 void **ReturnValue);
117
118 static ACPI_STATUS
119 AeInstallPciHandler (
120 ACPI_HANDLE ObjHandle,
121 UINT32 Level,
122 void *Context,
123 void **ReturnValue);
124
125 static ACPI_STATUS
126 AeInstallDeviceHandlers (
127 void);
128
129 #if (!ACPI_REDUCED_HARDWARE)
130 static UINT32
131 AeEventHandler (
132 void *Context);
133
134 static UINT32
135 AeSciHandler (
136 void *Context);
137
138 static char *TableEvents[] =
139 {
140 "LOAD",
141 "UNLOAD",
142 "UNKNOWN"
143 };
144 #endif /* !ACPI_REDUCED_HARDWARE */
145
146
147 static UINT32 SigintCount = 0;
148 static AE_DEBUG_REGIONS AeRegions;
149 BOOLEAN AcpiGbl_DisplayRegionAccess = FALSE;
150
151 /*
152 * We will override some of the default region handlers, especially the
153 * SystemMemory handler, which must be implemented locally. Do not override
154 * the PCI_Config handler since we would like to exercise the default handler
155 * code. These handlers are installed "early" - before any _REG methods
156 * are executed - since they are special in the sense that the ACPI spec
157 * declares that they must "always be available". Cannot override the
158 * DataTable region handler either -- needed for test execution.
159 */
160 static ACPI_ADR_SPACE_TYPE DefaultSpaceIdList[] =
161 {
162 ACPI_ADR_SPACE_SYSTEM_MEMORY,
163 ACPI_ADR_SPACE_SYSTEM_IO
164 };
165
166 /*
167 * We will install handlers for some of the various address space IDs.
168 * Test one user-defined address space (used by aslts).
169 */
170 #define ACPI_ADR_SPACE_USER_DEFINED1 0x80
171 #define ACPI_ADR_SPACE_USER_DEFINED2 0xE4
172
173 static ACPI_ADR_SPACE_TYPE SpaceIdList[] =
174 {
175 ACPI_ADR_SPACE_SMBUS,
176 ACPI_ADR_SPACE_CMOS,
177 ACPI_ADR_SPACE_PCI_BAR_TARGET,
178 ACPI_ADR_SPACE_IPMI,
179 ACPI_ADR_SPACE_GPIO,
180 ACPI_ADR_SPACE_GSBUS,
181 ACPI_ADR_SPACE_FIXED_HARDWARE,
182 ACPI_ADR_SPACE_USER_DEFINED1,
183 ACPI_ADR_SPACE_USER_DEFINED2
184 };
185
186 static ACPI_CONNECTION_INFO AeMyContext;
187
188
189 /******************************************************************************
190 *
191 * FUNCTION: AeCtrlCHandler
192 *
193 * PARAMETERS: Sig
194 *
195 * RETURN: none
196 *
197 * DESCRIPTION: Control-C handler. Abort running control method if any.
198 *
199 *****************************************************************************/
200
201 void ACPI_SYSTEM_XFACE
202 AeCtrlCHandler (
203 int Sig)
204 {
205
206 signal (SIGINT, SIG_IGN);
207 SigintCount++;
208
209 AcpiOsPrintf ("Caught a ctrl-c (#%u)\n\n", SigintCount);
210
211 if (AcpiGbl_MethodExecuting)
212 {
213 AcpiGbl_AbortMethod = TRUE;
214 signal (SIGINT, AeCtrlCHandler);
215
216 if (SigintCount < 10)
217 {
218 return;
219 }
220 }
221
222 (void) AcpiOsTerminate ();
223 exit (0);
224 }
225
226
227 /******************************************************************************
228 *
229 * FUNCTION: AeNotifyHandler(s)
230 *
231 * PARAMETERS: Standard notify handler parameters
232 *
233 * RETURN: Status
234 *
235 * DESCRIPTION: Notify handlers for AcpiExec utility. Used by the ASL
236 * test suite(s) to communicate errors and other information to
237 * this utility via the Notify() operator. Tests notify handling
238 * and multiple notify handler support.
239 *
240 *****************************************************************************/
241
242 static void
243 AeNotifyHandler1 (
244 ACPI_HANDLE Device,
245 UINT32 Value,
246 void *Context)
247 {
248 AeCommonNotifyHandler (Device, Value, 1);
249 }
250
251 static void
252 AeNotifyHandler2 (
253 ACPI_HANDLE Device,
254 UINT32 Value,
255 void *Context)
256 {
257 AeCommonNotifyHandler (Device, Value, 2);
258 }
259
260 static void
261 AeCommonNotifyHandler (
262 ACPI_HANDLE Device,
263 UINT32 Value,
264 UINT32 HandlerId)
265 {
266 char *Type;
267
268
269 Type = "Device";
270 if (Value <= ACPI_MAX_SYS_NOTIFY)
271 {
272 Type = "System";
273 }
274
275 switch (Value)
276 {
277 #if 0
278 case 0:
279
280 printf ("[AcpiExec] Method Error 0x%X: Results not equal\n", Value);
281 if (AcpiGbl_DebugFile)
282 {
283 AcpiOsPrintf ("[AcpiExec] Method Error: Results not equal\n");
284 }
285 break;
286
287 case 1:
288
289 printf ("[AcpiExec] Method Error: Incorrect numeric result\n");
290 if (AcpiGbl_DebugFile)
291 {
292 AcpiOsPrintf ("[AcpiExec] Method Error: Incorrect numeric result\n");
293 }
294 break;
295
296 case 2:
297
298 printf ("[AcpiExec] Method Error: An operand was overwritten\n");
299 if (AcpiGbl_DebugFile)
300 {
301 AcpiOsPrintf ("[AcpiExec] Method Error: An operand was overwritten\n");
302 }
303 break;
304
305 #endif
306
307 default:
308
309 printf ("[AcpiExec] Handler %u: Received a %s Notify on [%4.4s] %p Value 0x%2.2X (%s)\n",
310 HandlerId, Type, AcpiUtGetNodeName (Device), Device, Value,
311 AcpiUtGetNotifyName (Value));
312 if (AcpiGbl_DebugFile)
313 {
314 AcpiOsPrintf ("[AcpiExec] Handler %u: Received a %s notify, Value 0x%2.2X\n",
315 HandlerId, Type, Value);
316 }
317
318 (void) AcpiEvaluateObject (Device, "_NOT", NULL, NULL);
319 break;
320 }
321 }
322
323
324 /******************************************************************************
325 *
326 * FUNCTION: AeSystemNotifyHandler
327 *
328 * PARAMETERS: Standard notify handler parameters
329 *
330 * RETURN: Status
331 *
332 * DESCRIPTION: System notify handler for AcpiExec utility. Used by the ASL
333 * test suite(s) to communicate errors and other information to
334 * this utility via the Notify() operator.
335 *
336 *****************************************************************************/
337
338 static void
339 AeSystemNotifyHandler (
340 ACPI_HANDLE Device,
341 UINT32 Value,
342 void *Context)
343 {
344
345 printf ("[AcpiExec] Global: Received a System Notify on [%4.4s] %p Value 0x%2.2X (%s)\n",
346 AcpiUtGetNodeName (Device), Device, Value,
347 AcpiUtGetNotifyName (Value));
348 if (AcpiGbl_DebugFile)
349 {
350 AcpiOsPrintf ("[AcpiExec] Global: Received a System Notify, Value 0x%2.2X\n", Value);
351 }
352
353 (void) AcpiEvaluateObject (Device, "_NOT", NULL, NULL);
354 }
355
356
357 /******************************************************************************
358 *
359 * FUNCTION: AeDeviceNotifyHandler
360 *
361 * PARAMETERS: Standard notify handler parameters
362 *
363 * RETURN: Status
364 *
365 * DESCRIPTION: Device notify handler for AcpiExec utility. Used by the ASL
366 * test suite(s) to communicate errors and other information to
367 * this utility via the Notify() operator.
368 *
369 *****************************************************************************/
370
371 static void
372 AeDeviceNotifyHandler (
373 ACPI_HANDLE Device,
374 UINT32 Value,
375 void *Context)
376 {
377
378 printf ("[AcpiExec] Global: Received a Device Notify on [%4.4s] %p Value 0x%2.2X (%s)\n",
379 AcpiUtGetNodeName (Device), Device, Value,
380 AcpiUtGetNotifyName (Value));
381 if (AcpiGbl_DebugFile)
382 {
383 AcpiOsPrintf ("[AcpiExec] Global: Received a Device Notify, Value 0x%2.2X\n", Value);
384 }
385
386 (void) AcpiEvaluateObject (Device, "_NOT", NULL, NULL);
387 }
388
389
390 /******************************************************************************
391 *
392 * FUNCTION: AeExceptionHandler
393 *
394 * PARAMETERS: Standard exception handler parameters
395 *
396 * RETURN: Status
397 *
398 * DESCRIPTION: System exception handler for AcpiExec utility.
399 *
400 *****************************************************************************/
401
402 static ACPI_STATUS
403 AeExceptionHandler (
404 ACPI_STATUS AmlStatus,
405 ACPI_NAME Name,
406 UINT16 Opcode,
407 UINT32 AmlOffset,
408 void *Context)
409 {
410 ACPI_STATUS NewAmlStatus = AmlStatus;
411 ACPI_STATUS Status;
412 ACPI_BUFFER ReturnObj;
413 ACPI_OBJECT_LIST ArgList;
414 ACPI_OBJECT Arg[3];
415 const char *Exception;
416
417
418 Exception = AcpiFormatException (AmlStatus);
419 AcpiOsPrintf ("[AcpiExec] Exception %s during execution ", Exception);
420 if (Name)
421 {
422 AcpiOsPrintf ("of method [%4.4s]", (char *) &Name);
423 }
424 else
425 {
426 AcpiOsPrintf ("at module level (table load)");
427 }
428 AcpiOsPrintf (" Opcode [%s] @%X\n", AcpiPsGetOpcodeName (Opcode), AmlOffset);
429
430 /*
431 * Invoke the _ERR method if present
432 *
433 * Setup parameter object
434 */
435 ArgList.Count = 3;
436 ArgList.Pointer = Arg;
437
438 Arg[0].Type = ACPI_TYPE_INTEGER;
439 Arg[0].Integer.Value = AmlStatus;
440
441 Arg[1].Type = ACPI_TYPE_STRING;
442 Arg[1].String.Pointer = ACPI_CAST_PTR (char, Exception);
443 Arg[1].String.Length = ACPI_STRLEN (Exception);
444
445 Arg[2].Type = ACPI_TYPE_INTEGER;
446 Arg[2].Integer.Value = AcpiOsGetThreadId();
447
448 /* Setup return buffer */
449
450 ReturnObj.Pointer = NULL;
451 ReturnObj.Length = ACPI_ALLOCATE_BUFFER;
452
453 Status = AcpiEvaluateObject (NULL, "\\_ERR", &ArgList, &ReturnObj);
454 if (ACPI_SUCCESS (Status))
455 {
456 if (ReturnObj.Pointer)
457 {
458 /* Override original status */
459
460 NewAmlStatus = (ACPI_STATUS)
461 ((ACPI_OBJECT *) ReturnObj.Pointer)->Integer.Value;
462
463 /* Free a buffer created via ACPI_ALLOCATE_BUFFER */
464
465 AcpiOsFree (ReturnObj.Pointer);
466 }
467 }
468 else if (Status != AE_NOT_FOUND)
469 {
470 AcpiOsPrintf ("[AcpiExec] Could not execute _ERR method, %s\n",
471 AcpiFormatException (Status));
472 }
473
474 /* Global override */
475
476 if (AcpiGbl_IgnoreErrors)
477 {
478 NewAmlStatus = AE_OK;
479 }
480
481 if (NewAmlStatus != AmlStatus)
482 {
483 AcpiOsPrintf ("[AcpiExec] Exception override, new status %s\n",
484 AcpiFormatException (NewAmlStatus));
485 }
486
487 return (NewAmlStatus);
488 }
489
490
491 /******************************************************************************
492 *
493 * FUNCTION: AeTableHandler
494 *
495 * PARAMETERS: Table handler
496 *
497 * RETURN: Status
498 *
499 * DESCRIPTION: System table handler for AcpiExec utility.
500 *
501 *****************************************************************************/
502
503 static ACPI_STATUS
504 AeTableHandler (
505 UINT32 Event,
506 void *Table,
507 void *Context)
508 {
509 #if (!ACPI_REDUCED_HARDWARE)
510 ACPI_STATUS Status;
511 #endif /* !ACPI_REDUCED_HARDWARE */
512
513
514 if (Event > ACPI_NUM_TABLE_EVENTS)
515 {
516 Event = ACPI_NUM_TABLE_EVENTS;
517 }
518
519 #if (!ACPI_REDUCED_HARDWARE)
520 /* Enable any GPEs associated with newly-loaded GPE methods */
521
522 Status = AcpiUpdateAllGpes ();
523 AE_CHECK_OK (AcpiUpdateAllGpes, Status);
524
525 printf ("[AcpiExec] Table Event %s, [%4.4s] %p\n",
526 TableEvents[Event], ((ACPI_TABLE_HEADER *) Table)->Signature, Table);
527 #endif /* !ACPI_REDUCED_HARDWARE */
528
529 return (AE_OK);
530 }
531
532
533 /******************************************************************************
534 *
535 * FUNCTION: AeGpeHandler
536 *
537 * DESCRIPTION: Common GPE handler for acpiexec
538 *
539 *****************************************************************************/
540
541 UINT32
542 AeGpeHandler (
543 ACPI_HANDLE GpeDevice,
544 UINT32 GpeNumber,
545 void *Context)
546 {
547 ACPI_NAMESPACE_NODE *DeviceNode = (ACPI_NAMESPACE_NODE *) GpeDevice;
548
549
550 AcpiOsPrintf ("[AcpiExec] GPE Handler received GPE%02X (GPE block %4.4s)\n",
551 GpeNumber, GpeDevice ? DeviceNode->Name.Ascii : "FADT");
552
553 return (ACPI_REENABLE_GPE);
554 }
555
556
557 /******************************************************************************
558 *
559 * FUNCTION: AeGlobalEventHandler
560 *
561 * DESCRIPTION: Global GPE/Fixed event handler
562 *
563 *****************************************************************************/
564
565 void
566 AeGlobalEventHandler (
567 UINT32 Type,
568 ACPI_HANDLE Device,
569 UINT32 EventNumber,
570 void *Context)
571 {
572 char *TypeName;
573
574
575 switch (Type)
576 {
577 case ACPI_EVENT_TYPE_GPE:
578
579 TypeName = "GPE";
580 break;
581
582 case ACPI_EVENT_TYPE_FIXED:
583
584 TypeName = "FixedEvent";
585 break;
586
587 default:
588
589 TypeName = "UNKNOWN";
590 break;
591 }
592
593 AcpiOsPrintf ("[AcpiExec] Global Event Handler received: Type %s Number %.2X Dev %p\n",
594 TypeName, EventNumber, Device);
595 }
596
597
598 /******************************************************************************
599 *
600 * FUNCTION: AeAttachedDataHandler
601 *
602 * DESCRIPTION: Handler for deletion of nodes with attached data (attached via
603 * AcpiAttachData)
604 *
605 *****************************************************************************/
606
607 static void
608 AeAttachedDataHandler (
609 ACPI_HANDLE Object,
610 void *Data)
611 {
612 ACPI_NAMESPACE_NODE *Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Data);
613
614
615 AcpiOsPrintf ("Received an attached data deletion (1) on %4.4s\n",
616 Node->Name.Ascii);
617 }
618
619
620 /******************************************************************************
621 *
622 * FUNCTION: AeAttachedDataHandler2
623 *
624 * DESCRIPTION: Handler for deletion of nodes with attached data (attached via
625 * AcpiAttachData)
626 *
627 *****************************************************************************/
628
629 static void
630 AeAttachedDataHandler2 (
631 ACPI_HANDLE Object,
632 void *Data)
633 {
634 ACPI_NAMESPACE_NODE *Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Data);
635
636
637 AcpiOsPrintf ("Received an attached data deletion (2) on %4.4s\n",
638 Node->Name.Ascii);
639 }
640
641
642 /******************************************************************************
643 *
644 * FUNCTION: AeInterfaceHandler
645 *
646 * DESCRIPTION: Handler for _OSI invocations
647 *
648 *****************************************************************************/
649
650 static UINT32
651 AeInterfaceHandler (
652 ACPI_STRING InterfaceName,
653 UINT32 Supported)
654 {
655 ACPI_FUNCTION_NAME (AeInterfaceHandler);
656
657
658 ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
659 "Received _OSI (\"%s\"), is %ssupported\n",
660 InterfaceName, Supported == 0 ? "not " : ""));
661
662 return (Supported);
663 }
664
665
666 #if (!ACPI_REDUCED_HARDWARE)
667 /******************************************************************************
668 *
669 * FUNCTION: AeEventHandler, AeSciHandler
670 *
671 * DESCRIPTION: Handler for Fixed Events and SCIs
672 *
673 *****************************************************************************/
674
675 static UINT32
676 AeEventHandler (
677 void *Context)
678 {
679 return (0);
680 }
681
682 static UINT32
683 AeSciHandler (
684 void *Context)
685 {
686
687 AcpiOsPrintf ("[AcpiExec] Received an SCI at handler\n");
688 return (0);
689 }
690
691 #endif /* !ACPI_REDUCED_HARDWARE */
692
693
694 /******************************************************************************
695 *
696 * FUNCTION: AeRegionInit
697 *
698 * PARAMETERS: None
699 *
700 * RETURN: Status
701 *
702 * DESCRIPTION: Opregion init function.
703 *
704 *****************************************************************************/
705
706 static ACPI_STATUS
707 AeRegionInit (
708 ACPI_HANDLE RegionHandle,
709 UINT32 Function,
710 void *HandlerContext,
711 void **RegionContext)
712 {
713
714 if (Function == ACPI_REGION_DEACTIVATE)
715 {
716 *RegionContext = NULL;
717 }
718 else
719 {
720 *RegionContext = RegionHandle;
721 }
722
723 return (AE_OK);
724 }
725
726
727 /*******************************************************************************
728 *
729 * FUNCTION: AeInstallSciHandler
730 *
731 * PARAMETERS: None
732 *
733 * RETURN: Status
734 *
735 * DESCRIPTION: Install handler for SCIs. Exercise the code by doing an
736 * install/remove/install.
737 *
738 ******************************************************************************/
739
740 static ACPI_STATUS
741 AeInstallSciHandler (
742 void)
743 {
744 ACPI_STATUS Status;
745
746
747 Status = AcpiInstallSciHandler (AeSciHandler, &AeMyContext);
748 if (ACPI_FAILURE (Status))
749 {
750 ACPI_EXCEPTION ((AE_INFO, Status,
751 "Could not install an SCI handler (1)"));
752 }
753
754 Status = AcpiRemoveSciHandler (AeSciHandler);
755 if (ACPI_FAILURE (Status))
756 {
757 ACPI_EXCEPTION ((AE_INFO, Status,
758 "Could not remove an SCI handler"));
759 }
760
761 Status = AcpiInstallSciHandler (AeSciHandler, &AeMyContext);
762 if (ACPI_FAILURE (Status))
763 {
764 ACPI_EXCEPTION ((AE_INFO, Status,
765 "Could not install an SCI handler (2)"));
766 }
767
768 return (Status);
769 }
770
771
772 /*******************************************************************************
773 *
774 * FUNCTION: AeInstallDeviceHandlers, AeInstallEcHandler,
775 * AeInstallPciHandler
776 *
777 * PARAMETERS: ACPI_WALK_NAMESPACE callback
778 *
779 * RETURN: Status
780 *
781 * DESCRIPTION: Walk entire namespace, install a handler for every EC
782 * and PCI device found.
783 *
784 ******************************************************************************/
785
786 static ACPI_STATUS
787 AeInstallEcHandler (
788 ACPI_HANDLE ObjHandle,
789 UINT32 Level,
790 void *Context,
791 void **ReturnValue)
792 {
793 ACPI_STATUS Status;
794
795
796 /* Install the handler for this EC device */
797
798 Status = AcpiInstallAddressSpaceHandler (ObjHandle, ACPI_ADR_SPACE_EC,
799 AeRegionHandler, AeRegionInit, &AeMyContext);
800 if (ACPI_FAILURE (Status))
801 {
802 ACPI_EXCEPTION ((AE_INFO, Status,
803 "Could not install an OpRegion handler for EC device (%p)",
804 ObjHandle));
805 }
806
807 return (Status);
808 }
809
810 static ACPI_STATUS
811 AeInstallPciHandler (
812 ACPI_HANDLE ObjHandle,
813 UINT32 Level,
814 void *Context,
815 void **ReturnValue)
816 {
817 ACPI_STATUS Status;
818
819
820 /* Install memory and I/O handlers for the PCI device */
821
822 Status = AcpiInstallAddressSpaceHandler (ObjHandle, ACPI_ADR_SPACE_SYSTEM_IO,
823 AeRegionHandler, AeRegionInit, &AeMyContext);
824 if (ACPI_FAILURE (Status))
825 {
826 ACPI_EXCEPTION ((AE_INFO, Status,
827 "Could not install an OpRegion handler for PCI device (%p)",
828 ObjHandle));
829 }
830
831 Status = AcpiInstallAddressSpaceHandler (ObjHandle, ACPI_ADR_SPACE_SYSTEM_MEMORY,
832 AeRegionHandler, AeRegionInit, &AeMyContext);
833 if (ACPI_FAILURE (Status))
834 {
835 ACPI_EXCEPTION ((AE_INFO, Status,
836 "Could not install an OpRegion handler for PCI device (%p)",
837 ObjHandle));
838 }
839
840 return (AE_CTRL_TERMINATE);
841 }
842
843 static ACPI_STATUS
844 AeInstallDeviceHandlers (
845 void)
846 {
847
848 /* Find all Embedded Controller devices */
849
850 AcpiGetDevices ("PNP0C09", AeInstallEcHandler, NULL, NULL);
851
852 /* Install a PCI handler */
853
854 AcpiGetDevices ("PNP0A08", AeInstallPciHandler, NULL, NULL);
855 return (AE_OK);
856 }
857
858
859 /******************************************************************************
860 *
861 * FUNCTION: AeInstallLateHandlers
862 *
863 * PARAMETERS: None
864 *
865 * RETURN: Status
866 *
867 * DESCRIPTION: Install handlers for the AcpiExec utility.
868 *
869 *****************************************************************************/
870
871 ACPI_STATUS
872 AeInstallLateHandlers (
873 void)
874 {
875 ACPI_STATUS Status;
876 UINT32 i;
877
878
879 #if (!ACPI_REDUCED_HARDWARE)
880 if (!AcpiGbl_ReducedHardware)
881 {
882 /* Install a user SCI handler */
883
884 Status = AeInstallSciHandler ();
885 AE_CHECK_OK (AeInstallSciHandler, Status);
886
887 /* Install some fixed event handlers */
888
889 Status = AcpiInstallFixedEventHandler (ACPI_EVENT_GLOBAL, AeEventHandler, NULL);
890 AE_CHECK_OK (AcpiInstallFixedEventHandler, Status);
891
892 Status = AcpiInstallFixedEventHandler (ACPI_EVENT_RTC, AeEventHandler, NULL);
893 AE_CHECK_OK (AcpiInstallFixedEventHandler, Status);
894 }
895 #endif /* !ACPI_REDUCED_HARDWARE */
896
897 AeMyContext.Connection = NULL;
898 AeMyContext.AccessLength = 0xA5;
899
900 /*
901 * We will install a handler for each EC device, directly under the EC
902 * device definition. This is unlike the other handlers which we install
903 * at the root node. Also install memory and I/O handlers at any PCI
904 * devices.
905 */
906 AeInstallDeviceHandlers ();
907
908 /*
909 * Install handlers for some of the "device driver" address spaces
910 * such as SMBus, etc.
911 */
912 for (i = 0; i < ACPI_ARRAY_LENGTH (SpaceIdList); i++)
913 {
914 /* Install handler at the root object */
915
916 Status = AcpiInstallAddressSpaceHandler (ACPI_ROOT_OBJECT,
917 SpaceIdList[i], AeRegionHandler,
918 AeRegionInit, &AeMyContext);
919 if (ACPI_FAILURE (Status))
920 {
921 ACPI_EXCEPTION ((AE_INFO, Status,
922 "Could not install an OpRegion handler for %s space(%u)",
923 AcpiUtGetRegionName((UINT8) SpaceIdList[i]), SpaceIdList[i]));
924 return (Status);
925 }
926 }
927
928 return (AE_OK);
929 }
930
931
932 /******************************************************************************
933 *
934 * FUNCTION: AeInstallEarlyHandlers
935 *
936 * PARAMETERS: None
937 *
938 * RETURN: Status
939 *
940 * DESCRIPTION: Install handlers for the AcpiExec utility.
941 *
942 * Notes: Don't install handler for PCI_Config, we want to use the
943 * default handler to exercise that code.
944 *
945 *****************************************************************************/
946
947 ACPI_STATUS
948 AeInstallEarlyHandlers (
949 void)
950 {
951 ACPI_STATUS Status;
952 UINT32 i;
953 ACPI_HANDLE Handle;
954
955
956 ACPI_FUNCTION_ENTRY ();
957
958
959 Status = AcpiInstallInterfaceHandler (AeInterfaceHandler);
960 if (ACPI_FAILURE (Status))
961 {
962 printf ("Could not install interface handler, %s\n",
963 AcpiFormatException (Status));
964 }
965
966 Status = AcpiInstallTableHandler (AeTableHandler, NULL);
967 if (ACPI_FAILURE (Status))
968 {
969 printf ("Could not install table handler, %s\n",
970 AcpiFormatException (Status));
971 }
972
973 Status = AcpiInstallExceptionHandler (AeExceptionHandler);
974 if (ACPI_FAILURE (Status))
975 {
976 printf ("Could not install exception handler, %s\n",
977 AcpiFormatException (Status));
978 }
979
980 /* Install global notify handlers */
981
982 Status = AcpiInstallNotifyHandler (ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
983 AeSystemNotifyHandler, NULL);
984 if (ACPI_FAILURE (Status))
985 {
986 printf ("Could not install a global system notify handler, %s\n",
987 AcpiFormatException (Status));
988 }
989
990 Status = AcpiInstallNotifyHandler (ACPI_ROOT_OBJECT, ACPI_DEVICE_NOTIFY,
991 AeDeviceNotifyHandler, NULL);
992 if (ACPI_FAILURE (Status))
993 {
994 printf ("Could not install a global notify handler, %s\n",
995 AcpiFormatException (Status));
996 }
997
998 Status = AcpiGetHandle (NULL, "\\_SB", &Handle);
999 if (ACPI_SUCCESS (Status))
1000 {
1001 Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,
1002 AeNotifyHandler1, NULL);
1003 if (ACPI_FAILURE (Status))
1004 {
1005 printf ("Could not install a notify handler, %s\n",
1006 AcpiFormatException (Status));
1007 }
1008
1009 Status = AcpiRemoveNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,
1010 AeNotifyHandler1);
1011 if (ACPI_FAILURE (Status))
1012 {
1013 printf ("Could not remove a notify handler, %s\n",
1014 AcpiFormatException (Status));
1015 }
1016
1017 Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
1018 AeNotifyHandler1, NULL);
1019 AE_CHECK_OK (AcpiInstallNotifyHandler, Status);
1020
1021 Status = AcpiRemoveNotifyHandler (Handle, ACPI_ALL_NOTIFY,
1022 AeNotifyHandler1);
1023 AE_CHECK_OK (AcpiRemoveNotifyHandler, Status);
1024
1025 #if 0
1026 Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
1027 AeNotifyHandler1, NULL);
1028 if (ACPI_FAILURE (Status))
1029 {
1030 printf ("Could not install a notify handler, %s\n",
1031 AcpiFormatException (Status));
1032 }
1033 #endif
1034
1035 /* Install two handlers for _SB_ */
1036
1037 Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,
1038 AeNotifyHandler1, ACPI_CAST_PTR (void, 0x01234567));
1039
1040 Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,
1041 AeNotifyHandler2, ACPI_CAST_PTR (void, 0x89ABCDEF));
1042
1043 /* Attempt duplicate handler installation, should fail */
1044
1045 Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,
1046 AeNotifyHandler1, ACPI_CAST_PTR (void, 0x77777777));
1047
1048 Status = AcpiAttachData (Handle, AeAttachedDataHandler, Handle);
1049 AE_CHECK_OK (AcpiAttachData, Status);
1050
1051 Status = AcpiDetachData (Handle, AeAttachedDataHandler);
1052 AE_CHECK_OK (AcpiDetachData, Status);
1053
1054 Status = AcpiAttachData (Handle, AeAttachedDataHandler, Handle);
1055 AE_CHECK_OK (AcpiAttachData, Status);
1056
1057 /* Test support for multiple attaches */
1058
1059 Status = AcpiAttachData (Handle, AeAttachedDataHandler2, Handle);
1060 AE_CHECK_OK (AcpiAttachData, Status);
1061 }
1062 else
1063 {
1064 printf ("No _SB_ found, %s\n", AcpiFormatException (Status));
1065 }
1066
1067
1068 Status = AcpiGetHandle (NULL, "\\_TZ.TZ1", &Handle);
1069 if (ACPI_SUCCESS (Status))
1070 {
1071 Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
1072 AeNotifyHandler1, ACPI_CAST_PTR (void, 0x01234567));
1073
1074 Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
1075 AeNotifyHandler2, ACPI_CAST_PTR (void, 0x89ABCDEF));
1076
1077 Status = AcpiRemoveNotifyHandler (Handle, ACPI_ALL_NOTIFY,
1078 AeNotifyHandler1);
1079 Status = AcpiRemoveNotifyHandler (Handle, ACPI_ALL_NOTIFY,
1080 AeNotifyHandler2);
1081
1082 Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
1083 AeNotifyHandler2, ACPI_CAST_PTR (void, 0x89ABCDEF));
1084
1085 Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
1086 AeNotifyHandler1, ACPI_CAST_PTR (void, 0x01234567));
1087 }
1088
1089 Status = AcpiGetHandle (NULL, "\\_PR.CPU0", &Handle);
1090 if (ACPI_SUCCESS (Status))
1091 {
1092 Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
1093 AeNotifyHandler1, ACPI_CAST_PTR (void, 0x01234567));
1094
1095 Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,
1096 AeNotifyHandler2, ACPI_CAST_PTR (void, 0x89ABCDEF));
1097 }
1098
1099 /*
1100 * Install handlers that will override the default handlers for some of
1101 * the space IDs.
1102 */
1103 for (i = 0; i < ACPI_ARRAY_LENGTH (DefaultSpaceIdList); i++)
1104 {
1105 /* Install handler at the root object */
1106
1107 Status = AcpiInstallAddressSpaceHandler (ACPI_ROOT_OBJECT,
1108 DefaultSpaceIdList[i], AeRegionHandler,
1109 AeRegionInit, &AeMyContext);
1110 if (ACPI_FAILURE (Status))
1111 {
1112 ACPI_EXCEPTION ((AE_INFO, Status,
1113 "Could not install a default OpRegion handler for %s space(%u)",
1114 AcpiUtGetRegionName ((UINT8) DefaultSpaceIdList[i]),
1115 DefaultSpaceIdList[i]));
1116 return (Status);
1117 }
1118 }
1119
1120 /*
1121 * Initialize the global Region Handler space
1122 * MCW 3/23/00
1123 */
1124 AeRegions.NumberOfRegions = 0;
1125 AeRegions.RegionList = NULL;
1126 return (Status);
1127 }
1128
1129
1130 /******************************************************************************
1131 *
1132 * FUNCTION: AeRegionHandler
1133 *
1134 * PARAMETERS: Standard region handler parameters
1135 *
1136 * RETURN: Status
1137 *
1138 * DESCRIPTION: Test handler - Handles some dummy regions via memory that can
1139 * be manipulated in Ring 3. Simulates actual reads and writes.
1140 *
1141 *****************************************************************************/
1142
1143 ACPI_STATUS
1144 AeRegionHandler (
1145 UINT32 Function,
1146 ACPI_PHYSICAL_ADDRESS Address,
1147 UINT32 BitWidth,
1148 UINT64 *Value,
1149 void *HandlerContext,
1150 void *RegionContext)
1151 {
1152
1153 ACPI_OPERAND_OBJECT *RegionObject = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, RegionContext);
1154 UINT8 *Buffer = ACPI_CAST_PTR (UINT8, Value);
1155 ACPI_PHYSICAL_ADDRESS BaseAddress;
1156 ACPI_SIZE Length;
1157 BOOLEAN BufferExists;
1158 AE_REGION *RegionElement;
1159 void *BufferValue;
1160 ACPI_STATUS Status;
1161 UINT32 ByteWidth;
1162 UINT32 i;
1163 UINT8 SpaceId;
1164 ACPI_CONNECTION_INFO *MyContext;
1165 UINT32 Value1;
1166 UINT32 Value2;
1167 ACPI_RESOURCE *Resource;
1168
1169
1170 ACPI_FUNCTION_NAME (AeRegionHandler);
1171
1172 /*
1173 * If the object is not a region, simply return
1174 */
1175 if (RegionObject->Region.Type != ACPI_TYPE_REGION)
1176 {
1177 return (AE_OK);
1178 }
1179
1180 /* Check that we actually got back our context parameter */
1181
1182 if (HandlerContext != &AeMyContext)
1183 {
1184 printf ("Region handler received incorrect context %p, should be %p\n",
1185 HandlerContext, &AeMyContext);
1186 }
1187
1188 MyContext = ACPI_CAST_PTR (ACPI_CONNECTION_INFO, HandlerContext);
1189
1190 /*
1191 * Find the region's address space and length before searching
1192 * the linked list.
1193 */
1194 BaseAddress = RegionObject->Region.Address;
1195 Length = (ACPI_SIZE) RegionObject->Region.Length;
1196 SpaceId = RegionObject->Region.SpaceId;
1197
1198 ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION, "Operation Region request on %s at 0x%X\n",
1199 AcpiUtGetRegionName (RegionObject->Region.SpaceId),
1200 (UINT32) Address));
1201
1202 /*
1203 * Region support can be disabled with the -do option.
1204 * We use this to support dynamically loaded tables where we pass a valid
1205 * address to the AML.
1206 */
1207 if (AcpiGbl_DbOpt_NoRegionSupport)
1208 {
1209 BufferValue = ACPI_TO_POINTER (Address);
1210 ByteWidth = (BitWidth / 8);
1211
1212 if (BitWidth % 8)
1213 {
1214 ByteWidth += 1;
1215 }
1216 goto DoFunction;
1217 }
1218
1219 switch (SpaceId)
1220 {
1221 case ACPI_ADR_SPACE_SYSTEM_IO:
1222 /*
1223 * For I/O space, exercise the port validation
1224 * Note: ReadPort currently always returns all ones, length=BitLength
1225 */
1226 switch (Function & ACPI_IO_MASK)
1227 {
1228 case ACPI_READ:
1229
1230 if (BitWidth == 64)
1231 {
1232 /* Split the 64-bit request into two 32-bit requests */
1233
1234 Status = AcpiHwReadPort (Address, &Value1, 32);
1235 AE_CHECK_OK (AcpiHwReadPort, Status);
1236 Status = AcpiHwReadPort (Address+4, &Value2, 32);
1237 AE_CHECK_OK (AcpiHwReadPort, Status);
1238
1239 *Value = Value1 | ((UINT64) Value2 << 32);
1240 }
1241 else
1242 {
1243 Status = AcpiHwReadPort (Address, &Value1, BitWidth);
1244 AE_CHECK_OK (AcpiHwReadPort, Status);
1245 *Value = (UINT64) Value1;
1246 }
1247 break;
1248
1249 case ACPI_WRITE:
1250
1251 if (BitWidth == 64)
1252 {
1253 /* Split the 64-bit request into two 32-bit requests */
1254
1255 Status = AcpiHwWritePort (Address, ACPI_LODWORD (*Value), 32);
1256 AE_CHECK_OK (AcpiHwWritePort, Status);
1257 Status = AcpiHwWritePort (Address+4, ACPI_HIDWORD (*Value), 32);
1258 AE_CHECK_OK (AcpiHwWritePort, Status);
1259 }
1260 else
1261 {
1262 Status = AcpiHwWritePort (Address, (UINT32) *Value, BitWidth);
1263 AE_CHECK_OK (AcpiHwWritePort, Status);
1264 }
1265 break;
1266
1267 default:
1268
1269 Status = AE_BAD_PARAMETER;
1270 break;
1271 }
1272
1273 if (ACPI_FAILURE (Status))
1274 {
1275 return (Status);
1276 }
1277
1278 /* Now go ahead and simulate the hardware */
1279 break;
1280
1281 /*
1282 * SMBus and GenericSerialBus support the various bidirectional
1283 * protocols.
1284 */
1285 case ACPI_ADR_SPACE_SMBUS:
1286 case ACPI_ADR_SPACE_GSBUS: /* ACPI 5.0 */
1287
1288 Length = 0;
1289
1290 switch (Function & ACPI_IO_MASK)
1291 {
1292 case ACPI_READ:
1293
1294 switch (Function >> 16)
1295 {
1296 case AML_FIELD_ATTRIB_QUICK:
1297 case AML_FIELD_ATTRIB_SEND_RCV:
1298 case AML_FIELD_ATTRIB_BYTE:
1299
1300 Length = 1;
1301 break;
1302
1303 case AML_FIELD_ATTRIB_WORD:
1304 case AML_FIELD_ATTRIB_WORD_CALL:
1305
1306 Length = 2;
1307 break;
1308
1309 case AML_FIELD_ATTRIB_BLOCK:
1310 case AML_FIELD_ATTRIB_BLOCK_CALL:
1311
1312 Length = 32;
1313 break;
1314
1315 case AML_FIELD_ATTRIB_MULTIBYTE:
1316 case AML_FIELD_ATTRIB_RAW_BYTES:
1317 case AML_FIELD_ATTRIB_RAW_PROCESS:
1318
1319 /* (-2) for status/length */
1320 Length = MyContext->AccessLength - 2;
1321 break;
1322
1323 default:
1324
1325 break;
1326 }
1327 break;
1328
1329 case ACPI_WRITE:
1330
1331 switch (Function >> 16)
1332 {
1333 case AML_FIELD_ATTRIB_QUICK:
1334 case AML_FIELD_ATTRIB_SEND_RCV:
1335 case AML_FIELD_ATTRIB_BYTE:
1336 case AML_FIELD_ATTRIB_WORD:
1337 case AML_FIELD_ATTRIB_BLOCK:
1338
1339 Length = 0;
1340 break;
1341
1342 case AML_FIELD_ATTRIB_WORD_CALL:
1343 Length = 2;
1344 break;
1345
1346 case AML_FIELD_ATTRIB_BLOCK_CALL:
1347 Length = 32;
1348 break;
1349
1350 case AML_FIELD_ATTRIB_MULTIBYTE:
1351 case AML_FIELD_ATTRIB_RAW_BYTES:
1352 case AML_FIELD_ATTRIB_RAW_PROCESS:
1353
1354 /* (-2) for status/length */
1355 Length = MyContext->AccessLength - 2;
1356 break;
1357
1358 default:
1359
1360 break;
1361 }
1362 break;
1363
1364 default:
1365
1366 break;
1367 }
1368
1369 if (AcpiGbl_DisplayRegionAccess)
1370 {
1371 AcpiOsPrintf ("AcpiExec: %s "
1372 "%s: Attr %X Addr %.4X BaseAddr %.4X Len %.2X Width %X BufLen %X",
1373 AcpiUtGetRegionName (SpaceId),
1374 (Function & ACPI_IO_MASK) ? "Write" : "Read ",
1375 (UINT32) (Function >> 16),
1376 (UINT32) Address, (UINT32) BaseAddress,
1377 Length, BitWidth, Buffer[1]);
1378
1379 /* GenericSerialBus has a Connection() parameter */
1380
1381 if (SpaceId == ACPI_ADR_SPACE_GSBUS)
1382 {
1383 Status = AcpiBufferToResource (MyContext->Connection,
1384 MyContext->Length, &Resource);
1385
1386 AcpiOsPrintf (" [AccLen %.2X Conn %p]",
1387 MyContext->AccessLength, MyContext->Connection);
1388 }
1389 AcpiOsPrintf ("\n");
1390 }
1391
1392 /* Setup the return buffer. Note: ASLTS depends on these fill values */
1393
1394 for (i = 0; i < Length; i++)
1395 {
1396 Buffer[i+2] = (UINT8) (0xA0 + i);
1397 }
1398
1399 Buffer[0] = 0x7A;
1400 Buffer[1] = (UINT8) Length;
1401 return (AE_OK);
1402
1403
1404 case ACPI_ADR_SPACE_IPMI: /* ACPI 4.0 */
1405
1406 if (AcpiGbl_DisplayRegionAccess)
1407 {
1408 AcpiOsPrintf ("AcpiExec: IPMI "
1409 "%s: Attr %X Addr %.4X BaseAddr %.4X Len %.2X Width %X BufLen %X\n",
1410 (Function & ACPI_IO_MASK) ? "Write" : "Read ",
1411 (UINT32) (Function >> 16), (UINT32) Address, (UINT32) BaseAddress,
1412 Length, BitWidth, Buffer[1]);
1413 }
1414
1415 /*
1416 * Regardless of a READ or WRITE, this handler is passed a 66-byte
1417 * buffer in which to return the IPMI status/length/data.
1418 *
1419 * Return some example data to show use of the bidirectional buffer
1420 */
1421 Buffer[0] = 0; /* Status byte */
1422 Buffer[1] = 64; /* Return buffer data length */
1423 Buffer[2] = 0; /* Completion code */
1424 Buffer[3] = 0; /* Reserved */
1425
1426 /*
1427 * Fill the 66-byte buffer with the return data.
1428 * Note: ASLTS depends on these fill values.
1429 */
1430 for (i = 4; i < 66; i++)
1431 {
1432 Buffer[i] = (UINT8) (i);
1433 }
1434 return (AE_OK);
1435
1436 default:
1437 break;
1438 }
1439
1440 /*
1441 * Search through the linked list for this region's buffer
1442 */
1443 BufferExists = FALSE;
1444 RegionElement = AeRegions.RegionList;
1445
1446 if (AeRegions.NumberOfRegions)
1447 {
1448 while (!BufferExists && RegionElement)
1449 {
1450 if (RegionElement->Address == BaseAddress &&
1451 RegionElement->Length == Length &&
1452 RegionElement->SpaceId == SpaceId)
1453 {
1454 BufferExists = TRUE;
1455 }
1456 else
1457 {
1458 RegionElement = RegionElement->NextRegion;
1459 }
1460 }
1461 }
1462
1463 /*
1464 * If the Region buffer does not exist, create it now
1465 */
1466 if (!BufferExists)
1467 {
1468 /*
1469 * Do the memory allocations first
1470 */
1471 RegionElement = AcpiOsAllocate (sizeof (AE_REGION));
1472 if (!RegionElement)
1473 {
1474 return (AE_NO_MEMORY);
1475 }
1476
1477 RegionElement->Buffer = AcpiOsAllocate (Length);
1478 if (!RegionElement->Buffer)
1479 {
1480 AcpiOsFree (RegionElement);
1481 return (AE_NO_MEMORY);
1482 }
1483
1484 /* Initialize the region with the default fill value */
1485
1486 ACPI_MEMSET (RegionElement->Buffer, AcpiGbl_RegionFillValue, Length);
1487
1488 RegionElement->Address = BaseAddress;
1489 RegionElement->Length = Length;
1490 RegionElement->SpaceId = SpaceId;
1491 RegionElement->NextRegion = NULL;
1492
1493 /*
1494 * Increment the number of regions and put this one
1495 * at the head of the list as it will probably get accessed
1496 * more often anyway.
1497 */
1498 AeRegions.NumberOfRegions += 1;
1499
1500 if (AeRegions.RegionList)
1501 {
1502 RegionElement->NextRegion = AeRegions.RegionList;
1503 }
1504
1505 AeRegions.RegionList = RegionElement;
1506 }
1507
1508 /*
1509 * Calculate the size of the memory copy
1510 */
1511 ByteWidth = (BitWidth / 8);
1512
1513 if (BitWidth % 8)
1514 {
1515 ByteWidth += 1;
1516 }
1517
1518 /*
1519 * The buffer exists and is pointed to by RegionElement.
1520 * We now need to verify the request is valid and perform the operation.
1521 *
1522 * NOTE: RegionElement->Length is in bytes, therefore it we compare against
1523 * ByteWidth (see above)
1524 */
1525 if (((UINT64) Address + ByteWidth) >
1526 ((UINT64)(RegionElement->Address) + RegionElement->Length))
1527 {
1528 ACPI_WARNING ((AE_INFO,
1529 "Request on [%4.4s] is beyond region limit Req-0x%X+0x%X, Base=0x%X, Len-0x%X",
1530 (RegionObject->Region.Node)->Name.Ascii, (UINT32) Address,
1531 ByteWidth, (UINT32)(RegionElement->Address),
1532 RegionElement->Length));
1533
1534 return (AE_AML_REGION_LIMIT);
1535 }
1536
1537 /*
1538 * Get BufferValue to point to the "address" in the buffer
1539 */
1540 BufferValue = ((UINT8 *) RegionElement->Buffer +
1541 ((UINT64) Address - (UINT64) RegionElement->Address));
1542
1543 DoFunction:
1544 /*
1545 * Perform a read or write to the buffer space
1546 */
1547 switch (Function)
1548 {
1549 case ACPI_READ:
1550 /*
1551 * Set the pointer Value to whatever is in the buffer
1552 */
1553 ACPI_MEMCPY (Value, BufferValue, ByteWidth);
1554 break;
1555
1556 case ACPI_WRITE:
1557 /*
1558 * Write the contents of Value to the buffer
1559 */
1560 ACPI_MEMCPY (BufferValue, Value, ByteWidth);
1561 break;
1562
1563 default:
1564
1565 return (AE_BAD_PARAMETER);
1566 }
1567
1568 if (AcpiGbl_DisplayRegionAccess)
1569 {
1570 switch (SpaceId)
1571 {
1572 case ACPI_ADR_SPACE_SYSTEM_MEMORY:
1573
1574 AcpiOsPrintf ("AcpiExec: SystemMemory "
1575 "%s: Val %.8X Addr %.4X Width %X [REGION: BaseAddr %.4X Len %.2X]\n",
1576 (Function & ACPI_IO_MASK) ? "Write" : "Read ",
1577 (UINT32) *Value, (UINT32) Address, BitWidth, (UINT32) BaseAddress, Length);
1578 break;
1579
1580 case ACPI_ADR_SPACE_GPIO: /* ACPI 5.0 */
1581
1582 /* This space is required to always be ByteAcc */
1583
1584 Status = AcpiBufferToResource (MyContext->Connection,
1585 MyContext->Length, &Resource);
1586
1587 AcpiOsPrintf ("AcpiExec: GeneralPurposeIo "
1588 "%s: Val %.8X Addr %.4X BaseAddr %.4X Len %.2X Width %X AccLen %.2X Conn %p\n",
1589 (Function & ACPI_IO_MASK) ? "Write" : "Read ", (UINT32) *Value,
1590 (UINT32) Address, (UINT32) BaseAddress, Length, BitWidth,
1591 MyContext->AccessLength, MyContext->Connection);
1592 break;
1593
1594 default:
1595
1596 break;
1597 }
1598 }
1599
1600 return (AE_OK);
1601 }