xref: /freebsd/share/examples/drivers/make_device_driver.sh (revision 99fcf9836aa5be4f04f6fd94fde909287d23cc94)

#!/bin/sh
# This writes a skeleton driver and puts it into the kernel tree for you.
# It also adds FOO and files.FOO configuration files so you can compile
# a kernel with your FOO driver linked in.
# To do so:
# cd /sys/i386/conf; config FOO; cd ../../compile/FOO; make depend; make
#
# More interestingly, it creates a modules/foo directory
# which it populates, to allow you to compile a FOO module
# which can be lonked with your presently running kernel (if you feel brave).
# To do so:
# cd /sys/modules/foo; make depend; make; make install; kldload foo
#
# arg1 to this script is expected to be lowercase "foo"
#
# Trust me, RUN THIS SCRIPT :)
#
# $FreeBSD$"
#
#
if [ "${1}X" = "X" ]
then
	echo "Hey , how about some help here.. give me a device name!"
	exit 1
fi
UPPER=`echo ${1} |tr "[:lower:]" "[:upper:]"`

HERE=`pwd`
cd /sys
TOP=`pwd`

RCS_KEYWORD=FreeBSD

if [ -d ${TOP}/modules/${1} ]
then
	echo "There appears to already be a module called ${1}"
	echo -n "Should it be overwritten? [Y]"
	read VAL
	if [ "-z" "$VAL" ]
	then
	  VAL=YES
	fi
	case ${VAL} in
	[yY]*)
	  echo "Cleaning up from prior runs"
	  rm -rf ${TOP}/dev/${1}
	  rm -rf ${TOP}/modules/${1}
	  rm ${TOP}/i386/conf/files.${UPPER}
	  rm ${TOP}/i386/conf/${UPPER}
	  rm ${TOP}/sys/${1}io.h
	  ;;
	*)
	  exit 1
	  ;;
	esac
fi

echo "The following files will be created:"
echo ${TOP}/modules/${1}
echo ${TOP}/i386/conf/files.${UPPER}
echo ${TOP}/i386/conf/${UPPER}
echo ${TOP}/dev/${1}
echo ${TOP}/dev/${1}/${1}.c
echo ${TOP}/sys/${1}io.h
echo ${TOP}/modules/${1}
echo ${TOP}/modules/${1}/Makefile


	mkdir ${TOP}/modules/${1}

#######################################################################
#######################################################################
#
# Create configuration information needed to create a kernel
# containing this driver.
#
# Not really needed if we are going to do this as a module.
#######################################################################
# First add the file to a local file list.
#######################################################################

cat >${TOP}/i386/conf/files.${UPPER} <<DONE
dev/${1}/${1}.c	 optional ${1}
DONE

#######################################################################
# Then create a configuration file for a kernel that contains this driver.
#######################################################################
cat >${TOP}/i386/conf/${UPPER} <<DONE
# Configuration file for kernel type: ${UPPER}
ident	${UPPER}
# \$${RCS_KEYWORD}: $
DONE

grep -v GENERIC < /sys/i386/conf/GENERIC >>${TOP}/i386/conf/${UPPER}

cat >>${TOP}/i386/conf/${UPPER} <<DONE
options		DDB		# trust me, you'll need this
device		${1}
DONE

if [ ! -d ${TOP}/dev/${1} ]
then
	mkdir -p ${TOP}/dev/${1}
fi




cat >${TOP}/dev/${1}/${1}.c <<DONE
/*
 * Copyright (c) [year] [your name]
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *
 * ${1} driver
 * \$${RCS_KEYWORD}: $
 */

/*
 * http://www.daemonnews.org/200008/isa.html is required reading.
 * hopefully it will make it's way into the handbook.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/conf.h>		/* cdevsw stuff */
#include <sys/kernel.h>		/* SYSINIT stuff */
#include <sys/uio.h>		/* SYSINIT stuff */
#include <sys/malloc.h>		/* malloc region definitions */
#include <sys/module.h>
#include <sys/bus.h>
#include <machine/bus.h>
#include <machine/resource.h>
#include <machine/bus_pio.h>
#include <machine/bus_memio.h>
#include <sys/rman.h>
#include <sys/time.h>

