arch/arm-linux/processor/arch_init.c

   1 #include <aros/symbolsets.h>
   2 #include <resources/processor.h>
   3 #include <proto/alib.h>
   4 #include <proto/exec.h>
   5 #include <proto/hostlib.h>
   6
   7 #include <ctype.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10
  11 #include "arch_intern.h"
  12 #include "processor_intern.h"
  13
  14 static char *getval(const char *key, char *s)
  15 {
  16     while (*key)
  17     {
  18         if (*key++ != *s++)
  19             return NULL;
  20     }
  21
  22     /* Skip whitespaces and colon */
  23     while (*s && (isspace(*s) || (*s == ':')))
  24         s++;
  25
  26     return s;
  27 }
  28
  29 static ULONG ParseFlags(char *opts, const char * const *FlagNames)
  30 {
  31     ULONG ret = 0;
  32     unsigned int i;
  33
  34     while (*opts)
  35     {
  36         /* Remember beginning of the word */
  37         char *p = opts;
  38
  39         /* Find end of the word */
  40         while (*opts && (!isspace(*opts)))
  41             opts++;
  42
  43         if (*opts)
  44         {
  45             /*
  46              * If this is not the end of line, split the string and advance to the next char.
  47              * Feature names are separated with one whitespace.
  48              */
  49             *opts++ = 0;
  50         }
  51
  52         /* Decode flag name */
  53         for (i = 0; FlagNames[i]; i++)
  54         {
  55             if (!strcmp(p, FlagNames[i]))
  56             {
  57                 /* Set bit corresponding to number of flag name in the list */
  58                 ret |= (1UL << i);
  59                 break;
  60             }
  61         }
  62     }
  63
  64     return ret;
  65 }
  66
  67 /*
  68  * This is what can be reported by Linux kernel (see their arch/arm/kernel/setup.c).
  69  * Order of these must be the same as order of family IDs.
  70  */
  71 static const char *arch_ids[] =
  72 {
  73     "3",
  74     "4",
  75     "4T",
  76     "5",
  77     "5T",
  78     "5TE",
  79     "5TEJ",
  80     "6TEJ",
  81     "7",
  82     NULL
  83 };
  84
  85 /*
  86  * Feature flags as reported by kernel (quote not everything is supported).
  87  * Again, order of these repeats order of feature ID tags.
  88  */
  89 static const char *feature_ids[] =
  90 {
  91     "vfp",
  92     "vfpv3",
  93     "neon",
  94     "thumb",
  95     "thumbee",
  96     NULL
  97 };
  98
  99 #ifdef HOST_OS_android
 100 #define LIBC_NAME "libc.so"
 101 #else
 102 #define LIBC_NAME "libc.so.6"
 103 #endif
 104
 105 static const char *libc_symbols[] =
 106 {
 107     "fopen",
 108     "fclose",
 109     "fgets",
 110     NULL
 111 };
 112
 113 /*
 114  * Unfortunately CPU identification instructions on ARM requires supervisor privileges,
 115  * so we can't use them on hosted. We can only ask host OS about our CPU.
 116  * On Linux (and Android) we can do this only by parsing human-readable text in /proc/cpuinfo.
 117  * We don't use unixio.hidd here because we want to start up as early as possible.
 118  */
 119 static ULONG arch_Init(struct ProcessorBase *ProcessorBase)
 120 {
 121     APTR HostLibBase, libc;
 122     struct LibCInterface *iface;
 123     ULONG i;
 124     struct LinuxArmProcessor *data = NULL;
 125
 126     HostLibBase = OpenResource("hostlib.resource");
 127     if (!HostLibBase)
 128         return FALSE;
 129
 130     libc = HostLib_Open(LIBC_NAME, NULL);
 131     if (!libc)
 132         return FALSE;
 133
 134     iface = (struct LibCInterface *)HostLib_GetInterface(libc, libc_symbols, &i);
 135     if (iface)
 136     {
 137         if (!i)
 138         {
 139             char *buf = AllocMem(BUFFER_SIZE, MEMF_ANY);
 140
 141             if (buf)
 142             {
 143                 data = AllocMem(sizeof(struct LinuxArmProcessor), MEMF_CLEAR);
 144                 if (data)
 145                 {
 146                     UWORD variant  = 0;
 147                     UWORD revision = 0;
 148                     void *file;
 149
 150                     HostLib_Lock();
 151                     file = iface->fopen("/proc/cpuinfo", "r");
 152                     HostLib_Unlock();
 153
 154                     if (file)
 155                     {
 156                         char *res;
 157
 158                         do
 159                         {
 160                             HostLib_Lock();
 161                             res = iface->fgets(buf, BUFFER_SIZE - 1, file);
 162                             HostLib_Unlock();
 163
 164                             if (res)
 165                             {
 166                                 char *val;
 167
 168                                 i = strlen(buf);
 169                                 if (i)
 170                                 {
 171                                     /* Strip the newline */
 172                                     i--;
 173                                     if (buf[i] == 0x0A)
 174                                         buf[i] = 0;
 175
 176                                     if ((val = getval("Processor", buf)))
 177                                     {
 178                                         data->Model = StrDup(val);
 179                                     }
 180                                     else if ((val = getval("Features", buf)))
 181                                     {
 182                                         data->Features = ParseFlags(val, feature_ids);
 183                                     }
 184                                     else if ((val = getval("CPU implementer", buf)))
 185                                     {
 186                                         data->Implementer = strtoul(val, NULL, 0);
 187                                     }
 188                                     else if ((val = getval("CPU architecture", buf)))
 189                                     {
 190                                         ULONG family;
 191
 192                                         for (family = 0; arch_ids[family]; family++)
 193                                         {
 194                                             if (!strcmp(arch_ids[family], val))
 195                                             {
 196                                                 data->Arch = family + CPUFAMILY_ARM_3;
 197                                                 break;
 198                                             }
 199                                         }
 200                                     }
 201                                     else if ((val = getval("CPU variant", buf)))
 202                                     {
 203                                         variant = strtoul(val, NULL, 0);
 204                                     }
 205                                     else if ((val = getval("CPU part", buf)))
 206                                     {
 207                                         data->Part = strtoul(val, NULL, 0);
 208                                     }
 209                                     else if ((val = getval("CPU revision", buf)))
 210                                     {
 211                                         revision = strtoul(val, NULL, 0);
 212                                     }
 213                                 }
 214                             }
 215                         } while (res);
 216
 217                         HostLib_Lock();
 218                         iface->fclose(file);
 219                         HostLib_Unlock();
 220                     }
 221                     data->Version = (revision << 16) | variant;
 222
 223                     /* Hack for qemu-arm support */
 224                     if (data->Arch == 0) {
 225                         data->Arch = CPUFAMILY_ARM_6;
 226                         data->Features |= FF_VFP;
 227                     }
 228                 }
 229
 230                 FreeMem(buf, BUFFER_SIZE);
 231             }
 232         }
 233         HostLib_DropInterface((void **)iface);
 234     }
 235
 236     HostLib_Close(libc, NULL);
 237
 238     ProcessorBase->Private1 = data;
 239     if (data)
 240     {
 241         if (data->Features & (FF_VFP | FF_VFPv3))
 242         {
 243             /*
 244              * Perhaps rather late, but i really would not like to duplicate this
 245              * code in kernel.resource.
 246              * Actually this definition can be used only by math code, i hope no
 247              * floating-point operations are performed at early startup.
 248              */
 249             SysBase->AttnFlags |= AFF_FPU;
 250         }
 251         return TRUE;
 252     }
 253     else
 254         return FALSE;
 255 }
 256
 257 ADD2INITLIB(arch_Init, 1);