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