#!/bin/sh -
#	$NetBSD: MAKEDEV,v 1.51 2002/08/09 02:39:34 lukem Exp $
#
#	@(#)MAKEDEV	8.1 (Berkeley) 6/9/93
#
###########################################################################
#
#   PLEASE RUN "cd ../share/man/man8 ; make makedevs"
#   AFTER CHANGING THIS FILE, AND COMMIT THE UPDATED MANPAGE!
#
###########################################################################
#
# Device "make" file.  Valid arguments:
#	std	standard devices
#	local	configuration specific devices
#	all	create a reasonable amount of all files
# Tapes:
#	ht*	massbus tm03 and tu??
#	tm*	unibus tm11 and te10 emulations (e.g. Emulex tc-11)
#	mt*	MSCP tapes (e.g. TU81, TK50)
#	ts*	unibus ts11
#	ut*	unibus tu45 emulations (e.g.si 9700)
#	uu*	tu58 cassettes on dl11 controller
#	st*	SCSI tapes
# Disks:
#	hp*	massbus rm??
#	hk*	unibus rk06 and rk07
#	up*	other unibus devices (e.g. on Emulex sc-21v controller)
#	ra*	MSCP disks (ra??, rd??)
#	rx*	MSCP floppy disk (rx33/50/...)
#	rl*	unibus rl02
#	rb*	730 idc w/ rb80 and/or rb02
#	ccd*	"concatenated" pseudo-disks
#	raid*	RAIDframe disk driver
#	vnd*	"file" pseudo-disks
#	rd*	HDC9224 rd disks on VS2000
#	sd*	SCSI disks
#	cd*	SCSI CD-ROM
#	md*	memory pseudo-disk devices
# Terminal multiplexors:
#	dz*	unibus dz11 and dz32
#	dh*	unibus dh11 and emulations (e.g. Able dmax, Emulex cs-11)
#	dmf*	unibus dmf32
#	dhu*    unibus dhu11
#	dmz*    unibus dmz32
#	dl*	unibus dl11
# Pseudo terminals:
#	pty*	set of 62 master and slave pseudo terminals
#	opty	first 16 ptys, to save inodes on install media
# Printers:
#	ct*	unibus parallel interface to CAT typesetter
#	lp*	unibus lp11 parallel interface
#	va*	unibus varian parallel interface
#	vp*	unibus versatec parallel interface
# Call units:
#	dn*	unibus dn11 and emulations (e.g. Able Quadracall)
# Special purpose devices:
#	clockctl clock control for non root users
#	ik*	unibus interface to ikonas frame buffer
#	ps*	unibus interface to picture system 2
#	ad*	unibus interface to data translation a/d converter
#	np*	unibus ethernet co-processor interface, for downloading.
#	qv*	qvss (microvax) display
#	lkm	loadable kernel modules
#	bpf*	berkeley packet filter
#	tun*	network tunnel device
#	scsibus* SCSI busses, see scsi(4), scsictl(8)
#	ss*	SCSI scanner
#	uk*	unknown SCSI device
#	ch*	SCSI media changer
#	random	Random number generator
#	systrace syscall tracer
#
PATH=/sbin:/usr/sbin:/bin:/usr/bin
umask 77

# Check if we have fdesc mounted
if [ -d fd ]; then
	case "`df fd`" in
	*fdesc*) nofdesc=false;;
	*) nofdesc=true;;
	esac
else
	nofdesc=true
fi

makedev()
{

for i
do
case $i in

all)
	makedev std fd vnd0 ccd0 pty0 lkm random
	makedev bpf0 bpf1 bpf2 bpf3 bpf4 bpf5 bpf6 bpf7
	makedev mt0 mt1 ts0 ts1 st0 st1 uk0 ss0 cd0 vt0
	makedev ra0 ra1 ra2 ra3 hp0 hp1 hp2 hp3 sd0 sd1 sd2 sd3 rd0 rd1 rd2
	makedev dz0 dl0 dhu0 rx0 rx1 md0 md1
	makedev raid0 raid1 raid2 raid3 raid4 raid5 raid6 raid7
	makedev scsibus0 scsibus1 scsibus2 scsibus3
	makedev clockctl
	makedev systrace
	;;

