workbench/tools/ShowConfig/ShowConfig.c

   1 #include <aros/kernel.h>
   2 #include <exec/execbase.h>
   3 #include <exec/memory.h>
   4 #include <resources/hpet.h>
   5 #include <resources/processor.h>
   6
   7 #include <proto/aros.h>
   8 #include <proto/hpet.h>
   9 #include <proto/kernel.h>
  10 #include <proto/exec.h>
  11 #include <proto/utility.h>
  12 #include <proto/processor.h>
  13
  14 #include <stdio.h>
  15
  16 #include "cpuspecific.h"
  17
  18 APTR ProcessorBase = NULL;
  19 char execextra[100];
  20
  21 ULONG ExtUDivMod32(ULONG a, ULONG b, ULONG *mod)
  22 {
  23     *mod = a % b;
  24
  25     return a/b;
  26 }
  27
  28 void PrintNum(ULONG num)
  29 {
  30     /* MBytes ? */
  31     if(num > 1023)
  32     {
  33         ULONG  x, xx;
  34         char* fmt = "meg";
  35
  36         /* GBytes ? */
  37         if(num > 0xfffff)
  38         {
  39             num >>= 10;
  40             fmt = "gig";
  41         }
  42
  43         num = ExtUDivMod32(UMult32(num, 100) >> 10, 100, &x);
  44
  45         /* round */
  46         x = ExtUDivMod32(x, 10, &xx);
  47
  48         if(xx > 4)
  49         {
  50             if(++x > 9)
  51             {
  52                 x = 0;
  53                 num++;
  54             }
  55         }
  56
  57         printf("%d.%d %s", (int)num, (int)x, fmt);
  58     }
  59     else
  60     {
  61         printf("%d K", (int)num);
  62     }
  63 }
  64
  65 ULONG ComputeKBytes(APTR a, APTR b)
  66 {
  67     IPTR result = b - a;
  68
  69     return (ULONG)(result >> 10);
  70 }
  71
  72 static ULONG GetProcessorsCount()
  73 {
  74     ULONG count = 0;
  75     struct TagItem tags [] =
  76     {
  77         {GCIT_NumberOfProcessors, (IPTR)&count},
  78         {TAG_DONE, TAG_DONE}
  79     };
  80
  81     GetCPUInfo(tags);
  82
  83     return count;
  84 }
  85
  86 struct
  87 {
  88     ULONG Architecture;
  89     STRPTR Description;
  90 } ProcessorArchitecture [] =
  91 {
  92     { PROCESSORARCH_UNKNOWN, "Unknown" },
  93     { PROCESSORARCH_M68K, "Motorola 68K" },
  94     { PROCESSORARCH_PPC, "PowerPC" },
  95     { PROCESSORARCH_X86, "X86" },
  96     { PROCESSORARCH_ARM, "ARM" },
  97     { 0, NULL }
  98 };
  99
 100 struct
 101 {
 102     ULONG Endianness;
 103     STRPTR Description;
 104 } CurrentEndianness [] =
 105 {
 106     { ENDIANNESS_UNKNOWN, "Unknown" },
 107     { ENDIANNESS_LE, "LE" },
 108     { ENDIANNESS_BE, "BE" },
 109     { 0, NULL}
 110 };
 111
 112 static VOID PrintProcessorInformation()
 113 {
 114     ULONG count = GetProcessorsCount();
 115     ULONG i, j;
 116     CONST_STRPTR modelstring;
 117     ULONG architecture, endianness;
 118     CONST_STRPTR architecturestring = "", endiannessstring = "";
 119     UQUAD cpuspeed;
 120
 121     for (i = 0; i < count; i++)
 122     {
 123         struct TagItem tags [] =
 124         {
 125             {GCIT_SelectedProcessor, i},
 126             {GCIT_ModelString, (IPTR)&modelstring},
 127             {GCIT_Architecture, (IPTR)&architecture},
 128             {GCIT_Endianness, (IPTR)&endianness},
 129             {GCIT_ProcessorSpeed, (IPTR)&cpuspeed},
 130             {TAG_DONE, TAG_DONE}
 131         };
 132
 133         GetCPUInfo(tags);
 134
 135         j = 0;
 136         while(ProcessorArchitecture[j].Description != NULL)
 137         {
 138             if (ProcessorArchitecture[j].Architecture == architecture)
 139             {
 140                 architecturestring = ProcessorArchitecture[j].Description;
 141                 break;
 142             }
 143             j++;
 144         }
 145
 146         j = 0;
 147         while(CurrentEndianness[j].Description != NULL)
 148         {
 149             if (CurrentEndianness[j].Endianness == endianness)
 150             {
 151                 endiannessstring = CurrentEndianness[j].Description;
 152                 break;
 153             }
 154             j++;
 155         }
 156
 157         if (!modelstring)
 158             modelstring = "Unknown";
 159
 160         printf("PROCESSOR %d:\t[%s/%s] %s", (int)(i + 1), architecturestring, endiannessstring, modelstring);
 161         if (cpuspeed)
 162             printf(" (%llu MHz)", (unsigned long long)(cpuspeed / 1000000));
 163         printf("\n");
 164
 165         PrintCPUSpecificInfo(i, ProcessorBase);
 166     }
 167 }
 168
 169 int __nocommandline;
 170 char __stdiowin[]="CON://800/400/ShowConfig/AUTO/CLOSE/WAIT";
 171
 172 int main()
 173 {
 174     struct MemHeader *mh;
 175     APTR KernelBase;
 176     APTR HPETBase;
 177     int offset = 0;
 178
 179 #if (__WORDSIZE==64)
 180     sprintf(&execextra[1], "64bit/");
 181     offset = 6;
 182 #endif
 183     if (OpenResource("execlock.resource"))
 184     {
 185         sprintf(&execextra[1 + offset], "SMP Enabled ");
 186         offset += 12;
 187     }
 188
 189     if (offset == 0)
 190         execextra[0]            = '\0';
 191     else
 192     {
 193         execextra[0]            = '[';
 194         execextra[offset]       = ']';
 195     }
 196
 197     printf("VERS:\t\tAROS version %d.%d, Exec version %d.%d %s\n", ArosBase->lib_Version, ArosBase->lib_Revision,
 198            SysBase->LibNode.lib_Version, SysBase->LibNode.lib_Revision, execextra);
 199
 200     ProcessorBase = OpenResource(PROCESSORNAME);
 201     if (ProcessorBase)
 202         PrintProcessorInformation();
 203
 204     HPETBase = OpenResource("hpet.resource");
 205     if (HPETBase)
 206     {
 207         const char *owner;
 208         ULONG i = 0;
 209
 210         while (GetUnitAttrs(i, HPET_UNIT_OWNER, &owner, TAG_DONE))
 211         {
 212             if (!owner)
 213                 owner = "Available for use";
 214
 215             printf("HPET %u:\t\t%s\n", (unsigned)(++i), owner);
 216         }
 217     }
 218
 219     printf("RAM:");
 220     for (mh = (struct MemHeader *)SysBase->MemList.lh_Head; mh->mh_Node.ln_Succ; mh = (struct MemHeader *)mh->mh_Node.ln_Succ) {
 221         char *memtype = "ROM";
 222
 223         if (mh->mh_Attributes & MEMF_CHIP)
 224             memtype = "CHIP";
 225         if (mh->mh_Attributes & MEMF_FAST)
 226             memtype = "FAST";
 227         printf("\t\tNode Type 0x%X, Attributes 0x%X (%s), at $%p-$%p (", mh->mh_Node.ln_Type, mh->mh_Attributes, memtype, mh->mh_Lower, mh->mh_Upper - 1);
 228         PrintNum(ComputeKBytes(mh->mh_Lower, mh->mh_Upper));
 229         printf(")\n");
 230     }
 231
 232     KernelBase = OpenResource("kernel.resource");
 233     if (KernelBase)
 234     {
 235         struct TagItem *bootinfo = KrnGetBootInfo();
 236         struct TagItem *tag;
 237
 238         tag = FindTagItem(KRN_BootLoader, bootinfo);
 239         if (tag)
 240             printf("BOOTLDR:\t%s\n", (char *)tag->ti_Data);
 241
 242         tag = FindTagItem(KRN_CmdLine, bootinfo);
 243         if (tag)
 244             printf("ARGS:\t\t%s\n", (char *)tag->ti_Data);
 245
 246     }
 247     return 0;
 248 }