On Wed, Oct 24, 2007 at 12:55:39AM +0200, Jan Stary wrote:
quoted text
> > > What is the relation of OpenBSD's audio drivers to the OSS project?
> > > What, if anything, does opensourcing (GPL, I know) their code mean for
> > > our audio drivers? In particular, does that mean (future) support for
> > > the high-end soundcards such as M-Audio Delta?
> > 
> > There's work in progress on adding support for Delta cards (1010,
> > 1010LT, 66, 44), and required features to make them usable (32bit
> > encodings, 12 channel capture, higher sample rate, etc...)
> 
> Where can I get in touch with this work and possibly test it?
> Is anything commited -> available in curent?
> 

it's not in cvs yet. Below's a diff you can test. It probably only
works on delta-1010 and delta-1010LT cards and it's enabled on i386
only. The diff adds support for 32bit samples and 10 channels.
Neither capture nor mixer are implemented yet. Feel free to contact
me privately if you have questions on that.

Anyway if you have any delta card, i'm interested in seeing your
card's eeprom contents (in dmesg), the kernel should be compiled on
i386 with these options:

	option  ENVY_DEBUG

	envy* at pci?
	audio* at envy?

Also, let me know if you notice regression with other audio
drivers.

cheers,

-- Alexandre

Index: arch/i386/conf/GENERIC
===================================================================
RCS file: /cvs/src/sys/arch/i386/conf/GENERIC,v
retrieving revision 1.583
diff -u -p -r1.583 GENERIC
--- arch/i386/conf/GENERIC	14 Oct 2007 17:39:46 -0000	1.583
+++ arch/i386/conf/GENERIC	24 Oct 2007 05:54:38 -0000
@@ -628,6 +628,7 @@ maestro* at pci?			# ESS Maestro PCI
 esa*	at pci?				# ESS Maestro3 PCI
 yds*	at pci? flags 0x0000		# Yamaha YMF Audio
 emu*	at pci?				# SB Live!
+#envy*	at pci?				# VIA Envy24 (aka ICE1712)
 sb0	at isa? port 0x220 irq 5 drq 1	# SoundBlaster
 sb*	at isapnp?
 ess*	at isapnp?			# ESS Tech ES188[78], ES888