std)
	rm -f console drum floppy crl csa1 cas2 tu0 tu1 g0 g1 g2 g3
	rm -f kUmem kmem mem null leds zero klog
	rm -f ipl ipnat ipstate ipauth
	mknod console		c 0 0
	mknod ttyg0		c 25 0
	mknod ttyg1		c 25 1
	mknod ttyg2		c 25 2
	mknod ttyg3		c 25 3
	mknod drum		c 7 0	; chmod 640 drum ; chgrp kmem drum
	mknod floppy		c 8 0
	mknod crl		c 35 0
	mknod csa1		c 51 0
	mknod csa2		c 51 1
	mknod tu0		b 8 0
	mknod tu1		b 8 1
	mknod kUmem		c 3 3	; chmod 600 kUmem
	mknod kmem		c 3 1	; chmod 640 kmem ; chgrp kmem kmem
	mknod mem		c 3 0	; chmod 640 mem ; chgrp kmem mem
	mknod null		c 3 2	; chmod 666 null
	mknod zero              c 3 12  ; chmod 666 zero
	mknod leds		c 3 13	; chmod 666 leds
	mknod klog		c 33 0	; chmod 600 klog
	if $nofdesc; then
		rm -f tty stdin stdout stderr
		mknod tty	c 2 0	; chmod 666 tty
		mknod stdin	c 53 0	; chmod 666 stdin
		mknod stdout	c 53 1	; chmod 666 stdout
		mknod stderr	c 53 2	; chmod 666 stderr
	fi
	mknod ipl		c 42 0	; chmod 600 ipl
	mknod ipnat		c 42 1	; chmod 600 ipnat
	mknod ipstate		c 42 2	; chmod 600 ipstate
	mknod ipauth		c 42 3	; chmod 600 ipauth
	;;

