1016 lines
27 KiB
Bash
Executable File
1016 lines
27 KiB
Bash
Executable File
#!/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 /usr/src; make buildkernel KERNCONF=FOO
|
|
#
|
|
# More interestingly, it creates a modules/foo directory
|
|
# which it populates, to allow you to compile a FOO module
|
|
# which can be linked 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"
|
|
# arg2 path to the kernel sources, "/sys" if omitted
|
|
#
|
|
# Trust me, RUN THIS SCRIPT :)
|
|
#
|
|
# TODO:
|
|
# o generate foo_isa.c, foo_pci.c, foo_pccard.c, foo_cardbus.c, and foovar.h
|
|
# o Put pccard stuff in here.
|
|
#
|
|
# $FreeBSD$"
|
|
#
|
|
#
|
|
if [ "X${1}" = "X" ]; then
|
|
echo "Hey, how about some help here... give me a device name!"
|
|
exit 1
|
|
fi
|
|
if [ "X${2}" = "X" ]; then
|
|
TOP=`cd /sys; pwd -P`
|
|
echo "Using ${TOP} as the path to the kernel sources!"
|
|
else
|
|
TOP=${2}
|
|
fi
|
|
UPPER=`echo ${1} |tr "[:lower:]" "[:upper:]"`
|
|
|
|
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}/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}/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}/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}
|
|
# \$${RCS_KEYWORD}$
|
|
|
|
files "${TOP}/conf/files.${UPPER}"
|
|
|
|
include GENERIC
|
|
|
|
ident ${UPPER}
|
|
|
|
DONE
|
|
|
|
cat >>${TOP}/i386/conf/${UPPER} <<DONE
|
|
# trust me, you'll need this
|
|
options KDB
|
|
options DDB
|
|
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.
|
|
*/
|
|
|
|
/*
|
|
* http://www.daemonnews.org/200008/isa.html is required reading.
|
|
* hopefully it will make it's way into the handbook.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("\$${RCS_KEYWORD}$");
|
|
|
|
#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 <sys/proc.h>
|
|
#include <sys/time.h>
|
|
#include <sys/${1}io.h> /* ${1} IOCTL definitions */
|
|
|
|
#include <machine/bus.h>
|
|
#include <machine/resource.h>
|
|
#include <sys/rman.h>
|
|
|
|
#include <dev/pci/pcireg.h>
|
|
#include <dev/pci/pcivar.h>
|
|
|
|
#include <isa/isavar.h>
|
|
|
|
#include "isa_if.h"
|
|
|
|
/* 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
|
|
|
|
/*
|
|
* The softc is automatically allocated by the parent bus using the
|
|
* size specified in the driver_t declaration below.
|
|
*/
|
|
#define DEV2SOFTC(dev) ((struct ${1}_softc *) (dev)->si_drv1)
|
|
#define DEVICE2SOFTC(dev) ((struct ${1}_softc *) device_get_softc(dev))
|
|
|
|
/*
|
|
* 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;
|
|
struct cdev *dev;
|
|
void *intr_cookie;
|
|
void *vaddr; /* Virtual address of mem resource. */
|
|
char buffer[BUFFERSIZE]; /* If we need to buffer something. */
|
|
};
|
|
|
|
/* 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, struct ${1}_softc *scp);
|
|
static int ${1}_detach(device_t device, struct ${1}_softc *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);
|
|
|
|
static struct cdevsw ${1}_cdevsw = {
|
|
.d_version = D_VERSION,
|
|
.d_open = ${1}open,
|
|
.d_close = ${1}close,
|
|
.d_read = ${1}read,
|
|
.d_write = ${1}write,
|
|
.d_ioctl = ${1}ioctl,
|
|
.d_poll = ${1}poll,
|
|
.d_mmap = ${1}mmap,
|
|
.d_name = "${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),
|
|
DEVMETHOD_END
|
|
};
|
|
|
|
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:
|
|
* This list should only be used for cards that have some non-destructive
|
|
* (to other cards) way of probing these address. Otherwise the driver
|
|
* should not go looking for instances of itself, but instead rely on
|
|
* the hints file. Strange failures for people with other cards might
|
|
* result.
|
|
*/
|
|
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 safety 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 mentioned 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.
|
|
* The ISA PNP system will have automatically added it to the system and
|
|
* so your identify routine needn't do anything.
|
|
*
|
|
* If the device is mentioned in the 'hints' file then this
|
|
* function can be removed. All devices mentioned 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);
|
|
struct ${1}_softc *scp = DEVICE2SOFTC(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 our table.
|
|
* error == ENOENT, It 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 resource 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 can't 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 resources, we will
|
|
* effectively have disabled 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 immediately. */
|
|
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 (yay new-bus!).
|
|
*/
|
|
static int
|
|
${1}_isa_attach (device_t device)
|
|
{
|
|
int error;
|
|
struct ${1}_softc *scp = DEVICE2SOFTC(device);
|
|
|
|
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)
|
|
{
|
|
int error;
|
|
struct ${1}_softc *scp = DEVICE2SOFTC(device);
|
|
|
|
error = ${1}_detach(device, scp);
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
***************************************
|
|
* PCI Attachment structures and code
|
|
***************************************
|
|
*/
|
|
|
|
static int ${1}_pci_probe(device_t);
|
|
static int ${1}_pci_attach(device_t);
|
|
static int ${1}_pci_detach(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);
|
|
/*
|
|
* Cardbus is a pci bus plus extra, so use the pci driver unless special
|
|
* things need to be done only in the cardbus case.
|
|
*/
|
|
DRIVER_MODULE(${1}, cardbus, ${1}_pci_driver, ${1}_devclass, 0, 0);
|
|
|
|
static struct _pcsid
|
|
{
|
|
u_int32_t type;
|
|
const char *desc;
|
|
} pci_ids[] = {
|
|
{ 0x1234abcd, "ACME PCI Widgetplus" },
|
|
{ 0x1243fedc, "Happy moon brand RIPOFFplus" },
|
|
{ 0x00000000, NULL }
|
|
};
|
|
|
|
/*
|
|
* See if this card is specifically mentioned in our list of known devices.
|
|
* Theoretically we might also put in a weak bid for some devices that
|
|
* report themselves to 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 might be a better driver, return -2 */
|
|
} else
|
|
return ENXIO;
|
|
}
|
|
|
|
static int
|
|
${1}_pci_attach(device_t device)
|
|
{
|
|
int error;
|
|
struct ${1}_softc *scp = DEVICE2SOFTC(device);
|
|
|
|
error = ${1}_attach(device, scp);
|
|
if (error)
|
|
${1}_pci_detach(device);
|
|
return (error);
|
|
}
|
|
|
|
static int
|
|
${1}_pci_detach (device_t device)
|
|
{
|
|
int error;
|
|
struct ${1}_softc *scp = DEVICE2SOFTC(device);
|
|
|
|
error = ${1}_detach(device, scp);
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
****************************************
|
|
* Common Attachment sub-functions
|
|
****************************************
|
|
*/
|
|
static int
|
|
${1}_attach(device_t device, struct ${1}_softc * scp)
|
|
{
|
|
device_t parent = device_get_parent(device);
|
|
int unit = device_get_unit(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_BIO
|
|
* INTR_TYPE_CAM
|
|
* INTR_TYPE_NET
|
|
* INTR_TYPE_MISC
|
|
* This will probably change with SMPng. INTR_TYPE_FAST may be
|
|
* OR'd into this type to mark the interrupt fast. However, fast
|
|
* interrupts cannot be shared at all so special precautions are
|
|
* necessary when coding fast interrupt routines.
|
|
*/
|
|
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 successful. */
|
|
} else
|
|
goto errexit;
|
|
}
|
|
|
|
/*
|
|
* If we want to access the memory we will need
|
|
* to know where it was mapped.
|
|
*
|
|
* Use of this function is discouraged, however. You should
|
|
* be accessing the device with the bus_space API if at all
|
|
* possible.
|
|
*/
|
|
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, struct ${1}_softc *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.
|
|
*
|
|
* Sometimes the parent bus will detach you anyway, even if you
|
|
* are busy. You must cope with that possibility. Your hardware
|
|
* might even already be gone in the case of cardbus or pccard
|
|
* devices.
|
|
*/
|
|
/* 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;
|
|
struct ${1}_softc *scp = DEVICE2SOFTC(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)
|
|
{
|
|
struct ${1}_softc *scp = DEVICE2SOFTC(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)
|
|
{
|
|
struct ${1}_softc *scp = (struct ${1}_softc *) arg;
|
|
|
|
/*
|
|
* Well we got an interrupt, now what?
|
|
*
|
|
* Make sure that the interrupt routine will always terminate,
|
|
* even in the face of "bogus" data from the card.
|
|
*/
|
|
(void)scp; /* Delete this line after using scp. */
|
|
return;
|
|
}
|
|
|
|
static int
|
|
${1}ioctl (struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td)
|
|
{
|
|
struct ${1}_softc *scp = DEV2SOFTC(dev);
|
|
|
|
(void)scp; /* Delete this line after using scp. */
|
|
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(struct cdev *dev, int oflags, int devtype, struct thread *td)
|
|
{
|
|
struct ${1}_softc *scp = DEV2SOFTC(dev);
|
|
|
|
/*
|
|
* Do processing.
|
|
*/
|
|
(void)scp; /* Delete this line after using scp. */
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
${1}close(struct cdev *dev, int fflag, int devtype, struct thread *td)
|
|
{
|
|
struct ${1}_softc *scp = DEV2SOFTC(dev);
|
|
|
|
/*
|
|
* Do processing.
|
|
*/
|
|
(void)scp; /* Delete this line after using scp. */
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
${1}read(struct cdev *dev, struct uio *uio, int ioflag)
|
|
{
|
|
struct ${1}_softc *scp = DEV2SOFTC(dev);
|
|
int toread;
|
|
|
|
/*
|
|
* Do processing.
|
|
* Read from buffer.
|
|
*/
|
|
(void)scp; /* Delete this line after using scp. */
|
|
toread = (min(uio->uio_resid, sizeof(scp->buffer)));
|
|
return(uiomove(scp->buffer, toread, uio));
|
|
}
|
|
|
|
static int
|
|
${1}write(struct cdev *dev, struct uio *uio, int ioflag)
|
|
{
|
|
struct ${1}_softc *scp = DEV2SOFTC(dev);
|
|
int towrite;
|
|
|
|
/*
|
|
* Do processing.
|
|
* Write to buffer.
|
|
*/
|
|
(void)scp; /* Delete this line after using scp. */
|
|
towrite = (min(uio->uio_resid, sizeof(scp->buffer)));
|
|
return(uiomove(scp->buffer, towrite, uio));
|
|
}
|
|
|
|
static int
|
|
${1}mmap(struct cdev *dev, vm_offset_t offset, vm_paddr_t *paddr, int nprot)
|
|
{
|
|
struct ${1}_softc *scp = DEV2SOFTC(dev);
|
|
|
|
/*
|
|
* Given a byte offset into your device, return the PHYSICAL
|
|
* page number that it would map to.
|
|
*/
|
|
(void)scp; /* Delete this line after using scp. */
|
|
#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(struct cdev *dev, int which, struct thread *td)
|
|
{
|
|
struct ${1}_softc *scp = DEV2SOFTC(dev);
|
|
|
|
/*
|
|
* Do processing.
|
|
*/
|
|
(void)scp; /* Delete this line after using scp. */
|
|
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
|
|
|
|
echo -n "Do you want to build the '${1}' module? [Y]"
|
|
read VAL
|
|
if [ "-z" "$VAL" ]; then
|
|
VAL=YES
|
|
fi
|
|
case ${VAL} in
|
|
[yY]*)
|
|
(cd ${TOP}/modules/${1}; make depend; make )
|
|
;;
|
|
*)
|
|
# exit
|
|
;;
|
|
esac
|
|
|
|
echo ""
|
|
echo -n "Do you want to build the '${UPPER}' kernel? [Y]"
|
|
read VAL
|
|
if [ "-z" "$VAL" ]; then
|
|
VAL=YES
|
|
fi
|
|
case ${VAL} in
|
|
[yY]*)
|
|
(
|
|
cd ${TOP}/i386/conf; \
|
|
config ${UPPER}; \
|
|
cd ${TOP}/i386/compile/${UPPER}; \
|
|
make depend; \
|
|
make; \
|
|
)
|
|
;;
|
|
*)
|
|
# exit
|
|
;;
|
|
esac
|
|
|
|
#--------------end of script---------------
|
|
#
|
|
# Edit to your taste...
|
|
#
|
|
#
|