Index: dev/pci/envy.c
===================================================================
RCS file: dev/pci/envy.c
diff -N dev/pci/envy.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ dev/pci/envy.c	24 Oct 2007 05:54:38 -0000
@@ -0,0 +1,699 @@
+/*
+ * Copyright (c) 2007 Alexandre Ratchov <alex@caoua.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/device.h>
+#include <sys/ioctl.h>
+#include <sys/audioio.h>
+#include <sys/malloc.h>
+#include <dev/pci/pcivar.h>
+#include <dev/pci/pcidevs.h>
+#include <dev/pci/envyvar.h>
+#include <dev/pci/envyreg.h>
+#include <dev/audio_if.h>
+#include <machine/bus.h>
+
+#ifdef ENVY_DEBUG
+#define DPRINTF(...) do { if (envydebug) printf(__VA_ARGS__); } while(0)
+#define DPRINTFN(n, ...) do { if (envydebug > (n)) printf(__VA_ARGS__); } while(0)
+int envydebug = 1;
+#else
+#define DPRINTF(...) do {} while(0)
+#define DPRINTFN(n, ...) do {} while(0)
+#endif
+#define DEVNAME(sc) ((sc)->dev.dv_xname)
+
+int  envymatch(struct device *, void *, void *);
+void envyattach(struct device *, struct device *, void *);
+int  envydetach(struct device *, int);
+
+int  envy_ccs_read(struct envy_softc *sc, int reg);
+void envy_ccs_write(struct envy_softc *sc, int reg, int val);
+int  envy_cci_read(struct envy_softc *sc, int index);
+void envy_cci_write(struct envy_softc *sc, int index, int data);
+void envy_i2c_wait(struct envy_softc *sc);
+int  envy_i2c_read(struct envy_softc *sc, int dev, int addr);
+void envy_i2c_write(struct envy_softc *sc, int dev, int addr, int data);
+int  envy_gpio_read(struct envy_softc *sc);
+void envy_gpio_write(struct envy_softc *sc, int data);
+void envy_eeprom_read(struct envy_softc *sc, unsigned char *);
+void envy_reset(struct envy_softc *sc);
+void envy_ak_write(struct envy_softc *sc, int dev, int addr, int data);
+int  envy_intr(void *);
+
+int envy_open(void *, int);
+void envy_close(void *);
+void *envy_allocm(void *, int, size_t, int, int);
+void envy_freem(void *, void *, int);
+int envy_query_encoding(void *, struct audio_encoding *);
+int envy_set_params(void *, int, int, struct audio_params *, 
+    struct audio_params *);
+int envy_round_blocksize(void *, int);
+size_t envy_round_buffersize(void *, int, size_t);
+int envy_trigger_output(void *, void *, void *, int,
+    void (*)(void *), void *, struct audio_params *);
+int envy_trigger_input(void *, void *, void *, int,
+    void (*)(void *), void *, struct audio_params *);
+int envy_halt_output(void *);
+int envy_halt_input(void *);
+int envy_getdev(void *, struct audio_device *);
+int envy_query_devinfo(void *, struct mixer_devinfo *);
+int envy_get_port(void *, struct mixer_ctrl *);
+int envy_set_port(void *, struct mixer_ctrl *);
+int envy_get_props(void *);
+
+struct cfattach envy_ca = {
+	sizeof(struct envy_softc), envymatch, envyattach, envydetach
+};
+
+struct cfdriver envy_cd = {
+	NULL, "envy", DV_DULL
+};
+
+struct audio_hw_if envy_hw_if = {
+	envy_open,		/* open */
+	envy_close,		/* close */
+	NULL,			/* drain */
+	envy_query_encoding,	/* query_encoding */
+	envy_set_params,	/* set_params */
+	envy_round_blocksize,	/* round_blocksize */
+	NULL,			/* commit_settings */
+	NULL,			/* init_output */
+	NULL,			/* init_input */
+	NULL,			/* start_output */
+	NULL,			/* start_input */
+	envy_halt_output,	/* halt_output */
+	envy_halt_input,	/* halt_input */
+	NULL,			/* speaker_ctl */
+	envy_getdev,		/* getdev */
+	NULL,			/* setfd */
+	envy_set_port,		/* set_port */
+	envy_get_port,		/* get_port */
+	envy_query_devinfo,	/* query_devinfo */
+	envy_allocm,		/* malloc */
+	envy_freem,		/* free */
+	envy_round_buffersize,	/* round_buffersize */
+	NULL,			/* mappage */
+	envy_get_props,		/* get_props */
+	envy_trigger_output,	/* trigger_output */
+	envy_trigger_input,	/* trigger_input */
+};
+
+/*
+ * correspondence between rates (in frames per second)
+ * and values of rate register
+ */
+struct {
+	int rate, reg;
+} envy_rates[] = {
+	{ 8000, 0x6}, { 9600, 0x3}, {11025, 0xa}, {12000, 2}, {16000, 5},
+	{22050, 0x9}, {24000, 0x1}, {32000, 0x4}, {44100, 8}, {48000, 0},
+	{64000, 0xf}, {88200, 0xb}, {96000, 0x7}, {-1, -1}
+};
+
+int
+envy_ccs_read(struct envy_softc *sc, int reg) 
+{
+	return bus_space_read_1((sc)->ctl_iot, (sc)->ctl_ioh, reg);
+}
+
+void
+envy_ccs_write(struct envy_softc *sc, int reg, int val)
+{
+	bus_space_write_1((sc)->ctl_iot, (sc)->ctl_ioh, reg, val);
+}
+
+int
+envy_cci_read(struct envy_softc *sc, int index)
+{
+	int val;
+	envy_ccs_write(sc, ENVY_CCI_INDEX, index);
+	val = envy_ccs_read(sc, ENVY_CCI_DATA);
+	return val;
+}
+
+void
+envy_cci_write(struct envy_softc *sc, int index, int data)
+{
+	envy_ccs_write(sc, ENVY_CCI_INDEX, index);
+	envy_ccs_write(sc, ENVY_CCI_DATA, data);
+}
+
+void
+envy_i2c_wait(struct envy_softc *sc)
+{
+	int timeout = 50, st;
+
+        for (;;) {
+		st = envy_ccs_read(sc, ENVY_I2C_CTL);
+		if (!(st & ENVY_I2C_CTL_BUSY)) 
+			break;
+		if (timeout == 0) {
+			printf("%s: i2c busy timeout\n", DEVNAME(sc));
+			break;
+		}
+		delay(50);
+		timeout--;
+	}
+}
+
+int
+envy_i2c_read(struct envy_softc *sc, int dev, int addr)
+{
+	envy_i2c_wait(sc);
+	envy_ccs_write(sc, ENVY_I2C_ADDR, addr);
+	envy_i2c_wait(sc);
+	envy_ccs_write(sc, ENVY_I2C_DEV, dev << 1);
+	envy_i2c_wait(sc);
+	return envy_ccs_read(sc, ENVY_I2C_DATA);
+}
+
+void
+envy_i2c_write(struct envy_softc *sc, int dev, int addr, int data)
+{
+	if (dev == 0x50) {
+		printf("%s: writing on eeprom is evil...\n", DEVNAME(sc));
+		return;
+	}
+	envy_i2c_wait(sc);
+	envy_ccs_write(sc, ENVY_I2C_ADDR, addr);
+	envy_i2c_wait(sc);
+	envy_ccs_write(sc, ENVY_I2C_DATA, data);
+	envy_i2c_wait(sc);
+	envy_ccs_write(sc, ENVY_I2C_DEV, (dev << 1) | 1);
+}
+
+void
+envy_eeprom_read(struct envy_softc *sc, unsigned char *eeprom)
+{
+	int i;
+
+	for (i = 0; i < ENVY_EEPROM_MAXSZ; i++) {
+		eeprom[i] = envy_i2c_read(sc, ENVY_I2C_DEV_EEPROM, i);
+	}
+	printf("%s: eeprom[] = (", DEVNAME(sc));
+	for (i = 0; i < ENVY_EEPROM_MAXSZ; i++) {
+		printf(" %02x", (unsigned)eeprom[i]);
+	}
+	printf(" )\n");
+}
+
+void
+envy_ak_write(struct envy_softc *sc, int dev, int addr, int data)
+{
+	int bits, i, reg;
+
+	bits  = 0xa000 | (addr << 8) | data;
+
+	reg = envy_cci_read(sc, ENVY_GPIO_DATA);
+	reg &= ~ENVY_GPIO_CSMASK;
+	reg |=  ENVY_GPIO_CS(dev);
+	envy_cci_write(sc, ENVY_GPIO_DATA, reg);
+	delay(1);
+
+	for (i = 0; i < 16; i++) {
+		reg &= ~(ENVY_GPIO_CLK | ENVY_GPIO_DOUT);
+		reg |= (bits & 0x8000) ? ENVY_GPIO_DOUT : 0;
+		envy_cci_write(sc, ENVY_GPIO_DATA, reg);
+		delay(1);
+
+		reg |= ENVY_GPIO_CLK;
+		envy_cci_write(sc, ENVY_GPIO_DATA, reg);
+		delay(1);
+		bits <<= 1;
+	}
+
+	reg |= ENVY_GPIO_CSMASK;
+	envy_cci_write(sc, ENVY_GPIO_DATA, reg);
+	delay(1);
+}
+
+void
+envy_reset(struct envy_softc *sc)
+{
+	char eeprom[ENVY_EEPROM_MAXSZ];
+	int dev;
+
+	/*
+	 * full reset
+	 */
+	envy_ccs_write(sc, ENVY_CTL, ENVY_CTL_RESET | ENVY_CTL_NATIVE);
+	delay(200);
+	envy_ccs_write(sc, ENVY_CTL, ENVY_CTL_NATIVE);
+	delay(200);
+
+	/*
+	 * read config from eprom and write it to registers
+	 */
+	envy_eeprom_read(sc, eeprom);
+	pci_conf_write(sc->pci_pc, sc->pci_tag, ENVY_CONF, 
+	    eeprom[ENVY_EEPROM_CONF] |
+	    (eeprom[ENVY_EEPROM_ACLINK] << 8) |
+	    (eeprom[ENVY_EEPROM_I2S] << 16) |
+	    (eeprom[ENVY_EEPROM_SPDIF] << 24));
+	envy_cci_write(sc, ENVY_GPIO_MASK, eeprom[ENVY_EEPROM_GPIOMASK]);
+	envy_cci_write(sc, ENVY_GPIO_DIR,  eeprom[ENVY_EEPROM_GPIODIR]);
+	envy_cci_write(sc, ENVY_GPIO_DATA, eeprom[ENVY_EEPROM_GPIOST]);
+
+	DPRINTF("%s: gpio_mask = %02x\n", DEVNAME(sc), 
+		envy_cci_read(sc, ENVY_GPIO_MASK));
+	DPRINTF("%s: gpio_dir = %02x\n", DEVNAME(sc), 
+		envy_cci_read(sc, ENVY_GPIO_DIR));
+	DPRINTF("%s: gpio_state = %02x\n", DEVNAME(sc), 
+		envy_cci_read(sc, ENVY_GPIO_DATA));
+	
+	/*
+	 * reset ak4524 codecs
+	 */
+	for (dev = 0; dev < 4; dev++) {
+		envy_ak_write(sc, dev, 0x01, 0x00);	/* reset */
+		delay(300);
+		envy_ak_write(sc, dev, 0x01, 0x03);	/* normal operation */
+		envy_ak_write(sc, dev, 0x02, 0x60);	/* data format: i2s data */
+	}
+
+	/*
+	 * clear and unmask interrupts
+	 */ 
+	envy_ccs_write(sc, ENVY_CCS_ISTAT, 0xff);
+	envy_ccs_write(sc, ENVY_CCS_IMASK, 0x00);
+}
+
+int
+envy_intr(void *self)
+{
+	struct envy_softc *sc = (struct envy_softc *)self;
+	int st;
+
+	st = bus_space_read_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_INTR);
+	if (!(st & (ENVY_MT_INTR_PACK | ENVY_MT_INTR_RACK))) {
+		return 0;
+	}
+	if (st & ENVY_MT_INTR_PACK) {
+		sc->ointr(sc->oarg);
+		st = ENVY_MT_INTR_PACK;
+		bus_space_write_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_INTR, st);
+	}
+	if (st & ENVY_MT_INTR_RACK) {
+		sc->iintr(sc->iarg);
+		st = ENVY_MT_INTR_RACK;
+		bus_space_write_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_INTR, st);
+	}
+	return 1;
+}
+
+int
+envymatch(struct device *parent, void *match, void *aux) {
+	struct pci_attach_args *pa = (struct pci_attach_args *)aux;
+
+	if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_ICENSEMBLE &&
+	    PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_ICENSEMBLE_ICE1712) {
+		return 1;
+	}
+	return 0;
+}
+
+void
+envyattach(struct device *parent, struct device *self, void *aux) {
+	struct envy_softc *sc = (struct envy_softc *)self;
+	struct pci_attach_args *pa = (struct pci_attach_args *)aux;
+	pci_intr_handle_t ih;
+	const char *intrstr;
+
+	sc->pci_tag = pa->pa_tag;
+	sc->pci_pc = pa->pa_pc;
+	sc->pci_dmat = pa->pa_dmat;
+	sc->pci_ih = NULL;
+	sc->ibuf.addr = sc->obuf.addr = NULL;
+	sc->ctl_iosz = 0;
+	sc->mt_iosz = 0;
+
+	if (pci_mapreg_map(pa, ENVY_CTL_BAR, PCI_MAPREG_TYPE_IO, 0, 
+			   &sc->ctl_iot, &sc->ctl_ioh, NULL, &sc->ctl_iosz, 0)) {
+		printf(": failed to map ctl i/o space\n");
+		sc->ctl_iosz = 0;
+		return;
+        }
+	if (pci_mapreg_map(pa, ENVY_MT_BAR, PCI_MAPREG_TYPE_IO, 0, 
+			   &sc->mt_iot, &sc->mt_ioh, NULL, &sc->mt_iosz, 0)) {
+		printf(": failed to map mt i/o space\n");
+		sc->mt_iosz = 0;
+		return;
+        }
+	if (pci_intr_map(pa, &ih)) {
+		printf(": can't map interrupt\n");
+	}
+	intrstr = pci_intr_string(sc->pci_pc, ih);
+	sc->pci_ih = pci_intr_establish(sc->pci_pc, ih, IPL_AUDIO,
+	    envy_intr, sc, sc->dev.dv_xname);
+	if (sc->pci_ih == NULL) {
+		printf(": can't establish interrupt");
+		if (intrstr)
+			printf(" at %s", intrstr);
+		printf("\n");
+		return;
+	}
+	printf(": %s\n", intrstr);
+	envy_reset(sc);
+	sc->audio = audio_attach_mi(&envy_hw_if, sc, &sc->dev);
+}
+
+int
+envydetach(struct device *self, int flags)
+{
+	struct envy_softc *sc = (struct envy_softc *)self;
+
+	if (sc->pci_ih != NULL) {
+		pci_intr_disestablish(sc->pci_pc, sc->pci_ih);
+		sc->pci_ih = NULL;
+	}
+	if (sc->ctl_iosz) {
+		bus_space_unmap(sc->ctl_iot, sc->ctl_ioh, sc->ctl_iosz);
+	}
+	if (sc->mt_iosz) {
+		bus_space_unmap(sc->ctl_iot, sc->mt_ioh, sc->mt_iosz);
+	}
+	return 0;
+}
+
+int
+envy_open(void *self, int flags)
+{
+	return 0;
+}
+
+void
+envy_close(void *self)
+{
+}
+
+void *
+envy_allocm(void *self, int dir, size_t size, int type, int flags)
+{
+	struct envy_softc *sc = (struct envy_softc *)self;
+	int err, rsegs, basereg, wait;
+	struct envy_buf *buf;
+
+	if (dir == AUMODE_RECORD) {
+		buf = &sc->ibuf;
+		basereg = ENVY_MT_RADDR;
+	} else {
+		buf = &sc->obuf;
+		basereg = ENVY_MT_PADDR;
+	}
+	if (buf->addr != NULL) {
+		DPRINTF("%s: multiple alloc, dir = %d\n", DEVNAME(sc), dir);
+		return NULL;
+	}
+	buf->size = size;
+	wait = (flags & M_NOWAIT) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK;
+
+#define ENVY_ALIGN	4
+#define ENVY_BOUNDARY	0
+
+	err = bus_dmamem_alloc(sc->pci_dmat, buf->size, ENVY_ALIGN, 
+	    ENVY_BOUNDARY, &buf->seg, 1, &rsegs, wait);
+	if (err) {
+		DPRINTF("%s: dmamem_alloc: failed %d\n", DEVNAME(sc), err);
+		goto err_ret;
+	}
+
+	err = bus_dmamem_map(sc->pci_dmat, &buf->seg, rsegs, buf->size, 
+            &buf->addr, wait | BUS_DMA_COHERENT);
+	if (err) {
+		DPRINTF("%s: dmamem_map: failed %d\n", DEVNAME(sc), err);
+		goto err_free;
+	}
+	
+	err = bus_dmamap_create(sc->pci_dmat, buf->size, 1, buf->size, 0,
+	    wait, &buf->map);
+	if (err) {
+		DPRINTF("%s: dmamap_create: failed %d\n", DEVNAME(sc), err);
+		goto err_unmap;
+	}
+	
+	err = bus_dmamap_load(sc->pci_dmat, buf->map, buf->addr, 
+            buf->size, NULL, wait);
+	if (err) {
+		DPRINTF("%s: dmamap_load: failed %d\n", DEVNAME(sc), err);
+		goto err_destroy;
+	}
+	bus_space_write_4(sc->mt_iot, sc->mt_ioh, basereg, buf->seg.ds_addr);
+	DPRINTF("%s: allocated %d bytes dir=%d, ka=%p, da=%p\n", 
+		DEVNAME(sc), buf->size, dir, buf->addr, buf->seg.ds_addr);
+	return buf->addr;
+
+ err_destroy:
+	bus_dmamap_destroy(sc->pci_dmat, buf->map);	
+ err_unmap:
+	bus_dmamem_unmap(sc->pci_dmat, buf->addr, buf->size);
+ err_free:
+	bus_dmamem_free(sc->pci_dmat, &buf->seg, 1);
+ err_ret:
+	return NULL;	
+}
+
+void
+envy_freem(void *self, void *addr, int type)
+{
+	struct envy_buf *buf;
+	struct envy_softc *sc = (struct envy_softc *)self;
+	int dir;
+
+	if (sc->ibuf.addr == addr) {
+		buf = &sc->ibuf;
+		dir = AUMODE_RECORD;
+	} else if (sc->obuf.addr == addr) {
+		buf = &sc->obuf;
+		dir = AUMODE_PLAY;
+	} else {
+		DPRINTF("%s: no buf to free\n", DEVNAME(sc));
+		return;
+	}
+	bus_dmamap_destroy(sc->pci_dmat, buf->map);	
+	bus_dmamem_unmap(sc->pci_dmat, buf->addr, buf->size);
+	bus_dmamem_free(sc->pci_dmat, &buf->seg, 1);
+	buf->addr = NULL;
+	DPRINTF("%s: freed buffer (mode=%d)\n", DEVNAME(sc), dir);
+}
+
+int
+envy_query_encoding(void *self, struct audio_encoding *enc)
+{
+	if (enc->index == 0) {
+		strlcpy(enc->name, AudioEslinear_le, sizeof(enc->name));
+		enc->encoding = AUDIO_ENCODING_SLINEAR_LE;
+		enc->precision = 32;
+		enc->flags = 0;
+		return 0;
+	}
+	return EINVAL;
+}
+
+int
+envy_set_params(void *self, int setmode, int usemode,
+    struct audio_params *p, struct audio_params *r)
+{
+	struct envy_softc *sc = (struct envy_softc *)self;
+	int i, rate, reg;
+
+	if (setmode == 0) {
+		DPRINTF("%s: no params to set\n", DEVNAME(sc));
+		return 0;
+	}
+	if (setmode == (AUMODE_PLAY | AUMODE_RECORD) &&
+	    p->sample_rate != r->sample_rate) {
+		DPRINTF("%s: play/rec rates mismatch\n", DEVNAME(sc));
+		return EINVAL;
+	}
+	rate = (setmode & AUMODE_PLAY) ? p->sample_rate : r->sample_rate;
+	for (i = 0; envy_rates[i].rate < rate; i++) {
+		if (envy_rates[i].rate == -1) {
+			i--;
+			DPRINTF("%s: rate: %d -> %d\n", DEVNAME(sc), rate, i);
+			break;
+		}
+	}
+	reg = bus_space_read_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_RATE);
+	reg &= ~ENVY_MT_RATEMASK;
+	reg |= envy_rates[i].reg;
+	bus_space_write_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_RATE, reg);
+	if (setmode & AUMODE_PLAY) {
+		p->encoding = AUDIO_ENCODING_SLINEAR;
+		p->precision = 32;
+		p->channels = ENVY_OCHANS;
+	}
+	if (setmode & AUMODE_RECORD) {
+		r->encoding = AUDIO_ENCODING_SLINEAR;
+		r->precision = 32;
+		r->channels = ENVY_ICHANS;
+	}
+	return 0;
+}
+
+int
+envy_round_blocksize(void *self, int blksz)
+{
+	/*
+	 * XXX: sizes depend on the mode but we don't have 
+	 * access to the mode here; So we use the greatest 
+	 * common divisor of input and output blocksizes, until 
+	 * upper layer is fixed
+	 */
+#define ENVY_GCD (6 * 5 * 4)
+	return (blksz / ENVY_GCD) * ENVY_GCD;
+}
+
+size_t
+envy_round_buffersize(void *self, int dir, size_t bufsz)
+{
+	/*
+	 * XXX: sizes depend on the blocksize... since we don't
+	 * have it, just round as blocksize.
+	 * upper layer is fixed
+	 */
+	return (bufsz / ENVY_GCD) * ENVY_GCD;
+}
+
+int
+envy_trigger_output(void *self, void *start, void *end, int blksz,
+    void (*intr)(void *), void *arg, struct audio_params *param)
+{
+	struct envy_softc *sc = (struct envy_softc *)self;
+	size_t bufsz;
+	int st;
+
+	bufsz = end - start;
+	if (bufsz % (ENVY_OCHANS * 4) != 0) {
+		DPRINTF("%s: %d: bad output bufsz\n", DEVNAME(sc), bufsz);
+		return EINVAL;
+	}
+	if (blksz % (ENVY_OCHANS * 4) != 0) {
+		DPRINTF("%s: %d: bad output blksz\n", DEVNAME(sc), blksz);
+		return EINVAL;
+	}	
+	bus_space_write_2(sc->mt_iot, sc->mt_ioh, 
+	    ENVY_MT_PBUFSZ, bufsz / 4 - 1);
+	bus_space_write_2(sc->mt_iot, sc->mt_ioh, 
+	    ENVY_MT_PBLKSZ, blksz / 4 - 1);
+
+	sc->ointr = intr;
+	sc->oarg = arg;
+
+	st = ENVY_MT_INTR_PACK;
+	bus_space_write_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_INTR, st);
+
+	st = bus_space_read_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_CTL);
+	st |= ENVY_MT_CTL_PSTART;
+	bus_space_write_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_CTL, st);
+	return 0;
+}
+
+int
+envy_trigger_input(void *self, void *start, void *end, int blksz,
+    void (*intr)(void *), void *arg, struct audio_params *param)
+{
+	struct envy_softc *sc = (struct envy_softc *)self;
+	size_t bufsz;
+	int st;
+	
+	bufsz = end - start;
+	if (bufsz % (ENVY_ICHANS * 4) != 0) {
+		DPRINTF("%s: %d: bad input bufsz\n", DEVNAME(sc), bufsz);
+		return EINVAL;
+	}
+	if (blksz % (ENVY_ICHANS * 4) != 0) {
+		DPRINTF("%s: %d: bad input blksz\n", DEVNAME(sc), blksz);
+		return EINVAL;
+	}
+	bus_space_write_2(sc->mt_iot, sc->mt_ioh, 
+	    ENVY_MT_RBUFSZ, bufsz / 4 - 1);
+	bus_space_write_2(sc->mt_iot, sc->mt_ioh, 
+	    ENVY_MT_RBLKSZ, blksz / 4 - 1);
+
+	sc->iintr = intr;
+	sc->iarg = arg;
+
+	st = ENVY_MT_INTR_RACK;
+	bus_space_write_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_INTR, st);
+
+	st = bus_space_read_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_CTL);
+	st |= ENVY_MT_CTL_RSTART;
+	bus_space_write_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_CTL, st);
+	return 0;
+}
+
+int
+envy_halt_output(void *self)
+{
+	struct envy_softc *sc = (struct envy_softc *)self;
+	int st;
+
+	st = bus_space_read_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_CTL);
+	st &= ~ENVY_MT_CTL_PSTART;
+	bus_space_write_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_CTL, 0);
+	return 0;
+}
+
+int
+envy_halt_input(void *self)
+{
+	struct envy_softc *sc = (struct envy_softc *)self;
+	int st;
+
+	st = bus_space_read_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_CTL);
+	st &= ~ENVY_MT_CTL_RSTART;
+	bus_space_write_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_CTL, 0);
+	return 0;
+}
+
+int
+envy_getdev(void *self, struct audio_device *dev)
+{
+	strlcpy(dev->name, "Envy24", MAX_AUDIO_DEV_LEN);
+	strlcpy(dev->version, "-", MAX_AUDIO_DEV_LEN);	/* XXX eeprom version */
+	strlcpy(dev->config, "envy", MAX_AUDIO_DEV_LEN);
+	return 0;
+}
+
+int
+envy_query_devinfo(void *self, struct mixer_devinfo *info)
+{
+	/*
+	 * XXX: no mixer yet
+	 */
+	return ENXIO;
+}
+
+int
+envy_get_port(void *self, struct mixer_ctrl *cp)
+{
+	return EINVAL;
+}
+
+int
+envy_set_port(void *self, struct mixer_ctrl *cp)
+{
+	return EINVAL;
+}
+
+int
+envy_get_props(void *self)
+{
+	return AUDIO_PROP_FULLDUPLEX;
+}
+
Index: dev/pci/envyreg.h
===================================================================
RCS file: dev/pci/envyreg.h
diff -N dev/pci/envyreg.h
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ dev/pci/envyreg.h	24 Oct 2007 05:54:39 -0000
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2007 Alexandre Ratchov <alex@caoua.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#ifndef SYS_DEV_PCI_ENVYREG_H
+#define SYS_DEV_PCI_ENVYREG_H
+
+/*
+ * BARs at PCI config space
+ */
+#define ENVY_CTL_BAR		0x10
+#define ENVY_MT_BAR		0x1c
+#define ENVY_CONF		0x60
+
+/*
+ * CCS "control" register
+ */
+#define ENVY_CTL		0x00
+#define   ENVY_CTL_RESET	0x80
+#define   ENVY_CTL_NATIVE	0x01
+#define ENVY_CCS_IMASK		0x01
+#define ENVY_CCS_ISTAT		0x02
+
+/*
+ * CCS registers to access indirect registers (CCI)
+ */
+#define ENVY_CCI_INDEX	0x3
+#define ENVY_CCI_DATA	0x4
+
+/*
+ * CCS regisers to access iic bus
+ */
+#define ENVY_I2C_DEV		0x10
+#define   ENVY_I2C_DEV_SHIFT	0x01
+#define   ENVY_I2C_DEV_WRITE	0x01
+#define   ENVY_I2C_DEV_EEPROM	0x50
+#define ENVY_I2C_ADDR		0x11
+#define ENVY_I2C_DATA		0x12
+#define ENVY_I2C_CTL		0x13
+#define	  ENVY_I2C_CTL_BUSY	0x1
+
+/*
+ * CCI registers to access GPIO pins
+ */
+#define ENVY_GPIO_DATA	0x20
+#define ENVY_GPIO_MASK	0x21
+#define ENVY_GPIO_DIR	0x22
+
+/*
+ * GPIO pin numbers
+ */
+#define ENVY_GPIO_CLK		0x2
+#define ENVY_GPIO_DOUT		0x8
+#define ENVY_GPIO_CSMASK	0x70
+#define ENVY_GPIO_CS(dev)	((dev) << 4)
+
+/*
+ * EEPROM bytes signification
+ */
+#define ENVY_EEPROM_CONF	6
+#define ENVY_EEPROM_ACLINK	7
+#define ENVY_EEPROM_I2S		8
+#define ENVY_EEPROM_SPDIF	9
+#define ENVY_EEPROM_GPIOMASK	10
+#define ENVY_EEPROM_GPIOST	11
+#define ENVY_EEPROM_GPIODIR	12
+
+#define ENVY_EEPROM_MAXSZ	32
+
+/*
+ * MT registers for play/record params
+ */
+#define ENVY_MT_INTR		0
+#define   ENVY_MT_INTR_PACK	0x01
+#define   ENVY_MT_INTR_RACK	0x02
+#define   ENVY_MT_INTR_PMASK	0x40
+#define   ENVY_MT_INTR_RMASK	0x80
+#define ENVY_MT_RATE		1
+#define   ENVY_MT_RATEMASK	0x0f
+#define ENVY_MT_PADDR		0x10
+#define ENVY_MT_PBUFSZ		0x14
+#define ENVY_MT_PBLKSZ		0x16
+#define ENVY_MT_CTL		0x18
+#define   ENVY_MT_CTL_PSTART	0x01
+#define   ENVY_MT_CTL_PPAUSE	0x02
+#define   ENVY_MT_CTL_RSTART	0x04
+#define   ENVY_MT_CTL_RPAUSE	0x08
+#define ENVY_MT_RADDR		0x20
+#define ENVY_MT_RBUFSZ		0x24
+#define ENVY_MT_RBLKSZ		0x26
+
+/*
+ * MT register to access the digital mixer
+ */
+#define ENVY_MT_OUTSRC		0x30	/* output source */
+#define ENVY_MT_SPDROUTE	0x32	/* spd route */
+#define ENVY_MT_INSEL		0x34	/* input select */
+
+/*
+ * default formats
+ */
+#define ENVY_IFRAME_SIZE	(4 * 12)
+#define ENVY_OFRAME_SIZE	(4 * 10)
+#define ENVY_IBUF_SIZE		(ENVY_IFRAME_SIZE * 0x1000)
+#define ENVY_OBUF_SIZE		(ENVY_OFRAME_SIZE * 0x1000)
+#define ENVY_ICHANS		12
+#define ENVY_OCHANS		10
+
+#endif /* !defined(SYS_DEV_PCI_ENVYREG_H) */
Index: dev/pci/envyvar.h
===================================================================
RCS file: dev/pci/envyvar.h
diff -N dev/pci/envyvar.h
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ dev/pci/envyvar.h	24 Oct 2007 05:54:39 -0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2007 Alexandre Ratchov <alex@caoua.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef SYS_DEV_PCI_ENVYVAR_H
+#define SYS_DEV_PCI_ENVYVAR_H
+
+#include <sys/types.h>
+#include <sys/device.h>
+#include <dev/audio_if.h>
+
+struct envy_buf {
+	bus_dma_segment_t	seg;
+	bus_dmamap_t		map;
+	caddr_t			addr;
+	size_t			size;
+};
+
+struct envy_softc {
+	struct device		dev;
+	struct device	       *audio;
+	struct envy_buf		ibuf, obuf;
+	pcitag_t		pci_tag;
+	pci_chipset_tag_t	pci_pc;
+	pci_intr_handle_t      *pci_ih;
+	bus_dma_tag_t		pci_dmat;
+	bus_space_tag_t		ctl_iot;
+	bus_space_handle_t      ctl_ioh;
+	bus_size_t		ctl_iosz;
+	bus_space_tag_t		mt_iot;
+	bus_space_handle_t      mt_ioh;
+	bus_size_t		mt_iosz;
+	void (*iintr)(void *);
+	void *iarg;
+	void (*ointr)(void *);
+	void *oarg;
+};
+
+#endif /* !defined(SYS_DEV_PCI_ENVYVAR_H) */
Index: dev/pci/files.pci
===================================================================
RCS file: /cvs/src/sys/dev/pci/files.pci,v
retrieving revision 1.245
diff -u -p -r1.245 files.pci
--- dev/pci/files.pci	12 Sep 2007 12:59:55 -0000	1.245
+++ dev/pci/files.pci	24 Oct 2007 05:54:39 -0000
@@ -131,6 +131,11 @@ attach	azalia at pci
 file	dev/pci/azalia.c		azalia
 file	dev/pci/azalia_codec.c		azalia
 
