34#ifdef HAVE_KERNEL_OPTION_HEADERS
43#include <isa/isavar.h>
49#define SB_DEFAULT_BUFSZ 4096
130 return bus_space_read_1(rman_get_bustag(port), rman_get_bushandle(port), off);
136 bus_space_write_1(rman_get_bustag(port), rman_get_bushandle(port), off,
data);
162 for (i = 0; i < 1000; i++) {
167 if (i > 10) DELAY((i > 100)? 1000 : 10);
169 printf(
"sb_dspwr(0x%02x) timed out.\n",
val);
177 printf(
"sb_cmd: %x\n",
val);
186 printf(
"sb_cmd1: %x, %x\n", cmd,
val);
197 printf(
"sb_cmd2: %x, %x\n", cmd,
val);
238 for (i = 1000; i > 0; i--) {
254 DEB(printf(
"sb_reset_dsp 0x%lx failed\n",
266 bus_teardown_intr(
dev, sb->
irq, sb->
ih);
267 bus_release_resource(
dev, SYS_RES_IRQ, 0, sb->
irq);
271 isa_dma_release(rman_get_start(sb->
drq));
272 bus_release_resource(
dev, SYS_RES_DRQ, 0, sb->
drq);
276 bus_release_resource(
dev, SYS_RES_IOPORT, 0, sb->
io_base);
293 sb->
io_base = bus_alloc_resource_any(
dev, SYS_RES_IOPORT,
297 sb->
irq = bus_alloc_resource_any(
dev, SYS_RES_IRQ,
301 sb->
drq = bus_alloc_resource_any(
dev, SYS_RES_DRQ,
305 isa_dma_acquire(rman_get_start(sb->
drq));
306 isa_dmainit(rman_get_start(sb->
drq), sb->
bufsize);
319 mix_setdevs(
m, SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_LINE |
320 SOUND_MASK_MIC | SOUND_MASK_CD | SOUND_MASK_VOLUME);
338 case SOUND_MIXER_PCM:
342 case SOUND_MIXER_MIC:
347 case SOUND_MIXER_VOLUME:
351 case SOUND_MIXER_SYNTH:
359 case SOUND_MIXER_LINE:
385 if (
src == SOUND_MASK_LINE)
387 else if (
src == SOUND_MASK_CD)
390 src = SOUND_MASK_MIC;
413 mix_setdevs(
m, SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_CD | SOUND_MASK_VOLUME);
430 case SOUND_MIXER_VOLUME:
434 case SOUND_MIXER_SYNTH:
442 case SOUND_MIXER_PCM:
507 if (sb->
bd_id >= 0x300) {
508 thresh =
stereo? 11025 : 23000;
510 }
else if (sb->
bd_id > 0x200) {
511 thresh = play? 23000 : 13000;
512 max = play? 44100 : 15000;
515 max = play? 23000 : 13000;
555 i = play? 0x90 : 0x98;
557 i = play? 0x1c : 0x2c;
694 uintptr_t
func, ver,
r, f;
697 r = BUS_READ_IVAR(device_get_parent(
dev),
dev, 0, &
func);
701 r = BUS_READ_IVAR(device_get_parent(
dev),
dev, 1, &ver);
702 f = (ver & 0xffff0000) >> 16;
704 if ((f &
BD_F_ESS) || (ver >= 0x400))
707 snprintf(
buf,
sizeof buf,
"SB DSP %d.%02d", (
int) ver >> 8, (
int) ver & 0xff);
709 device_set_desc_copy(
dev,
buf);
721 gone_in_dev(
dev, 14,
"ISA sound driver");
722 sb = malloc(
sizeof(*sb), M_DEVBUF, M_WAITOK | M_ZERO);
724 BUS_READ_IVAR(device_get_parent(
dev),
dev, 1, &ver);
725 sb->
bd_id = ver & 0x0000ffff;
726 sb->
bd_flags = (ver & 0xffff0000) >> 16;
733 if (
mixer_init(
dev, (sb->
bd_id < 0x300)? &sbmix_mixer_class : &sbpromix_mixer_class, sb))
740 if (bus_dma_tag_create(bus_get_dma_tag(
dev), 2,
742 BUS_SPACE_MAXADDR_24BIT,
749 device_printf(
dev,
"unable to create dma tag\n");
754 rman_get_start(sb->
io_base), rman_get_start(sb->
irq),
int sndbuf_alloc(struct snd_dbuf *b, bus_dma_tag_t dmatag, int dmaflags, unsigned int size)
unsigned int sndbuf_runsz(struct snd_dbuf *b)
void chn_intr(struct pcm_channel *c)
#define PCMTRIG_COMMON(x)
struct pcmchan_matrix * m
static int mixer_setrecsrc(struct snd_mixer *mixer, u_int32_t src)
int mixer_init(device_t dev, kobj_class_t cls, void *devinfo)
static int mixer_set(struct snd_mixer *m, u_int dev, u_int32_t muted, u_int lev)
void mix_setdevs(struct snd_mixer *m, u_int32_t v)
void * mix_getdevinfo(struct snd_mixer *m)
void mix_setrecdevs(struct snd_mixer *m, u_int32_t v)
Record mask of available recording devices.
static int sb_reset_dsp(struct sb_info *sb)
MODULE_DEPEND(snd_sb8, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER)
static int sb_start(struct sb_chinfo *ch)
static u_int32_t sbchan_getptr(kobj_t obj, void *data)
MIXER_DECLARE(sbpromix_mixer)
static struct pcmchan_caps sb201_playcaps
static u_int32_t sbpro_fmt[]
static int sbpromix_init(struct snd_mixer *m)
static void sb_intr(void *arg)
static kobj_method_t sbmix_mixer_methods[]
static void sb_lock(struct sb_info *sb)
static device_method_t sb_methods[]
static int sb_speed(struct sb_chinfo *ch)
static u_int32_t sb_fmt[]
static int port_rd(struct resource *port, int off)
static u_int32_t sbmix_setrecsrc(struct snd_mixer *m, u_int32_t src)
static int sb_detach(device_t dev)
static u_int sb_get_byte(struct sb_info *sb)
static driver_t sb_driver
static kobj_method_t sbpromix_mixer_methods[]
static void sb_setmixer(struct sb_info *sb, u_int port, u_int value)
static void sb_wr(struct sb_info *sb, int reg, u_int8_t val)
static int sb_cmd2(struct sb_info *sb, u_char cmd, int val)
static struct pcmchan_caps sbpro_playcaps
static int sbchan_trigger(kobj_t obj, void *data, int go)
SND_DECLARE_FILE("$FreeBSD$")
static struct pcmchan_caps sb201_reccaps
static int sbchan_setformat(kobj_t obj, void *data, u_int32_t format)
static struct pcmchan_caps * sbchan_getcaps(kobj_t obj, void *data)
static void port_wr(struct resource *port, int off, u_int8_t data)
MODULE_VERSION(snd_sb8, 1)
static u_int32_t sbpromix_setrecsrc(struct snd_mixer *m, u_int32_t src)
static int sbpromix_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
static void * sbchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir)
static struct pcmchan_caps sb200_playcaps
static int sb_getmixer(struct sb_info *sb, u_int port)
static u_int32_t sbchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
static int sb_cmd(struct sb_info *sb, u_char val)
static int sb_probe(device_t dev)
static u_int32_t sbchan_setspeed(kobj_t obj, void *data, u_int32_t speed)
static int sbmix_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
static int sb_alloc_resources(struct sb_info *sb, device_t dev)
static kobj_method_t sbchan_methods[]
static int sb_stop(struct sb_chinfo *ch)
static struct pcmchan_caps sb200_reccaps
DRIVER_MODULE(snd_sb8, sbc, sb_driver, pcm_devclass, 0, 0)
static struct pcmchan_caps sbpro_reccaps
static int sb_rd(struct sb_info *sb, int reg)
static void sb_release_resources(struct sb_info *sb, device_t dev)
static int sb_cmd1(struct sb_info *sb, u_char cmd, int val)
static int sbmix_init(struct snd_mixer *m)
static void sb_unlock(struct sb_info *sb)
static int sb_dspwr(struct sb_info *sb, u_char val)
static int sb_dspready(struct sb_info *sb)
static int sb_attach(device_t dev)
void sbc_unlock(struct sbc_softc *)
void sbc_lock(struct sbc_softc *)
#define DSP_CMD_DMAEXIT_8
int sndbuf_dmasetup(struct snd_dbuf *b, struct resource *drq)
void sndbuf_dma(struct snd_dbuf *b, int go)
int sndbuf_dmaptr(struct snd_dbuf *b)
void pcm_setflags(device_t dev, uint32_t val)
void * pcm_getdevinfo(device_t dev)
uint32_t pcm_getflags(device_t dev)
int pcm_setstatus(device_t dev, char *str)
int pcm_addchan(device_t dev, int dir, kobj_class_t cls, void *devinfo)
int pcm_unregister(device_t dev)
int pcm_register(device_t dev, void *devinfo, int numplay, int numrec)
int snd_setup_intr(device_t dev, struct resource *res, int flags, driver_intr_t hand, void *param, void **cookiep)
unsigned int pcm_getbuffersize(device_t dev, unsigned int minbufsz, unsigned int deflt, unsigned int maxbufsz)
#define SND_FORMAT(f, c, e)
struct pcm_channel * channel
struct resource * io_base
bus_dma_tag_t parent_dmat