#include <pci/pcireg.h>
#include <pci/pcivar.h>

#include <isa/isavar.h>
#include "isa_if.h"
#include <sys/${1}io.h>		/* ${1} IOCTL definitions */

/* XXX These should be defined in terms of bus-space ops */
#define ${UPPER}_INB(port) inb(port_start)
#define ${UPPER}_OUTB(port, val) ( port_start, (val))
#define SOME_PORT 123
#define EXPECTED_VALUE 0x42

/* 
 * device specific Misc defines 
 */
#define BUFFERSIZE	1024
#define NUMPORTS	4
#define MEMSIZE		(4 * 1024) /* imaginable h/w buffer size */

/*
 * One of these per allocated device
 */
struct ${1}_softc {
	bus_space_tag_t bt;
	bus_space_handle_t bh;
	int rid_ioport;
	int rid_memory;
	int rid_irq;
	int rid_drq;
	struct resource* res_ioport;	/* resource for port range */
	struct resource* res_memory;	/* resource for mem range */
	struct resource* res_irq;	/* resource for irq range */
	struct resource* res_drq;	/* resource for dma channel */
	device_t device;
	dev_t dev;
	void	*intr_cookie;
	void	*vaddr;			/* Virtual address of mem resource */
	char	buffer[BUFFERSIZE];	/* if we needed to buffer something */
} ;

typedef	struct ${1}_softc *sc_p;


/* Function prototypes (these should all be static) */
static int ${1}_deallocate_resources(device_t device);
static int ${1}_allocate_resources(device_t device);
static int ${1}_attach(device_t device, sc_p scp);
static int ${1}_detach(device_t device, sc_p scp);

static d_open_t		${1}open;
static d_close_t	${1}close;
static d_read_t		${1}read;
static d_write_t	${1}write;
static d_ioctl_t	${1}ioctl;
static d_mmap_t		${1}mmap;
static d_poll_t		${1}poll;
static	void		${1}intr(void *arg);
 
#define CDEV_MAJOR 20
static struct cdevsw ${1}_cdevsw = {
	/* open */	${1}open,
	/* close */	${1}close,
	/* read */	${1}read,
	/* write */	${1}write,
	/* ioctl */	${1}ioctl,
	/* poll */	${1}poll,
	/* mmap */	${1}mmap,
	/* strategy */	nostrategy,	/* not a block type device */
	/* name */	"${1}",
	/* maj */	CDEV_MAJOR,
	/* dump */	nodump,		/* not a block type device */
	/* psize */	nopsize,	/* not a block type device */
	/* flags */	0,
	/* bmaj */	-1
};

static devclass_t ${1}_devclass;
 
/*****************************************\
* ISA Attachment structures and functions
\*****************************************/
static void ${1}_isa_identify (driver_t *, device_t);
static int ${1}_isa_probe (device_t);
static int ${1}_isa_attach (device_t);
static int ${1}_isa_detach (device_t);

static struct isa_pnp_id ${1}_ids[] = {
	{0x12345678,	"ABCco Widget"},
	{0xfedcba98,	"shining moon Widget ripoff"},
	{0,		NULL}
};

static device_method_t ${1}_methods[] = {
	DEVMETHOD(device_identify,	${1}_isa_identify),
	DEVMETHOD(device_probe,		${1}_isa_probe),
	DEVMETHOD(device_attach,	${1}_isa_attach),
	DEVMETHOD(device_detach,	${1}_isa_detach),
	{ 0, 0 }
};

static driver_t ${1}_isa_driver = {
	"${1}",
	${1}_methods,
	sizeof (struct ${1}_softc)
};


DRIVER_MODULE(${1}, isa, ${1}_isa_driver, ${1}_devclass, 0, 0);

/*
 * Here list some port addresses we might expect our widget to appear at:
 */
static struct localhints {
	int ioport;
	int irq;
	int drq;
	int mem;
} res[] = {
	{ 0x210, 11, 2, 0xcd000},
	{ 0x310, 12, 3, 0xdd000},
	{ 0x320, 9, 6, 0xd4000},
	{0,0,0,0}
};

