workbench/c/CPUInfo/x86/main.c

   1 /*
   2     Copyright © 2000, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Probe installed x86 compatable CPUs and display relevant information
   6     Lang: english
   7 */
   8
   9 /* BIG TO DO - SEPERATE THE INDIVIDUAL PROCESSOR FAMILY "PROBES" INTO RUNTIME SHARED LIBS OR SIMILAR */
  10
  11 /****************************************************************************************************
  12      Currently Supports:
  13
  14         i386 compatable families...
  15             AMD 486/5x86/K5/K6/K6-II/K6-III/Athlon/Duron/Opteron/Athlon64
  16             Intel P5/P54C/P55C/P24T/P6/P2/P3/PM/Itanium(IA-64)
  17             Cyrix  5x86/M1/MediaGX/M2
  18             UMC
  19             NexGen  Nx586
  20             Centaur  C6/C2/C3
  21             Rise Technology mP6
  22             SiS  55x
  23             Transmeta Crusoe TM3x00 and TM5x00
  24             National Semiconductor  Geode
  25
  26      Soon....
  27
  28         PPC?
  29
  30 *****************************************************************************************************/
  31
  32 #include "x86.h"
  33
  34 /********************************************
  35                     Variables
  36  ********************************************/
  37
  38 ULONG   st_low, st_high, end_low, end_high;
  39
  40 /********************************************/
  41
  42 void    i386_getregs ( char *out, int eax,int ebx,int ecx,int edx )
  43 {
  44     int                     loop;
  45
  46     out[16] = '\0';
  47     for( loop = 0 ; loop < 4 ; loop++ )
  48     {
  49         out[loop] = eax >> (8*loop);
  50         out[loop+4] = ebx >> (8*loop);
  51         out[loop+8] = ecx >> (8*loop);
  52         out[loop+12] = edx >> (8*loop);
  53     }
  54 }
  55
  56 /********************************************/
  57
  58 void    i386_printregs ( int eax,int ebx,int ecx,int edx )
  59 {
  60     char                    *out[17];
  61     i386_getregs( out, eax, ebx, ecx, edx );
  62     printf( out );
  63 }
  64
  65 /********************************************/
  66
  67 int     i386_sprintregs ( int buffpos, char *buffer, int eax,int ebx,int ecx,int edx) /* returns buffer position */
  68 {
  69     char                    *out[17];
  70         ULONG                   size;
  71
  72     i386_getregs( out, eax, ebx, ecx, edx );
  73     size = strlen( out );
  74     AddBufferLine( buffpos, buffer, out );
  75
  76     return  ( buffpos += size );
  77 }
  78
  79 /********************************************/
  80
  81 void    Convert32 (unsigned long value)
  82 {
  83         int                         loop;
  84
  85         for( loop=0 ; loop<32 ; loop++, value <<= 1 )
  86     {
  87                 putchar( ( 1 << 31 & value ) ? '1' : '0' );
  88
  89                 if ( loop == 23 || loop == 15 || loop == 7 )    putchar(' ');
  90         }
  91         putchar('\n');
  92 }
  93
  94 /********************************************/
  95
  96 void    Convert64(unsigned long long value)
  97 {
  98         Convert32 ( value >> 32 );
  99         printf ("           ");
 100         Convert32 ( value );
 101 }
 102
 103 /********************************************/
 104
 105 void    i386_Parse_MSR ( unsigned int msr, int size)
 106 {
 107         unsigned long               msrvala=0,msrvalb=0;
 108     unsigned long long          msrres;
 109
 110     i386_rdmsr( msr, msrvala, msrvalb );
 111     msrres = ( ( msrvalb << 32 ) | msrvala );
 112
 113         if ( msrres  == 1 )
 114     {
 115                 printf ( "MSR: 0x%08x=0x%08llx : ", msr, msrres );
 116                 if ( size == 32 ) Convert32( msrres );
 117                 if ( size == 64 ) Convert64( msrres );
 118                 return;
 119         }
 120         printf ("  Couldn't read MSR 0x%x\n", msr );
 121 }
 122
 123 /********************************************/
 124
 125 #define TICKS (65536 - 8271)
 126
 127 /* Returns CPU clock in khz */
 128
 129 int     i386_cpuspeed ( void )
 130 {
 131         int                         loops;
 132
 133     Forbid();
 134
 135         /* Setup timer */
 136         outb((inb(0x61) & ~0x02) | 0x01, 0x61);
 137         outb(0xb0, 0x43);
 138         outb(TICKS & 0xff, 0x42);
 139         outb(TICKS >> 8, 0x42);
 140
 141         asm("rdtsc":"=a" (st_low),"=d" (st_high));
 142
 143         loops = 0;
 144
 145         do loops++;
 146         while ((inb(0x61) & 0x20) == 0);
 147
 148         asm( "rdtsc\n\t" "subl st_low,%%eax\n\t" "subl st_high,%%edx\n\t" :"=a" (end_low), "=d" (end_high)      );
 149
 150     Permit();
 151
 152         if (loops < 4 || end_low < 50000) return(-1);                      /* Make sure we have a credible result */
 153
 154         return( end_low/48 );
 155 }
 156
 157 /********************************************/
 158
 159 ULONG    i386_approx_mhz ( void )
 160 {
 161     ULONG                   speed;
 162
 163     printf("    Approximate Clock Frequency = ");
 164
 165     if ((speed = i386_cpuspeed()) > 0)
 166     {
 167         speed += i386_cpuspeed();
 168         speed += i386_cpuspeed();
 169
 170         speed /= 3;                                                 /* get an average for better results */
 171
 172         if (speed < 1000000)
 173         {
 174                         speed += 50;                                            /* for rounding         */
 175
 176             printf("%d.%02d Mhz\n",speed/1000,(speed/100)%10);
 177                 }
 178         else
 179         {
 180                         speed += 500;                                           /* for rounding         */
 181             printf("%d Mhz\n",speed/1000);
 182                 }
 183         }
 184     return speed;
 185 }
 186
 187 /********************************************
 188         PARSE INTEL 386 COMPATABLEs
 189  ********************************************/
 190
 191 void    parse_i386 ( struct i386_compat_intern * CPUi386, ULONG CPU_ID )
 192 {
 193     unsigned long           li,maxi,maxei,ebx,ecx,edx,unused;
 194     char                    *strVendor;
 195     int                     i;
 196
 197     /* . Display what we know from the CPUs i386 private structure .. */
 198     printf("\nProcessor internal (private) for i386 compatable\n");
 199     printf("(stored @  %p)\n\n",CPUi386);
 200
 201 /*    printf("    intern.x86             : %p\n",CPUi386->x86);
 202     printf("    intern.x86_vendor      : %p\n",CPUi386->x86_vendor);
 203     printf("    intern.x86_model       : %p\n",CPUi386->x86_model);
 204     printf("    intern.x86_mask        : %08x\n",CPUi386->x86_mask);
 205     printf("    intern.x86_hard_math   : %p\n",CPUi386->x86_hard_math);
 206     printf("    intern.x86_cpuid       : %08x\n",CPUi386->x86_cpuid);
 207     printf("    intern.x86_capability  : %08x\n",CPUi386->x86_capability); */
 208
 209     strVendor = &CPUi386->x86_vendor_id;
 210
 211 #warning TODO: Insert code to verify CPUID instruction availability
 212
 213     i386_cpuid(0,maxi,unused,unused,unused);
 214     maxi &= 0xffff;                                                     /* The high-order word is non-zero on some Cyrix CPUs */
 215
 216     /* Max CPUID level supported &  Vendor Name */
 217     i386_cpuid(0,unused,ebx,ecx,edx);
 218
 219     printf("    Vendor ID: \"");
 220     for(i=0;i<4;i++) putchar(ebx >> (8*i));
 221     for(i=0;i<4;i++) putchar(edx >> (8*i));
 222     for(i=0;i<4;i++) putchar(ecx >> (8*i));
 223     printf("\"; CPUID level %ld\n\n",maxi);
 224
 225 /* Use the first 4 letters of the vender string to ID our processor.. */
 226
 227 /*
 228
 229         EBX-EDX-ECX             Vendor
 230
 231         "AuthenticAMD"        AMD processor
 232         "GenuineIntel"        Intel processor
 233         "CyrixInstead"        Cyrix processor
 234         "UMC UMC UMC "        UMC processor
 235         "NexGenDriven"        NexGen processor
 236         "CentaurHauls"        Centaur processor
 237         "RiseRiseRise"        Rise Technology processor
 238         "SiS SiS SiS "        SiS processor
 239         "GenuineTMx86"        Transmeta processor
 240         "Geode by NSC"        National Semiconductor processor
 241 */
 242
 243     switch(ebx)
 244     {
 245     case 0x68747541:                                                    /* AMD processor */
 246         parse_i386_AMD(maxi, CPUi386);
 247         break;
 248
 249     case 0x756e6547:
 250         switch(ecx)
 251         {
 252         case 0x6c65746e:
 253             parse_i386_Intel(maxi, CPUi386);                                /* Intel processor */
 254             break;
 255         case 0x756e6547:
 256             parse_i386_Transmeta(maxi, CPUi386);                        /* Transmeta processor */
 257             break;
 258         }
 259
 260     case 0x69727943:                                                    /* Cyrix processor */
 261         parse_i386_Cyrix(maxi, CPUi386);
 262         break;
 263
 264     //case 0x68747541:                                                    /* UMC processor */
 265     //    parse_i386_UMC(maxi, CPUi386);
 266     //    break;
 267
 268     //case 0x756e6547:                                                    /* NexGen processor */
 269     //    parse_i386_NexGen(maxi, CPUi386);
 270     //    break;
 271
 272     //case 0x69727943:                                                    /* Centaur processor */
 273     //    parse_i386_Centaur(maxi, CPUi386);
 274     //    break;
 275
 276     //case 0x68747541:                                                    /* Rise Technology processor */
 277     //    parse_i386_Rise(maxi, CPUi386);
 278     //    break;
 279
 280     //case 0x756e6547:                                                    /* SiS processor  */
 281     //    parse_i386_SiS(maxi, CPUi386);
 282     //    break;
 283
 284     //case 0x69727943:                                                    /* National Semiconductor processor */
 285     //    parse_i386_NSC(maxi, CPUi386);
 286     //    break;
 287
 288     default:
 289         printf("Unknown vendor\n");
 290         break;
 291     }
 292
 293     /* Dump all the CPUID results in raw hex */
 294     printf("\n    Raw CPUID Dump:\n    ---------------\n\n");
 295     printf("         eax in    eax      ebx      ecx      edx\n");
 296
 297     for(i=0;i<=maxi;i++)
 298     {
 299         unsigned long eax,ebx,ecx,edx;
 300
 301         i386_cpuid(i,eax,ebx,ecx,edx);
 302         printf("        %08x %08lx %08lx %08lx %08lx\n",i,eax,ebx,ecx,edx);
 303     }
 304
 305     i386_cpuid(0x80000000,maxei,unused,unused,unused);
 306
 307     for(li=0x80000000;li<=maxei;li++)
 308     {
 309         unsigned long eax,ebx,ecx,edx;
 310
 311         i386_cpuid(li,eax,ebx,ecx,edx);
 312         printf("        %08lx %08lx %08lx %08lx %08lx\n",li,eax,ebx,ecx,edx);
 313     }
 314     printf("\n");
 315 }
 316
 317 /********************************************
 318     Transmeta  specific information
 319  ********************************************/
 320
 321 void    parse_i386_Transmeta( int maxi, struct i386_compat_intern * CPUi386 )
 322 {
 323
 324     struct  CPU_INTERN_DATA *global;
 325     ULONG                   speed, maxei,unused;
 326     int                     family = 0;
 327     char                    *BUFF_STR;
 328
 329     if ((global = AllocMem(sizeof(struct CPU_INTERN_DATA),MEMF_PUBLIC|MEMF_CLEAR)))
 330     {
 331         //if ( maxi >= 3 )                                                                   /* Crusoe CPU serial number */
 332         //{
 333         //  unsigned long signature,unused,ebx;
 334
 335         //  i386_cpuid(3,unused,ebx,unused,unused);
 336
 337         //  Intel_CPU_NAME_cnt = AddBufferLine(Intel_CPU_NAME_cnt, Intel_CPU_NAME, "    Processor serial: ");
 338
 339         //  sprintf( BUFF_STR,"-%04lX",ebx >> 16);
 340         //  Intel_CPU_NAME_cnt = AddBufferLine(Intel_CPU_NAME_cnt, Intel_CPU_NAME, BUFF_STR);
 341         //  sprintf( BUFF_STR,"-%04lX",ebx & 0xffff);
 342         //  Intel_CPU_NAME_cnt = AddBufferLine(Intel_CPU_NAME_cnt, Intel_CPU_NAME, BUFF_STR);
 343
 344         //}
 345             speed = i386_approx_mhz();
 346         }
 347     else
 348     {
 349         printf( "ERROR: Couldn't allocate memory to parse CPU information .." );
 350         return;
 351     }
 352     FreeMem(global,sizeof(struct CPU_INTERN_DATA));
 353
 354 }
 355
 356 /********************************************
 357        UMC  specific information
 358  ********************************************/
 359
 360 void    parse_i386_UMC( int maxi, struct i386_compat_intern * CPUi386 )
 361 {
 362
 363     struct  CPU_INTERN_DATA *global;
 364     ULONG                   speed, maxei,unused;
 365     int                     family = 0;
 366     char                    *BUFF_STR;
 367
 368     if ((global = AllocMem(sizeof(struct CPU_INTERN_DATA),MEMF_PUBLIC|MEMF_CLEAR)))
 369     {
 370             speed = i386_approx_mhz();
 371     }
 372     else
 373     {
 374         printf( "ERROR: Couldn't allocate memory to parse CPU information .." );
 375         return;
 376     }
 377     FreeMem(global,sizeof(struct CPU_INTERN_DATA));
 378
 379 }
 380
 381 /********************************************
 382      NexGen  specific information
 383  ********************************************/
 384
 385 void    parse_i386_NexGen( int maxi, struct i386_compat_intern * CPUi386 )
 386 {
 387
 388     struct  CPU_INTERN_DATA *global;
 389     ULONG                   speed, maxei,unused;
 390     int                     family = 0;
 391     char                    *BUFF_STR;
 392
 393     if ((global = AllocMem(sizeof(struct CPU_INTERN_DATA),MEMF_PUBLIC|MEMF_CLEAR)))
 394     {
 395             speed = i386_approx_mhz();
 396     }
 397     else
 398     {
 399         printf( "ERROR: Couldn't allocate memory to parse CPU information .." );
 400         return;
 401     }
 402     FreeMem(global,sizeof(struct CPU_INTERN_DATA));
 403
 404 }
 405
 406 /********************************************
 407      Centaur  specific information
 408  ********************************************/
 409
 410 void    parse_i386_Centaur( int maxi, struct i386_compat_intern * CPUi386 )
 411 {
 412
 413     struct  CPU_INTERN_DATA *global;
 414     ULONG                   speed, maxei,unused;
 415     int                     family = 0;
 416     char                    *BUFF_STR;
 417
 418     if ((global = AllocMem(sizeof(struct CPU_INTERN_DATA),MEMF_PUBLIC|MEMF_CLEAR)))
 419     {
 420             speed = i386_approx_mhz();
 421     }
 422     else
 423     {
 424         printf( "ERROR: Couldn't allocate memory to parse CPU information .." );
 425         return;
 426     }
 427     FreeMem(global,sizeof(struct CPU_INTERN_DATA));
 428
 429 }
 430
 431 /********************************************
 432            SiS  specific information
 433  ********************************************/
 434
 435 void    parse_i386_SiS( int maxi, struct i386_compat_intern * CPUi386 )
 436 {
 437
 438     struct  CPU_INTERN_DATA *global;
 439     ULONG                   speed, maxei,unused;
 440     int                     family = 0;
 441     char                    *BUFF_STR;
 442
 443     if ((global = AllocMem(sizeof(struct CPU_INTERN_DATA),MEMF_PUBLIC|MEMF_CLEAR)))
 444     {
 445             speed = i386_approx_mhz();
 446     }
 447     else
 448     {
 449         printf( "ERROR: Couldn't allocate memory to parse CPU information .." );
 450         return;
 451     }
 452     FreeMem(global,sizeof(struct CPU_INTERN_DATA));
 453
 454 }
 455