fd)
	if $nofdesc; then
		rm -f fd/*
		mkdir fd 2>/dev/null
		n=0
		while [ $n -lt 64 ]; do
			mknod fd/$n c 53 $n
			n=$(($n + 1))
		done
		chmod 755 fd
		chmod 666 fd/*
	fi
	;;

st*)
	case $i in
	st*) name=st;	unit=${i#st};	blk=21; chr=60;;
	esac
	rm -f $name$unit n$name$unit e$name$unit en$name$unit \
	r$name$unit nr$name$unit er$name$unit enr$name$unit
	mknod ${name}${unit}	b $blk $(($unit * 16+ 0))
	mknod n${name}${unit}	b $blk $(($unit * 16+ 1))
	mknod e${name}${unit}	b $blk $(($unit * 16+ 2))
	mknod en${name}${unit}	b $blk $(($unit * 16+ 3))
	mknod r${name}${unit}	c $chr $(($unit * 16+ 0))
	mknod nr${name}${unit}	c $chr $(($unit * 16+ 1))
	mknod er${name}${unit}	c $chr $(($unit * 16+ 2))
	mknod enr${name}${unit} c $chr $(($unit * 16+ 3))
	chgrp operator ${name}${unit} n${name}${unit} \
		e$name$unit en$name$unit \
		r${name}${unit} nr${name}${unit} \
		er${name}${unit} enr${name}${unit}
	chmod 660 ${name}${unit} n${name}${unit} \
		e$name$unit en$name$unit \
		r${name}${unit} nr${name}${unit} \
		er${name}${unit} enr${name}${unit}
	;;

ht*|tm*|mt*|ts*|ut*)
	case $i in
	ht*) name=ht;	unit=${i#ht};	blk=1; chr=5 ;;
	mt*) name=mt;	unit=${i#mt};	blk=15;	chr=38;;
	tm*) name=tm;	unit=${i#tm};	blk=5; chr=14;;
	ts*) name=ts;	unit=${i#ts};	blk=6; chr=16;;
	ut*) name=ut;	unit=${i#ut};	blk=10; chr=17;;
	esac
	case $unit in
	[0-7])
		four=$(($unit + 4)) ; eight=$(($unit + 8))
		twelve=$(($unit + 12)) ; twenty=$(($unit + 20))
		rm -f $name$unit $name$four $name$eight $name$twelve \
		    n$name$unit n$name$eight nr$name$unit nr$name$eight \
		    r$name$unit r$name$four r$name$eight r$name$twelve
		mknod $name$unit	b $blk $unit
		mknod $name$four	b $blk $four
		mknod $name$eight	b $blk $eight
		mknod $name$twelve	b $blk $twelve
		mknod n$name$unit	b $blk $four ;: sanity w/pdp11 v7
		mknod n$name$eight	b $blk $twelve ;: ditto
		mknod nr$name$unit	c $chr $four ;: sanity w/pdp11 v7
		mknod nr$name$eight	c $chr $twelve ;: ditto
		mknod r$name$unit	c $chr $unit
		mknod r$name$four	c $chr $four
		mknod r$name$eight	c $chr $eight
		mknod r$name$twelve	c $chr $twelve
		chgrp operator $name$unit $name$four $name$eight $name$twelve \
		    n$name$unit n$name$eight nr$name$unit nr$name$eight \
		    r$name$unit r$name$four r$name$eight r$name$twelve
		chmod 660 $name$unit $name$four $name$eight $name$twelve \
		    n$name$unit n$name$eight nr$name$unit nr$name$eight \
		    r$name$unit r$name$four r$name$eight r$name$twelve
		if [ $i = ut ]
		then
			rm -f $name$twenty r$name$twenty
			mknod $name$twenty	b $blk $twenty
			mknod r$name$twenty	c $chr $twenty
			chgrp operator $name$twenty r$name$twenty
			chmod 660 $name$twenty r$name$twenty
		fi
		if [ ! -e rmt$eight ]	# compatibility stuff
		then
			ln -fs $name$unit mt$unit
			ln -fs $name$four mt$four
			ln -fs $name$eight mt$eight
			ln -fs $name$twelve mt$twelve
			ln -fs n$name$unit nmt$unit
			ln -fs n$name$eight nmt$eight
			ln -fs nr$name$unit nrmt$unit
			ln -fs nr$name$eight nrmt$eight
			ln -fs r$name$unit rmt$unit
			ln -fs r$name$four rmt$four
			ln -fs r$name$eight rmt$eight
			ln -fs r$name$twelve rmt$twelve
		fi
		;;
	*)
		echo bad unit for tape in: $1
		;;
	esac
	;;

random)
	rm -f random urandom
	mknod random c 67 0
	mknod urandom c 67 1
	chmod 444 random
	chmod 644 urandom
	;;

hp*|hk*|up*|ra*|rl*|rb*|ccd*|vnd*|rd*|sd*|rx*|raid*)
	umask 2
	case $i in
	hp*) name=hp;	unit=${i#hp};	blk=0; chr=4;;
	hk*) name=hk;	unit=${i#hk};	blk=3; chr=11;;
	up*) name=up;	unit=${i#up};	blk=2; chr=13;;
	raid*) name=raid; unit=${i#raid}; blk=25; chr=73;;
	ra*) name=ra;	unit=${i#ra};	blk=9;	chr=9;;
	rb*) name=rb;	unit=${i#rb};	blk=11; chr=23;;
	rx*) name=rx;	unit=${i#rx};	blk=12; chr=30;;
	rl*) name=rl;	unit=${i#rl};	blk=14; chr=32;;
	ccd*) name=ccd;	unit=${i#ccd};	blk=17; chr=54;;
	vnd*) name=vnd;	unit=${i#vnd};	blk=18; chr=55;;
	rd*) name=rd;	unit=${i#rd};	blk=19; chr=58;;
	sd*) name=sd;	unit=${i#sd};	blk=20; chr=59;;
	esac
	case $unit in
	[0-9]|[12][0-9]|3[01])
		rm -f ${name}${unit}[a-h] r${name}${unit}[a-h]
		mknod ${name}${unit}a	b $blk $(($unit * 8 + 0))
		mknod ${name}${unit}b	b $blk $(($unit * 8 + 1))
		mknod ${name}${unit}c	b $blk $(($unit * 8 + 2))
		mknod ${name}${unit}d	b $blk $(($unit * 8 + 3))
		mknod ${name}${unit}e	b $blk $(($unit * 8 + 4))
		mknod ${name}${unit}f	b $blk $(($unit * 8 + 5))
		mknod ${name}${unit}g	b $blk $(($unit * 8 + 6))
		mknod ${name}${unit}h	b $blk $(($unit * 8 + 7))
		mknod r${name}${unit}a	c $chr $(($unit * 8 + 0))
		mknod r${name}${unit}b	c $chr $(($unit * 8 + 1))
		mknod r${name}${unit}c	c $chr $(($unit * 8 + 2))
		mknod r${name}${unit}d	c $chr $(($unit * 8 + 3))
		mknod r${name}${unit}e	c $chr $(($unit * 8 + 4))
		mknod r${name}${unit}f	c $chr $(($unit * 8 + 5))
		mknod r${name}${unit}g	c $chr $(($unit * 8 + 6))
		mknod r${name}${unit}h	c $chr $(($unit * 8 + 7))
		chgrp operator ${name}${unit}[a-h] r${name}${unit}[a-h]
		chmod 640 ${name}${unit}[a-h] r${name}${unit}[a-h]
		;;
	*)
		echo bad unit for disk in: $i
		;;
	esac
	umask 77
	;;

cd*)
	case $i in
	cd*) name=cd;   unit=${i#cd};   chr=61; blk=22;;
	esac
	rm -f $name$unit? r$name$unit?
	mknod ${name}${unit}a   b $blk $(($unit * 8 + 0))
	mknod ${name}${unit}c   b $blk $(($unit * 8 + 2))
	mknod r${name}${unit}a  c $chr $(($unit * 8 + 0))
	mknod r${name}${unit}c  c $chr $(($unit * 8 + 2))
	chgrp operator $name$unit? r$name$unit?
	chmod 640 $name$unit? r$name$unit?
	;;

ss*)
	case $i in
	ss*) name=ss;   unit=${i#ss};   chr=64;;
	esac
	rm -f $name$unit n$name$unit en$name$unit
	mknod $name$unit	c $chr $(($unit * 16 + 0))
	mknod n$name$unit	c $chr $(($unit * 16 + 1))
	mknod en$name$unit	c $chr $(($unit * 16 + 3))
	chgrp operator $name$unit n$name$unit en$name$unit
	chmod 640 $name$unit n$name$unit en$name$unit
	;;

ch*|uk*)
	case $i in
	ch*) name=ch;   unit=${i#ch};   chr=63;;
	uk*) name=uk;   unit=${i#uk};   chr=65;;
	esac
	rm -f $name$unit
	mknod $name$unit        c $chr $unit
	chgrp operator $name$unit
	chmod 640 $name$unit
	;;

md*)
	unit=${i#md}; blk=23; chr=62
	rm -f md${unit}? rmd${unit}?
	mknod md${unit}a  b $blk $(($unit * 8 + 0))
	mknod md${unit}c  b $blk $(($unit * 8 + 2))
#	mknod rmd${unit}a c $chr $(($unit * 8 + 0))
#	mknod rmd${unit}c c $chr $(($unit * 8 + 2))
	chgrp operator md${unit}? #rmd${unit}?
	chmod 640 md${unit}? #rmd${unit}?
	;;

uu*)
	unit=${i#uu}
	name=uu; blk=13
	case $unit in
	[0-3])
		mknod ${name}${unit}	b $blk $(($unit * 2 + 0))
		mknod ${name}${unit}a	b $blk $(($unit * 2 + 1))
		;;
	*)
		echo bad unit for uu cassette in: $i
		;;
	esac
	;;

dz*)
	unit=${i#dz}
	case $unit in
	[0-7])
		i=0
		while [ $i -lt 8 ]; do
		  no=$(($unit * 8 + $i))
		  `printf "mknod tty%02d c 1 %d\n" $no $no`
		  i=$(($i + 1))
		done
		;;
	*)
		echo bad unit for dz in: $i
		;;
	esac
	;;

dhu*|dh*|dmf*|dmz*|vt*)
	case $i in
	vt*)	name=vt; major=68; count=8
		unit=${i#vt}
		case $unit in
		0) ch=w ;;
		*) echo bad unit for $name in: $i ;;
		esac;;
	dmz*)	name=dmz; major=37; count=24
		unit=${i#dmz}
		case $unit in
		0) ch=a ;; 1) ch=b ;; 2) ch=c ;; 3) ch=e ;; 4) ch=f ;;
		*) echo bad unit for $name in: $i ;;
		esac;;
	dmf*)	name=dmf; major=22; count=8
		unit=${i#dmf}
		case $unit in
		0) ch=A ;; 1) ch=B ;; 2) ch=C ;; 3) ch=E ;;
		4) ch=F ;; 5) ch=G ;; 6) ch=H ;; 7) ch=I ;;
		*) echo bad unit for $name in: $i ;;
		esac;;
	dhu*)	name=dhu; major=34; count=16
		unit=${i#dhu}
		case $unit in
		0) ch=S ;; 1) ch=T ;; 2) ch=U ;; 3) ch=V ;;
		4) ch=W ;; 5) ch=X ;; 6) ch=Y ;; 7) ch=Z ;;
		*) echo bad unit for $name in: $i ;;
		esac;;
	dh*)	name=dh; major=12; count=16
		unit=${i#dh}
		case $unit in
		0) ch=h ;; 1) ch=i ;; 2) ch=j ;; 3) ch=k ;;
		4) ch=l ;; 5) ch=m ;; 6) ch=n ;; 7) ch=o ;;
		*) echo bad unit for $name in: $i ;;
		esac;;
	esac
	i=0
	while [ $i -lt $count ]; do
	  `printf "mknod tty%s%x c %d %d\n" \
	     $ch $i $major $(($unit * $count + $i))`
	  i=$(($i + 1))
	done

	;;

dl*)
	unit=${i#dl}
	major=66
	`printf "mknod ttyJ%x c %d %d\n" $unit $major $unit`
	;;

lp*|va*|vp*)
	case $i in
	lp*) name=lp; unit=${i#lp}; major=15;;
	va*) name=va; unit=${i#va}; major=10;;
	vp*) name=vp; unit=${i#vp}; major=6;;
	esac
	case $unit in
	[0-7])
		mknod $i c $major $unit
		chmod 666 $i
		;;
	*)
		echo bad unit for $name in: $i
		;;
	esac
	;;

opty)
	rm -f ttyp[0-9a-f] ptyp[0-9a-f]
	for j in 0 1 2 3 4 5 6 7 8 9 a b c d e f
	do
		case $j in
		[0-9])	jn=$j ;;
		a)	jn=10 ;;
		b)	jn=11 ;;
		c)	jn=12 ;;
		d)	jn=13 ;;
		e)	jn=14 ;;
		f)	jn=15 ;;
		esac
		mknod ttyp$j c 20 $jn
		mknod ptyp$j c 21 $jn
	done
	chmod 666 ttyp[0-9a-f] ptyp[0-9a-f]
	;;

		
pty*)
	class=${i#pty}
	name=`echo pqrstuvwxyzPQRST | dd bs=1 count=1 skip=$class 2>/dev/null`
	case $name in
	w)	echo "$0: $i: pty unit conflicts with console ttyw0 device."
		continue;;
	S|T)	echo "$0: $i: pty unit conflicts with dhu11 device."
		continue;;
	?)      ;;
	*)      echo "$0: $i: pty unit must be between 0 and 15"
	        continue ;;
	esac
	rm -f tty$name[0-9a-zA-Z] pty$name[0-9a-zA-Z]
	jn=0
	while [ $jn -lt 62 ]
	do
		j=`echo 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ | dd bs=1 count=1 skip=$jn 2>/dev/null`
		skip=0
		if [ $jn -ge 16 ]; then
			skip=$(($class * 30 + 256 - 16))
		fi
		unit=$(($class * 16 + $jn + $skip))
		mknod tty$name$j c 20 $unit
		mknod pty$name$j c 21 $unit
		jn=$(($jn + 1))
	done
	chmod 666 tty$name[0-9a-zA-Z] pty$name[0-9a-zA-Z]
	;;

np*)
	class=${i#np}
	case $class in
	0) offset=0 name=0;;
	1) offset=16 name=1;;
	2) offset=32 name=2;;
	*) echo bad unit for np in: $i;;
	esac
	case $class in
	0|1|2)
	i=0
	while [ $i -lt 4 ]; do
	  `printf "mknod np%02d c 39 %d\n" $(($offset + $i)) $(($offset + $i))`
	  i=$(($i + 1))
	done
	esac
	;;

dn*|ik*|ps*|ad*|ct*)
	case $i in
	ct*) name=ct; unit=${i#ct}; chr=18;;
	dn*) name=cu; unit=${i#dn}; chr=24;;
	ps*) name=ps; unit=${i#ps}; chr=27;;
	ad*) name=ad; unit=${i#ad}; chr=29;;
	ik*) name=ik; unit=${i#ik}; chr=31;;
	esac
	case $unit in
	[0-7])
		umask 0
		mknod ${name}${unit} c ${chr} ${unit}
		umask 77
		;;
	*)
		echo bad unit for ${name} in: $i
		;;
	esac
	;;

bpf*)
	unit=${i#bpf}
	rm -f bpf$unit
	mknod bpf$unit c 56 $unit
	chmod 600 bpf$unit
	;;

qd*)
	unit=${i#qd}
	rm -f qd$unit
	mknod qc$unit c 40 $(($unit * 4))
	mknod qd$unit c 40 $(($unit * 4 + 2))
	;;

tun*)
	unit=${i#tun}
	rm -f tun$unit
	mknod tun$unit c 57 $unit
	chmod 600 tun$unit
	;;

lkm)
	mknod lkm c 28 0
	chgrp kmem lkm
	chmod 640 lkm
	;;

qv0)
	mknod qv0 c 40 0
	mknod qvcons c 40 1
	mknod mouse c 40 2
	;;

scsibus*)
	unit=${i#scsibus}
	rm -f scsibus$unit
	mknod scsibus$unit c 72 $unit
	chmod 644 scsibus$unit
	;;

clockctl)
	rm -f clockctl
	mknod clockctl c 75 0
	chgrp ntpd clockctl
	chmod 660 clockctl
	;;

systrace)
	rm -f systrace
	mknod systrace c 76 0
	chmod 644 systrace
	;;

local)
	if [ -f "$0.local" ]; then
		umask 0
		sh $0.local all
		umask 77
	fi
	;;
*)
	echo $i: invalid device
	;;

esac
done

}

makedev $*