#define MAXHINTS 10 /* just an arbitrary safty limit */
/*
 * Called once when the driver is somehow connected with the bus,
 * (Either linked in and the bus is started, or loaded as a module).
 *
 * The aim of this routine in an ISA driver is to add child entries to
 * the parent bus so that it looks as if the devices were detected by
 * some pnp-like method, or at least mentionned in the hints.
 *
 * For NON-PNP "dumb" devices:
 * Add entries into the bus's list of likely devices, so that
 * our 'probe routine' will be called for them.
 * This is similar to what the 'hints' code achieves, except this is
 * loadable with the driver.
 * In the 'dumb' case we end up with more children than needed but
 * some (or all) of them will fail probe() and only waste a little memory.
 *
 * For NON-PNP "Smart" devices:
 * If the device has a NON-PNP way of being detected and setting/sensing
 * the card, then do that here and add a child for each set of
 * hardware found. 
 *
 * For PNP devices:
 * If the device is always PNP capable then this function can be removed.
 *
 * If the device is mentionned in the 'hints' file then this
 * function can be removed. All devices mentionned in the hints
 * file get added as children for probing, whether or not the
 * driver is linked in. So even as a module it MAY still be there.
 * See isa/isahint.c for hints being added in.
 */
static void
${1}_isa_identify (driver_t *driver, device_t parent)
{
	u_int32_t	irq=0;
	u_int32_t	ioport;
	device_t	child;
	int i;


	/*
	 * If we've already got ${UPPER} attached somehow, don't try again.
	 * Maybe it was in the hints file. or it was loaded before.
	 */
	if (device_find_child(parent, "${1}", 0)) {
		printf("${UPPER}: already attached\n");
		return;
	}
/* XXX look at dev/acpica/acpi_isa.c for use of ISA_ADD_CONFIG() macro */
/* XXX What is ISA_SET_CONFIG_CALLBACK(parent, child, pnpbios_set_config, 0) ?*/
	for (i = 0; i < MAXHINTS; i++) {

		ioport = res[i].ioport;
		irq = res[i].irq;
		if ((ioport == 0) &&  (irq == 0)) {
			return; /* we've added all our local hints */
		}

		child = BUS_ADD_CHILD(parent, ISA_ORDER_SPECULATIVE, "${1}", -1);
		bus_set_resource(child, SYS_RES_IOPORT,	0, ioport, NUMPORTS);
		bus_set_resource(child, SYS_RES_IRQ,	0, irq, 1);
		bus_set_resource(child, SYS_RES_DRQ,	0, res[i].drq, 1);
		bus_set_resource(child, SYS_RES_MEMORY,	0, res[i].mem, MEMSIZE);


#if 0
		/*
		 * If we wanted to pretend PNP found it
		 * we could do this, and put matching entries
		 * in the PNP table, but I think it's probably too hacky.
		 * As you see, some people have done it though.
		 * Basically EISA (remember that?) would do this I think
		 */
		isa_set_vendorid(child, PNP_EISAID("ESS1888"));
		isa_set_logicalid(child, PNP_EISAID("ESS1888"));
#endif
	}
#if 0
	Do some smart probing (e.g. like the lnc driver)
	and add a child for each one found.
#endif

	return;
}
/*
 * The ISA code calls this for each device it knows about,
 * whether via the PNP code or via the hints etc.
 * If the device nas no PNP capabilities, remove all the 
 * PNP entries, but keep the call to ISA_PNP_PROBE()
 * As it will guard against accidentally recognising
 * foreign hardware. This is because we will be called to check against
 * ALL PNP hardware.
 */
