workbench/c/CPUInfo/x86.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 = ( ( (unsigned long long)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 = (char *)&CPUi386->x86_vendor_id;
 210
 211 /* TODO: Insert code to verify CPUID instruction availability */
 212     (void)strVendor;
 213
 214     i386_cpuid(0,maxi,unused,unused,unused);
 215     maxi &= 0xffff;                                                     /* The high-order word is non-zero on some Cyrix CPUs */
 216
 217     /* Max CPUID level supported &  Vendor Name */
 218     i386_cpuid(0,unused,ebx,ecx,edx);
 219
 220     printf("    Vendor ID: \"");
 221     for(i=0;i<4;i++) putchar(ebx >> (8*i));
 222     for(i=0;i<4;i++) putchar(edx >> (8*i));
 223     for(i=0;i<4;i++) putchar(ecx >> (8*i));
 224     printf("\"; CPUID level %ld\n\n",maxi);
 225
 226 /* Use the first 4 letters of the vender string to ID our processor.. */
 227
 228 /*
 229
 230         EBX-EDX-ECX             Vendor
 231
 232         "AuthenticAMD"        AMD processor
 233         "GenuineIntel"        Intel processor
 234         "CyrixInstead"        Cyrix processor
 235         "UMC UMC UMC "        UMC processor
 236         "NexGenDriven"        NexGen processor
 237         "CentaurHauls"        Centaur processor
 238         "RiseRiseRise"        Rise Technology processor
 239         "SiS SiS SiS "        SiS processor
 240         "GenuineTMx86"        Transmeta processor
 241         "Geode by NSC"        National Semiconductor processor
 242 */
 243
 244     switch(ebx)
 245     {
 246     case 0x68747541:                                                    /* AMD processor */
 247         parse_i386_AMD(maxi, CPUi386);
 248         break;
 249
 250     case 0x756e6547:
 251         switch(ecx)
 252         {
 253         case 0x6c65746e:
 254             parse_i386_Intel(maxi, CPUi386);                                /* Intel processor */
 255             break;
 256         case 0x756e6547:
 257             parse_i386_Transmeta(maxi, CPUi386);                        /* Transmeta processor */
 258             break;
 259         }
 260
 261     case 0x69727943:                                                    /* Cyrix processor */
 262         parse_i386_Cyrix(maxi, CPUi386);
 263         break;
 264
 265     //case 0x68747541:                                                    /* UMC processor */
 266     //    parse_i386_UMC(maxi, CPUi386);
 267     //    break;
 268
 269     //case 0x756e6547:                                                    /* NexGen processor */
 270     //    parse_i386_NexGen(maxi, CPUi386);
 271     //    break;
 272
 273     //case 0x69727943:                                                    /* Centaur processor */
 274     //    parse_i386_Centaur(maxi, CPUi386);
 275     //    break;
 276
 277     //case 0x68747541:                                                    /* Rise Technology processor */
 278     //    parse_i386_Rise(maxi, CPUi386);
 279     //    break;
 280
 281     //case 0x756e6547:                                                    /* SiS processor  */
 282     //    parse_i386_SiS(maxi, CPUi386);
 283     //    break;
 284
 285     //case 0x69727943:                                                    /* National Semiconductor processor */
 286     //    parse_i386_NSC(maxi, CPUi386);
 287     //    break;
 288
 289     default:
 290         printf("Unknown vendor\n");
 291         break;
 292     }
 293
 294     /* Dump all the CPUID results in raw hex */
 295     printf("\n    Raw CPUID Dump:\n    ---------------\n\n");
 296     printf("         eax in    eax      ebx      ecx      edx\n");
 297
 298     for(i=0;i<=maxi;i++)
 299     {
 300         unsigned long eax,ebx,ecx,edx;
 301
 302         i386_cpuid(i,eax,ebx,ecx,edx);
 303         printf("        %08x %08lx %08lx %08lx %08lx\n",i,eax,ebx,ecx,edx);
 304     }
 305
 306     i386_cpuid(0x80000000,maxei,unused,unused,unused);
 307
 308     for(li=0x80000000;li<=maxei;li++)
 309     {
 310         unsigned long eax,ebx,ecx,edx;
 311
 312         i386_cpuid(li,eax,ebx,ecx,edx);
 313         printf("        %08lx %08lx %08lx %08lx %08lx\n",li,eax,ebx,ecx,edx);
 314     }
 315     printf("\n");
 316 }
 317
 318 /********************************************
 319     Transmeta  specific information
 320  ********************************************/
 321
 322 void    parse_i386_Transmeta( int maxi, struct i386_compat_intern * CPUi386 )
 323 {
 324
 325     struct  CPU_INTERN_DATA *global;
 326     ULONG                   speed;
 327     //ULONG                   maxei,unused;
 328     //int                     family = 0;
 329     //char                    *BUFF_STR;
 330
 331     if ((global = AllocMem(sizeof(struct CPU_INTERN_DATA),MEMF_PUBLIC|MEMF_CLEAR)))
 332     {
 333         //if ( maxi >= 3 )                                                                   /* Crusoe CPU serial number */
 334         //{
 335         //  unsigned long signature,unused,ebx;
 336
 337         //  i386_cpuid(3,unused,ebx,unused,unused);
 338
 339         //  Intel_CPU_NAME_cnt = AddBufferLine(Intel_CPU_NAME_cnt, Intel_CPU_NAME, "    Processor serial: ");
 340
 341         //  sprintf( BUFF_STR,"-%04lX",ebx >> 16);
 342         //  Intel_CPU_NAME_cnt = AddBufferLine(Intel_CPU_NAME_cnt, Intel_CPU_NAME, BUFF_STR);
 343         //  sprintf( BUFF_STR,"-%04lX",ebx & 0xffff);
 344         //  Intel_CPU_NAME_cnt = AddBufferLine(Intel_CPU_NAME_cnt, Intel_CPU_NAME, BUFF_STR);
 345
 346         //}
 347             speed = i386_approx_mhz();
 348             (void)speed;
 349         }
 350     else
 351     {
 352         printf( "ERROR: Couldn't allocate memory to parse CPU information .." );
 353         return;
 354     }
 355     FreeMem(global,sizeof(struct CPU_INTERN_DATA));
 356
 357 }
 358
 359 /********************************************
 360        UMC  specific information
 361  ********************************************/
 362
 363 void    parse_i386_UMC( int maxi, struct i386_compat_intern * CPUi386 )
 364 {
 365
 366     struct  CPU_INTERN_DATA *global;
 367     ULONG                   speed;
 368
 369     if ((global = AllocMem(sizeof(struct CPU_INTERN_DATA),MEMF_PUBLIC|MEMF_CLEAR)))
 370     {
 371             speed = i386_approx_mhz();
 372             (void)speed;
 373     }
 374     else
 375     {
 376         printf( "ERROR: Couldn't allocate memory to parse CPU information .." );
 377         return;
 378     }
 379     FreeMem(global,sizeof(struct CPU_INTERN_DATA));
 380
 381 }
 382
 383 /********************************************
 384      NexGen  specific information
 385  ********************************************/
 386
 387 void    parse_i386_NexGen( int maxi, struct i386_compat_intern * CPUi386 )
 388 {
 389
 390     struct  CPU_INTERN_DATA *global;
 391     //ULONG                   speed;
 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;
 415
 416     if ((global = AllocMem(sizeof(struct CPU_INTERN_DATA),MEMF_PUBLIC|MEMF_CLEAR)))
 417     {
 418             //speed = i386_approx_mhz();
 419     }
 420     else
 421     {
 422         printf( "ERROR: Couldn't allocate memory to parse CPU information .." );
 423         return;
 424     }
 425     FreeMem(global,sizeof(struct CPU_INTERN_DATA));
 426
 427 }
 428
 429 /********************************************
 430            SiS  specific information
 431  ********************************************/
 432
 433 void    parse_i386_SiS( int maxi, struct i386_compat_intern * CPUi386 )
 434 {
 435
 436     struct  CPU_INTERN_DATA *global;
 437     ULONG                   speed;
 438
 439     if ((global = AllocMem(sizeof(struct CPU_INTERN_DATA),MEMF_PUBLIC|MEMF_CLEAR)))
 440     {
 441             speed = i386_approx_mhz();
 442             (void)speed;
 443     }
 444     else
 445     {
 446         printf( "ERROR: Couldn't allocate memory to parse CPU information .." );
 447         return;
 448     }
 449     FreeMem(global,sizeof(struct CPU_INTERN_DATA));
 450
 451 }
 452