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