static int
${1}_isa_probe (device_t device)
{
	int error;
	device_t parent = device_get_parent(device);
	sc_p scp = device_get_softc(device);
	u_long	port_start, port_count;


	bzero(scp, sizeof(*scp));
	scp->device = device;

	/*
	 * Check this device for a PNP match in our table..
	 * There are several possible outcomes.
	 * error == 0		We match a PNP ).
	 * error == ENXIO,	It is a PNP device but not in out table.
	 * error == ENOENT,	I is not a PNP device.. try heuristic probes.
	 *    -- logic from if_ed_isa.c, added info from isa/isa_if.m:
	 *
	 * If we had a list of devices that we could handle really well,
	 * and a list which we could handle only basic functions, then
	 * we would call this twice, once for each list,
	 * and return a value of '-2' or something if we could
	 * only handle basic functions. This would allow a specific
	 * Widgetplus driver to make a better offer if it knows how to
	 * do all the extended functions. (see non-pnp part for more info)
	 */
	error = ISA_PNP_PROBE(parent, device, ${1}_ids);
	switch (error) {
	case 0:
		/*
		 * We found a PNP device.
		 * Do nothing, as it's all done in attach()
		 */
		break;
	case ENOENT:
		/*
		 * Well it didn't show up in the PNP tables
		 * so look directly at known ports (if we have any)
		 * in case we are looking for an old pre-PNP card.
		 * 
		 * Hopefully the  'identify' routine will have picked these
		 * up for us first if they use some proprietary detection
		 * method.
		 *
		 * The ports, irqs etc should come from a 'hints' section
		 * which is read in by code in isa/isahint.c
		 * and kern/subr_bus.c to create resource entries,
		 * or have been added by the 'identify routine above.
		 * Note that HINTS based resourse requests have NO
		 * SIZE for the memory or ports requests  (just a base)
		 * so we may need to 'correct' this before we
		 * do any probing.
		 */
		/*
		 * find out the values of any resources we
		 * need for our dumb probe. Also check we have enough ports 
		 * in the request. (could be hints based). 
		 * Should probably do the same for memory regions too.
		 */
		error = bus_get_resource(device, SYS_RES_IOPORT, 0,
			&port_start, &port_count);
		if (port_count != NUMPORTS) {
			bus_set_resource(device, SYS_RES_IOPORT, 0,
			port_start, NUMPORTS);
		}

		/*
		 * Make a temporary resource reservation.
		 * If we can't get the resources we need then
		 * we need to abort.  Possibly this indicates
		 * the resources were used by another device
		 * in which case the probe would have failed anyhow.
		 */
		if ((error = (${1}_allocate_resources(device)))) {
			error = ENXIO;
			goto errexit;
		}

		/* dummy heuristic type probe */
		if ( inb(port_start) != EXPECTED_VALUE) {
			/* 
			 * It isn't what we hoped, so quit looking for it.
			 */
			error = ENXIO;
		} else {
			u_long membase = bus_get_resource_start(device,
					SYS_RES_MEMORY, 0 /*rid*/);
			u_long memsize;
			/*
			 * If we discover in some way that the device has
			 * XXX bytes of memory window, we can override
			 * or set the memory size in the child resource list.
			 */
			memsize = inb(port_start + 1) * 1024; /* for example */
			error = bus_set_resource(device, SYS_RES_MEMORY,
				/*rid*/0, membase, memsize);
			/*
			 * We found one, return non-positive numbers..
			 * Return -N if we cant handle it, but not well.
			 * Return -2 if we would LIKE the device
			 * Return -1 if we want it a lot
			 * Return 0 if we MUST get the device
			 * This allows drivers to 'bid' for a device.
			 */
			device_set_desc(device, "ACME Widget model 1234");
			error = -1; /* we want it but someone else
					may be even better */
		}
		/*
		 * Unreserve the resources for now because
		 * another driver may bid for device too.
		 * If we lose the bid, but still hold the resouces, we will
		 * effectively have diabled the other driver from getting them
		 * which will result in neither driver getting the device.
		 * We will ask for them again in attach if we win.
		 */
		${1}_deallocate_resources(device);
		break;
	case  ENXIO:
		/* It was PNP but not ours, leave imediatly */
	default:
		error = ENXIO;
	}
errexit:
	return (error);
}

/*
 * Called if the probe succeeded and our bid won the device.
 * We can be destructive here as we know we have the device.
 * This is the first place we can be sure we have a softc structure.
 * You would do ISA specific attach things here, but generically there aren't
 * any (yey new-bus!).
 */
