arch/all-pc/acpi/readreg.c

   1 #include <asm/io.h>
   2 #include <resources/acpi.h>
   3
   4 #include "gas_io.h"
   5
   6 /*****************************************************************************
   7
   8     NAME */
   9 #include <proto/acpi.h>
  10
  11 AROS_LH1I(IPTR, ACPI_ReadReg,
  12
  13 /*  SYNOPSIS */
  14         AROS_LHA(struct GENERIC_ACPI_ADDR *, reg, A0),
  15
  16 /*  LOCATION */
  17         struct ACPIBase *, ACPIBase, 3, Acpi)
  18
  19 /*  FUNCTION
  20         Read a value from the register specified by GAS
  21
  22     INPUTS
  23         reg - a pointer to a generic address structure
  24
  25     RESULT
  26         A value read from the register
  27
  28     NOTES
  29         Only memory and I/O spaces are supported.
  30         64-bit registers are supported only in memory space and only on 64-bit platforms.
  31         The given GAS must address a complete register, not a data structure.
  32
  33     EXAMPLE
  34
  35     BUGS
  36
  37     SEE ALSO
  38
  39     INTERNALS
  40
  41 ******************************************************************************/
  42 {
  43     AROS_LIBFUNC_INIT
  44
  45     unsigned char size = GetSize(reg);
  46     IPTR val = ReadRegInt(reg, size);
  47
  48     if (reg->register_bit_width != FullSize[reg->size])
  49     {
  50         /*
  51          * Partial bit field.
  52          * Mask out the needed bits and shift to the right.
  53          */
  54         unsigned long mask = (1 << reg->register_bit_width) - 1;
  55
  56         val = (val >> reg->register_bit_offset) & mask;
  57     }
  58
  59     return val;
  60
  61     AROS_LIBFUNC_EXIT
  62 }
  63
  64 const unsigned char FullSize[] = {0, 8, 16, 32, 64};
  65
  66 unsigned char GetSize(struct GENERIC_ACPI_ADDR *reg)
  67 {
  68     unsigned char size = reg->size;
  69
  70     if (size == ACPI_SIZE_UNDEFINED)
  71     {
  72         /* Need to compute register size */
  73         unsigned char bits = reg->register_bit_offset + reg->register_bit_width;
  74
  75         if (bits <= 8)
  76             size = ACPI_SIZE_BYTE;
  77         else if (bits <= 16)
  78             size = ACPI_SIZE_WORD;
  79         else if (bits <= 32)
  80             size = ACPI_SIZE_DWORD;
  81         else
  82             size = ACPI_SIZE_QUAD;
  83     }
  84     return size;
  85 }
  86
  87 IPTR ReadRegInt(struct GENERIC_ACPI_ADDR *reg, unsigned char size)
  88 {
  89     IPTR val = 0;
  90
  91     switch (reg->address_space_id)
  92     {
  93     case ACPI_SPACE_MEM:
  94         switch (size)
  95         {
  96         case ACPI_SIZE_BYTE:
  97             val = *((UBYTE *)(IPTR)reg->address);
  98             break;
  99
 100         case ACPI_SIZE_WORD:
 101             val = *((UWORD *)(IPTR)reg->address);
 102             break;
 103
 104         case ACPI_SIZE_DWORD:
 105             val = *((ULONG *)(IPTR)reg->address);
 106             break;
 107
 108 #if __WORDSIZE == 64
 109         case ACPI_SIZE_QUAD:
 110             val = *((UQUAD *)(IPTR)reg->address);
 111             break;
 112 #endif
 113         }
 114         break;
 115
 116     case ACPI_SPACE_IO:
 117         switch (size)
 118         {
 119         case ACPI_SIZE_BYTE:
 120             val = inb(reg->address);
 121             break;
 122
 123         case ACPI_SIZE_WORD:
 124             val = inw(reg->address);
 125             break;
 126
 127         case ACPI_SIZE_DWORD:
 128             val = inl(reg->address);
 129             break;
 130
 131         /* ACPI_SIZE_QUAD - not supported ? */
 132         }
 133         break;
 134     }
 135
 136     return val;
 137 }