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