static int
${1}_isa_attach (device_t device)
{
	sc_p	scp	= device_get_softc(device);
        int	error;

        error =  ${1}_attach(device, scp);
        if (error) {
                ${1}_isa_detach(device);
        }
        return (error);

}

/* 
 * detach the driver (e.g. module unload)
 * call the bus independent version
 * and undo anything we did in the ISA attach routine.
 */
static int
${1}_isa_detach (device_t device)
{
	sc_p	scp	= device_get_softc(device);
        int	error;

        error =  ${1}_detach(device, scp);
        return (error);
}

/***************************************\
* PCI Attachment structures and code	*
\***************************************/

static int	${1}_pci_probe	__P((device_t));
static int	${1}_pci_attach	__P((device_t));
static int	${1}_pci_detach	__P((device_t));

static device_method_t ${1}_pci_methods[] = {
	/* Device interface */
	DEVMETHOD(device_probe,		${1}_pci_probe),
	DEVMETHOD(device_attach,	${1}_pci_attach),
	DEVMETHOD(device_detach,	${1}_pci_detach),
	{ 0, 0 }
};

static driver_t ${1}_pci_driver = {
	"${1}",
	${1}_pci_methods,
	sizeof(struct ${1}_softc),
};


DRIVER_MODULE(${1}, pci, ${1}_pci_driver, ${1}_devclass, 0, 0);

static struct _pcsid
{
	u_int32_t	type;
	const char	*desc;
} pci_ids[] = {
	{ 0x1234abcd,	"ACME PCI Widgetplus"	},
	{ 0x1234fedc,	"Happy moon brand RIPOFFplus"	},
	{ 0x00000000,	NULL					}
};

/*
 * See if this card is specifically mentionned in our list of known devices.
 * Theoretically we might also put in a weak bid for some devices that
 * report themselves o be some generic type of device if we can handle
 * that generic type. (other PCI_XXX calls give that info).
 * This would allow a specific driver to over-ride us.
 *
 * See the comments in the ISA section regarding returning non-positive
 * values from probe routines.
 */
static int
${1}_pci_probe (device_t device)
{
	u_int32_t	type = pci_get_devid(device);
	struct _pcsid	*ep =pci_ids;

	while (ep->type && ep->type != type)
		++ep;
	if (ep->desc) {
		device_set_desc(device, ep->desc);
		return 0; /* If there may be a better driver, return -2 */
	} else {
		return ENXIO;
	}
}

static int
${1}_pci_attach(device_t device)
{
	sc_p	scp	= device_get_softc(device);
        int	error;

        error =  ${1}_attach(device, scp);
        if (error) {
                ${1}_pci_detach(device);
        }
        return (error);
}

static int
${1}_pci_detach (device_t device)
{
	sc_p	scp	= device_get_softc(device);
        int	error;

        error =  ${1}_detach(device, scp);
        return (error);
}


/****************************************\
*  Common Attachment subfunctions	*
\****************************************/
static int
${1}_attach(device_t device, sc_p scp)
{
	int	unit	= device_get_unit(device);
	device_t parent	= device_get_parent(device);

	scp->dev = make_dev(&${1}_cdevsw, 0,
			UID_ROOT, GID_OPERATOR, 0600, "${1}%d", unit);
	scp->dev->si_drv1 = scp;

	if (${1}_allocate_resources(device)) {
		goto errexit;
	}

	scp->bt = rman_get_bustag(scp->res_ioport);
	scp->bh = rman_get_bushandle(scp->res_ioport);

	/* register the interrupt handler */
	/*
	 * The type should be one of:
	 *	INTR_TYPE_TTY
	 *	(INTR_TYPE_TTY | INTR_TYPE_FAST) 
	 *	INTR_TYPE_BIO 
	 *	INTR_TYPE_CAM 
	 *	INTR_TYPE_NET 
	 *	INTR_TYPE_MISC 
	 * This will probably change with SMPng.
	 */
	if (scp->res_irq) {
		/* default to the tty mask for registration */  /* XXX */
		if (BUS_SETUP_INTR(parent, device, scp->res_irq, INTR_TYPE_TTY,
				${1}intr, scp, &scp->intr_cookie) == 0) {
			/* do something if successfull */
		} else {
			goto errexit;
		}
	}

	/*
	 * If we want to access the memory we will need
	 * to know where it was mapped.
	 */
	scp->vaddr = rman_get_virtual(scp->res_memory);
	return 0;

errexit:
	/*
	 * Undo anything we may have done
	 */
	${1}_detach(device, scp);
	return (ENXIO);
}

