#! /bin/sh -

RCSID='$Id: MAKEDEV 2.3 1997/09/29 19:03:13 johnsonm Exp $'

#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#
# Customisation:
#   The devices fall into various classes.  This section contains the mapping
# from a class name into a group name and permission.
#   You will almost certainly need to edit the group name to match your
# system, and you may change the permissions to suit your preference.  These
# lines _must_ be of the format "user group perm".

 public="  root root   0666"
 system="  root root   0660"
   kmem="  root kmem   0640"
    tty="  root tty    0666"
   cons="  root tty    0622"
    vcs="  root root   0600"
dialout="  root dialout 0660"
  mouse="  root root   0660"
printer="  root lp     0660"
 floppy="  root floppy 0660"
   disk="  root disk   0660"
   scsi="  root root   0600"
  cdrom="  root disk   0660"
   tape="  root tape   0660"
  audio="  root audio  0660"
  ibcs2="  root root   0666"
scanner="  root root   0666"
   coda="  root root   0600"
readable="  root root   0444"

MAXVT=63

# defaults for $major_*
major_ide0=3
major_ide1=22
major_sd=8
major_lp=6

#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#

procfs=/proc

opt_v=
opt_d=
opt_n=

while [ $# -ge 1 ]
do
	case $1 in
		--)	shift; break ;;
		-v)	shift; opt_v=1 ;;
		-d)	shift; opt_d=1 ;;
		-n)	shift; opt_n=1; opt_v=1 ;;
		-V)	shift; opt_V=1 ;;
		-*)	echo "$0: unknown flag \"$1\"" >&2; exit 1 ;;
		*)	break ;;
	esac
done

if [ "$opt_V" ]
then
	echo "$RCSID"
	exit 0
fi

opts="${opt_n:+-n} ${opt_v:+-v} ${opt_d:+-d}"

#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#

makedev () {	# usage: makedev name [bcu] major minor owner group mode
	if [ "$opt_v" ]
	then	if [ "$opt_d" ]
		then	echo "delete $1"
		else	echo "create $1	$2 $3 $4 $5:$6 $7" 
		fi
	fi
	if [ ! "$opt_n" ]
	then	if [ "$opt_d" ]
		then
			rm -f $1
		else
			rm -f $1-
			mknod $1- $2 $3 $4 &&
			chown $5:$6 $1- &&
			chmod $7 $1- &&
			mv $1- $1
		fi
	fi
}
symlink () {	# usage: symlink name target
	if [ "$opt_v" ]
	then	if [ "$opt_d" ]
		then	echo "delete $1"
		else	echo "create $1	-> $2"
		fi
	fi
	[ ! "$opt_n" ] && rm -f $1 &&
	[ ! "$opt_d" ] && ln -s $2 $1
}

#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#

# For bash and ksh, we can use faster builtin routines to do manipulation,
# otherwise (ash) fall back to slower method using `expr'.
# The extra level of indirection using `eval' is necessary a) for ksh, and
# b) to get past ash.

if [ "$RANDOM" != "$RANDOM" ]
then
	math () {
		eval echo "\$(($*))"
	}
	index () {	# index string c
		eval "I=\${1%$2*}"
		eval echo "\${#I}"
	}
	suffix () {
	    eval echo "\${1#$2}"
	}
	strip () {
		eval echo "\${1% $2 *} \${1#* $2 }"
	}
else
	math () {
		expr "$@"
	}
	index () {	# index string c
		expr $1 : ".*$2" - 1
	}
	suffix () {
		expr "$1" : "$2\(.*\)"
	}
	strip () {
		echo "[$1][$2]" >&2
		echo "`expr \"$1\" : \"\(.*\) $2 \"` `expr \"$1\" : \".* $2 \(.*\)\"`"
	}
fi

#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#

devices=
if [ ! -f $procfs/devices ]
then
	echo "$0: warning: can't read $procfs/devices" >&2
else
	exec 3<$procfs/devices
	while read major device <&3
	do
		case "$major" in
			Character|Block|'')
				;;
			*)
				eval "major_$device=$major"
				devices="$devices $device"
				;;
		esac
	done
	exec 3<&-
fi

