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