etc/etc.i386/MAKEDEV

   1 #!/bin/sh -
   2 #
   3 # Copyright (c) 1990 The Regents of the University of California.
   4 # All rights reserved.
   5 #
   6 # Written and contributed by W. Jolitz 12/90
   7 #
   8 # Redistribution and use in source and binary forms are permitted provided
   9 # that: (1) source distributions retain this entire copyright notice and
  10 # comment, and (2) distributions including binaries display the following
  11 # acknowledgement:  ``This product includes software developed by the
  12 # University of California, Berkeley and its contributors'' in the
  13 # documentation or other materials provided with the distribution and in
  14 # all advertising materials mentioning features or use of this software.
  15 # Neither the name of the University nor the names of its contributors may
  16 # be used to endorse or promote products derived from this software without
  17 # specific prior written permission.
  18 # THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  19 # WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  20 # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  21 #
  22 #       @(#)MAKEDEV     5.2 (Berkeley) 6/22/90
  23 #
  24 # Device "make" file.  Valid arguments:
  25 #       all     makes all known devices, standard number of units (or close)
  26 #       std     standard devices
  27 #       local   configuration specific devices
  28 #       mach-4  mach4&lites+devices for Mach's XFree86 distribution
  29 #       (see http://www.cs.hut.fi/lites.html for more info on LITES)
  30 #
  31 # Tapes:
  32 #       wt*     QIC-interfaced (e.g. not SCSI) 3M cartridge tape
  33 #       st*     "NEW type scsi tapes" (old driver uses the
  34 #               block devices of the disks to get access)
  35 #       ft*     QIC-40/QIC-80 3M cartridge tape (interfaced
  36 #               via the floppy disk controller)
  37 #
  38 # Disks:
  39 #       wd*     "Winchester" disk drives (ST506,IDE,ESDI,RLL,...)
  40 #       wfd*    "IDE floppy" disk drives (LS-120)
  41 #       fd*     "floppy" disk drives (3 1/2", 5 1/4")
  42 #       sd*     "SCSI disks"
  43 #       cd*     "SCSI CD-ROM disks"
  44 #       mcd*    "Mitsumi CD-ROM disks"
  45 #       scd*    "Sony CD-ROM disks"
  46 #       matcd*  "Matsushita (Panasonic) CD-ROM disks"
  47 #       wcd*    "IDE CD-ROM disks"
  48 #       vn*     "vnode disks"
  49 #       od*     "optical disks"
  50 #       fla*    "M-Systems DiskOnChip"
  51 #
  52 # Console ports:
  53 #       vty*    virtual console devices for syscons/pcvt/codrv
  54 #
  55 # Pointing devices:
  56 #       mse*    Logitech and ATI Inport bus mouse
  57 #       psm*    PS/2 mouse
  58 #       sysmouse Mousesystems mouse emulator for syscons
  59 #
  60 # Time devices:
  61 #       refclock-*  serial ports used by xntpd parse refclocks
  62 #
  63 # Terminal ports:
  64 #       tty*    general purpose serial ports
  65 #       cua*    dialout serial ports
  66 #       ttyA*   Specialix SI/XIO dialin ports ('*' = number of devices)
  67 #       cuaA*   Specialix SI/XIO dialout ports
  68 #       ttyD*   Digiboard - 16 dialin ports
  69 #       cuaD*   Digiboard - 16 dialout ports
  70 #       ttyR*   Rocketport dialin ports
  71 #       cuaR*   Rocketport dialout ports
  72 #
  73 # Pseudo terminals:
  74 #       pty*    set of 32 master and slave pseudo terminals
  75 #       vty*    virtual terminals using syscons/pcvt/codrv console
  76 #
  77 # Printers:
  78 #       lpt*    stock lp
  79 #
  80 # SCSI devices (other than CD-ROM, tape and disk):
  81 #       ssc     The ``super scsi'' device
  82 #       uk*     "unknown" device (supports ioctl calls only)
  83 #       worm*   WORM driver
  84 #       pt*     Processor Type (HP scanner, as one example)
  85 #
  86 # PC-CARD (previously called PCMCIA) support
  87 #       card*   PC-CARD slots
  88 #
  89 # Special purpose devices:
  90 #       apm     Advanced Power Management BIOS
  91 #       bpf*    packet filter
  92 #       speaker pc speaker
  93 #       tw*     xten power controller
  94 #       snd*    various sound cards
  95 #       pcaudio PCM audio driver
  96 #       socksys iBCS2 socket system driver
  97 #       vat     VAT compatibility audio driver (requires snd*)
  98 #       gsc     Genius GS-4500 hand scanner
  99 #       joy     pc joystick
 100 #       tun*    Tunneling IP device
 101 #       snp*    tty snoop devices
 102 #       spigot  Video Spigot video acquisition card
 103 #       ctx*    Cortex-I video acquisition card
 104 #       meteor* Matrox Meteor video acquisition card (pci)
 105 #       bktr*   Bt848 based video acquisition card (pci)
 106 #       labpc*  National Instrument's Lab-PC and LAB-PC+
 107 #       perfmon CPU performance-monitoring counters
 108 #       pci     PCI configuration-space access from user mode
 109 #       ipl     ipfilter control devices (ipl, ipnat, ipstate, ipauth)
 110 #
 111 #       $Id: MAKEDEV,v 1.166 1998/08/04 21:45:20 brian Exp $
 112 #
 113
 114 PATH=/sbin:/bin/:/usr/bin:/usr/sbin:$PATH
 115 umask 77
 116
 117 # Usage: die exitcode msg
 118 die() {
 119         echo $2
 120         exit $1
 121 }
 122
 123 # Convert integer to partition name
 124 dkitop() {
 125         local p
 126
 127         case $1 in
 128         0) p=a;; 1) p=b;; 2) p=c;; 3) p=d;; 4) p=e;; 5) p=f;; 6) p=g;; 7) p=h;;
 129         *) p="?";;
 130         esac
 131         echo $p
 132 }
 133
 134 # Convert integer to slice name
 135 dkitos() {
 136         local s
 137
 138         case $1 in
 139         0) s="";;
 140         1) s="";;
 141         *) s=s$(($1-1));;
 142         esac
 143         echo $s
 144 }
 145
 146 # Convert disk (type, unit, slice, partition) to minor number
 147 dkminor()
 148 {
 149         echo $(($1 << 25 | ($2 / 32) << 21 | ($2 % 32) << 3 | $3 << 16 | $4))
 150 }
 151
 152 # Override mknod(2) to add extra handling to it.
 153 mknod() {
 154         rm -f "$1" || exit 1
 155         /sbin/mknod "$@" || die 2 "/sbin/mknod $@ failed"
 156         chown root.wheel "$1" || exit 1
 157 }
 158
 159 # Convert the last character of a tty name to a minor number.
 160 ttyminor()
 161 {
 162         case $unit in
 163         [0-9]) m=$unit;;
 164         a) m=10;; b) m=11;; c) m=12;; d) m=13;; e) m=14;; f) m=15;; g) m=16;;
 165         h) m=17;; i) m=18;; j) m=19;; k) m=20;; l) m=21;; m) m=22;; n) m=23;;
 166         o) m=24;; p) m=25;; q) m=26;; r) m=27;; s) m=28;; t) m=29;; u) m=30;;
 167         v) m=31;;
 168         *) m="?";;
 169         esac
 170         echo $m
 171 }
 172
 173 # Raw partition for disks
 174 dkrawpart=2
 175
 176 # Compatibility slice for disks
 177 dkcompatslice=0
 178
 179 # Raw slice for disks
 180 dkrawslice=1
 181
 182 # Control bit for SCSI
 183 scsictl=$((1 << 29))
 184
 185 # Standard umasks
 186 disk_umask=037                  # allow group operator to read disks
 187 tape_umask=017                  # allow group operator to read/write tapes
 188
 189 for i in $*; do
 190 case $i in
 191
 192 all)
 193         sh MAKEDEV std                                  # standard
 194         sh MAKEDEV fd0 fd1                              # bdev, floppy disk
 195         sh MAKEDEV sd0 sd1 sd2 sd3 wd0 wd1 wd2 wd3      # bdev, ordinary disk
 196         sh MAKEDEV od0                                  # bdev, optical disk
 197         sh MAKEDEV wfd0                                 # bdev, LS-120 floppy
 198         sh MAKEDEV vn0                                  # bdev, virtual disk
 199         sh MAKEDEV cd0 matcd0 mcd0 scd0 wcd0            # bdev, cdrom
 200         sh MAKEDEV ft0 st0 wt0                          # bdev, tape
 201         sh MAKEDEV vty4                                 # cdev, virtual tty
 202         sh MAKEDEV cuaa0 cuaa1 cuaa2 cuaa3              # cdev, serial tty
 203         sh MAKEDEV pty0                                 # cdev, pseudo tty
 204         sh MAKEDEV ttyd0 ttyd1 ttyd2 ttyd3              # cdev, serial tty
 205         sh MAKEDEV mse0 psm0 sysmouse                   # cdev, mouse
 206         sh MAKEDEV pcaudio speaker                      # cdev, noise
 207         sh MAKEDEV lpt0 lpt1 lpt2                       # cdev, printer
 208         sh MAKEDEV bpf0 ipl tun0                        # cdev, network
 209         sh MAKEDEV ch0 perfmon tw0                      # cdev, miscellaneous
 210         sh MAKEDEV apm card0 card1                      # cdev, laptop
 211         ;;
 212 std)
 213         mknod console   c 0 0;  chmod 600 console
 214         mknod drum      c 4 0;  chmod 640 drum;         chgrp kmem drum
 215         mknod kmem      c 2 1;  chmod 640 kmem;         chgrp kmem kmem
 216         mknod mem       c 2 0;  chmod 640 mem;          chgrp kmem mem
 217         mknod null      c 2 2;  chmod 666 null
 218         mknod random    c 2 3;  chmod 644 random
 219         mknod urandom   c 2 4;  chmod 644 urandom
 220         mknod zero      c 2 12; chmod 666 zero
 221         mknod io        c 2 14; chmod 600 io
 222         mknod tty       c 1 0;  chmod 666 tty
 223         mknod klog      c 7 0;  chmod 600 klog
 224         mknod stdin     c 22 0; chmod 666 stdin
 225         mknod stdout    c 22 1; chmod 666 stdout
 226         mknod stderr    c 22 2; chmod 666 stderr
 227         mknod lkm       c 32 0; chmod 644 lkm
 228         mknod pci       c 78 0; chmod 644 pci
 229         mkdir -p fd
 230         (cd fd && eval `echo "" | awk ' BEGIN { \
 231                 for (i = 0; i < 64; i++) \
 232                         printf("mknod %d c 22 %d;", i, i)}'`)
 233         chown -R bin.bin fd
 234         chmod 555 fd
 235         chmod 666 fd/*
 236         ;;
 237
 238 mach-4)
 239         mknod iopl c 22 0
 240         mknod kbd c 23 0
 241         mknod mouse c 24 0
 242         mknod time c 25 0
 243         mknod timezone c 26 0
 244         ;;
 245
 246 # Create device files for new Archive/Wangtek QIC-02 tape driver (vak)
 247 wt*)
 248         umask $tape_umask
 249         u=`expr $i : '..\(.*\)'`
 250         if [ x$u = x ]; then u=0; fi
 251         mknod rwt${u}   c 10 `expr  0 + $u`     # default density, 512b blocks
 252         mknod nrwt${u}  c 10 `expr  4 + $u`
 253 #       mknod rWt${u}   c 10 `expr 64 + $u`     # default density, 1024b blocks
 254 #       mknod nrWt${u}  c 10 `expr 68 + $u`
 255         mknod rwt${u}b  c 10 `expr 16 + $u`     # 60 megabytes
 256         mknod nrwt${u}b c 10 `expr 20 + $u`
 257         mknod rwt${u}c  c 10 `expr 24 + $u`     # 120 megabytes
 258         mknod nrwt${u}c c 10 `expr 28 + $u`
 259         mknod rwt${u}d  c 10 `expr 32 + $u`     # 150 megabytes
 260         mknod nrwt${u}d c 10 `expr 36 + $u`
 261 #       mknod rwt${u}e  c 10 `expr 40 + $u`     # 300 megabytes?
 262 #       mknod nrwt${u}e c 10 `expr 44 + $u`
 263 #       mknod rwt${u}f  c 10 `expr 48 + $u`     # 600 megabytes?
 264 #       mknod nrwt${u}f c 10 `expr 52 + $u`
 265         chgrp operator r[Ww]t$u nr[Ww]t$u r[Ww]t$u[a-f] nr[Ww]t$u[a-f]
 266         umask 77
 267         ;;
 268
 269 # Individual slices.
 270 od*s*|sd*s*|vn*s*|wd*s*|wfd*s*|fla*s*)
 271         umask $disk_umask
 272         case $i in
 273         od*s*) name=od; blk=20; chr=70;;
 274         sd*s*) name=sd; blk=4;  chr=13;;
 275         wd*s*) name=wd; blk=0;  chr=3;;
 276         vn*s*) name=vn; blk=15; chr=43;;
 277         wfd*s*) name=wfd; blk=1; chr=87;;
 278         fla*s*) name=fla; blk=28; chr=101;;
 279         esac
 280         case $i in
 281         wfd*s*)
 282                 unit=`expr $i : '...\([0-9]*\)s'`
 283                 slice=`expr $i : '...[0-9]*s\([0-9]*\)'`
 284                 part=`expr $i : '...[0-9]*s[0-9]*\(.*\)'`
 285                 ;;
 286         *)
 287                 unit=`expr $i : '..\([0-9]*\)s'`
 288                 slice=`expr $i : '..[0-9]*s\([0-9]*\)'`
 289                 part=`expr $i : '..[0-9]*s[0-9]*\(.*\)'`
 290                 ;;
 291         esac
 292         case $unit in
 293         [0-9]|[0-9][0-9]|[0-4][0-9][0-9]|50[0-9]|51[0-1])
 294                 case $slice in
 295                 [0-9]|[1-2][0-9]|30)
 296                         oldslice=$slice
 297                         slice=$(($slice+1))
 298                         slicename=`dkitos $slice`
 299                         minor=`dkminor 0 $unit $slice $dkrawpart`
 300                         mknod  $name$unit$slicename b $blk $minor
 301                         mknod r$name$unit$slicename c $chr $minor
 302                         case $part in
 303                         [a-h])
 304                                 case $oldslice in
 305                                 0) slice=$oldslice ;;
 306                                 esac
 307                                 for part in 0 1 2 3 4 5 6 7
 308                                 do
 309                                         minor=`dkminor 0 $unit $slice $part`
 310                                         partname=`dkitop $part`
 311                                         mknod  $name$unit$slicename$partname \
 312                                               b $blk $minor
 313                                         mknod r$name$unit$slicename$partname \
 314                                               c $chr $minor
 315                                 done
 316                                 ;;
 317                         "")
 318                                 ;;
 319                         *)
 320                                 echo bad partition for disk in: $i
 321                                 ;;
 322                         esac
 323                         chgrp operator $name$unit$slicename* \
 324                                       r$name$unit$slicename*
 325                         ;;
 326                 *)
 327                         echo bad slice for disk in: $i
 328                         ;;
 329                 esac
 330                 ;;
 331         *)
 332                 echo bad unit for disk in: $i "(unit=$unit, slice=$slice, part=$part)"
 333                 ;;
 334         esac
 335         umask 77
 336         ;;
 337
 338 fd*)
 339         umask $disk_umask
 340         unit=`expr $i : '..\(.*\)'`
 341         name=fd; blk=2; chr=9
 342         case $unit in
 343         0|1|2|3)
 344                 mknod ${name}${unit}   b $blk `expr $unit '*' 64`
 345                 mknod r${name}${unit}  c $chr `expr $unit '*' 64`
 346                 # Fake BSD partitions
 347                 for i in a b c d e f g h
 348                 do
 349                         ln ${name}${unit} ${name}${unit}$i
 350                         ln r${name}${unit} r${name}${unit}$i
 351                 done
 352                 # User-readable and programmer-readable name sets
 353
 354                 mknod ${name}${unit}.1720  b $blk `expr $unit '*' 64 + 1`
 355                 mknod r${name}${unit}.1720 c $chr `expr $unit '*' 64 + 1`
 356                 # ln ${name}${unit}.1720 ${name}${unit}135hs21
 357                 # ln r${name}${unit}.1720 r${name}${unit}135hs21
 358
 359                 mknod ${name}${unit}.1480  b $blk `expr $unit '*' 64 + 2`
 360                 mknod r${name}${unit}.1480 c $chr `expr $unit '*' 64 + 2`
 361                 # ln ${name}${unit}.1480 ${name}${unit}135hs18
 362                 # ln r${name}${unit}.1480 r${name}${unit}135hs18
 363                 # ln ${name}${unit}.1480 ${name}${unit}96hs18
 364                 # ln r${name}${unit}.1480 r${name}${unit}96hs18
 365
 366                 mknod ${name}${unit}.1440  b $blk `expr $unit '*' 64 + 3`
 367                 mknod r${name}${unit}.1440 c $chr `expr $unit '*' 64 + 3`
 368                 # ln ${name}${unit}.1440 ${name}${unit}135
 369                 # ln r${name}${unit}.1440 r${name}${unit}135
 370                 # ln ${name}${unit}.1440 ${name}${unit}135ds18
 371                 # ln r${name}${unit}.1440 r${name}${unit}135ds18
 372                 # ln ${name}${unit}.1440 ${name}${unit}96ds18
 373                 # ln r${name}${unit}.1440 r${name}${unit}96ds18
 374
 375                 mknod ${name}${unit}.1200  b $blk `expr $unit '*' 64 + 4`
 376                 mknod r${name}${unit}.1200 c $chr `expr $unit '*' 64 + 4`
 377                 # ln ${name}${unit}.1200 ${name}${unit}96
 378                 # ln r${name}${unit}.1200 r${name}${unit}96
 379                 # ln ${name}${unit}.1200 ${name}${unit}96ds15
 380                 # ln r${name}${unit}.1200 r${name}${unit}96ds15
 381                 # ln ${name}${unit}.1200 ${name}${unit}135ds15
 382                 # ln r${name}${unit}.1200 r${name}${unit}135ds15
 383
 384                 mknod ${name}${unit}.820  b $blk `expr $unit '*' 64 + 5`
 385                 mknod r${name}${unit}.820 c $chr `expr $unit '*' 64 + 5`
 386                 # ln ${name}${unit}.820 ${name}${unit}96hs10
 387                 # ln r${name}${unit}.820 r${name}${unit}96hs10
 388                 # ln ${name}${unit}.820 ${name}${unit}135hs10
 389                 # ln r${name}${unit}.820 r${name}${unit}135hs10
 390
 391                 mknod ${name}${unit}.800  b $blk `expr $unit '*' 64 + 6`
 392                 mknod r${name}${unit}.800 c $chr `expr $unit '*' 64 + 6`
 393                 # ln ${name}${unit}.800 ${name}${unit}96ds10
 394                 # ln r${name}${unit}.800 r${name}${unit}96ds10
 395                 # ln ${name}${unit}.800 ${name}${unit}135ds10
 396                 # ln r${name}${unit}.800 r${name}${unit}135ds10
 397
 398                 mknod ${name}${unit}.720  b $blk `expr $unit '*' 64 + 7`
 399                 mknod r${name}${unit}.720 c $chr `expr $unit '*' 64 + 7`
 400                 # ln ${name}${unit}.720 ${name}${unit}96ds9
 401                 # ln r${name}${unit}.720 r${name}${unit}96ds9
 402                 # ln ${name}${unit}.720 ${name}${unit}135ds9
 403                 # ln r${name}${unit}.720 r${name}${unit}135ds9
 404
 405                 mknod ${name}${unit}.360  b $blk `expr $unit '*' 64 + 8`
 406                 mknod r${name}${unit}.360 c $chr `expr $unit '*' 64 + 8`
 407                 # ln ${name}${unit}.360 ${name}${unit}48
 408                 # ln r${name}${unit}.360 r${name}${unit}48
 409                 # ln ${name}${unit}.360 ${name}${unit}48ds9
 410                 # ln r${name}${unit}.360 r${name}${unit}48ds9
 411
 412                 chgrp operator ${name}${unit}* r${name}${unit}*
 413                 ;;
 414         *)
 415                 echo bad unit for disk in: $i
 416                 ;;
 417         esac
 418         umask 77
 419         ;;
 420
 421 ft*)
 422         umask $tape_umask
 423         unit=`expr $i : '..\(.*\)'`
 424         name=ft; blk=2; chr=9
 425         case $unit in
 426         0|1|2|3)
 427                 mknod ${name}${unit}   b $blk `expr $unit '*' 64 + 32`
 428                 mknod r${name}${unit}  c $chr `expr $unit '*' 64 + 32`
 429                 ln ${name}${unit} ${name}${unit}a
 430                 ln r${name}${unit} r${name}${unit}a
 431                 chgrp operator ${name}${unit}* r${name}${unit}*
 432                 ;;
 433         *)
 434                 echo bad unit for tape in: $i
 435                 ;;
 436         esac
 437         umask 77
 438         ;;
 439
 440 od*|sd*|vn*|wd*|wfd*|fla*)
 441         umask $disk_umask
 442         case $i in
 443         od*) name=od; blk=20; chr=70;;
 444         sd*) name=sd; blk=4;  chr=13;;
 445         vn*) name=vn; blk=15; chr=43;;
 446         wd*) name=wd; blk=0;  chr=3;;
 447         wfd*) name=wfd; blk=1; chr=87;;
 448         fla*) name=fla; blk=28; chr=101;;
 449         esac
 450         case $i in
 451         wfd*)
 452                 unit=`expr $i : '...\(.*\)'`
 453                 ;;
 454         *)
 455                 unit=`expr $i : '..\(.*\)'`
 456                 ;;
 457         esac
 458         case $unit in
 459         [0-9]|[0-9][0-9]|[0-4][0-9][0-9]|50[0-9]|51[0-1])
 460                 for slicepartname in s0h s1 s2 s3 s4
 461                 do
 462                         sh MAKEDEV $name$unit$slicepartname
 463                 done
 464                 case $name in
 465                 od|sd)
 466                         minor=`dkminor 0 $unit 0 0`
 467                         mknod r${name}${unit}.ctl c $chr $(($minor | $scsictl))
 468                         chmod 600 r${name}${unit}.ctl
 469                         ;;
 470                 esac
 471                 ;;
 472         *)
 473                 echo bad unit for disk in: $i
 474                 ;;
 475         esac
 476         umask 77
 477         ;;
 478
 479 ccd*)
 480         umask $disk_umask
 481         name=ccd
 482         blk=21; chr=74
 483         unit=`expr $i : '...\(.*\)'`
 484         case $unit in
 485         [0-9]|[0-9][0-9]|[0-4][0-9][0-9]|50[0-9]|51[0-1])
 486                 for part in 0 1 2 3 4 5 6 7
 487                 do
 488                         minor=`dkminor 0 $unit 0 $part`
 489                         partname=`dkitop $part`
 490                         mknod  $name$unit$partname b $blk $minor
 491                         mknod r$name$unit$partname c $chr $minor
 492                 done
 493                 chgrp operator ${name}${unit}[a-h] r${name}${unit}[a-h]
 494                 ;;
 495         *)
 496                 echo bad unit for disk in: $i
 497                 ;;
 498         esac
 499         umask 77
 500         ;;
 501
 502 ssc*)
 503         mknod ssc c 49 0
 504         ;;
 505
 506 uk*)
 507         unit=`expr $i : 'uk\(.*\)'`
 508         mknod uk$unit c 31 $unit
 509         ;;
 510
 511 worm*)
 512         umask $disk_umask
 513         unit=`expr $i : 'worm\(.*\)'`
 514         if [ "X${unit}" = "X" ]; then
 515                 unit=0
 516         fi
 517         chr=62
 518         blk=23
 519         name=worm
 520         mknod ${name}${unit} b $blk ${unit}
 521         mknod r${name}${unit} c $chr ${unit}
 522         chgrp operator ${name}${unit} r${name}${unit}
 523         umask 077
 524         mknod r${name}${unit}.ctl c $chr `expr $unit + $scsictl `
 525         ;;
 526
 527 # SCSI processor type driver
 528 pt[0-9]*)
 529         chr=61
 530         name=pt
 531         unit=`expr $i : 'pt\([0-9][0-9]*\)'`
 532         if [ "X${unit}" = "X" ]; then
 533                 unit=0
 534         fi
 535         unit=`expr $unit + 1 - 1`
 536         mknod ${name}${unit} c $chr $unit
 537         mknod ${name}${unit}.ctl c $chr `expr $unit + $scsictl `
 538         ;;
 539
 540 pty*)
 541         class=`expr $i : 'pty\(.*\)'`
 542         case $class in
 543         0) offset=0 name=p;;
 544         1) offset=32 name=q;;
 545         2) offset=64 name=r;;
 546         3) offset=96 name=s;;
 547 # Note that xterm (at least) only look at p-s.
 548         4) offset=128 name=P;;
 549         5) offset=160 name=Q;;
 550         6) offset=192 name=R;;
 551         7) offset=224 name=S;;
 552         # This still leaves [tuTU].
 553         *) echo bad unit for pty in: $i;;
 554         esac
 555         case $class in
 556         0|1|2|3|4|5|6|7)
 557                 umask 0
 558                 eval `echo $offset $name | awk ' { b=0+$1; n=$2 } END { \
 559                         for (i = 0; i < 32; i++) {
 560                                 c = substr("0123456789abcdefghijklmnopqrstuv", i + 1, 1); \
 561                                 printf("mknod tty%s%s c 5 %d; \
 562                                         mknod pty%s%s c 6 %d;", \
 563                                         n, c, b+i, \
 564                                         n, c, b+i); \
 565                         } \
 566                 }'`
 567                 umask 77
 568                 ;;
 569         esac
 570         ;;
 571
 572 st*)
 573         umask $tape_umask
 574         unit=`expr $i : '..\(.*\)'`
 575         chr=14
 576
 577         case $unit in
 578         0|1|2|3|4|5|6)
 579                 for mode in 0 1 2 3
 580                 do
 581                         mknod rst${unit}.${mode} c $chr `expr $unit '*' 16 + $mode '*' 4 + 0`
 582                         mknod nrst${unit}.${mode} c $chr `expr $unit '*' 16 + $mode '*' 4 + 1`
 583                         mknod erst${unit}.${mode} c $chr `expr $unit '*' 16 + $mode '*' 4 + 2`
 584                         mknod st${unit}ctl.${mode} c $chr `expr $unit '*' 16 + $mode '*' 4 + 3`
 585                         chgrp operator  rst${unit}.${mode}\
 586                                         nrst${unit}.${mode} \
 587                                         erst${unit}.${mode} \
 588                                         st${unit}ctl.${mode}
 589                         chmod 600       st${unit}ctl.${mode}
 590                 done
 591                 mknod rst${unit}.ctl c $chr `expr $unit '*' 16 + $scsictl `
 592                 chmod 600 rst${unit}.ctl
 593
 594                 ln rst${unit}.0 rst${unit}
 595                 ln nrst${unit}.0 nrst${unit}
 596                 ln erst${unit}.0 erst${unit}
 597                 ;;
 598         *)
 599                 echo bad unit for tape in: $i
 600                 ;;
 601         esac
 602         umask 77
 603         ;;
 604
 605 ch*)
 606         umask 37
 607         unit=`expr $i : '..\(.*\)'`
 608         case $i in
 609         ch*) name=ch;  chr=17;;
 610         esac
 611         case $unit in
 612         0|1|2|3|4|5|6)
 613                 mknod ${name}${unit}    c $chr `expr $unit '*' 16 + 0`
 614                 chgrp operator ${name}${unit}
 615                 mknod r${name}${unit}.ctl c $chr `expr $unit '*' 16 + $scsictl `
 616                 chmod 600 r${name}${unit}.ctl
 617                 ;;
 618         *)
 619                 echo bad unit for media changer in: $i
 620                 ;;
 621         esac
 622         umask 77
 623         ;;
 624
 625 cd*|mcd*|scd*)
 626         umask $disk_umask
 627         case $i in
 628         cd*) unit=`expr $i : '..\(.*\)'`; name=cd; blk=6; chr=15;;
 629         mcd*) unit=`expr $i : '...\(.*\)'`; name=mcd; blk=7; chr=29;;
 630         scd*) unit=`expr $i : '...\(.*\)'`; name=scd; blk=16; chr=45;;
 631         esac
 632         case $unit in
 633         0|1|2|3|4|5|6)
 634                 mknod ${name}${unit}a   b $blk `expr $unit '*' 8 + 0`
 635                 mknod ${name}${unit}c   b $blk `expr $unit '*' 8 + 2`
 636                 mknod r${name}${unit}a  c $chr `expr $unit '*' 8 + 0`
 637                 mknod r${name}${unit}c  c $chr `expr $unit '*' 8 + 2`
 638                 chgrp operator ${name}${unit}[a-h] r${name}${unit}[a-h]
 639                 case $name in
 640                 cd)
 641                         mknod r${name}${unit}.ctl c $chr `expr $unit '*' 8 + $scsictl `
 642                         chmod 600 r${name}${unit}.ctl
 643                         ;;
 644                 esac
 645                 ;;
 646         *)
 647                 echo bad unit for disk in: $i
 648                 ;;
 649         esac
 650         umask 77
 651         ;;
 652
 653 matcd*)
 654         umask 2
 655         case $i in
 656         matcd*) unit=`expr $i : '.....\(.*\)'`; name=matcd; blk=17; chr=46;;
 657         esac
 658         case $unit in
 659         0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15)
 660                 mknod ${name}${unit}a   b $blk `expr $unit '*' 8 + 0`
 661                 mknod ${name}${unit}c   b $blk `expr $unit '*' 8 + 2`
 662                 mknod r${name}${unit}a  c $chr `expr $unit '*' 8 + 0`
 663                 mknod r${name}${unit}c  c $chr `expr $unit '*' 8 + 2`
 664                 chgrp operator ${name}${unit}[a-h] r${name}${unit}[a-h]
 665                 chmod 640 ${name}${unit}[a-h] r${name}${unit}[a-h]
 666
 667                 mknod ${name}${unit}la  b $blk `expr $unit '*' 8 + 128`
 668                 mknod ${name}${unit}lc  b $blk `expr $unit '*' 8 + 130`
 669                 mknod r${name}${unit}la c $chr `expr $unit '*' 8 + 128`
 670                 mknod r${name}${unit}lc c $chr `expr $unit '*' 8 + 130`
 671                 chgrp operator ${name}${unit}l[a-h] r${name}${unit}l[a-h]
 672                 chmod 640 ${name}${unit}l[a-h] r${name}${unit}l[a-h]
 673                 ;;
 674         *)
 675                 echo bad unit for disk in: $i
 676                 ;;
 677         esac
 678         umask 77
 679         ;;
 680
 681 wcd*)
 682         umask 2 ;
 683         unit=`expr $i : '...\(.*\)'`
 684         blk=19
 685         chr=69
 686         case $unit in
 687         0|1|2|3)
 688                 mknod wcd${unit}a  b $blk `expr $unit '*' 8 + 0`
 689                 mknod rwcd${unit}a c $chr `expr $unit '*' 8 + 0`
 690                 mknod wcd${unit}c  b $blk `expr $unit '*' 8 + 2`
 691                 mknod rwcd${unit}c c $chr `expr $unit '*' 8 + 2`
 692                 chgrp operator wcd${unit}[a-h] rwcd${unit}[a-h]
 693                 chmod 640 wcd${unit}[a-h] rwcd${unit}[a-h]
 694                 ;;
 695         *)
 696                 echo bad unit for disk in: $i
 697                 ;;
 698         esac
 699         umask 77
 700         ;;
 701
 702 lpt*)
 703         unit=`expr $i : 'lpt\(.*\)'`
 704         mknod lpt$unit c 16 $unit
 705         mknod lpctl$unit c 16 `expr $unit + 128`
 706         ;;
 707
 708 tw*)
 709         unit=`expr $i : 'tw\(.*\)'`
 710         mknod tw$unit c 19 $unit
 711         chgrp operator tw$unit
 712         ;;
 713
 714 # Use this to create virtual consoles for syscons, pcvt or codrv
 715 # ttyv0-b
 716 # use as MAKEDEV vtyNN to create NN entries
 717 vty*)
 718         chr=12
 719         units=`expr $i : 'vty\(.*\)'`
 720         eval `echo ${chr} ${units} | awk ' { c=0+$1; n=0+$2 } END {
 721                 for (i = 0; i < n; i++)
 722                         printf("mknod ttyv%01x c %d %d;", i, c, i); }'`
 723         ln -fs ttyv0 vga        # XXX X still needs this pccons relic
 724         ;;
 725
 726 bpf*)
 727         unit=`expr $i : 'bpf\(.*\)'`
 728         mknod bpf$unit c 23 $unit
 729         ;;
 730
 731 speaker)
 732         mknod speaker c 26 0
 733         ;;
 734
 735 cuaa?|cua?)
 736         umask 7
 737         unit=`expr $i : 'cua.*\(.\)$'`
 738         m=`ttyminor $unit`
 739         mknod cuaa$unit c 28 `expr $m + 128`
 740         mknod cuaia$unit c 28 `expr $m + 32 + 128`
 741         mknod cuala$unit c 28 `expr $m + 64 + 128`
 742         chown uucp.dialer cua*a$unit
 743         umask 77
 744         ;;
 745
 746 tty0?|ttyd?|tty?)
 747         unit=`expr $i : 'tty.*\(.\)$'`
 748         m=`ttyminor $unit`
 749         mknod ttyd$unit c 28 $m
 750         mknod ttyid$unit c 28 `expr $m + 32`
 751         mknod ttyld$unit c 28 `expr $m + 64`
 752         ;;
 753
 754 cuac?)
 755         umask 7
 756         portlist="0 1 2 3 4 5 6 7 8 9 a b c d e f
 757                   g h i j k l m n o p q r s t u v"
 758         major=48
 759         card=`expr $i : 'cua.*\(.\)$'`
 760         for unit in $portlist
 761         do
 762                 minor=`ttyminor $unit`
 763                 minor=`expr $card \* 65536 + $minor`
 764                 name=$card$unit
 765                 mknod cuac$name c $major `expr $minor + 128`
 766                 mknod cuaic$name c $major `expr $minor + 32 + 128`
 767                 mknod cualc$name c $major `expr $minor + 64 + 128`
 768                 chown uucp.dialer cuac$name cuaic$name cualc$name
 769         done
 770         umask 77
 771         ;;
 772
 773 ttyc?)
 774         portlist="0 1 2 3 4 5 6 7 8 9 a b c d e f
 775                   g h i j k l m n o p q r s t u v"
 776         major=48
 777         card=`expr $i : 'tty.*\(.\)$'`
 778         for unit in $portlist
 779         do
 780                 minor=`ttyminor $unit`
 781                 minor=`expr $card \* 65536 + $minor`
 782                 name=$card$unit
 783                 mknod ttyc$name c $major $minor
 784                 mknod ttyic$name c $major `expr $minor + 32`
 785                 mknod ttylc$name c $major `expr $minor + 64`
 786         done
 787         ;;
 788
 789 # RISCom8 'rc' driver entries
 790
 791 cuam?)
 792         umask 7
 793         unit=`expr $i : 'cua.*\(.\)$'`
 794         m=`ttyminor $unit`
 795         mknod cuam$unit c 63 `expr $m + 128`
 796         chown uucp.dialer cuam$unit
 797         umask 77
 798         ;;
 799
 800 ttym?)
 801         unit=`expr $i : 'tty.*\(.\)$'`
 802         m=`ttyminor $unit`
 803         mknod ttym$unit c 63 $m
 804         ;;
 805
 806 # Specialix SI/XIO.
 807 # Note: these are 'base 1' to match the numbers on the panels, and to match
 808 #       the manual that comes with the system.
 809 ttyA*)
 810         major=68
 811         nports=`expr $i : 'ttyA\(.*\)$'`
 812         port=1
 813         while [ $port -le $nports ]; do
 814                 minor=`expr $port - 1`
 815                 name=`expr $port + 1000 | cut -c 3-4`
 816                 mknod ttyA$name c $major $minor
 817                 mknod ttyiA$name c $major `expr $minor + 65536`
 818                 mknod ttylA$name c $major `expr $minor + 131072`
 819                 port=`expr $port + 1`
 820         done
 821         # For the user-mode control program, 'sicontrol'
 822         mknod si_control c 68 262144
 823         ;;
 824
 825 cuaA*)
 826         umask 7
 827         major=68
 828         nports=`expr $i : 'cuaA\(.*\)$'`
 829         port=1
 830         while [ $port -le $nports ]; do
 831                 minor=`expr $port - 1`
 832                 name=`expr $port + 1000 | cut -c 3-4`
 833                 mknod cuaA$name c $major `expr $minor + 128`
 834                 mknod cuaiA$name c $major `expr $minor + 128 + 65536`
 835                 mknod cualA$name c $major `expr $minor + 128 + 131072`
 836                 chown uucp.dialer cuaA$name cuaiA$name cualA$name
 837                 port=`expr $port + 1`
 838         done
 839         umask 77
 840         ;;
 841
 842 # Digiboard PC/?? 16 port card.
 843 # The current scheme of minor numbering is:
 844 #
 845 #       unused{14} CARD{2} major{8} CALLOUT{1} LOCK{1} INIT{1} PORT{5}
 846 #
 847 #   CARD bitfield in future versions may be extended to 3 bits.
 848 #
 849 # See dgb(4)
 850 #
 851 ttyD?)
 852         portlist="0 1 2 3 4 5 6 7 8 9 a b c d e f"
 853         major=58
 854         card=`expr $i : 'tty.*\(.\)$'`
 855         for unit in $portlist
 856         do
 857                 minor=`ttyminor $unit`
 858                 minor=`expr $card \* 65536 + $minor`
 859                 name=$card$unit
 860                 mknod ttyD$name c $major $minor
 861                 mknod ttyiD$name c $major `expr $minor + 32`
 862                 mknod ttylD$name c $major `expr $minor + 64`
 863         done
 864         ;;
 865
 866 cuaD?)
 867         umask 7
 868         portlist="0 1 2 3 4 5 6 7 8 9 a b c d e f"
 869         major=58
 870         card=`expr $i : 'cua.*\(.\)$'`
 871         for unit in $portlist
 872         do
 873                 minor=`ttyminor $unit`
 874                 minor=`expr $card \* 65536 + $minor`
 875                 name=$card$unit
 876                 mknod cuaD$name c $major `expr $minor + 128`
 877                 mknod cuaiD$name c $major `expr $minor + 32 + 128`
 878                 mknod cualD$name c $major `expr $minor + 64 + 128`
 879                 chown uucp.dialer cua*D$name
 880         done
 881         umask 77
 882         ;;
 883
 884 ttyM*)
 885         portlist="0 1 2 3 4 5 6 7 8 9 a b c d e f"
 886         modulelist="a b c d"
 887         major=101
 888         card=`expr $i : 'tty.*\(.\)$'`
 889         for unit in $modulelist
 890         do
 891                 moduleminor=`ttyminor $unit`
 892                 moduleminor=`expr $moduleminor % 10 \* 16`
 893                 modulename=$unit
 894
 895                 for unit in $portlist
 896                 do
 897                         minor=`ttyminor $unit`
 898                         minor=`expr $card \* 65536 + $minor + $moduleminor`
 899                         name=$card$modulename$unit
 900                         rm -f tty*M$name
 901                         mknod ttyM$name c $major $minor
 902                         mknod ttyiM$name c $major `expr $minor + 64`
 903                         mknod ttylM$name c $major `expr $minor + 128`
 904                         chown root.wheel tty*M$name
 905                 done
 906         done
 907         ;;
 908
 909 cuaM?)
 910         umask 7
 911         portlist="0 1 2 3 4 5 6 7 8 9 a b c d e f"
 912         modulelist="a b c d"
 913         major=101
 914         card=`expr $i : 'cua.*\(.\)$'`
 915         for unit in $modulelist
 916         do
 917                 moduleminor=`ttyminor $unit`
 918                 moduleminor=`expr $moduleminor % 10 \* 16`
 919                 modulename=$unit
 920
 921                 for unit in $portlist
 922                 do
 923                         minor=`ttyminor $unit`
 924                         minor=`expr $card \* 65536 + $minor + $moduleminor`
 925                         name=$card$modulename$unit
 926                         rm -f cua*M$name
 927                         mknod cuaM$name c $major `expr $minor + 262144`
 928                         mknod cuaiM$name c $major `expr $minor + 64 + 262144`
 929                         mknod cualM$name c $major `expr $minor + 128 + 262144`
 930                         chown uucp.dialer cua*M$name
 931                 done
 932         done
 933         umask 77
 934         ;;
 935
 936 ttyR?)
 937         major=81
 938         BOARD=1; MINOR=65536; Rnum=0
 939         MINOR=`expr $BOARD \* 65536`
 940         dmesg | grep ^RocketPort[0-4] > /tmp/rp_list
 941         controllers=`awk '{print $1}' < /tmp/rp_list`
 942         rm -f /dev/ttyR*; rm -f /dev/ttyiR*; rm -f /dev/ttylR*
 943         for i in $controllers;do
 944            ndevices=`grep ^$i /tmp/rp_list | sed -e 's/.* \([0-9]*\) ports/\1/'`
 945            echo -n "Creating $ndevices devices for $i: "
 946            for dev in `jot $ndevices 0`;do
 947                    mknod /dev/ttyR$Rnum c $major $MINOR
 948                    mknod /dev/ttylR$Rnum c $major `expr $MINOR + 32`
 949                    mknod /dev/ttyiR$Rnum c $major `expr $MINOR + 64`
 950                    Rnum=`expr $Rnum + 1`
 951                    MINOR=`expr $MINOR + 1`
 952            done
 953                 BOARD=`expr $BOARD + 1`
 954                 MINOR=`expr $BOARD \* 65536`
 955            echo " "
 956         done
 957         ;;
 958
 959 cuaR?)
 960         major=81
 961         BOARD=1; MINOR=65536; Rnum=0
 962         MINOR=`expr $BOARD \* 65536`
 963         dmesg | grep ^RocketPort[0-4] > /tmp/rp_list
 964         controllers=`awk '{print $1}' < /tmp/rp_list`
 965         rm -f /dev/cuaR*; rm -f /dev/cuaiR*; rm -f /dev/cualR*
 966         for i in $controllers;do
 967            ndevices=`grep ^$i /tmp/rp_list | sed -e 's/.* \([0-9]*\) ports/\1/'`
 968            echo -n "Creating $ndevices devices for $i: "
 969            for dev in `jot $ndevices 0`;do
 970                    mknod /dev/cuaR$Rnum c  $major `expr $MINOR + 128`
 971                    mknod /dev/cualR$Rnum c $major `expr $MINOR + 128 + 32`
 972                    mknod /dev/cuaiR$Rnum c $major `expr $MINOR + 128 + 64`
 973                    Rnum=`expr $Rnum + 1`
 974                    MINOR=`expr $MINOR + 1`
 975            done
 976                 BOARD=`expr $BOARD + 1`
 977                 MINOR=`expr $BOARD \* 65536`
 978            echo " "
 979         done
 980         chown uucp.dialer /dev/cuaR*
 981         ;;
 982
 983 mse*)
 984         unit=`expr $i : 'mse\(.*\)'`
 985         chr=27
 986         mknod mse$unit c $chr `expr $unit '*' 2 + 1`    # non-blocking for X11
 987         ;;
 988
 989 psm*)
 990         unit=`expr $i : 'psm\(.*\)'`
 991         chr=21
 992         mknod psm$unit c $chr `expr $unit '*' 2 + 1`    # non-blocking for X11
 993         ;;
 994
 995 mouse*)
 996         name=`expr $i : 'mouse\(.*\)'`
 997         if [ ! -c $name ]; then
 998                 $0 $name                        # make the appropriate device
 999         fi
1000         ln -fs $name mouse
1001         ;;
1002
1003 pcaudio)
1004         mknod pcaudio c 24 0
1005         mknod pcaudioctl c 24 128
1006         ;;
1007
1008 socksys)
1009         mknod socksys c 41 0
1010         mknod spx c 41 1
1011         ln -fs socksys nfsd
1012         chmod 666 socksys nfsd spx
1013         ;;
1014
1015 snd*)
1016 #
1017 # changes from Linux voxware
1018 # minor         Linux                   FreeBSD
1019 # 8             sequencer2 (aka music0) music0
1020 # 17            patmgr0                 sequencer1
1021 # 33            patmgr1                 sequencer2
1022 #
1023
1024         unit=`expr $i : 'snd\(.*\)'`
1025         chr=30
1026
1027         # XXX write this less verbosely, like std
1028         snd_security_hole=0     # XXX
1029         umask $snd_security_hole
1030
1031         if [ $unit = "0" ] ; then
1032                 ln -fs mixer$unit mixer
1033                 ln -fs sequencer$unit sequencer
1034                 ln -fs dsp$unit dsp
1035                 ln -fs audio$unit audio
1036                 ln -fs dspW$unit dspW
1037                 ln -fs music$unit music
1038                 ln -fs pss$unit pss
1039         fi
1040
1041         mknod mixer$unit        c $chr `expr $unit '*' 16 + 0`
1042         mknod sequencer$unit    c $chr `expr $unit '*' 16 + 1`
1043         mknod midi$unit         c $chr `expr $unit '*' 16 + 2`
1044         mknod dsp$unit          c $chr `expr $unit '*' 16 + 3`
1045         mknod audio$unit        c $chr `expr $unit '*' 16 + 4`
1046         mknod dspW$unit         c $chr `expr $unit '*' 16 + 5`
1047         mknod sndstat           c $chr 6
1048                                 # minor number 7 is unused
1049         mknod music$unit        c $chr `expr $unit '*' 16 + 8`
1050         mknod pss$unit          c $chr `expr $unit '*' 16 + 9`
1051                                 # minor numbers 10-15 are unused
1052         umask 77
1053         ;;
1054
1055 vat)
1056         mknod vatio c 25 128
1057         chmod 660 vatio
1058         ;;
1059
1060 gsc*)
1061         unit=`expr $i : 'gsc\(.*\)'`
1062         mknod gsc${unit} c 47 $unit
1063         mknod gsc${unit}p c 47 $(($unit + 8))
1064         mknod gsc${unit}d c 47 $(($unit + 32))
1065         mknod gsc${unit}pd c 47 $(($unit + 40))
1066         chmod 666 gsc${unit}*
1067         ;;
1068
1069 apm*)
1070         chr=39
1071         mknod apm c $chr 0
1072         chgrp operator apm
1073         chmod 660 apm
1074         ;;
1075
1076 card*)
1077         unit=`expr $i : 'card\(.*\)'`
1078         chr=50
1079         mknod card$unit c $chr $unit
1080         chmod 644 card$unit
1081         ;;
1082
1083 ttyx?|ttyy?|ttyz?)
1084         case $i in
1085         *0) unit=0;;    *1) unit=1;;    *2) unit=2;;    *3) unit=3;;
1086         *4) unit=4;;    *5) unit=5;;    *6) unit=6;;    *7) unit=7;;
1087         *8) unit=8;;    *9) unit=9;;    *a) unit=10;;   *b) unit=11;;
1088         *c) unit=12;;   *d) unit=13;;   *e) unit=14;;   *f) unit=15;;
1089         esac
1090         case $i in
1091         ttyy?)  unit=`expr $unit \+ 16`;;
1092         ttyz?)  unit=`expr $unit \+ 32`;;
1093         esac
1094         mknod $i c 42 $unit
1095         chown uucp.wheel $i
1096         ;;
1097
1098 cronyx)
1099         mknod cronyx c 42 63
1100         ;;
1101
1102 joy)
1103         mknod joy0 c 51 0
1104         mknod joy1 c 51 1
1105         chgrp operator joy0 joy1
1106         chmod 640  joy0 joy1
1107         ;;
1108
1109 spigot)
1110         mknod spigot c 11 0
1111         chmod 444 spigot
1112         ;;
1113
1114 ctx?)
1115         unit=`expr $i : 'ctx\(.*\)'`
1116         mknod ctx$unit c 40 $unit
1117         chmod 444 ctx$unit
1118         ;;
1119
1120 meteor?)
1121         unit=`expr $i : 'meteor\(.*\)'`
1122         mknod meteor$unit c 67 $unit
1123         chmod 444 meteor$unit
1124         ;;
1125
1126 bktr?)
1127         unit=`expr $i : 'bktr\(.*\)'`
1128         mknod bktr$unit c 92 $unit
1129         mknod tuner$unit c 92 $((16 + $unit ))
1130         chmod 444 bktr$unit tuner$unit
1131         ;;
1132
1133 tun*)
1134         ntun=`expr $i : 'tun\(.*\)$'`
1135         unit=0
1136         while [ $unit -le $ntun ]; do
1137                 mknod tun$unit c 52 $unit
1138                 chown uucp.dialer tun$unit
1139                 unit=`expr $unit + 1`
1140         done
1141         ;;
1142
1143 sysmouse)
1144         mknod sysmouse c 12 128
1145         mknod consolectl c 12 255
1146         ;;
1147
1148 snp?)
1149         unit=`expr $i : 'snp\(.*\)'`
1150         mknod snp$unit c 53 $unit
1151         ;;
1152
1153 # dufault@hda.com: If I do much more work on other A-D boards
1154 # then eventually we'll have a "ad" and "dio" interface and some of these
1155 # "labpcaio" ones will be gone.
1156 # labpcaio: D-A and A-D.
1157 # labpcdio: Digital in and Digital out.
1158 #
1159 labpc*)
1160         umask 7
1161         case $i in
1162         labpcaio*)
1163                 name=labpcaio
1164                 unit=`expr $i : 'labpcaio\(.*\)'`
1165                 all="0 1 2 3 4 5 6 7"
1166                 offset=0
1167                 ;;
1168         labpcdio*)
1169                 name=labpcdio
1170                 unit=`expr $i : 'labpcdio\(.*\)'`
1171                 all="0 1 2 3"
1172                 offset=8
1173                 ;;
1174         *)
1175                 die 3 "Don't know LabPC type $i"
1176                 ;;
1177         esac
1178         if [ "X${unit}" = "X" ]; then
1179                 unit=all
1180         fi
1181         case $unit in
1182                 0|1|2|3|4|5|6|7)
1183                                 mknod $name$unit c 66 `expr $offset + $unit `
1184                 ;;
1185                 all)
1186                         for i in $all
1187                         do
1188                                 mknod $name$i c 66 `expr $offset + $i `
1189                         done
1190                         ;;
1191                 *)
1192                         echo "No such LabPC unit: $unit"
1193                         ;;
1194         esac
1195         umask 77
1196         ;;
1197
1198 perfmon)
1199         mknod perfmon c 2 32
1200         chgrp kmem perfmon
1201         chmod 640 perfmon
1202         ;;
1203
1204 ipl)
1205         mknod ipl c 79 0
1206         mknod ipnat c 79 1
1207         mknod ipstate c 79 2
1208         mknod ipauth c 79 3
1209         ;;
1210
1211 local)
1212         umask 0                 # XXX should be elsewhere
1213         sh MAKEDEV.local
1214         umask 77
1215         ;;
1216
1217 *)
1218         echo $i - no such device name
1219         ;;
1220
1221 esac
1222 done