Major () {
	device=$2
	if [ "$opt_d" ]
	then
		echo -1	# don't care
	else
		eval echo \${major_$1:-\${device:?\"unknown major number for $1\"}}
	fi
}

cvt () {
	while [ $# -ne 0 ]
	do
		case "$1" in
			mem|tty|ttyp|cua|cub)	;;
			hd)	(for d in a b c d e f g h ; do
					echo -n hd$d " "
				 done) ; echo
				;;
			ide0)	echo hda hdb ;;
			ide1)	echo hdc hdd ;;
			ide2)	echo hde hdf ;;
			ide3)	echo hdg hdh ;;
			sd)	echo sda sdb ;;
			sg)	echo sg ;;
			sr)	echo scd0 ;;
			st)	echo st0 ;;
			xd)	echo xda xdb ;;
			ad)	echo ada adb ;;
			fd)	echo fd0 fd1 ;;
			lp)	echo lp ;;
			mt)	echo ftape ;;
			loop)	echo loop ;;
			md)	echo md ;;
			ibcs2)	echo ibcs2 ;;
			tpqic02)	echo qic ;;
			sound)		echo audio ;;
			logiscan)	echo logiscan ;;
			ac4096)		echo ac4096 ;;
			hw)	echo helloworld ;;
			sbpcd | sbpcd[123])	echo $1 ;;
			Joystick)	echo js ;;
			apm_bios)	echo apm ;;
			dcf)		echo dcf ;;
			aztcd)		echo aztcd ;;
			pcmcia)	;; # taken care of by its own driver
			ttyC)	echo cyclades ;;
			vcs)	;;
			pty)	echo pty ;;
			misc)	echo misc ;;
			fb)	echo fb ;;
			netlink)	echo netlink ;;
			snd)	;;
			ptm)	;;
			pts)	;;
			ttyS)	echo ttyS0 ttyS1 ttyS2 ttyS3 ;;
			*)	echo "$0: don't know what \"$1\" is" >&2 ;;
		esac
		shift
	done
}

