1130b656e5
This will make a number of things easier in the future, as well as (finally!) avoiding the Id-smashing problem which has plagued developers for so long. Boy, I'm glad we're not using sup anymore. This update would have been insane otherwise.
1221 lines
30 KiB
Bash
1221 lines
30 KiB
Bash
#!/bin/sh -
|
|
#
|
|
# Copyright (c) 1990 The Regents of the University of California.
|
|
# All rights reserved.
|
|
#
|
|
# Written and contributed by W. Jolitz 12/90
|
|
#
|
|
# Redistribution and use in source and binary forms are permitted provided
|
|
# that: (1) source distributions retain this entire copyright notice and
|
|
# comment, and (2) distributions including binaries display the following
|
|
# acknowledgement: ``This product includes software developed by the
|
|
# University of California, Berkeley and its contributors'' in the
|
|
# documentation or other materials provided with the distribution and in
|
|
# all advertising materials mentioning features or use of this software.
|
|
# Neither the name of the University nor the names of its contributors may
|
|
# be used to endorse or promote products derived from this software without
|
|
# specific prior written permission.
|
|
# THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
|
# WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
|
# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
#
|
|
# @(#)MAKEDEV 5.2 (Berkeley) 6/22/90
|
|
#
|
|
# Device "make" file. Valid arguments:
|
|
# all makes all known devices, standard number of units (or close)
|
|
# std standard devices
|
|
# local configuration specific devices
|
|
# mach-4 mach4&lites+devices for Mach's XFree86 distribution
|
|
# (see http://www.cs.hut.fi/lites.html for more info on LITES)
|
|
#
|
|
# Tapes:
|
|
# wt* QIC-interfaced (e.g. not SCSI) 3M cartridge tape
|
|
# st* "NEW type scsi tapes" (old driver uses the
|
|
# block devices of the disks to get access)
|
|
# ft* QIC-40/QIC-80 3M cartridge tape (interfaced
|
|
# via the floppy disk controller)
|
|
#
|
|
# Disks:
|
|
# wd* "Winchester" disk drives (ST506,IDE,ESDI,RLL,...)
|
|
# fd* "floppy" disk drives (3 1/2", 5 1/4")
|
|
# sd* "SCSI disks"
|
|
# cd* "SCSI CD-ROM disks"
|
|
# mcd* "Mitsumi CD-ROM disks"
|
|
# scd* "Sony CD-ROM disks"
|
|
# matcd* "Matsushita (Panasonic) CD-ROM disks"
|
|
# wcd* "IDE CD-ROM disks"
|
|
# vn* "vnode disks"
|
|
# od* "optical disks"
|
|
#
|
|
# Console ports:
|
|
# vty* virtual console devices for syscons/pcvt/codrv
|
|
#
|
|
# Pointing devices:
|
|
# mse* Logitech and ATI Inport bus mouse
|
|
# psm* PS/2 mouse
|
|
# sysmouse Mousesystems mouse emulator for syscons
|
|
#
|
|
# Time devices:
|
|
# refclock-* serial ports used by xntpd parse refclocks
|
|
#
|
|
# Terminal ports:
|
|
# tty* general purpose serial ports
|
|
# cua* dialout serial ports
|
|
# ttyA* Specialix SI/XIO dialin ports ('*' = number of devices)
|
|
# cuaA* Specialix SI/XIO dialout ports
|
|
# ttyD* Digiboard - 16 dialin ports
|
|
# cuaD* Digiboard - 16 dialout ports
|
|
#
|
|
# Pseudo terminals:
|
|
# pty* set of 32 master and slave pseudo terminals
|
|
# vty* virtual terminals using syscons/pcvt/codrv console
|
|
#
|
|
# Printers:
|
|
# lpt* stock lp
|
|
#
|
|
# SCSI devices (other than CD-ROM, tape and disk):
|
|
# uk* "unknown" device (supports ioctl calls only)
|
|
# worm* WORM driver
|
|
# pt* Processor Type (HP scanner, as one example)
|
|
#
|
|
# PC-CARD (previously called PCMCIA) support
|
|
# card* PC-CARD slots
|
|
#
|
|
# Special purpose devices:
|
|
# apm Advanced Power Management BIOS
|
|
# bpf* packet filter
|
|
# speaker pc speaker
|
|
# tw* xten power controller
|
|
# snd* various sound cards
|
|
# pcaudio PCM audio driver
|
|
# socksys iBCS2 socket system driver
|
|
# vat VAT compatibility audio driver (requires snd*)
|
|
# gsc Genius GS-4500 hand scanner
|
|
# joy pc joystick
|
|
# tun* Tunneling IP device
|
|
# snp* tty snoop devices
|
|
# spigot Video Spigot video acquisition card
|
|
# meteor* Matrox Meteor video acquisition card (pci)
|
|
# qcam* Connectix QuickCam(tm) parallel port camera
|
|
# isdn* ISDN devices
|
|
# labpc* National Instrument's Lab-PC and LAB-PC+
|
|
# perfmon CPU performance-monitoring counters
|
|
# pci PCI configuration-space access from user mode
|
|
#
|
|
# $FreeBSD$
|
|
#
|
|
|
|
PATH=/sbin:/bin/:/usr/bin:/usr/sbin:$PATH
|
|
umask 77
|
|
|
|
# Convert integer to partition name
|
|
dkitop() {
|
|
local p
|
|
|
|
case $1 in
|
|
0) p=a;; 1) p=b;; 2) p=c;; 3) p=d;; 4) p=e;; 5) p=f;; 6) p=g;; 7) p=h;;
|
|
*) p="?";;
|
|
esac
|
|
echo $p
|
|
}
|
|
|
|
# Convert integer to slice name
|
|
dkitos() {
|
|
local s
|
|
|
|
case $1 in
|
|
0) s="";;
|
|
1) s="";;
|
|
*) s=s$(($1-1));;
|
|
esac
|
|
echo $s
|
|
}
|
|
|
|
# Convert disk (type, unit, slice, partition) to minor number
|
|
dkminor()
|
|
{
|
|
echo $((32 * 65536 * $1 + 8 * $2 + 65536 * $3 + $4))
|
|
}
|
|
|
|
# Convert the last character of a tty name to a minor number.
|
|
ttyminor()
|
|
{
|
|
case $unit in
|
|
[0-9]) m=$unit;;
|
|
a) m=10;; b) m=11;; c) m=12;; d) m=13;; e) m=14;; f) m=15;; g) m=16;;
|
|
h) m=17;; i) m=18;; j) m=19;; k) m=20;; l) m=21;; m) m=22;; n) m=23;;
|
|
o) m=24;; p) m=25;; q) m=26;; r) m=27;; s) m=28;; t) m=29;; u) m=30;;
|
|
v) m=31;;
|
|
*) m="?";;
|
|
esac
|
|
echo $m
|
|
}
|
|
|
|
# Raw partition for disks
|
|
dkrawpart=2
|
|
|
|
# Compatibility slice for disks
|
|
dkcompatslice=0
|
|
|
|
# Raw slice for disks
|
|
dkrawslice=1
|
|
|
|
# Control bit for SCSI
|
|
scsictl=536870912
|
|
|
|
# Standard umasks
|
|
disk_umask=037 # allow group operator to read disks
|
|
tape_umask=017 # allow group operator to read/write tapes
|
|
|
|
for i
|
|
do
|
|
case $i in
|
|
|
|
all)
|
|
sh MAKEDEV std # standard
|
|
sh MAKEDEV wd0 wd1 wd2 wd3 fd0 fd1 sd0 sd1 sd2 sd3 # bdev, disk
|
|
sh MAKEDEV cd0 mcd0 scd0 matcd0 wcd0 # bdev, cdrom
|
|
sh MAKEDEV od0 # bdev, ODD
|
|
sh MAKEDEV ft0 wt0 st0 # bdev, tape
|
|
sh MAKEDEV ttyd0 ttyd1 ttyd2 ttyd3 # cdev, serial
|
|
sh MAKEDEV cuaa0 cuaa1 cuaa2 cuaa3 # cdev, serial
|
|
sh MAKEDEV lpt0 lpt1 lpt2 # cdev, printer
|
|
sh MAKEDEV pty0 ch0 tw0 bpf0 # cdev
|
|
sh MAKEDEV perfmon speaker pcaudio psm0 mse0 sysmouse # cdev
|
|
sh MAKEDEV vty4 # cdev
|
|
sh MAKEDEV tun0 # cdev
|
|
sh MAKEDEV apm card0 card1 # cdev, laptop
|
|
;;
|
|
std)
|
|
rm -f console drum mem kmem null random urandom zero io tty klog
|
|
rm -f stdin stdout stderr lkm pci
|
|
mknod console c 0 0; chmod 600 console; chown root.wheel console
|
|
mknod drum c 4 0; chmod 640 drum; chown root.kmem drum
|
|
mknod kmem c 2 1; chmod 640 kmem; chown root.kmem kmem
|
|
mknod mem c 2 0; chmod 640 mem; chown root.kmem mem
|
|
mknod null c 2 2; chmod 666 null; chown root.wheel null
|
|
mknod random c 2 3; chmod 644 random; chown root.wheel random
|
|
mknod urandom c 2 4; chmod 644 urandom; chown root.wheel urandom
|
|
mknod zero c 2 12; chmod 666 zero; chown root.wheel zero
|
|
mknod io c 2 14; chmod 600 io; chown root.wheel io
|
|
mknod tty c 1 0; chmod 666 tty; chown root.wheel tty
|
|
mknod klog c 7 0; chmod 600 klog; chown root.wheel klog
|
|
mknod stdin c 22 0; chmod 666 stdin; chown root.wheel stdin
|
|
mknod stdout c 22 1; chmod 666 stdout; chown root.wheel stdout
|
|
mknod stderr c 22 2; chmod 666 stderr; chown root.wheel stderr
|
|
mknod lkm c 32 0; chmod 644 lkm; chown root.wheel lkm
|
|
mknod pci c 78 0; chmod 644 pci; chown root.wheel pci
|
|
rm -f fd/*
|
|
mkdir fd > null 2>&1
|
|
(cd fd && eval `echo "" | awk ' BEGIN { \
|
|
for (i = 0; i < 64; i++) \
|
|
printf("mknod %d c 22 %d;", i, i)}'`)
|
|
chown -R bin.bin fd
|
|
chmod 555 fd
|
|
chmod 666 fd/*
|
|
;;
|
|
|
|
mach-4)
|
|
mknod iopl c 22 0
|
|
mknod kbd c 23 0
|
|
mknod mouse c 24 0
|
|
mknod time c 25 0
|
|
mknod timezone c 26 0
|
|
;;
|
|
|
|
# Create device files for new Archive/Wangtek QIC-02 tape driver (vak)
|
|
wt*)
|
|
umask $tape_umask
|
|
u=`expr $i : '..\(.*\)'`
|
|
if [ x$u = x ]; then u=0; fi
|
|
rm -f r[Ww]t$u nr[Ww]t$u r[Ww]t$u[a-f] nr[Ww]t$u[a-f]
|
|
mknod rwt${u} c 10 `expr 0 + $u` # default density, 512b blocks
|
|
mknod nrwt${u} c 10 `expr 4 + $u`
|
|
# mknod rWt${u} c 10 `expr 64 + $u` # default density, 1024b blocks
|
|
# mknod nrWt${u} c 10 `expr 68 + $u`
|
|
mknod rwt${u}b c 10 `expr 16 + $u` # 60 megabytes
|
|
mknod nrwt${u}b c 10 `expr 20 + $u`
|
|
mknod rwt${u}c c 10 `expr 24 + $u` # 120 megabytes
|
|
mknod nrwt${u}c c 10 `expr 28 + $u`
|
|
mknod rwt${u}d c 10 `expr 32 + $u` # 150 megabytes
|
|
mknod nrwt${u}d c 10 `expr 36 + $u`
|
|
# mknod rwt${u}e c 10 `expr 40 + $u` # 300 megabytes?
|
|
# mknod nrwt${u}e c 10 `expr 44 + $u`
|
|
# mknod rwt${u}f c 10 `expr 48 + $u` # 600 megabytes?
|
|
# mknod nrwt${u}f c 10 `expr 52 + $u`
|
|
chown root.operator r[Ww]t$u nr[Ww]t$u r[Ww]t$u[a-f] nr[Ww]t$u[a-f]
|
|
umask 77
|
|
;;
|
|
|
|
# Individual slices.
|
|
od*s*|sd*s*|vn*s*|wd*s*)
|
|
umask $disk_umask
|
|
case $i in
|
|
od*s*) name=od; blk=20; chr=70;;
|
|
sd*s*) name=sd; blk=4; chr=13;;
|
|
wd*s*) name=wd; blk=0; chr=3;;
|
|
vn*s*) name=vn; blk=15; chr=43;;
|
|
esac
|
|
unit=`expr $i : '..\([0-9]*\)s'`
|
|
slice=`expr $i : '..[0-9]*s\([0-9]*\)'`
|
|
part=`expr $i : '..[0-9]*s[0-9]*\(.*\)'`
|
|
case $unit in
|
|
[0-9]|[1-2][0-9]|30|31)
|
|
case $slice in
|
|
[0-9]|[1-2][0-9]|30)
|
|
oldslice=$slice
|
|
slice=$(($slice+1))
|
|
slicename=`dkitos $slice`
|
|
rm -f $name$unit$slicename* r$name$unit$slicename*
|
|
minor=`dkminor 0 $unit $slice $dkrawpart`
|
|
mknod $name$unit$slicename b $blk $minor
|
|
mknod r$name$unit$slicename c $chr $minor
|
|
case $part in
|
|
[a-h])
|
|
case $oldslice in
|
|
0) slice=$oldslice ;;
|
|
esac
|
|
for part in 0 1 2 3 4 5 6 7
|
|
do
|
|
minor=`dkminor 0 $unit $slice $part`
|
|
partname=`dkitop $part`
|
|
mknod $name$unit$slicename$partname \
|
|
b $blk $minor
|
|
mknod r$name$unit$slicename$partname \
|
|
c $chr $minor
|
|
done
|
|
;;
|
|
"")
|
|
;;
|
|
*)
|
|
echo bad partition for disk in: $i
|
|
;;
|
|
esac
|
|
chgrp operator $name$unit$slicename* \
|
|
r$name$unit$slicename*
|
|
;;
|
|
*)
|
|
echo bad slice for disk in: $i
|
|
;;
|
|
esac
|
|
;;
|
|
*)
|
|
echo bad unit for disk in: $i "(unit=$unit, slice=$slice, part=$part)"
|
|
;;
|
|
esac
|
|
umask 77
|
|
;;
|
|
|
|
fd*)
|
|
umask $disk_umask
|
|
unit=`expr $i : '..\(.*\)'`
|
|
name=fd; blk=2; chr=9
|
|
rm -f $name$unit* r$name$unit*
|
|
case $unit in
|
|
0|1|2|3)
|
|
mknod ${name}${unit} b $blk `expr $unit '*' 64`
|
|
mknod r${name}${unit} c $chr `expr $unit '*' 64`
|
|
# Fake BSD partitions
|
|
for i in a b c d e f g h
|
|
do
|
|
ln ${name}${unit} ${name}${unit}$i
|
|
ln r${name}${unit} r${name}${unit}$i
|
|
done
|
|
# User-readable and programmer-readable name sets
|
|
|
|
mknod ${name}${unit}.1720 b $blk `expr $unit '*' 64 + 1`
|
|
mknod r${name}${unit}.1720 c $chr `expr $unit '*' 64 + 1`
|
|
# ln ${name}${unit}.1720 ${name}${unit}135hs21
|
|
# ln r${name}${unit}.1720 r${name}${unit}135hs21
|
|
|
|
mknod ${name}${unit}.1480 b $blk `expr $unit '*' 64 + 2`
|
|
mknod r${name}${unit}.1480 c $chr `expr $unit '*' 64 + 2`
|
|
# ln ${name}${unit}.1480 ${name}${unit}135hs18
|
|
# ln r${name}${unit}.1480 r${name}${unit}135hs18
|
|
# ln ${name}${unit}.1480 ${name}${unit}96hs18
|
|
# ln r${name}${unit}.1480 r${name}${unit}96hs18
|
|
|
|
mknod ${name}${unit}.1440 b $blk `expr $unit '*' 64 + 3`
|
|
mknod r${name}${unit}.1440 c $chr `expr $unit '*' 64 + 3`
|
|
# ln ${name}${unit}.1440 ${name}${unit}135
|
|
# ln r${name}${unit}.1440 r${name}${unit}135
|
|
# ln ${name}${unit}.1440 ${name}${unit}135ds18
|
|
# ln r${name}${unit}.1440 r${name}${unit}135ds18
|
|
# ln ${name}${unit}.1440 ${name}${unit}96ds18
|
|
# ln r${name}${unit}.1440 r${name}${unit}96ds18
|
|
|
|
mknod ${name}${unit}.1200 b $blk `expr $unit '*' 64 + 4`
|
|
mknod r${name}${unit}.1200 c $chr `expr $unit '*' 64 + 4`
|
|
# ln ${name}${unit}.1200 ${name}${unit}96
|
|
# ln r${name}${unit}.1200 r${name}${unit}96
|
|
# ln ${name}${unit}.1200 ${name}${unit}96ds15
|
|
# ln r${name}${unit}.1200 r${name}${unit}96ds15
|
|
# ln ${name}${unit}.1200 ${name}${unit}135ds15
|
|
# ln r${name}${unit}.1200 r${name}${unit}135ds15
|
|
|
|
mknod ${name}${unit}.820 b $blk `expr $unit '*' 64 + 5`
|
|
mknod r${name}${unit}.820 c $chr `expr $unit '*' 64 + 5`
|
|
# ln ${name}${unit}.820 ${name}${unit}96hs10
|
|
# ln r${name}${unit}.820 r${name}${unit}96hs10
|
|
# ln ${name}${unit}.820 ${name}${unit}135hs10
|
|
# ln r${name}${unit}.820 r${name}${unit}135hs10
|
|
|
|
mknod ${name}${unit}.800 b $blk `expr $unit '*' 64 + 6`
|
|
mknod r${name}${unit}.800 c $chr `expr $unit '*' 64 + 6`
|
|
# ln ${name}${unit}.800 ${name}${unit}96ds10
|
|
# ln r${name}${unit}.800 r${name}${unit}96ds10
|
|
# ln ${name}${unit}.800 ${name}${unit}135ds10
|
|
# ln r${name}${unit}.800 r${name}${unit}135ds10
|
|
|
|
mknod ${name}${unit}.720 b $blk `expr $unit '*' 64 + 7`
|
|
mknod r${name}${unit}.720 c $chr `expr $unit '*' 64 + 7`
|
|
# ln ${name}${unit}.720 ${name}${unit}96ds9
|
|
# ln r${name}${unit}.720 r${name}${unit}96ds9
|
|
# ln ${name}${unit}.720 ${name}${unit}135ds9
|
|
# ln r${name}${unit}.720 r${name}${unit}135ds9
|
|
|
|
mknod ${name}${unit}.360 b $blk `expr $unit '*' 64 + 8`
|
|
mknod r${name}${unit}.360 c $chr `expr $unit '*' 64 + 8`
|
|
# ln ${name}${unit}.360 ${name}${unit}48
|
|
# ln r${name}${unit}.360 r${name}${unit}48
|
|
# ln ${name}${unit}.360 ${name}${unit}48ds9
|
|
# ln r${name}${unit}.360 r${name}${unit}48ds9
|
|
|
|
chgrp operator ${name}${unit}* r${name}${unit}*
|
|
;;
|
|
*)
|
|
echo bad unit for disk in: $i
|
|
;;
|
|
esac
|
|
umask 77
|
|
;;
|
|
|
|
ft*)
|
|
umask $tape_umask
|
|
unit=`expr $i : '..\(.*\)'`
|
|
name=ft; blk=2; chr=9
|
|
rm -f $name$unit* r$name$unit*
|
|
case $unit in
|
|
0|1|2|3)
|
|
mknod ${name}${unit} b $blk `expr $unit '*' 64 + 32`
|
|
mknod r${name}${unit} c $chr `expr $unit '*' 64 + 32`
|
|
ln ${name}${unit} ${name}${unit}a
|
|
ln r${name}${unit} r${name}${unit}a
|
|
chgrp operator ${name}${unit}* r${name}${unit}*
|
|
;;
|
|
*)
|
|
echo bad unit for tape in: $i
|
|
;;
|
|
esac
|
|
umask 77
|
|
;;
|
|
|
|
od*|sd*|vn*|wd*)
|
|
umask $disk_umask
|
|
case $i in
|
|
od*) name=od; blk=20; chr=70;;
|
|
sd*) name=sd; blk=4; chr=13;;
|
|
vn*) name=vn; blk=15; chr=43;;
|
|
wd*) name=wd; blk=0; chr=3;;
|
|
esac
|
|
unit=`expr $i : '..\(.*\)'`
|
|
case $unit in
|
|
[0-9]|[1-2][0-9]|30|31)
|
|
for slicepartname in s0h s1 s2 s3 s4
|
|
do
|
|
sh MAKEDEV $name$unit$slicepartname
|
|
done
|
|
case $name in
|
|
od|sd)
|
|
rm -f r${name}${unit}.ctl
|
|
mknod r${name}${unit}.ctl c $chr `expr $unit '*' 8 + $scsictl `
|
|
chmod 600 r${name}${unit}.ctl
|
|
;;
|
|
esac
|
|
;;
|
|
*)
|
|
echo bad unit for disk in: $i
|
|
;;
|
|
esac
|
|
umask 77
|
|
;;
|
|
|
|
ccd*)
|
|
umask 37
|
|
name=ccd
|
|
blk=21; chr=74
|
|
unit=`expr $i : '...\(.*\)'`
|
|
case $unit in
|
|
[0-9]|[1-2][0-9]|30|31)
|
|
rm -f r${name}${unit}.ctl
|
|
mknod r${name}${unit}.ctl c $chr `expr $unit '*' 8 + $scsictl `
|
|
chmod 600 r${name}${unit}.ctl
|
|
for part in 0 1 2 3 4 5 6 7
|
|
do
|
|
minor=`dkminor 0 $unit 0 $part`
|
|
partname=`dkitop $part`
|
|
mknod $name$unit$partname \
|
|
b $blk $minor
|
|
mknod r$name$unit$partname \
|
|
c $chr $minor
|
|
done
|
|
;;
|
|
*)
|
|
echo bad unit for disk in: $i
|
|
;;
|
|
esac
|
|
umask 77
|
|
;;
|
|
|
|
uk*)
|
|
unit=`expr $i : 'uk\(.*\)'`
|
|
rm -f uk$unit
|
|
mknod uk$unit c 31 $unit
|
|
;;
|
|
|
|
worm*)
|
|
unit=`expr $i : 'worm\(.*\)'`
|
|
if [ "X${unit}" = "X" ]; then
|
|
unit=0
|
|
fi
|
|
chr=62
|
|
name=worm
|
|
rm -f r${name}${unit}
|
|
mknod r${name}${unit} c $chr ${unit}
|
|
rm -f r${name}${unit}.ctl
|
|
mknod r${name}${unit}.ctl c $chr `expr $unit + $scsictl `
|
|
;;
|
|
|
|
# SCSI processor type driver
|
|
pt[0-9]*)
|
|
chr=61
|
|
name=pt
|
|
unit=`expr $i : 'pt\([0-9][0-9]*\)'`
|
|
if [ "X${unit}" = "X" ]; then
|
|
unit=0
|
|
fi
|
|
unit=`expr $unit + 1 - 1`
|
|
rm -f ${name}${unit}
|
|
mknod ${name}${unit} c $chr $unit
|
|
rm -f ${name}${unit}.ctl
|
|
mknod ${name}${unit}.ctl c $chr `expr $unit + $scsictl `
|
|
;;
|
|
|
|
pty*)
|
|
class=`expr $i : 'pty\(.*\)'`
|
|
case $class in
|
|
0) offset=0 name=p;;
|
|
1) offset=32 name=q;;
|
|
2) offset=64 name=r;;
|
|
3) offset=96 name=s;;
|
|
# Note that xterm (at least) only look at p-s.
|
|
4) offset=128 name=P;;
|
|
5) offset=160 name=Q;;
|
|
6) offset=192 name=R;;
|
|
7) offset=224 name=S;;
|
|
# This still leaves [tuTU].
|
|
*) echo bad unit for pty in: $i;;
|
|
esac
|
|
case $class in
|
|
0|1|2|3|4|5|6|7)
|
|
umask 0
|
|
eval `echo $offset $name | awk ' { b=$1; n=$2 } END { \
|
|
for (i = 0; i < 32; i++) {
|
|
c = substr("0123456789abcdefghijklmnopqrstuv", i + 1, 1); \
|
|
printf("rm -f tty%s%s pty%s%s; \
|
|
mknod tty%s%s c 5 %d; \
|
|
mknod pty%s%s c 6 %d; \
|
|
chown root.wheel tty%s%s pty%s%s;", \
|
|
n, c, n, c, \
|
|
n, c, b+i, \
|
|
n, c, b+i, \
|
|
n, c, n, c); \
|
|
} \
|
|
}'`
|
|
umask 77
|
|
;;
|
|
esac
|
|
;;
|
|
|
|
st*)
|
|
umask $tape_umask
|
|
unit=`expr $i : '..\(.*\)'`
|
|
chr=14
|
|
|
|
#remove old stype names
|
|
rm -f [hml]rst[0123456] [hml][en]rst[0123456] [hml]enrst[0123456]
|
|
#remove new style names
|
|
rm -f rst${unit} [en]rst${unit} enrst${unit}
|
|
rm -f rst${unit}.[0123] nrst${unit}.[0123]\
|
|
erst${unit}.[0123] st${unit}ctl.[0123]
|
|
#remove control device
|
|
|
|
case $unit in
|
|
0|1|2|3|4|5|6)
|
|
for mode in 0 1 2 3
|
|
do
|
|
mknod rst${unit}.${mode} c $chr `expr $unit '*' 16 + $mode '*' 4 + 0`
|
|
mknod nrst${unit}.${mode} c $chr `expr $unit '*' 16 + $mode '*' 4 + 1`
|
|
mknod erst${unit}.${mode} c $chr `expr $unit '*' 16 + $mode '*' 4 + 2`
|
|
mknod st${unit}ctl.${mode} c $chr `expr $unit '*' 16 + $mode '*' 4 + 3`
|
|
chgrp operator rst${unit}.${mode}\
|
|
nrst${unit}.${mode} \
|
|
erst${unit}.${mode} \
|
|
st${unit}ctl.${mode}
|
|
chmod 600 st${unit}ctl.${mode}
|
|
done
|
|
rm -f rst${unit}.ctl
|
|
mknod rst${unit}.ctl c $chr `expr $unit '*' 16 + $scsictl `
|
|
chmod 600 rst${unit}.ctl
|
|
|
|
ln rst${unit}.0 rst${unit}
|
|
ln nrst${unit}.0 nrst${unit}
|
|
ln erst${unit}.0 erst${unit}
|
|
;;
|
|
*)
|
|
echo bad unit for tape in: $i
|
|
;;
|
|
esac
|
|
umask 77
|
|
;;
|
|
|
|
ch*)
|
|
umask 37
|
|
unit=`expr $i : '..\(.*\)'`
|
|
case $i in
|
|
ch*) name=ch; chr=17;;
|
|
esac
|
|
rm -f $name$unit
|
|
case $unit in
|
|
0|1|2|3|4|5|6)
|
|
mknod ${name}${unit} c $chr `expr $unit '*' 16 + 0`
|
|
chgrp operator ${name}${unit}
|
|
rm -f r${name}${unit}.ctl
|
|
mknod r${name}${unit}.ctl c $chr `expr $unit '*' 16 + $scsictl `
|
|
chmod 600 r${name}${unit}.ctl
|
|
;;
|
|
*)
|
|
echo bad unit for media changer in: $i
|
|
;;
|
|
esac
|
|
umask 77
|
|
;;
|
|
|
|
cd*|mcd*|scd*)
|
|
umask $disk_umask
|
|
case $i in
|
|
cd*) unit=`expr $i : '..\(.*\)'`; name=cd; blk=6; chr=15;;
|
|
mcd*) unit=`expr $i : '...\(.*\)'`; name=mcd; blk=7; chr=29;;
|
|
scd*) unit=`expr $i : '...\(.*\)'`; name=scd; blk=16; chr=45;;
|
|
esac
|
|
rm -f $name$unit? r$name$unit?
|
|
case $unit in
|
|
0|1|2|3|4|5|6)
|
|
mknod ${name}${unit}a b $blk `expr $unit '*' 8 + 0`
|
|
mknod ${name}${unit}c b $blk `expr $unit '*' 8 + 2`
|
|
mknod r${name}${unit}a c $chr `expr $unit '*' 8 + 0`
|
|
mknod r${name}${unit}c c $chr `expr $unit '*' 8 + 2`
|
|
chgrp operator ${name}${unit}[a-h] r${name}${unit}[a-h]
|
|
case $name in
|
|
cd)
|
|
rm -f r${name}${unit}.ctl
|
|
mknod r${name}${unit}.ctl c $chr `expr $unit '*' 8 + $scsictl `
|
|
chmod 600 r${name}${unit}.ctl
|
|
;;
|
|
esac
|
|
;;
|
|
*)
|
|
echo bad unit for disk in: $i
|
|
;;
|
|
esac
|
|
umask 77
|
|
;;
|
|
|
|
matcd*)
|
|
umask 2
|
|
case $i in
|
|
matcd*) unit=`expr $i : '.....\(.*\)'`; name=matcd; blk=17; chr=46;;
|
|
esac
|
|
rm -f $name$unit? r$name$unit? $name$unit?? r$name$unit??
|
|
case $unit in
|
|
0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15)
|
|
mknod ${name}${unit}a b $blk `expr $unit '*' 8 + 0`
|
|
mknod ${name}${unit}c b $blk `expr $unit '*' 8 + 2`
|
|
mknod r${name}${unit}a c $chr `expr $unit '*' 8 + 0`
|
|
mknod r${name}${unit}c c $chr `expr $unit '*' 8 + 2`
|
|
chgrp operator ${name}${unit}[a-h] r${name}${unit}[a-h]
|
|
chmod 640 ${name}${unit}[a-h] r${name}${unit}[a-h]
|
|
|
|
mknod ${name}${unit}la b $blk `expr $unit '*' 8 + 128`
|
|
mknod ${name}${unit}lc b $blk `expr $unit '*' 8 + 130`
|
|
mknod r${name}${unit}la c $chr `expr $unit '*' 8 + 128`
|
|
mknod r${name}${unit}lc c $chr `expr $unit '*' 8 + 130`
|
|
chgrp operator ${name}${unit}l[a-h] r${name}${unit}l[a-h]
|
|
chmod 640 ${name}${unit}l[a-h] r${name}${unit}l[a-h]
|
|
;;
|
|
*)
|
|
echo bad unit for disk in: $i
|
|
;;
|
|
esac
|
|
umask 77
|
|
;;
|
|
|
|
wcd*)
|
|
umask 2 ;
|
|
unit=`expr $i : '...\(.*\)'`
|
|
blk=19
|
|
chr=69
|
|
rm -f wcd$unit? rwcd$unit?
|
|
case $unit in
|
|
0|1|2|3)
|
|
mknod wcd${unit}a b $blk `expr $unit '*' 8 + 0`
|
|
mknod rwcd${unit}a c $chr `expr $unit '*' 8 + 0`
|
|
mknod wcd${unit}c b $blk `expr $unit '*' 8 + 2`
|
|
mknod rwcd${unit}c c $chr `expr $unit '*' 8 + 2`
|
|
chgrp operator wcd${unit}[a-h] rwcd${unit}[a-h]
|
|
chmod 640 wcd${unit}[a-h] rwcd${unit}[a-h]
|
|
;;
|
|
*)
|
|
echo bad unit for disk in: $i
|
|
;;
|
|
esac
|
|
umask 77
|
|
;;
|
|
|
|
lpt*)
|
|
unit=`expr $i : 'lpt\(.*\)'`
|
|
rm -f lpt$unit
|
|
rm -f lpctl$unit
|
|
mknod lpt$unit c 16 $unit
|
|
mknod lpctl$unit c 16 `expr $unit + 128`
|
|
chown root.wheel lpt$unit
|
|
chown root.wheel lpctl$unit
|
|
;;
|
|
|
|
tw*)
|
|
unit=`expr $i : 'tw\(.*\)'`
|
|
rm -f tw$unit
|
|
mknod tw$unit c 19 $unit
|
|
chown root.operator tw$unit
|
|
;;
|
|
|
|
# Use this to create virtual consoles for syscons, pcvt or codrv
|
|
# ttyv0-b
|
|
# use as MAKEDEV vtyNN to create NN entries
|
|
vty*)
|
|
chr=12
|
|
units=`expr $i : 'vty\(.*\)'`
|
|
eval `echo ${chr} ${units} | awk ' { c=$1; n=$2 } END {
|
|
for (i = 0; i < n; i++)
|
|
printf("rm -f ttyv%01x; mknod ttyv%01x c %d %d; \
|
|
chown root.wheel ttyv%01x;", \
|
|
i, i, c, i, i); }'`
|
|
ln -fs ttyv0 vga # XXX X still needs this pccons relic
|
|
;;
|
|
|
|
bpf*)
|
|
unit=`expr $i : 'bpf\(.*\)'`
|
|
rm -f bpf$unit
|
|
mknod bpf$unit c 23 $unit
|
|
chown root.wheel bpf$unit
|
|
;;
|
|
|
|
speaker)
|
|
rm -f speaker
|
|
mknod speaker c 26 0
|
|
chown root.wheel speaker
|
|
;;
|
|
|
|
cuaa?|cua?)
|
|
umask 7
|
|
unit=`expr $i : 'cua.*\(.\)$'`
|
|
rm -f cua*a$unit
|
|
m=`ttyminor $unit`
|
|
mknod cuaa$unit c 28 `expr $m + 128`
|
|
mknod cuaia$unit c 28 `expr $m + 32 + 128`
|
|
mknod cuala$unit c 28 `expr $m + 64 + 128`
|
|
chown uucp.dialer cua*a$unit
|
|
umask 77
|
|
;;
|
|
|
|
tty0?|ttyd?|tty?)
|
|
unit=`expr $i : 'tty.*\(.\)$'`
|
|
rm -f tty*d$unit
|
|
m=`ttyminor $unit`
|
|
mknod ttyd$unit c 28 $m
|
|
mknod ttyid$unit c 28 `expr $m + 32`
|
|
mknod ttyld$unit c 28 `expr $m + 64`
|
|
chown root.wheel tty*d$unit
|
|
;;
|
|
|
|
cuac?)
|
|
umask 7
|
|
portlist="0 1 2 3 4 5 6 7 8 9 a b c d e f
|
|
g h i j k l m n o p q r s t u v"
|
|
major=48
|
|
card=`expr $i : 'cua.*\(.\)$'`
|
|
for unit in $portlist
|
|
do
|
|
minor=`ttyminor $unit`
|
|
minor=`expr $card \* 65536 + $minor`
|
|
name=$card$unit
|
|
rm -f cuac$name cuaic$name cualc$name
|
|
mknod cuac$name c $major `expr $minor + 128`
|
|
mknod cuaic$name c $major `expr $minor + 32 + 128`
|
|
mknod cualc$name c $major `expr $minor + 64 + 128`
|
|
chown uucp.dialer cuac$name cuaic$name cualc$name
|
|
done
|
|
umask 77
|
|
;;
|
|
|
|
ttyc?)
|
|
portlist="0 1 2 3 4 5 6 7 8 9 a b c d e f
|
|
g h i j k l m n o p q r s t u v"
|
|
major=48
|
|
card=`expr $i : 'tty.*\(.\)$'`
|
|
for unit in $portlist
|
|
do
|
|
minor=`ttyminor $unit`
|
|
minor=`expr $card \* 65536 + $minor`
|
|
name=$card$unit
|
|
rm -f ttyc$name ttyic$name ttylc$name
|
|
mknod ttyc$name c $major $minor
|
|
mknod ttyic$name c $major `expr $minor + 32`
|
|
mknod ttylc$name c $major `expr $minor + 64`
|
|
chown root.wheel ttyc$name ttyic$name ttylc$name
|
|
done
|
|
;;
|
|
|
|
# RISCom8 'rc' driver entries
|
|
|
|
cuam?)
|
|
umask 7
|
|
unit=`expr $i : 'cua.*\(.\)$'`
|
|
rm -f cuam$unit
|
|
m=`ttyminor $unit`
|
|
mknod cuam$unit c 63 `expr $m + 128`
|
|
chown uucp.dialer cuam$unit
|
|
umask 77
|
|
;;
|
|
|
|
ttym?)
|
|
unit=`expr $i : 'tty.*\(.\)$'`
|
|
rm -f ttym$unit
|
|
m=`ttyminor $unit`
|
|
mknod ttym$unit c 63 $m
|
|
chown root.wheel ttym$unit
|
|
;;
|
|
|
|
# Specialix SI/XIO.
|
|
# Note: these are 'base 1' to match the numbers on the panels, and to match
|
|
# the manual that comes with the system.
|
|
ttyA*)
|
|
major=68
|
|
nports=`expr $i : 'ttyA\(.*\)$'`
|
|
port=1
|
|
while [ $port -le $nports ]; do
|
|
minor=`expr $port - 1`
|
|
name=`expr $port + 1000 | cut -c 3-4`
|
|
rm -f tty*A$name
|
|
mknod ttyA$name c $major $minor
|
|
chown root.wheel ttyA$name
|
|
mknod ttyiA$name c $major `expr $minor + 65536`
|
|
chown root.wheel ttyiA$name
|
|
mknod ttylA$name c $major `expr $minor + 131072`
|
|
chown root.wheel ttylA$name
|
|
port=`expr $port + 1`
|
|
done
|
|
# For the user-mode control program, 'sicontrol'
|
|
rm -f si_control
|
|
mknod si_control c 68 262144
|
|
chmod 600 si_control
|
|
chown root.wheel si_control
|
|
;;
|
|
|
|
cuaA*)
|
|
umask 7
|
|
major=68
|
|
nports=`expr $i : 'cuaA\(.*\)$'`
|
|
port=1
|
|
while [ $port -le $nports ]; do
|
|
minor=`expr $port - 1`
|
|
name=`expr $port + 1000 | cut -c 3-4`
|
|
rm -f cuaA$name
|
|
mknod cuaA$name c $major `expr $minor + 128`
|
|
chown uucp.dialer cuaA$name
|
|
port=`expr $port + 1`
|
|
done
|
|
umask 77
|
|
;;
|
|
|
|
# Digiboard PC/?? 16 port card.
|
|
# The current scheme of minor numbering is:
|
|
#
|
|
# unused{14} CARD{2} major{8} CALLOUT{1} LOCK{1} INIT{1} PORT{5}
|
|
#
|
|
# CARD bitfield in future versions may be extended to 3 bits.
|
|
#
|
|
# See dgb(4)
|
|
#
|
|
ttyD?)
|
|
portlist="0 1 2 3 4 5 6 7 8 9 a b c d e f"
|
|
major=58
|
|
card=`expr $i : 'tty.*\(.\)$'`
|
|
for unit in $portlist
|
|
do
|
|
minor=`ttyminor $unit`
|
|
minor=`expr $card \* 65536 + $minor`
|
|
name=$card$unit
|
|
rm -f tty*D$name
|
|
mknod ttyD$name c $major $minor
|
|
mknod ttyiD$name c $major `expr $minor + 32`
|
|
mknod ttylD$name c $major `expr $minor + 64`
|
|
chown root.wheel tty*D$name
|
|
done
|
|
;;
|
|
|
|
cuaD?)
|
|
umask 7
|
|
portlist="0 1 2 3 4 5 6 7 8 9 a b c d e f"
|
|
major=58
|
|
card=`expr $i : 'cua.*\(.\)$'`
|
|
for unit in $portlist
|
|
do
|
|
minor=`ttyminor $unit`
|
|
minor=`expr $card \* 65536 + $minor`
|
|
name=$card$unit
|
|
rm -f cua*D$name
|
|
mknod cuaD$name c $major `expr $minor + 128`
|
|
mknod cuaiD$name c $major `expr $minor + 32 + 128`
|
|
mknod cualD$name c $major `expr $minor + 64 + 128`
|
|
chown uucp.dialer cua*D$name
|
|
done
|
|
umask 77
|
|
;;
|
|
|
|
mse*)
|
|
unit=`expr $i : 'mse\(.*\)'`
|
|
chr=27
|
|
rm -f mse$unit
|
|
mknod mse$unit c $chr `expr $unit '*' 2 + 1` # non-blocking for X11
|
|
chown root.wheel mse$unit
|
|
;;
|
|
|
|
psm*)
|
|
unit=`expr $i : 'psm\(.*\)'`
|
|
chr=21
|
|
rm -f psm$unit
|
|
mknod psm$unit c $chr `expr $unit '*' 2 + 1` # non-blocking for X11
|
|
chown root.wheel psm$unit
|
|
;;
|
|
|
|
mouse*)
|
|
name=`expr $i : 'mouse\(.*\)'`
|
|
if [ ! -c $name ]; then
|
|
$0 $name # make the appropriate device
|
|
fi
|
|
rm -f mouse
|
|
ln -s $name mouse
|
|
;;
|
|
|
|
pcaudio)
|
|
rm -f pcaudio pcaudioctl
|
|
mknod pcaudio c 24 0
|
|
mknod pcaudioctl c 24 128
|
|
chown root.wheel pcaudio pcaudioctl
|
|
;;
|
|
|
|
socksys)
|
|
rm -f socksys nfsd spx
|
|
mknod socksys c 41 0
|
|
mknod spx c 41 1
|
|
ln -s socksys nfsd
|
|
chown root.wheel socksys nfsd spx
|
|
chmod 666 socksys nfsd spx
|
|
;;
|
|
|
|
snd*)
|
|
#
|
|
# changes from Linux voxware
|
|
# minor Linux FreeBSD
|
|
# 8 sequencer2 (aka music0) music0
|
|
# 17 patmgr0 sequencer1
|
|
# 33 patmgr1 sequencer2
|
|
#
|
|
|
|
unit=`expr $i : 'snd\(.*\)'`
|
|
chr=30
|
|
|
|
# XXX write this less verbosely, like std
|
|
snd_security_hole=0 # XXX
|
|
umask $snd_security_hole
|
|
|
|
if [ $unit = "0" ] ; then
|
|
rm -f mixer ; ln -s mixer$unit mixer
|
|
rm -f sequencer ; ln -s sequencer$unit sequencer
|
|
rm -f dsp ; ln -s dsp$unit dsp
|
|
rm -f audio ; ln -s audio$unit audio
|
|
rm -f dspW ; ln -s dspW$unit dspW
|
|
rm -f music ; ln -s music$unit music
|
|
rm -f pss ; ln -s pss$unit pss
|
|
fi
|
|
|
|
rm -f mixer$unit # Mixer [ Control ]
|
|
mknod mixer$unit c $chr `expr $unit '*' 16 + 0`
|
|
|
|
rm -f sequencer$unit # Sequencer [ FM Synth and MIDI output ]
|
|
mknod sequencer$unit c $chr `expr $unit '*' 16 + 1`
|
|
|
|
rm -f midi midi$unit # Midi 0
|
|
mknod midi$unit c $chr `expr $unit '*' 16 + 2`
|
|
|
|
rm -f dsp$unit # DSP [ Digitized voice ]
|
|
mknod dsp$unit c $chr `expr $unit '*' 16 + 3`
|
|
|
|
rm -f audio$unit # SPARC audio [ Not fully implemented ]
|
|
mknod audio$unit c $chr `expr $unit '*' 16 + 4`
|
|
|
|
rm -f dspW$unit # Wide DSP (each sample is 16 bits)
|
|
mknod dspW$unit c $chr `expr $unit '*' 16 + 5`
|
|
|
|
rm -f sndstat # Status Device [ Debugging interface, only 1 ]
|
|
mknod sndstat c $chr 6
|
|
|
|
# minor number 7 is unused
|
|
|
|
rm -f music$unit # Sequencer level 2
|
|
mknod music$unit c $chr `expr $unit '*' 16 + 8`
|
|
|
|
rm -f pss$unit # PSS and programmable devices
|
|
mknod pss$unit c $chr `expr $unit '*' 16 + 9`
|
|
|
|
# minor numbers 10-15 are unused
|
|
umask 77
|
|
;;
|
|
|
|
vat)
|
|
rm -f vatio
|
|
mknod vatio c 25 128
|
|
chown root.wheel vatio
|
|
chmod 660 vatio
|
|
;;
|
|
|
|
gsc*)
|
|
unit=`expr $i : 'gsc\(.*\)'`
|
|
rm -f gsc${unit}*
|
|
mknod gsc${unit} c 47 $unit
|
|
mknod gsc${unit}p c 47 $(($unit + 8))
|
|
mknod gsc${unit}d c 47 $(($unit + 32))
|
|
mknod gsc${unit}pd c 47 $(($unit + 40))
|
|
chmod 666 gsc${unit}*
|
|
chown root.wheel gsc${unit}*
|
|
;;
|
|
|
|
apm*)
|
|
rm -f apm
|
|
chr=39
|
|
mknod apm c $chr 0
|
|
chown root.operator apm
|
|
chmod 660 apm
|
|
;;
|
|
|
|
card*)
|
|
unit=`expr $i : 'card\(.*\)'`
|
|
chr=50
|
|
rm -f card$unit
|
|
mknod card$unit c $chr $unit
|
|
chmod 644 card$unit
|
|
chown root.wheel card$unit
|
|
;;
|
|
|
|
ttyx?|ttyy?|ttyz?)
|
|
case $i in
|
|
*0) unit=0;; *1) unit=1;; *2) unit=2;; *3) unit=3;;
|
|
*4) unit=4;; *5) unit=5;; *6) unit=6;; *7) unit=7;;
|
|
*8) unit=8;; *9) unit=9;; *a) unit=10;; *b) unit=11;;
|
|
*c) unit=12;; *d) unit=13;; *e) unit=14;; *f) unit=15;;
|
|
esac
|
|
case $i in
|
|
ttyy?) unit=`expr $unit \+ 16`;;
|
|
ttyz?) unit=`expr $unit \+ 32`;;
|
|
esac
|
|
rm -f $i
|
|
mknod $i c 42 $unit
|
|
chown uucp.wheel $i
|
|
;;
|
|
|
|
cronyx)
|
|
rm -f cronyx
|
|
mknod cronyx c 42 63
|
|
chown root.wheel cronyx
|
|
;;
|
|
|
|
joy)
|
|
rm -f joy0 joy1
|
|
mknod joy0 c 51 0
|
|
mknod joy1 c 51 1
|
|
chown root.operator joy0 joy1
|
|
chmod 640 joy0 joy1
|
|
;;
|
|
|
|
spigot)
|
|
rm -f spigot
|
|
mknod spigot c 11 0
|
|
chmod 444 spigot
|
|
;;
|
|
|
|
qcam?)
|
|
unit=`expr $i : 'qcam\(.*\)'`
|
|
rm -f qcam$unit
|
|
mknod qcam$unit c 73 $unit
|
|
chmod 444 qcam$unit
|
|
;;
|
|
|
|
meteor?)
|
|
unit=`expr $i : 'meteor\(.*\)'`
|
|
rm -f meteor$unit
|
|
mknod meteor$unit c 67 $unit
|
|
chown root.wheel meteor$unit
|
|
chmod 444 meteor$unit
|
|
;;
|
|
|
|
tun?)
|
|
unit=`expr $i : 'tun\(.*\)'`
|
|
rm -f tun$unit
|
|
mknod tun$unit c 52 $unit
|
|
chown uucp.dialer tun$unit
|
|
;;
|
|
|
|
sysmouse)
|
|
rm -f sysmouse consolectl
|
|
mknod sysmouse c 12 128
|
|
mknod consolectl c 12 255
|
|
chown root.wheel sysmouse consolectl
|
|
;;
|
|
|
|
snp?)
|
|
unit=`expr $i : 'snp\(.*\)'`
|
|
rm -f snp$unit
|
|
mknod snp$unit c 53 $unit
|
|
chown root.wheel snp$unit
|
|
;;
|
|
|
|
# Valid arguments to isdn:
|
|
# none makes all the node but nic0
|
|
# 5000 makes nic0 for Niccy 5000
|
|
# 3008 makes nic0 for Niccy 3008
|
|
# 3009 makes nic0 for Niccy 3009
|
|
# 1000 makes nodes for Niccy 1000
|
|
# tel* makes nodes for TELES S0
|
|
#
|
|
isdn*)
|
|
type=`expr $i : 'isdn\(.*\)'`
|
|
if [ "X${type}" = "X" ]; then
|
|
type=none
|
|
fi
|
|
unit=54
|
|
rm -f nic0 snic0 n?ic0 isdn isdn? ity?? itel?? ispy
|
|
mknod n8ic0 c $unit 0
|
|
mknod snic0 c `expr $unit + 4` 0
|
|
mknod n9ic0 c `expr $unit + 6` 0
|
|
mknod isdn c `expr $unit + 1` 0
|
|
mknod isdn1 c `expr $unit + 1` 1
|
|
mknod isdn2 c `expr $unit + 1` 2
|
|
mknod ity00 c `expr $unit + 2` 0
|
|
mknod ity01 c `expr $unit + 2` 1
|
|
mknod ityo0 c `expr $unit + 2` 130
|
|
mknod ityo1 c `expr $unit + 2` 131
|
|
mknod itel00 c `expr $unit + 3` 0
|
|
mknod itel01 c `expr $unit + 3` 1
|
|
mknod ispy c `expr $unit + 5` 0
|
|
chown root.wheel n8ic0 n9ic0 snic0 isdn isdn? ity?? itel?? ispy
|
|
chown uucp.wheel ityo[01]
|
|
case $type in
|
|
5000)
|
|
ln snic0 nic0
|
|
chown root.wheel nic0
|
|
;;
|
|
3008)
|
|
ln n8ic0 nic0
|
|
chown root.wheel nic0
|
|
;;
|
|
3009)
|
|
ln n9ic0 nic0
|
|
chown root.wheel nic0
|
|
;;
|
|
1000|tel*|TEL*|none)
|
|
;;
|
|
*)
|
|
echo "No such ISDN device subtype: $type"
|
|
;;
|
|
esac
|
|
;;
|
|
|
|
# dufault@hda.com: If I do much more work on other A-D boards
|
|
# then eventually we'll have a "ad" and "dio" interface and some of these
|
|
# "labpcaio" ones will be gone.
|
|
# labpcaio: D-A and A-D.
|
|
# labpcdio: Digital in and Digital out.
|
|
#
|
|
labpc*)
|
|
umask 7
|
|
case $i in
|
|
labpcaio*)
|
|
name=labpcaio
|
|
unit=`expr $i : 'labpcaio\(.*\)'`
|
|
all="0 1 2 3 4 5 6 7"
|
|
offset=0
|
|
;;
|
|
labpcdio*)
|
|
name=labpcdio
|
|
unit=`expr $i : 'labpcdio\(.*\)'`
|
|
all="0 1 2 3"
|
|
offset=8
|
|
;;
|
|
*)
|
|
echo "Don't understand that labpc name"
|
|
exit
|
|
;;
|
|
esac
|
|
if [ "X${unit}" = "X" ]; then
|
|
unit=all
|
|
fi
|
|
case $unit in
|
|
0|1|2|3|4|5|6|7)
|
|
rm -f $name$unit
|
|
mknod $name$unit c 66 `expr $offset + $unit `
|
|
;;
|
|
all)
|
|
for i in $all
|
|
do
|
|
rm -f $name$i
|
|
mknod $name$i c 66 `expr $offset + $i `
|
|
done
|
|
;;
|
|
*)
|
|
echo "No such LabPC unit: $unit"
|
|
;;
|
|
esac
|
|
umask 77
|
|
;;
|
|
|
|
perfmon)
|
|
rm -f perfmon
|
|
mknod perfmon c 2 32
|
|
chown root.kmem perfmon
|
|
chmod 640 perfmon
|
|
;;
|
|
|
|
local)
|
|
umask 0 # XXX should be elsewhere
|
|
sh MAKEDEV.local
|
|
umask 77
|
|
;;
|
|
|
|
*)
|
|
echo $i - no such device name
|
|
;;
|
|
|
|
esac
|
|
done
|