static int
${1}_detach(device_t device, sc_p scp)
{
	device_t parent = device_get_parent(device);

	/*
	 * At this point stick a strong piece of wood into the device
	 * to make sure it is stopped safely. The alternative is to 
	 * simply REFUSE to detach if it's busy. What you do depends on 
	 * your specific situation.
	 */
	/* ZAP some register */

	/*
	 * Take our interrupt handler out of the list of handlers
	 * that can handle this irq.
	 */
	if (scp->intr_cookie != NULL) {
		if (BUS_TEARDOWN_INTR(parent, device,
			scp->res_irq, scp->intr_cookie) != 0) {
				printf("intr teardown failed.. continuing\n");
		}
		scp->intr_cookie = NULL;
	}

	/*
	 * deallocate any system resources we may have
	 * allocated on behalf of this driver.
	 */
	scp->vaddr = NULL;
	return ${1}_deallocate_resources(device);
}

static int
${1}_allocate_resources(device_t device)
{
	int error;
	sc_p scp = device_get_softc(device);
	int	size = 16; /* SIZE of port range used */

	scp->res_ioport = bus_alloc_resource(device, SYS_RES_IOPORT,
			&scp->rid_ioport, 0ul, ~0ul, size, RF_ACTIVE);
	if (scp->res_ioport == NULL) {
		goto errexit;
	}

	scp->res_irq = bus_alloc_resource(device, SYS_RES_IRQ,
			&scp->rid_irq, 0ul, ~0ul, 1, RF_SHAREABLE|RF_ACTIVE);
	if (scp->res_irq == NULL) {
		goto errexit;
	}

	scp->res_drq = bus_alloc_resource(device, SYS_RES_DRQ,
			&scp->rid_drq, 0ul, ~0ul, 1, RF_ACTIVE);
	if (scp->res_drq == NULL) {
		goto errexit;
	}

	scp->res_memory = bus_alloc_resource(device, SYS_RES_MEMORY,
			&scp->rid_memory, 0ul, ~0ul, MSIZE, RF_ACTIVE);
	if (scp->res_memory == NULL) {
		goto errexit;
	}
	return (0);

errexit:
	error = ENXIO;
	/* cleanup anything we may have assigned. */
	${1}_deallocate_resources(device);
	return (ENXIO); /* for want of a better idea */
}

static int
${1}_deallocate_resources(device_t device)
{
	sc_p scp = device_get_softc(device);

	if (scp->res_irq != 0) {
		bus_deactivate_resource(device, SYS_RES_IRQ,
			scp->rid_irq, scp->res_irq);
		bus_release_resource(device, SYS_RES_IRQ,
			scp->rid_irq, scp->res_irq);
		scp->res_irq = 0;
	}
	if (scp->res_ioport != 0) {
		bus_deactivate_resource(device, SYS_RES_IOPORT,
			scp->rid_ioport, scp->res_ioport);
		bus_release_resource(device, SYS_RES_IOPORT,
			scp->rid_ioport, scp->res_ioport);
		scp->res_ioport = 0;
	}
	if (scp->res_memory != 0) {
		bus_deactivate_resource(device, SYS_RES_MEMORY,
			scp->rid_memory, scp->res_memory);
		bus_release_resource(device, SYS_RES_MEMORY,
			scp->rid_memory, scp->res_memory);
		scp->res_memory = 0;
	}
	if (scp->res_drq != 0) {
		bus_deactivate_resource(device, SYS_RES_DRQ,
			scp->rid_drq, scp->res_drq);
		bus_release_resource(device, SYS_RES_DRQ,
			scp->rid_drq, scp->res_drq);
		scp->res_drq = 0;
	}
	if (scp->dev) {
		destroy_dev(scp->dev);
	}
	return (0);
}

