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