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