etc/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 # $FreeBSD: src/etc/MAKEDEV,v 1.243.2.57 2003/02/10 11:35:53 simokawa Exp $
  24 # $DragonFly: src/etc/MAKEDEV,v 1.7 2004/03/17 19:20:12 dillon Exp $
  25 #
  26 # Device "make" file.  Valid arguments:
  27 #       all     makes all known devices, standard number of units (or close)
  28 #       std     standard devices
  29 #       jail    suitable for a jail(8)
  30 #       local   configuration specific devices
  31 #       mach-4  mach4&lites+devices for Mach's XFree86 distribution
  32 #       (see http://www.cs.hut.fi/lites.html for more info on LITES)
  33 #
  34 # Tapes:
  35 #       ast*    ATAPI tape drives
  36 #       wt*     QIC-interfaced (e.g. not SCSI) 3M cartridge tape
  37 #       sa*     SCSI Sequential Access Devices
  38 #
  39 # Disks:
  40 #       aac*    Adaptec FSA RAID controllers
  41 #       aacd*   Adaptec FSA RAID
  42 #       acd*    ATAPI CD-ROM disks
  43 #       ad*     ATA disks
  44 #       afd*    ATAPI floppy disks
  45 #       amrd*   AMI MegaRAID
  46 #       cd*     SCSI CD-ROM disks
  47 #       da*     SCSI Direct Access Devices
  48 #       fd*     floppy disk drives (3 1/2", 5 1/4")
  49 #       fla*    M-Systems DiskOnChip
  50 #       idad*   Compaq Smart-2 RAID arrays
  51 #       ips*    IBM ServeRAID controller
  52 #       ipsd*   IBM ServeRAID
  53 #       mcd*    Mitsumi CD-ROM disks
  54 #       md*     Memory (or malloc) disk
  55 #       mlx*    Mylex DAC960 RAID controllers
  56 #       mlxd*   Mylex DAC960 RAID disk volumes
  57 #       pst*    Promise SuperTrak RAID disks
  58 #       scd*    Sony CD-ROM disks
  59 #       vn*     vnode disks
  60 #
  61 # Console ports:
  62 #       vty*    virtual console devices for syscons/pcvt/codrv
  63 #
  64 # Pointing devices:
  65 #       mse*    Logitech and ATI Inport bus mouse
  66 #       psm*    PS/2 mouse
  67 #       jogdial Sony VAIO Jogdial
  68 #       sysmouse Mousesystems mouse emulator for syscons
  69 #
  70 # Time devices:
  71 #       refclock-* serial ports used by xntpd parse refclocks
  72 #
  73 # Terminal ports:
  74 #       tty*    general purpose serial ports
  75 #       cua*    dialout serial ports
  76 #       ttyA*   Specialix SI/XIO dialin ports ('*' = number of devices)
  77 #       cuaA*   Specialix SI/XIO dialout ports
  78 #       ttyD*   Digiboard - 16 dialin ports
  79 #       cuaD*   Digiboard - 16 dialout ports
  80 #       ttyE*   Stallion EasyIO (stl) dialin ports
  81 #       cuaE*   Stallion EasyIO (stl) dialout ports
  82 #       ttyF*   Stallion Brumby (stli) dialin ports
  83 #       cuaF*   Stallion Brumby (stli) dialout ports
  84 #       ttyR*   Rocketport dialin ports
  85 #       cuaR*   Rocketport dialout ports
  86 #
  87 #       stlN    Stallion EasyIO board N dialin and dialout
  88 #       stliN   Stallion Brumby board N dialin and dialout
  89 #
  90 # Pseudo terminals:
  91 #       pty*    set of 32 master and slave pseudo terminals
  92 #       vty*    virtual terminals using syscons/pcvt/codrv console
  93 #
  94 # Parallel port:
  95 #       lpt*    Printer
  96 #       ppi*    Parallel port i/o
  97 #       pps*    Pulse per second timing interface
  98 #       pcfclock* Parallel time sync interface
  99 #
 100 # I2C and SMBus:
 101 #       iic*    I2C devices
 102 #       smb*    SMBUS devices
 103 #
 104 # USB devices:
 105 #       usb*    USB bus control device
 106 #       ucom*   USB serial devices
 107 #       ugen*   generic USB device
 108 #       uhid*   Human Interface Device (HID)
 109 #       ulpt*   printer
 110 #       umodem* modems
 111 #       ums*    mouse
 112 #       urio*   Diamond Rio 500
 113 #       uscanner* USB scanners
 114 #
 115 # SCSI devices (other than CD-ROM, tape and disk):
 116 #       ch*     SCSI Media-Changer (juke box) driver
 117 #       pt*     Processor Type (HP scanner, as one example)
 118 #       pass*   CAM Passthrough device
 119 #       ses*    SES (SCSI Environmental Services) and
 120 #               SAF-TE (Scsi Accessable Fault-Tolerant Enclosures) device
 121 #
 122 # PC-CARD (previously called PCMCIA) support
 123 #       card*   PC-CARD slots
 124 #
 125 # ISDN devices:
 126 #       i4b     isdnd call control device
 127 #       i4bctl  debugging control device
 128 #       i4btrc* trace data interface(s), one per passive card
 129 #       i4btel* telephony interface(s)
 130 #       i4bteld* telephony dialout interface(s)
 131 #       i4brbch* raw b channel access device(s)
 132 #
 133 # Special purpose devices:
 134 #       apm     Advanced Power Management BIOS
 135 #       apmctl  APM BIOS control device
 136 #       bpf*    packet filter
 137 #       crypto  crypto interface
 138 #       speaker pc speaker
 139 #       tw*     xten power controller
 140 #       snd*    various sound cards
 141 #       pcaudio PCM audio driver
 142 #       socksys iBCS2 socket system driver
 143 #       vat     VAT compatibility audio driver (requires snd*)
 144 #       gsc     Genius GS-4500 hand scanner
 145 #       joy     pc joystick
 146 #       tun*    Tunneling IP device
 147 #       tap*    Ethernet Tunneling device
 148 #       snp*    tty snoop devices
 149 #       spigot  Video Spigot video acquisition card
 150 #       ctx*    Cortex-I video acquisition card
 151 #       meteor* Matrox Meteor video acquisition card (pci)
 152 #       bktr*   Bt848 based video acquisition card (pci)
 153 #       labpc*  National Instrument's Lab-PC and LAB-PC+
 154 #       perfmon CPU performance-monitoring counters
 155 #       pci     PCI configuration-space access from user mode
 156 #       ipl     ipfilter control devices (ipl, ipnat, ipstate, ipauth)
 157 #       kbd     keyboard devices
 158 #       elan-mmcr       AMD Elan support (e.g. mmap MMCR)
 159 #       agpgart AGP interface
 160 #       cfs*    Coda Distributed Filesystem
 161 #       nsmb*   SMB/CIFS protocol interface
 162 #
 163
 164 if [ -n "$MAKEDEVPATH" ]; then
 165         PATH="$MAKEDEVPATH"
 166 else
 167         PATH=/sbin:/bin
 168 fi
 169 umask 77
 170
 171 # Usage: die exitcode msg
 172 die() {
 173         echo $2
 174         exit $1
 175 }
 176
 177 # Convert integer to partition name
 178 dkitop() {
 179         local p
 180
 181         case $1 in
 182         0) p=a;; 1) p=b;; 2) p=c;; 3) p=d;; 4) p=e;; 5) p=f;; 6) p=g;; 7) p=h;;
 183         8) p=i;; 9) p=j;; 10) p=k;; 11) p=l;; 12) p=m;; 13) p=n;; 14) p=o;; 15) p=p;;
 184         *) p="?";;
 185         esac
 186         echo $p
 187 }
 188
 189 # Convert integer to slice name
 190 dkitos() {
 191         local s
 192
 193         case $1 in
 194         0) s="";;
 195         1) s="";;
 196         *) s=s$(($1-1));;
 197         esac
 198         echo $s
 199 }
 200
 201 # Convert disk (type, unit, slice, partition) to minor number
 202 dkminor()
 203 {
 204         echo $(($1 << 25 | ($2 / 32) << 21 | ($2 % 32) << 3 | $3 << 16 | ($4 & 7) | ($4 & 8) << 17))
 205 }
 206
 207 # Override mknod(2) to add extra handling to it.
 208 mknod=/sbin/mknod
 209 for i in `IFS=':'; echo $PATH`; do
 210         if [ -x "${i}/mknod" ]; then
 211                 mknod="${i}/mknod"
 212                 break
 213         fi
 214 done
 215 mknod() {
 216         rm -f "$1" || exit 1
 217         case $# in
 218         4) "$mknod" "$@" root:wheel || die 2 "$mknod $@ failed";;
 219         5) "$mknod" "$@"            || die 2 "$mknod $@ failed";;
 220         *) die 2 "bad node: mknod $@";;
 221         esac
 222 }
 223
 224 # Convert tape (ctrl, unit, mode, access) to minor number
 225 saminor()
 226 {
 227         echo $(($1 << 29 | ($2 / 16) << 16 | ($2 % 16) << 4 | $3 << 2 | $4))
 228 }
 229
 230 # Convert the last character of a tty name to a minor number.
 231 ttyminor()
 232 {
 233         case $1 in
 234         [0-9]) m=$1;;
 235         a) m=10;; b) m=11;; c) m=12;; d) m=13;; e) m=14;; f) m=15;; g) m=16;;
 236         h) m=17;; i) m=18;; j) m=19;; k) m=20;; l) m=21;; m) m=22;; n) m=23;;
 237         o) m=24;; p) m=25;; q) m=26;; r) m=27;; s) m=28;; t) m=29;; u) m=30;;
 238         v) m=31;;
 239         *) m="?";;
 240         esac
 241         echo $m
 242 }
 243
 244 # Convert a unit number to a minor number.
 245 unit2minor()
 246 {
 247   echo $(((($1 >> 8) << 16) | ($1 % 256)))
 248 }
 249
 250 # For the stallion devices tty[EF]
 251 # stallion major letter card iscallout
 252 stallion () {
 253         major=$1
 254         letter=$2
 255         card=$3
 256         iscallout=$4
 257
 258         port=0
 259         maxport=8
 260         pref=tty
 261         owner=
 262         minorbase=0
 263
 264         if [ $iscallout -gt 0 ]; then
 265             pref=cua
 266             owner=uucp:dialer
 267             minorbase=128
 268         fi
 269
 270         case "$card" in
 271         [0-7]);;
 272         *) die 1 "Invalid stl card number $card";;
 273         esac
 274
 275         # make the mem interface for extracting stats & loading microcode.
 276         # 0x1000000 + card number
 277         mknod staliomem$card c $major 0x0100000$card
 278
 279         while [ $port -lt $maxport ]; do
 280             minor=$(($minorbase + $card * 1048576 + $port))
 281             if [ $port -ge 32 ]; then
 282                 minor=$(($minor + 65504))
 283             fi
 284             unit=$(($card * 64 + $port))
 285
 286             mknod ${pref}${letter}$unit c $major $minor $owner
 287             mknod ${pref}i${letter}$unit c $major $(($minor + 32)) $owner
 288             mknod ${pref}l${letter}$unit c $major $(($minor + 64)) $owner
 289             port=$(($port + 1))
 290         done
 291 }
 292
 293 # Raw partition for disks
 294 dkrawpart=2
 295
 296 # Compatibility slice for disks
 297 dkcompatslice=0
 298
 299 # Raw slice for disks
 300 dkrawslice=1
 301
 302 # Standard umasks
 303 disk_umask=037                  # allow group operator to read disks
 304 tape_umask=017                  # allow group operator to read/write tapes
 305
 306 for i in $*; do
 307 case $i in
 308
 309 all)
 310         sh MAKEDEV std                                  # standard
 311         sh MAKEDEV fd0 fd1                              # bdev, floppy disk
 312         sh MAKEDEV da0 da1 da2 da3                      # bdev, SCSI disk
 313         sh MAKEDEV ata                                  # cdev, ATA control
 314         sh MAKEDEV ad0 ad1 ad2 ad3                      # bdev, ATA disk
 315         sh MAKEDEV ar0 ar1                              # bdev, ATA RAID disk
 316         sh MAKEDEV acd0 afd0 ast0                       # bdev, ATAPI devices
 317         sh MAKEDEV wd0 wd1 wd2 wd3                      # bdev, OLD disk
 318         sh MAKEDEV wcd0 wfd0 wst0                       # bdev, OLD ATAPI devs
 319         sh MAKEDEV vn0                                  # bdev, virtual disk
 320         sh MAKEDEV cd0 mcd0 scd0                        # bdev, cdrom
 321         sh MAKEDEV sa0 wt0                              # bdev, tape
 322         sh MAKEDEV vty12                                # cdev, virtual tty
 323         sh MAKEDEV cuaa0 cuaa1 cuaa2 cuaa3              # cdev, serial tty
 324         sh MAKEDEV pty0                                 # cdev, pseudo tty
 325         sh MAKEDEV ttyd0 ttyd1 ttyd2 ttyd3              # cdev, serial tty
 326         sh MAKEDEV zs0                                  # big-Alpha serial tty
 327         sh MAKEDEV kbd0 kbd1                            # cdev, keyboard
 328         sh MAKEDEV mse0 psm0 jogdial sysmouse           # cdev, mouse
 329         sh MAKEDEV pcaudio speaker snd0                 # cdev, noise
 330         sh MAKEDEV lpt0 lpt1 lpt2                       # cdev, printer
 331         sh MAKEDEV ppi0 ppi1 ppi2                       # cdev, parallel port
 332         sh MAKEDEV iic0 iic1                            # cdev, I2C device
 333         sh MAKEDEV smb0 smb1                            # cdev, SMBus device
 334         sh MAKEDEV usb usb0 uhid0 ums0 ulpt0 ugen0      # cdev, USB devices
 335         sh MAKEDEV usb1 uhid1 ums1 ulpt1 ugen1          # cdev, USB devices
 336         sh MAKEDEV usb2 usb3 usb4 usb5                  # cdev, USB devices
 337         sh MAKEDEV urio0 uscanner0 umodem0              # cdev, USB devices too
 338         sh MAKEDEV bpf0 bpf1 bpf2 bpf3                  # cdev, network
 339         sh MAKEDEV ipl tun0 tun1 tun2 tun3              # cdev, network
 340         sh MAKEDEV tap0 tap1 tap2 tap3                  # cdev, network
 341         sh MAKEDEV ch0 perfmon tw0                      # cdev, miscellaneous
 342         sh MAKEDEV apm apmctl card0 card1 card2 card3   # cdev, laptop
 343         sh MAKEDEV pass4 xpt2                           # cdev, CAM
 344         sh MAKEDEV i4b i4bctl i4btrc0 i4btrc1           # cdev, ISDN
 345         sh MAKEDEV i4btel0 i4btel1 i4bteld0 i4bteld1    # cdev, ISDN
 346         sh MAKEDEV i4brbch0 i4brbch1                    # cdev, ISDN
 347         sh MAKEDEV agpgart                              # cdev, AGP
 348         sh MAKEDEV nsmb0                                # cdev, SMB/CIFS
 349         sh MAKEDEV crypto                               # cdev, crypto
 350         sh MAKEDEV fw0 fw1 fw2 fw3 fwmem0               # cdev, firewire
 351         ;;
 352
 353 # a much restricted set of the above, to save precious i-nodes on the
 354 # fixit floppy
 355 fixit)
 356         sh MAKEDEV std                                  # standard
 357         sh MAKEDEV fd0                                  # bdev, floppy disk
 358         sh MAKEDEV da0                                  # bdev, SCSI disk
 359         sh MAKEDEV ad0                                  # bdev, ATA disk
 360         sh MAKEDEV acd0 afd0 ast0                       # bdev, ATAPI devices
 361         sh MAKEDEV wd0                                  # bdev, OLD disk
 362         sh MAKEDEV wcd0 wfd0 wst0                       # bdev, OLD ATAPI devs
 363         sh MAKEDEV vn0                                  # bdev, virtual disk
 364         sh MAKEDEV cd0                                  # bdev, cdrom
 365         sh MAKEDEV sa0                                  # bdev, tape
 366         sh MAKEDEV vty2                                 # cdev, virtual tty
 367         sh MAKEDEV cuaa0                                # cdev, serial tty
 368         sh MAKEDEV pty0                                 # cdev, pseudo tty
 369         sh MAKEDEV ttyd0                                # cdev, serial tty
 370         sh MAKEDEV zs0                                  # big-Alpha serial tty
 371         sh MAKEDEV kbd0                                 # cdev, keyboard
 372         sh MAKEDEV mse0 psm0 sysmouse                   # cdev, mouse
 373         sh MAKEDEV lpt0                                 # cdev, printer
 374         sh MAKEDEV ppi0                                 # cdev, parallel port
 375         sh MAKEDEV iic0                                 # cdev, I2C device
 376         sh MAKEDEV smb0                                 # cdev, SMBus device
 377         sh MAKEDEV ums0                                 # cdev, USB devices
 378         sh MAKEDEV tun0                                 # cdev, network
 379         sh MAKEDEV tap0                                 # cdev, network
 380         sh MAKEDEV ch0                                  # cdev, miscellaneous
 381         sh MAKEDEV apm apmctl card0                     # cdev, laptop
 382         sh MAKEDEV pass1 xpt1                           # cdev, CAM
 383         sh MAKEDEV i4b i4bctl i4btrc0 i4btrc1           # cdev, ISDN
 384         sh MAKEDEV i4btel0 i4bteld0                     # cdev, ISDN
 385         sh MAKEDEV i4brbch0                             # cdev, ISDN
 386         rm -f fd/[1-9]?
 387         ;;
 388
 389 std)
 390         mknod console   c 0 0;                  chmod 600 console
 391         mknod kmem      c 2 1 root:kmem;        chmod 640 kmem
 392         mknod mem       c 2 0 root:kmem;        chmod 640 mem
 393         mknod null      c 2 2;                  chmod 666 null
 394         mknod random    c 2 3;                  chmod 644 random
 395         mknod urandom   c 2 4;                  chmod 644 urandom
 396         mknod zero      c 2 12;                 chmod 666 zero
 397         mknod io        c 2 14;                 chmod 600 io
 398         mknod tty       c 1 0;                  chmod 666 tty
 399         mknod klog      c 7 0;                  chmod 600 klog
 400         mknod stdin     c 22 0;                 chmod 666 stdin
 401         mknod stdout    c 22 1;                 chmod 666 stdout
 402         mknod stderr    c 22 2;                 chmod 666 stderr
 403         mknod pci       c 78 0;                 chmod 644 pci
 404         mkdir -p fd
 405         (cd fd && i=0 &&
 406                 while [ $i -lt 64 ]; do
 407                         mknod $i c 22 $i
 408                         i=$(($i + 1))
 409                 done
 410         )
 411         chmod 555 fd
 412         chmod 666 fd/*
 413         ;;
 414
 415 jail)
 416         sh MAKEDEV std pty0
 417         rm mem kmem pci io klog console         # for security
 418         ln -sf null mem                 # for libkvm (ab)users
 419         ln -sf null kmem                # --//--
 420         ln -sf null console
 421         ;;
 422
 423 mach-4)
 424         mknod iopl c 22 0
 425         mknod kbd c 23 0
 426         mknod mouse c 24 0
 427         mknod time c 25 0
 428         mknod timezone c 26 0
 429         ;;
 430
 431 # Create device files for new Archive/Wangtek QIC-02 tape driver (vak)
 432 wt*)
 433         umask $tape_umask
 434         u=`expr $i : '..\(.*\)'`
 435         if [ -z "${u}" ]; then u=0; fi
 436         # default density, 512b blocks
 437         mknod rwt${u}   c 10 $(( 0 + $u)) root:operator
 438         mknod nrwt${u}  c 10 $(( 4 + $u)) root:operator
 439         # default density, 1024b blocks
 440 #       mknod rWt${u}   c 10 $((64 + $u)) root:operator
 441 #       mknod nrWt${u}  c 10 $((68 + $u)) root:operator
 442         mknod rwt${u}b  c 10 $((16 + $u)) root:operator # 60 megabytes
 443         mknod nrwt${u}b c 10 $((20 + $u)) root:operator
 444         mknod rwt${u}c  c 10 $((24 + $u)) root:operator # 120 megabytes
 445         mknod nrwt${u}c c 10 $((28 + $u)) root:operator
 446         mknod rwt${u}d  c 10 $((32 + $u)) root:operator # 150 megabytes
 447         mknod nrwt${u}d c 10 $((36 + $u)) root:operator
 448 #       mknod rwt${u}e  c 10 $((40 + $u)) root:operator # 300 megabytes?
 449 #       mknod nrwt${u}e c 10 $((44 + $u)) root:operator
 450 #       mknod rwt${u}f  c 10 $((48 + $u)) root:operator # 600 megabytes?
 451 #       mknod nrwt${u}f c 10 $((52 + $u)) root:operator
 452         umask 77
 453         ;;
 454
 455 # Individual slices.
 456 aacd*s*|ad*s*|ar*s*|afd*s*|amrd*s*|da*s*|fla*s*|idad*s*|ipsd*s*|md*s*|mlxd*s*|pst*s*|twed*s*|vn*s*|wd*s*|wfd*s*)
 457         umask $disk_umask
 458         case $i in
 459         aacd*s*) name=aacd; chr=151;;
 460         ad*s*) name=ad; chr=116;;
 461         ar*s*) name=ar; chr=157;;
 462         afd*s*) name=afd; chr=118;;
 463         amrd*s*) name=amrd; chr=133;;
 464         da*s*) name=da;  chr=13;;
 465         fla*s*) name=fla; chr=102;;
 466         idad*s*) name=idad; chr=109;;
 467         ipsd*s*) name=ipsd; chr=176;;
 468         md*s*) name=md;  chr=95;;
 469         mlxd*s*) name=mlxd; chr=131;;
 470         pst*s*) name=pst; chr=168;;
 471         twed*s*) name=twed; chr=147;;
 472         vn*s*) name=vn; chr=43;;
 473         wd*s*) name=wd;  chr=3;;
 474         wfd*s*) name=wfd; chr=87;;
 475         esac
 476         case $i in
 477         aacd*s*|amrd*s*|idad*s*|ipsd*s*|mlxd*s*|twed*s*)
 478                 unit=`expr $i : '....\([0-9]*\)s'`
 479                 slice=`expr $i : '....[0-9]*s\([0-9]*\)'`
 480                 part=`expr $i : '....[0-9]*s[0-9]*\(.*\)'`
 481                 ;;
 482         afd*s*|fla*s*|pst*s*|wfd*s*)
 483                 unit=`expr $i : '...\([0-9]*\)s'`
 484                 slice=`expr $i : '...[0-9]*s\([0-9]*\)'`
 485                 part=`expr $i : '...[0-9]*s[0-9]*\(.*\)'`
 486                 ;;
 487         *)
 488                 unit=`expr $i : '..\([0-9]*\)s'`
 489                 slice=`expr $i : '..[0-9]*s\([0-9]*\)'`
 490                 part=`expr $i : '..[0-9]*s[0-9]*\(.*\)'`
 491                 ;;
 492         esac
 493         case $unit in
 494         [0-9]|[0-9][0-9]|[0-4][0-9][0-9]|50[0-9]|51[0-1])
 495                 case $slice in
 496                 [0-9]|[1-2][0-9]|30)
 497                         oldslice=$slice
 498                         slice=$(($slice+1))
 499                         slicename=`dkitos $slice`
 500                         minor=`dkminor 0 $unit $slice $dkrawpart`
 501                         mknod  $name$unit$slicename c $chr $minor root:operator
 502                         rm -f r$name$unit$slicename
 503                         case $part in
 504                         [a-h])
 505                                 case $oldslice in
 506                                 0) slice=$oldslice ;;
 507                                 esac
 508                                 for part in 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
 509                                 do
 510                                         minor=`dkminor 0 $unit $slice $part`
 511                                         partname=`dkitop $part`
 512                                         mknod  $name$unit$slicename$partname \
 513                                               c $chr $minor root:operator
 514                                         rm -f r$name$unit$slicename$partname
 515                                 done
 516                                 ;;
 517                         "")
 518                                 ;;
 519                         *)
 520                                 echo bad partition for disk in: $i
 521                                 ;;
 522                         esac
 523                         ;;
 524                 *)
 525                         echo bad slice for disk in: $i
 526                         ;;
 527                 esac
 528                 ;;
 529         *)
 530                 echo bad unit for disk in: $i "(unit=$unit, slice=$slice, part=$part)"
 531                 ;;
 532         esac
 533         umask 77
 534         ;;
 535
 536 fd*)
 537         umask $disk_umask
 538         unit=`expr $i : '..\(.*\)'`
 539         name=fd; chr=9
 540         case $unit in
 541         0|1|2|3)
 542                 mknod ${name}${unit}   c $chr $(($unit * 64)) root:operator
 543                 rm -f r${name}${unit}
 544                 # Fake BSD partitions
 545                 for i in a b c d e f g h
 546                 do
 547                         ln -f ${name}${unit} ${name}${unit}$i
 548                         rm -f r${name}${unit} r${name}${unit}$i
 549                 done
 550                 # User-readable and programmer-readable name sets
 551
 552                 mknod ${name}${unit}.1720  c $chr $(($unit * 64 + 1)) \
 553                     root:operator
 554                 rm -f r${name}${unit}.1720
 555                 # ln -f ${name}${unit}.1720 ${name}${unit}135hs21
 556                 # rm -f r${name}${unit}135hs21
 557
 558                 mknod ${name}${unit}.1480  c $chr $(($unit * 64 + 2)) \
 559                     root:operator
 560                 rm -f r${name}${unit}.1480
 561                 # ln -f ${name}${unit}.1480 ${name}${unit}135hs18
 562                 # rm -f r${name}${unit}135hs18
 563                 # ln -f ${name}${unit}.1480 ${name}${unit}96hs18
 564                 # rm -f r${name}${unit}96hs18
 565
 566                 mknod ${name}${unit}.1440  c $chr $(($unit * 64 + 3)) \
 567                     root:operator
 568                 rm -f r${name}${unit}.1440
 569                 # ln -f ${name}${unit}.1440 ${name}${unit}135
 570                 # rm -f r${name}${unit}135
 571                 # ln -f ${name}${unit}.1440 ${name}${unit}135ds18
 572                 # rm -f r${name}${unit}135ds18
 573                 # ln -f ${name}${unit}.1440 ${name}${unit}96ds18
 574                 # rm -f r${name}${unit}96ds18
 575
 576                 mknod ${name}${unit}.1200  c $chr $(($unit * 64 + 4)) \
 577                     root:operator
 578                 rm -f r${name}${unit}.1200
 579                 # ln -f ${name}${unit}.1200 ${name}${unit}96
 580                 # rm -f r${name}${unit}96
 581                 # ln -f ${name}${unit}.1200 ${name}${unit}96ds15
 582                 # rm -f r${name}${unit}96ds15
 583                 # ln -f ${name}${unit}.1200 ${name}${unit}135ds15
 584                 # rm -f r${name}${unit}135ds15
 585
 586                 mknod ${name}${unit}.820  c $chr $(($unit * 64 + 5)) \
 587                     root:operator
 588                 rm -f r${name}${unit}.820
 589                 # ln -f ${name}${unit}.820 ${name}${unit}96hs10
 590                 # rm -f r${name}${unit}96hs10
 591                 # ln -f ${name}${unit}.820 ${name}${unit}135hs10
 592                 # rm -f r${name}${unit}135hs10
 593
 594                 mknod ${name}${unit}.800  c $chr $(($unit * 64 + 6)) \
 595                     root:operator
 596                 rm -f r${name}${unit}.800
 597                 # ln -f ${name}${unit}.800 ${name}${unit}96ds10
 598                 # rm -f r${name}${unit}96ds10
 599                 # ln -f ${name}${unit}.800 ${name}${unit}135ds10
 600                 # rm -f r${name}${unit}135ds10
 601
 602                 mknod ${name}${unit}.720  c $chr $(($unit * 64 + 7)) \
 603                     root:operator
 604                 rm -f r${name}${unit}.720
 605                 # ln -f ${name}${unit}.720 ${name}${unit}96ds9
 606                 # rm -f r${name}${unit}96ds9
 607                 # ln -f ${name}${unit}.720 ${name}${unit}135ds9
 608                 # rm -f r${name}${unit}135ds9
 609
 610                 mknod ${name}${unit}.360  c $chr $(($unit * 64 + 8)) \
 611                     root:operator
 612                 rm -f r${name}${unit}.360
 613                 # ln -f ${name}${unit}.360 ${name}${unit}48
 614                 # rm -f r${name}${unit}48
 615                 # ln -f ${name}${unit}.360 ${name}${unit}48ds9
 616                 # rm -f r${name}${unit}48ds9
 617
 618                 mknod ${name}${unit}.640  c $chr $(($unit * 64 + 9)) \
 619                     root:operator
 620                 rm -f r${name}${unit}.640
 621                 # ln -f ${name}${unit}.640 ${name}${unit}96ds8
 622                 # rm -f r${name}${unit}96ds8
 623                 # ln -f ${name}${unit}.640 ${name}${unit}135ds8
 624                 # rm -f r${name}${unit}135ds8
 625
 626                 mknod ${name}${unit}.1232  c $chr $(($unit * 64 + 10)) \
 627                     root:operator
 628                 rm -f r${name}${unit}.1232
 629                 # ln -f ${name}${unit}.1232 ${name}${unit}96ds8
 630                 # rm -f r${name}${unit}96ds8
 631                 # ln -f ${name}${unit}.1232 ${name}${unit}135ds8
 632                 # rm -f r${name}${unit}135ds8
 633                 ;;
 634         *)
 635                 echo bad unit for disk in: $i
 636                 ;;
 637         esac
 638         umask 77
 639         ;;
 640
 641 aacd*|ad*|ar*|afd*|amrd*|da*|fla*|idad*|ipsd*|md*|mlxd*|pst*|twed*|vn*|wd*|wfd*)
 642         umask $disk_umask
 643         case $i in
 644         aacd*) name=aacd; chr=151;;
 645         ad*) name=ad; chr=116;;
 646         ar*) name=ar; chr=157;;
 647         afd*) name=afd; chr=118;;
 648         amrd*) name=amrd; chr=133;;
 649         da*) name=da;  chr=13;;
 650         fla*) name=fla; chr=102;;
 651         idad*) name=idad; chr=109;;
 652         ipsd*) name=ipsd; chr=176;;
 653         md*) name=md; chr=95;;
 654         mlxd*) name=mlxd; chr=131;;
 655         pst*) name=pst; chr=168;;
 656         twed*) name=twed; chr=147;;
 657         vn*) name=vn; chr=43;;
 658         wd*) name=wd;  chr=3;;
 659         wfd*) name=wfd; chr=87;;
 660         esac
 661         case $i in
 662         aacd*|amrd*|idad*|ipsd*|mlxd*|twed*)
 663                 unit=`expr $i : '....\(.*\)'`
 664                 ;;
 665         afd*|fla*|pst*|wfd*)
 666                 unit=`expr $i : '...\(.*\)'`
 667                 ;;
 668         *)
 669                 unit=`expr $i : '..\(.*\)'`
 670                 ;;
 671         esac
 672         case $unit in
 673         [0-9]|[0-9][0-9]|[0-4][0-9][0-9]|50[0-9]|51[0-1])
 674                 for slicepartname in s0h s1h s2 s3 s4
 675                 do
 676                         sh MAKEDEV $name$unit$slicepartname
 677                 done
 678                 ;;
 679         *)
 680                 echo bad unit for disk in: $i
 681                 ;;
 682         esac
 683         umask 77
 684         ;;
 685
 686 ccd*)
 687         umask $disk_umask
 688         name=ccd
 689         chr=74
 690         unit=`expr $i : '...\(.*\)'`
 691         case $unit in
 692         [0-9]|[0-9][0-9]|[0-4][0-9][0-9]|50[0-9]|51[0-1])
 693                 for part in 0 1 2 3 4 5 6 7
 694                 do
 695                         minor=`dkminor 0 $unit 0 $part`
 696                         partname=`dkitop $part`
 697                         mknod  $name$unit$partname c $chr $minor root:operator
 698                         rm -f r$name$unit$partname
 699                 done
 700                 ;;
 701         *)
 702                 echo bad unit for disk in: $i
 703                 ;;
 704         esac
 705         umask 77
 706         ;;
 707
 708 # SCSI processor type driver
 709 pt[0-9]*)
 710         chr=61
 711         name=pt
 712         unit=`expr $i : 'pt\([0-9][0-9]*\)'`
 713         if [ -z "${unit}" ]; then
 714                 unit=0
 715         fi
 716         unit=$(($unit + 1 - 1))
 717         mknod ${name}${unit} c $chr `unit2minor $unit`
 718         ;;
 719
 720 # SCSI SES/SAF-TE type driver
 721 ses[0-9]*)
 722         chr=110
 723         name=ses
 724         unit=`expr $i : 'ses\([0-9][0-9]*\)'`
 725         if [ -z "${unit}" ]; then
 726                 unit=0
 727         fi
 728         unit=$(($unit + 1 - 1))
 729         mknod ${name}${unit} c $chr `unit2minor $unit`
 730         ;;
 731 # SCSI target mode sample driver
 732 targ[0-9]*)
 733         chr=65
 734         name=targ
 735         unit=`expr $i : 'targ\([0-9][0-9]*\)'`
 736         if [ -z "${unit}" ]; then
 737                 unit=0
 738         fi
 739         unit=$(($unit + 1 - 1))
 740         mknod ${name}${unit} c $chr `unit2minor $unit`
 741         mknod ${name}.ctl c $chr 0xffff00ff
 742         ;;
 743
 744 # CAM transport layer device
 745 xpt*)
 746         # This major number is temporary
 747         chr=104
 748         name=xpt
 749         units=`expr $i : 'xpt\(.*\)'`
 750         if [ -z "${units}" ]; then
 751                 units=1
 752         fi
 753         i=0
 754         while [ $i -lt $units ]; do
 755                 dname=$name$i
 756                 rm -rf $dname
 757                 mknod $dname c $chr `unit2minor $i` root:operator
 758                 i=$(($i + 1))
 759         done
 760         ;;
 761
 762 # CAM passthrough device
 763 pass*)
 764         # This major number is temporary
 765         chr=31
 766         name=pass
 767         units=`expr $i : 'pass\(.*\)'`
 768         if [ -z "${units}" ]; then
 769                 units=1
 770         fi
 771         i=0
 772         while [ $i -lt $units ]; do
 773                 dname=$name$i
 774                 rm -rf $dname
 775                 mknod $dname c $chr `unit2minor $i` root:operator
 776                 i=$(($i + 1))
 777         done
 778         ;;
 779 pty*)
 780         class=`expr $i : 'pty\(.*\)'`
 781         case $class in
 782         0) offset=0 name=p;;
 783         1) offset=32 name=q;;
 784         2) offset=64 name=r;;
 785         3) offset=96 name=s;;
 786 # Note that xterm (at least) only look at p-s.
 787         4) offset=128 name=P;;
 788         5) offset=160 name=Q;;
 789         6) offset=192 name=R;;
 790         7) offset=224 name=S;;
 791         # This still leaves [tuTU].
 792         *) echo bad unit for pty in: $i;;
 793         esac
 794         umask 0
 795         case $class in
 796         0|1|2|3|4|5|6|7)
 797                 i=0
 798                 while [ $i -lt 32 ]; do
 799 #                       This was an awk substr() before.
 800                         c=$(echo 0123456789abcdefghijklmnopqrstuv |
 801                             dd bs=1 skip=$i count=1 2>/dev/null)
 802                         mknod tty$name$c c 5 $(($offset + $i))
 803                         mknod pty$name$c c 6 $(($offset + $i))
 804                         i=$(($i + 1))
 805                 done
 806                 ;;
 807         esac
 808         umask 77
 809         ;;
 810
 811 sa*)
 812         umask $tape_umask
 813         unit=`expr $i : '..\(.*\)'`
 814         chr=14
 815
 816         case $unit in
 817         [0-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9])
 818                 mknod sa${unit}.ctl c $chr `saminor 1 ${unit} 0 0`
 819                 ln -f sa${unit}.ctl rsa${unit}.ctl
 820                 for m in 0 1 2 3
 821                 do
 822                         mknod sa${unit}.${m} c $chr \
 823                             `saminor 0 ${unit} ${m} 0`  root:operator
 824                         ln -f sa${unit}.${m} rsa${unit}.${m}
 825                         mknod nsa${unit}.${m} c $chr \
 826                             `saminor 0 ${unit} ${m} 1` root:operator
 827                         ln -f nsa${unit}.${m} nrsa${unit}.${m}
 828                         mknod esa${unit}.${m} c $chr \
 829                             `saminor 0 ${unit} ${m} 2` root:operator
 830                         ln -f esa${unit}.${m} ersa${unit}.${m}
 831                 done
 832                 ln -f sa${unit}.0 sa${unit}
 833                 ln -f sa${unit}.0 rsa${unit}.0
 834                 ln -f sa${unit}.0 rsa${unit}
 835                 ln -f nsa${unit}.0 nsa${unit}
 836                 ln -f nsa${unit}.0 nrsa${unit}.0
 837                 ln -f nsa${unit}.0 nrsa${unit}
 838                 ln -f esa${unit}.0 esa${unit}
 839                 ln -f esa${unit}.0 ersa${unit}.0
 840                 ln -f esa${unit}.0 ersa${unit}
 841                 ;;
 842         *)
 843                 echo bad unit for tape in: $i
 844                 ;;
 845         esac
 846         umask 77
 847         ;;
 848
 849 ch*)
 850         umask 37
 851         unit=`expr $i : '..\(.*\)'`
 852         case $i in
 853         ch*) name=ch;  chr=17;;
 854         esac
 855         case $unit in
 856         0|1|2|3|4|5|6)
 857                 mknod ${name}${unit}    c $chr $unit root:operator
 858                 ;;
 859         *)
 860                 echo bad unit for media changer in: $i
 861                 ;;
 862         esac
 863         umask 77
 864         ;;
 865
 866 ata)
 867         mknod ata c 159 0 root:operator
 868         ;;
 869 ast*)
 870         umask 2 ;
 871         unit=`expr $i : '...\(.*\)'`
 872         chr=119
 873         case $unit in
 874         0|1|2|3)
 875                 mknod ast${unit} c $chr $(($unit * 8 + 0)) root:operator
 876                 chmod 640 ast${unit}
 877                 mknod nast${unit} c $chr $(($unit * 8 + 1)) root:operator
 878                 chmod 640 nast${unit}
 879                 ;;
 880         *)
 881                 echo bad unit for tape in: $i
 882                 ;;
 883         esac
 884         umask 77
 885         ;;
 886
 887 acd*t*)
 888         umask $disk_umask
 889         units=`expr $i : '...\(.*\)t'`;
 890         tracks=`expr $i : '.*t\(.*\)'`;
 891         name=acd;
 892         chr=117;
 893         if [ -z "${units}" ]; then
 894                 units=0
 895         fi
 896         if [ -z "${tracks}" ]; then
 897                 tracks=100
 898         fi
 899         if [ "${units}" -le 31 -a "${tracks}" -le 169 ]; then
 900                 i=0
 901                 while [ $i -le $units ]; do
 902                         dname=$name$i
 903                         rm -rf ${dname}t*
 904                         j=1
 905                         while [ $j -le ${tracks} ]; do
 906                                 mknod ${dname}t$j c $chr \
 907                                         $((($i * 8) + (65536 * $j))) \
 908                                         root:operator
 909                                 j=$(($j + 1))
 910                         done
 911                         i=$(($i + 1))
 912                 done
 913         else
 914                 echo "$i is invalid -- can't have more than 32 cd devices or 169 tracks"
 915         fi
 916         umask 77
 917         ;;
 918
 919 acd*|cd*|mcd*|scd*)
 920         umask $disk_umask
 921         case $i in
 922         acd*) units=`expr $i : '...\(.*\)'`; name=acd; chr=117;;
 923         cd*) units=`expr $i : '..\(.*\)'`; name=cd; chr=15;;
 924         mcd*) units=`expr $i : '...\(.*\)'`; name=mcd; chr=29;;
 925         scd*) units=`expr $i : '...\(.*\)'`; name=scd; chr=45;;
 926         esac
 927         if [ -z "${units}" ]; then
 928                 units=0
 929         fi
 930         if [ "${units}" -le 31 ]; then
 931                 i=0
 932                 while [ $i -le $units ]; do
 933                         dname=$name$i
 934                         rm -rf ${dname}*
 935                         mknod ${dname}a c $chr $(($i * 8)) root:operator
 936                         case $name in
 937                         acd)
 938                                 ln -f ${dname}a ${dname}c;;
 939                         *)
 940                                 mknod ${dname}c c $chr $(($i * 8 + 2)) root:operator;;
 941                         esac
 942                         rm -f r${dname}a
 943                         rm -f r${dname}c
 944                         i=$(($i + 1))
 945                 done
 946         else
 947                 echo "$i is invalid -- can't have more than 32 cd devices"
 948         fi
 949         umask 77
 950         ;;
 951
 952 wcd*)
 953         umask 2 ;
 954         unit=`expr $i : '...\(.*\)'`
 955         chr=69
 956         case $unit in
 957         0|1|2|3|4|5|6|7)
 958                 mknod wcd${unit}a  c $chr $(($unit * 8 + 0)) root:operator
 959                 mknod wcd${unit}c  c $chr $(($unit * 8 + 2)) root:operator
 960                 ln -f wcd${unit}a rwcd${unit}a
 961                 ln -f wcd${unit}c rwcd${unit}c
 962                 chmod 640 wcd${unit}[a-h] rwcd${unit}[a-h]
 963                 ;;
 964         *)
 965                 echo bad unit for disk in: $i
 966                 ;;
 967         esac
 968         umask 77
 969         ;;
 970
 971 wst*)
 972         umask 2 ;
 973         unit=`expr $i : '...\(.*\)'`
 974         chr=90
 975         case $unit in
 976         0|1|2|3)
 977                 mknod rwst${unit} c $chr $(($unit * 8 + 0)) root:operator
 978                 chmod 640 rwst${unit}
 979                 ;;
 980         esac
 981         umask 77
 982         ;;
 983
 984 iic*)
 985         unit=`expr $i : 'iic\(.*\)'`
 986         mknod iic$unit c 105 `unit2minor $unit`
 987         ;;
 988
 989 smb*)
 990         unit=`expr $i : 'smb\(.*\)'`
 991         mknod smb$unit c 106 `unit2minor $unit`
 992         ;;
 993
 994 pcfclock*)
 995         unit=`expr $i : 'pcfclock\(.*\)'`
 996         mknod pcfclock$unit c 140 `unit2minor $unit`
 997         ;;
 998
 999 ppi*)
1000         unit=`expr $i : 'ppi\(.*\)'`
1001         mknod ppi$unit c 82 `unit2minor $unit`
1002         ;;
1003
1004 pps*)
1005         unit=`expr $i : 'pps\(.*\)'`
1006         mknod pps$unit c 89 `unit2minor $unit`
1007         ;;
1008
1009 usb)
1010         mknod usb c 108 255 root:operator
1011         chmod 0660 usb
1012         ;;
1013
1014 usb*)
1015         umask 7
1016         unit=`expr $i : 'usb\(.*\)'`
1017         mknod usb$unit c 108 `unit2minor $unit` root:operator
1018         umask 77
1019         ;;
1020
1021 ucom*)
1022         umask 7
1023         unit=`expr $i : 'ucom\(.*\)'`
1024         minor=$(($unit + 128))
1025         minor=`unit2minor $(($unit + 128))`
1026         mknod ucom$unit c 138 $minor uucp:dialer
1027         umask 77
1028         ;;
1029
1030 uhid*)
1031         umask 7
1032         unit=`expr $i : 'uhid\(.*\)'`
1033         mknod uhid$unit c 122 `unit2minor $unit` root:operator
1034         umask 77
1035         ;;
1036
1037 ums*)
1038         umask 7
1039         unit=`expr $i : 'ums\(.*\)'`
1040         mknod ums$unit c 111 `unit2minor $unit` root:operator
1041         umask 77
1042         ;;
1043
1044 ulpt*)
1045         unit=`expr $i : 'ulpt\(.*\)'`
1046         minor=`unit2minor $unit`
1047         mknod ulpt$unit c 113 $minor
1048         minor=`unit2minor $(($unit + 64))`
1049         mknod unlpt$unit c 113 $minor           # and the 'no prime' version
1050         ;;
1051
1052 ugen*)
1053         umask 7
1054         unit=`expr $i : 'ugen\([0-9][0-9]*\)'`
1055         endpoint=`expr $i : 'ugen.*\.\([0-9][0-9]*\)'`
1056         if [ -z "${unit}" ]; then
1057                 echo $i - Invalid unit number
1058         fi
1059         if [ -z "${endpoint}" ]; then           # ugen0 & ugen0.1 - ugen0.15
1060                 mknod ugen$unit c 114 \
1061                                 `unit2minor $(($unit * 16))` root:operator
1062                 i=1
1063                 while [ $i -lt 16 ]; do
1064                         mknod ugen$unit.$i c 114 \
1065                                 `unit2minor $(($unit * 16 + $i))` root:operator
1066                         i=$(($i + 1))
1067                 done
1068         else
1069                 minor=`unit2minor $(($unit * 16 + $endpoint))`
1070                 mknod ugen$unit.$endpoint c 114 $minor root:operator
1071         fi
1072         umask 77
1073         ;;
1074
1075 urio*)
1076         umask 7
1077         unit=`expr $i : 'urio\(.*\)'`
1078         mknod urio$unit c 143 `unit2minor $unit` root:operator
1079         umask 77
1080         ;;
1081
1082 uscanner*)
1083         umask 7
1084         unit=`expr $i : 'uscanner\(.*\)'`
1085         mknod uscanner$unit c 156 `unit2minor $unit` root:operator
1086         umask 77
1087         ;;
1088
1089 umodem*)
1090         umask 7
1091         unit=`expr $i : 'umodem\(.*\)'`
1092         mknod umodem$unit c 124 `unit2minor $unit` uucp:dialer
1093         umask 77
1094         ;;
1095
1096 lpt*)
1097         unit=`expr $i : 'lpt\(.*\)'`
1098         mknod lpt$unit c 16 `unit2minor $unit`
1099         mknod lpctl$unit c 16 `unit2minor $(($unit + 128))`
1100         ;;
1101
1102 # Use this to create virtual consoles for syscons, pcvt or codrv
1103 # ttyv0-b
1104 # use as MAKEDEV vtyNN to create NN entries
1105 vty*)
1106         chr=12
1107         units=`expr $i : 'vty\(.*\)'`
1108         i=0
1109         while [ $i -lt $units ]; do
1110                 mknod ttyv$(printf %01x $i) c $chr `unit2minor $i`
1111                 i=$(($i + 1))
1112         done
1113         ln -fs ttyv0 vga        # XXX X still needs this pccons relic
1114         ;;
1115
1116 nmdm*)
1117         units=`expr $i : 'nmdm\(.*\)'`
1118         chr=18
1119         i=0
1120         while [ $i -lt $units ]; do
1121                 minor=`unit2minor $i`
1122                 minor=$(($minor + $minor))
1123                 mknod nmdm${i}A c $chr $minor
1124                 mknod nmdm${i}B c $chr $(($minor + 1))
1125                 i=$(($i + 1))
1126         done
1127         ;;
1128
1129 bpf*)
1130         nbpf=`expr $i : 'bpf\(.*\)$'`
1131         unit=0
1132         while [ $unit -le $nbpf ]; do
1133                 mknod bpf$unit c 23 `unit2minor $unit`
1134                 unit=$(($unit + 1))
1135         done
1136         ;;
1137
1138 speaker)
1139         mknod speaker c 26 0
1140         ;;
1141
1142 cua?|cuaa?|cuaa??)
1143         umask 7
1144         unit_low=`expr $i : 'cua.*\(.\)$'`
1145         case $i in
1146         cua?|cuaa?)
1147                 unit_high=""
1148                 m_high=0
1149                 ;;
1150         cuaa??)
1151                 unit_high=`expr $i : 'cuaa\(.\).$'`
1152                 m_high=`ttyminor $unit_high`
1153                 ;;
1154         esac
1155         unit=$unit_high$unit_low
1156         m=$(($m_high << 16 | `ttyminor $unit_low`))
1157         mknod cuaa$unit c 28 $(($m | 128)) uucp:dialer
1158         mknod cuaia$unit c 28 $(($m | 32 | 128)) uucp:dialer
1159         mknod cuala$unit c 28 $(($m | 64 | 128)) uucp:dialer
1160         umask 77
1161         ;;
1162
1163 crypto)
1164         mknod crypto c 70 0 root:operator
1165         chmod 666 crypto
1166         ;;
1167
1168 fwmem*)
1169         unit=`expr $i : 'fwmem\(.*\)'`
1170         mknod fwmem$unit c 127 $((1<<24 | $unit)) root:operator
1171         chmod 660 fwmem$unit
1172         ;;
1173
1174 fw*)
1175         unit=`expr $i : 'fw\(.*\)'`
1176         mknod fw$unit c 127 $unit root:operator
1177         chmod 660 fw$unit
1178         ;;
1179
1180 tty?|tty0?|ttyd?|ttyd??)
1181         unit_low=`expr $i : 'tty.*\(.\)$'`
1182         case $i in
1183         tty?|tty0?|ttyd?)
1184                 unit_high=""
1185                 m_high=0
1186                 ;;
1187         ttyd??)
1188                 unit_high=`expr $i : 'ttyd\(.\).$'`
1189                 m_high=`ttyminor $unit_high`
1190                 ;;
1191         esac
1192         unit=$unit_high$unit_low
1193         m=$(($m_high << 16 | `ttyminor $unit_low`))
1194         mknod ttyd$unit c 28 $m
1195         mknod ttyid$unit c 28 $(($m | 32))
1196         mknod ttyld$unit c 28 $(($m | 64))
1197         ;;
1198
1199 cuac?)
1200         umask 7
1201         portlist="0 1 2 3 4 5 6 7 8 9 a b c d e f
1202                   g h i j k l m n o p q r s t u v"
1203         major=48
1204         card=`expr $i : 'cua.*\(.\)$'`
1205         for unit in $portlist
1206         do
1207                 minor=`ttyminor $unit`
1208                 minor=$(($card * 65536 + $minor))
1209                 name=$card$unit
1210                 mknod cuac$name c $major $(($minor + 128)) uucp:dialer
1211                 mknod cuaic$name c $major $(($minor + 32 + 128)) uucp:dialer
1212                 mknod cualc$name c $major $(($minor + 64 + 128)) uucp:dialer
1213         done
1214         umask 77
1215         ;;
1216
1217 ttyc?)
1218         portlist="0 1 2 3 4 5 6 7 8 9 a b c d e f
1219                   g h i j k l m n o p q r s t u v"
1220         major=48
1221         card=`expr $i : 'tty.*\(.\)$'`
1222         for unit in $portlist
1223         do
1224                 minor=`ttyminor $unit`
1225                 minor=$(($card * 65536 + $minor))
1226                 name=$card$unit
1227                 mknod ttyc$name c $major $minor
1228                 mknod ttyic$name c $major $(($minor + 32))
1229                 mknod ttylc$name c $major $(($minor + 64))
1230         done
1231         ;;
1232
1233 # RISCom8 'rc' driver entries
1234
1235 cuam?)
1236         umask 7
1237         unit=`expr $i : 'cua.*\(.\)$'`
1238         m=`ttyminor $unit`
1239         mknod cuam$unit c 63 $(($m + 128)) uucp:dialer
1240         umask 77
1241         ;;
1242
1243 ttym?)
1244         unit=`expr $i : 'tty.*\(.\)$'`
1245         m=`ttyminor $unit`
1246         mknod ttym$unit c 63 $m
1247         ;;
1248
1249 # Specialix SI/XIO.
1250 # Note: these are 'base 1' to match the numbers on the panels, and to match
1251 #       the manual that comes with the system.
1252 ttyA*)
1253         major=68
1254         nports=`expr $i : 'ttyA\(.*\)$'`
1255         port=1
1256         while [ $port -le $nports ]; do
1257                 minor=$(($port - 1))
1258                 name=$(printf %02d $port)
1259                 mknod ttyA$name c $major $minor
1260                 mknod ttyiA$name c $major $(($minor + 65536))
1261                 mknod ttylA$name c $major $(($minor + 131072))
1262                 port=$(($port + 1))
1263         done
1264         # For the user-mode control program, 'sicontrol'
1265         mknod si_control c 68 262144
1266         ;;
1267
1268 cuaA*)
1269         umask 7
1270         major=68
1271         nports=`expr $i : 'cuaA\(.*\)$'`
1272         port=1
1273         while [ $port -le $nports ]; do
1274                 minor=$(($port - 1))
1275                 name=$(printf %02d $port)
1276                 mknod cuaA$name c $major $(($minor + 128)) uucp:dialer
1277                 mknod cuaiA$name c $major $(($minor + 128 + 65536)) \
1278                     uucp:dialer
1279                 mknod cualA$name c $major $(($minor + 128 + 131072)) \
1280                     uucp:dialer
1281                 port=$(($port + 1))
1282         done
1283         umask 77
1284         ;;
1285
1286 # Alpha AS8[24]00 (TurboLaser) console.
1287 zs?)
1288         unit=`expr $i : 'zs.*\(.\)$'`
1289         m=`ttyminor $unit`
1290         mknod zs$unit c 135 $m
1291         ;;
1292
1293 # Digiboard PC/?? 16 port card.
1294 # The current scheme of minor numbering is:
1295 #
1296 #       unused{14} CARD{2} major{8} CALLOUT{1} LOCK{1} INIT{1} PORT{5}
1297 #
1298 #   CARD bitfield in future versions may be extended to 3 bits.
1299 #
1300 # See dgb(4)
1301 #
1302 ttyD?)
1303         portlist="0 1 2 3 4 5 6 7 8 9 a b c d e f"
1304         major=58
1305         card=`expr $i : 'tty.*\(.\)$'`
1306         for unit in $portlist
1307         do
1308                 minor=`ttyminor $unit`
1309                 minor=$(($card * 65536 + $minor))
1310                 name=$card$unit
1311                 mknod ttyD$name c $major $minor
1312                 mknod ttyiD$name c $major $(($minor + 32))
1313                 mknod ttylD$name c $major $(($minor + 64))
1314         done
1315         ;;
1316
1317 cuaD?)
1318         umask 7
1319         portlist="0 1 2 3 4 5 6 7 8 9 a b c d e f"
1320         major=58
1321         card=`expr $i : 'cua.*\(.\)$'`
1322         for unit in $portlist
1323         do
1324                 minor=`ttyminor $unit`
1325                 minor=$(($card * 65536 + $minor))
1326                 name=$card$unit
1327                 mknod cuaD$name c $major $(($minor + 128)) uucp:dialer
1328                 mknod cuaiD$name c $major $(($minor + 32 + 128)) uucp:dialer
1329                 mknod cualD$name c $major $(($minor + 64 + 128)) uucp:dialer
1330         done
1331         umask 77
1332         ;;
1333
1334 # Stallion multi serial cards (stl and stli drivers)
1335 #
1336 # These drivers reserve 64 minor devices per board, even if the board
1337 # supports only 4 devices.  We default to creating only 8 of the 64 devices
1338 # to keep /dev from getting too large (which => slow).  The last part of the
1339 # arg is the board number to create ports for.  So:
1340 #       ttyE0 will create 8 dialin ports ttyE0-ttyE7, plus ttyiE* and ttylE*
1341 #       cuaE0 will create 8 dialout ports cuaE0-cuaE7, plus cuaiE* and cualE*
1342 #       ttyE1 will create 8 dialin ports ttyE64-ttyE71, plus ttyiE* and ttylE*
1343 #       etc
1344 # If you have EasyConnect 8/32 or 8/64 cards, you will need to change the
1345 # definition of "maxport" below to get nodes for the full 32 or 64
1346 # ports per card.
1347 #
1348 # Note that the mapping of minor device numbers (with the hole between
1349 # 32-64k) is a bit odd to keep compatibility with ttyd? for
1350 # lock/initial devices.
1351 # Minor device field for the ports is
1352 #       card{3} unused{4} unit-msb{1} unused{8} callout{1} lock{1} init{1} unit-lsbs{5}
1353 # for the mem device is
1354 #       0x1000000 + card
1355 # (For stl, there is only 1 mem device per system; for stli, one per board)
1356
1357 ttyE*)
1358         stallion 72 E `expr $i : 'tty.*\(.\)$'` 0
1359         ;;
1360 cuaE*)
1361         stallion 72 E `expr $i : 'cua.*\(.\)$'` 1
1362         ;;
1363 stl*)
1364         card=`expr $i : 'stl\(.\)$'`
1365         stallion 72 E $card 0
1366         stallion 72 E $card 1
1367         ;;
1368
1369 ttyF*)
1370         stallion 75 F `expr $i : 'tty.*\(.\)$'` 0
1371         ;;
1372 cuaF*)
1373         stallion 75 F `expr $i : 'cua.*\(.\)$'` 1
1374         ;;
1375 stli*)
1376         card=`expr $i : 'stl\(.\)$'`
1377         stallion 75 F $card 0
1378         stallion 75 F $card 1
1379         ;;
1380
1381 ttyM*)
1382         portlist="0 1 2 3 4 5 6 7 8 9 a b c d e f"
1383         modulelist="a b c d"
1384         major=101
1385         card=`expr $i : 'tty.*\(.\)$'`
1386         for unit in $modulelist
1387         do
1388                 moduleminor=`ttyminor $unit`
1389                 moduleminor=$(($moduleminor % 10 * 16))
1390                 modulename=$unit
1391
1392                 for unit in $portlist
1393                 do
1394                         minor=`ttyminor $unit`
1395                         minor=$(($card * 65536 + $minor + $moduleminor))
1396                         name=$card$modulename$unit
1397                         rm -f tty*M$name
1398                         mknod ttyM$name c $major $minor
1399                         mknod ttyiM$name c $major $(($minor + 64))
1400                         mknod ttylM$name c $major $(($minor + 128))
1401                 done
1402         done
1403         ;;
1404
1405 cuaM?)
1406         umask 7
1407         portlist="0 1 2 3 4 5 6 7 8 9 a b c d e f"
1408         modulelist="a b c d"
1409         major=101
1410         card=`expr $i : 'cua.*\(.\)$'`
1411         for unit in $modulelist
1412         do
1413                 moduleminor=`ttyminor $unit`
1414                 moduleminor=$(($moduleminor % 10 * 16))
1415                 modulename=$unit
1416
1417                 for unit in $portlist
1418                 do
1419                         minor=`ttyminor $unit`
1420                         minor=$(($card * 65536 + $minor + $moduleminor))
1421                         name=$card$modulename$unit
1422                         rm -f cua*M$name
1423                         mknod cuaM$name c $major $(($minor + 262144)) \
1424                             uucp:dialer
1425                         mknod cuaiM$name c $major $(($minor + 64 + 262144)) \
1426                             uucp:dialer
1427                         mknod cualM$name c $major $(($minor + 128 + 262144)) \
1428                             uucp:dialer
1429                 done
1430         done
1431         umask 77
1432         ;;
1433
1434 ttyR?)
1435         major=81
1436         BOARD=1; Rnum=0
1437         MINOR=$(($BOARD * 65536))
1438         controllers=$(
1439                 dmesg | while read first rest; do
1440                         case "$first" in
1441                         RocketPort[0-4])
1442                                 echo "$first"
1443                                 ;;
1444                         esac
1445                 done
1446         )
1447         rm -f ttyR* ttyiR* ttylR*
1448         for i in $controllers; do
1449            ndevices=$(
1450                 dmesg | while read first bar ports rest; do
1451                         case "$first" in
1452                         $i*)
1453                                 echo "$ports"
1454                                 ;;
1455                         esac
1456                 done
1457            )
1458            echo -n "Creating $ndevices devices for $i: "
1459            dev=0
1460            while [ $dev -lt $ndevices ]; do
1461                    mknod ttyR$Rnum c $major $MINOR
1462                    mknod ttyiR$Rnum c $major $(($MINOR + 32))
1463                    mknod ttylR$Rnum c $major $(($MINOR + 64))
1464                    Rnum=$(($Rnum + 1))
1465                    MINOR=$(($MINOR + 1))
1466                    dev=$(($dev + 1))
1467            done
1468                 BOARD=$(($BOARD + 1))
1469                 MINOR=$(($BOARD * 65536))
1470            echo " "
1471         done
1472         ;;
1473
1474 cuaR?)
1475         major=81
1476         BOARD=1; Rnum=0
1477         MINOR=$(($BOARD * 65536))
1478         controllers=$(
1479                 dmesg | while read first rest; do
1480                         case "$first" in
1481                         RocketPort[0-4])
1482                                 echo "$first"
1483                                 ;;
1484                         esac
1485                 done
1486         )
1487         rm -f cuaR* cuaiR* cualR*
1488         for i in $controllers; do
1489            ndevices=$(
1490                 dmesg | while read first bar ports rest; do
1491                         case "$first" in
1492                         $i*)
1493                                 echo "$ports"
1494                                 ;;
1495                         esac
1496                 done
1497            )
1498            echo -n "Creating $ndevices devices for $i: "
1499            dev=0
1500            while [ $dev -lt $ndevices ]; do
1501                    mknod cuaR$Rnum c  $major $(($MINOR + 128)) uucp:dialer
1502                    mknod cuaiR$Rnum c $major $(($MINOR + 128 + 32)) \
1503                        uucp:dialer
1504                    mknod cualR$Rnum c $major $(($MINOR + 128 + 64)) \
1505                        uucp:dialer
1506                    Rnum=$(($Rnum + 1))
1507                    MINOR=$(($MINOR + 1))
1508                    dev=$(($dev + 1))
1509            done
1510                 BOARD=$(($BOARD + 1))
1511                 MINOR=$(($BOARD * 65536))
1512            echo " "
1513         done
1514         ;;
1515
1516 mse*)
1517         unit=`expr $i : 'mse\(.*\)'`
1518         chr=27
1519         # non-blocking for X11
1520         mknod mse$unit c $chr `unit2minor $(($unit * 2 + 1))`
1521         ;;
1522
1523 psm*)
1524         unit=`expr $i : 'psm\(.*\)'`
1525         chr=21
1526         # non-blocking for X11
1527         mknod psm$unit c $chr `unit2minor $(($unit * 2 + 1))`
1528         ;;
1529
1530 mouse*)
1531         name=`expr $i : 'mouse\(.*\)'`
1532         if [ ! -c $name ]; then
1533                 $0 $name                        # make the appropriate device
1534         fi
1535         ln -fs $name mouse
1536         ;;
1537
1538 pcaudio)
1539         mknod pcaudio c 24 0
1540         mknod pcaudioctl c 24 128
1541         ;;
1542
1543 socksys)
1544         mknod socksys c 41 0
1545         mknod spx c 41 1
1546         ln -fs socksys nfsd
1547         chmod 666 socksys nfsd spx
1548         ;;
1549
1550 snd*)
1551 #
1552 # changes from Linux voxware
1553 # minor         Linux                   FreeBSD
1554 # 8             sequencer2 (aka music0) music0
1555 # 17            patmgr0                 sequencer1
1556 # 33            patmgr1                 sequencer2
1557 #
1558
1559         unit=`expr $i : 'snd\(.*\)'`
1560         chr=30
1561
1562         # XXX write this less verbosely, like std
1563         snd_security_hole=0     # XXX
1564         umask $snd_security_hole
1565
1566         ln -fs mixer$unit mixer
1567         ln -fs sequencer$unit sequencer
1568         ln -fs dsp$unit dsp
1569         ln -fs audio$unit audio
1570         ln -fs dspW$unit dspW
1571         ln -fs music$unit music
1572         ln -fs pss$unit pss
1573         ln -fs dsp$unit.0 dsp$unit
1574         ln -fs audio$unit.0 audio$unit
1575         ln -fs dspW$unit.0 dspW$unit
1576
1577         mknod mixer$unit        c $chr `unit2minor $(($unit * 16 + 0))`
1578         mknod sequencer$unit    c $chr `unit2minor $(($unit * 16 + 1))`
1579         mknod midi$unit         c $chr `unit2minor $(($unit * 16 + 2))`
1580
1581         for chn in 0 1 2 3
1582         do
1583                 minor=$(($chn * 65536 + $unit * 16))
1584                 mknod dsp$unit.$chn     c $chr $(($minor + 3))
1585                 mknod audio$unit.$chn   c $chr $(($minor + 4))
1586                 mknod dspW$unit.$chn    c $chr $(($minor + 5))
1587         done
1588
1589         mknod sndstat           c $chr 6
1590                                 # minor number 7 is unused
1591         mknod music$unit        c $chr `unit2minor $(($unit * 16 + 8))`
1592         mknod pss$unit          c $chr `unit2minor $(($unit * 16 + 9))`
1593                                 # minor numbers 10-15 are unused
1594         umask 77
1595         ;;
1596
1597 vat)
1598         mknod vatio c 25 128
1599         chmod 660 vatio
1600         ;;
1601
1602 gsc*)
1603         unit=`expr $i : 'gsc\(.*\)'`
1604         mknod gsc${unit} c 47 `unit2minor $unit`
1605         mknod gsc${unit}p c 47 `unit2minor $(($unit + 8))`
1606         mknod gsc${unit}d c 47 `unit2minor $(($unit + 32))`
1607         mknod gsc${unit}pd c 47 `unit2minor $(($unit + 40))`
1608         chmod 666 gsc${unit}*
1609         ;;
1610
1611 apm)
1612         mknod apm c 39 0 root:operator
1613         chmod 664 apm
1614         ;;
1615
1616 apmctl)
1617         mknod apmctl c 39 8 root:operator
1618         chmod 660 apmctl
1619         ;;
1620
1621 card*)
1622         unit=`expr $i : 'card\(.*\)'`
1623         chr=50
1624         mknod card$unit c $chr `unit2minor $unit`
1625         chmod 644 card$unit
1626         ;;
1627
1628 ttyx?|ttyy?|ttyz?)
1629         case $i in
1630         *0) unit=0;;    *1) unit=1;;    *2) unit=2;;    *3) unit=3;;
1631         *4) unit=4;;    *5) unit=5;;    *6) unit=6;;    *7) unit=7;;
1632         *8) unit=8;;    *9) unit=9;;    *a) unit=10;;   *b) unit=11;;
1633         *c) unit=12;;   *d) unit=13;;   *e) unit=14;;   *f) unit=15;;
1634         esac
1635         case $i in
1636         ttyy?)  unit=$(($unit + 16));;
1637         ttyz?)  unit=$(($unit + 32));;
1638         esac
1639         mknod $i c 42 $unit
1640         ;;
1641
1642 cronyx)
1643         mknod cronyx c 42 63
1644         ;;
1645
1646 joy)
1647         mknod joy0 c 51 0 root:operator
1648         mknod joy1 c 51 1 root:operator
1649         chmod 640  joy0 joy1
1650         ;;
1651
1652 spigot)
1653         mknod spigot c 11 0
1654         chmod 444 spigot
1655         ;;
1656
1657 ctx?)
1658         unit=`expr $i : 'ctx\(.*\)'`
1659         mknod ctx$unit c 40 `unit2minor $unit`
1660         chmod 444 ctx$unit
1661         ;;
1662
1663 meteor?)
1664         unit=`expr $i : 'meteor\(.*\)'`
1665         mknod meteor$unit c 67 `unit2minor $unit`
1666         chmod 444 meteor$unit
1667         ;;
1668
1669 bktr?)
1670         unit=`expr $i : 'bktr\(.*\)'`
1671         mknod bktr$unit c 92 `unit2minor $unit`
1672         mknod tuner$unit c 92 `unit2minor $((16 + $unit))`
1673         mknod vbi$unit c 92 `unit2minor $((32 + $unit))`
1674         chmod 444 bktr$unit tuner$unit vbi$unit
1675         ;;
1676
1677 tun*)
1678         ntun=`expr $i : 'tun\(.*\)$'`
1679         unit=0
1680         while [ $unit -le $ntun ]; do
1681                 mknod tun$unit c 52 `unit2minor $unit`
1682                 unit=$(($unit + 1))
1683         done
1684         ;;
1685
1686 tap*)
1687         ntap=`expr $i : 'tap\(.*\)$'`
1688         unit=0
1689         while [ $unit -le $ntap ]; do
1690                 mknod tap$unit c 149 `unit2minor $unit` root:network
1691                 unit=$(($unit + 1))
1692         done
1693         ;;
1694
1695 sysmouse)
1696         mknod sysmouse c 12 128
1697         mknod consolectl c 12 255
1698         ;;
1699
1700 jogdial)
1701         mknod jogdial c 160 0
1702         ;;
1703
1704 snp?)
1705         unit=`expr $i : 'snp\(.*\)'`
1706         mknod snp$unit c 53 `unit2minor $unit`
1707         ;;
1708
1709 # dufault@hda.com: If I do much more work on other A-D boards
1710 # then eventually we'll have a "ad" and "dio" interface and some of these
1711 # "labpcaio" ones will be gone.
1712 # labpcaio: D-A and A-D.
1713 # labpcdio: Digital in and Digital out.
1714 #
1715 labpc*)
1716         umask 7
1717         case $i in
1718         labpcaio*)
1719                 name=labpcaio
1720                 unit=`expr $i : 'labpcaio\(.*\)'`
1721                 all="0 1 2 3 4 5 6 7"
1722                 offset=0
1723                 ;;
1724         labpcdio*)
1725                 name=labpcdio
1726                 unit=`expr $i : 'labpcdio\(.*\)'`
1727                 all="0 1 2 3"
1728                 offset=8
1729                 ;;
1730         *)
1731                 die 3 "Don't know LabPC type $i"
1732                 ;;
1733         esac
1734         if [ -z "${unit}" ]; then
1735                 unit=all
1736         fi
1737         case $unit in
1738                 0|1|2|3|4|5|6|7)
1739                                 mknod $name$unit c 66 $(($offset + $unit))
1740                 ;;
1741                 all)
1742                         for i in $all
1743                         do
1744                                 mknod $name$i c 66 $(($offset + $i))
1745                         done
1746                         ;;
1747                 *)
1748                         echo "No such LabPC unit: $unit"
1749                         ;;
1750         esac
1751         umask 77
1752         ;;
1753
1754 perfmon)
1755         mknod perfmon c 2 32 root:kmem
1756         chmod 640 perfmon
1757         ;;
1758
1759 ipl)
1760         mknod ipl c 79 0
1761         mknod ipnat c 79 1
1762         mknod ipstate c 79 2
1763         mknod ipauth c 79 3
1764         ;;
1765
1766 elan*)
1767         mknod elan-mmcr c 100 0 # XXX local major
1768         chmod 600 elan-mmcr
1769         ;;
1770
1771 kbd*)
1772         unit=`expr $i : 'kbd\(.*\)'`
1773         chr=112
1774         mknod kbd$unit c $chr `unit2minor $unit`
1775         ;;
1776
1777 i4b)
1778         mknod i4b c 60 0
1779         ;;
1780
1781 i4bctl)
1782         mknod i4bctl c 55 0
1783         ;;
1784
1785 i4brbch*)
1786         unit=`expr $i : 'i4brbch\(.*\)'`
1787         mknod i4brbch$unit c 57 `unit2minor $unit`
1788         ;;
1789
1790 i4bteld*)
1791         offset=64
1792         unit=`expr $i : 'i4bteld\(.*\)'`
1793         mknod i4bteld$unit c 56 `unit2minor $(($offset + $unit))`
1794         ;;
1795
1796 i4btel*)
1797         unit=`expr $i : 'i4btel\(.*\)'`
1798         mknod i4btel$unit c 56 `unit2minor $unit`
1799         ;;
1800
1801 i4btrc*)
1802         unit=`expr $i : 'i4btrc\(.*\)'`
1803         mknod i4btrc$unit c 59 `unit2minor $unit`
1804         ;;
1805
1806 aac*)
1807         unit=`expr $i : 'aac\(.*\)'`
1808         mknod aac$unit c 150 `unit2minor $unit`
1809         ln -fs aac$unit afa$unit
1810         ln -fs aac$unit hpn$unit
1811         ;;
1812
1813 mlx*)
1814         unit=`expr $i : 'mlx\(.*\)'`
1815         mknod mlx$unit c 130 `unit2minor $unit`
1816         ;;
1817
1818 amr*)
1819         unit=`expr $i : 'amr\(.*\)'`
1820         mknod amr$unit c 132 `unit2minor $unit`
1821         ;;
1822
1823 ips*)
1824         unit=`expr $i : 'ips\(.*\)'`
1825         mknod mlx$unit c 175 `unit2minor $unit`
1826         ;;
1827
1828 ciss*)
1829         unit=`expr $i : 'ciss\(.*\)'`
1830         mknod ciss$unit c 166 `unit2minor $unit`
1831         ;;
1832
1833 agpgart)
1834         mknod agpgart c 148 0
1835         ;;
1836
1837 twe*)
1838         unit=`expr $i : 'twe\(.*\)'`
1839         mknod twe$unit c 146 `unit2minor $unit`
1840         ;;
1841
1842 tw*)
1843         unit=`expr $i : 'tw\(.*\)'`
1844         mknod tw$unit c 19 `unit2minor $unit` root:operator
1845         ;;
1846
1847 cfs*)
1848         unit=`expr $i : 'cfs\(.*\)'`
1849         mknod cfs$unit c 93 $unit root:operator
1850         ;;
1851
1852 nsmb*)
1853         unit=`expr $i : 'nsmb\(.*\)'`
1854         mknod nsmb$unit c 144 $unit
1855         ;;
1856
1857 local)
1858         umask 0                 # XXX should be elsewhere
1859         sh MAKEDEV.local
1860         umask 77
1861         ;;
1862
1863 *)
1864         echo $i - no such device name
1865         ;;
1866
1867 esac
1868 done