source: trunk/athena/bin/machtype/machtype_irix.c @ 13614

Revision 13614, 8.5 KB checked in by danw, 24 years ago (diff)
autoconfiscate and warnsify
Line 
1/*
2 *  Machtype: determine machine type & display type
3 *
4 * RCS Info
5 *      $Id: machtype_irix.c,v 1.1 1999-09-22 00:26:49 danw Exp $
6 */
7
8#include <stdio.h>
9#include <string.h>
10#include <sys/param.h>
11#include <sys/types.h>
12#include <sys/file.h>
13#include <sys/sysinfo.h>
14#include <sys/ioctl.h>
15#include <sys/wait.h>
16#include <unistd.h>
17#include "machtype.h"
18
19#include <invent.h>
20#include <sys/sbd.h>
21void do_INV_SCSI(inventory_t *);
22void do_INV_SCSICONTROL(inventory_t *, int);
23void do_INV_DISK(inventory_t *, int);
24void do_INV_PROCESSOR(inventory_t *,int);
25void do_INV_GRAPHICS(inventory_t *);
26void do_INV_CAM(inventory_t *);
27void do_INV_CPUCHIP(inventory_t *);
28
29void do_machtype(void)
30{
31  puts("sgi");
32}
33
34void do_cpu(int verbose)
35{
36  inventory_t *inv;
37  setinvent();
38  inv = getinvent();
39  while (inv) {
40    if (inv->inv_class == INV_PROCESSOR) {
41      do_INV_PROCESSOR(inv, verbose);
42    }
43    inv = getinvent();
44  }
45}
46
47void do_INV_CPUCHIP(inventory_t* i)
48{
49  char* pu_short = (i->inv_type == INV_CPUCHIP)?"CPU":"FPU";
50  char* pu_long = (i->inv_type == INV_CPUCHIP)?
51    "Processor Chip":"Floating Point Coprocessor";
52  int chip = (i->inv_state & C0_IMPMASK) >> C0_IMPSHIFT;
53  int major = (i->inv_state & C0_MAJREVMASK) >> C0_MAJREVSHIFT;
54  int minor = (i->inv_state & C0_MINREVMASK) >> C0_MINREVSHIFT;
55  char* s_chip = 0;
56  switch(chip)
57    {
58    case C0_IMP_R2000:
59      if (major >= C0_MAJREVMIN_R2000A)
60        s_chip = "R2000A";
61      else
62        s_chip = "R2000";
63      break;
64    case C0_IMP_R2000A:
65      if (major >= C0_MAJREVMIN_R3000A)
66        s_chip = "R3000A";
67      else if (major >= C0_MAJREVMIN_R3000)
68        s_chip = "R3000";
69      else
70        s_chip = "R2000A";
71      break;
72    case C0_IMP_R6000:
73      s_chip = "R6000";
74      break;
75    case C0_IMP_R4000:
76      if (major >= C0_MAJREVMIN_R4400)
77        s_chip = "R4400";
78      else
79        s_chip = "R4000";
80      break;
81    case C0_IMP_R6000A:
82      s_chip = "R6000A";
83      break;
84    case C0_IMP_R10000:
85      s_chip = "R10000";
86      break;
87    case C0_IMP_R8000:
88      s_chip = "R8000";
89      break;
90    case C0_IMP_R4600:
91      s_chip = "R4600";
92      break;
93    case C0_IMP_R4700:
94      s_chip = "R4700";
95      break;
96    case C0_IMP_R4650:
97      s_chip = "R4650";
98      break;
99    case C0_IMP_R5000:
100      s_chip = "R5000";
101      break;
102    default:
103      s_chip = 0;
104      break;
105    }
106  if (s_chip)
107    printf("%s: MIPS %s %s Revision: %d.%d\n",
108           pu_short, s_chip, pu_long, major, minor);
109  else
110    printf("%s: unknown (0x%x) %s Revision: %d.%d\n",
111           pu_short, chip, pu_long, major, minor);
112}
113
114void do_INV_PROCESSOR(inventory_t *i,int verbose)
115{
116  if (i->inv_type == INV_CPUBOARD )  {
117    switch (i->inv_state) {
118    case INV_IP19BOARD:
119      puts(verbose ? "SGI IP19": "IP19");
120      break;
121    case INV_IP20BOARD:
122      puts(verbose ? "SGI IP20": "IP20");
123      break;
124    case INV_IP21BOARD:
125      puts(verbose ? "SGI IP21": "IP21");
126      break;
127    case INV_IP22BOARD:
128      puts(verbose ? "SGI IP22": "IP22");
129      break;
130    case INV_IP25BOARD:
131      puts(verbose ? "SGI IP25": "IP25");
132      break;
133    case INV_IP26BOARD:
134      puts(verbose ? "SGI IP26": "IP26");
135      break;
136#ifdef INV_IP27BOARD
137    case INV_IP27BOARD:
138      puts(verbose ? "SGI IP27": "IP27");
139      break;
140#endif
141    case INV_IP28BOARD:
142      puts(verbose ? "SGI IP28": "IP28");
143      break;
144    case INV_IP30BOARD:
145      puts(verbose ? "SGI IP30": "IP30");
146      break;
147    case INV_IP32BOARD:
148      puts(verbose ? "SGI IP32": "IP32");
149      break;
150#ifdef INV_IP33BOARD
151    case INV_IP33BOARD:
152      puts(verbose ? "SGI IP33": "IP33");
153      break;
154#endif
155    case INV_IPMHSIMBOARD:
156      puts(verbose ? "SGI IPMHSIM": "IPMHSIM");
157      break;
158    default:
159      if(verbose)
160        printf("Unknown SGI type %d\n", i->inv_state);
161      else
162        puts("SGI???");
163    }
164  } else if (verbose) {
165    switch(i->inv_type) {
166    case INV_CPUCHIP:
167    case INV_FPUCHIP:
168      do_INV_CPUCHIP(i);
169    }
170  }
171}
172
173void do_dpy(int verbose)
174{
175  int status;
176  inventory_t *inv;
177  int done = 0;
178
179  if (verbose) {
180    fflush(stdout);
181    switch(fork()) {
182    case -1:
183      fprintf (stderr,
184               "Don't know how to determine display type for this machine.\n");
185      return;
186    case 0:
187      if ((execlp("/usr/gfx/gfxinfo","gfxinfo",NULL) ) == -1 ) {
188        fprintf (stderr,
189                 "Don't know how to determine display "
190                 "type for this machine.\n");
191        return;
192      }
193    default:
194      wait(&status);
195      break;
196    } /* switch */
197    (void) setinvent();
198    inv = getinvent();
199    while ((inv != NULL) && !done) {
200      if ( inv->inv_class == INV_VIDEO) {
201        do_INV_CAM(inv);
202      }
203      inv = getinvent();
204    }
205  } else { /* not verbose */
206    (void) setinvent();
207    inv = getinvent();
208    while ((inv != NULL) && !done) {
209      if ( inv->inv_class == INV_GRAPHICS) {
210        do_INV_GRAPHICS(inv);
211      }
212      inv = getinvent();
213    }
214  } /* verbose */
215}
216
217void do_INV_GRAPHICS(inventory_t *i)
218{
219  switch(i->inv_type)
220    {
221    case INV_NEWPORT:
222      switch(i->inv_state)
223        {
224        case INV_NEWPORT_24:
225          fprintf(stdout,"XL-24\n");
226          break;
227        case INV_NEWPORT_XL:
228          fprintf(stdout,"XL\n");
229          break;
230        default:
231          fprintf(stdout,"NG1\n");
232          break;
233        }
234      break;
235    case INV_GR2:
236      /* an EXPRESS is an EXPRESS of course of course
237         except when you are a GR3-XZ */
238      if ((i->inv_state & ~INV_GR2_INDY) == INV_GR2_ELAN )
239        fprintf(stdout,"GR3-XZ\n");
240      else
241        fprintf(stdout,"UNKNOWN video\n");
242      break;
243#ifdef INV_CRIME
244    case INV_CRIME:
245      fprintf(stdout, "CRM\n");
246      break;
247#endif
248    default:
249      fprintf(stdout,"UNKNOWN video\n");
250    }
251}
252
253void do_INV_CAM(inventory_t *i)
254{
255  if (i->inv_type == INV_VIDEO_VINO ) {
256    if (i->inv_state == INV_VINO_INDY_CAM ) {
257      fprintf(stdout,"\tIndy cam connected\n");
258    }
259  }
260}
261
262
263
264void do_disk(int verbose)
265{
266  inventory_t *inv;
267  int done=0;
268  (void) setinvent();
269  inv = getinvent();
270  while ((inv != NULL) && !done) {
271    if (inv->inv_class == INV_DISK)
272      do_INV_DISK(inv, verbose);
273    else if (inv->inv_class == INV_SCSI)
274      do_INV_SCSI(inv);
275    inv = getinvent();
276  }
277}
278
279void do_INV_SCSI(inventory_t *i)
280{
281  if (i->inv_type == INV_CDROM) {
282    fprintf(stdout, "CDROM: unit %i, on SCSI controller %i\n",
283            i->inv_unit,i->inv_controller);
284  } else {
285    fprintf(stdout, "Unknown type %i:unit %i, on SCSI controller %i\n",
286            i->inv_type,i->inv_unit,i->inv_controller);
287  }
288}
289
290void do_INV_DISK(inventory_t *i, int verbose)
291{
292  switch (i->inv_type)
293    {
294    case INV_SCSIDRIVE:
295      printf("Disk drive: unit %u, on SCSI controller %u\n",
296             i->inv_unit, i->inv_controller);
297      break;
298
299    case INV_SCSIFLOPPY:
300      printf("Floppy drive: unit %u, on SCSI controller %u\n",
301             i->inv_unit, i->inv_controller);
302      break;
303
304    case INV_SCSICONTROL:
305    case INV_GIO_SCSICONTROL:
306#ifdef INV_PCI_SCSICONTROL
307    case INV_PCI_SCSICONTROL:
308#endif
309      do_INV_SCSICONTROL(i, verbose);
310      break;
311
312    default:
313      printf("Unknown type %u: unit %u, on SCSI controller %u\n",
314             i->inv_type, i->inv_unit, i->inv_controller);
315      break;
316    }
317}
318
319void do_INV_SCSICONTROL(inventory_t *i, int verbose)
320{
321  /* Only display SCSI controller info when verbose */
322  if (!verbose)
323    return;
324
325  switch (i->inv_type)
326    {
327    case INV_SCSICONTROL:
328      printf("Integral");
329      break;
330    case INV_GIO_SCSICONTROL:
331      printf("GIO");
332      break;
333#ifdef INV_PCI_SCSICONTROL
334    case INV_PCI_SCSICONTROL:
335      printf("PCI");
336      break;
337#endif
338    default:
339      printf("Unknown");
340      break;
341    }
342
343  printf(" SCSI controller %u: Version ", i->inv_controller);
344
345  switch (i->inv_state)
346    {
347    case INV_WD93:
348      printf("WD 33C93");
349      break;
350
351    case INV_WD93A:
352      printf("WD 33C93A");
353      break;
354
355    case INV_WD93B:
356      printf("WD 33C93B");
357      break;
358
359    case INV_WD95A:
360      printf("WD 33C95A");
361      break;
362
363    case INV_SCIP95:
364      printf("SCIP w/WD 33C95A");
365      break;
366
367#ifdef INV_ADP7880
368    case INV_ADP7880:
369      printf("ADAPTEC 7880");
370      break;
371#endif
372
373    default:
374      printf("Unknown");
375      break;
376    }
377
378  if (i->inv_unit)
379    printf(", rev. %X", i->inv_unit);
380
381  putchar('\n');
382}
383
384
385#define MEG (1024*1024)
386
387void do_memory(int verbose)
388{
389  inventory_t *inv;
390  int mem = 0;
391  int mem_mb = 0;
392  setinvent();
393  inv = getinvent();
394  while (inv) {
395    if (inv->inv_class == INV_MEMORY) {
396      switch(inv->inv_type) {
397      case INV_MAIN:
398        mem = inv->inv_state;
399        break;
400      case INV_MAIN_MB:
401        mem_mb = inv->inv_state;
402        break;
403      }
404    }
405    inv = getinvent();
406  }
407  if (!mem && !mem_mb) {
408    fprintf(stderr, "can't find main memory in inventory\n");
409    exit(2);
410  }
411  if (verbose)
412    printf("%d (%d M) total\n", mem?mem:(mem_mb * MEG),
413           mem_mb?mem_mb:(mem/MEG));
414  else
415    printf("%d\n", mem);
416}
Note: See TracBrowser for help on using the repository browser.