for arg
do
	case $arg in
	generic)
		# pick the right generic-<arch> using dpkg's knowledge
		case `dpkg --print-installation-architecture` in
			i386)
				$0 $opts generic-i386
				;;
			m68k)
				$0 $opts generic-m68k
				;;
			powerpc)
				$0 $opts generic-powerpc
				;;
			sparc)
				$0 $opts generic-sparc
				;;
			*)
				echo "$0: no support for generic-$arg" >&2
				exit 1
				;;
		esac
		;;
	generic-i386)
		$0 $opts std
		$0 $opts fd
		$0 $opts fd0 fd1
		$0 $opts hda hdb hdc hdd
		$0 $opts xda xdb
		$0 $opts sda sdb
		$0 $opts pty
		$0 $opts console
		$0 $opts ttyS0 ttyS1 ttyS2 ttyS3
		$0 $opts busmice
		$0 $opts lp
		$0 $opts par
		$0 $opts fb
		;;
	generic-m68k)
		$0 $opts std
		$0 $opts fd
		$0 $opts fd0-bare fd1-bare
		$0 $opts hda hdb
		$0 $opts sda sdb
		$0 $opts ada adb
		$0 $opts pty
		$0 $opts console
		$0 $opts ttyS0 ttyS1 ttyS2 ttyS3 ttyS5
		$0 $opts m68k-mice
		$0 $opts lp
		$0 $opts par
		$0 $opts nvram
		$0 $opts audio
		$0 $opts fb
		;;
	generic-powerpc)
		$0 $opts std
		$0 $opts fd
		$0 $opts fd0-bare fd1-bare
		$0 $opts hda hdb
		$0 $opts xda xdb
		$0 $opts sda sdb
		$0 $opts pty
		$0 $opts console
		$0 $opts ttyS0 ttyS1 ttyS2 ttyS3
		$0 $opts busmice
		$0 $opts lp
		$0 $opts par
		$0 $opts nvram
		$0 $opts adb
		$0 $opts fb
		;;
	generic-sparc)
		$0 $opts std
		$0 $opts fd0-bare fd1-bare
		$0 $opts hda hdb
		$0 $opts sda sdb sdc sdd
		$0 $opts scd0 scd1
		$0 $opts st0 st1
		$0 $opts pty
		$0 $opts console
		$0 $opts ttyS0 ttyS1 ttyS2 ttyS3
		$0 $opts fb
		$0 $opts rtc
		makedev kbd  c 11 0 $cons
		makedev sunmouse  c 10 6 $mouse
		;;
	local)
		$0.local $opts
		;;
	std)
		makedev mem  c 1 1 $kmem
		makedev kmem c 1 2 $kmem
		makedev null c 1 3 $public
		makedev port c 1 4 $kmem
		makedev zero c 1 5 $public
		symlink core $procfs/kcore
		makedev full c 1 7 $public
		makedev random c 1 8 $readable
		makedev urandom c 1 9 $readable
		$0 ram
		makedev tty  c 5 0 $tty
		;;
	random)
		makedev random c 1 8 $readable
		;;
	urandom)
		makedev urandom c 1 9 $readable
		;;
	ram)
		for i in 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ; do
			makedev ram$i  b 1 $i $disk
		done
		ln -sf ram1 ram
		;;
	initrd)
		makedev initrd b 1 250 $disk
		;;
	console)
		major=`Major vcs`	# not fatal
		makedev tty0 c 4 0 $cons
		# console
		#	new kernels need a device, old ones a symlink... sigh
		kern_rev1=`uname -r | awk -F'.' '{print $1}'`
		kern_rev2=`uname -r | awk -F'.' '{print $2}'`
		if [ $kern_rev1 -gt 2 ]
		then
			makedev console c 5 1 $cons
		else
			if [ $kern_rev1 -eq 2 -a $kern_rev2 -ge 1 ]
			then
				makedev console c 5 1 $cons
			else
				symlink console tty0
			fi
		fi
		[ "$major" ] && makedev vcs0 c $major 0 $vcs
		[ "$major" ] && makedev vcsa c $major 128 $vcs
		# individual vts
		line=1
		while [ $line -le $MAXVT -a $line -le 63 ]
		do
			makedev tty$line c 4 $line $tty
			[ "$major" ] && makedev vcs$line c $major $line $vcs
			[ "$major" ] && makedev vcsa$line c $major `math $line + 128` $vcs
			line=`math $line + 1`
		done
		;;
	adb)
		# pick the right arch device using dpkg's knowledge
		case `dpkg --print-installation-architecture` in
			powerpc)
				# ADB bus devices (char)
				makedev adb c 56 0
				makedev adbmouse c 10 10
				;;
			m68k)
				# ACSI disk 2, whole device (block)
				makedev adb b 28 16 $disk
				for part in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
				do
					minor=`expr 16 + $part`
					makedev adb$part b 28 $minor $disk
				done
				;;
			*)
				echo "no support for adb on $arg" >&2
				exit 1
				;;
		esac
		;;
	nvram)
		makedev nvram c 10 144
		;;
	tty[1-9]|tty[1-5][0-9]|tty[6][0-3])
		line=`suffix $arg tty`
		makedev tty$line c 4 $line $tty
		;;
	ttyS[0-9]|ttyS[1-5][0-9]|ttyS[6][0-3])
		line=`suffix $arg ttyS`
		minor=`math 64 + $line`
		makedev ttyS$line c 4 $minor $dialout
		;;
	pty[a-ep-z])
		bank=`suffix $arg pty`
		base=`index pqrstuvwxyzabcde $bank`
		base=`math $base \* 16`
		for i in 0 1 2 3 4 5 6 7 8 9 a b c d e f
		do
			j=`index 0123456789abcdef $i`
			makedev pty$bank$i c 2 `math $base + $j` $tty
			makedev tty$bank$i c 3 `math $base + $j` $tty
		done
		;;
	pty)
		ptysufs=""
		for i in p q r s t u v w x y z a b c d e
		do
			ptysufs="$ptysufs pty$i"
		done
		$0 $opts $ptysufs ptmx
		;;
	ptmx)
		# master pty multiplexer for 2.1 kernels
		makedev ptmx c 5 2 $tty
		;;
	cyclades)
		major1=`Major ttyC` || continue
		major2=`Major cub` || continue
		for i in 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 \
                         16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
		do
			makedev ttyC$i c $major1 $i $tty
			makedev cub$i c $major2 $i $dialout
		done
		;;
	fb)
		for i in 0 1 2 3 4 5 6 7
		do
			makedev fb$i c 29 `math 32 \* $i` $cons
			makedev fb${i}current c 29 `math 32 \* $i` $cons
			makedev fb${i}autodetect c 29 `math 32 \* $i + 1` $cons
		done
		;;
	fb[0-7])
		dev=`suffix $arg fb`
		base=`math 32 \* $dev`
		makedev fb$dev c 29 $base $cons
		makedev fb${dev}current c 29 $base $cons
		makedev fb${dev}autodetect c 29 `math $base + 1` $cons
		for i in 0 1 2 3 4 5 6 7
		do
			makedev fb${dev}user$i c 29 `math $base + 24 + $i` $cons
		done
		;;
	netlink)
		makedev route c 36 0 $coda
		makedev skip  c 36 0 $coda
		;;
	lp)
		major=`Major lp` || continue
		makedev ${arg}0 c $major 0 $printer
		makedev ${arg}1 c $major 1 $printer
		makedev ${arg}2 c $major 2 $printer
		;;
	par)
		major=`Major lp` || continue
		makedev ${arg}0 c $major 0 $printer
		makedev ${arg}1 c $major 1 $printer
		makedev ${arg}2 c $major 2 $printer
		;;
	busmice)
		major=`Major mouse 10` || continue
		makedev logibm	  c $major 0 $mouse
		makedev psaux     c $major 1 $mouse
		makedev inportbm  c $major 2 $mouse
		makedev atibm     c $major 3 $mouse
		makedev jbm       c $major 4 $mouse
		;;
	m68k-mice)
		major=`Major mouse 10` || continue
		makedev amigamouse c $major 4 $mouse
		makedev atarimouse c $major 5 $mouse
		makedev amigamouse1 c $major 7 $mouse
		makedev adbmouse  c $major 10 $mouse
		;;
	misc)
		major=`Major mouse 10` || continue
		makedev logibm	  c $major 0 $mouse
		makedev psaux     c $major 1 $mouse
		makedev inportbm  c $major 2 $mouse
		makedev atibm     c $major 3 $mouse
		makedev jbm       c $major 4 $mouse
		makedev amigamouse c $major 4 $mouse
		makedev atarimouse c $major 5 $mouse
		makedev sunmouse  c $major 6 $mouse
		makedev amigamouse1 c $major 7 $mouse
		makedev smouse    c $major 8 $mouse
		makedev pc110pad  c $major 9 $mouse
		makedev adbmouse  c $major 10 $mouse
		makedev beep      c $major 128 $mouse
		makedev modreq    c $major 129 $mouse
		makedev watchdog  c $major 130 $mouse
		makedev temperature c $major 131 $mouse
		makedev hwtrap    c $major 132 $mouse
		makedev exttrp    c $major 133 $mouse
		makedev apm_bios  c $major 134 $mouse
		makedev rtc       c $major 135 $mouse
		makedev openprom  c $major 139 $mouse
		makedev relay8    c $major 140 $mouse
		makedev relay16   c $major 141 $mouse
		makedev msr       c $major 142 $mouse
		makedev pciconf   c $major 143 $mouse
		makedev nvram     c $major 144 $mouse
		makedev hfmodem   c $major 145 $mouse
		makedev led       c $major 151 $mouse
		makedev mergemem  c $major 153 $mouse
		makedev pmu       c $major 154 $mouse
		;;
        rtc)
		major=`Major mouse 10` || continue
		makedev rtc       c $major 135 $mouse
		;;
	js)
		major=`Major Joystick` || continue
		makedev js0 c $major 0 $mouse
		makedev js1 c $major 1 $mouse
		;;
	fd[0-7]-bare)
		sarg="${arg%-bare}" 
		major=`Major fd 2` || continue
		base=`suffix $sarg fd`
		if [ $base -ge 4 ]
		then
			base=`math $base + 124`
		fi
		makedev ${sarg} b $major $base $floppy
		;;
	fd[0-7])
		major=`Major fd 2` || continue
		base=`suffix $arg fd`
		if [ $base -ge 4 ]
		then
			base=`math $base + 124`
		fi
		makedev ${arg} b $major $base $floppy
		makedev ${arg}d360  b $major `math $base +  4` $floppy
		makedev ${arg}h1200 b $major `math $base +  8` $floppy
		makedev ${arg}u360  b $major `math $base + 12` $floppy
		makedev ${arg}u720  b $major `math $base + 16` $floppy
		makedev ${arg}h360  b $major `math $base + 20` $floppy
		makedev ${arg}h720  b $major `math $base + 24` $floppy
		makedev ${arg}u1440 b $major `math $base + 28` $floppy
		makedev ${arg}u2880 b $major `math $base + 32` $floppy
		makedev ${arg}CompaQ b $major `math $base + 36` $floppy

		makedev ${arg}h1440 b $major `math $base + 40` $floppy
		makedev ${arg}u1680 b $major `math $base + 44` $floppy
		makedev ${arg}h410  b $major `math $base + 48` $floppy
		makedev ${arg}u820  b $major `math $base + 52` $floppy
		makedev ${arg}h1476 b $major `math $base + 56` $floppy
		makedev ${arg}u1722 b $major `math $base + 60` $floppy
		makedev ${arg}h420  b $major `math $base + 64` $floppy
		makedev ${arg}u830  b $major `math $base + 68` $floppy
		makedev ${arg}h1494 b $major `math $base + 72` $floppy
		makedev ${arg}u1743 b $major `math $base + 76` $floppy
		makedev ${arg}h880  b $major `math $base + 80` $floppy
		makedev ${arg}u1040 b $major `math $base + 84` $floppy
		makedev ${arg}u1120 b $major `math $base + 88` $floppy
		makedev ${arg}h1600 b $major `math $base + 92` $floppy
		makedev ${arg}u1760 b $major `math $base + 96` $floppy
		makedev ${arg}u1920 b $major `math $base + 100` $floppy
		makedev ${arg}u3200 b $major `math $base + 104` $floppy
		makedev ${arg}u3520 b $major `math $base + 108` $floppy
		makedev ${arg}u3840 b $major `math $base + 112` $floppy
		makedev ${arg}u1840 b $major `math $base + 116` $floppy
		makedev ${arg}u800  b $major `math $base + 120` $floppy
		makedev ${arg}u1600 b $major `math $base + 124` $floppy
		;;
	ed[a-b])
		major=`Major ed 36` || continue
		unit=`suffix $arg ed`
		base=`index ab $unit`
		base=`math $base \* 64`
		makedev ed$unit b $major $base $disk
		for part in 1 2 3 4 5 6 7 8 # 9 10 11 12 13 14 15 16 17 18 19 20
		do
			makedev ed$unit$part b $major `math $base + $part` $disk
		done
		;;
	hd[a-b])
		major=`Major ide0` || major=`Major hd 3` || continue
		unit=`suffix $arg hd`
		base=`index ab $unit`
		base=`math $base \* 64`
		makedev hd$unit b $major $base $disk
		for part in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
		do
			makedev hd$unit$part b $major `math $base + $part` $disk
		done
		;;
	hd[c-d])
		major=`Major ide1 22` || continue
		unit=`suffix $arg hd`
		base=`index cd $unit`
		base=`math $base \* 64`
		makedev hd$unit b $major $base $disk
		for part in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
		do
			makedev hd$unit$part b $major `expr $base + $part` $disk
		done
		;;
	hd[e-f])
		major=`Major ide2 33` || continue
		unit=`suffix $arg hd`
		base=`index ef $unit`
		base=`math $base \* 64`
		makedev hd$unit b $major $base $disk
		for part in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
		do
			makedev hd$unit$part b $major `expr $base + $part` $disk
		done
		;;
	hd[g-h])
		major=`Major ide3 34` || continue
		unit=`suffix $arg hd`
		base=`index gh $unit`
		base=`math $base \* 64`
		makedev hd$unit b $major $base $disk
		for part in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
		do
			makedev hd$unit$part b $major `expr $base + $part` $disk
		done
		;;
	ht)
		major=`Major ht0 37` || continue
		# Only one IDE tape drive is currently supported; ht0.
		makedev ht0 c $major 0 $tape
		makedev ht0 c $major 0 $tape
		makedev nht0 c $major 128 $tape
		;;
	xd[a-d])
		major=`Major xd 13` || continue
		unit=`suffix $arg xd`
		base=`index abcd $unit`
		base=`math $base \* 64`
		makedev xd$unit b $major $base $disk
		for part in 1 2 3 4 5 6 7 8 # 9 10 11 12 13 14 15 16 17 18 19 20
		do
			makedev xd$unit$part b $major `expr $base + $part` $disk
		done
		;;
	sd[a-p])
		major=`Major sd 8` || continue
		unit=`suffix $arg sd`
		base=`index abcdefghijklmnopqrstuvwxyz $unit`
		base=`math $base \* 16`
		if [ $base -lt 256 ]; then
			major=8
		else
			major=65
			base=`math $base \- 256`
		fi
		makedev sd$unit b $major $base $disk
		for part in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
		do
			minor=`expr $base + $part`
			makedev sd$unit$part b $major $minor $disk
		done
		;;
	ad[a-p])
		major=`Major ad 28` || continue
		unit=`suffix $arg ad`
		base=`index abcdefghijklmnop $unit`
		base=`math $base \* 16`
		makedev ad$unit b $major $base $disk
		for part in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
		do
			minor=`expr $base + $part`
			makedev ad$unit$part b $major $minor $disk
		done
		;;
	loop)
		major=`Major loop` || continue
		for part in 0 1 2 3 4 5 6 7
		do
			makedev loop$part b $major $part $disk
		done
		;;
	md)
		major=`Major md` || continue
		for part in 0 1 2 3
		do
			makedev md$part b $major $part $disk
		done
		;;
	st[0-7])
		major=`Major st 9`
		unit=`suffix $arg st`
		makedev st$unit c $major $unit $tape
		makedev nst$unit c $major `math 128 + $unit` $tape
		;;
	qic)
		major=`Major tpqic02 12`
		makedev rmt8       c $major   6 $tape
		makedev rmt16      c $major   8 $tape
		makedev tape-d     c $major 136 $tape
		makedev tape-reset c $major 255 $tape
		;;
	ftape)
		major=`Major mt 27` || continue
		for unit in 0 1 2 3
		do
			makedev rft$unit c $major $unit $tape
			makedev nrft$unit c $major `math $unit + 4` $tape
		done
		symlink ftape rft0
		symlink nftape nrft0
		;;
	scd-all)
		major=`Major sr 11` || continue
		for unit in 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
		do
			makedev scd$unit b $major $unit $cdrom
		done
		;;
	cfs0)
		makedev cfs0 c 67 0 $coda
		;;
	scd[0-9]|scd[0-1][0-9])
		major=`Major sr 11` || continue
		unit=`suffix $arg scd`
		makedev scd$unit b $major $unit $cdrom
		;;
	ttyI[0-9]|ttyI[1-5][0-9]|ttyI[6][0-3])
		major=43
		unit=`suffix $arg ttyI`
		makedev ttyI$unit c $major $unit $dialout
		;;
	ippp[0-9]|ippp[1-5][0-9]|ippp[6][0-3])
		major=45
		unit=`suffix $arg ippp`
		minor=`math $unit + 128`
		makedev ippp$unit c $major $minor $dialout
		;;
	isdn[0-9]|isdn[1-5][0-9]|isdn[6][0-3])
		major=45
		unit=`suffix $arg isdn`
		minor=`math $unit + 0`
		makedev isdn$unit c $major $minor $dialout
		;;
	isdnctrl[0-9]|isdnctrl[1-5][0-9]|isdnctrl[6][0-3])
		major=45
		unit=`suffix $arg isdnctrl`
		minor=`math $unit + 64`
		makedev isdnctrl$unit c $major $minor $dialout
		;;
	isdninfo)
		makedev isdninfo c 45 255 $dialout
		;;
	isdn-tty)
		major=43
		for unit in 0 1 2 3 4 5 6 7
		do
			makedev ttyI$unit c $major $unit $dialout
		done
		;;
	isdn-ippp)
		major=45
		for unit in 0 1 2 3 4 5 6 7
		do
			makedev ippp$unit c $major `math $unit + 128` $dialout
		done
		;;
	isdn-io)
		for unit in 0 1 2 3 4 5 6 7
		do
			makedev isdn$unit c 45 $unit $dialout
			makedev isdnctrl$unit c 45 `math $unit + 64` $dialout
			makedev ippp$unit c 45 `math $unit + 128` $dialout
		done
		makedev isdninfo c 45 255 $dialout
		;;
	sonycd)
		major=`Major cdu31a` || continue
		makedev $arg b $major 0 $cdrom
		;;
	mcd)
		major=`Major mcd 23` || continue
		makedev $arg b $major 0 $cdrom
		;;
	mcdx)
		major=`Major mcdx 20` || continue
		makedev $arg b $major 0 $cdrom
		;;
	cdu535)
		makedev $arg b 24 0 $cdrom
		;;
	lmscd)
		makedev $arg b 24 0 $cdrom
		;;
	sbpcd|sbpcd[123])
		major=`Major $arg` || continue
		base=`suffix ${arg}0 sbpcd`
		# base=`expr ${arg}0 : "sbpcd\(.\)"`
		for minor in 0 1 2 3
		do
			# XXX
			unit=`expr substr 0123456789abcdef \( $base \* 4 + $minor + 1 \) 1`
			makedev sbpcd$unit b $major $minor $cdrom
		done
		[ $arg = sbpcd ] && symlink $arg ${arg}0
		;;
	aztcd)
		major=`Major $arg` || continue
		makedev ${arg}0 b $major 0 $cdrom
		;;
	bpcd)
		makedev $arg b 41 0 $cdrom
		;;
	logiscan)
		major=`Major logiscan` || continue
		makedev $arg c $major 0 $scanner
		;;
	m105scan)
		major=`Major m105` || continue
		makedev $arg c $major 0 $scanner
		;;
	ac4096)
		major=`Major ac4096` || continue
		makedev $arg c $major 0 $scanner
		;;
	audio)
		major=`Major sound 14`
		makedev mixer      c $major  0 $audio
		makedev sequencer  c $major  1 $audio
		makedev midi00     c $major  2 $audio
		makedev dsp        c $major  3 $audio
		makedev audio      c $major  4 $audio
		makedev sndstat    c $major  6 $audio
