workbench/libs/identify/idhardware.c

   1 /*
   2  * Copyright (c) 2010-2011 Matthias Rustler
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included
  12  * in all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  15  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  17  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  19  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  20  * IN THE SOFTWARE.
  21  *
  22  * $Id$
  23  */
  24
  25 #include <resources/processor.h>
  26
  27 #include <proto/utility.h>
  28 #include <proto/processor.h>
  29
  30 #include <stdio.h>
  31 #include <string.h>
  32
  33 #include "identify_intern.h"
  34 #include "identify.h"
  35 #include "locale.h"
  36
  37 #include <aros/debug.h>
  38
  39 static CONST_STRPTR handle_version(TEXT *buffer, Tag tag);
  40 static CONST_STRPTR handle_size(TEXT *buffer, Tag tag);
  41 static CONST_STRPTR handle_freq(TEXT *buffer, Tag tag);
  42 static CONST_STRPTR handle_mhz(TEXT *buffer, Tag tag);
  43 static CONST_STRPTR handle_number(TEXT *buffer, Tag tag);
  44 static CONST_STRPTR handle_address(TEXT *buffer, Tag tag);
  45 static CONST_STRPTR handle_hex(TEXT *buffer, Tag tag);
  46 static CONST_STRPTR handle_avail(Tag tag, BOOL null4na);
  47 static CONST_STRPTR handle_notavail(BOOL null4na);
  48
  49 /*****************************************************************************
  50
  51     NAME */
  52 #include <proto/identify.h>
  53
  54         AROS_LH2(CONST_STRPTR, IdHardware,
  55
  56 /*  SYNOPSIS */
  57         AROS_LHA(ULONG           , type   , D0),
  58         AROS_LHA(struct TagItem *, taglist, A0),
  59
  60 /*  LOCATION */
  61         struct IdentifyBaseIntern *, IdentifyBase, 6, Identify)
  62
  63 /*  FUNCTION
  64         Gets information about the current system environment. The result
  65         is returned as read only string. This function is fully DraCo
  66         compatible!
  67
  68         Once a information has been evaluated, it will be cached internally,
  69         so changes will be ignored. Use IdHardwareUpdate() to clear the cache
  70         contents.
  71
  72     INPUTS
  73        Type -- (ULONG) Information type. These types are known:
  74
  75                IDHW_SYSTEM     -- What system is used?
  76                (e. g. "Amiga 4000")
  77
  78                IDHW_CPU        -- What kind of CPU is available?
  79                (e. g. "68060")
  80
  81                IDHW_FPU        -- What kind of FPU is available?
  82                (e. g. "68060")
  83
  84                IDHW_MMU        -- What kind of MMU is available?
  85                (e. g. "68060")
  86
  87                IDHW_OSVER      -- What OS version is used?
  88                (e.g. "V39.106")
  89
  90                IDHW_EXECVER    -- What exec version is used?
  91                (e.g. "V39.47")
  92
  93                IDHW_WBVER      -- What WorkBench version is used?
  94                (e.g. "V39.29")
  95
  96                IDHW_ROMSIZE    -- Size of AmigaOS ROM
  97                (e.g. "512KB")
  98
  99                IDHW_CHIPSET    -- What Chipset is available?
 100                (e.g. "AGA")
 101
 102                IDHW_GFXSYS     -- What Graphic OS is used?
 103                (e.g. "CyberGraphX")
 104
 105                IDHW_CHIPRAM    -- Size of complete Chip RAM
 106                (e.g. "~2.0MB")
 107
 108                IDHW_FASTRAM    -- Size of complete Fast RAM
 109                (e.g. "12.0MB")
 110
 111                IDHW_RAM        -- Size of complete System RAM
 112                (e.g. "~14.0MB")
 113
 114                IDHW_SETPATCHVER -- [V4] Version of current SetPatch
 115                (e.g. "V40.14")
 116
 117                IDHW_AUDIOSYS   -- [V5] What Audio OS is used?
 118                (e.g. "AHI")
 119
 120                IDHW_OSNR       -- [V5] What AmigaOS is used?
 121                (e.g. "3.1")
 122
 123                IDHW_VMMCHIPRAM -- [V5] Size of virtual Chip RAM
 124                (e.g. "0")
 125
 126                IDHW_VMMFASTRAM -- [V5] Size of virtual Fast RAM
 127                (e.g. "40.0MB")
 128
 129                IDHW_VMMRAM     -- [V5] Size of total virtual RAM
 130                (e.g. "40.0MB")
 131
 132                IDHW_PLNCHIPRAM -- [V5] Size of non-virtual Chip RAM
 133                (e.g. "2.0MB")
 134
 135                IDHW_PLNFASTRAM -- [V5] Size of non-virtual Fast RAM
 136                (e.g. "12.0MB")
 137
 138                IDHW_PLNRAM     -- [V5] Size of total non-virtual RAM
 139                (e.g. "14.0MB")
 140
 141                IDHW_VBR        -- [V6] Vector Base Register contents
 142                (e.g. "0x0806C848")
 143
 144                IDHW_LASTALERT  -- [V6] Last Alert code
 145                (e.g. "80000003")
 146
 147                IDHW_VBLANKFREQ -- [V6] VBlank frequency (see execbase.h)
 148                (e.g. "50 Hz")
 149
 150                IDHW_POWERFREQ  -- [V6] Power supply frequency (see execbase.h)
 151                (e.g. "50 Hz")
 152
 153                IDHW_ECLOCK     -- [V6] System E clock frequency
 154                (e.g. "709379 Hz")
 155
 156                IDHW_SLOWRAM    -- [V6] A500/A2000 "Slow" RAM expansion
 157                (e.g. "512.0KB")
 158
 159                IDHW_GARY       -- [V6] GARY revision
 160                (e.g. "Normal")
 161
 162                IDHW_RAMSEY     -- [V6] RAMSEY revision
 163                (e.g. "F")
 164
 165                IDHW_BATTCLOCK  -- [V6] Battery backed up clock present?
 166                (e.g. "Found")
 167
 168                IDHW_CHUNKYPLANAR -- [V7] Chunky to planar hardware present?
 169                (e.g. "Found")
 170
 171                IDHW_POWERPC    -- [V7] PowerPC CPU present?
 172                (e.g. "603e")
 173
 174                IDHW_PPCCLOCK   -- [V7] PowerPC processor clock
 175                (e.g. "200 MHz")
 176
 177                IDHW_CPUREV     -- [V8] Revision of the main processor, if
 178                available (e.g. "Rev 1")
 179
 180                IDHW_CPUCLOCK   -- [V8] CPU clock
 181                (e.g. "50 MHz")
 182
 183                IDHW_FPUCLOCK   -- [V8] FPU clock, if available
 184                (e.g. "50 MHz")
 185
 186                IDHW_RAMACCESS  -- [V8] Access time of the main board RAM
 187                (e.g. "80 ns")
 188
 189                IDHW_RAMWIDTH   -- [V8] Width of the main board RAM
 190                (e.g. "16 bit")
 191
 192                IDHW_RAMCAS     -- [V8] CAS mode of the main board RAM
 193                (e.g. "Double")
 194
 195                IDHW_RAMBANDWIDTH -- [V8] Bandwidth of the main board RAM
 196                (e.g. "2")
 197
 198                IDHW_TCPIP      -- [V9] Used TCP/IP stack
 199                (e.g. "AmiTCP/IP")
 200
 201                IDHW_PPCOS      -- [V9] Used PowerPC OS
 202                (e.g. "PowerUp")
 203
 204                IDHW_AGNUS      -- [V9] Agnus chip type and revision
 205                (e.g. "Alice 8374 Rev. 3-4")
 206
 207                IDHW_AGNUSMODE  -- [V9] Agnus chip mode
 208                (e.g. "PAL")
 209
 210                IDHW_DENISE     -- [V10] Denise chip type
 211                (e.g. "Lisa 8364")
 212
 213                IDHW_DENISEREV  -- [V10] Denise chip revision
 214                (e.g. "0")
 215
 216         TagList -- (struct TagItem *) tags that describe further
 217                    options. You may provide NULL.
 218
 219     TAGS
 220         IDTAG_Localize  -- [V8] (BOOL) FALSE to get English strings
 221                            only, TRUE for localized strings. This is useful for applications
 222                            with English as only language. Defaults to TRUE.
 223
 224         IDTAG_NULL4NA   -- [V8] (BOOL) TRUE to get NULL pointer instead
 225                            of a 'not available' string. Defaults to FALSE.
 226
 227     RESULT
 228         String  -- (STRPTR) String containing the desired
 229                    information, or NULL if not available. Note that
 230                    all strings are READ ONLY!
 231
 232     NOTES
 233         Some results are nonsense on AROS.
 234
 235     EXAMPLE
 236
 237     BUGS
 238
 239     SEE ALSO
 240         IdHardwareNum(), IdHardwareUpdate()
 241
 242     INTERNALS
 243
 244     HISTORY
 245
 246
 247 *****************************************************************************/
 248 {
 249     AROS_LIBFUNC_INIT
 250
 251     struct TagItem *tag;
 252     struct TagItem *tags;
 253
 254     CONST_STRPTR result = NULL;
 255     BOOL null4na = FALSE;
 256     BOOL localize = TRUE;
 257
 258     for (tags = taglist; (tag = NextTagItem(&tags)); )
 259     {
 260         switch (tag->ti_Tag)
 261         {
 262             case IDTAG_NULL4NA:
 263                 null4na = tag->ti_Data ? TRUE : FALSE;
 264                 break;
 265
 266             case IDTAG_Localize:
 267                 localize = tag->ti_Data ? TRUE : FALSE;
 268                 break;
 269         }
 270     }
 271
 272     if (localize) {
 273         /* FIXME: Do something here? */
 274     }
 275
 276     ObtainSemaphore(&IdentifyBase->sem);
 277
 278     switch(type)
 279     {
 280         case IDHW_SYSTEM:
 281             result = "AROS";
 282             break;
 283
 284         case IDHW_CPU:
 285         {
 286             IPTR cpu = 0;
 287             APTR ProcessorBase = OpenResource(PROCESSORNAME);
 288
 289             if (ProcessorBase)
 290             {
 291                 struct TagItem tags [] =
 292                 {
 293                     { GCIT_Family, (IPTR)&cpu },
 294                     { TAG_DONE }
 295                 };
 296                 GetCPUInfo(tags);
 297                 switch(cpu)
 298                 {
 299                     case CPUFAMILY_60X: result = "60X"; break;
 300                     case CPUFAMILY_7X0: result = "7X0"; break;
 301                     case CPUFAMILY_74XX: result = "74XX"; break;
 302                     case CPUFAMILY_4XX: result = "4XX"; break;
 303                     case CPUFAMILY_AMD_K5: result = "AMD_K5"; break;
 304                     case CPUFAMILY_AMD_K6: result = "AMD_K6"; break;
 305                     case CPUFAMILY_AMD_K7: result = "AMD_K7"; break;
 306                     case CPUFAMILY_AMD_K8: result = "AMD_K8"; break;
 307                     case CPUFAMILY_AMD_K9: result = "ADM_K9"; break;
 308                     case CPUFAMILY_AMD_K10: result = "AMD_K10"; break;
 309                     case CPUFAMILY_INTEL_486: result = "INTEL_486"; break;
 310                     case CPUFAMILY_INTEL_PENTIUM: result = "INTEL_PENTIUM"; break;
 311                     case CPUFAMILY_INTEL_PENTIUM_PRO: result = "INTEL_PENTIUM_PRO"; break;
 312                     case CPUFAMILY_INTEL_PENTIUM4: result = "INTEL_PENTIUM4"; break;
 313                     case CPUFAMILY_MOTOROLA_68000: result = "MOTOROLA_68000"; break;
 314                     default: result = "unknown"; break;
 315                 }
 316             }
 317             else
 318             {
 319                 result = "unknown";
 320             }
 321             break;
 322         }
 323         case IDHW_FPU:
 324             result = handle_notavail(null4na);
 325             break;
 326
 327         case IDHW_MMU:
 328             result = handle_notavail(null4na);
 329             break;
 330
 331         case IDHW_OSVER:
 332             result = handle_version(IdentifyBase->hwb.buf_OsVer, IDHW_OSVER);
 333             break;
 334
 335         case IDHW_EXECVER:
 336             result = handle_version(IdentifyBase->hwb.buf_ExecVer, IDHW_EXECVER);
 337             break;
 338
 339         case IDHW_WBVER:
 340             result = handle_version(IdentifyBase->hwb.buf_WbVer, IDHW_WBVER);
 341             break;
 342
 343         case IDHW_ROMSIZE:
 344             result = handle_size(IdentifyBase->hwb.buf_RomSize, IDHW_ROMSIZE);
 345             break;
 346
 347         case IDHW_CHIPSET:
 348             result = _(MSG_HW_OCS);
 349             break;
 350
 351         case IDHW_GFXSYS:
 352             result = _(MSG_HW_CYBERGRAPHX);
 353             break;
 354
 355         case IDHW_CHIPRAM:
 356             result = handle_size(IdentifyBase->hwb.buf_ChipRAM, IDHW_CHIPRAM);
 357             break;
 358
 359         case IDHW_FASTRAM:
 360             result = handle_size(IdentifyBase->hwb.buf_FastRAM, IDHW_FASTRAM);
 361             break;
 362
 363         case IDHW_RAM:
 364             result = handle_size(IdentifyBase->hwb.buf_RAM, IDHW_RAM);
 365             break;
 366
 367         case IDHW_SETPATCHVER:
 368             result = handle_version(IdentifyBase->hwb.buf_SetPatchVer, IDHW_SETPATCHVER);
 369             break;
 370
 371         case IDHW_AUDIOSYS:
 372             result = _(MSG_HW_AHI);
 373             break;
 374
 375         case IDHW_OSNR:
 376             result = _(MSG_HW_OS_40);
 377             break;
 378
 379         case IDHW_VMMCHIPRAM:
 380             result = "0";
 381             break;
 382
 383         case IDHW_VMMFASTRAM:
 384             result = "0";
 385             break;
 386
 387         case IDHW_VMMRAM:
 388             result = "0";
 389             break;
 390
 391         case IDHW_PLNCHIPRAM:
 392             result = handle_size(IdentifyBase->hwb.buf_PlainChipRAM, IDHW_PLNCHIPRAM);
 393             break;
 394
 395         case IDHW_PLNFASTRAM:
 396             result = handle_size(IdentifyBase->hwb.buf_PlainFastRAM, IDHW_PLNFASTRAM);
 397             break;
 398
 399         case IDHW_PLNRAM:
 400             result = handle_size(IdentifyBase->hwb.buf_PlainRAM, IDHW_PLNRAM);
 401             break;
 402
 403         case IDHW_VBR:
 404             IdentifyBase->hwb.buf_VBR[0] = '\0'; // not buffered
 405             result = handle_address(IdentifyBase->hwb.buf_VBR, IDHW_VBR);
 406             break;
 407
 408         case IDHW_LASTALERT:
 409             IdentifyBase->hwb.buf_LastAlert[0] = '\0'; // not buffered
 410             result = handle_hex(IdentifyBase->hwb.buf_LastAlert, IDHW_LASTALERT);
 411             break;
 412
 413         case IDHW_VBLANKFREQ:
 414             result = handle_freq(IdentifyBase->hwb.buf_VBlankFreq, IDHW_VBLANKFREQ);
 415             break;
 416
 417         case IDHW_POWERFREQ:
 418             result = handle_freq(IdentifyBase->hwb.buf_PowerFreq, IDHW_POWERFREQ);
 419             break;
 420
 421         case IDHW_ECLOCK:
 422             result = handle_freq(IdentifyBase->hwb.buf_EClock, IDHW_ECLOCK);
 423             break;
 424
 425         case IDHW_SLOWRAM:
 426             result = handle_size(IdentifyBase->hwb.buf_SlowRAM, IDHW_SLOWRAM);
 427             break;
 428
 429         case IDHW_GARY:
 430             result = handle_notavail(null4na);
 431             break;
 432
 433         case IDHW_RAMSEY:
 434             result = handle_notavail(null4na);
 435             break;
 436
 437         case IDHW_BATTCLOCK:
 438             result = handle_avail(IDHW_BATTCLOCK, null4na);
 439             break;
 440
 441         case IDHW_CHUNKYPLANAR:
 442             result = handle_avail(IDHW_CHUNKYPLANAR, null4na);
 443             break;
 444
 445         case IDHW_POWERPC:
 446             result = handle_notavail(null4na);
 447             break;
 448
 449         case IDHW_PPCCLOCK:
 450             result = "0 MHz";
 451             break;
 452
 453         case IDHW_CPUREV:
 454             result = handle_notavail(null4na);
 455             break;
 456
 457         case IDHW_CPUCLOCK:
 458             result = handle_mhz(IdentifyBase->hwb.buf_CPUClock, IDHW_CPUCLOCK);
 459             break;
 460
 461         case IDHW_FPUCLOCK:
 462             result = "0 MHz";
 463             break;
 464
 465         case IDHW_RAMACCESS:
 466             result = handle_notavail(null4na);
 467             break;
 468
 469         case IDHW_RAMWIDTH:
 470             result = handle_number(IdentifyBase->hwb.buf_RAMWidth, IDHW_RAMWIDTH);
 471             break;
 472
 473         case IDHW_RAMCAS:
 474         {
 475             ULONG num = IdHardwareNum(IDHW_RAMCAS, NULL);
 476             if (num == 2)
 477             {
 478                 result = _(MSG_HW_RAMCAS_DOUBLE);
 479             }
 480             else
 481             {
 482                 result = _(MSG_HW_RAMCAS_NORMAL);
 483             }
 484             break;
 485         }
 486
 487         case IDHW_RAMBANDWIDTH:
 488             result = handle_notavail(null4na);
 489             break;
 490
 491         case IDHW_TCPIP:
 492             result = _(MSG_HW_TCPIP_AMITCP);
 493             break;
 494
 495         case IDHW_PPCOS:
 496             result = _(MSG_HW_PPCOS_NONE);
 497             break;
 498
 499         case IDHW_AGNUS:
 500             result = _(MSG_HW_AGNUS_NONE);
 501             break;
 502
 503         case IDHW_AGNUSMODE:
 504             result = _(MSG_HW_AMODE_NONE);
 505             break;
 506
 507         case IDHW_DENISE:
 508             result = _(MSG_HW_DENISE_NONE);
 509             break;
 510
 511         case IDHW_DENISEREV:
 512             result = handle_notavail(null4na);
 513             break;
 514
 515         default:
 516             result = handle_notavail(null4na);
 517             break;
 518     }
 519
 520     ReleaseSemaphore(&IdentifyBase->sem);
 521
 522     return result;
 523
 524     AROS_LIBFUNC_EXIT
 525 } /* IdHardware */
 526
 527
 528 static CONST_STRPTR handle_version(TEXT *buffer, Tag tag)
 529 {
 530     CONST_STRPTR result = buffer;
 531     if (*buffer == '\0')
 532     {
 533         ULONG num = IdHardwareNum(tag, NULL);
 534         if (num != 0 && num != -1)
 535         {
 536             ULONG version = num & 0xffff;
 537             ULONG revision = num >> 16;
 538             snprintf(buffer, STRBUFSIZE, _(MSG_HW_VERSION), version, revision);
 539         }
 540         else
 541         {
 542             strlcpy(buffer, _(MSG_HW_NOVERSION), STRBUFSIZE);
 543         }
 544     }
 545     return result;
 546 }
 547
 548 static CONST_STRPTR handle_size(TEXT *buffer, Tag tag)
 549 {
 550     CONST_STRPTR result = buffer;
 551     CONST_STRPTR format;
 552     UBYTE fraction = 0;
 553
 554     if (*buffer == '\0')
 555     {
 556         UQUAD num = IdHardwareNum(tag, NULL);
 557         if (num < 1000)
 558         {
 559             num *= 10;
 560             format = _(MSG_BYTE);
 561         }
 562         else if (num < 1000 * 1000)
 563         {
 564             num /= 102;
 565             format = _(MSG_KBYTE);
 566         }
 567         else if (num < 1000 * 1000 * 1000)
 568         {
 569             num = num / 1024 / 102;
 570             format = _(MSG_MBYTE);
 571         }
 572         else
 573         {
 574             num = num / 1024 / 1024 / 102;
 575             format = _(MSG_GBYTE);
 576         }
 577         fraction = num % 10;
 578         num /= 10;
 579
 580         snprintf(buffer, STRBUFSIZE, format,
 581             (long unsigned int)num, '0' + fraction);
 582     }
 583     return result;
 584 }
 585
 586 static CONST_STRPTR handle_freq(TEXT *buffer, Tag tag)
 587 {
 588     CONST_STRPTR result = buffer;
 589     if (*buffer == '\0')
 590     {
 591         ULONG num = IdHardwareNum(tag, NULL);
 592         {
 593             snprintf(buffer, STRBUFSIZE, "%u Hz", (unsigned int)num);
 594         }
 595     }
 596     return result;
 597 }
 598
 599 static CONST_STRPTR handle_mhz(TEXT *buffer, Tag tag)
 600 {
 601     CONST_STRPTR result = buffer;
 602     if (*buffer == '\0')
 603     {
 604         ULONG num = IdHardwareNum(tag, NULL);
 605         {
 606             snprintf(buffer, STRBUFSIZE, "%u MHz", (unsigned int)num);
 607         }
 608     }
 609     return result;
 610 }
 611
 612 static CONST_STRPTR handle_number(TEXT *buffer, Tag tag)
 613 {
 614     CONST_STRPTR result = buffer;
 615     if (*buffer == '\0')
 616     {
 617         ULONG num = IdHardwareNum(tag, NULL);
 618         {
 619             snprintf(buffer, STRBUFSIZE, "%u", (unsigned int)num);
 620         }
 621     }
 622     return result;
 623 }
 624
 625 static CONST_STRPTR handle_address(TEXT *buffer, Tag tag)
 626 {
 627     CONST_STRPTR result = buffer;
 628     if (*buffer == '\0')
 629     {
 630         ULONG num = IdHardwareNum(tag, NULL);
 631         {
 632             snprintf(buffer, STRBUFSIZE, "0x%08x", (unsigned int)num);
 633         }
 634     }
 635     return result;
 636 }
 637
 638 static CONST_STRPTR handle_hex(TEXT *buffer, Tag tag)
 639 {
 640     CONST_STRPTR result = buffer;
 641     if (*buffer == '\0')
 642     {
 643         ULONG num = IdHardwareNum(tag, NULL);
 644         {
 645             snprintf(buffer, STRBUFSIZE, "%08x", (unsigned int)num);
 646         }
 647     }
 648     return result;
 649 }
 650
 651 static CONST_STRPTR handle_avail(Tag tag, BOOL null4na)
 652 {
 653     ULONG num = IdHardwareNum(tag, NULL);
 654     if (num)
 655     {
 656         return _(MSG_HW_FOUND);
 657     }
 658     else
 659     {
 660         return handle_notavail(null4na);
 661     }
 662 }
 663
 664 static CONST_STRPTR handle_notavail(BOOL null4na)
 665 {
 666     if (null4na == FALSE)
 667         return _(MSG_HW_NONE);
 668     else
 669         return NULL;
 670 }