static void
${1}intr(void *arg)
{
	sc_p scp	= arg;

	/* 
	 * well we got an interupt, now what?
	 */
	return;
}

static int
${1}ioctl (dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
{
	sc_p scp	= dev->si_drv1;

	switch (cmd) {
	case DHIOCRESET:
		/* whatever resets it */
#if 0
		${UPPER}_OUTB(SOME_PORT, 0xff) ;
#endif
		break;
	default:
		return ENXIO;
	}
	return (0);
}
/*
 * You also need read, write, open, close routines.
 * This should get you started
 */
static int
${1}open(dev_t dev, int oflags, int devtype, struct proc *p)
{
	sc_p scp	= dev->si_drv1;

	/* 
	 * Do processing
	 */
	return (0);
}

static int
${1}close(dev_t dev, int fflag, int devtype, struct proc *p)
{
	sc_p scp	= dev->si_drv1;

	/* 
	 * Do processing
	 */
	return (0);
}

static int
${1}read(dev_t dev, struct uio *uio, int ioflag)
{
	sc_p scp	= dev->si_drv1;
	int	 toread;


	/* 
	 * Do processing
	 * read from buffer
	 */
	toread = (min(uio->uio_resid, sizeof(scp->buffer)));
	return(uiomove(scp->buffer, toread, uio));
}

static int
${1}write(dev_t dev, struct uio *uio, int ioflag)
{
	sc_p scp	= dev->si_drv1;
	int	towrite;

	/* 
	 * Do processing
	 * write to buffer
	 */
	towrite = (min(uio->uio_resid, sizeof(scp->buffer)));
	return(uiomove(scp->buffer, towrite, uio));
}

static int
${1}mmap(dev_t dev, vm_offset_t offset, int nprot)
{
	sc_p scp	= dev->si_drv1;

	/* 
	 * Given a byte offset into your device, return the PHYSICAL
	 * page number that it would map to.
	 */
#if 0	/* if we had a frame buffer or whatever.. do this */
	if (offset > FRAMEBUFFERSIZE - PAGE_SIZE) {
		return (-1);
	}
	return i386_btop((FRAMEBASE + offset));
#else
	return (-1);
#endif
}

static int
${1}poll(dev_t dev, int which, struct proc *p)
{
	sc_p scp	= dev->si_drv1;

	/* 
	 * Do processing
	 */
	return (0); /* this is the wrong value I'm sure */
}

DONE

cat >${TOP}/sys/${1}io.h <<DONE
/*
 * Definitions needed to access the ${1} device (ioctls etc)
 * see mtio.h , ioctl.h as examples
 */
#ifndef SYS_DHIO_H
#define SYS_DHIO_H

#ifndef KERNEL
#include <sys/types.h>
#endif
#include <sys/ioccom.h>

/*
 * define an ioctl here
 */
#define DHIOCRESET _IO('D', 0) /* reset the ${1} device */
#endif
DONE

if [ ! -d ${TOP}/modules/${1} ]
then
	mkdir -p ${TOP}/modules/${1}
fi

cat >${TOP}/modules/${1}/Makefile <<DONE
#	${UPPER} Loadable Kernel Module
#
# \$${RCS_KEYWORD}: $
 
.PATH:  \${.CURDIR}/../../dev/${1}
KMOD    = ${1}
SRCS    = ${1}.c
SRCS    += opt_inet.h device_if.h bus_if.h pci_if.h isa_if.h
  
# you may need to do this is your device is an if_xxx driver
opt_inet.h:
	echo "#define INET 1" > opt_inet.h
	   
.include <bsd.kmod.mk>
DONE

(cd ${TOP}/modules/${1}; make depend; make )
exit

config ${UPPER}
cd ../../compile/${UPPER}
make depend
make ${1}.o
make
exit

#--------------end of script---------------
#
#edit to your taste..
#
#