/* $OpenBSD: envy.c,v 1.28 2009/05/18 20:10:12 ratchov Exp $ */ /* * Copyright (c) 2007 Alexandre Ratchov * * 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. */ /* * TODO: * * - add nspdin, nspdout, to struct envy_card * * - use eeprom version rather isht flag * * - implement HT mixer, midi uart, spdif, init ADC/DACs for >48kHz modes * */ #include #include #include #include #include #include #include #include #include #include #include #include #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 *, int); void envy_ccs_write(struct envy_softc *, int, int); int envy_cci_read(struct envy_softc *, int); void envy_cci_write(struct envy_softc *, int, int); void envy_i2c_wait(struct envy_softc *); int envy_i2c_read(struct envy_softc *, int, int); void envy_i2c_write(struct envy_softc *, int, int, int); int envy_gpio_getstate(struct envy_softc *); void envy_gpio_setstate(struct envy_softc *, int); int envy_gpio_getmask(struct envy_softc *); void envy_gpio_setmask(struct envy_softc *, int); int envy_gpio_getdir(struct envy_softc *); void envy_gpio_setdir(struct envy_softc *, int); int envy_eeprom_gpioxxx(struct envy_softc *, int); void envy_reset(struct envy_softc *); int envy_codec_read(struct envy_softc *, int, int); void envy_codec_write(struct envy_softc *, int, int, int); int envy_intr(void *); int envy_lineout_getsrc(struct envy_softc *, int); void envy_lineout_setsrc(struct envy_softc *, int, int); int envy_spdout_getsrc(struct envy_softc *, int); void envy_spdout_setsrc(struct envy_softc *, int, int); void envy_mon_getvol(struct envy_softc *, int, int, int *); void envy_mon_setvol(struct envy_softc *, int, int, int); 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 *); void delta_init(struct envy_softc *); void delta_codec_write(struct envy_softc *, int, int, int); void julia_init(struct envy_softc *); void julia_codec_write(struct envy_softc *, int, int, int); void unkenvy_init(struct envy_softc *); void unkenvy_codec_write(struct envy_softc *, int, int, int); int unkenvy_codec_ndev(struct envy_softc *); int ak4524_dac_ndev(struct envy_softc *); void ak4524_dac_devinfo(struct envy_softc *, struct mixer_devinfo *, int); void ak4524_dac_get(struct envy_softc *, struct mixer_ctrl *, int); int ak4524_dac_set(struct envy_softc *, struct mixer_ctrl *, int); int ak4524_adc_ndev(struct envy_softc *); void ak4524_adc_devinfo(struct envy_softc *, struct mixer_devinfo *, int); void ak4524_adc_get(struct envy_softc *, struct mixer_ctrl *, int); int ak4524_adc_set(struct envy_softc *, struct mixer_ctrl *, int); int ak4358_dac_ndev(struct envy_softc *); void ak4358_dac_devinfo(struct envy_softc *, struct mixer_devinfo *, int); void ak4358_dac_get(struct envy_softc *, struct mixer_ctrl *, int); int ak4358_dac_set(struct envy_softc *, struct mixer_ctrl *, int); 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 */ NULL }; struct pci_matchid envy_matchids[] = { { PCI_VENDOR_ICENSEMBLE, PCI_PRODUCT_ICENSEMBLE_ICE1712 }, { PCI_VENDOR_ICENSEMBLE, PCI_PRODUCT_ICENSEMBLE_VT172x } }; /* * 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} }; /* * ESI julia cards don't have EEPROM, use this copy */ static unsigned char julia_eeprom[ENVY_EEPROM_MAXSZ] = { /* gpio mask/dir/state is from linux */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x80, 0xf8, 0xc3, 0x9f, 0xff, 0x7f, 0x9f, 0xff, 0x7f, 0x16, 0x80, 0x00 }; struct envy_codec ak4524_dac = { "ak4524 dac", ak4524_dac_ndev, ak4524_dac_devinfo, ak4524_dac_get, ak4524_dac_set }, ak4524_adc = { "ak4524 adc", ak4524_adc_ndev, ak4524_adc_devinfo, ak4524_adc_get, ak4524_adc_set }, ak4358_dac = { "ak4358 dac", ak4358_dac_ndev, ak4358_dac_devinfo, ak4358_dac_get, ak4358_dac_set }, unkenvy_codec = { "unknown codec", unkenvy_codec_ndev, NULL, NULL, NULL }; /* * array with vendor/product sub-IDs to card info */ struct envy_card envy_cards[] = { { PCI_ID_CODE(0x1412, 0xd630), "M-Audio Delta 1010", 8, &ak4524_adc, 8, &ak4524_dac, delta_init, delta_codec_write, NULL }, { PCI_ID_CODE(0x1412, 0xd632), "M-Audio Delta 66", 4, &ak4524_adc, 4, &ak4524_dac, delta_init, delta_codec_write, NULL }, { PCI_ID_CODE(0x1412, 0xd633), "M-Audio Delta 44", 4, &ak4524_adc, 4, &ak4524_dac, delta_init, delta_codec_write, NULL }, { PCI_ID_CODE(0x1412, 0xd63b), "M-Audio Delta 1010LT", 8, &ak4524_adc, 8, &ak4524_dac, delta_init, delta_codec_write, NULL }, { 0, "unknown 1712-based card", 8, &unkenvy_codec, 8, &unkenvy_codec, unkenvy_init, unkenvy_codec_write } }, envy_cards_ht[] = { { PCI_ID_CODE(0x3031, 0x4553), "ESI Julia", 2, &unkenvy_codec, 2, &ak4358_dac, julia_init, julia_codec_write, julia_eeprom }, { 0, "unknown 1724-based card", 2, &unkenvy_codec, 8, &unkenvy_codec, unkenvy_init, unkenvy_codec_write } }; /* * m-audio delta specific code */ void delta_init(struct envy_softc *sc) { int dev; for (dev = 0; dev < sc->card->noch / 2; dev++) { envy_codec_write(sc, dev, AK4524_RST, 0x0); delay(300); envy_codec_write(sc, dev, AK4524_RST, AK4524_RST_AD | AK4524_RST_DA); envy_codec_write(sc, dev, AK4524_FMT, AK4524_FMT_IIS24); sc->shadow[dev][AK4524_DEEMVOL] = AK4524_DEEM_OFF; sc->shadow[dev][AK4524_ADC_GAIN0] = 0x7f; sc->shadow[dev][AK4524_ADC_GAIN1] = 0x7f; sc->shadow[dev][AK4524_DAC_GAIN0] = 0x7f; sc->shadow[dev][AK4524_DAC_GAIN1] = 0x7f; } } void delta_codec_write(struct envy_softc *sc, int dev, int addr, int data) { int bits, i, reg; reg = envy_gpio_getstate(sc); reg &= ~ENVY_GPIO_CSMASK; reg |= ENVY_GPIO_CS(dev); envy_gpio_setstate(sc, reg); delay(1); bits = 0xa000 | (addr << 8) | data; for (i = 0; i < 16; i++) { reg &= ~(ENVY_GPIO_CLK | ENVY_GPIO_DOUT); reg |= (bits & 0x8000) ? ENVY_GPIO_DOUT : 0; envy_gpio_setstate(sc, reg); delay(1); reg |= ENVY_GPIO_CLK; envy_gpio_setstate(sc, reg); delay(1); bits <<= 1; } reg |= ENVY_GPIO_CSMASK; envy_gpio_setstate(sc, reg); delay(1); } /* * esi julia specific code */ void julia_init(struct envy_softc *sc) { int i; envy_codec_write(sc, 0, 0, 0); /* reset */ delay(300); envy_codec_write(sc, 0, 0, 0x87); /* i2s mode */ for (i = 0; i < sc->card->noch; i++) { sc->shadow[0][AK4358_ATT(i)] = 0xff; } } void julia_codec_write(struct envy_softc *sc, int dev, int addr, int data) { #define JULIA_AK4358_ADDR 0x11 envy_i2c_write(sc, JULIA_AK4358_ADDR, addr, data); } /* * unknown card, ignore codecs setup and hope it works with the power on * settings */ void unkenvy_init(struct envy_softc *sc) { } void unkenvy_codec_write(struct envy_softc *sc, int dev, int addr, int data) { } int unkenvy_codec_ndev(struct envy_softc *sc) { return 0; } /* * AK 4358 DAC specific code */ int ak4358_dac_ndev(struct envy_softc *sc) { /* 1 volume knob per channel */ return sc->card->noch; } void ak4358_dac_devinfo(struct envy_softc *sc, struct mixer_devinfo *dev, int idx) { dev->type = AUDIO_MIXER_VALUE; dev->mixer_class = ENVY_MIX_CLASSOUT; dev->un.v.delta = 2; dev->un.v.num_channels = 1; snprintf(dev->label.name, MAX_AUDIO_DEV_LEN, AudioNline "%d", idx); strlcpy(dev->un.v.units.name, AudioNvolume, MAX_AUDIO_DEV_LEN); } void ak4358_dac_get(struct envy_softc *sc, struct mixer_ctrl *ctl, int idx) { int val; val = envy_codec_read(sc, 0, AK4358_ATT(idx)) & ~AK4358_ATT_EN; ctl->un.value.num_channels = 1; ctl->un.value.level[0] = 2 * val; } int ak4358_dac_set(struct envy_softc *sc, struct mixer_ctrl *ctl, int idx) { int val; if (ctl->un.value.num_channels != 1) return EINVAL; val = ctl->un.value.level[0] / 2; envy_codec_write(sc, 0, AK4358_ATT(idx), val | AK4358_ATT_EN); return 0; } /* * AK 4524 DAC specific code */ int ak4524_dac_ndev(struct envy_softc *sc) { /* 1 mute + 2 volume knobs per channel pair */ return 3 * (sc->card->noch / 2); } void ak4524_dac_devinfo(struct envy_softc *sc, struct mixer_devinfo *dev, int idx) { int ndev; ndev = sc->card->noch; if (idx < ndev) { dev->type = AUDIO_MIXER_VALUE; dev->mixer_class = ENVY_MIX_CLASSOUT; dev->un.v.delta = 2; dev->un.v.num_channels = 1; snprintf(dev->label.name, MAX_AUDIO_DEV_LEN, AudioNline "%d", idx); strlcpy(dev->un.v.units.name, AudioNvolume, MAX_AUDIO_DEV_LEN); } else { idx -= ndev; dev->type = AUDIO_MIXER_ENUM; dev->mixer_class = ENVY_MIX_CLASSOUT; dev->un.e.member[0].ord = 0; strlcpy(dev->un.e.member[0].label.name, AudioNoff, MAX_AUDIO_DEV_LEN); dev->un.e.member[1].ord = 1; strlcpy(dev->un.e.member[1].label.name, AudioNon, MAX_AUDIO_DEV_LEN); dev->un.s.num_mem = 2; snprintf(dev->label.name, MAX_AUDIO_DEV_LEN, AudioNmute "%d-%d", 2 * idx, 2 * idx + 1); } } void ak4524_dac_get(struct envy_softc *sc, struct mixer_ctrl *ctl, int idx) { int val, ndev; ndev = sc->card->noch; if (idx < ndev) { val = envy_codec_read(sc, idx / 2, (idx % 2) + AK4524_DAC_GAIN0); ctl->un.value.num_channels = 1; ctl->un.value.level[0] = 2 * val; } else { idx -= ndev; val = envy_codec_read(sc, idx, AK4524_DEEMVOL); ctl->un.ord = (val & AK4524_MUTE) ? 1 : 0; } } int ak4524_dac_set(struct envy_softc *sc, struct mixer_ctrl *ctl, int idx) { int val, ndev; ndev = sc->card->noch; if (idx < ndev) { if (ctl->un.value.num_channels != 1) return EINVAL; val = ctl->un.value.level[0] / 2; envy_codec_write(sc, idx / 2, (idx % 2) + AK4524_DAC_GAIN0, val); } else { idx -= ndev; if (ctl->un.ord >= 2) return EINVAL; val = AK4524_DEEM_OFF | (ctl->un.ord ? AK4524_MUTE : 0); envy_codec_write(sc, idx, AK4524_DEEMVOL, val); } return 0; } /* * AK 4524 ADC specific code */ int ak4524_adc_ndev(struct envy_softc *sc) { /* one volume per channel */ return sc->card->nich; } void ak4524_adc_devinfo(struct envy_softc *sc, struct mixer_devinfo *dev, int idx) { dev->type = AUDIO_MIXER_VALUE; dev->mixer_class = ENVY_MIX_CLASSIN; dev->un.v.delta = 2; dev->un.v.num_channels = 1; snprintf(dev->label.name, MAX_AUDIO_DEV_LEN, AudioNline "%d", idx); strlcpy(dev->un.v.units.name, AudioNvolume, MAX_AUDIO_DEV_LEN); } void ak4524_adc_get(struct envy_softc *sc, struct mixer_ctrl *ctl, int idx) { int val; val = envy_codec_read(sc, idx / 2, (idx % 2) + AK4524_ADC_GAIN0); ctl->un.value.num_channels = 1; ctl->un.value.level[0] = 2 * val; } int ak4524_adc_set(struct envy_softc *sc, struct mixer_ctrl *ctl, int idx) { int val; if (ctl->un.value.num_channels != 1) return EINVAL; val = ctl->un.value.level[0] / 2; envy_codec_write(sc, idx / 2, (idx % 2) + AK4524_ADC_GAIN0, val); return 0; } /* * generic Envy24 and Envy24HT code, common to all cards */ int envy_ccs_read(struct envy_softc *sc, int reg) { return bus_space_read_1(sc->ccs_iot, sc->ccs_ioh, reg); } void envy_ccs_write(struct envy_softc *sc, int reg, int val) { bus_space_write_1(sc->ccs_iot, sc->ccs_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); } int envy_gpio_getstate(struct envy_softc *sc) { if (sc->isht) { return envy_ccs_read(sc, ENVY_CCS_GPIODATA0) | (envy_ccs_read(sc, ENVY_CCS_GPIODATA1) << 8) | (envy_ccs_read(sc, ENVY_CCS_GPIODATA2) << 16); } else return envy_cci_read(sc, ENVY_CCI_GPIODATA); } void envy_gpio_setstate(struct envy_softc *sc, int reg) { if (sc->isht) { envy_ccs_write(sc, ENVY_CCS_GPIODATA0, reg & 0xff); envy_ccs_write(sc, ENVY_CCS_GPIODATA1, (reg >> 8) & 0xff); envy_ccs_write(sc, ENVY_CCS_GPIODATA2, (reg >> 16) & 0xff); } else envy_cci_write(sc, ENVY_CCI_GPIODATA, reg); } int envy_gpio_getmask(struct envy_softc *sc) { if (sc->isht) { return envy_ccs_read(sc, ENVY_CCS_GPIOMASK0) | (envy_ccs_read(sc, ENVY_CCS_GPIOMASK1) << 8) | (envy_ccs_read(sc, ENVY_CCS_GPIOMASK2) << 16); } else return envy_cci_read(sc, ENVY_CCI_GPIOMASK); } void envy_gpio_setmask(struct envy_softc *sc, int mask) { if (sc->isht) { envy_ccs_write(sc, ENVY_CCS_GPIOMASK0, mask & 0xff); envy_ccs_write(sc, ENVY_CCS_GPIOMASK1, (mask >> 8) & 0xff); envy_ccs_write(sc, ENVY_CCS_GPIOMASK2, (mask >> 16) & 0xff); } else envy_cci_write(sc, ENVY_CCI_GPIOMASK, mask); } int envy_gpio_getdir(struct envy_softc *sc) { if (sc->isht) { return envy_ccs_read(sc, ENVY_CCS_GPIODIR0) | (envy_ccs_read(sc, ENVY_CCS_GPIODIR1) << 8) | (envy_ccs_read(sc, ENVY_CCS_GPIODIR2) << 16); } else return envy_cci_read(sc, ENVY_CCI_GPIODIR); } void envy_gpio_setdir(struct envy_softc *sc, int dir) { if (sc->isht) { envy_ccs_write(sc, ENVY_CCS_GPIODIR0, dir & 0xff); envy_ccs_write(sc, ENVY_CCS_GPIODIR1, (dir >> 8) & 0xff); envy_ccs_write(sc, ENVY_CCS_GPIODIR2, (dir >> 16) & 0xff); } else envy_cci_write(sc, ENVY_CCI_GPIODIR, dir); } 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); } int envy_codec_read(struct envy_softc *sc, int dev, int addr) { return sc->shadow[dev][addr]; } void envy_codec_write(struct envy_softc *sc, int dev, int addr, int data) { DPRINTFN(2, "envy_codec_write: %d, %d, 0x%x\n", dev, addr, data); sc->shadow[dev][addr] = data; sc->card->codec_write(sc, dev, addr, data); } int envy_eeprom_gpioxxx(struct envy_softc *sc, int addr) { int val; val = sc->eeprom[addr]; if (sc->isht) { val |= sc->eeprom[++addr] << 8; val |= sc->eeprom[++addr] << 16; } return val; } void envy_reset(struct envy_softc *sc) { int i; /* * 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 eeprom using i2c device or from a static array */ if (sc->card->eeprom == NULL) { for (i = 0; i < ENVY_EEPROM_MAXSZ; i++) { sc->eeprom[i] = envy_i2c_read(sc, ENVY_I2C_DEV_EEPROM, i); } #ifdef ENVY_DEBUG printf("%s: eeprom: ", DEVNAME(sc)); for (i = 0; i < ENVY_EEPROM_MAXSZ; i++) { printf(" %02x", (unsigned)sc->eeprom[i]); } printf("\n"); #endif } else memcpy(sc->eeprom, sc->card->eeprom, ENVY_EEPROM_MAXSZ); /* * write eeprom values to corresponding registers */ pci_conf_write(sc->pci_pc, sc->pci_tag, ENVY_CONF, sc->eeprom[ENVY_EEPROM_CONF] | (sc->eeprom[ENVY_EEPROM_ACLINK] << 8) | (sc->eeprom[ENVY_EEPROM_I2S] << 16) | (sc->eeprom[ENVY_EEPROM_SPDIF] << 24)); envy_gpio_setmask(sc, envy_eeprom_gpioxxx(sc, ENVY_EEPROM_GPIOMASK)); envy_gpio_setdir(sc, envy_eeprom_gpioxxx(sc, ENVY_EEPROM_GPIODIR(sc))); envy_gpio_setstate(sc, envy_eeprom_gpioxxx(sc, ENVY_EEPROM_GPIOST(sc))); DPRINTF("%s: gpio_mask = %02x\n", DEVNAME(sc), envy_gpio_getmask(sc)); DPRINTF("%s: gpio_dir = %02x\n", DEVNAME(sc), envy_gpio_getdir(sc)); DPRINTF("%s: gpio_state = %02x\n", DEVNAME(sc), envy_gpio_getstate(sc)); /* * clear all interrupts and unmask used ones */ envy_ccs_write(sc, ENVY_CCS_INTSTAT, 0xff); envy_ccs_write(sc, ENVY_CCS_INTMASK, ~ENVY_CCS_INT_MT); if (sc->isht) { bus_space_write_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_NSTREAM, 4 - sc->card->noch / 2); bus_space_write_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_IMASK, ~(ENVY_MT_IMASK_PDMA0 | ENVY_MT_IMASK_RDMA0)); } sc->card->init(sc); } 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) { st = ENVY_MT_INTR_PACK; bus_space_write_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_INTR, st); sc->ointr(sc->oarg); } if (st & ENVY_MT_INTR_RACK) { st = ENVY_MT_INTR_RACK; bus_space_write_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_INTR, st); sc->iintr(sc->iarg); } return 1; } int envy_lineout_getsrc(struct envy_softc *sc, int out) { int reg, shift, src; if (sc->isht) { reg = bus_space_read_4(sc->mt_iot, sc->mt_ioh, ENVY_MT_HTSRC); DPRINTF("%s: outsrc=%x\n", DEVNAME(sc), reg); shift = 3 * (out / 2) + ((out & 1) ? 20 : 8); src = (reg >> shift) & ENVY_MT_HTSRC_MASK; if (src == ENVY_MT_HTSRC_DMA) { return ENVY_MIX_OUTSRC_DMA; } else { src -= ENVY_MT_HTSRC_LINE; return ENVY_MIX_OUTSRC_LINEIN + src; } } reg = bus_space_read_2(sc->mt_iot, sc->mt_ioh, ENVY_MT_OUTSRC); DPRINTF("%s: outsrc=%x\n", DEVNAME(sc), reg); shift = (out & 1) ? (out & ~1) + 8 : out; src = (reg >> shift) & 3; if (src == ENVY_MT_OUTSRC_DMA) { return ENVY_MIX_OUTSRC_DMA; } else if (src == ENVY_MT_OUTSRC_MON) { return ENVY_MIX_OUTSRC_MON; } reg = bus_space_read_4(sc->mt_iot, sc->mt_ioh, ENVY_MT_INSEL); DPRINTF("%s: insel=%x\n", DEVNAME(sc), reg); reg = (reg >> (out * 4)) & 0xf; if (src == ENVY_MT_OUTSRC_LINE) return ENVY_MIX_OUTSRC_LINEIN + (reg & 7); else return ENVY_MIX_OUTSRC_SPDIN + (reg >> 3); } void envy_lineout_setsrc(struct envy_softc *sc, int out, int src) { int reg, shift, mask, sel; if (sc->isht) { if (src < ENVY_MIX_OUTSRC_SPDIN) { sel = ENVY_MT_HTSRC_LINE; sel += src; } else if (src < ENVY_MIX_OUTSRC_DMA) { sel = ENVY_MT_HTSRC_SPD; sel += src - ENVY_MIX_OUTSRC_SPDIN; } else { sel = ENVY_MT_HTSRC_DMA; } shift = 3 * (out / 2) + ((out & 1) ? 20 : 8); mask = ENVY_MT_HTSRC_MASK << shift; reg = bus_space_read_4(sc->mt_iot, sc->mt_ioh, ENVY_MT_HTSRC); reg = (reg & ~mask) | (sel << shift); bus_space_write_4(sc->mt_iot, sc->mt_ioh, ENVY_MT_HTSRC, reg); DPRINTF("%s: outsrc <- %x\n", DEVNAME(sc), reg); return; } if (src < ENVY_MIX_OUTSRC_DMA) { /* * linein and spdin are used as output source so we * must select the input source channel number */ if (src < ENVY_MIX_OUTSRC_SPDIN) sel = src - ENVY_MIX_OUTSRC_LINEIN; else sel = (src - ENVY_MIX_OUTSRC_SPDIN) << 3; shift = out * ENVY_MT_INSEL_BITS; mask = ENVY_MT_INSEL_MASK << shift; reg = bus_space_read_4(sc->mt_iot, sc->mt_ioh, ENVY_MT_INSEL); reg = (reg & ~mask) | (sel << shift); bus_space_write_4(sc->mt_iot, sc->mt_ioh, ENVY_MT_INSEL, reg); DPRINTF("%s: insel <- %x\n", DEVNAME(sc), reg); } /* * set the lineout route register */ if (src < ENVY_MIX_OUTSRC_SPDIN) { sel = ENVY_MT_OUTSRC_LINE; } else if (src < ENVY_MIX_OUTSRC_DMA) { sel = ENVY_MT_OUTSRC_SPD; } else if (src == ENVY_MIX_OUTSRC_DMA) { sel = ENVY_MT_OUTSRC_DMA; } else { sel = ENVY_MT_OUTSRC_MON; } shift = (out & 1) ? (out & ~1) + 8 : out; mask = ENVY_MT_OUTSRC_MASK << shift; reg = bus_space_read_2(sc->mt_iot, sc->mt_ioh, ENVY_MT_OUTSRC); reg = (reg & ~mask) | (sel << shift); bus_space_write_2(sc->mt_iot, sc->mt_ioh, ENVY_MT_OUTSRC, reg); DPRINTF("%s: outsrc <- %x\n", DEVNAME(sc), reg); } int envy_spdout_getsrc(struct envy_softc *sc, int out) { int reg, src, sel; reg = bus_space_read_2(sc->mt_iot, sc->mt_ioh, ENVY_MT_SPDROUTE); DPRINTF("%s: spdroute=%x\n", DEVNAME(sc), reg); src = (out == 0) ? reg : reg >> 2; src &= ENVY_MT_SPDSRC_MASK; if (src == ENVY_MT_SPDSRC_DMA) { return ENVY_MIX_OUTSRC_DMA; } else if (src == ENVY_MT_SPDSRC_MON) { return ENVY_MIX_OUTSRC_MON; } sel = (out == 0) ? reg >> 8 : reg >> 12; sel &= ENVY_MT_SPDSEL_MASK; if (src == ENVY_MT_SPDSRC_LINE) return ENVY_MIX_OUTSRC_LINEIN + (sel & 7); else return ENVY_MIX_OUTSRC_SPDIN + (sel >> 3); } void envy_spdout_setsrc(struct envy_softc *sc, int out, int src) { int reg, shift, mask, sel; reg = bus_space_read_2(sc->mt_iot, sc->mt_ioh, ENVY_MT_SPDROUTE); if (src < ENVY_MIX_OUTSRC_DMA) { /* * linein and spdin are used as output source so we * must select the input source channel number */ if (src < ENVY_MIX_OUTSRC_SPDIN) sel = src - ENVY_MIX_OUTSRC_LINEIN; else sel = (src - ENVY_MIX_OUTSRC_SPDIN) << 3; shift = 8 + out * ENVY_MT_SPDSEL_BITS; mask = ENVY_MT_SPDSEL_MASK << shift; reg = (reg & ~mask) | (sel << shift); } /* * set the lineout route register */ if (src < ENVY_MIX_OUTSRC_SPDIN) { sel = ENVY_MT_OUTSRC_LINE; } else if (src < ENVY_MIX_OUTSRC_DMA) { sel = ENVY_MT_OUTSRC_SPD; } else if (src == ENVY_MIX_OUTSRC_DMA) { sel = ENVY_MT_OUTSRC_DMA; } else { sel = ENVY_MT_OUTSRC_MON; } shift = out * 2; mask = ENVY_MT_SPDSRC_MASK << shift; reg = (reg & ~mask) | (sel << shift); bus_space_write_2(sc->mt_iot, sc->mt_ioh, ENVY_MT_SPDROUTE, reg); DPRINTF("%s: spdroute <- %x\n", DEVNAME(sc), reg); } void envy_mon_getvol(struct envy_softc *sc, int idx, int ch, int *val) { int reg; bus_space_write_2(sc->mt_iot, sc->mt_ioh, ENVY_MT_MONIDX, idx); reg = bus_space_read_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_MONDATA + ch); *val = 0x7f - (reg & 0x7f); } void envy_mon_setvol(struct envy_softc *sc, int idx, int ch, int val) { int reg; bus_space_write_2(sc->mt_iot, sc->mt_ioh, ENVY_MT_MONIDX, idx); reg = 0x7f - val; DPRINTF("%s: mon=%d/%d <- %d\n", DEVNAME(sc), reg, ch, val); bus_space_write_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_MONDATA + ch, reg); } int envymatch(struct device *parent, void *match, void *aux) { return pci_matchbyid((struct pci_attach_args *)aux, envy_matchids, sizeof(envy_matchids) / sizeof(envy_matchids[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; int subid; 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->ccs_iosz = 0; sc->mt_iosz = 0; sc->isht = (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_ICENSEMBLE_VT172x); if (pci_mapreg_map(pa, ENVY_CTL_BAR, PCI_MAPREG_TYPE_IO, 0, &sc->ccs_iot, &sc->ccs_ioh, NULL, &sc->ccs_iosz, 0)) { printf(": can't map ctl i/o space\n"); sc->ccs_iosz = 0; return; } if (pci_mapreg_map(pa, ENVY_MT_BAR(sc->isht), PCI_MAPREG_TYPE_IO, 0, &sc->mt_iot, &sc->mt_ioh, NULL, &sc->mt_iosz, 0)) { printf(": can't 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); subid = pci_conf_read(sc->pci_pc, sc->pci_tag, PCI_SUBVEND_0); sc->card = sc->isht ? envy_cards_ht : envy_cards; while (sc->card->subid != subid) { if (sc->card->subid == 0) break; sc->card++; } printf("%s: %s, %u inputs, %u outputs\n", DEVNAME(sc), sc->card->name, sc->card->nich, sc->card->noch); 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->ccs_iosz) { bus_space_unmap(sc->ccs_iot, sc->ccs_ioh, sc->ccs_iosz); } if (sc->mt_iosz) { bus_space_unmap(sc->mt_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 %ld bytes dir=%d, ka=%p, da=%p\n", DEVNAME(sc), buf->size, dir, buf->addr, (void *)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 = 24; 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)); r->sample_rate = p->sample_rate; } 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 = 24; p->channels = sc->isht ? sc->card->noch : ENVY_PCHANS; } if (setmode & AUMODE_RECORD) { r->encoding = AUDIO_ENCODING_SLINEAR; r->precision = 24; r->channels = sc->isht ? sc->card->nich : ENVY_RCHANS; } return 0; } int envy_round_blocksize(void *self, int blksz) { struct envy_softc *sc = (struct envy_softc *)self; int mul, pmult, rmult; /* * XXX: audio(4) layer doesn't round to the sample size * until it's fixed, roll our own rounding */ pmult = (sc->isht ? sc->card->noch : ENVY_PCHANS); if (pmult == 0) pmult = 1; rmult = (sc->isht ? sc->card->nich : ENVY_RCHANS); if (rmult == 0) rmult = 1; mul = pmult * rmult; while ((mul & 0x1f) != 0) mul <<= 1; blksz -= blksz % mul; if (blksz == 0) blksz = mul; return blksz; } size_t envy_round_buffersize(void *self, int dir, size_t bufsz) { return bufsz; } 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 = (char *)end - (char *)start; #ifdef ENVY_DEBUG if (blksz % (sc->isht ? sc->card->noch * 4 : ENVY_PFRAME_SIZE) != 0) { printf("%s: %d: bad output blksz\n", DEVNAME(sc), blksz); return EINVAL; } if (bufsz % blksz) { printf("%s: %ld: bad output bufsz\n", DEVNAME(sc), bufsz); return EINVAL; } #endif 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(sc), 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 = (char *)end - (char *)start; #ifdef ENVY_DEBUG if (blksz % (sc->isht ? sc->card->nich * 4 : ENVY_RFRAME_SIZE) != 0) { printf("%s: %d: bad input blksz\n", DEVNAME(sc), blksz); return EINVAL; } if (bufsz % blksz != 0) { printf("%s: %ld: bad input bufsz\n", DEVNAME(sc), bufsz); return EINVAL; } #endif 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(sc); 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, st); 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(sc); bus_space_write_1(sc->mt_iot, sc->mt_ioh, ENVY_MT_CTL, st); return 0; } int envy_getdev(void *self, struct audio_device *dev) { struct envy_softc *sc = (struct envy_softc *)self; strlcpy(dev->name, sc->isht ? "Envy24HT" : "Envy24", MAX_AUDIO_DEV_LEN); strlcpy(dev->version, "-", MAX_AUDIO_DEV_LEN); strlcpy(dev->config, sc->card->name, MAX_AUDIO_DEV_LEN); return 0; } int envy_query_devinfo(void *self, struct mixer_devinfo *dev) { struct envy_softc *sc = (struct envy_softc *)self; int i, n, idx, ndev; char *classes[] = { AudioCinputs, AudioCoutputs, AudioCmonitor }; if (dev->index < 0) return ENXIO; idx = dev->index; ndev = ENVY_MIX_NCLASS; dev->prev = dev->next = AUDIO_MIXER_LAST; /* * classes */ if (idx < ndev) { dev->type = AUDIO_MIXER_CLASS; dev->mixer_class = idx; strlcpy(dev->label.name, classes[idx], MAX_AUDIO_DEV_LEN); return 0; } idx -= ndev; /* * output.lineX_source */ ndev = sc->card->noch; if (idx < ndev) { n = 0; dev->type = AUDIO_MIXER_ENUM; dev->mixer_class = ENVY_MIX_CLASSOUT; for (i = 0; i < sc->card->nich; i++) { dev->un.e.member[n].ord = n; snprintf(dev->un.e.member[n++].label.name, MAX_AUDIO_DEV_LEN, AudioNline "%d", i); } dev->un.e.member[n].ord = n; snprintf(dev->un.e.member[n++].label.name, MAX_AUDIO_DEV_LEN, "play%d", idx); if (!sc->isht && idx < 2) { dev->un.e.member[n].ord = n; snprintf(dev->un.e.member[n++].label.name, MAX_AUDIO_DEV_LEN, "mon%d", idx); } snprintf(dev->label.name, MAX_AUDIO_DEV_LEN, "line%u_" AudioNsource, idx); dev->un.s.num_mem = n; return 0; } idx -= ndev; /* * envy monitor level */ ndev = sc->isht ? 0 : ENVY_MIX_NMONITOR; if (idx < ndev) { dev->type = AUDIO_MIXER_VALUE; dev->mixer_class = ENVY_MIX_CLASSMON; dev->un.v.delta = 2; dev->un.v.num_channels = 1; snprintf(dev->label.name, MAX_AUDIO_DEV_LEN, "%s%d", idx < 10 ? "play" : "rec", idx % 10); strlcpy(dev->un.v.units.name, AudioNvolume, MAX_AUDIO_DEV_LEN); return 0; } idx -= ndev; /* * inputs.xxx */ ndev = sc->card->adc->ndev(sc); if (idx < ndev) { sc->card->adc->devinfo(sc, dev, idx); return 0; } idx -= ndev; /* * outputs.xxx */ ndev = sc->card->dac->ndev(sc); if (idx < ndev) { sc->card->dac->devinfo(sc, dev, idx); return 0; } return ENXIO; } int envy_get_port(void *self, struct mixer_ctrl *ctl) { struct envy_softc *sc = (struct envy_softc *)self; int val, idx, ndev; if (ctl->dev < ENVY_MIX_NCLASS) { return EINVAL; } idx = ctl->dev - ENVY_MIX_NCLASS; ndev = sc->card->noch; if (idx < ndev) { ctl->un.ord = envy_lineout_getsrc(sc, idx); if (ctl->un.ord >= ENVY_MIX_NOUTSRC) ctl->un.ord -= ENVY_MIX_NOUTSRC - sc->card->nich; return 0; } idx -= ndev; ndev = sc->isht ? 0 : ENVY_MIX_NMONITOR; if (idx < ndev) { envy_mon_getvol(sc, idx / 2, idx % 2, &val); ctl->un.value.num_channels = 1; ctl->un.value.level[0] = 2 * val; return 0; } idx -= ndev; ndev = sc->card->adc->ndev(sc); if (idx < ndev) { sc->card->adc->get(sc, ctl, idx); return 0; } idx -= ndev; ndev = sc->card->dac->ndev(sc); if (idx < ndev) { sc->card->dac->get(sc, ctl, idx); return 0; } return ENXIO; } int envy_set_port(void *self, struct mixer_ctrl *ctl) { struct envy_softc *sc = (struct envy_softc *)self; int maxsrc, val, idx, ndev; if (ctl->dev < ENVY_MIX_NCLASS) { return EINVAL; } idx = ctl->dev - ENVY_MIX_NCLASS; ndev = sc->card->noch; if (idx < ndev) { maxsrc = sc->card->nich + 1; if (idx < 2) maxsrc++; if (ctl->un.ord < 0 || ctl->un.ord >= maxsrc) return EINVAL; if (ctl->un.ord >= sc->card->nich) ctl->un.ord += ENVY_MIX_NOUTSRC - sc->card->nich; envy_lineout_setsrc(sc, idx, ctl->un.ord); return 0; } idx -= ndev; ndev = sc->isht ? 0 : ENVY_MIX_NMONITOR; if (idx < ndev) { if (ctl->un.value.num_channels != 1) { return EINVAL; } val = ctl->un.value.level[0] / 2; envy_mon_setvol(sc, idx / 2, idx % 2, val); return 0; } idx -= ndev; ndev = sc->card->adc->ndev(sc); if (idx < ndev) return sc->card->adc->set(sc, ctl, idx); idx -= ndev; ndev = sc->card->dac->ndev(sc); if (idx < ndev) return sc->card->dac->set(sc, ctl, idx); return ENXIO; } int envy_get_props(void *self) { return AUDIO_PROP_FULLDUPLEX | AUDIO_PROP_INDEPENDENT; }