+# VIA Envy24 (aka ICE1712)
+device	envy: audio, auconv, mulaw
+attach	envy at pci
+file	dev/pci/envy.c			envy
+
 # Creative Labs EMU10k1 (SBLive! series and PCI512)
 device	emu: audio, auconv, mulaw, ac97
 attach	emu at pci
Index: dev/audio.c
===================================================================
RCS file: /cvs/src/sys/dev/audio.c,v
retrieving revision 1.83
diff -u -p -r1.83 audio.c
--- dev/audio.c	23 Oct 2007 17:43:41 -0000	1.83
+++ dev/audio.c	24 Oct 2007 05:54:42 -0000
@@ -129,7 +129,7 @@ int	audio_check_params(struct audio_para
 
 void	audio_set_blksize(struct audio_softc *, int, int);
 void	audio_calc_blksize(struct audio_softc *, int);
-void	audio_fill_silence(struct audio_params *, u_char *, int);
+void	audio_fill_silence(struct audio_params *, u_char *, u_char *, int);
 int	audio_silence_copyout(struct audio_softc *, int, struct uio *);
 
 void	audio_init_ringbuffer(struct audio_ringbuffer *);
@@ -1062,10 +1062,10 @@ audio_drain(struct audio_softc *sc)
 		cc = cb->blksize - (inp - cb->start) % cb->blksize;
 		if (sc->sc_pparams.sw_code) {
 			int ncc = cc / sc->sc_pparams.factor;
-			audio_fill_silence(&sc->sc_pparams, inp, ncc);
+			audio_fill_silence(&sc->sc_pparams, cb->start, inp, ncc);
 			sc->sc_pparams.sw_code(sc->hw_hdl, inp, ncc);
 		} else
-			audio_fill_silence(&sc->sc_pparams, inp, cc);
+			audio_fill_silence(&sc->sc_pparams, cb->start, inp, cc);
 		inp += cc;
 		if (inp >= cb->end)
 			inp = cb->start;
@@ -1338,17 +1338,38 @@ audio_calc_blksize(struct audio_softc *s
 }
 
 void
-audio_fill_silence(struct audio_params *params, u_char *p, int n)
+audio_fill_silence(struct audio_params *params, u_char *start, u_char *p, int n)
 {
-	u_char auzero0, auzero1 = 0; /* initialize to please gcc */
-	int nfill = 1;
+	size_t rounderr;
+	int i, samplesz, nsamples;
+	u_char auzero[4] = {0, 0, 0, 0};
+
+	/*
+	 * p may point the middle of a sample; round it to the
+	 * beginning of the sample, so we overwrite partially written
+	 * ones.
+	 */
+	samplesz = params->precision / 8;
+	rounderr = (p - start) % samplesz;
+	p -= rounderr;
+	n += rounderr;
+	nsamples = n / samplesz;
 
 	switch (params->encoding) {
+	case AUDIO_ENCODING_SLINEAR_LE:
+	case AUDIO_ENCODING_SLINEAR_BE:
+		break;
 	case AUDIO_ENCODING_ULAW:
-		auzero0 = 0x7f;
+		auzero[0] = 0x7f;
 		break;
 	case AUDIO_ENCODING_ALAW:
-		auzero0 = 0x55;
+		auzero[0] = 0x55;
+		break;
+	case AUDIO_ENCODING_ULINEAR_LE:
+		auzero[samplesz - 1] = 0x80; 
+		break;
+	case AUDIO_ENCODING_ULINEAR_BE:
+		auzero[0] = 0x80;
 		break;
 	case AUDIO_ENCODING_MPEG_L1_STREAM:
 	case AUDIO_ENCODING_MPEG_L1_PACKETS:
@@ -1357,38 +1378,14 @@ audio_fill_silence(struct audio_params *
 	case AUDIO_ENCODING_MPEG_L2_PACKETS:
 	case AUDIO_ENCODING_MPEG_L2_SYSTEM:
 	case AUDIO_ENCODING_ADPCM: /* is this right XXX */
-	case AUDIO_ENCODING_SLINEAR_LE:
-	case AUDIO_ENCODING_SLINEAR_BE:
-		auzero0 = 0;	/* fortunately this works for both 8 and 16 bits */
-		break;
-	case AUDIO_ENCODING_ULINEAR_LE:
-	case AUDIO_ENCODING_ULINEAR_BE:
-		if (params->precision == 16) {
-			nfill = 2;
-			if (params->encoding == AUDIO_ENCODING_ULINEAR_LE) {
-				auzero0 = 0;
-				auzero1 = 0x80;
-			} else {
-				auzero0 = 0x80;
-				auzero1 = 0;
-			}
-		} else
-			auzero0 = 0x80;
 		break;
 	default:
 		DPRINTF(("audio: bad encoding %d\n", params->encoding));
-		auzero0 = 0;
 		break;
 	}
-	if (nfill == 1) {
-		while (--n >= 0)
-			*p++ = auzero0; /* XXX memset */
-	} else /* nfill must be 2 */ {
-		while (n > 1) {
-			*p++ = auzero0;
-			*p++ = auzero1;
-			n -= 2;
-		}
+	while (--nsamples >= 0) {
+		for (i = 0; i < samplesz; i++) 
+			*p++ = auzero[i];
 	}
 }
 
@@ -1399,7 +1396,7 @@ audio_silence_copyout(struct audio_softc
 	int k;
 	u_char zerobuf[128];
 
-	audio_fill_silence(&sc->sc_rparams, zerobuf, sizeof zerobuf);
+	audio_fill_silence(&sc->sc_rparams, zerobuf, zerobuf, sizeof zerobuf);
 
 	error = 0;
 	while (n > 0 && uio->uio_resid > 0 && !error) {
@@ -1564,10 +1561,10 @@ audio_write(dev_t dev, struct uio *uio, 
 			DPRINTFN(1, ("audio_write: fill %d\n", cc));
 			if (sc->sc_pparams.sw_code) {
 				int ncc = cc / sc->sc_pparams.factor;
-				audio_fill_silence(&sc->sc_pparams, einp, ncc);
+				audio_fill_silence(&sc->sc_pparams, cb->start, einp, ncc);
 				sc->sc_pparams.sw_code(sc->hw_hdl, einp, ncc);
 			} else
-				audio_fill_silence(&sc->sc_pparams, einp, cc);
+				audio_fill_silence(&sc->sc_pparams, cb->start, einp, cc);
 		}
 	}
 	return (error);
@@ -1855,7 +1852,7 @@ audio_mmap(dev_t dev, off_t off, int pro
 	if (!cb->mmapped) {
 		cb->mmapped = 1;
 		if (cb == &sc->sc_pr) {
-			audio_fill_silence(&sc->sc_pparams, cb->start, cb->bufsize);
+			audio_fill_silence(&sc->sc_pparams, cb->start, cb->start, cb->bufsize);
 			s = splaudio();
 			if (!sc->sc_pbus && !sc->sc_pr.pause)
 				(void)audiostartp(sc);
@@ -1959,10 +1956,10 @@ audio_pint_silence(struct audio_softc *s
 
 			if (sc->sc_pparams.sw_code) {
 				int ncc = cc / sc->sc_pparams.factor;
-				audio_fill_silence(&sc->sc_pparams, inp, ncc);
+				audio_fill_silence(&sc->sc_pparams, cb->start, inp, ncc);
 				sc->sc_pparams.sw_code(sc->hw_hdl, inp, ncc);
 			} else
-				audio_fill_silence(&sc->sc_pparams, inp, cc);
+				audio_fill_silence(&sc->sc_pparams, cb->start, inp, cc);
 
 		} else {
 			DPRINTFN(5, ("audio_pint_silence: already silent cc=%d inp=%p\n", cc, inp));
@@ -1976,10 +1973,10 @@ audio_pint_silence(struct audio_softc *s
 
 		if (sc->sc_pparams.sw_code) {
 			int ncc = cc / sc->sc_pparams.factor;
-			audio_fill_silence(&sc->sc_pparams, inp, ncc);
+			audio_fill_silence(&sc->sc_pparams, cb->start, inp, ncc);
 			sc->sc_pparams.sw_code(sc->hw_hdl, inp, ncc);
 		} else
-			audio_fill_silence(&sc->sc_pparams, inp, cc);
+			audio_fill_silence(&sc->sc_pparams, cb->start, inp, cc);
 
 	}
 }
@@ -2226,7 +2223,8 @@ audio_check_params(struct audio_params *
 	case AUDIO_ENCODING_SLINEAR_BE:
 	case AUDIO_ENCODING_ULINEAR_LE:
 	case AUDIO_ENCODING_ULINEAR_BE:
-		if (p->precision != 8 && p->precision != 16)
+		if (p->precision != 8 && p->precision != 16 && 
+		    p->precision != 32)
 			return (EINVAL);
 		break;
 	case AUDIO_ENCODING_MPEG_L1_STREAM:
@@ -2240,7 +2238,8 @@ audio_check_params(struct audio_params *
 		return (EINVAL);
 	}
 
-	if (p->channels < 1 || p->channels > 8)	/* sanity check # of channels */
+	/* sanity check # of channels */
+	if (p->channels < 1 || p->channels > 12)
 		return (EINVAL);
 
 	return (0);