Xref: utzoo comp.sys.att:3326 unix-pc.sources:58
Path: utzoo!utgpu!water!watmath!uunet!lll-winken!lll-tis!helios.ee.lbl.gov!nosc!ucsd!ucsdhub!jack!elgar!ford@kenobi.UUCP
From: ford@kenobi.UUCP (Mike "Ford" Ditto)
Newsgroups: comp.sys.att,unix-pc.sources
Subject: Unix PC /dev/vidram device driver (sources)
Summary: 10-minute hack, submitted for your approval
Keywords: unixpc loadable device driver source
Message-ID: <156@elgar.UUCP>
Date: 25 May 88 17:03:22 GMT
Sender: ford@elgar.UUCP
Reply-To: ford@kenobi.UUCP (Mike Ditto)
Organization: Omnicron Data Systems,  Bonita, CA
Lines: 308


Since everyone's talking about direct video access these days, I put
together a device driver just for that purpose.  "/dev/vidram" is a
character device that lets you use seek/read/write to access the
**RAW** video memory.  I think this is a much lower level access than
anyone will want; for example, if the screen-blanker is active
(blanking the screen) you will just read zeroes from this device.  But
I'll send it out so all you people can see if you have some use for
it.


"vidram.shar" is after my signature.

					-=] Ford [=-

"Once there were parking lots,		(In Real Life:  Mike Ditto)
now it's a peaceful oasis.		ford%kenobi@crash.CTS.COM
This was a Pizza Hut,			...!sdcsvax!crash!kenobi!ford
now it's all covered with daisies." -- Talking Heads

#! /bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #! /bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create the files:
#	vidram.doc
#	Makefile
#	Size
#	Install
#	Name
#	Remove
#	Files
#	INSTALL
# This archive created: Tue May 24 23:44:09 1988
export PATH; PATH=/bin:$PATH
echo shar: extracting "'vidram.doc'" '(2985 characters)'
if test -f 'vidram.doc'
then
	echo shar: will not over-write existing file "'vidram.doc'"
else
cat << \SHAR_EOF > 'vidram.doc'
Ha!  You expect documentation for a program I wrote in 10 minutes and
give away free?!?!  Well, I guess I can do something...

The "/dev/vidram" driver allows file-like access to the Unix PC video
bitmap memory.  This is a very low-level way to access the display,
and I don't recommend it, but it's an interesting thing to experiment
with.  Use it at your own risk.

To use it, just open(2) "/dev/vidram" and lseek(2) to the position you
want to access.  The video display is arranged in 16-bit words, and
the leftmost 16 pixels on the top line are at lseek offset 0.  The
leftmost pixel is the least significant bit (bit 0) of this word, and
the rightmost pixel of that group of 16 is the most significant bit
(bit 15) of the word.  This can be confusing if you think in Motorola
Byte Order, but that's your problem anyway.  You may read(2) or
write(2) the bytes to/from the display after seeking to the position
you want.

Note that the driver makes things look like just a bunch of bytes; you
only have to think of the 16-bit words if you want to visualize how
all these bits would appear on the screen.  Because Unix works in
bytes, and the screen hardware works in words, the driver is not
incredibly efficient.  But it is somewhat interesting, so I wrote it.

The driver is currently set up so that only super-user can write to
the screen (anyone can read).  It is pretty obvious how to change this
in the source if you want to just use the file permissions to regulate
/dev/vidram access.


To make the driver, just type "make" (as root).  You can also type
"make installable" to create a "vid+IN" that J. Random Luser can
install on his machine, or "make floppy" to make an Installable Floppy
that you can send to J. Random Luser if he doesn't have a uucp
connection.  Note that this doesn't physically create a floppy disk
where there wasn't one, it just writes on a disk that you supply,
despite the misleading command name and my misleading description
above.  The installable packages don't include source; if you want to
give that to someone, just send the shar file you got it in.


In case anyone's interested, here's a breakdown of how long it took me
to write this driver:


	10 minutes  to write the code.  It compiled the first time (weird!).
	10 minutes  to steal the installation package from another driver.
	10 minutes  to test it a bit and discover that the hardware only
		    allows word-wide access, and modify the code to do this.
	10 minutes  for the machine to crash and reboot, since there was a
		    slight bug in that last change.
	10 minutes  to fix the bug, recompile and test a bit more.
	10 minutes  to write this silly file.


Anyway, let me know if you find this program useful, educational, or
broken.

					-=] Ford [=-

"Once there were parking lots,		(In Real Life:  Mike Ditto)
now it's a peaceful oasis.		ford%kenobi@crash.CTS.COM
This was a Pizza Hut,			...!sdcsvax!crash!kenobi!ford
now it's all covered with daisies." -- Talking Heads
SHAR_EOF
if test 2985 -ne "`wc -c < 'vidram.doc'`"
then
	echo shar: error transmitting "'vidram.doc'" '(should have been 2985 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'Makefile'" '(360 characters)'
if test -f 'Makefile'
then
	echo shar: will not over-write existing file "'Makefile'"
else
cat << \SHAR_EOF > 'Makefile'
D=-O
CFLAGS= $D
DRIVER=vid

install : $(DRIVER).o
	./INSTALL

all : $(DRIVER)+IN

installable : $(DRIVER)+IN

$(DRIVER)+IN : $(DRIVER).o
	cpio -oBc < Files > $(DRIVER)+IN

floppy : $(DRIVER)+IN
	echo "Insert a formatted floppy disk and press return"; read foo
	dd if=$(DRIVER)+IN of=/dev/rfp021 bs=16384

clean: 
	rm $(DRIVER).o $(DRIVER)+IN

clobber : clean

SHAR_EOF
if test 360 -ne "`wc -c < 'Makefile'`"
then
	echo shar: error transmitting "'Makefile'" '(should have been 360 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'Size'" '(3 characters)'
if test -f 'Size'
then
	echo shar: will not over-write existing file "'Size'"
else
cat << \SHAR_EOF > 'Size'
42
SHAR_EOF
if test 3 -ne "`wc -c < 'Size'`"
then
	echo shar: error transmitting "'Size'" '(should have been 3 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'Install'" '(250 characters)'
if test -f 'Install'
then
	echo shar: will not over-write existing file "'Install'"
else
cat << \SHAR_EOF > 'Install'
# Install script for /dev/vidram driver

DRIVER=vid

./INSTALL || exit 1

cd /etc/lddrv

# put an entry in InstDrv for ${DRIVER}
cat >> InstDrv << EOF
Name=/dev/vidram driver
File=${DRIVER}
EOF


echo "The /dev/vidram driver is now installed"
exit 0
SHAR_EOF
if test 250 -ne "`wc -c < 'Install'`"
then
	echo shar: error transmitting "'Install'" '(should have been 250 characters)'
fi
chmod +x 'Install'
fi # end of overwriting check
echo shar: extracting "'Name'" '(42 characters)'
if test -f 'Name'
then
	echo shar: will not over-write existing file "'Name'"
else
cat << \SHAR_EOF > 'Name'
/dev/vidram driver by Ford Prefect (M.D.)
SHAR_EOF
if test 42 -ne "`wc -c < 'Name'`"
then
	echo shar: error transmitting "'Name'" '(should have been 42 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'Remove'" '(167 characters)'
if test -f 'Remove'
then
	echo shar: will not over-write existing file "'Remove'"
else
cat << \SHAR_EOF > 'Remove'
rm -f /dev/vidram

cd /etc/lddrv
./lddrv -dv vid
echo '/^vid$/d
w' | ed - drivers
rm -f ifile.vid vid vid.o

/etc/masterupd -d vid


echo "/dev/vidram driver REMOVED"
SHAR_EOF
if test 167 -ne "`wc -c < 'Remove'`"
then
	echo shar: error transmitting "'Remove'" '(should have been 167 characters)'
fi
chmod +x 'Remove'
fi # end of overwriting check
echo shar: extracting "'Files'" '(45 characters)'
if test -f 'Files'
then
	echo shar: will not over-write existing file "'Files'"
else
cat << \SHAR_EOF > 'Files'
Size
Install
Name
Remove
Files
INSTALL
vid.o
SHAR_EOF
if test 45 -ne "`wc -c < 'Files'`"
then
	echo shar: error transmitting "'Files'" '(should have been 45 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'INSTALL'" '(918 characters)'
if test -f 'INSTALL'
then
	echo shar: will not over-write existing file "'INSTALL'"
else
cat << \SHAR_EOF > 'INSTALL'
set -e		# exit if there anything goes wrong

DRIVER=vid

if [ ! -f ${DRIVER}.o ]
then
	echo "you must make ${DRIVER}.o before running INSTALL" 1>&2
	exit 1
fi


if [ ! -c /dev/vidram ]
then
	/etc/masterupd -a char release open close read write ${DRIVER}

	# get the assigned device number
	MAJOR=`/etc/masterupd -c ${DRIVER}`
	if [ $? -ne 0 ]
	then
		echo "${DRIVER} cannot be added to the /etc/master file" 1>&2
		exit 1
	fi

	rm -f /dev/vidram > /dev/null 2>&1
	/etc/mknod /dev/vidram c $MAJOR 0
fi

cp ${DRIVER}.o /etc/lddrv/

cd /etc/lddrv

# remove the driver if it's already running

./lddrv -q ${DRIVER} && ./lddrv -d ${DRIVER}

# allocate and load the module

if ./lddrv -a ${DRIVER}
then
	echo "Driver ${DRIVER} successfully loaded"
else
	echo "Error: Driver ${DRIVER} failed loading stage" 1>&2
	exit 1
fi

# load the driver at boot time

grep "^${DRIVER}\$" drivers > /dev/null || echo ${DRIVER} >> drivers
SHAR_EOF
if test 918 -ne "`wc -c < 'INSTALL'`"
then
	echo shar: error transmitting "'INSTALL'" '(should have been 918 characters)'
fi
chmod +x 'INSTALL'
fi # end of overwriting check
#	End of shell archive
exit 0