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