arch/arm-linux/processor/arch_init.c

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