source: trunk/athena/bin/machtype/machtype_sgi.c @ 12292

Revision 12292, 7.5 KB checked in by rbasch, 26 years ago (diff)
Port to IRIX 6.5: Update recognized processor boards; nlist() moved from mld to elf library.
Line 
1/*
2 *  Machtype: determine machine type & display type
3 *
4 * RCS Info
5 *      $Id: machtype_sgi.c,v 1.13 1998-12-27 21:36:03 rbasch Exp $
6 *      $Locker:  $
7 */
8
9#include <stdio.h>
10#include <string.h>
11#include <strings.h>
12#include <nlist.h>
13#include <sys/param.h>
14#include <sys/types.h>
15#include <sys/file.h>
16#include <sys/sysinfo.h>
17#include <sys/ioctl.h>
18#include "machtype.h"
19
20#ifdef sgi
21#include <sys/cpu.h>
22#include <invent.h>
23void do_INV_SCSI(inventory_t *, int);
24void do_INV_SCSICONTROL(inventory_t *, int);
25void do_INV_DISK(inventory_t *, int);
26void do_INV_PROCESSOR(inventory_t *,int);
27void do_INV_GRAPHICS(inventory_t *, int);
28void do_INV_CAM(inventory_t *, int);
29#endif
30
31
32
33#define NL_NF(nl) ((nl).n_type == 0)
34
35#define KERNEL "/unix"
36#define MEMORY "/dev/kmem"
37
38struct nlist nl[] = {
39#define X_cpu 0
40        { "cputype" },
41#define X_maxmem 1
42        { "maxmem" },
43#define X_physmem 2
44        { "physmem" },
45#define X_nscsi 3
46        { "_nscsi_devices" },
47        { "" },
48};
49
50
51void do_machtype(void)
52{
53    puts("sgi");
54}
55
56void do_cpu(int verbose)
57{
58inventory_t *inv;
59int done=0;
60        (void)setinvent();
61        inv = getinvent();
62        while ((inv != NULL) && !done) {
63                if ( inv->inv_class == 1) {
64                        do_INV_PROCESSOR(inv,verbose);
65                }
66                inv = getinvent();
67        }
68}
69
70void do_INV_PROCESSOR(inventory_t *i,int verbose)
71{
72if (i->inv_type == INV_CPUBOARD )  {
73        switch (i->inv_state) {
74        case INV_IP19BOARD:
75                puts(verbose ? "SGI IP19": "IP19");
76                break;
77        case INV_IP20BOARD:
78                puts(verbose ? "SGI IP20": "IP20");
79                break;
80        case INV_IP21BOARD:
81                puts(verbose ? "SGI IP21": "IP21");
82                break;
83        case INV_IP22BOARD:
84                puts(verbose ? "SGI IP22": "IP22");
85                break;
86        case INV_IP25BOARD:
87                puts(verbose ? "SGI IP25": "IP25");
88                break;
89        case INV_IP26BOARD:
90                puts(verbose ? "SGI IP26": "IP26");
91                break;
92        case INV_IP27BOARD:
93                puts(verbose ? "SGI IP27": "IP27");
94                break;
95        case INV_IP28BOARD:
96                puts(verbose ? "SGI IP28": "IP28");
97                break;
98        case INV_IP30BOARD:
99                puts(verbose ? "SGI IP30": "IP30");
100                break;
101        case INV_IP32BOARD:
102                puts(verbose ? "SGI IP32": "IP32");
103                break;
104        case INV_IP33BOARD:
105                puts(verbose ? "SGI IP33": "IP33");
106                break;
107        case INV_IPMHSIMBOARD:
108                puts(verbose ? "SGI IPMHSIM": "IPMHSIM");
109                break;
110        default:
111                if(verbose)
112                        printf("Unknown SGI type %d\n", i->inv_state);
113                else
114                        puts("SGI???");
115        }
116        } else if (verbose) {
117                if (i->inv_type == INV_CPUCHIP) {
118                        fprintf(stdout,"CPU: MIPS R4600\n");
119        } else {
120                        fprintf(stdout,"FPU:MIPS R4610\n");
121        }
122}
123}
124
125
126void do_dpy(int verbose)
127{
128int status;
129inventory_t *inv;
130int done=0;
131
132    if (verbose) {
133        switch(fork()) {
134                case -1:
135                        fprintf (stderr,
136                        "Don't know how to determine display type for this machine.\n");
137                        return;
138                case 0:
139                        if ((execlp("/usr/gfx/gfxinfo","gfxinfo",NULL) ) == -1 ) {
140                                fprintf (stderr,
141                                "Don't know how to determine display type for this machine.\n");
142                                return;
143                        }       
144                default:
145                        wait(&status);
146                break;
147        } /* switch */
148        (void) setinvent();
149        inv = getinvent();
150        while ((inv != NULL) && !done) {
151                if ( inv->inv_class == INV_VIDEO) {
152                        do_INV_CAM(inv, verbose);
153                }
154                inv = getinvent();
155        }
156    } else { /* not verbose */
157        (void) setinvent();
158        inv = getinvent();
159        while ((inv != NULL) && !done) {
160                if ( inv->inv_class == INV_GRAPHICS) {
161                        do_INV_GRAPHICS(inv, verbose);
162                }
163                inv = getinvent();
164        }
165     } /* verbose */
166}
167
168void do_INV_GRAPHICS(inventory_t *i, int verbose)
169{
170  switch(i->inv_type)
171    {
172    case INV_NEWPORT:
173      switch(i->inv_state)
174        {
175        case INV_NEWPORT_24:
176          fprintf(stdout,"XL-24\n");
177          break;
178        case INV_NEWPORT_XL:
179          fprintf(stdout,"XL\n");
180          break;
181        default:
182          fprintf(stdout,"NG1\n");
183          break;
184        }
185      break;
186    case INV_GR2:
187      /* an EXPRESS is an EXPRESS of course of course
188         except when you are a GR3-XZ */
189      if ((i->inv_state & ~INV_GR2_INDY) == INV_GR2_ELAN )
190        fprintf(stdout,"GR3-XZ\n");
191      else
192        fprintf(stdout,"UNKNOWN video\n");
193      break;
194#ifdef INV_CRIME
195    case INV_CRIME:
196      fprintf(stdout, "CRM\n");
197      break;
198#endif
199    default:
200      fprintf(stdout,"UNKNOWN video\n");
201    }
202}
203
204void do_INV_CAM(inventory_t *i, int verbose)
205{
206        if (i->inv_type == INV_VIDEO_VINO ) {
207                if (i->inv_state == INV_VINO_INDY_CAM ) {
208                        fprintf(stdout,"\tIndy cam connected\n");
209                }
210        }
211}
212
213
214
215void do_disk(int verbose)
216{
217inventory_t *inv;
218int t;
219int done=0;
220        (void) setinvent();
221        inv = getinvent();
222        t = 0;
223        while ((inv != NULL) && !done) {
224                if (inv->inv_class == INV_DISK)
225                  do_INV_DISK(inv, verbose);
226                else if (inv->inv_class == INV_SCSI)
227                  do_INV_SCSI(inv, verbose);
228                inv = getinvent();
229        }
230}
231void do_INV_SCSI(inventory_t *i, int verbose)
232{
233if (i->inv_type == INV_CDROM) {
234        fprintf(stdout,"CDROM: unit %i, on SCSI controller %i\n",i->inv_unit,i->inv_controller);
235} else {
236        fprintf(stdout,"Unknown type %i:unit %i, on SCSI controller %i\n",i->inv_type,i->inv_unit,i->inv_controller);
237}
238}
239
240void do_INV_DISK(inventory_t *i, int verbose)
241{
242  switch (i->inv_type)
243    {
244    case INV_SCSIDRIVE:
245      printf("Disk drive: unit %u, on SCSI controller %u\n",
246             i->inv_unit, i->inv_controller);
247      break;
248
249    case INV_SCSIFLOPPY:
250      printf("Floppy drive: unit %u, on SCSI controller %u\n",
251             i->inv_unit, i->inv_controller);
252      break;
253
254    case INV_SCSICONTROL:
255    case INV_GIO_SCSICONTROL:
256#ifdef INV_PCI_SCSICONTROL
257    case INV_PCI_SCSICONTROL:
258#endif
259      do_INV_SCSICONTROL(i, verbose);
260      break;
261
262    default:
263      printf("Unknown type %u: unit %u, on SCSI controller %u\n",
264             i->inv_type, i->inv_unit, i->inv_controller);
265      break;
266    }
267}
268
269void do_INV_SCSICONTROL(inventory_t *i, int verbose)
270{
271  /* Only display SCSI controller info when verbose */
272  if (!verbose)
273    return;
274
275  switch (i->inv_type)
276    {
277    case INV_SCSICONTROL:
278      printf("Integral");
279      break;
280    case INV_GIO_SCSICONTROL:
281      printf("GIO");
282      break;
283#ifdef INV_PCI_SCSICONTROL
284    case INV_PCI_SCSICONTROL:
285      printf("PCI");
286      break;
287#endif
288    default:
289      printf("Unknown");
290      break;
291    }
292
293  printf(" SCSI controller %u: Version ", i->inv_controller);
294
295  switch (i->inv_state)
296    {
297    case INV_WD93:
298      printf("WD 33C93");
299      break;
300
301    case INV_WD93A:
302      printf("WD 33C93A");
303      break;
304
305    case INV_WD93B:
306      printf("WD 33C93B");
307      break;
308
309    case INV_WD95A:
310      printf("WD 33C95A");
311      break;
312
313    case INV_SCIP95:
314      printf("SCIP w/WD 33C95A");
315      break;
316
317#ifdef INV_ADP7880
318    case INV_ADP7880:
319      printf("ADAPTEC 7880");
320      break;
321#endif
322
323    default:
324      printf("Unknown");
325      break;
326    }
327
328  if (i->inv_unit)
329    printf(", rev. %X", i->inv_unit);
330
331  putchar('\n');
332}
333
334
335#define MEG (1024*1024)
336
337void do_memory(int verbose)
338{
339  int mf, pos, mem, nbpp;
340
341  if (nlist(KERNEL, nl) < 0) {
342      fprintf(stderr,"can't get namelist\n");
343      exit(2);
344  }
345  if ((mf = open(MEMORY, O_RDONLY)) == -1) {
346      perror("can't open memory");
347      exit(2);
348  }
349  nbpp = getpagesize() / 1024;
350  pos = nl[X_maxmem].n_value;
351  if(pos == 0) {
352      fprintf(stderr, "can't find maxmem\n");
353      exit(3);
354  }
355  lseek(mf,pos,L_SET);  /* Error checking ? */
356  if(read(mf,&mem,4) == -1) {
357      perror("read (kmem)");
358      exit(4);
359  } else {
360    if(verbose)
361      printf("%d user, ",mem * nbpp);
362  }
363  pos = nl[X_physmem].n_value;
364  if(pos == 0) {
365      fprintf(stderr, "can't find physmem\n");
366      exit(3);
367  }
368  lseek(mf,pos,L_SET);
369  if(read(mf,&mem,4) == -1) {
370      perror("read (kmem)");
371      exit(4);
372  } else {
373    if(verbose)
374      printf("%d (%d M) total\n",mem * nbpp,(mem * getpagesize() + MEG/2)/MEG);
375    else
376      printf("%d\n", mem * nbpp);
377  }
378  return;
379}
380
Note: See TracBrowser for help on using the repository browser.