661 lines
16 KiB
C
661 lines
16 KiB
C
/*-
|
|
* Copyright (c) 1999 Seigo Tanimura
|
|
* 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.
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
#include "isa.h"
|
|
|
|
#include <dev/sound/chip.h>
|
|
#include <dev/sound/pcm/sound.h>
|
|
#include <dev/sound/isa/sb.h>
|
|
|
|
#define IO_MAX 3
|
|
#define IRQ_MAX 1
|
|
#define DRQ_MAX 2
|
|
#define INTR_MAX 2
|
|
|
|
struct sbc_ihl {
|
|
driver_intr_t *intr[INTR_MAX];
|
|
void *intr_arg[INTR_MAX];
|
|
};
|
|
|
|
/* Here is the parameter structure per a device. */
|
|
struct sbc_softc {
|
|
device_t dev; /* device */
|
|
|
|
int io_rid[IO_MAX]; /* io port rids */
|
|
struct resource *io[IO_MAX]; /* io port resources */
|
|
int io_alloced[IO_MAX]; /* io port alloc flag */
|
|
|
|
int irq_rid[IRQ_MAX]; /* irq rids */
|
|
struct resource *irq[IRQ_MAX]; /* irq resources */
|
|
int irq_alloced[IRQ_MAX]; /* irq alloc flag */
|
|
|
|
int drq_rid[DRQ_MAX]; /* drq rids */
|
|
struct resource *drq[DRQ_MAX]; /* drq resources */
|
|
int drq_alloced[DRQ_MAX]; /* drq alloc flag */
|
|
|
|
struct sbc_ihl ihl[IRQ_MAX];
|
|
|
|
void *ih;
|
|
|
|
u_int32_t bd_ver;
|
|
};
|
|
|
|
static int sbc_probe(device_t dev);
|
|
static int sbc_attach(device_t dev);
|
|
static void sbc_intr(void *p);
|
|
|
|
static struct resource *sbc_alloc_resource(device_t bus, device_t child, int type, int *rid,
|
|
u_long start, u_long end, u_long count, u_int flags);
|
|
static int sbc_release_resource(device_t bus, device_t child, int type, int rid,
|
|
struct resource *r);
|
|
static int sbc_setup_intr(device_t dev, device_t child, struct resource *irq,
|
|
int flags, driver_intr_t *intr, void *arg,
|
|
void **cookiep);
|
|
static int sbc_teardown_intr(device_t dev, device_t child, struct resource *irq,
|
|
void *cookie);
|
|
|
|
static int alloc_resource(struct sbc_softc *scp);
|
|
static int release_resource(struct sbc_softc *scp);
|
|
|
|
static devclass_t sbc_devclass;
|
|
|
|
static int io_range[3] = {0x10, 0x2, 0x4};
|
|
|
|
static int sb_rd(struct resource *io, int reg);
|
|
static void sb_wr(struct resource *io, int reg, u_int8_t val);
|
|
static int sb_dspready(struct resource *io);
|
|
static int sb_cmd(struct resource *io, u_char val);
|
|
static u_int sb_get_byte(struct resource *io);
|
|
static void sb_setmixer(struct resource *io, u_int port, u_int value);
|
|
|
|
static int
|
|
sb_rd(struct resource *io, int reg)
|
|
{
|
|
return bus_space_read_1(rman_get_bustag(io),
|
|
rman_get_bushandle(io),
|
|
reg);
|
|
}
|
|
|
|
static void
|
|
sb_wr(struct resource *io, int reg, u_int8_t val)
|
|
{
|
|
return bus_space_write_1(rman_get_bustag(io),
|
|
rman_get_bushandle(io),
|
|
reg, val);
|
|
}
|
|
|
|
static int
|
|
sb_dspready(struct resource *io)
|
|
{
|
|
return ((sb_rd(io, SBDSP_STATUS) & 0x80) == 0);
|
|
}
|
|
|
|
static int
|
|
sb_dspwr(struct resource *io, u_char val)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 1000; i++) {
|
|
if (sb_dspready(io)) {
|
|
sb_wr(io, SBDSP_CMD, val);
|
|
return 1;
|
|
}
|
|
if (i > 10) DELAY((i > 100)? 1000 : 10);
|
|
}
|
|
printf("sb_dspwr(0x%02x) timed out.\n", val);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
sb_cmd(struct resource *io, u_char val)
|
|
{
|
|
return sb_dspwr(io, val);
|
|
}
|
|
|
|
static void
|
|
sb_setmixer(struct resource *io, u_int port, u_int value)
|
|
{
|
|
u_long flags;
|
|
|
|
flags = spltty();
|
|
sb_wr(io, SB_MIX_ADDR, (u_char) (port & 0xff)); /* Select register */
|
|
DELAY(10);
|
|
sb_wr(io, SB_MIX_DATA, (u_char) (value & 0xff));
|
|
DELAY(10);
|
|
splx(flags);
|
|
}
|
|
|
|
static u_int
|
|
sb_get_byte(struct resource *io)
|
|
{
|
|
int i;
|
|
|
|
for (i = 1000; i > 0; i--) {
|
|
if (sb_rd(io, DSP_DATA_AVAIL) & 0x80)
|
|
return sb_rd(io, DSP_READ);
|
|
else
|
|
DELAY(20);
|
|
}
|
|
return 0xffff;
|
|
}
|
|
|
|
static int
|
|
sb_reset_dsp(struct resource *io)
|
|
{
|
|
sb_wr(io, SBDSP_RST, 3);
|
|
DELAY(100);
|
|
sb_wr(io, SBDSP_RST, 0);
|
|
return (sb_get_byte(io) == 0xAA)? 0 : ENXIO;
|
|
}
|
|
|
|
static int
|
|
sb_identify_board(struct resource *io)
|
|
{
|
|
int ver, essver, rev;
|
|
|
|
sb_cmd(io, DSP_CMD_GETVER); /* Get version */
|
|
ver = (sb_get_byte(io) << 8) | sb_get_byte(io);
|
|
if (ver < 0x100 || ver > 0x4ff) return 0;
|
|
if (ver == 0x0301) {
|
|
/* Try to detect ESS chips. */
|
|
sb_cmd(io, DSP_CMD_GETID); /* Return ident. bytes. */
|
|
essver = (sb_get_byte(io) << 8) | sb_get_byte(io);
|
|
rev = essver & 0x000f;
|
|
essver &= 0xfff0;
|
|
if (essver == 0x4880) ver |= 0x1000;
|
|
else if (essver == 0x6880) ver = 0x0500 | rev;
|
|
}
|
|
return ver;
|
|
}
|
|
|
|
static struct isa_pnp_id sbc_ids[] = {
|
|
{0x01008c0e, "Creative ViBRA16C"}, /* CTL0001 */
|
|
{0x31008c0e, "Creative SB16/SB32"}, /* CTL0031 */
|
|
{0x41008c0e, "Creative SB16/SB32"}, /* CTL0041 */
|
|
{0x42008c0e, "Creative SB AWE64"}, /* CTL0042 */
|
|
{0x43008c0e, "Creative ViBRA16X"}, /* CTL0043 */
|
|
{0x44008c0e, "Creative SB AWE64 Gold"}, /* CTL0044 */
|
|
{0x45008c0e, "Creative SB AWE64"}, /* CTL0045 */
|
|
|
|
{0x01000000, "Avance Logic ALS100+"}, /* @@@0001 - ViBRA16X clone */
|
|
{0x01100000, "Avance Asound 110"}, /* @@@1001 */
|
|
{0x01200000, "Avance Logic ALS120"}, /* @@@2001 - ViBRA16X clone */
|
|
|
|
{0x02017316, "ESS ES1688"}, /* ESS1688 */
|
|
{0x68187316, "ESS ES1868"}, /* ESS1868 */
|
|
{0x69187316, "ESS ES1869"}, /* ESS1869 */
|
|
{0xacb0110e, "ESS ES1869 (Compaq OEM)"}, /* CPQb0ac */
|
|
{0x78187316, "ESS ES1878"}, /* ESS1878 */
|
|
{0x79187316, "ESS ES1879"}, /* ESS1879 */
|
|
{0x88187316, "ESS ES1888"}, /* ESS1888 */
|
|
{0x07017316, "ESS ES1888 (DEC OEM)"}, /* ESS0107 */
|
|
{0}
|
|
};
|
|
|
|
static int
|
|
sbc_probe(device_t dev)
|
|
{
|
|
char *s = NULL;
|
|
u_int32_t lid, vid;
|
|
|
|
lid = isa_get_logicalid(dev);
|
|
vid = isa_get_vendorid(dev);
|
|
if (lid) {
|
|
if (lid == 0x01000000 && vid != 0x01009305) /* ALS0001 */
|
|
return ENXIO;
|
|
/* Check pnp ids */
|
|
return ISA_PNP_PROBE(device_get_parent(dev), dev, sbc_ids);
|
|
} else {
|
|
int rid = 0, ver;
|
|
struct resource *io;
|
|
|
|
io = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
|
|
0, ~0, 16, RF_ACTIVE);
|
|
if (!io) goto bad;
|
|
if (sb_reset_dsp(io)) goto bad2;
|
|
ver = sb_identify_board(io);
|
|
if (ver == 0) goto bad2;
|
|
switch ((ver & 0x00000f00) >> 8) {
|
|
case 1:
|
|
case 2:
|
|
s = "Soundblaster";
|
|
break;
|
|
|
|
case 3:
|
|
s = (ver & 0x0000f000)? "ESS 488" : "Soundblaster Pro";
|
|
break;
|
|
|
|
case 4:
|
|
s = "Soundblaster 16";
|
|
break;
|
|
|
|
case 5:
|
|
s = (ver & 0x00000008)? "ESS 688" : "ESS 1688";
|
|
break;
|
|
}
|
|
if (s) device_set_desc(dev, s);
|
|
bad2: bus_release_resource(dev, SYS_RES_IOPORT, rid, io);
|
|
bad: return s? 0 : ENXIO;
|
|
}
|
|
}
|
|
|
|
static int
|
|
sbc_attach(device_t dev)
|
|
{
|
|
char *err = NULL;
|
|
struct sbc_softc *scp;
|
|
struct sndcard_func *func;
|
|
device_t child;
|
|
u_int32_t logical_id = isa_get_logicalid(dev);
|
|
int flags = device_get_flags(dev);
|
|
int f, dh, dl, x, irq, i;
|
|
|
|
if (!logical_id && (flags & DV_F_DUAL_DMA)) {
|
|
bus_set_resource(dev, SYS_RES_DRQ, 1,
|
|
flags & DV_F_DRQ_MASK, 1);
|
|
}
|
|
|
|
scp = device_get_softc(dev);
|
|
bzero(scp, sizeof(*scp));
|
|
scp->dev = dev;
|
|
err = "alloc_resource";
|
|
if (alloc_resource(scp)) goto bad;
|
|
|
|
err = "sb_reset_dsp";
|
|
if (sb_reset_dsp(scp->io[0])) goto bad;
|
|
err = "sb_identify_board";
|
|
scp->bd_ver = sb_identify_board(scp->io[0]) & 0x00000fff;
|
|
if (scp->bd_ver == 0) goto bad;
|
|
f = 0;
|
|
if (logical_id == 0x01200000 && scp->bd_ver < 0x0400) scp->bd_ver = 0x0499;
|
|
switch ((scp->bd_ver & 0x0f00) >> 8) {
|
|
case 1: /* old sound blaster has nothing... */
|
|
break;
|
|
|
|
case 2:
|
|
f |= BD_F_DUP_MIDI;
|
|
if (scp->bd_ver > 0x200) f |= BD_F_MIX_CT1335;
|
|
break;
|
|
|
|
case 5:
|
|
f |= BD_F_ESS;
|
|
scp->bd_ver = 0x0301;
|
|
case 3:
|
|
f |= BD_F_DUP_MIDI | BD_F_MIX_CT1345;
|
|
break;
|
|
|
|
case 4:
|
|
f |= BD_F_SB16 | BD_F_MIX_CT1745;
|
|
if (scp->drq[0]) dl = rman_get_start(scp->drq[0]); else dl = -1;
|
|
if (scp->drq[1]) dh = rman_get_start(scp->drq[1]); else dh = dl;
|
|
if (!logical_id && (dh < dl)) {
|
|
struct resource *r;
|
|
r = scp->drq[0];
|
|
scp->drq[0] = scp->drq[1];
|
|
scp->drq[1] = r;
|
|
dl = rman_get_start(scp->drq[0]);
|
|
dh = rman_get_start(scp->drq[1]);
|
|
}
|
|
/* soft irq/dma configuration */
|
|
x = -1;
|
|
irq = rman_get_start(scp->irq[0]);
|
|
if (irq == 5) x = 2;
|
|
else if (irq == 7) x = 4;
|
|
else if (irq == 9) x = 1;
|
|
else if (irq == 10) x = 8;
|
|
if (x == -1) {
|
|
err = "bad irq (5/7/9/10 valid)";
|
|
goto bad;
|
|
}
|
|
else sb_setmixer(scp->io[0], IRQ_NR, x);
|
|
sb_setmixer(scp->io[0], DMA_NR, (1 << dh) | (1 << dl));
|
|
device_printf(dev, "setting card to irq %d, drq %d", irq, dl);
|
|
if (dl != dh) printf(", %d", dh);
|
|
printf("\n");
|
|
break;
|
|
}
|
|
|
|
switch (logical_id) {
|
|
case 0x43008c0e: /* CTL0043 */
|
|
case 0x01200000:
|
|
case 0x01000000:
|
|
f |= BD_F_SB16X;
|
|
break;
|
|
}
|
|
scp->bd_ver |= f << 16;
|
|
|
|
err = "setup_intr";
|
|
for (i = 0; i < IRQ_MAX; i++) {
|
|
if (bus_setup_intr(dev, scp->irq[i], INTR_TYPE_TTY, sbc_intr, &scp->ihl[i], &scp->ih))
|
|
goto bad;
|
|
}
|
|
|
|
/* PCM Audio */
|
|
func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT);
|
|
if (func == NULL) goto bad;
|
|
bzero(func, sizeof(*func));
|
|
func->func = SCF_PCM;
|
|
child = device_add_child(dev, "pcm", -1);
|
|
device_set_ivars(child, func);
|
|
|
|
#if notyet
|
|
/* Midi Interface */
|
|
func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT);
|
|
if (func == NULL) goto bad;
|
|
bzero(func, sizeof(*func));
|
|
func->func = SCF_MIDI;
|
|
child = device_add_child(dev, "midi", -1);
|
|
device_set_ivars(child, func);
|
|
|
|
/* OPL FM Synthesizer */
|
|
func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT);
|
|
if (func == NULL) goto bad;
|
|
bzero(func, sizeof(*func));
|
|
func->func = SCF_SYNTH;
|
|
child = device_add_child(dev, "midi", -1);
|
|
device_set_ivars(child, func);
|
|
#endif /* notyet */
|
|
|
|
/* probe/attach kids */
|
|
bus_generic_attach(dev);
|
|
|
|
return (0);
|
|
|
|
bad: if (err) device_printf(dev, "%s\n", err);
|
|
release_resource(scp);
|
|
return (ENXIO);
|
|
}
|
|
|
|
static void
|
|
sbc_intr(void *p)
|
|
{
|
|
struct sbc_ihl *ihl = p;
|
|
int i;
|
|
|
|
i = 0;
|
|
while (i < INTR_MAX) {
|
|
if (ihl->intr[i] != NULL) ihl->intr[i](ihl->intr_arg[i]);
|
|
i++;
|
|
}
|
|
}
|
|
|
|
static int
|
|
sbc_setup_intr(device_t dev, device_t child, struct resource *irq,
|
|
int flags, driver_intr_t *intr, void *arg,
|
|
void **cookiep)
|
|
{
|
|
struct sbc_softc *scp = device_get_softc(dev);
|
|
struct sbc_ihl *ihl = NULL;
|
|
int i;
|
|
|
|
i = 0;
|
|
while (i < IRQ_MAX) {
|
|
if (irq == scp->irq[i]) ihl = &scp->ihl[i];
|
|
i++;
|
|
}
|
|
if (ihl == NULL) return (EINVAL);
|
|
i = 0;
|
|
while (i < INTR_MAX) {
|
|
if (ihl->intr[i] == NULL) {
|
|
ihl->intr[i] = intr;
|
|
ihl->intr_arg[i] = arg;
|
|
*cookiep = &ihl->intr[i];
|
|
return 0;
|
|
} else i++;
|
|
}
|
|
return (EINVAL);
|
|
}
|
|
|
|
static int
|
|
sbc_teardown_intr(device_t dev, device_t child, struct resource *irq,
|
|
void *cookie)
|
|
{
|
|
struct sbc_softc *scp = device_get_softc(dev);
|
|
struct sbc_ihl *ihl = NULL;
|
|
int i;
|
|
|
|
i = 0;
|
|
while (i < IRQ_MAX) {
|
|
if (irq == scp->irq[i]) ihl = &scp->ihl[i];
|
|
i++;
|
|
}
|
|
if (ihl == NULL) return (EINVAL);
|
|
i = 0;
|
|
while (i < INTR_MAX) {
|
|
if (cookie == &ihl->intr[i]) {
|
|
ihl->intr[i] = NULL;
|
|
ihl->intr_arg[i] = NULL;
|
|
return 0;
|
|
} else i++;
|
|
}
|
|
return (EINVAL);
|
|
}
|
|
|
|
static struct resource *
|
|
sbc_alloc_resource(device_t bus, device_t child, int type, int *rid,
|
|
u_long start, u_long end, u_long count, u_int flags)
|
|
{
|
|
struct sbc_softc *scp;
|
|
int *alloced, rid_max, alloced_max;
|
|
struct resource **res;
|
|
|
|
scp = device_get_softc(bus);
|
|
switch (type) {
|
|
case SYS_RES_IOPORT:
|
|
alloced = scp->io_alloced;
|
|
res = scp->io;
|
|
rid_max = IO_MAX - 1;
|
|
alloced_max = 1;
|
|
break;
|
|
case SYS_RES_DRQ:
|
|
alloced = scp->drq_alloced;
|
|
res = scp->drq;
|
|
rid_max = DRQ_MAX - 1;
|
|
alloced_max = 1;
|
|
break;
|
|
case SYS_RES_IRQ:
|
|
alloced = scp->irq_alloced;
|
|
res = scp->irq;
|
|
rid_max = IRQ_MAX - 1;
|
|
alloced_max = INTR_MAX; /* pcm and mpu may share the irq. */
|
|
break;
|
|
default:
|
|
return (NULL);
|
|
}
|
|
|
|
if (*rid > rid_max || alloced[*rid] == alloced_max)
|
|
return (NULL);
|
|
|
|
alloced[*rid]++;
|
|
return (res[*rid]);
|
|
}
|
|
|
|
static int
|
|
sbc_release_resource(device_t bus, device_t child, int type, int rid,
|
|
struct resource *r)
|
|
{
|
|
struct sbc_softc *scp;
|
|
int *alloced, rid_max;
|
|
|
|
scp = device_get_softc(bus);
|
|
switch (type) {
|
|
case SYS_RES_IOPORT:
|
|
alloced = scp->io_alloced;
|
|
rid_max = IO_MAX - 1;
|
|
break;
|
|
case SYS_RES_DRQ:
|
|
alloced = scp->drq_alloced;
|
|
rid_max = DRQ_MAX - 1;
|
|
break;
|
|
case SYS_RES_IRQ:
|
|
alloced = scp->irq_alloced;
|
|
rid_max = IRQ_MAX - 1;
|
|
break;
|
|
default:
|
|
return (1);
|
|
}
|
|
|
|
if (rid > rid_max || alloced[rid] == 0)
|
|
return (1);
|
|
|
|
alloced[rid]--;
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
sbc_read_ivar(device_t bus, device_t dev, int index, uintptr_t * result)
|
|
{
|
|
struct sbc_softc *scp = device_get_softc(bus);
|
|
struct sndcard_func *func = device_get_ivars(dev);
|
|
|
|
switch (index) {
|
|
case 0:
|
|
*result = func->func;
|
|
break;
|
|
|
|
case 1:
|
|
*result = scp->bd_ver;
|
|
break;
|
|
|
|
default:
|
|
return ENOENT;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
sbc_write_ivar(device_t bus, device_t dev,
|
|
int index, uintptr_t value)
|
|
{
|
|
switch (index) {
|
|
case 0:
|
|
case 1:
|
|
return EINVAL;
|
|
|
|
default:
|
|
return (ENOENT);
|
|
}
|
|
}
|
|
|
|
static int
|
|
alloc_resource(struct sbc_softc *scp)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0 ; i < IO_MAX ; i++) {
|
|
if (scp->io[i] == NULL) {
|
|
scp->io_rid[i] = i;
|
|
scp->io[i] = bus_alloc_resource(scp->dev, SYS_RES_IOPORT, &scp->io_rid[i],
|
|
0, ~0, io_range[i], RF_ACTIVE);
|
|
if (i == 0 && scp->io[i] == NULL)
|
|
return (1);
|
|
scp->io_alloced[i] = 0;
|
|
}
|
|
}
|
|
for (i = 0 ; i < DRQ_MAX ; i++) {
|
|
if (scp->drq[i] == NULL) {
|
|
scp->drq_rid[i] = i;
|
|
scp->drq[i] = bus_alloc_resource(scp->dev, SYS_RES_DRQ, &scp->drq_rid[i],
|
|
0, ~0, 1, RF_ACTIVE);
|
|
if (i == 0 && scp->drq[i] == NULL)
|
|
return (1);
|
|
scp->drq_alloced[i] = 0;
|
|
}
|
|
}
|
|
for (i = 0 ; i < IRQ_MAX ; i++) {
|
|
if (scp->irq[i] == NULL) {
|
|
scp->irq_rid[i] = i;
|
|
scp->irq[i] = bus_alloc_resource(scp->dev, SYS_RES_IRQ, &scp->irq_rid[i],
|
|
0, ~0, 1, RF_ACTIVE);
|
|
if (i == 0 && scp->irq[i] == NULL)
|
|
return (1);
|
|
scp->irq_alloced[i] = 0;
|
|
}
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
release_resource(struct sbc_softc *scp)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0 ; i < IO_MAX ; i++) {
|
|
if (scp->io[i] != NULL) {
|
|
bus_release_resource(scp->dev, SYS_RES_IOPORT, scp->io_rid[i], scp->io[i]);
|
|
scp->io[i] = NULL;
|
|
}
|
|
}
|
|
for (i = 0 ; i < DRQ_MAX ; i++) {
|
|
if (scp->drq[i] != NULL) {
|
|
bus_release_resource(scp->dev, SYS_RES_DRQ, scp->drq_rid[i], scp->drq[i]);
|
|
scp->drq[i] = NULL;
|
|
}
|
|
}
|
|
for (i = 0 ; i < IRQ_MAX ; i++) {
|
|
if (scp->irq[i] != NULL) {
|
|
bus_release_resource(scp->dev, SYS_RES_IRQ, scp->irq_rid[i], scp->irq[i]);
|
|
scp->irq[i] = NULL;
|
|
}
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static device_method_t sbc_methods[] = {
|
|
/* Device interface */
|
|
DEVMETHOD(device_probe, sbc_probe),
|
|
DEVMETHOD(device_attach, sbc_attach),
|
|
DEVMETHOD(device_detach, bus_generic_detach),
|
|
DEVMETHOD(device_shutdown, bus_generic_shutdown),
|
|
DEVMETHOD(device_suspend, bus_generic_suspend),
|
|
DEVMETHOD(device_resume, bus_generic_resume),
|
|
|
|
/* Bus interface */
|
|
DEVMETHOD(bus_read_ivar, sbc_read_ivar),
|
|
DEVMETHOD(bus_write_ivar, sbc_write_ivar),
|
|
DEVMETHOD(bus_print_child, bus_generic_print_child),
|
|
DEVMETHOD(bus_alloc_resource, sbc_alloc_resource),
|
|
DEVMETHOD(bus_release_resource, sbc_release_resource),
|
|
DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
|
|
DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
|
|
DEVMETHOD(bus_setup_intr, sbc_setup_intr),
|
|
DEVMETHOD(bus_teardown_intr, sbc_teardown_intr),
|
|
|
|
{ 0, 0 }
|
|
};
|
|
|
|
static driver_t sbc_driver = {
|
|
"sbc",
|
|
sbc_methods,
|
|
sizeof(struct sbc_softc),
|
|
};
|
|
|
|
/* sbc can be attached to an isa bus. */
|
|
DRIVER_MODULE(sbc, isa, sbc_driver, sbc_devclass, 0, 0);
|