Annotation of sys/dev/pci/autri.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: autri.c,v 1.20 2007/05/26 00:36:03 krw Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2001 SOMEYA Yoshihiko and KUROSAWA Takahiro.
! 5: * All rights reserved.
! 6: *
! 7: * Redistribution and use in source and binary forms, with or without
! 8: * modification, are permitted provided that the following conditions
! 9: * are met:
! 10: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: * 2. Redistributions in binary form must reproduce the above copyright
! 13: * notice, this list of conditions and the following disclaimer in the
! 14: * documentation and/or other materials provided with the distribution.
! 15: *
! 16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 17: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 18: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 19: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 20: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 21: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 22: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 23: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 24: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 25: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 26: */
! 27:
! 28: /*
! 29: * Trident 4DWAVE-DX/NX, SiS 7018, ALi M5451 Sound Driver
! 30: *
! 31: * The register information is taken from the ALSA driver.
! 32: *
! 33: * Documentation links:
! 34: * - ftp://ftp.alsa-project.org/pub/manuals/trident/
! 35: */
! 36:
! 37: #include "midi.h"
! 38:
! 39: #include <sys/param.h>
! 40: #include <sys/systm.h>
! 41: #include <sys/kernel.h>
! 42: #include <sys/fcntl.h>
! 43: #include <sys/malloc.h>
! 44: #include <sys/device.h>
! 45: #include <sys/proc.h>
! 46:
! 47: #include <dev/pci/pcidevs.h>
! 48: #include <dev/pci/pcireg.h>
! 49: #include <dev/pci/pcivar.h>
! 50:
! 51: #include <sys/audioio.h>
! 52: #include <dev/audio_if.h>
! 53: #include <dev/midi_if.h>
! 54: #include <dev/mulaw.h>
! 55: #include <dev/auconv.h>
! 56: #include <dev/ic/ac97.h>
! 57: #include <dev/ic/mpuvar.h>
! 58:
! 59: #include <machine/bus.h>
! 60: #include <machine/intr.h>
! 61:
! 62: #include <dev/pci/autrireg.h>
! 63: #include <dev/pci/autrivar.h>
! 64:
! 65: #ifdef AUDIO_DEBUG
! 66: # define DPRINTF(x) if (autridebug) printf x
! 67: # define DPRINTFN(n,x) if (autridebug > (n)) printf x
! 68: int autridebug = 0;
! 69: #else
! 70: # define DPRINTF(x)
! 71: # define DPRINTFN(n,x)
! 72: #endif
! 73:
! 74: int autri_match(struct device *, void *, void *);
! 75: void autri_attach(struct device *, struct device *, void *);
! 76: int autri_intr(void *);
! 77:
! 78: #define DMAADDR(p) ((p)->map->dm_segs[0].ds_addr)
! 79: #define KERNADDR(p) ((void *)((p)->addr))
! 80:
! 81: int autri_allocmem(struct autri_softc *, size_t, size_t, struct autri_dma *);
! 82: int autri_freemem(struct autri_softc *, struct autri_dma *);
! 83:
! 84: #define TWRITE1(sc, r, x) bus_space_write_1((sc)->memt, (sc)->memh, (r), (x))
! 85: #define TWRITE2(sc, r, x) bus_space_write_2((sc)->memt, (sc)->memh, (r), (x))
! 86: #define TWRITE4(sc, r, x) bus_space_write_4((sc)->memt, (sc)->memh, (r), (x))
! 87: #define TREAD1(sc, r) bus_space_read_1((sc)->memt, (sc)->memh, (r))
! 88: #define TREAD2(sc, r) bus_space_read_2((sc)->memt, (sc)->memh, (r))
! 89: #define TREAD4(sc, r) bus_space_read_4((sc)->memt, (sc)->memh, (r))
! 90:
! 91: static __inline void autri_reg_set_1(struct autri_softc *, int, uint8_t);
! 92: static __inline void autri_reg_clear_1(struct autri_softc *, int, uint8_t);
! 93: static __inline void autri_reg_set_4(struct autri_softc *, int, uint32_t);
! 94: static __inline void autri_reg_clear_4(struct autri_softc *, int, uint32_t);
! 95:
! 96: int autri_attach_codec(void *sc, struct ac97_codec_if *);
! 97: int autri_read_codec(void *sc, u_int8_t a, u_int16_t *d);
! 98: int autri_write_codec(void *sc, u_int8_t a, u_int16_t d);
! 99: void autri_reset_codec(void *sc);
! 100: enum ac97_host_flags autri_flags_codec(void *);
! 101:
! 102: void autri_powerhook(int why,void *addr);
! 103: int autri_init(void *sc);
! 104: struct autri_dma *autri_find_dma(struct autri_softc *, void *);
! 105: void autri_setup_channel(struct autri_softc *sc,int mode,
! 106: struct audio_params *param);
! 107: void autri_enable_interrupt(struct autri_softc *sc, int ch);
! 108: void autri_disable_interrupt(struct autri_softc *sc, int ch);
! 109: void autri_startch(struct autri_softc *sc, int ch, int ch_intr);
! 110: void autri_stopch(struct autri_softc *sc, int ch, int ch_intr);
! 111: void autri_enable_loop_interrupt(void *sc);
! 112: #if 0
! 113: void autri_disable_loop_interrupt(void *sc);
! 114: #endif
! 115:
! 116: struct cfdriver autri_cd = {
! 117: NULL, "autri", DV_DULL
! 118: };
! 119:
! 120: struct cfattach autri_ca = {
! 121: sizeof(struct autri_softc), autri_match, autri_attach
! 122: };
! 123:
! 124: int autri_open(void *, int);
! 125: void autri_close(void *);
! 126: int autri_query_encoding(void *, struct audio_encoding *);
! 127: int autri_set_params(void *, int, int, struct audio_params *,
! 128: struct audio_params *);
! 129: int autri_round_blocksize(void *, int);
! 130: int autri_trigger_output(void *, void *, void *, int, void (*)(void *),
! 131: void *, struct audio_params *);
! 132: int autri_trigger_input(void *, void *, void *, int, void (*)(void *),
! 133: void *, struct audio_params *);
! 134: int autri_halt_output(void *);
! 135: int autri_halt_input(void *);
! 136: int autri_getdev(void *, struct audio_device *);
! 137: int autri_mixer_set_port(void *, mixer_ctrl_t *);
! 138: int autri_mixer_get_port(void *, mixer_ctrl_t *);
! 139: void *autri_malloc(void *, int, size_t, int, int);
! 140: void autri_free(void *, void *, int);
! 141: paddr_t autri_mappage(void *, void *, off_t, int);
! 142: int autri_get_props(void *);
! 143: int autri_query_devinfo(void *addr, mixer_devinfo_t *dip);
! 144:
! 145: int autri_get_portnum_by_name(struct autri_softc *, char *, char *, char *);
! 146:
! 147: struct audio_hw_if autri_hw_if = {
! 148: autri_open,
! 149: autri_close,
! 150: NULL, /* drain */
! 151: autri_query_encoding,
! 152: autri_set_params,
! 153: autri_round_blocksize,
! 154: NULL, /* commit_settings */
! 155: NULL, /* init_output */
! 156: NULL, /* init_input */
! 157: NULL, /* start_output */
! 158: NULL, /* start_input */
! 159: autri_halt_output,
! 160: autri_halt_input,
! 161: NULL, /* speaker_ctl */
! 162: autri_getdev,
! 163: NULL, /* setfd */
! 164: autri_mixer_set_port,
! 165: autri_mixer_get_port,
! 166: autri_query_devinfo,
! 167: autri_malloc,
! 168: autri_free,
! 169: NULL,
! 170: autri_mappage,
! 171: autri_get_props,
! 172: autri_trigger_output,
! 173: autri_trigger_input,
! 174: };
! 175:
! 176: #if NMIDI > 0
! 177: void autri_midi_close(void *);
! 178: void autri_midi_getinfo(void *, struct midi_info *);
! 179: int autri_midi_open(void *, int, void (*)(void *, int),
! 180: void (*)(void *), void *);
! 181: int autri_midi_output(void *, int);
! 182:
! 183: struct midi_hw_if autri_midi_hw_if = {
! 184: autri_midi_open,
! 185: autri_midi_close,
! 186: autri_midi_output,
! 187: NULL, /* flush */
! 188: autri_midi_getinfo,
! 189: NULL, /* ioctl */
! 190: };
! 191: #endif
! 192:
! 193: /*
! 194: * register set/clear bit
! 195: */
! 196: static __inline void
! 197: autri_reg_set_1(sc, no, mask)
! 198: struct autri_softc *sc;
! 199: int no;
! 200: uint8_t mask;
! 201: {
! 202: bus_space_write_1(sc->memt, sc->memh, no,
! 203: (bus_space_read_1(sc->memt, sc->memh, no) | mask));
! 204: }
! 205:
! 206: static __inline void
! 207: autri_reg_clear_1(sc, no, mask)
! 208: struct autri_softc *sc;
! 209: int no;
! 210: uint8_t mask;
! 211: {
! 212: bus_space_write_1(sc->memt, sc->memh, no,
! 213: (bus_space_read_1(sc->memt, sc->memh, no) & ~mask));
! 214: }
! 215:
! 216: static __inline void
! 217: autri_reg_set_4(sc, no, mask)
! 218: struct autri_softc *sc;
! 219: int no;
! 220: uint32_t mask;
! 221: {
! 222: bus_space_write_4(sc->memt, sc->memh, no,
! 223: (bus_space_read_4(sc->memt, sc->memh, no) | mask));
! 224: }
! 225:
! 226: static __inline void
! 227: autri_reg_clear_4(sc, no, mask)
! 228: struct autri_softc *sc;
! 229: int no;
! 230: uint32_t mask;
! 231: {
! 232: bus_space_write_4(sc->memt, sc->memh, no,
! 233: (bus_space_read_4(sc->memt, sc->memh, no) & ~mask));
! 234: }
! 235:
! 236: /*
! 237: * AC97 codec
! 238: */
! 239: int
! 240: autri_attach_codec(sc_, codec_if)
! 241: void *sc_;
! 242: struct ac97_codec_if *codec_if;
! 243: {
! 244: struct autri_codec_softc *sc = sc_;
! 245:
! 246: DPRINTF(("autri_attach_codec()\n"));
! 247:
! 248: sc->codec_if = codec_if;
! 249: return 0;
! 250: }
! 251:
! 252: int
! 253: autri_read_codec(sc_, index, data)
! 254: void *sc_;
! 255: u_int8_t index;
! 256: u_int16_t *data;
! 257: {
! 258: struct autri_codec_softc *codec = sc_;
! 259: struct autri_softc *sc = codec->sc;
! 260: u_int32_t status, addr, cmd, busy;
! 261: u_int16_t count;
! 262:
! 263: /*DPRINTF(("sc->sc->type : 0x%X",sc->sc->type));*/
! 264:
! 265: switch (sc->sc_devid) {
! 266: case AUTRI_DEVICE_ID_4DWAVE_DX:
! 267: addr = AUTRI_DX_ACR1;
! 268: cmd = AUTRI_DX_ACR1_CMD_READ;
! 269: busy = AUTRI_DX_ACR1_BUSY_READ;
! 270: break;
! 271: case AUTRI_DEVICE_ID_4DWAVE_NX:
! 272: addr = AUTRI_NX_ACR2;
! 273: cmd = AUTRI_NX_ACR2_CMD_READ;
! 274: busy = AUTRI_NX_ACR2_BUSY_READ | AUTRI_NX_ACR2_RECV_WAIT;
! 275: break;
! 276: case AUTRI_DEVICE_ID_SIS_7018:
! 277: addr = AUTRI_SIS_ACRD;
! 278: cmd = AUTRI_SIS_ACRD_CMD_READ;
! 279: busy = AUTRI_SIS_ACRD_BUSY_READ | AUTRI_SIS_ACRD_AUDIO_BUSY;
! 280: break;
! 281: case AUTRI_DEVICE_ID_ALI_M5451:
! 282: if (sc->sc_revision > 0x01)
! 283: addr = AUTRI_ALI_ACWR;
! 284: else
! 285: addr = AUTRI_ALI_ACRD;
! 286: cmd = AUTRI_ALI_ACRD_CMD_READ;
! 287: busy = AUTRI_ALI_ACRD_BUSY_READ;
! 288: break;
! 289: default:
! 290: printf("%s: autri_read_codec : unknown device\n",
! 291: sc->sc_dev.dv_xname);
! 292: return -1;
! 293: }
! 294:
! 295: /* wait for 'Ready to Read' */
! 296: for (count=0; count < 0xffff; count++) {
! 297: if ((TREAD4(sc, addr) & busy) == 0)
! 298: break;
! 299: DELAY(1);
! 300: }
! 301:
! 302: if (count == 0xffff) {
! 303: printf("%s: Codec timeout. Busy reading AC97 codec.\n",
! 304: sc->sc_dev.dv_xname);
! 305: return -1;
! 306: }
! 307:
! 308: /* send Read Command to AC97 */
! 309: TWRITE4(sc, addr, (index & 0x7f) | cmd);
! 310:
! 311: /* wait for 'Returned data is available' */
! 312: for (count=0; count < 0xffff; count++) {
! 313: status = TREAD4(sc, addr);
! 314: if ((status & busy) == 0)
! 315: break;
! 316: DELAY(1);
! 317: }
! 318:
! 319: if (count == 0xffff) {
! 320: printf("%s: Codec timeout. Busy reading AC97 codec.\n",
! 321: sc->sc_dev.dv_xname);
! 322: return -1;
! 323: }
! 324:
! 325: *data = (status >> 16) & 0x0000ffff;
! 326: /*DPRINTF(("autri_read_codec(0x%X) return 0x%X\n",reg,*data));*/
! 327: return 0;
! 328: }
! 329:
! 330: int
! 331: autri_write_codec(sc_, index, data)
! 332: void *sc_;
! 333: u_int8_t index;
! 334: u_int16_t data;
! 335: {
! 336: struct autri_codec_softc *codec = sc_;
! 337: struct autri_softc *sc = codec->sc;
! 338: u_int32_t addr, cmd, busy;
! 339: u_int16_t count;
! 340:
! 341: /*DPRINTF(("autri_write_codec(0x%X,0x%X)\n",index,data));*/
! 342:
! 343: switch (sc->sc_devid) {
! 344: case AUTRI_DEVICE_ID_4DWAVE_DX:
! 345: addr = AUTRI_DX_ACR0;
! 346: cmd = AUTRI_DX_ACR0_CMD_WRITE;
! 347: busy = AUTRI_DX_ACR0_BUSY_WRITE;
! 348: break;
! 349: case AUTRI_DEVICE_ID_4DWAVE_NX:
! 350: addr = AUTRI_NX_ACR1;
! 351: cmd = AUTRI_NX_ACR1_CMD_WRITE;
! 352: busy = AUTRI_NX_ACR1_BUSY_WRITE;
! 353: break;
! 354: case AUTRI_DEVICE_ID_SIS_7018:
! 355: addr = AUTRI_SIS_ACWR;
! 356: cmd = AUTRI_SIS_ACWR_CMD_WRITE;
! 357: busy = AUTRI_SIS_ACWR_BUSY_WRITE | AUTRI_SIS_ACWR_AUDIO_BUSY;
! 358: break;
! 359: case AUTRI_DEVICE_ID_ALI_M5451:
! 360: addr = AUTRI_ALI_ACWR;
! 361: cmd = AUTRI_ALI_ACWR_CMD_WRITE;
! 362: if (sc->sc_revision > 0x01)
! 363: cmd |= 0x0100;
! 364: busy = AUTRI_ALI_ACWR_BUSY_WRITE;
! 365: break;
! 366: default:
! 367: printf("%s: autri_write_codec : unknown device.\n",
! 368: sc->sc_dev.dv_xname);
! 369: return -1;
! 370: }
! 371:
! 372: /* wait for 'Ready to Write' */
! 373: for (count=0; count < 0xffff; count++) {
! 374: if ((TREAD4(sc, addr) & busy) == 0)
! 375: break;
! 376: DELAY(1);
! 377: }
! 378:
! 379: if (count == 0xffff) {
! 380: printf("%s: Codec timeout. Busy writing AC97 codec\n",
! 381: sc->sc_dev.dv_xname);
! 382: return -1;
! 383: }
! 384:
! 385: /* send Write Command to AC97 */
! 386: TWRITE4(sc, addr, (data << 16) | (index & 0x7f) | cmd);
! 387:
! 388: return 0;
! 389: }
! 390:
! 391: void
! 392: autri_reset_codec(sc_)
! 393: void *sc_;
! 394: {
! 395: struct autri_codec_softc *codec = sc_;
! 396: struct autri_softc *sc = codec->sc;
! 397: u_int32_t reg, ready;
! 398: int addr, count = 200;
! 399:
! 400: DPRINTF(("autri_reset_codec(codec=%p,sc=%p)\n",codec,sc));
! 401: DPRINTF(("sc->sc_devid=%X\n",sc->sc_devid));
! 402:
! 403: switch (sc->sc_devid) {
! 404: case AUTRI_DEVICE_ID_4DWAVE_DX:
! 405: /* warm reset AC97 codec */
! 406: autri_reg_set_4(sc, AUTRI_DX_ACR2, 1);
! 407: delay(100);
! 408: /* release reset */
! 409: autri_reg_clear_4(sc, AUTRI_DX_ACR2, 1);
! 410: delay(100);
! 411:
! 412: addr = AUTRI_DX_ACR2;
! 413: ready = AUTRI_DX_ACR2_CODEC_READY;
! 414: break;
! 415: case AUTRI_DEVICE_ID_4DWAVE_NX:
! 416: /* warm reset AC97 codec */
! 417: autri_reg_set_4(sc, AUTRI_NX_ACR0, 1);
! 418: delay(100);
! 419: /* release reset */
! 420: autri_reg_clear_4(sc, AUTRI_NX_ACR0, 1);
! 421: delay(100);
! 422:
! 423: addr = AUTRI_NX_ACR0;
! 424: ready = AUTRI_NX_ACR0_CODEC_READY;
! 425: break;
! 426: case AUTRI_DEVICE_ID_SIS_7018:
! 427: /* warm reset AC97 codec */
! 428: autri_reg_set_4(sc, AUTRI_SIS_SCTRL, 2);
! 429: delay(1000);
! 430: /* release reset (warm & cold) */
! 431: autri_reg_clear_4(sc, AUTRI_SIS_SCTRL, 3);
! 432: delay(2000);
! 433:
! 434: addr = AUTRI_SIS_SCTRL;
! 435: ready = AUTRI_SIS_SCTRL_CODEC_READY;
! 436: break;
! 437: case AUTRI_DEVICE_ID_ALI_M5451:
! 438: /* warm reset AC97 codec */
! 439: autri_reg_set_4(sc, AUTRI_ALI_SCTRL, 1);
! 440: delay(100);
! 441: /* release reset (warm & cold) */
! 442: autri_reg_clear_4(sc, AUTRI_ALI_SCTRL, 3);
! 443: delay(100);
! 444:
! 445: addr = AUTRI_ALI_SCTRL;
! 446: ready = AUTRI_ALI_SCTRL_CODEC_READY;
! 447: break;
! 448: }
! 449:
! 450: /* wait for 'Codec Ready' */
! 451: while (count--) {
! 452: reg = TREAD4(sc, addr);
! 453: if (reg & ready)
! 454: break;
! 455: delay(1000);
! 456: }
! 457:
! 458: if (count == 0)
! 459: printf("%s: Codec timeout. AC97 is not ready for operation.\n",
! 460: sc->sc_dev.dv_xname);
! 461: }
! 462:
! 463: enum ac97_host_flags
! 464: autri_flags_codec(void *v)
! 465: {
! 466: struct autri_codec_softc *sc = v;
! 467:
! 468: return (sc->flags);
! 469: }
! 470:
! 471: /*
! 472: *
! 473: */
! 474: const struct pci_matchid autri_devices[] = {
! 475: { PCI_VENDOR_TRIDENT, PCI_PRODUCT_TRIDENT_4DWAVE_NX },
! 476: { PCI_VENDOR_SIS, PCI_PRODUCT_SIS_7018 },
! 477: { PCI_VENDOR_ALI, PCI_PRODUCT_ALI_M5451 }
! 478: };
! 479:
! 480: int
! 481: autri_match(parent, match, aux)
! 482: struct device *parent;
! 483: void *match;
! 484: void *aux;
! 485: {
! 486: struct pci_attach_args *pa = aux;
! 487:
! 488: if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_TRIDENT &&
! 489: PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_TRIDENT_4DWAVE_DX) {
! 490: /*
! 491: * IBM makes a pcn network card and improperly
! 492: * sets the vendor and product ID's. Avoid matching.
! 493: */
! 494: if (PCI_CLASS(pa->pa_class) == PCI_CLASS_NETWORK)
! 495: return (0);
! 496: else
! 497: return (1);
! 498: }
! 499:
! 500: return (pci_matchbyid((struct pci_attach_args *)aux, autri_devices,
! 501: sizeof(autri_devices)/sizeof(autri_devices[0])));
! 502: }
! 503:
! 504: void
! 505: autri_attach(parent, self, aux)
! 506: struct device *parent;
! 507: struct device *self;
! 508: void *aux;
! 509: {
! 510: struct autri_softc *sc = (struct autri_softc *)self;
! 511: struct pci_attach_args *pa = (struct pci_attach_args *)aux;
! 512: pci_chipset_tag_t pc = pa->pa_pc;
! 513: struct autri_codec_softc *codec;
! 514: bus_size_t iosize;
! 515: pci_intr_handle_t ih;
! 516: char const *intrstr;
! 517: mixer_ctrl_t ctl;
! 518: int i, r;
! 519:
! 520: sc->sc_devid = pa->pa_id;
! 521: sc->sc_class = pa->pa_class;
! 522: sc->sc_revision = PCI_REVISION(pa->pa_class);
! 523:
! 524: /* map register to memory */
! 525: if (pci_mapreg_map(pa, AUTRI_PCI_MEMORY_BASE,
! 526: PCI_MAPREG_TYPE_MEM, 0, &sc->memt, &sc->memh, NULL, &iosize, 0)) {
! 527: printf("%s: can't map memory space\n", sc->sc_dev.dv_xname);
! 528: return;
! 529: }
! 530:
! 531: /* map and establish the interrupt */
! 532: if (pci_intr_map(pa, &ih)) {
! 533: printf("%s: couldn't map interrupt\n", sc->sc_dev.dv_xname);
! 534: bus_space_unmap(sc->memt, sc->memh, iosize);
! 535: return;
! 536: }
! 537: intrstr = pci_intr_string(pc, ih);
! 538: sc->sc_ih = pci_intr_establish(pc, ih, IPL_AUDIO, autri_intr, sc,
! 539: sc->sc_dev.dv_xname);
! 540: if (sc->sc_ih == NULL) {
! 541: printf("%s: couldn't establish interrupt",
! 542: sc->sc_dev.dv_xname);
! 543: if (intrstr != NULL)
! 544: printf(" at %s", intrstr);
! 545: printf("\n");
! 546: bus_space_unmap(sc->memt, sc->memh, iosize);
! 547: return;
! 548: }
! 549: printf(": %s\n", intrstr);
! 550:
! 551: sc->sc_dmatag = pa->pa_dmat;
! 552: sc->sc_pc = pc;
! 553: sc->sc_pt = pa->pa_tag;
! 554:
! 555: /* initialize the device */
! 556: autri_init(sc);
! 557:
! 558: /* attach AC97 codec */
! 559: codec = &sc->sc_codec;
! 560: memcpy(&codec->sc_dev, &sc->sc_dev, sizeof(codec->sc_dev));
! 561: codec->sc = sc;
! 562:
! 563: codec->host_if.arg = codec;
! 564: codec->host_if.attach = autri_attach_codec;
! 565: codec->host_if.reset = autri_reset_codec;
! 566: codec->host_if.read = autri_read_codec;
! 567: codec->host_if.write = autri_write_codec;
! 568: codec->host_if.flags = autri_flags_codec;
! 569: codec->flags = AC97_HOST_DONT_READ | AC97_HOST_SWAPPED_CHANNELS;
! 570: if (sc->sc_dev.dv_cfdata->cf_flags & 0x0001)
! 571: codec->flags &= ~AC97_HOST_SWAPPED_CHANNELS;
! 572:
! 573: if ((r = ac97_attach(&codec->host_if)) != 0) {
! 574: printf("%s: can't attach codec (error 0x%X)\n",
! 575: sc->sc_dev.dv_xname, r);
! 576: pci_intr_disestablish(pc, sc->sc_ih);
! 577: bus_space_unmap(sc->memt, sc->memh, iosize);
! 578: return;
! 579: }
! 580:
! 581: /* disable mutes */
! 582: for (i = 0; i < 4; i++) {
! 583: static struct {
! 584: char *class, *device;
! 585: } d[] = {
! 586: { AudioCoutputs, AudioNmaster},
! 587: { AudioCinputs, AudioNdac},
! 588: { AudioCinputs, AudioNcd},
! 589: { AudioCrecord, AudioNvolume},
! 590: };
! 591:
! 592: ctl.type = AUDIO_MIXER_ENUM;
! 593: ctl.un.ord = 0;
! 594:
! 595: #if 0
! 596: ctl.dev = sc->sc_codec.codec_if->vtbl->get_portnum_by_name(sc->sc_codec.codec_if,
! 597: d[i].class, d[i].device, AudioNmute);
! 598: #endif
! 599: ctl.dev = autri_get_portnum_by_name(sc,d[i].class,
! 600: d[i].device, AudioNmute);
! 601: autri_mixer_set_port(sc, &ctl);
! 602: }
! 603:
! 604: /* set a reasonable default volume */
! 605: ctl.type = AUDIO_MIXER_VALUE;
! 606: ctl.un.value.num_channels = 2;
! 607: ctl.un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
! 608: ctl.un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = 127;
! 609:
! 610: ctl.dev = autri_get_portnum_by_name(sc,AudioCoutputs,AudioNmaster,NULL);
! 611: autri_mixer_set_port(sc, &ctl);
! 612:
! 613: audio_attach_mi(&autri_hw_if, sc, &sc->sc_dev);
! 614:
! 615: #if NMIDI > 0
! 616: midi_attach_mi(&autri_midi_hw_if, sc, &sc->sc_dev);
! 617: #endif
! 618:
! 619: sc->sc_old_power = PWR_RESUME;
! 620: powerhook_establish(autri_powerhook, sc);
! 621: }
! 622:
! 623: void
! 624: autri_powerhook(int why,void *addr)
! 625: {
! 626: struct autri_softc *sc = addr;
! 627:
! 628: if (why == PWR_RESUME && sc->sc_old_power == PWR_SUSPEND) {
! 629: DPRINTF(("PWR_RESUME\n"));
! 630: autri_init(sc);
! 631: /*autri_reset_codec(&sc->sc_codec);*/
! 632: (sc->sc_codec.codec_if->vtbl->restore_ports)(sc->sc_codec.codec_if);
! 633: }
! 634: sc->sc_old_power = why;
! 635: }
! 636:
! 637: int
! 638: autri_init(sc_)
! 639: void *sc_;
! 640: {
! 641: struct autri_softc *sc = sc_;
! 642: pcireg_t reg;
! 643:
! 644: pci_chipset_tag_t pc = sc->sc_pc;
! 645: pcitag_t pt = sc->sc_pt;
! 646:
! 647: DPRINTF(("in autri_init()\n"));
! 648: DPRINTFN(5,("pci_conf_read(0x40) : 0x%X\n",pci_conf_read(pc,pt,0x40)));
! 649: DPRINTFN(5,("pci_conf_read(0x44) : 0x%X\n",pci_conf_read(pc,pt,0x44)));
! 650:
! 651: switch (sc->sc_devid) {
! 652: case AUTRI_DEVICE_ID_4DWAVE_DX:
! 653: /* disable Legacy Control */
! 654: pci_conf_write(pc, pt, AUTRI_PCI_DDMA_CFG,0);
! 655: reg = pci_conf_read(pc, pt, AUTRI_PCI_LEGACY_IOBASE);
! 656: pci_conf_write(pc, pt, AUTRI_PCI_LEGACY_IOBASE, reg & 0xffff0000);
! 657: delay(100);
! 658: /* audio engine reset */
! 659: reg = pci_conf_read(pc, pt, AUTRI_PCI_LEGACY_IOBASE);
! 660: pci_conf_write(pc, pt, AUTRI_PCI_LEGACY_IOBASE, reg | 0x00040000);
! 661: delay(100);
! 662: /* release reset */
! 663: reg = pci_conf_read(pc, pt, AUTRI_PCI_LEGACY_IOBASE);
! 664: pci_conf_write(pc, pt, AUTRI_PCI_LEGACY_IOBASE, reg & ~0x00040000);
! 665: delay(100);
! 666: /* DAC on */
! 667: autri_reg_set_4(sc,AUTRI_DX_ACR2,0x02);
! 668: break;
! 669: case AUTRI_DEVICE_ID_4DWAVE_NX:
! 670: /* disable Legacy Control */
! 671: pci_conf_write(pc, pt, AUTRI_PCI_DDMA_CFG,0);
! 672: reg = pci_conf_read(pc, pt, AUTRI_PCI_LEGACY_IOBASE);
! 673: pci_conf_write(pc, pt, AUTRI_PCI_LEGACY_IOBASE, reg & 0xffff0000);
! 674: delay(100);
! 675: /* audio engine reset */
! 676: reg = pci_conf_read(pc, pt, AUTRI_PCI_LEGACY_IOBASE);
! 677: pci_conf_write(pc, pt, AUTRI_PCI_LEGACY_IOBASE, reg | 0x00010000);
! 678: delay(100);
! 679: /* release reset */
! 680: reg = pci_conf_read(pc, pt, AUTRI_PCI_LEGACY_IOBASE);
! 681: pci_conf_write(pc, pt, AUTRI_PCI_LEGACY_IOBASE, reg & ~0x00010000);
! 682: delay(100);
! 683: /* DAC on */
! 684: autri_reg_set_4(sc,AUTRI_NX_ACR0,0x02);
! 685: break;
! 686: case AUTRI_DEVICE_ID_SIS_7018:
! 687: /* disable Legacy Control */
! 688: pci_conf_write(pc, pt, AUTRI_PCI_DDMA_CFG,0);
! 689: reg = pci_conf_read(pc, pt, AUTRI_PCI_LEGACY_IOBASE);
! 690: pci_conf_write(pc, pt, AUTRI_PCI_LEGACY_IOBASE, reg & 0xffff0000);
! 691: delay(100);
! 692: /* reset Digital Controller */
! 693: reg = pci_conf_read(pc, pt, AUTRI_PCI_LEGACY_IOBASE);
! 694: pci_conf_write(pc, pt, AUTRI_PCI_LEGACY_IOBASE, reg | 0x000c0000);
! 695: delay(100);
! 696: /* release reset */
! 697: reg = pci_conf_read(pc, pt, AUTRI_PCI_LEGACY_IOBASE);
! 698: pci_conf_write(pc, pt, AUTRI_PCI_LEGACY_IOBASE, reg & ~0x00040000);
! 699: delay(100);
! 700: /* disable AC97 GPIO interrupt */
! 701: TWRITE1(sc, AUTRI_SIS_ACGPIO, 0);
! 702: /* enable 64 channel mode */
! 703: autri_reg_set_4(sc, AUTRI_LFO_GC_CIR, BANK_B_EN);
! 704: break;
! 705: case AUTRI_DEVICE_ID_ALI_M5451:
! 706: /* disable Legacy Control */
! 707: pci_conf_write(pc, pt, AUTRI_PCI_DDMA_CFG,0);
! 708: reg = pci_conf_read(pc, pt, AUTRI_PCI_LEGACY_IOBASE);
! 709: pci_conf_write(pc, pt, AUTRI_PCI_LEGACY_IOBASE, reg & 0xffff0000);
! 710: delay(100);
! 711: /* reset Digital Controller */
! 712: reg = pci_conf_read(pc, pt, AUTRI_PCI_LEGACY_IOBASE);
! 713: pci_conf_write(pc, pt, AUTRI_PCI_LEGACY_IOBASE, reg | 0x000c0000);
! 714: delay(100);
! 715: /* release reset */
! 716: reg = pci_conf_read(pc, pt, AUTRI_PCI_LEGACY_IOBASE);
! 717: pci_conf_write(pc, pt, AUTRI_PCI_LEGACY_IOBASE, reg & ~0x00040000);
! 718: delay(100);
! 719: /* enable PCM input */
! 720: autri_reg_set_4(sc, AUTRI_ALI_GCONTROL, AUTRI_ALI_GCONTROL_PCM_IN);
! 721: break;
! 722: }
! 723:
! 724: if (sc->sc_devid == AUTRI_DEVICE_ID_ALI_M5451) {
! 725: sc->sc_play.ch = 0;
! 726: sc->sc_play.ch_intr = 1;
! 727: sc->sc_rec.ch = 31;
! 728: sc->sc_rec.ch_intr = 2;
! 729: } else {
! 730: sc->sc_play.ch = 0x20;
! 731: sc->sc_play.ch_intr = 0x21;
! 732: sc->sc_rec.ch = 0x22;
! 733: sc->sc_rec.ch_intr = 0x23;
! 734: }
! 735:
! 736: /* clear channel status */
! 737: TWRITE4(sc, AUTRI_STOP_A, 0xffffffff);
! 738: TWRITE4(sc, AUTRI_STOP_B, 0xffffffff);
! 739:
! 740: /* disable channel interrupt */
! 741: TWRITE4(sc, AUTRI_AINTEN_A, 0);
! 742: TWRITE4(sc, AUTRI_AINTEN_B, 0);
! 743:
! 744: #if 0
! 745: /* TLB */
! 746: if (sc->sc_devid == AUTRI_DEVICE_ID_4DWAVE_NX) {
! 747: TWRITE4(sc,AUTRI_NX_TLBC,0);
! 748: }
! 749: #endif
! 750:
! 751: autri_enable_loop_interrupt(sc);
! 752:
! 753: DPRINTF(("out autri_init()\n"));
! 754: return 0;
! 755: }
! 756:
! 757: void
! 758: autri_enable_loop_interrupt(sc_)
! 759: void *sc_;
! 760: {
! 761: struct autri_softc *sc = sc_;
! 762: u_int32_t reg;
! 763:
! 764: /*reg = (ENDLP_IE | MIDLP_IE);*/
! 765: reg = ENDLP_IE;
! 766: #if 0
! 767: if (sc->sc_devid == AUTRI_DEVICE_ID_SIS_7018)
! 768: reg |= BANK_B_EN;
! 769: #endif
! 770: autri_reg_set_4(sc,AUTRI_LFO_GC_CIR,reg);
! 771: }
! 772:
! 773: #if 0
! 774: void
! 775: autri_disable_loop_interrupt(sc_)
! 776: void *sc_;
! 777: {
! 778: struct autri_softc *sc = sc_;
! 779: u_int32_t reg;
! 780:
! 781: reg = (ENDLP_IE | MIDLP_IE);
! 782: autri_reg_clear_4(sc,AUTRI_LFO_GC_CIR,reg);
! 783: }
! 784: #endif
! 785:
! 786: int
! 787: autri_intr(p)
! 788: void *p;
! 789: {
! 790: struct autri_softc *sc = p;
! 791: u_int32_t intsrc;
! 792: u_int32_t mask, active[2];
! 793: int ch, endch;
! 794: /*
! 795: u_int32_t reg;
! 796: u_int32_t cso,eso;
! 797: */
! 798:
! 799: intsrc = TREAD4(sc,AUTRI_MISCINT);
! 800: if ((intsrc & (ADDRESS_IRQ|MPU401_IRQ)) == 0)
! 801: return 0;
! 802:
! 803: if (intsrc & ADDRESS_IRQ) {
! 804:
! 805: active[0] = TREAD4(sc,AUTRI_AIN_A);
! 806: active[1] = TREAD4(sc,AUTRI_AIN_B);
! 807:
! 808: if (sc->sc_devid == AUTRI_DEVICE_ID_ALI_M5451) {
! 809: endch = 32;
! 810: } else {
! 811: endch = 64;
! 812: }
! 813:
! 814: for (ch=0; ch<endch; ch++) {
! 815: mask = 1 << (ch & 0x1f);
! 816: if (active[(ch & 0x20) ? 1 : 0] & mask) {
! 817:
! 818: /* clear interrupt */
! 819: TWRITE4(sc, (ch & 0x20) ? AUTRI_AIN_B : AUTRI_AIN_A, mask);
! 820: /* disable interrupt */
! 821: autri_reg_clear_4(sc,(ch & 0x20) ? AUTRI_AINTEN_B : AUTRI_AINTEN_A, mask);
! 822: #if 0
! 823: reg = TREAD4(sc,AUTRI_LFO_GC_CIR) & ~0x0000003f;
! 824: TWRITE4(sc,AUTRI_LFO_GC_CIR, reg | ch);
! 825:
! 826: if (sc->sc_devid == AUTRI_DEVICE_ID_4DWAVE_NX) {
! 827: cso = TREAD4(sc, 0xe0) & 0x00ffffff;
! 828: eso = TREAD4(sc, 0xe8) & 0x00ffffff;
! 829: } else {
! 830: cso = (TREAD4(sc, 0xe0) >> 16) & 0x0000ffff;
! 831: eso = (TREAD4(sc, 0xe8) >> 16) & 0x0000ffff;
! 832: }
! 833: /*printf("cso=%d, eso=%d\n",cso,eso);*/
! 834: #endif
! 835: if (ch == sc->sc_play.ch_intr) {
! 836: if (sc->sc_play.intr)
! 837: sc->sc_play.intr(sc->sc_play.intr_arg);
! 838: }
! 839:
! 840: if (ch == sc->sc_rec.ch_intr) {
! 841: if (sc->sc_rec.intr)
! 842: sc->sc_rec.intr(sc->sc_rec.intr_arg);
! 843: }
! 844:
! 845: /* enable interrupt */
! 846: autri_reg_set_4(sc, (ch & 0x20) ? AUTRI_AINTEN_B : AUTRI_AINTEN_A, mask);
! 847: }
! 848: }
! 849: }
! 850:
! 851: if (intsrc & MPU401_IRQ) {
! 852: /* XXX */
! 853: }
! 854:
! 855: autri_reg_set_4(sc,AUTRI_MISCINT,
! 856: ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW);
! 857:
! 858: return 1;
! 859: }
! 860:
! 861: /*
! 862: *
! 863: */
! 864:
! 865: int
! 866: autri_allocmem(sc, size, align, p)
! 867: struct autri_softc *sc;
! 868: size_t size;
! 869: size_t align;
! 870: struct autri_dma *p;
! 871: {
! 872: int error;
! 873:
! 874: p->size = size;
! 875: error = bus_dmamem_alloc(sc->sc_dmatag, p->size, align, 0,
! 876: p->segs, sizeof(p->segs)/sizeof(p->segs[0]),
! 877: &p->nsegs, BUS_DMA_NOWAIT);
! 878: if (error)
! 879: return (error);
! 880:
! 881: error = bus_dmamem_map(sc->sc_dmatag, p->segs, p->nsegs, p->size,
! 882: &p->addr, BUS_DMA_NOWAIT|BUS_DMA_COHERENT);
! 883: if (error)
! 884: goto free;
! 885:
! 886: error = bus_dmamap_create(sc->sc_dmatag, p->size, 1, p->size,
! 887: 0, BUS_DMA_NOWAIT, &p->map);
! 888: if (error)
! 889: goto unmap;
! 890:
! 891: error = bus_dmamap_load(sc->sc_dmatag, p->map, p->addr, p->size, NULL,
! 892: BUS_DMA_NOWAIT);
! 893: if (error)
! 894: goto destroy;
! 895: return (0);
! 896:
! 897: destroy:
! 898: bus_dmamap_destroy(sc->sc_dmatag, p->map);
! 899: unmap:
! 900: bus_dmamem_unmap(sc->sc_dmatag, p->addr, p->size);
! 901: free:
! 902: bus_dmamem_free(sc->sc_dmatag, p->segs, p->nsegs);
! 903: return (error);
! 904: }
! 905:
! 906: int
! 907: autri_freemem(sc, p)
! 908: struct autri_softc *sc;
! 909: struct autri_dma *p;
! 910: {
! 911: bus_dmamap_unload(sc->sc_dmatag, p->map);
! 912: bus_dmamap_destroy(sc->sc_dmatag, p->map);
! 913: bus_dmamem_unmap(sc->sc_dmatag, p->addr, p->size);
! 914: bus_dmamem_free(sc->sc_dmatag, p->segs, p->nsegs);
! 915: return 0;
! 916: }
! 917:
! 918: int
! 919: autri_open(addr, flags)
! 920: void *addr;
! 921: int flags;
! 922: {
! 923: DPRINTF(("autri_open()\n"));
! 924: DPRINTFN(5,("MISCINT : 0x%08X\n",
! 925: TREAD4((struct autri_softc *)addr, AUTRI_MISCINT)));
! 926: DPRINTFN(5,("LFO_GC_CIR : 0x%08X\n",
! 927: TREAD4((struct autri_softc *)addr, AUTRI_LFO_GC_CIR)));
! 928: return 0;
! 929: }
! 930:
! 931: void
! 932: autri_close(addr)
! 933: void *addr;
! 934: {
! 935: DPRINTF(("autri_close()\n"));
! 936: }
! 937:
! 938: int
! 939: autri_query_encoding(addr, fp)
! 940: void *addr;
! 941: struct audio_encoding *fp;
! 942: {
! 943: switch (fp->index) {
! 944: case 0:
! 945: strlcpy(fp->name, AudioEulinear, sizeof fp->name);
! 946: fp->encoding = AUDIO_ENCODING_ULINEAR;
! 947: fp->precision = 8;
! 948: fp->flags = 0;
! 949: break;
! 950: case 1:
! 951: strlcpy(fp->name, AudioEmulaw, sizeof fp->name);
! 952: fp->encoding = AUDIO_ENCODING_ULAW;
! 953: fp->precision = 8;
! 954: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 955: break;
! 956: case 2:
! 957: strlcpy(fp->name, AudioEalaw, sizeof fp->name);
! 958: fp->encoding = AUDIO_ENCODING_ALAW;
! 959: fp->precision = 8;
! 960: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 961: break;
! 962: case 3:
! 963: strlcpy(fp->name, AudioEslinear, sizeof fp->name);
! 964: fp->encoding = AUDIO_ENCODING_SLINEAR;
! 965: fp->precision = 8;
! 966: fp->flags = 0;
! 967: break;
! 968: case 4:
! 969: strlcpy(fp->name, AudioEslinear_le, sizeof fp->name);
! 970: fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
! 971: fp->precision = 16;
! 972: fp->flags = 0;
! 973: break;
! 974: case 5:
! 975: strlcpy(fp->name, AudioEulinear_le, sizeof fp->name);
! 976: fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
! 977: fp->precision = 16;
! 978: fp->flags = 0;
! 979: break;
! 980: case 6:
! 981: strlcpy(fp->name, AudioEslinear_be, sizeof fp->name);
! 982: fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
! 983: fp->precision = 16;
! 984: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 985: break;
! 986: case 7:
! 987: strlcpy(fp->name, AudioEulinear_be, sizeof fp->name);
! 988: fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
! 989: fp->precision = 16;
! 990: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 991: break;
! 992: default:
! 993: return (EINVAL);
! 994: }
! 995:
! 996: return 0;
! 997: }
! 998:
! 999: int
! 1000: autri_set_params(addr, setmode, usemode, play, rec)
! 1001: void *addr;
! 1002: int setmode, usemode;
! 1003: struct audio_params *play, *rec;
! 1004: {
! 1005: struct audio_params *p;
! 1006: int mode;
! 1007:
! 1008: for (mode = AUMODE_RECORD; mode != -1;
! 1009: mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) {
! 1010: if ((setmode & mode) == 0)
! 1011: continue;
! 1012:
! 1013: p = mode == AUMODE_PLAY ? play : rec;
! 1014:
! 1015: if (p->sample_rate < 4000 || p->sample_rate > 48000 ||
! 1016: (p->precision != 8 && p->precision != 16) ||
! 1017: (p->channels != 1 && p->channels != 2))
! 1018: return (EINVAL);
! 1019:
! 1020: p->factor = 1;
! 1021: p->sw_code = 0;
! 1022: switch (p->encoding) {
! 1023: case AUDIO_ENCODING_SLINEAR_BE:
! 1024: case AUDIO_ENCODING_ULINEAR_BE:
! 1025: if (p->precision == 16)
! 1026: p->sw_code = swap_bytes;
! 1027: break;
! 1028: case AUDIO_ENCODING_SLINEAR_LE:
! 1029: case AUDIO_ENCODING_ULINEAR_LE:
! 1030: break;
! 1031: case AUDIO_ENCODING_ULAW:
! 1032: if (mode == AUMODE_PLAY)
! 1033: p->sw_code = mulaw_to_ulinear8;
! 1034: else
! 1035: p->sw_code = ulinear8_to_mulaw;
! 1036:
! 1037: break;
! 1038: case AUDIO_ENCODING_ALAW:
! 1039: if (mode == AUMODE_PLAY)
! 1040: p->sw_code = alaw_to_ulinear8;
! 1041: else
! 1042: p->sw_code = ulinear8_to_alaw;
! 1043:
! 1044: break;
! 1045: default:
! 1046: return (EINVAL);
! 1047: }
! 1048: }
! 1049:
! 1050: return 0;
! 1051: }
! 1052:
! 1053: int
! 1054: autri_round_blocksize(addr, block)
! 1055: void *addr;
! 1056: int block;
! 1057: {
! 1058: return ((block + 3) & -4);
! 1059: }
! 1060:
! 1061: int
! 1062: autri_halt_output(addr)
! 1063: void *addr;
! 1064: {
! 1065: struct autri_softc *sc = addr;
! 1066:
! 1067: DPRINTF(("autri_halt_output()\n"));
! 1068:
! 1069: sc->sc_play.intr = NULL;
! 1070: autri_stopch(sc, sc->sc_play.ch, sc->sc_play.ch_intr);
! 1071: autri_disable_interrupt(sc, sc->sc_play.ch_intr);
! 1072:
! 1073: return 0;
! 1074: }
! 1075:
! 1076: int
! 1077: autri_halt_input(addr)
! 1078: void *addr;
! 1079: {
! 1080: struct autri_softc *sc = addr;
! 1081:
! 1082: DPRINTF(("autri_halt_input()\n"));
! 1083:
! 1084: sc->sc_rec.intr = NULL;
! 1085: autri_stopch(sc, sc->sc_rec.ch, sc->sc_rec.ch_intr);
! 1086: autri_disable_interrupt(sc, sc->sc_rec.ch_intr);
! 1087:
! 1088: return 0;
! 1089: }
! 1090:
! 1091: int
! 1092: autri_getdev(addr, retp)
! 1093: void *addr;
! 1094: struct audio_device *retp;
! 1095: {
! 1096: struct autri_softc *sc = addr;
! 1097:
! 1098: DPRINTF(("autri_getdev().\n"));
! 1099:
! 1100: strncpy(retp->name, "Trident 4DWAVE", sizeof(retp->name));
! 1101: snprintf(retp->version, sizeof(retp->version), "0x%02x",
! 1102: PCI_REVISION(sc->sc_class));
! 1103:
! 1104: switch (sc->sc_devid) {
! 1105: case AUTRI_DEVICE_ID_4DWAVE_DX:
! 1106: strncpy(retp->config, "4DWAVE-DX", sizeof(retp->config));
! 1107: break;
! 1108: case AUTRI_DEVICE_ID_4DWAVE_NX:
! 1109: strncpy(retp->config, "4DWAVE-NX", sizeof(retp->config));
! 1110: break;
! 1111: case AUTRI_DEVICE_ID_SIS_7018:
! 1112: strncpy(retp->config, "SiS 7018", sizeof(retp->config));
! 1113: break;
! 1114: case AUTRI_DEVICE_ID_ALI_M5451:
! 1115: strncpy(retp->config, "ALi M5451", sizeof(retp->config));
! 1116: break;
! 1117: default:
! 1118: strncpy(retp->config, "unknown", sizeof(retp->config));
! 1119: }
! 1120:
! 1121: return 0;
! 1122: }
! 1123:
! 1124: int
! 1125: autri_mixer_set_port(addr, cp)
! 1126: void *addr;
! 1127: mixer_ctrl_t *cp;
! 1128: {
! 1129: struct autri_softc *sc = addr;
! 1130:
! 1131: return (sc->sc_codec.codec_if->vtbl->mixer_set_port(
! 1132: sc->sc_codec.codec_if, cp));
! 1133: }
! 1134:
! 1135: int
! 1136: autri_mixer_get_port(addr, cp)
! 1137: void *addr;
! 1138: mixer_ctrl_t *cp;
! 1139: {
! 1140: struct autri_softc *sc = addr;
! 1141:
! 1142: return (sc->sc_codec.codec_if->vtbl->mixer_get_port(
! 1143: sc->sc_codec.codec_if, cp));
! 1144: }
! 1145:
! 1146: int
! 1147: autri_query_devinfo(addr, dip)
! 1148: void *addr;
! 1149: mixer_devinfo_t *dip;
! 1150: {
! 1151: struct autri_softc *sc = addr;
! 1152:
! 1153: return (sc->sc_codec.codec_if->vtbl->query_devinfo(
! 1154: sc->sc_codec.codec_if, dip));
! 1155: }
! 1156:
! 1157: int
! 1158: autri_get_portnum_by_name(sc, class, device, qualifier)
! 1159: struct autri_softc *sc;
! 1160: char *class, *device, *qualifier;
! 1161: {
! 1162: return (sc->sc_codec.codec_if->vtbl->get_portnum_by_name(
! 1163: sc->sc_codec.codec_if, class, device, qualifier));
! 1164: }
! 1165:
! 1166: void *
! 1167: autri_malloc(addr, direction, size, pool, flags)
! 1168: void *addr;
! 1169: int direction;
! 1170: size_t size;
! 1171: int pool, flags;
! 1172: {
! 1173: struct autri_softc *sc = addr;
! 1174: struct autri_dma *p;
! 1175: int error;
! 1176:
! 1177: p = malloc(sizeof(*p), pool, flags);
! 1178: if (!p)
! 1179: return NULL;
! 1180:
! 1181: #if 0
! 1182: error = autri_allocmem(sc, size, 16, p);
! 1183: #endif
! 1184: error = autri_allocmem(sc, size, 0x10000, p);
! 1185: if (error) {
! 1186: free(p, pool);
! 1187: return NULL;
! 1188: }
! 1189:
! 1190: p->next = sc->sc_dmas;
! 1191: sc->sc_dmas = p;
! 1192: return KERNADDR(p);
! 1193: }
! 1194:
! 1195: void
! 1196: autri_free(addr, ptr, pool)
! 1197: void *addr;
! 1198: void *ptr;
! 1199: int pool;
! 1200: {
! 1201: struct autri_softc *sc = addr;
! 1202: struct autri_dma **pp, *p;
! 1203:
! 1204: for (pp = &sc->sc_dmas; (p = *pp) != NULL; pp = &p->next) {
! 1205: if (KERNADDR(p) == ptr) {
! 1206: autri_freemem(sc, p);
! 1207: *pp = p->next;
! 1208: free(p, pool);
! 1209: return;
! 1210: }
! 1211: }
! 1212: }
! 1213:
! 1214: struct autri_dma *
! 1215: autri_find_dma(sc, addr)
! 1216: struct autri_softc *sc;
! 1217: void *addr;
! 1218: {
! 1219: struct autri_dma *p;
! 1220:
! 1221: for (p = sc->sc_dmas; p && KERNADDR(p) != addr; p = p->next)
! 1222: ;
! 1223:
! 1224: return p;
! 1225: }
! 1226:
! 1227: paddr_t
! 1228: autri_mappage(addr, mem, off, prot)
! 1229: void *addr;
! 1230: void *mem;
! 1231: off_t off;
! 1232: int prot;
! 1233: {
! 1234: struct autri_softc *sc = addr;
! 1235: struct autri_dma *p;
! 1236:
! 1237: if (off < 0)
! 1238: return (-1);
! 1239:
! 1240: p = autri_find_dma(sc, mem);
! 1241: if (!p)
! 1242: return (-1);
! 1243:
! 1244: return (bus_dmamem_mmap(sc->sc_dmatag, p->segs, p->nsegs,
! 1245: off, prot, BUS_DMA_WAITOK));
! 1246: }
! 1247:
! 1248: int
! 1249: autri_get_props(addr)
! 1250: void *addr;
! 1251: {
! 1252: return (AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT |
! 1253: AUDIO_PROP_FULLDUPLEX);
! 1254: }
! 1255:
! 1256: void
! 1257: autri_setup_channel(sc, mode, param)
! 1258: struct autri_softc *sc;
! 1259: int mode;
! 1260: struct audio_params *param;
! 1261: {
! 1262: int i, ch, channel;
! 1263: u_int32_t reg, cr[5];
! 1264: u_int32_t cso, eso;
! 1265: u_int32_t delta, dch[2], ctrl;
! 1266: u_int32_t alpha_fms, fm_vol, attribute;
! 1267:
! 1268: u_int32_t dmaaddr, dmalen;
! 1269: int factor, rvol, cvol;
! 1270: struct autri_chstatus *chst;
! 1271:
! 1272: ctrl = AUTRI_CTRL_LOOPMODE;
! 1273: switch (param->encoding) {
! 1274: case AUDIO_ENCODING_SLINEAR_BE:
! 1275: case AUDIO_ENCODING_SLINEAR_LE:
! 1276: ctrl |= AUTRI_CTRL_SIGNED;
! 1277: break;
! 1278: }
! 1279:
! 1280: factor = 0;
! 1281: if (param->precision == 16) {
! 1282: ctrl |= AUTRI_CTRL_16BIT;
! 1283: factor++;
! 1284: }
! 1285:
! 1286: if (param->channels == 2) {
! 1287: ctrl |= AUTRI_CTRL_STEREO;
! 1288: factor++;
! 1289: }
! 1290:
! 1291: delta = (u_int32_t)param->sample_rate;
! 1292: if (delta < 4000)
! 1293: delta = 4000;
! 1294: if (delta > 48000)
! 1295: delta = 48000;
! 1296:
! 1297: attribute = 0;
! 1298:
! 1299: dch[1] = ((delta << 12) / 48000) & 0x0000ffff;
! 1300: if (mode == AUMODE_PLAY) {
! 1301: chst = &sc->sc_play;
! 1302: dch[0] = ((delta << 12) / 48000) & 0x0000ffff;
! 1303: ctrl |= AUTRI_CTRL_WAVEVOL;
! 1304: /*
! 1305: if (sc->sc_devid == AUTRI_DEVICE_ID_ALI_M5451)
! 1306: ctrl |= 0x80000000;
! 1307: */
! 1308: } else {
! 1309: chst = &sc->sc_rec;
! 1310: dch[0] = ((48000 << 12) / delta) & 0x0000ffff;
! 1311: if (sc->sc_devid == AUTRI_DEVICE_ID_SIS_7018) {
! 1312: ctrl |= AUTRI_CTRL_MUTE_SIS;
! 1313: attribute = AUTRI_ATTR_PCMREC_SIS;
! 1314: if (delta != 48000)
! 1315: attribute |= AUTRI_ATTR_ENASRC_SIS;
! 1316: }
! 1317: ctrl |= AUTRI_CTRL_MUTE;
! 1318: }
! 1319:
! 1320: dmaaddr = DMAADDR(chst->dma);
! 1321: cso = alpha_fms = 0;
! 1322: rvol = cvol = 0x7f;
! 1323: fm_vol = 0x0 | ((rvol & 0x7f) << 7) | (cvol & 0x7f);
! 1324:
! 1325: for (ch=0; ch<2; ch++) {
! 1326:
! 1327: if (ch == 0)
! 1328: dmalen = (chst->length >> factor);
! 1329: else {
! 1330: /* channel for interrupt */
! 1331: dmalen = (chst->blksize >> factor);
! 1332: if (sc->sc_devid == AUTRI_DEVICE_ID_SIS_7018)
! 1333: ctrl |= AUTRI_CTRL_MUTE_SIS;
! 1334: else
! 1335: ctrl |= AUTRI_CTRL_MUTE;
! 1336: attribute = 0;
! 1337: }
! 1338:
! 1339: eso = dmalen - 1;
! 1340:
! 1341: switch (sc->sc_devid) {
! 1342: case AUTRI_DEVICE_ID_4DWAVE_DX:
! 1343: cr[0] = (cso << 16) | (alpha_fms & 0x0000ffff);
! 1344: cr[1] = dmaaddr;
! 1345: cr[2] = (eso << 16) | (dch[ch] & 0x0000ffff);
! 1346: cr[3] = fm_vol;
! 1347: cr[4] = ctrl;
! 1348: break;
! 1349: case AUTRI_DEVICE_ID_4DWAVE_NX:
! 1350: cr[0] = (dch[ch] << 24) | (cso & 0x00ffffff);
! 1351: cr[1] = dmaaddr;
! 1352: cr[2] = ((dch[ch] << 16) & 0xff000000) | (eso & 0x00ffffff);
! 1353: cr[3] = (alpha_fms << 16) | (fm_vol & 0x0000ffff);
! 1354: cr[4] = ctrl;
! 1355: break;
! 1356: case AUTRI_DEVICE_ID_SIS_7018:
! 1357: cr[0] = (cso << 16) | (alpha_fms & 0x0000ffff);
! 1358: cr[1] = dmaaddr;
! 1359: cr[2] = (eso << 16) | (dch[ch] & 0x0000ffff);
! 1360: cr[3] = attribute;
! 1361: cr[4] = ctrl;
! 1362: break;
! 1363: case AUTRI_DEVICE_ID_ALI_M5451:
! 1364: cr[0] = (cso << 16) | (alpha_fms & 0x0000ffff);
! 1365: cr[1] = dmaaddr;
! 1366: cr[2] = (eso << 16) | (dch[ch] & 0x0000ffff);
! 1367: cr[3] = 0;
! 1368: cr[4] = ctrl;
! 1369: break;
! 1370: }
! 1371:
! 1372: /* write channel data */
! 1373: channel = (ch == 0) ? chst->ch : chst->ch_intr;
! 1374:
! 1375: reg = TREAD4(sc,AUTRI_LFO_GC_CIR) & ~0x0000003f;
! 1376: TWRITE4(sc,AUTRI_LFO_GC_CIR, reg | channel);
! 1377:
! 1378: for (i=0; i<5; i++) {
! 1379: TWRITE4(sc, AUTRI_ARAM_CR + i*sizeof(cr[0]), cr[i]);
! 1380: DPRINTFN(5,("cr[%d] : 0x%08X\n", i, cr[i]));
! 1381: }
! 1382:
! 1383: /* Bank A only */
! 1384: if (channel < 0x20) {
! 1385: TWRITE4(sc, AUTRI_EBUF1, AUTRI_EMOD_STILL);
! 1386: TWRITE4(sc, AUTRI_EBUF2, AUTRI_EMOD_STILL);
! 1387: }
! 1388: }
! 1389:
! 1390: }
! 1391:
! 1392: int
! 1393: autri_trigger_output(addr, start, end, blksize, intr, arg, param)
! 1394: void *addr;
! 1395: void *start, *end;
! 1396: int blksize;
! 1397: void (*intr)(void *);
! 1398: void *arg;
! 1399: struct audio_params *param;
! 1400: {
! 1401: struct autri_softc *sc = addr;
! 1402: struct autri_dma *p;
! 1403:
! 1404: DPRINTFN(5,("autri_trigger_output: sc=%p start=%p end=%p "
! 1405: "blksize=%d intr=%p(%p)\n", addr, start, end, blksize, intr, arg));
! 1406:
! 1407: sc->sc_play.intr = intr;
! 1408: sc->sc_play.intr_arg = arg;
! 1409: sc->sc_play.offset = 0;
! 1410: sc->sc_play.blksize = blksize;
! 1411: sc->sc_play.length = (char *)end - (char *)start;
! 1412:
! 1413: p = autri_find_dma(sc, start);
! 1414: if (!p) {
! 1415: printf("autri_trigger_output: bad addr %p\n", start);
! 1416: return (EINVAL);
! 1417: }
! 1418:
! 1419: sc->sc_play.dma = p;
! 1420:
! 1421: /* */
! 1422: autri_setup_channel(sc, AUMODE_PLAY, param);
! 1423:
! 1424: /* volume set to no attenuation */
! 1425: TWRITE4(sc, AUTRI_MUSICVOL_WAVEVOL, 0);
! 1426:
! 1427: /* enable interrupt */
! 1428: autri_enable_interrupt(sc, sc->sc_play.ch_intr);
! 1429:
! 1430: /* start channel */
! 1431: autri_startch(sc, sc->sc_play.ch, sc->sc_play.ch_intr);
! 1432:
! 1433: return 0;
! 1434: }
! 1435:
! 1436: int
! 1437: autri_trigger_input(addr, start, end, blksize, intr, arg, param)
! 1438: void *addr;
! 1439: void *start, *end;
! 1440: int blksize;
! 1441: void (*intr)(void *);
! 1442: void *arg;
! 1443: struct audio_params *param;
! 1444: {
! 1445: struct autri_softc *sc = addr;
! 1446: struct autri_dma *p;
! 1447:
! 1448: DPRINTFN(5,("autri_trigger_input: sc=%p start=%p end=%p "
! 1449: "blksize=%d intr=%p(%p)\n", addr, start, end, blksize, intr, arg));
! 1450:
! 1451: sc->sc_rec.intr = intr;
! 1452: sc->sc_rec.intr_arg = arg;
! 1453: sc->sc_rec.offset = 0;
! 1454: sc->sc_rec.blksize = blksize;
! 1455: sc->sc_rec.length = (char *)end - (char *)start;
! 1456:
! 1457: /* */
! 1458: p = autri_find_dma(sc, start);
! 1459: if (!p) {
! 1460: printf("autri_trigger_input: bad addr %p\n", start);
! 1461: return (EINVAL);
! 1462: }
! 1463:
! 1464: sc->sc_rec.dma = p;
! 1465:
! 1466: /* */
! 1467: if (sc->sc_devid == AUTRI_DEVICE_ID_4DWAVE_NX) {
! 1468: autri_reg_set_4(sc, AUTRI_NX_ACR0, AUTRI_NX_ACR0_PSB_CAPTURE);
! 1469: TWRITE1(sc, AUTRI_NX_RCI3, AUTRI_NX_RCI3_ENABLE | sc->sc_rec.ch);
! 1470: }
! 1471:
! 1472: #if 0
! 1473: /* 4DWAVE only allows capturing at a 48KHz rate */
! 1474: if (sc->sc_devid == AUTRI_DEVICE_ID_4DWAVE_DX ||
! 1475: sc->sc_devid == AUTRI_DEVICE_ID_4DWAVE_NX)
! 1476: param->sample_rate = 48000;
! 1477: #endif
! 1478:
! 1479: autri_setup_channel(sc, AUMODE_RECORD, param);
! 1480:
! 1481: /* enable interrupt */
! 1482: autri_enable_interrupt(sc, sc->sc_rec.ch_intr);
! 1483:
! 1484: /* start channel */
! 1485: autri_startch(sc, sc->sc_rec.ch, sc->sc_rec.ch_intr);
! 1486:
! 1487: return 0;
! 1488: }
! 1489:
! 1490: #if 0
! 1491: int
! 1492: autri_halt(sc)
! 1493: struct autri_softc *sc;
! 1494: {
! 1495: DPRINTF(("autri_halt().\n"));
! 1496: /*autri_stopch(sc);*/
! 1497: autri_disable_interrupt(sc, sc->sc_play.channel);
! 1498: autri_disable_interrupt(sc, sc->sc_rec.channel);
! 1499: return 0;
! 1500: }
! 1501: #endif
! 1502:
! 1503: void
! 1504: autri_enable_interrupt(sc, ch)
! 1505: struct autri_softc *sc;
! 1506: int ch;
! 1507: {
! 1508: int reg;
! 1509:
! 1510: reg = (ch & 0x20) ? AUTRI_AINTEN_B : AUTRI_AINTEN_A;
! 1511: ch &= 0x1f;
! 1512:
! 1513: autri_reg_set_4(sc, reg, 1 << ch);
! 1514: }
! 1515:
! 1516: void
! 1517: autri_disable_interrupt(sc, ch)
! 1518: struct autri_softc *sc;
! 1519: int ch;
! 1520: {
! 1521: int reg;
! 1522:
! 1523: reg = (ch & 0x20) ? AUTRI_AINTEN_B : AUTRI_AINTEN_A;
! 1524: ch &= 0x1f;
! 1525:
! 1526: autri_reg_clear_4(sc, reg, 1 << ch);
! 1527: }
! 1528:
! 1529: void
! 1530: autri_startch(sc, ch, ch_intr)
! 1531: struct autri_softc *sc;
! 1532: int ch, ch_intr;
! 1533: {
! 1534: int reg;
! 1535: u_int32_t chmask;
! 1536:
! 1537: reg = (ch & 0x20) ? AUTRI_START_B : AUTRI_START_A;
! 1538: ch &= 0x1f;
! 1539: chmask = (1 << ch) | (1 << ch_intr);
! 1540:
! 1541: autri_reg_set_4(sc, reg, chmask);
! 1542: }
! 1543:
! 1544: void
! 1545: autri_stopch(sc, ch, ch_intr)
! 1546: struct autri_softc *sc;
! 1547: int ch, ch_intr;
! 1548: {
! 1549: int reg;
! 1550: u_int32_t chmask;
! 1551:
! 1552: reg = (ch & 0x20) ? AUTRI_STOP_B : AUTRI_STOP_A;
! 1553: ch &= 0x1f;
! 1554: chmask = (1 << ch) | (1 << ch_intr);
! 1555:
! 1556: autri_reg_set_4(sc, reg, chmask);
! 1557: }
! 1558:
! 1559: #if NMIDI > 0
! 1560: int
! 1561: autri_midi_open(void *addr, int flags,
! 1562: void (*iintr)(void *, int),
! 1563: void (*ointr)(void *),
! 1564: void *arg)
! 1565: {
! 1566: struct autri_softc *sc = addr;
! 1567:
! 1568: DPRINTF(("autri_midi_open()\n"));
! 1569:
! 1570: DPRINTFN(5,("MPUR1 : 0x%02X\n",TREAD1(sc,AUTRI_MPUR1)));
! 1571: DPRINTFN(5,("MPUR2 : 0x%02X\n",TREAD1(sc,AUTRI_MPUR2)));
! 1572:
! 1573: sc->sc_iintr = iintr;
! 1574: sc->sc_ointr = ointr;
! 1575: sc->sc_arg = arg;
! 1576:
! 1577: if (flags & FREAD)
! 1578: autri_reg_clear_1(sc, AUTRI_MPUR2, AUTRI_MIDIIN_ENABLE_INTR);
! 1579:
! 1580: if (flags & FWRITE)
! 1581: autri_reg_set_1(sc, AUTRI_MPUR2, AUTRI_MIDIOUT_CONNECT);
! 1582:
! 1583: return (0);
! 1584: }
! 1585:
! 1586: void
! 1587: autri_midi_close(void *addr)
! 1588: {
! 1589: struct autri_softc *sc = addr;
! 1590:
! 1591: DPRINTF(("autri_midi_close()\n"));
! 1592:
! 1593: tsleep(sc, PWAIT, "autri", hz/10); /* give uart a chance to drain */
! 1594:
! 1595: sc->sc_iintr = NULL;
! 1596: sc->sc_ointr = NULL;
! 1597: }
! 1598:
! 1599: int
! 1600: autri_midi_output(void *addr, int d)
! 1601: {
! 1602: struct autri_softc *sc = addr;
! 1603: int x;
! 1604:
! 1605: for (x = 0; x != MIDI_BUSY_WAIT; x++) {
! 1606: if ((TREAD1(sc, AUTRI_MPUR1) & AUTRI_MIDIOUT_READY) == 0) {
! 1607: TWRITE1(sc, AUTRI_MPUR0, d);
! 1608: return (0);
! 1609: }
! 1610: delay(MIDI_BUSY_DELAY);
! 1611: }
! 1612: return (EIO);
! 1613: }
! 1614:
! 1615: void
! 1616: autri_midi_getinfo(void *addr, struct midi_info *mi)
! 1617: {
! 1618: mi->name = "4DWAVE MIDI UART";
! 1619: mi->props = MIDI_PROP_CAN_INPUT;
! 1620: }
! 1621:
! 1622: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to autri.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pci