Annotation of sys/dev/pci/auvia.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: auvia.c,v 1.33 2005/05/06 01:45:22 miod Exp $ */
! 2: /* $NetBSD: auvia.c,v 1.7 2000/11/15 21:06:33 jdolecek Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 2000 The NetBSD Foundation, Inc.
! 6: * All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to The NetBSD Foundation
! 9: * by Tyler C. Sarna
! 10: *
! 11: * Redistribution and use in source and binary forms, with or without
! 12: * modification, are permitted provided that the following conditions
! 13: * are met:
! 14: * 1. Redistributions of source code must retain the above copyright
! 15: * notice, this list of conditions and the following disclaimer.
! 16: * 2. Redistributions in binary form must reproduce the above copyright
! 17: * notice, this list of conditions and the following disclaimer in the
! 18: * documentation and/or other materials provided with the distribution.
! 19: * 3. All advertising materials mentioning features or use of this software
! 20: * must display the following acknowledgement:
! 21: * This product includes software developed by the NetBSD
! 22: * Foundation, Inc. and its contributors.
! 23: * 4. Neither the name of The NetBSD Foundation nor the names of its
! 24: * contributors may be used to endorse or promote products derived
! 25: * from this software without specific prior written permission.
! 26: *
! 27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
! 28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
! 31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
! 34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 37: * POSSIBILITY OF SUCH DAMAGE.
! 38: */
! 39:
! 40: /*
! 41: * VIA Technologies VT82C686A Southbridge Audio Driver
! 42: *
! 43: * Documentation links:
! 44: *
! 45: * ftp://ftp.alsa-project.org/pub/manuals/via/686a.pdf
! 46: */
! 47:
! 48: #include <sys/param.h>
! 49: #include <sys/systm.h>
! 50: #include <sys/malloc.h>
! 51: #include <sys/device.h>
! 52: #include <sys/audioio.h>
! 53:
! 54: #include <dev/pci/pcidevs.h>
! 55: #include <dev/pci/pcivar.h>
! 56:
! 57: #include <dev/audio_if.h>
! 58: #include <dev/mulaw.h>
! 59: #include <dev/auconv.h>
! 60:
! 61: #include <dev/ic/ac97.h>
! 62:
! 63: #include <dev/pci/auviavar.h>
! 64:
! 65: struct auvia_dma {
! 66: struct auvia_dma *next;
! 67: caddr_t addr;
! 68: size_t size;
! 69: bus_dmamap_t map;
! 70: bus_dma_segment_t seg;
! 71: };
! 72:
! 73: struct auvia_dma_op {
! 74: u_int32_t ptr;
! 75: u_int32_t flags;
! 76: #define AUVIA_DMAOP_EOL 0x80000000
! 77: #define AUVIA_DMAOP_FLAG 0x40000000
! 78: #define AUVIA_DMAOP_STOP 0x20000000
! 79: #define AUVIA_DMAOP_COUNT(x) ((x)&0x00FFFFFF)
! 80: };
! 81:
! 82: /* rev. H and later seem to support only fixed rate 44.1 kHz */
! 83: #define AUVIA_FIXED_RATE 44100
! 84:
! 85: int auvia_match(struct device *, void *, void *);
! 86: void auvia_attach(struct device *, struct device *, void *);
! 87: int auvia_open(void *, int);
! 88: void auvia_close(void *);
! 89: int auvia_query_encoding(void *addr, struct audio_encoding *fp);
! 90: int auvia_set_params(void *, int, int, struct audio_params *,
! 91: struct audio_params *);
! 92: int auvia_round_blocksize(void *, int);
! 93: int auvia_halt_output(void *);
! 94: int auvia_halt_input(void *);
! 95: int auvia_getdev(void *, struct audio_device *);
! 96: int auvia_set_port(void *, mixer_ctrl_t *);
! 97: int auvia_get_port(void *, mixer_ctrl_t *);
! 98: int auvia_query_devinfo(void *, mixer_devinfo_t *);
! 99: void * auvia_malloc(void *, int, size_t, int, int);
! 100: void auvia_free(void *, void *, int);
! 101: paddr_t auvia_mappage(void *, void *, off_t, int);
! 102: int auvia_get_props(void *);
! 103: int auvia_build_dma_ops(struct auvia_softc *, struct auvia_softc_chan *,
! 104: struct auvia_dma *, void *, void *, int);
! 105: int auvia_trigger_output(void *, void *, void *, int, void (*)(void *),
! 106: void *, struct audio_params *);
! 107: int auvia_trigger_input(void *, void *, void *, int, void (*)(void *),
! 108: void *, struct audio_params *);
! 109:
! 110: int auvia_intr(void *);
! 111:
! 112: struct cfdriver auvia_cd = {
! 113: NULL, "auvia", DV_DULL
! 114: };
! 115:
! 116: struct cfattach auvia_ca = {
! 117: sizeof (struct auvia_softc), auvia_match, auvia_attach
! 118: };
! 119:
! 120: #define AUVIA_PCICONF_JUNK 0x40
! 121: #define AUVIA_PCICONF_ENABLES 0x00FF0000 /* reg 42 mask */
! 122: #define AUVIA_PCICONF_ACLINKENAB 0x00008000 /* ac link enab */
! 123: #define AUVIA_PCICONF_ACNOTRST 0x00004000 /* ~(ac reset) */
! 124: #define AUVIA_PCICONF_ACSYNC 0x00002000 /* ac sync */
! 125: #define AUVIA_PCICONF_ACVSR 0x00000800 /* var. samp. rate */
! 126: #define AUVIA_PCICONF_ACSGD 0x00000400 /* SGD enab */
! 127: #define AUVIA_PCICONF_ACFM 0x00000200 /* FM enab */
! 128: #define AUVIA_PCICONF_ACSB 0x00000100 /* SB enab */
! 129: #define AUVIA_PCICONF_PRIVALID 0x00000001 /* primary codec rdy */
! 130:
! 131: #define AUVIA_PLAY_BASE 0x00
! 132: #define AUVIA_RECORD_BASE 0x10
! 133:
! 134: #define AUVIA_RP_STAT 0x00
! 135: #define AUVIA_RPSTAT_INTR 0x03
! 136: #define AUVIA_RP_CONTROL 0x01
! 137: #define AUVIA_RPCTRL_START 0x80
! 138: #define AUVIA_RPCTRL_TERMINATE 0x40
! 139: #define AUVIA_RPCTRL_AUTOSTART 0x20
! 140: /* The following are 8233 specific */
! 141: #define AUVIA_RPCTRL_STOP 0x04
! 142: #define AUVIA_RPCTRL_EOL 0x02
! 143: #define AUVIA_RPCTRL_FLAG 0x01
! 144: #define AUVIA_RP_MODE 0x02
! 145: #define AUVIA_RPMODE_INTR_FLAG 0x01
! 146: #define AUVIA_RPMODE_INTR_EOL 0x02
! 147: #define AUVIA_RPMODE_STEREO 0x10
! 148: #define AUVIA_RPMODE_16BIT 0x20
! 149: #define AUVIA_RPMODE_AUTOSTART 0x80
! 150: #define AUVIA_RP_DMAOPS_BASE 0x04
! 151:
! 152: #define VIA8233_RP_DXS_LVOL 0x02
! 153: #define VIA8233_RP_DXS_RVOL 0x03
! 154: #define VIA8233_RP_RATEFMT 0x08
! 155: #define VIA8233_RATEFMT_48K 0xfffff
! 156: #define VIA8233_RATEFMT_STEREO 0x00100000
! 157: #define VIA8233_RATEFMT_16BIT 0x00200000
! 158:
! 159: #define VIA_RP_DMAOPS_COUNT 0x0C
! 160:
! 161: #define AUVIA_CODEC_CTL 0x80
! 162: #define AUVIA_CODEC_READ 0x00800000
! 163: #define AUVIA_CODEC_BUSY 0x01000000
! 164: #define AUVIA_CODEC_PRIVALID 0x02000000
! 165: #define AUVIA_CODEC_INDEX(x) ((x)<<16)
! 166:
! 167: #define TIMEOUT 50
! 168:
! 169: struct audio_hw_if auvia_hw_if = {
! 170: auvia_open,
! 171: auvia_close,
! 172: NULL, /* drain */
! 173: auvia_query_encoding,
! 174: auvia_set_params,
! 175: auvia_round_blocksize,
! 176: NULL, /* commit_settings */
! 177: NULL, /* init_output */
! 178: NULL, /* init_input */
! 179: NULL, /* start_output */
! 180: NULL, /* start_input */
! 181: auvia_halt_output,
! 182: auvia_halt_input,
! 183: NULL, /* speaker_ctl */
! 184: auvia_getdev,
! 185: NULL, /* setfd */
! 186: auvia_set_port,
! 187: auvia_get_port,
! 188: auvia_query_devinfo,
! 189: auvia_malloc,
! 190: auvia_free,
! 191: NULL, /* auvia_round_buffersize */
! 192: auvia_mappage,
! 193: auvia_get_props,
! 194: auvia_trigger_output,
! 195: auvia_trigger_input
! 196: };
! 197:
! 198: int auvia_attach_codec(void *, struct ac97_codec_if *);
! 199: int auvia_write_codec(void *, u_int8_t, u_int16_t);
! 200: int auvia_read_codec(void *, u_int8_t, u_int16_t *);
! 201: void auvia_reset_codec(void *);
! 202: int auvia_waitready_codec(struct auvia_softc *sc);
! 203: int auvia_waitvalid_codec(struct auvia_softc *sc);
! 204:
! 205: const struct pci_matchid auvia_devices[] = {
! 206: { PCI_VENDOR_VIATECH, PCI_PRODUCT_VIATECH_VT82C686A_AC97 },
! 207: { PCI_VENDOR_VIATECH, PCI_PRODUCT_VIATECH_VT8233_AC97 },
! 208: };
! 209:
! 210: int
! 211: auvia_match(struct device *parent, void *match, void *aux)
! 212: {
! 213: return (pci_matchbyid((struct pci_attach_args *)aux, auvia_devices,
! 214: sizeof(auvia_devices)/sizeof(auvia_devices[0])));
! 215: }
! 216:
! 217:
! 218: void
! 219: auvia_attach(struct device *parent, struct device *self, void *aux)
! 220: {
! 221: struct pci_attach_args *pa = aux;
! 222: struct auvia_softc *sc = (struct auvia_softc *) self;
! 223: const char *intrstr = NULL;
! 224: struct mixer_ctrl ctl;
! 225: pci_chipset_tag_t pc = pa->pa_pc;
! 226: pcitag_t pt = pa->pa_tag;
! 227: pci_intr_handle_t ih;
! 228: bus_size_t iosize;
! 229: pcireg_t pr;
! 230: int r, i;
! 231:
! 232: if (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_VIATECH_VT8233_AC97)
! 233: sc->sc_flags |= AUVIA_FLAGS_VT8233;
! 234:
! 235: if (pci_mapreg_map(pa, 0x10, PCI_MAPREG_TYPE_IO, 0, &sc->sc_iot,
! 236: &sc->sc_ioh, NULL, &iosize, 0)) {
! 237: printf(": can't map i/o space\n");
! 238: return;
! 239: }
! 240:
! 241: sc->sc_dmat = pa->pa_dmat;
! 242: sc->sc_pc = pc;
! 243: sc->sc_pt = pt;
! 244:
! 245: if (pci_intr_map(pa, &ih)) {
! 246: printf(": couldn't map interrupt\n");
! 247: bus_space_unmap(sc->sc_iot, sc->sc_ioh, iosize);
! 248: return;
! 249: }
! 250: intrstr = pci_intr_string(pc, ih);
! 251:
! 252: sc->sc_ih = pci_intr_establish(pc, ih, IPL_AUDIO, auvia_intr, sc,
! 253: sc->sc_dev.dv_xname);
! 254: if (sc->sc_ih == NULL) {
! 255: printf(": couldn't establish interrupt");
! 256: if (intrstr != NULL)
! 257: printf(" at %s", intrstr);
! 258: printf("\n");
! 259: bus_space_unmap(sc->sc_iot, sc->sc_ioh, iosize);
! 260: return;
! 261: }
! 262:
! 263: printf(": %s\n", intrstr);
! 264:
! 265: /* disable SBPro compat & others */
! 266: pr = pci_conf_read(pc, pt, AUVIA_PCICONF_JUNK);
! 267:
! 268: pr &= ~AUVIA_PCICONF_ENABLES; /* clear compat function enables */
! 269: /* XXX what to do about MIDI, FM, joystick? */
! 270:
! 271: pr |= (AUVIA_PCICONF_ACLINKENAB | AUVIA_PCICONF_ACNOTRST |
! 272: AUVIA_PCICONF_ACVSR | AUVIA_PCICONF_ACSGD);
! 273:
! 274: pr &= ~(AUVIA_PCICONF_ACFM | AUVIA_PCICONF_ACSB);
! 275:
! 276: pci_conf_write(pc, pt, AUVIA_PCICONF_JUNK, pr);
! 277:
! 278: sc->host_if.arg = sc;
! 279: sc->host_if.attach = auvia_attach_codec;
! 280: sc->host_if.read = auvia_read_codec;
! 281: sc->host_if.write = auvia_write_codec;
! 282: sc->host_if.reset = auvia_reset_codec;
! 283:
! 284: if ((r = ac97_attach(&sc->host_if)) != 0) {
! 285: printf("%s: can't attach codec (error 0x%X)\n",
! 286: sc->sc_dev.dv_xname, r);
! 287: pci_intr_disestablish(pc, sc->sc_ih);
! 288: bus_space_unmap(sc->sc_iot, sc->sc_ioh, iosize);
! 289: return;
! 290: }
! 291:
! 292: /* disable mutes */
! 293: for (i = 0; i < 4; i++) {
! 294: static struct {
! 295: char *class, *device;
! 296: } d[] = {
! 297: { AudioCoutputs, AudioNmaster},
! 298: { AudioCinputs, AudioNdac},
! 299: { AudioCinputs, AudioNcd},
! 300: { AudioCrecord, AudioNvolume},
! 301: };
! 302:
! 303: ctl.type = AUDIO_MIXER_ENUM;
! 304: ctl.un.ord = 0;
! 305:
! 306: ctl.dev = sc->codec_if->vtbl->get_portnum_by_name(sc->codec_if,
! 307: d[i].class, d[i].device, AudioNmute);
! 308: auvia_set_port(sc, &ctl);
! 309: }
! 310:
! 311: /* set a reasonable default volume */
! 312:
! 313: ctl.type = AUDIO_MIXER_VALUE;
! 314: ctl.un.value.num_channels = 2;
! 315: ctl.un.value.level[AUDIO_MIXER_LEVEL_LEFT] = \
! 316: ctl.un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = 199;
! 317:
! 318: ctl.dev = sc->codec_if->vtbl->get_portnum_by_name(sc->codec_if,
! 319: AudioCoutputs, AudioNmaster, NULL);
! 320: auvia_set_port(sc, &ctl);
! 321:
! 322: audio_attach_mi(&auvia_hw_if, sc, &sc->sc_dev);
! 323: }
! 324:
! 325:
! 326: int
! 327: auvia_attach_codec(void *addr, struct ac97_codec_if *cif)
! 328: {
! 329: struct auvia_softc *sc = addr;
! 330:
! 331: sc->codec_if = cif;
! 332:
! 333: return 0;
! 334: }
! 335:
! 336:
! 337: void
! 338: auvia_reset_codec(void *addr)
! 339: {
! 340: int i;
! 341: struct auvia_softc *sc = addr;
! 342: pcireg_t r;
! 343:
! 344: /* perform a codec cold reset */
! 345:
! 346: r = pci_conf_read(sc->sc_pc, sc->sc_pt, AUVIA_PCICONF_JUNK);
! 347:
! 348: r &= ~AUVIA_PCICONF_ACNOTRST; /* enable RESET (active low) */
! 349: pci_conf_write(sc->sc_pc, sc->sc_pt, AUVIA_PCICONF_JUNK, r);
! 350: delay(2);
! 351:
! 352: r |= AUVIA_PCICONF_ACNOTRST; /* disable RESET (inactive high) */
! 353: pci_conf_write(sc->sc_pc, sc->sc_pt, AUVIA_PCICONF_JUNK, r);
! 354: delay(200);
! 355:
! 356: for (i = 500000; i != 0 && !(pci_conf_read(sc->sc_pc, sc->sc_pt,
! 357: AUVIA_PCICONF_JUNK) & AUVIA_PCICONF_PRIVALID); i--)
! 358: DELAY(1);
! 359: if (i == 0)
! 360: printf("%s: codec reset timed out\n", sc->sc_dev.dv_xname);
! 361: }
! 362:
! 363:
! 364: int
! 365: auvia_waitready_codec(struct auvia_softc *sc)
! 366: {
! 367: int i;
! 368:
! 369: /* poll until codec not busy */
! 370: for (i = 0; (i < TIMEOUT) && (bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 371: AUVIA_CODEC_CTL) & AUVIA_CODEC_BUSY); i++)
! 372: delay(1);
! 373:
! 374: if (i >= TIMEOUT) {
! 375: printf("%s: codec busy\n", sc->sc_dev.dv_xname);
! 376: return 1;
! 377: }
! 378:
! 379: return 0;
! 380: }
! 381:
! 382:
! 383: int
! 384: auvia_waitvalid_codec(struct auvia_softc *sc)
! 385: {
! 386: int i;
! 387:
! 388: /* poll until codec valid */
! 389: for (i = 0; (i < TIMEOUT) && !(bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 390: AUVIA_CODEC_CTL) & AUVIA_CODEC_PRIVALID); i++)
! 391: delay(1);
! 392:
! 393: if (i >= TIMEOUT) {
! 394: printf("%s: codec invalid\n", sc->sc_dev.dv_xname);
! 395: return 1;
! 396: }
! 397:
! 398: return 0;
! 399: }
! 400:
! 401:
! 402: int
! 403: auvia_write_codec(void *addr, u_int8_t reg, u_int16_t val)
! 404: {
! 405: struct auvia_softc *sc = addr;
! 406:
! 407: if (auvia_waitready_codec(sc))
! 408: return 1;
! 409:
! 410: bus_space_write_4(sc->sc_iot, sc->sc_ioh, AUVIA_CODEC_CTL,
! 411: AUVIA_CODEC_PRIVALID | AUVIA_CODEC_INDEX(reg) | val);
! 412:
! 413: return 0;
! 414: }
! 415:
! 416:
! 417: int
! 418: auvia_read_codec(void *addr, u_int8_t reg, u_int16_t *val)
! 419: {
! 420: struct auvia_softc *sc = addr;
! 421:
! 422: if (auvia_waitready_codec(sc))
! 423: return 1;
! 424:
! 425: bus_space_write_4(sc->sc_iot, sc->sc_ioh, AUVIA_CODEC_CTL,
! 426: AUVIA_CODEC_PRIVALID | AUVIA_CODEC_READ | AUVIA_CODEC_INDEX(reg));
! 427:
! 428: if (auvia_waitready_codec(sc))
! 429: return 1;
! 430:
! 431: if (auvia_waitvalid_codec(sc))
! 432: return 1;
! 433:
! 434: *val = bus_space_read_2(sc->sc_iot, sc->sc_ioh, AUVIA_CODEC_CTL);
! 435:
! 436: return 0;
! 437: }
! 438:
! 439:
! 440: int
! 441: auvia_open(void *addr, int flags)
! 442: {
! 443: return 0;
! 444: }
! 445:
! 446:
! 447: void
! 448: auvia_close(void *addr)
! 449: {
! 450: struct auvia_softc *sc = addr;
! 451:
! 452: auvia_halt_output(sc);
! 453: auvia_halt_input(sc);
! 454:
! 455: sc->sc_play.sc_intr = NULL;
! 456: sc->sc_record.sc_intr = NULL;
! 457: }
! 458:
! 459:
! 460: int
! 461: auvia_query_encoding(void *addr, struct audio_encoding *fp)
! 462: {
! 463: switch (fp->index) {
! 464: case 0:
! 465: strlcpy(fp->name, AudioEulinear, sizeof fp->name);
! 466: fp->encoding = AUDIO_ENCODING_ULINEAR;
! 467: fp->precision = 8;
! 468: fp->flags = 0;
! 469: return (0);
! 470: case 1:
! 471: strlcpy(fp->name, AudioEmulaw, sizeof fp->name);
! 472: fp->encoding = AUDIO_ENCODING_ULAW;
! 473: fp->precision = 8;
! 474: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 475: return (0);
! 476: case 2:
! 477: strlcpy(fp->name, AudioEalaw, sizeof fp->name);
! 478: fp->encoding = AUDIO_ENCODING_ALAW;
! 479: fp->precision = 8;
! 480: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 481: return (0);
! 482: case 3:
! 483: strlcpy(fp->name, AudioEslinear, sizeof fp->name);
! 484: fp->encoding = AUDIO_ENCODING_SLINEAR;
! 485: fp->precision = 8;
! 486: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 487: return (0);
! 488: case 4:
! 489: strlcpy(fp->name, AudioEslinear_le, sizeof fp->name);
! 490: fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
! 491: fp->precision = 16;
! 492: fp->flags = 0;
! 493: return (0);
! 494: case 5:
! 495: strlcpy(fp->name, AudioEulinear_le, sizeof fp->name);
! 496: fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
! 497: fp->precision = 16;
! 498: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 499: return (0);
! 500: case 6:
! 501: strlcpy(fp->name, AudioEslinear_be, sizeof fp->name);
! 502: fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
! 503: fp->precision = 16;
! 504: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 505: return (0);
! 506: case 7:
! 507: strlcpy(fp->name, AudioEulinear_be, sizeof fp->name);
! 508: fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
! 509: fp->precision = 16;
! 510: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 511: return (0);
! 512: default:
! 513: return (EINVAL);
! 514: }
! 515: }
! 516:
! 517:
! 518: int
! 519: auvia_set_params(void *addr, int setmode, int usemode,
! 520: struct audio_params *play, struct audio_params *rec)
! 521: {
! 522: struct auvia_softc *sc = addr;
! 523: struct audio_params *p;
! 524: u_int16_t regval;
! 525: int mode, base;
! 526:
! 527: /* for mode in (RECORD, PLAY) */
! 528: for (mode = AUMODE_RECORD; mode != -1;
! 529: mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) {
! 530: if ((setmode & mode) == 0)
! 531: continue;
! 532:
! 533: if (mode == AUMODE_PLAY) {
! 534: p = play;
! 535: base = AUVIA_PLAY_BASE;
! 536: } else {
! 537: p = rec;
! 538: base = AUVIA_RECORD_BASE;
! 539: }
! 540:
! 541: if (sc->sc_flags & AUVIA_FLAGS_VT8233) {
! 542: u_int32_t v = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 543: base + VIA8233_RP_RATEFMT) & ~(VIA8233_RATEFMT_48K
! 544: | VIA8233_RATEFMT_STEREO | VIA8233_RATEFMT_16BIT);
! 545:
! 546: v |= VIA8233_RATEFMT_48K *
! 547: (p->sample_rate / 20) / (48000 / 20);
! 548:
! 549: if (p->channels == 2)
! 550: v |= VIA8233_RATEFMT_STEREO;
! 551: if (p->precision == 16)
! 552: v |= VIA8233_RATEFMT_16BIT;
! 553:
! 554: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 555: base + VIA8233_RP_RATEFMT, v);
! 556: }
! 557:
! 558: if (ac97_set_rate(sc->codec_if, p, mode))
! 559: return (EINVAL);
! 560:
! 561: if ((p->precision != 8 && p->precision != 16) ||
! 562: (p->channels != 1 && p->channels != 2))
! 563: return (EINVAL);
! 564:
! 565: p->factor = 1;
! 566: p->sw_code = 0;
! 567: switch (p->encoding) {
! 568: case AUDIO_ENCODING_SLINEAR_BE:
! 569: if (p->precision == 16)
! 570: p->sw_code = swap_bytes;
! 571: else
! 572: p->sw_code = change_sign8;
! 573: break;
! 574: case AUDIO_ENCODING_SLINEAR_LE:
! 575: if (p->precision != 16)
! 576: p->sw_code = change_sign8;
! 577: break;
! 578: case AUDIO_ENCODING_ULINEAR_BE:
! 579: if (p->precision == 16)
! 580: p->sw_code = mode == AUMODE_PLAY?
! 581: swap_bytes_change_sign16_le :
! 582: change_sign16_swap_bytes_le;
! 583: break;
! 584: case AUDIO_ENCODING_ULINEAR_LE:
! 585: if (p->precision == 16)
! 586: p->sw_code = change_sign16_le;
! 587: break;
! 588: case AUDIO_ENCODING_ULAW:
! 589: if (mode == AUMODE_PLAY) {
! 590: p->factor = 2;
! 591: p->sw_code = mulaw_to_slinear16_le;
! 592: } else
! 593: p->sw_code = ulinear8_to_mulaw;
! 594: break;
! 595: case AUDIO_ENCODING_ALAW:
! 596: if (mode == AUMODE_PLAY) {
! 597: p->factor = 2;
! 598: p->sw_code = alaw_to_slinear16_le;
! 599: } else
! 600: p->sw_code = ulinear8_to_alaw;
! 601: break;
! 602: case AUDIO_ENCODING_SLINEAR:
! 603: case AUDIO_ENCODING_ULINEAR:
! 604: break;
! 605: default:
! 606: return (EINVAL);
! 607: }
! 608:
! 609: regval = (p->channels == 2 ? AUVIA_RPMODE_STEREO : 0)
! 610: | (p->precision * p->factor == 16 ?
! 611: AUVIA_RPMODE_16BIT : 0)
! 612: | AUVIA_RPMODE_INTR_FLAG | AUVIA_RPMODE_INTR_EOL
! 613: | AUVIA_RPMODE_AUTOSTART;
! 614:
! 615: if (mode == AUMODE_PLAY)
! 616: sc->sc_play.sc_reg = regval;
! 617: else
! 618: sc->sc_record.sc_reg = regval;
! 619: }
! 620:
! 621: return 0;
! 622: }
! 623:
! 624:
! 625: int
! 626: auvia_round_blocksize(void *addr, int blk)
! 627: {
! 628: return ((blk + 31) & -32);
! 629: }
! 630:
! 631:
! 632: int
! 633: auvia_halt_output(void *addr)
! 634: {
! 635: struct auvia_softc *sc = addr;
! 636:
! 637: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 638: AUVIA_PLAY_BASE + AUVIA_RP_CONTROL, AUVIA_RPCTRL_TERMINATE);
! 639:
! 640: return 0;
! 641: }
! 642:
! 643:
! 644: int
! 645: auvia_halt_input(void *addr)
! 646: {
! 647: struct auvia_softc *sc = addr;
! 648:
! 649: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 650: AUVIA_RECORD_BASE + AUVIA_RP_CONTROL, AUVIA_RPCTRL_TERMINATE);
! 651:
! 652: return 0;
! 653: }
! 654:
! 655:
! 656: int
! 657: auvia_getdev(void *addr, struct audio_device *retp)
! 658: {
! 659: struct auvia_softc *sc = addr;
! 660:
! 661: if (retp) {
! 662: strncpy(retp->name,
! 663: sc->sc_flags & AUVIA_FLAGS_VT8233? "VIA VT8233" :
! 664: "VIA VT82C686A", sizeof(retp->name));
! 665: strncpy(retp->version, sc->sc_revision, sizeof(retp->version));
! 666: strncpy(retp->config, "auvia", sizeof(retp->config));
! 667: }
! 668:
! 669: return 0;
! 670: }
! 671:
! 672:
! 673: int
! 674: auvia_set_port(void *addr, mixer_ctrl_t *cp)
! 675: {
! 676: struct auvia_softc *sc = addr;
! 677:
! 678: return (sc->codec_if->vtbl->mixer_set_port(sc->codec_if, cp));
! 679: }
! 680:
! 681:
! 682: int
! 683: auvia_get_port(void *addr, mixer_ctrl_t *cp)
! 684: {
! 685: struct auvia_softc *sc = addr;
! 686:
! 687: return (sc->codec_if->vtbl->mixer_get_port(sc->codec_if, cp));
! 688: }
! 689:
! 690:
! 691: int
! 692: auvia_query_devinfo(void *addr, mixer_devinfo_t *dip)
! 693: {
! 694: struct auvia_softc *sc = addr;
! 695:
! 696: return (sc->codec_if->vtbl->query_devinfo(sc->codec_if, dip));
! 697: }
! 698:
! 699:
! 700: void *
! 701: auvia_malloc(void *addr, int direction, size_t size, int pool, int flags)
! 702: {
! 703: struct auvia_softc *sc = addr;
! 704: struct auvia_dma *p;
! 705: int error;
! 706: int rseg;
! 707:
! 708: p = malloc(sizeof(*p), pool, flags);
! 709: if (!p)
! 710: return 0;
! 711:
! 712: p->size = size;
! 713: if ((error = bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, &p->seg,
! 714: 1, &rseg, BUS_DMA_NOWAIT)) != 0) {
! 715: printf("%s: unable to allocate dma, error = %d\n",
! 716: sc->sc_dev.dv_xname, error);
! 717: goto fail_alloc;
! 718: }
! 719:
! 720: if ((error = bus_dmamem_map(sc->sc_dmat, &p->seg, rseg, size, &p->addr,
! 721: BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) != 0) {
! 722: printf("%s: unable to map dma, error = %d\n",
! 723: sc->sc_dev.dv_xname, error);
! 724: goto fail_map;
! 725: }
! 726:
! 727: if ((error = bus_dmamap_create(sc->sc_dmat, size, 1, size, 0,
! 728: BUS_DMA_NOWAIT, &p->map)) != 0) {
! 729: printf("%s: unable to create dma map, error = %d\n",
! 730: sc->sc_dev.dv_xname, error);
! 731: goto fail_create;
! 732: }
! 733:
! 734: if ((error = bus_dmamap_load(sc->sc_dmat, p->map, p->addr, size, NULL,
! 735: BUS_DMA_NOWAIT)) != 0) {
! 736: printf("%s: unable to load dma map, error = %d\n",
! 737: sc->sc_dev.dv_xname, error);
! 738: goto fail_load;
! 739: }
! 740:
! 741: p->next = sc->sc_dmas;
! 742: sc->sc_dmas = p;
! 743:
! 744: return p->addr;
! 745:
! 746:
! 747: fail_load:
! 748: bus_dmamap_destroy(sc->sc_dmat, p->map);
! 749: fail_create:
! 750: bus_dmamem_unmap(sc->sc_dmat, p->addr, size);
! 751: fail_map:
! 752: bus_dmamem_free(sc->sc_dmat, &p->seg, 1);
! 753: fail_alloc:
! 754: free(p, pool);
! 755: return 0;
! 756: }
! 757:
! 758:
! 759: void
! 760: auvia_free(void *addr, void *ptr, int pool)
! 761: {
! 762: struct auvia_softc *sc = addr;
! 763: struct auvia_dma **pp, *p;
! 764:
! 765: for (pp = &(sc->sc_dmas); (p = *pp) != NULL; pp = &p->next)
! 766: if (p->addr == ptr) {
! 767: bus_dmamap_unload(sc->sc_dmat, p->map);
! 768: bus_dmamap_destroy(sc->sc_dmat, p->map);
! 769: bus_dmamem_unmap(sc->sc_dmat, p->addr, p->size);
! 770: bus_dmamem_free(sc->sc_dmat, &p->seg, 1);
! 771:
! 772: *pp = p->next;
! 773: free(p, pool);
! 774: return;
! 775: }
! 776:
! 777: panic("auvia_free: trying to free unallocated memory");
! 778: }
! 779:
! 780: paddr_t
! 781: auvia_mappage(void *addr, void *mem, off_t off, int prot)
! 782: {
! 783: struct auvia_softc *sc = addr;
! 784: struct auvia_dma *p;
! 785:
! 786: if (off < 0)
! 787: return -1;
! 788:
! 789: for (p = sc->sc_dmas; p && p->addr != mem; p = p->next)
! 790: ;
! 791:
! 792: if (!p)
! 793: return -1;
! 794:
! 795: return bus_dmamem_mmap(sc->sc_dmat, &p->seg, 1, off, prot,
! 796: BUS_DMA_WAITOK);
! 797: }
! 798:
! 799:
! 800: int
! 801: auvia_get_props(void *addr)
! 802: {
! 803: return (AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT |
! 804: AUDIO_PROP_FULLDUPLEX);
! 805: }
! 806:
! 807:
! 808: int
! 809: auvia_build_dma_ops(struct auvia_softc *sc, struct auvia_softc_chan *ch,
! 810: struct auvia_dma *p, void *start, void *end, int blksize)
! 811: {
! 812: struct auvia_dma_op *op;
! 813: struct auvia_dma *dp;
! 814: bus_addr_t s;
! 815: size_t l;
! 816: int segs;
! 817:
! 818: s = p->map->dm_segs[0].ds_addr;
! 819: l = (vaddr_t)end - (vaddr_t)start;
! 820: segs = howmany(l, blksize);
! 821:
! 822: if (segs > ch->sc_dma_op_count) {
! 823: /* if old list was too small, free it */
! 824: if (ch->sc_dma_ops)
! 825: auvia_free(sc, ch->sc_dma_ops, M_DEVBUF);
! 826:
! 827: ch->sc_dma_ops = auvia_malloc(sc, 0,
! 828: sizeof(struct auvia_dma_op) * segs, M_DEVBUF, M_WAITOK);
! 829:
! 830: for (dp = sc->sc_dmas; dp &&
! 831: dp->addr != (void *)(ch->sc_dma_ops); dp = dp->next)
! 832: ;
! 833:
! 834: if (!dp)
! 835: panic("%s: build_dma_ops: where'd my memory go??? "
! 836: "address (%p)", sc->sc_dev.dv_xname,
! 837: ch->sc_dma_ops);
! 838:
! 839: ch->sc_dma_op_count = segs;
! 840: ch->sc_dma_ops_dma = dp;
! 841: }
! 842:
! 843: dp = ch->sc_dma_ops_dma;
! 844: op = ch->sc_dma_ops;
! 845:
! 846: while (l) {
! 847: op->ptr = htole32(s);
! 848: l = l - min(l, blksize);
! 849: /* if last block */
! 850: op->flags = htole32((l? AUVIA_DMAOP_FLAG : AUVIA_DMAOP_EOL) | blksize);
! 851: s += blksize;
! 852: op++;
! 853: }
! 854:
! 855: return 0;
! 856: }
! 857:
! 858:
! 859: int
! 860: auvia_trigger_output(void *addr, void *start, void *end, int blksize,
! 861: void (*intr)(void *), void *arg, struct audio_params *param)
! 862: {
! 863: struct auvia_softc *sc = addr;
! 864: struct auvia_softc_chan *ch = &(sc->sc_play);
! 865: struct auvia_dma *p;
! 866:
! 867: for (p = sc->sc_dmas; p && p->addr != start; p = p->next)
! 868: ;
! 869:
! 870: if (!p)
! 871: panic("auvia_trigger_output: request with bad start "
! 872: "address (%p)", start);
! 873:
! 874: if (auvia_build_dma_ops(sc, ch, p, start, end, blksize)) {
! 875: return 1;
! 876: }
! 877:
! 878: ch->sc_intr = intr;
! 879: ch->sc_arg = arg;
! 880:
! 881: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 882: AUVIA_PLAY_BASE + AUVIA_RP_DMAOPS_BASE,
! 883: ch->sc_dma_ops_dma->map->dm_segs[0].ds_addr);
! 884:
! 885: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 886: AUVIA_PLAY_BASE + AUVIA_RP_MODE, ch->sc_reg);
! 887:
! 888: if (sc->sc_flags & AUVIA_FLAGS_VT8233) {
! 889: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 890: AUVIA_PLAY_BASE + VIA8233_RP_DXS_LVOL, 0);
! 891: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 892: AUVIA_PLAY_BASE + VIA8233_RP_DXS_RVOL, 0);
! 893: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 894: AUVIA_PLAY_BASE + AUVIA_RP_CONTROL,
! 895: AUVIA_RPCTRL_START | AUVIA_RPCTRL_AUTOSTART |
! 896: AUVIA_RPCTRL_STOP | AUVIA_RPCTRL_EOL | AUVIA_RPCTRL_FLAG);
! 897: } else
! 898: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 899: AUVIA_PLAY_BASE + AUVIA_RP_CONTROL, AUVIA_RPCTRL_START);
! 900:
! 901: return 0;
! 902: }
! 903:
! 904:
! 905: int
! 906: auvia_trigger_input(void *addr, void *start, void *end, int blksize,
! 907: void (*intr)(void *), void *arg, struct audio_params *param)
! 908: {
! 909: struct auvia_softc *sc = addr;
! 910: struct auvia_softc_chan *ch = &(sc->sc_record);
! 911: struct auvia_dma *p;
! 912:
! 913: for (p = sc->sc_dmas; p && p->addr != start; p = p->next)
! 914: ;
! 915:
! 916: if (!p)
! 917: panic("auvia_trigger_input: request with bad start "
! 918: "address (%p)", start);
! 919:
! 920: if (auvia_build_dma_ops(sc, ch, p, start, end, blksize))
! 921: return 1;
! 922:
! 923: ch->sc_intr = intr;
! 924: ch->sc_arg = arg;
! 925:
! 926: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 927: AUVIA_RECORD_BASE + AUVIA_RP_DMAOPS_BASE,
! 928: ch->sc_dma_ops_dma->map->dm_segs[0].ds_addr);
! 929: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 930: AUVIA_RECORD_BASE + AUVIA_RP_MODE, ch->sc_reg);
! 931:
! 932: if (sc->sc_flags & AUVIA_FLAGS_VT8233) {
! 933: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 934: AUVIA_RECORD_BASE + VIA8233_RP_DXS_LVOL, 0);
! 935: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 936: AUVIA_RECORD_BASE + VIA8233_RP_DXS_RVOL, 0);
! 937: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 938: AUVIA_RECORD_BASE + AUVIA_RP_CONTROL,
! 939: AUVIA_RPCTRL_START | AUVIA_RPCTRL_AUTOSTART |
! 940: AUVIA_RPCTRL_STOP | AUVIA_RPCTRL_EOL | AUVIA_RPCTRL_FLAG);
! 941: } else
! 942: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 943: AUVIA_RECORD_BASE + AUVIA_RP_CONTROL, AUVIA_RPCTRL_START);
! 944:
! 945: return 0;
! 946: }
! 947:
! 948:
! 949: int
! 950: auvia_intr(void *arg)
! 951: {
! 952: struct auvia_softc *sc = arg;
! 953: u_int8_t r;
! 954: int i = 0;
! 955:
! 956: r = bus_space_read_1(sc->sc_iot, sc->sc_ioh,
! 957: AUVIA_RECORD_BASE + AUVIA_RP_STAT);
! 958: if (r & AUVIA_RPSTAT_INTR) {
! 959: if (sc->sc_record.sc_intr)
! 960: sc->sc_record.sc_intr(sc->sc_record.sc_arg);
! 961:
! 962: /* clear interrupts */
! 963: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 964: AUVIA_RECORD_BASE + AUVIA_RP_STAT, AUVIA_RPSTAT_INTR);
! 965:
! 966: i++;
! 967: }
! 968: r = bus_space_read_1(sc->sc_iot, sc->sc_ioh,
! 969: AUVIA_PLAY_BASE + AUVIA_RP_STAT);
! 970: if (r & AUVIA_RPSTAT_INTR) {
! 971: if (sc->sc_play.sc_intr)
! 972: sc->sc_play.sc_intr(sc->sc_play.sc_arg);
! 973:
! 974: /* clear interrupts */
! 975: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 976: AUVIA_PLAY_BASE + AUVIA_RP_STAT, AUVIA_RPSTAT_INTR);
! 977:
! 978: i++;
! 979: }
! 980:
! 981: return (i? 1 : 0);
! 982: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to auvia.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pci