#		makedev sequencer2 c $major  8 $audio
		makedev mixer1     c $major 16 $audio
#		makedev patmgr0    c $major 17 $audio
		makedev midi01     c $major 18 $audio
		makedev dsp1       c $major 19 $audio
		makedev audio1     c $major 20 $audio
#		makedev patmgr1    c $major 33 $audio
		makedev midi02     c $major 34 $audio
		makedev midi03     c $major 50 $audio
		;;
	pcaudio)
		major=`Major pcsp` || continue
		makedev pcmixer c $major 0 $audio
		makedev pcsp    c $major 3 $audio
		makedev pcaudio c $major 4 $audio
		;;
	sg|sg-all)
		major=`Major sg 21`
		for unit in 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
		do
			makedev sg$unit c $major $unit $scsi
		done
		;;
	fd)
		# not really devices, we use the /proc filesystem
		symlink fd     $procfs/self/fd
		symlink stdin  fd/0
		symlink stdout fd/1
		symlink stderr fd/2
		;;
	ibcs2)
		major=`Major ibcs2` || continue
		makedev socksys c $major 0 $ibcs2
		symlink nfsd socksys
		makedev spx     c $major 1 $ibcs2
		symlink X0R null
		;;
	apm)
		major=`Major apm_bios` || continue
		makedev $arg c $major 0 $system
		;;
	dcf)
		major=`Major dcf` || continue
		makedev $arg c $major 0 $system
		;;
	helloworld)
		major=`Major hw` || continue
		makedev helloworld c $major 0 $public
		;;
	update)
		if [ ! "$devices" ]
		then
			echo "$0: don't appear to have any devices" >&2
			continue
		fi
		if [ "$opt_d" ]
		then
			echo "$0: can't delete an update" >&2
			continue
		fi
		create=
		delete=
		devs="$devices"
		if [ -f DEVICES ]
		then
			exec 3<DEVICES
			while read device major <&3
			do
				eval now=\$major_$device
				if [ "$now" = "" ]
				then
					delete="$delete `cvt $device`"
					continue
				elif [ "$now" != $major ]
				then
					create="$create "`cvt $device`
				fi
				devs=`strip " $devs " $device`
				# devs=`expr "$devs" : "\(.*\) $device"``expr "$devs" : ".* $device\(.*\)"`
			done
			exec 3<&-
		fi
		create="$create "`cvt $devs`
		[ "$delete" != "" ] && $0 $opts -d $delete
		[ "$create" != " " ] && $0 $opts $create
		[ "$opt_n" ] && continue
		for device in $devices
		do
			if [ "`cvt $device`" ]
			then
			    eval echo $device \$major_$device
			fi
		done > DEVICES
		;;
	*)
		echo "$0: don't know how to make device \"$arg\"" >&2
		;;
	esac
done

exit 0
