Annotation of sys/dev/pci/esa.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: esa.c,v 1.11 2006/01/25 23:54:21 brad Exp $ */
! 2: /* $NetBSD: esa.c,v 1.12 2002/03/24 14:17:35 jmcneill Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 2001, 2002 Jared D. McNeill <jmcneill@invisible.ca>
! 6: * All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. The name of the author may not be used to endorse or promote products
! 14: * derived from this software without specific prior written permission.
! 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,
! 21: * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
! 22: * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
! 23: * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
! 24: * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 25: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 26: * SUCH DAMAGE.
! 27: */
! 28:
! 29: /*
! 30: * Shamelessly stolen from NetBSD who based it on FreeBSD's who in turn
! 31: * based it on Linux's driver. What a wonderful world.
! 32: *
! 33: *
! 34: * ESS Allegro-1 / Maestro3 Audio Driver
! 35: *
! 36: * Based on the FreeBSD maestro3 driver and the NetBSD eap driver.
! 37: * Original driver by Don Kim.
! 38: *
! 39: * The list management code could possibly be written better, but what
! 40: * we have right now does the job nicely. Thanks to Zach Brown <zab@zabbo.net>
! 41: * and Andrew MacDonald <amac@epsilon.yi.org> for helping me debug the
! 42: * problems with the original list management code present in the Linux
! 43: * driver.
! 44: */
! 45:
! 46: #include <sys/types.h>
! 47: #include <sys/errno.h>
! 48: #include <sys/param.h>
! 49: #include <sys/systm.h>
! 50: #include <sys/malloc.h>
! 51: #include <sys/device.h>
! 52: #include <sys/conf.h>
! 53: #include <sys/exec.h>
! 54: #include <sys/selinfo.h>
! 55: #include <sys/audioio.h>
! 56:
! 57: #include <machine/bus.h>
! 58: #include <machine/intr.h>
! 59:
! 60: #include <dev/pci/pcidevs.h>
! 61: #include <dev/pci/pcivar.h>
! 62:
! 63: #include <dev/audio_if.h>
! 64: #include <dev/mulaw.h>
! 65: #include <dev/auconv.h>
! 66: #include <dev/ic/ac97.h>
! 67:
! 68: #include <dev/pci/esareg.h>
! 69: #include <dev/pci/esavar.h>
! 70: #include <dev/microcode/esa/esadsp.h>
! 71:
! 72: #define PCI_CBIO 0x10
! 73:
! 74: #define ESA_DAC_DATA 0x1100
! 75:
! 76: enum {
! 77: ESS_ALLEGRO1,
! 78: ESS_MAESTRO3
! 79: };
! 80:
! 81: static struct esa_card_type {
! 82: u_int16_t pci_vendor_id;
! 83: u_int16_t pci_product_id;
! 84: int type;
! 85: int delay1, delay2;
! 86: } esa_card_types[] = {
! 87: { PCI_VENDOR_ESSTECH, PCI_PRODUCT_ESSTECH_ES1989,
! 88: ESS_ALLEGRO1, 50, 800 },
! 89: { PCI_VENDOR_ESSTECH, PCI_PRODUCT_ESSTECH_MAESTRO3,
! 90: ESS_MAESTRO3, 20, 500 },
! 91: { PCI_VENDOR_ESSTECH, PCI_PRODUCT_ESSTECH_MAESTRO3_2,
! 92: ESS_MAESTRO3, 20, 500 },
! 93: { 0, 0, 0, 0, 0 }
! 94: };
! 95:
! 96: struct audio_device esa_device = {
! 97: "ESS Allegro",
! 98: "",
! 99: "esa"
! 100: };
! 101:
! 102: int esa_match(struct device *, void *, void *);
! 103: void esa_attach(struct device *, struct device *, void *);
! 104: int esa_detach(struct device *, int);
! 105:
! 106: /* audio(9) functions */
! 107: int esa_open(void *, int);
! 108: void esa_close(void *);
! 109: int esa_query_encoding(void *, struct audio_encoding *);
! 110: int esa_set_params(void *, int, int, struct audio_params *,
! 111: struct audio_params *);
! 112: int esa_round_blocksize(void *, int);
! 113: int esa_commit_settings(void *);
! 114: int esa_halt_output(void *);
! 115: int esa_halt_input(void *);
! 116: int esa_set_port(void *, mixer_ctrl_t *);
! 117: int esa_get_port(void *, mixer_ctrl_t *);
! 118: int esa_query_devinfo(void *, mixer_devinfo_t *);
! 119: void * esa_malloc(void *, int, size_t, int, int);
! 120: void esa_free(void *, void *, int);
! 121: int esa_getdev(void *, struct audio_device *);
! 122: size_t esa_round_buffersize(void *, int, size_t);
! 123: int esa_get_props(void *);
! 124: int esa_trigger_output(void *, void *, void *, int,
! 125: void (*)(void *), void *,
! 126: struct audio_params *);
! 127: int esa_trigger_input(void *, void *, void *, int,
! 128: void (*)(void *), void *,
! 129: struct audio_params *);
! 130:
! 131: int esa_intr(void *);
! 132: int esa_allocmem(struct esa_softc *, size_t, size_t,
! 133: struct esa_dma *);
! 134: int esa_freemem(struct esa_softc *, struct esa_dma *);
! 135: paddr_t esa_mappage(void *addr, void *mem, off_t off, int prot);
! 136:
! 137: /* Supporting subroutines */
! 138: u_int16_t esa_read_assp(struct esa_softc *, u_int16_t, u_int16_t);
! 139: void esa_write_assp(struct esa_softc *, u_int16_t, u_int16_t,
! 140: u_int16_t);
! 141: int esa_init_codec(struct esa_softc *);
! 142: int esa_attach_codec(void *, struct ac97_codec_if *);
! 143: int esa_read_codec(void *, u_int8_t, u_int16_t *);
! 144: int esa_write_codec(void *, u_int8_t, u_int16_t);
! 145: void esa_reset_codec(void *);
! 146: enum ac97_host_flags esa_flags_codec(void *);
! 147: int esa_wait(struct esa_softc *);
! 148: int esa_init(struct esa_softc *);
! 149: void esa_config(struct esa_softc *);
! 150: u_int8_t esa_assp_halt(struct esa_softc *);
! 151: void esa_codec_reset(struct esa_softc *);
! 152: int esa_amp_enable(struct esa_softc *);
! 153: void esa_enable_interrupts(struct esa_softc *);
! 154: u_int32_t esa_get_pointer(struct esa_softc *, struct esa_channel *);
! 155:
! 156: /* list management */
! 157: int esa_add_list(struct esa_voice *, struct esa_list *, u_int16_t,
! 158: int);
! 159: void esa_remove_list(struct esa_voice *, struct esa_list *, int);
! 160:
! 161: /* power management */
! 162: int esa_power(struct esa_softc *, int);
! 163: void esa_powerhook(int, void *);
! 164: int esa_suspend(struct esa_softc *);
! 165: int esa_resume(struct esa_softc *);
! 166:
! 167: static audio_encoding_t esa_encoding[] = {
! 168: { 0, AudioEulinear, AUDIO_ENCODING_ULINEAR, 8, 0 },
! 169: { 1, AudioEmulaw, AUDIO_ENCODING_ULAW, 8,
! 170: AUDIO_ENCODINGFLAG_EMULATED },
! 171: { 2, AudioEalaw, AUDIO_ENCODING_ALAW, 8, AUDIO_ENCODINGFLAG_EMULATED },
! 172: { 3, AudioEslinear, AUDIO_ENCODING_SLINEAR, 8,
! 173: AUDIO_ENCODINGFLAG_EMULATED }, /* XXX: Are you sure? */
! 174: { 4, AudioEslinear_le, AUDIO_ENCODING_SLINEAR_LE, 16, 0 },
! 175: { 5, AudioEulinear_le, AUDIO_ENCODING_ULINEAR_LE, 16,
! 176: AUDIO_ENCODINGFLAG_EMULATED },
! 177: { 6, AudioEslinear_be, AUDIO_ENCODING_SLINEAR_BE, 16,
! 178: AUDIO_ENCODINGFLAG_EMULATED },
! 179: { 7, AudioEulinear_be, AUDIO_ENCODING_ULINEAR_BE, 16,
! 180: AUDIO_ENCODINGFLAG_EMULATED }
! 181: };
! 182:
! 183: #define ESA_NENCODINGS 8
! 184:
! 185: struct audio_hw_if esa_hw_if = {
! 186: esa_open,
! 187: esa_close,
! 188: NULL, /* drain */
! 189: esa_query_encoding,
! 190: esa_set_params,
! 191: esa_round_blocksize,
! 192: esa_commit_settings,
! 193: NULL, /* init_output */
! 194: NULL, /* init_input */
! 195: NULL, /* start_output */
! 196: NULL, /* start_input */
! 197: esa_halt_output,
! 198: esa_halt_input,
! 199: NULL, /* speaker_ctl */
! 200: esa_getdev,
! 201: NULL, /* getfd */
! 202: esa_set_port,
! 203: esa_get_port,
! 204: esa_query_devinfo,
! 205: esa_malloc,
! 206: esa_free,
! 207: esa_round_buffersize,
! 208: esa_mappage,
! 209: esa_get_props,
! 210: esa_trigger_output,
! 211: esa_trigger_input
! 212: };
! 213:
! 214: struct cfdriver esa_cd = {
! 215: NULL, "esa", DV_DULL
! 216: };
! 217:
! 218: struct cfattach esa_ca = {
! 219: sizeof(struct esa_softc), esa_match, esa_attach,
! 220: esa_detach, /*esa_activate*/ NULL
! 221: };
! 222:
! 223: /*
! 224: * audio(9) functions
! 225: */
! 226:
! 227: int
! 228: esa_open(void *hdl, int flags)
! 229: {
! 230:
! 231: return (0);
! 232: }
! 233:
! 234: void
! 235: esa_close(void *hdl)
! 236: {
! 237:
! 238: return;
! 239: }
! 240:
! 241: int
! 242: esa_query_encoding(void *hdl, struct audio_encoding *ae)
! 243: {
! 244:
! 245: if (ae->index < 0 || ae->index >= ESA_NENCODINGS)
! 246: return (EINVAL);
! 247: *ae = esa_encoding[ae->index];
! 248:
! 249: return (0);
! 250: }
! 251:
! 252: int
! 253: esa_set_params(void *hdl, int setmode, int usemode, struct audio_params *play,
! 254: struct audio_params *rec)
! 255: {
! 256: struct esa_voice *vc = hdl;
! 257: //struct esa_softc *sc = (struct esa_softc *)vc->parent;
! 258: struct esa_channel *ch;
! 259: struct audio_params *p;
! 260: int mode;
! 261:
! 262: for (mode = AUMODE_RECORD; mode != -1;
! 263: mode = (mode == AUMODE_RECORD) ? AUMODE_PLAY : -1) {
! 264: if ((setmode & mode) == 0)
! 265: continue;
! 266:
! 267: switch (mode) {
! 268: case AUMODE_PLAY:
! 269: p = play;
! 270: ch = &vc->play;
! 271: break;
! 272: case AUMODE_RECORD:
! 273: p = rec;
! 274: ch = &vc->rec;
! 275: break;
! 276: }
! 277:
! 278: if (p->sample_rate < ESA_MINRATE ||
! 279: p->sample_rate > ESA_MAXRATE ||
! 280: (p->precision != 8 && p->precision != 16) ||
! 281: (p->channels < 1 || p->channels > 2))
! 282: return (EINVAL);
! 283:
! 284: p->factor = 1;
! 285: p->sw_code = 0;
! 286:
! 287: switch(p->encoding) {
! 288: case AUDIO_ENCODING_SLINEAR_BE:
! 289: if (p->precision == 16)
! 290: p->sw_code = swap_bytes;
! 291: else
! 292: p->sw_code = change_sign8;
! 293: break;
! 294: case AUDIO_ENCODING_SLINEAR_LE:
! 295: if (p->precision != 16)
! 296: p->sw_code = change_sign8;
! 297: break;
! 298: case AUDIO_ENCODING_ULINEAR_BE:
! 299: if (p->precision == 16) {
! 300: if (mode == AUMODE_PLAY)
! 301: p->sw_code =
! 302: swap_bytes_change_sign16_le;
! 303: else
! 304: p->sw_code =
! 305: change_sign16_swap_bytes_le;
! 306: }
! 307: break;
! 308: case AUDIO_ENCODING_ULINEAR_LE:
! 309: if (p->precision == 16)
! 310: p->sw_code = change_sign16_le;
! 311: break;
! 312: case AUDIO_ENCODING_ULAW:
! 313: if (mode == AUMODE_PLAY) {
! 314: p->factor = 2;
! 315: p->sw_code = mulaw_to_slinear16_le;
! 316: } else
! 317: p->sw_code = ulinear8_to_mulaw;
! 318: break;
! 319: case AUDIO_ENCODING_ALAW:
! 320: if (mode == AUMODE_PLAY) {
! 321: p->factor = 2;
! 322: p->sw_code = alaw_to_slinear16_le;
! 323: } else
! 324: p->sw_code = ulinear8_to_alaw;
! 325: break;
! 326: default:
! 327: return (EINVAL);
! 328: }
! 329:
! 330: ch->mode = *p;
! 331: }
! 332:
! 333: return (0);
! 334: }
! 335:
! 336: int
! 337: esa_commit_settings(void *hdl)
! 338: {
! 339: struct esa_voice *vc = hdl;
! 340: struct esa_softc *sc = (struct esa_softc *)vc->parent;
! 341: struct audio_params *p = &vc->play.mode;
! 342: struct audio_params *r = &vc->rec.mode;
! 343: u_int32_t data;
! 344: u_int32_t freq;
! 345: int data_bytes = (((ESA_MINISRC_TMP_BUFFER_SIZE & ~1) +
! 346: (ESA_MINISRC_IN_BUFFER_SIZE & ~1) +
! 347: (ESA_MINISRC_OUT_BUFFER_SIZE & ~1) + 4) + 255)
! 348: &~ 255;
! 349:
! 350: /* playback */
! 351: vc->play.data_offset = ESA_DAC_DATA + (data_bytes * vc->index);
! 352: if (p->channels == 1)
! 353: data = 1;
! 354: else
! 355: data = 0;
! 356: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 357: vc->play.data_offset + ESA_SRC3_MODE_OFFSET,
! 358: data);
! 359: if (p->precision * p->factor == 8)
! 360: data = 1;
! 361: else
! 362: data = 0;
! 363: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 364: vc->play.data_offset + ESA_SRC3_WORD_LENGTH_OFFSET,
! 365: data);
! 366: if ((freq = ((p->sample_rate << 15) + 24000) / 48000) != 0) {
! 367: freq--;
! 368: }
! 369: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 370: vc->play.data_offset + ESA_CDATA_FREQUENCY, freq);
! 371:
! 372: /* recording */
! 373: vc->rec.data_offset = ESA_DAC_DATA + (data_bytes * vc->index) +
! 374: (data_bytes / 2);
! 375: if (r->channels == 1)
! 376: data = 1;
! 377: else
! 378: data = 0;
! 379: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 380: vc->rec.data_offset + ESA_SRC3_MODE_OFFSET,
! 381: data);
! 382: if (r->precision * r->factor == 8)
! 383: data = 1;
! 384: else
! 385: data = 0;
! 386: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 387: vc->rec.data_offset + ESA_SRC3_WORD_LENGTH_OFFSET,
! 388: data);
! 389: if ((freq = ((r->sample_rate << 15) + 24000) / 48000) != 0) {
! 390: freq--;
! 391: }
! 392: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 393: vc->rec.data_offset + ESA_CDATA_FREQUENCY, freq);
! 394:
! 395: return (0);
! 396: };
! 397:
! 398: int
! 399: esa_round_blocksize(void *hdl, int bs)
! 400: {
! 401: struct esa_voice *vc = hdl;
! 402:
! 403: /*
! 404: * Surely there has to be a better solution...
! 405: */
! 406: vc->play.blksize = vc->rec.blksize = 4096;
! 407:
! 408: return (vc->play.blksize);
! 409: }
! 410:
! 411: int
! 412: esa_halt_output(void *hdl)
! 413: {
! 414: struct esa_voice *vc = hdl;
! 415: struct esa_softc *sc = (struct esa_softc *)vc->parent;
! 416: bus_space_tag_t iot = sc->sc_iot;
! 417: bus_space_handle_t ioh = sc->sc_ioh;
! 418: u_int16_t data;
! 419:
! 420: if (vc->play.active == 0)
! 421: return (0);
! 422:
! 423: vc->play.active = 0;
! 424:
! 425: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 426: ESA_CDATA_INSTANCE_READY + vc->play.data_offset, 0);
! 427:
! 428: sc->sc_ntimers--;
! 429: if (sc->sc_ntimers == 0) {
! 430: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 431: ESA_KDATA_TIMER_COUNT_RELOAD, 0);
! 432: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 433: ESA_KDATA_TIMER_COUNT_CURRENT, 0);
! 434: data = bus_space_read_2(iot, ioh, ESA_HOST_INT_CTRL);
! 435: bus_space_write_2(iot, ioh, ESA_HOST_INT_CTRL,
! 436: data & ~ESA_CLKRUN_GEN_ENABLE);
! 437: }
! 438:
! 439: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 440: ESA_KDATA_MIXER_TASK_NUMBER,
! 441: sc->mixer_list.indexmap[vc->index]);
! 442: /* remove ourselves from the packed lists */
! 443: esa_remove_list(vc, &sc->mixer_list, vc->index);
! 444: esa_remove_list(vc, &sc->dma_list, vc->index);
! 445: esa_remove_list(vc, &sc->msrc_list, vc->index);
! 446:
! 447: return (0);
! 448: }
! 449:
! 450: int
! 451: esa_halt_input(void *hdl)
! 452: {
! 453: struct esa_voice *vc = hdl;
! 454: struct esa_softc *sc = (struct esa_softc *)vc->parent;
! 455: bus_space_tag_t iot = sc->sc_iot;
! 456: bus_space_handle_t ioh = sc->sc_ioh;
! 457: u_int32_t data;
! 458:
! 459: if (vc->rec.active == 0)
! 460: return (0);
! 461:
! 462: vc->rec.active = 0;
! 463:
! 464: sc->sc_ntimers--;
! 465: if (sc->sc_ntimers == 0) {
! 466: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 467: ESA_KDATA_TIMER_COUNT_RELOAD, 0);
! 468: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 469: ESA_KDATA_TIMER_COUNT_CURRENT, 0);
! 470: data = bus_space_read_2(iot, ioh, ESA_HOST_INT_CTRL);
! 471: bus_space_write_2(iot, ioh, ESA_HOST_INT_CTRL,
! 472: data & ~ESA_CLKRUN_GEN_ENABLE);
! 473: }
! 474:
! 475: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, vc->rec.data_offset +
! 476: ESA_CDATA_INSTANCE_READY, 0);
! 477: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, ESA_KDATA_ADC1_REQUEST,
! 478: 0);
! 479:
! 480: /* remove ourselves from the packed lists */
! 481: esa_remove_list(vc, &sc->adc1_list, vc->index + ESA_NUM_VOICES);
! 482: esa_remove_list(vc, &sc->dma_list, vc->index + ESA_NUM_VOICES);
! 483: esa_remove_list(vc, &sc->msrc_list, vc->index + ESA_NUM_VOICES);
! 484:
! 485: return (0);
! 486: }
! 487:
! 488: void *
! 489: esa_malloc(void *hdl, int direction, size_t size, int type, int flags)
! 490: {
! 491: struct esa_voice *vc = hdl;
! 492: struct esa_softc *sc = (struct esa_softc *)vc->parent;
! 493: struct esa_dma *p;
! 494: int error;
! 495:
! 496: p = malloc(sizeof(*p), type, flags);
! 497: if (!p)
! 498: return (0);
! 499: error = esa_allocmem(sc, size, 16, p);
! 500: if (error) {
! 501: free(p, type);
! 502: printf("%s: esa_malloc: not enough memory\n",
! 503: sc->sc_dev.dv_xname);
! 504: return (0);
! 505: }
! 506: p->next = vc->dma;
! 507: vc->dma = p;
! 508:
! 509: return (KERNADDR(p));
! 510: }
! 511:
! 512: void
! 513: esa_free(void *hdl, void *addr, int type)
! 514: {
! 515: struct esa_voice *vc = hdl;
! 516: struct esa_softc *sc = (struct esa_softc *)vc->parent;
! 517: struct esa_dma *p;
! 518: struct esa_dma **pp;
! 519:
! 520: for (pp = &vc->dma; (p = *pp) != NULL; pp = &p->next)
! 521: if (KERNADDR(p) == addr) {
! 522: esa_freemem(sc, p);
! 523: *pp = p->next;
! 524: free(p, type);
! 525: return;
! 526: }
! 527: }
! 528:
! 529: int
! 530: esa_getdev(void *hdl, struct audio_device *ret)
! 531: {
! 532:
! 533: *ret = esa_device;
! 534:
! 535: return (0);
! 536: }
! 537:
! 538: int
! 539: esa_set_port(void *hdl, mixer_ctrl_t *mc)
! 540: {
! 541: struct esa_voice *vc = hdl;
! 542: struct esa_softc *sc = (struct esa_softc *)vc->parent;
! 543:
! 544: return (sc->codec_if->vtbl->mixer_set_port(sc->codec_if, mc));
! 545: }
! 546:
! 547: int
! 548: esa_get_port(void *hdl, mixer_ctrl_t *mc)
! 549: {
! 550: struct esa_voice *vc = hdl;
! 551: struct esa_softc *sc = (struct esa_softc *)vc->parent;
! 552:
! 553: return (sc->codec_if->vtbl->mixer_get_port(sc->codec_if, mc));
! 554: }
! 555:
! 556: int
! 557: esa_query_devinfo(void *hdl, mixer_devinfo_t *di)
! 558: {
! 559: struct esa_voice *vc = hdl;
! 560: struct esa_softc *sc = (struct esa_softc *)vc->parent;
! 561:
! 562: return (sc->codec_if->vtbl->query_devinfo(sc->codec_if, di));
! 563: }
! 564:
! 565: size_t
! 566: esa_round_buffersize(void *hdl, int direction, size_t bufsize)
! 567: {
! 568: struct esa_voice *vc = hdl;
! 569:
! 570: /*
! 571: * We must be able to do better than this...
! 572: */
! 573: vc->play.bufsize = vc->rec.bufsize = 65536;
! 574:
! 575: return (vc->play.bufsize);
! 576: }
! 577:
! 578: int
! 579: esa_get_props(void *hdl)
! 580: {
! 581:
! 582: return (AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT | AUDIO_PROP_FULLDUPLEX);
! 583: }
! 584:
! 585: int
! 586: esa_trigger_output(void *hdl, void *start, void *end, int blksize,
! 587: void (*intr)(void *), void *intrarg,
! 588: struct audio_params *param)
! 589: {
! 590: struct esa_voice *vc = hdl;
! 591: struct esa_softc *sc = (struct esa_softc *)vc->parent;
! 592: struct esa_dma *p;
! 593: bus_space_tag_t iot = sc->sc_iot;
! 594: bus_space_handle_t ioh = sc->sc_ioh;
! 595: u_int32_t data;
! 596: u_int32_t bufaddr;
! 597: u_int32_t i;
! 598: size_t size;
! 599:
! 600: int data_bytes = (((ESA_MINISRC_TMP_BUFFER_SIZE & ~1) +
! 601: (ESA_MINISRC_IN_BUFFER_SIZE & ~1) +
! 602: (ESA_MINISRC_OUT_BUFFER_SIZE & ~1) + 4) + 255)
! 603: &~ 255;
! 604: int dac_data = ESA_DAC_DATA + (data_bytes * vc->index);
! 605: int dsp_in_size = ESA_MINISRC_IN_BUFFER_SIZE - (0x20 * 2);
! 606: int dsp_out_size = ESA_MINISRC_OUT_BUFFER_SIZE - (0x20 * 2);
! 607: int dsp_in_buf = dac_data + (ESA_MINISRC_TMP_BUFFER_SIZE / 2);
! 608: int dsp_out_buf = dsp_in_buf + (dsp_in_size / 2) + 1;
! 609:
! 610: if (vc->play.active)
! 611: return (EINVAL);
! 612:
! 613: for (p = vc->dma; p && KERNADDR(p) != start; p = p->next)
! 614: ;
! 615: if (!p) {
! 616: printf("%s: esa_trigger_output: bad addr %p\n",
! 617: sc->sc_dev.dv_xname, start);
! 618: return (EINVAL);
! 619: }
! 620:
! 621: vc->play.active = 1;
! 622: vc->play.intr = intr;
! 623: vc->play.arg = intrarg;
! 624: vc->play.pos = 0;
! 625: vc->play.count = 0;
! 626: vc->play.buf = start;
! 627: size = (size_t)(((caddr_t)end - (caddr_t)start));
! 628: bufaddr = DMAADDR(p);
! 629: vc->play.start = bufaddr;
! 630:
! 631: #define LO(x) ((x) & 0x0000ffff)
! 632: #define HI(x) ((x) >> 16)
! 633:
! 634: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 635: ESA_CDATA_HOST_SRC_ADDRL, LO(bufaddr));
! 636: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 637: ESA_CDATA_HOST_SRC_ADDRH, HI(bufaddr));
! 638: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 639: ESA_CDATA_HOST_SRC_END_PLUS_1L, LO(bufaddr + size));
! 640: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 641: ESA_CDATA_HOST_SRC_END_PLUS_1H, HI(bufaddr + size));
! 642: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 643: ESA_CDATA_HOST_SRC_CURRENTL, LO(bufaddr));
! 644: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 645: ESA_CDATA_HOST_SRC_CURRENTH, HI(bufaddr));
! 646:
! 647: /* DSP buffers */
! 648: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 649: ESA_CDATA_IN_BUF_BEGIN, dsp_in_buf);
! 650: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 651: ESA_CDATA_IN_BUF_END_PLUS_1, dsp_in_buf + (dsp_in_size / 2));
! 652: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 653: ESA_CDATA_IN_BUF_HEAD, dsp_in_buf);
! 654: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 655: ESA_CDATA_IN_BUF_TAIL, dsp_in_buf);
! 656: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 657: ESA_CDATA_OUT_BUF_BEGIN, dsp_out_buf);
! 658: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 659: ESA_CDATA_OUT_BUF_END_PLUS_1, dsp_out_buf + (dsp_out_size / 2));
! 660: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 661: ESA_CDATA_OUT_BUF_HEAD, dsp_out_buf);
! 662: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 663: ESA_CDATA_OUT_BUF_TAIL, dsp_out_buf);
! 664:
! 665: /* Some per-client initializers */
! 666: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 667: ESA_SRC3_DIRECTION_OFFSET + 12, dac_data + 40 + 8);
! 668: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 669: ESA_SRC3_DIRECTION_OFFSET + 19, 0x400 + ESA_MINISRC_COEF_LOC);
! 670: /* Enable or disable low-pass filter? (0xff if rate > 45000) */
! 671: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 672: ESA_SRC3_DIRECTION_OFFSET + 22,
! 673: vc->play.mode.sample_rate > 45000 ? 0xff : 0);
! 674: /* Tell it which way DMA is going */
! 675: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 676: ESA_CDATA_DMA_CONTROL,
! 677: ESA_DMACONTROL_AUTOREPEAT + ESA_DMAC_PAGE3_SELECTOR +
! 678: ESA_DMAC_BLOCKF_SELECTOR);
! 679:
! 680: /* Set an armload of static initializers */
! 681: for (i = 0; i < (sizeof(esa_playvals) / sizeof(esa_playvals[0])); i++)
! 682: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 683: esa_playvals[i].addr, esa_playvals[i].val);
! 684:
! 685: /* Put us in the packed task lists */
! 686: esa_add_list(vc, &sc->msrc_list, dac_data >> ESA_DP_SHIFT_COUNT,
! 687: vc->index);
! 688: esa_add_list(vc, &sc->dma_list, dac_data >> ESA_DP_SHIFT_COUNT,
! 689: vc->index);
! 690: esa_add_list(vc, &sc->mixer_list, dac_data >> ESA_DP_SHIFT_COUNT,
! 691: vc->index);
! 692: #undef LO
! 693: #undef HI
! 694:
! 695: /* XXX */
! 696: //esa_commit_settings(vc);
! 697:
! 698: sc->sc_ntimers++;
! 699:
! 700: if (sc->sc_ntimers == 1) {
! 701: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 702: ESA_KDATA_TIMER_COUNT_RELOAD, 240);
! 703: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 704: ESA_KDATA_TIMER_COUNT_CURRENT, 240);
! 705: data = bus_space_read_2(iot, ioh, ESA_HOST_INT_CTRL);
! 706: bus_space_write_2(iot, ioh, ESA_HOST_INT_CTRL,
! 707: data | ESA_CLKRUN_GEN_ENABLE);
! 708: }
! 709:
! 710: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, dac_data +
! 711: ESA_CDATA_INSTANCE_READY, 1);
! 712: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 713: ESA_KDATA_MIXER_TASK_NUMBER,
! 714: sc->mixer_list.indexmap[vc->index]);
! 715:
! 716: return (0);
! 717: }
! 718:
! 719: int
! 720: esa_trigger_input(void *hdl, void *start, void *end, int blksize,
! 721: void (*intr)(void *), void *intrarg,
! 722: struct audio_params *param)
! 723: {
! 724: struct esa_voice *vc = hdl;
! 725: struct esa_softc *sc = (struct esa_softc *)vc->parent;
! 726: struct esa_dma *p;
! 727: bus_space_tag_t iot = sc->sc_iot;
! 728: bus_space_handle_t ioh = sc->sc_ioh;
! 729: u_int32_t data;
! 730: u_int32_t bufaddr;
! 731: u_int32_t i;
! 732: size_t size;
! 733: int data_bytes = (((ESA_MINISRC_TMP_BUFFER_SIZE & ~1) +
! 734: (ESA_MINISRC_IN_BUFFER_SIZE & ~1) +
! 735: (ESA_MINISRC_OUT_BUFFER_SIZE & ~1) + 4) + 255)
! 736: &~ 255;
! 737: int adc_data = ESA_DAC_DATA + (data_bytes * vc->index) +
! 738: (data_bytes / 2);
! 739: int dsp_in_size = ESA_MINISRC_IN_BUFFER_SIZE - (0x10 * 2);
! 740: int dsp_out_size = ESA_MINISRC_OUT_BUFFER_SIZE - (0x10 * 2);
! 741: int dsp_in_buf = adc_data + (ESA_MINISRC_TMP_BUFFER_SIZE / 2);
! 742: int dsp_out_buf = dsp_in_buf + (dsp_in_size / 2) + 1;
! 743: vc->rec.data_offset = adc_data;
! 744:
! 745: /* We only support 1 recording channel */
! 746: if (vc->index > 0)
! 747: return (ENODEV);
! 748:
! 749: if (vc->rec.active)
! 750: return (EINVAL);
! 751:
! 752: for (p = vc->dma; p && KERNADDR(p) != start; p = p->next)
! 753: ;
! 754: if (!p) {
! 755: printf("%s: esa_trigger_input: bad addr %p\n",
! 756: sc->sc_dev.dv_xname, start);
! 757: return (EINVAL);
! 758: }
! 759:
! 760: vc->rec.active = 1;
! 761: vc->rec.intr = intr;
! 762: vc->rec.arg = intrarg;
! 763: vc->rec.pos = 0;
! 764: vc->rec.count = 0;
! 765: vc->rec.buf = start;
! 766: size = (size_t)(((caddr_t)end - (caddr_t)start));
! 767: bufaddr = DMAADDR(p);
! 768: vc->rec.start = bufaddr;
! 769:
! 770: #define LO(x) ((x) & 0x0000ffff)
! 771: #define HI(x) ((x) >> 16)
! 772:
! 773: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 774: ESA_CDATA_HOST_SRC_ADDRL, LO(bufaddr));
! 775: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 776: ESA_CDATA_HOST_SRC_ADDRH, HI(bufaddr));
! 777: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 778: ESA_CDATA_HOST_SRC_END_PLUS_1L, LO(bufaddr + size));
! 779: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 780: ESA_CDATA_HOST_SRC_END_PLUS_1H, HI(bufaddr + size));
! 781: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 782: ESA_CDATA_HOST_SRC_CURRENTL, LO(bufaddr));
! 783: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 784: ESA_CDATA_HOST_SRC_CURRENTH, HI(bufaddr));
! 785:
! 786: /* DSP buffers */
! 787: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 788: ESA_CDATA_IN_BUF_BEGIN, dsp_in_buf);
! 789: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 790: ESA_CDATA_IN_BUF_END_PLUS_1, dsp_in_buf + (dsp_in_size / 2));
! 791: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 792: ESA_CDATA_IN_BUF_HEAD, dsp_in_buf);
! 793: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 794: ESA_CDATA_IN_BUF_TAIL, dsp_in_buf);
! 795: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 796: ESA_CDATA_OUT_BUF_BEGIN, dsp_out_buf);
! 797: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 798: ESA_CDATA_OUT_BUF_END_PLUS_1, dsp_out_buf + (dsp_out_size / 2));
! 799: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 800: ESA_CDATA_OUT_BUF_HEAD, dsp_out_buf);
! 801: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 802: ESA_CDATA_OUT_BUF_TAIL, dsp_out_buf);
! 803:
! 804: /* Some per-client initializers */
! 805: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 806: ESA_SRC3_DIRECTION_OFFSET + 12, adc_data + 40 + 8);
! 807: /* Tell it which way DMA is going */
! 808: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 809: ESA_CDATA_DMA_CONTROL,
! 810: ESA_DMACONTROL_DIRECTION + ESA_DMACONTROL_AUTOREPEAT +
! 811: ESA_DMAC_PAGE3_SELECTOR + ESA_DMAC_BLOCKF_SELECTOR);
! 812:
! 813: /* Set an armload of static initializers */
! 814: for (i = 0; i < (sizeof(esa_recvals) / sizeof(esa_recvals[0])); i++)
! 815: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 816: esa_recvals[i].addr, esa_recvals[i].val);
! 817:
! 818: /* Put us in the packed task lists */
! 819: esa_add_list(vc, &sc->adc1_list, adc_data >> ESA_DP_SHIFT_COUNT,
! 820: vc->index + ESA_NUM_VOICES);
! 821: esa_add_list(vc, &sc->msrc_list, adc_data >> ESA_DP_SHIFT_COUNT,
! 822: vc->index + ESA_NUM_VOICES);
! 823: esa_add_list(vc, &sc->dma_list, adc_data >> ESA_DP_SHIFT_COUNT,
! 824: vc->index + ESA_NUM_VOICES);
! 825: #undef LO
! 826: #undef HI
! 827:
! 828: /* XXX */
! 829: //esa_commit_settings(vc);
! 830:
! 831: sc->sc_ntimers++;
! 832: if (sc->sc_ntimers == 1) {
! 833: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 834: ESA_KDATA_TIMER_COUNT_RELOAD, 240);
! 835: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 836: ESA_KDATA_TIMER_COUNT_CURRENT, 240);
! 837: data = bus_space_read_2(iot, ioh, ESA_HOST_INT_CTRL);
! 838: bus_space_write_2(iot, ioh, ESA_HOST_INT_CTRL,
! 839: data | ESA_CLKRUN_GEN_ENABLE);
! 840: }
! 841:
! 842: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, adc_data +
! 843: ESA_CDATA_INSTANCE_READY, 1);
! 844: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, ESA_KDATA_ADC1_REQUEST,
! 845: 1);
! 846:
! 847: return (0);
! 848: }
! 849:
! 850: /* Interrupt handler */
! 851:
! 852: int
! 853: esa_intr(void *hdl)
! 854: {
! 855: struct esa_softc *sc = hdl;
! 856: struct esa_voice *vc;
! 857: bus_space_tag_t iot = sc->sc_iot;
! 858: bus_space_handle_t ioh = sc->sc_ioh;
! 859: u_int8_t status, ctl;
! 860: u_int32_t pos;
! 861: u_int32_t diff;
! 862: u_int32_t play_blksize, play_bufsize;
! 863: u_int32_t rec_blksize, rec_bufsize;
! 864: int i;
! 865:
! 866: status = bus_space_read_1(iot, ioh, ESA_HOST_INT_STATUS);
! 867: if (status == 0xff)
! 868: return (0);
! 869:
! 870: /* ack the interrupt */
! 871: bus_space_write_1(iot, ioh, ESA_HOST_INT_STATUS, status);
! 872:
! 873: if (status & ESA_HV_INT_PENDING) {
! 874: u_int8_t event;
! 875:
! 876: printf("%s: hardware volume interrupt\n", sc->sc_dev.dv_xname);
! 877: event = bus_space_read_1(iot, ioh, ESA_HW_VOL_COUNTER_MASTER);
! 878: switch(event) {
! 879: case 0x99:
! 880: case 0xaa:
! 881: case 0x66:
! 882: case 0x88:
! 883: printf("%s: esa_intr: FIXME\n", sc->sc_dev.dv_xname);
! 884: break;
! 885: default:
! 886: printf("%s: unknown hwvol event 0x%02x\n",
! 887: sc->sc_dev.dv_xname, event);
! 888: break;
! 889: }
! 890: bus_space_write_1(iot, ioh, ESA_HW_VOL_COUNTER_MASTER, 0x88);
! 891: }
! 892:
! 893: if (status & ESA_ASSP_INT_PENDING) {
! 894: ctl = bus_space_read_1(iot, ioh, ESA_ASSP_CONTROL_B);
! 895: if (!(ctl & ESA_STOP_ASSP_CLOCK)) {
! 896: ctl = bus_space_read_1(iot, ioh,
! 897: ESA_ASSP_HOST_INT_STATUS);
! 898: if (ctl & ESA_DSP2HOST_REQ_TIMER) {
! 899: bus_space_write_1(iot, ioh,
! 900: ESA_ASSP_HOST_INT_STATUS,
! 901: ESA_DSP2HOST_REQ_TIMER);
! 902: for (i = 0; i < ESA_NUM_VOICES; i++) {
! 903: vc = &sc->voice[i];
! 904: if (vc->play.active) {
! 905: play_blksize = vc->play.blksize;
! 906: play_bufsize = vc->play.bufsize;
! 907: pos = esa_get_pointer(sc, &vc->play)
! 908: % play_bufsize;
! 909: diff = (play_bufsize + pos - vc->play.pos)
! 910: % play_bufsize;
! 911: vc->play.pos = pos;
! 912: vc->play.count += diff;
! 913: while(vc->play.count >= play_blksize) {
! 914: vc->play.count -= play_blksize;
! 915: (*vc->play.intr)(vc->play.arg);
! 916: }
! 917: }
! 918: if (vc->rec.active) {
! 919: rec_blksize = vc->rec.blksize;
! 920: rec_bufsize = vc->rec.bufsize;
! 921: pos = esa_get_pointer(sc, &vc->rec)
! 922: % rec_bufsize;
! 923: diff = (rec_bufsize + pos - vc->rec.pos)
! 924: % rec_bufsize;
! 925: vc->rec.pos = pos;
! 926: vc->rec.count += diff;
! 927: while(vc->rec.count >= rec_blksize) {
! 928: vc->rec.count -= rec_blksize;
! 929: (*vc->rec.intr)(vc->rec.arg);
! 930: }
! 931: }
! 932: }
! 933: }
! 934: }
! 935: }
! 936:
! 937: return (1);
! 938: }
! 939:
! 940: int
! 941: esa_allocmem(struct esa_softc *sc, size_t size, size_t align,
! 942: struct esa_dma *p)
! 943: {
! 944: int error;
! 945:
! 946: p->size = size;
! 947: error = bus_dmamem_alloc(sc->sc_dmat, p->size, align, 0,
! 948: p->segs, sizeof(p->segs) / sizeof(p->segs[0]),
! 949: &p->nsegs, BUS_DMA_NOWAIT);
! 950: if (error)
! 951: return (error);
! 952:
! 953: error = bus_dmamem_map(sc->sc_dmat, p->segs, p->nsegs, p->size,
! 954: &p->addr, BUS_DMA_NOWAIT | BUS_DMA_COHERENT);
! 955: if (error)
! 956: goto free;
! 957:
! 958: error = bus_dmamap_create(sc->sc_dmat, p->size, 1, p->size, 0,
! 959: BUS_DMA_NOWAIT, &p->map);
! 960: if (error)
! 961: goto unmap;
! 962:
! 963: error = bus_dmamap_load(sc->sc_dmat, p->map, p->addr, p->size, NULL,
! 964: BUS_DMA_NOWAIT);
! 965: if (error)
! 966: goto destroy;
! 967:
! 968: return (0);
! 969:
! 970: destroy:
! 971: bus_dmamap_destroy(sc->sc_dmat, p->map);
! 972: unmap:
! 973: bus_dmamem_unmap(sc->sc_dmat, p->addr, p->size);
! 974: free:
! 975: bus_dmamem_free(sc->sc_dmat, p->segs, p->nsegs);
! 976:
! 977: return (error);
! 978: }
! 979:
! 980: int
! 981: esa_freemem(struct esa_softc *sc, struct esa_dma *p)
! 982: {
! 983:
! 984: bus_dmamap_unload(sc->sc_dmat, p->map);
! 985: bus_dmamap_destroy(sc->sc_dmat, p->map);
! 986: bus_dmamem_unmap(sc->sc_dmat, p->addr, p->size);
! 987: bus_dmamem_free(sc->sc_dmat, p->segs, p->nsegs);
! 988:
! 989: return (0);
! 990: }
! 991:
! 992: /*
! 993: * Supporting Subroutines
! 994: */
! 995: const struct pci_matchid esa_devices[] = {
! 996: { PCI_VENDOR_ESSTECH, PCI_PRODUCT_ESSTECH_ES1989 },
! 997: { PCI_VENDOR_ESSTECH, PCI_PRODUCT_ESSTECH_MAESTRO3 },
! 998: { PCI_VENDOR_ESSTECH, PCI_PRODUCT_ESSTECH_MAESTRO3_2 },
! 999: };
! 1000:
! 1001: int
! 1002: esa_match(struct device *dev, void *match, void *aux)
! 1003: {
! 1004: return (pci_matchbyid((struct pci_attach_args *)aux, esa_devices,
! 1005: sizeof(esa_devices)/sizeof(esa_devices[0])));
! 1006: }
! 1007:
! 1008: void
! 1009: esa_attach(struct device *parent, struct device *self, void *aux)
! 1010: {
! 1011: struct esa_softc *sc = (struct esa_softc *)self;
! 1012: struct pci_attach_args *pa = (struct pci_attach_args *)aux;
! 1013: pcitag_t tag = pa->pa_tag;
! 1014: pci_chipset_tag_t pc = pa->pa_pc;
! 1015: pci_intr_handle_t ih;
! 1016: struct esa_card_type *card;
! 1017: const char *intrstr;
! 1018: int i, len;
! 1019:
! 1020: for (card = esa_card_types; card->pci_vendor_id; card++)
! 1021: if (PCI_VENDOR(pa->pa_id) == card->pci_vendor_id &&
! 1022: PCI_PRODUCT(pa->pa_id) == card->pci_product_id) {
! 1023: sc->type = card->type;
! 1024: sc->delay1 = card->delay1;
! 1025: sc->delay2 = card->delay2;
! 1026: break;
! 1027: }
! 1028:
! 1029: /* Map I/O register */
! 1030: if (pci_mapreg_map(pa, PCI_CBIO, PCI_MAPREG_TYPE_IO, 0,
! 1031: &sc->sc_iot, &sc->sc_ioh, &sc->sc_iob, &sc->sc_ios, 0)) {
! 1032: printf(": can't map i/o space\n");
! 1033: return;
! 1034: }
! 1035:
! 1036: /* Initialize softc */
! 1037: sc->sc_tag = tag;
! 1038: sc->sc_pct = pc;
! 1039: sc->sc_dmat = pa->pa_dmat;
! 1040:
! 1041: /* Map and establish an interrupt */
! 1042: if (pci_intr_map(pa, &ih)) {
! 1043: printf(": can't map interrupt\n");
! 1044: bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
! 1045: return;
! 1046: }
! 1047: intrstr = pci_intr_string(pc, ih);
! 1048: sc->sc_ih = pci_intr_establish(pc, ih, IPL_AUDIO, esa_intr, self,
! 1049: sc->sc_dev.dv_xname);
! 1050: if (sc->sc_ih == NULL) {
! 1051: printf(": can't establish interrupt");
! 1052: if (intrstr != NULL)
! 1053: printf(" at %s", intrstr);
! 1054: printf("\n");
! 1055: bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
! 1056: return;
! 1057: }
! 1058: printf(": %s\n", intrstr);
! 1059:
! 1060: /* Power up chip */
! 1061: esa_power(sc, PCI_PMCSR_STATE_D0);
! 1062:
! 1063: /* Init chip */
! 1064: if (esa_init(sc) == -1) {
! 1065: printf("%s: esa_attach: unable to initialize the card\n",
! 1066: sc->sc_dev.dv_xname);
! 1067: pci_intr_disestablish(pc, sc->sc_ih);
! 1068: bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
! 1069: return;
! 1070: }
! 1071:
! 1072: /* create suspend save area */
! 1073: len = sizeof(u_int16_t) * (ESA_REV_B_CODE_MEMORY_LENGTH
! 1074: + ESA_REV_B_DATA_MEMORY_LENGTH + 1);
! 1075: sc->savemem = (u_int16_t *)malloc(len, M_DEVBUF, M_NOWAIT);
! 1076: if (sc->savemem == NULL) {
! 1077: printf("%s: unable to allocate suspend buffer\n",
! 1078: sc->sc_dev.dv_xname);
! 1079: pci_intr_disestablish(pc, sc->sc_ih);
! 1080: bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
! 1081: return;
! 1082: }
! 1083: bzero(sc->savemem, len);
! 1084:
! 1085: /*
! 1086: * Every card I've seen has had their channels swapped with respect
! 1087: * to the mixer. Ie:
! 1088: * $ mixerctl -w outputs.master=0,191
! 1089: * Would result in the _right_ speaker being turned off.
! 1090: *
! 1091: * So, we will swap the left and right mixer channels to compensate
! 1092: * for this.
! 1093: */
! 1094: sc->codec_flags |= AC97_HOST_SWAPPED_CHANNELS;
! 1095: sc->codec_flags |= AC97_HOST_DONT_READ;
! 1096:
! 1097: /* Attach AC97 host interface */
! 1098: sc->host_if.arg = self;
! 1099: sc->host_if.attach = esa_attach_codec;
! 1100: sc->host_if.read = esa_read_codec;
! 1101: sc->host_if.write = esa_write_codec;
! 1102: sc->host_if.reset = esa_reset_codec;
! 1103: sc->host_if.flags = esa_flags_codec;
! 1104:
! 1105: if (ac97_attach(&sc->host_if) != 0) {
! 1106: pci_intr_disestablish(pc, sc->sc_ih);
! 1107: bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
! 1108: free(sc->savemem, M_DEVBUF);
! 1109: return;
! 1110: }
! 1111:
! 1112: /* initialize list management structures */
! 1113: sc->mixer_list.mem_addr = ESA_KDATA_MIXER_XFER0;
! 1114: sc->mixer_list.max = ESA_MAX_VIRTUAL_MIXER_CHANNELS;
! 1115: sc->adc1_list.mem_addr = ESA_KDATA_ADC1_XFER0;
! 1116: sc->adc1_list.max = ESA_MAX_VIRTUAL_ADC1_CHANNELS;
! 1117: sc->dma_list.mem_addr = ESA_KDATA_DMA_XFER0;
! 1118: sc->dma_list.max = ESA_MAX_VIRTUAL_DMA_CHANNELS;
! 1119: sc->msrc_list.mem_addr = ESA_KDATA_INSTANCE0_MINISRC;
! 1120: sc->msrc_list.max = ESA_MAX_INSTANCE_MINISRC;
! 1121:
! 1122: /* initialize index maps */
! 1123: for (i = 0; i < ESA_NUM_VOICES * 2; i++) {
! 1124: sc->mixer_list.indexmap[i] = -1;
! 1125: sc->msrc_list.indexmap[i] = -1;
! 1126: sc->dma_list.indexmap[i] = -1;
! 1127: sc->adc1_list.indexmap[i] = -1;
! 1128: }
! 1129: for (i = 0; i < ESA_NUM_VOICES; i++) {
! 1130: sc->voice[i].parent = (struct device *)sc;
! 1131: sc->voice[i].index = i;
! 1132: sc->sc_audiodev[i] =
! 1133: audio_attach_mi(&esa_hw_if, &sc->voice[i], &sc->sc_dev);
! 1134: }
! 1135:
! 1136: sc->powerhook = powerhook_establish(esa_powerhook, sc);
! 1137: if (sc->powerhook == NULL)
! 1138: printf("%s: WARNING: unable to establish powerhook\n",
! 1139: sc->sc_dev.dv_xname);
! 1140:
! 1141: return;
! 1142: }
! 1143:
! 1144: int
! 1145: esa_detach(struct device *self, int flags)
! 1146: {
! 1147: struct esa_softc *sc = (struct esa_softc *)self;
! 1148: int i;
! 1149:
! 1150: for (i = 0; i < ESA_NUM_VOICES; i++) {
! 1151: if (sc->sc_audiodev[i] != NULL)
! 1152: config_detach(sc->sc_audiodev[i], flags);
! 1153: }
! 1154:
! 1155: if (sc->sc_ih != NULL)
! 1156: pci_intr_disestablish(sc->sc_pct, sc->sc_ih);
! 1157: if (sc->sc_ios)
! 1158: bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
! 1159:
! 1160: free(sc->savemem, M_DEVBUF);
! 1161:
! 1162: return (0);
! 1163: }
! 1164:
! 1165: u_int16_t
! 1166: esa_read_assp(struct esa_softc *sc, u_int16_t region, u_int16_t index)
! 1167: {
! 1168: u_int16_t data;
! 1169: bus_space_tag_t iot = sc->sc_iot;
! 1170: bus_space_handle_t ioh = sc->sc_ioh;
! 1171:
! 1172: bus_space_write_2(iot, ioh, ESA_DSP_PORT_MEMORY_TYPE,
! 1173: region & ESA_MEMTYPE_MASK);
! 1174: bus_space_write_2(iot, ioh, ESA_DSP_PORT_MEMORY_INDEX, index);
! 1175: data = bus_space_read_2(iot, ioh, ESA_DSP_PORT_MEMORY_DATA);
! 1176:
! 1177: return (data);
! 1178: }
! 1179:
! 1180: void
! 1181: esa_write_assp(struct esa_softc *sc, u_int16_t region, u_int16_t index,
! 1182: u_int16_t data)
! 1183: {
! 1184: bus_space_tag_t iot = sc->sc_iot;
! 1185: bus_space_handle_t ioh = sc->sc_ioh;
! 1186:
! 1187: bus_space_write_2(iot, ioh, ESA_DSP_PORT_MEMORY_TYPE,
! 1188: region & ESA_MEMTYPE_MASK);
! 1189: bus_space_write_2(iot, ioh, ESA_DSP_PORT_MEMORY_INDEX, index);
! 1190: bus_space_write_2(iot, ioh, ESA_DSP_PORT_MEMORY_DATA, data);
! 1191:
! 1192: return;
! 1193: }
! 1194:
! 1195: int
! 1196: esa_init_codec(struct esa_softc *sc)
! 1197: {
! 1198: bus_space_tag_t iot = sc->sc_iot;
! 1199: bus_space_handle_t ioh = sc->sc_ioh;
! 1200: u_int32_t data;
! 1201:
! 1202: data = bus_space_read_1(iot, ioh, ESA_CODEC_COMMAND);
! 1203:
! 1204: return ((data & 0x1) ? 0 : 1);
! 1205: }
! 1206:
! 1207: int
! 1208: esa_attach_codec(void *aux, struct ac97_codec_if *codec_if)
! 1209: {
! 1210: struct esa_softc *sc = aux;
! 1211:
! 1212: sc->codec_if = codec_if;
! 1213:
! 1214: return (0);
! 1215: }
! 1216:
! 1217: int
! 1218: esa_read_codec(void *aux, u_int8_t reg, u_int16_t *result)
! 1219: {
! 1220: struct esa_softc *sc = aux;
! 1221: bus_space_tag_t iot = sc->sc_iot;
! 1222: bus_space_handle_t ioh = sc->sc_ioh;
! 1223:
! 1224: if (esa_wait(sc))
! 1225: printf("%s: esa_read_codec: timed out\n", sc->sc_dev.dv_xname);
! 1226: bus_space_write_1(iot, ioh, ESA_CODEC_COMMAND, (reg & 0x7f) | 0x80);
! 1227: delay(50);
! 1228: if (esa_wait(sc))
! 1229: printf("%s: esa_read_codec: timed out\n", sc->sc_dev.dv_xname);
! 1230: *result = bus_space_read_2(iot, ioh, ESA_CODEC_DATA);
! 1231:
! 1232: return (0);
! 1233: }
! 1234:
! 1235: int
! 1236: esa_write_codec(void *aux, u_int8_t reg, u_int16_t data)
! 1237: {
! 1238: struct esa_softc *sc = aux;
! 1239: bus_space_tag_t iot = sc->sc_iot;
! 1240: bus_space_handle_t ioh = sc->sc_ioh;
! 1241:
! 1242: if (esa_wait(sc)) {
! 1243: printf("%s: esa_write_codec: timed out\n", sc->sc_dev.dv_xname);
! 1244: return (-1);
! 1245: }
! 1246: bus_space_write_2(iot, ioh, ESA_CODEC_DATA, data);
! 1247: bus_space_write_1(iot, ioh, ESA_CODEC_COMMAND, reg & 0x7f);
! 1248: delay(50);
! 1249:
! 1250: return (0);
! 1251: }
! 1252:
! 1253: void
! 1254: esa_reset_codec(void *aux)
! 1255: {
! 1256:
! 1257: return;
! 1258: }
! 1259:
! 1260: enum ac97_host_flags
! 1261: esa_flags_codec(void *aux)
! 1262: {
! 1263: struct esa_softc *sc = aux;
! 1264:
! 1265: return (sc->codec_flags);
! 1266: }
! 1267:
! 1268: int
! 1269: esa_wait(struct esa_softc *sc)
! 1270: {
! 1271: int i, val;
! 1272: bus_space_tag_t iot = sc->sc_iot;
! 1273: bus_space_handle_t ioh = sc->sc_ioh;
! 1274:
! 1275: for (i = 0; i < 20; i++) {
! 1276: val = bus_space_read_1(iot, ioh, ESA_CODEC_STATUS);
! 1277: if ((val & 1) == 0)
! 1278: return (0);
! 1279: delay(2);
! 1280: }
! 1281:
! 1282: return (-1);
! 1283: }
! 1284:
! 1285: int
! 1286: esa_init(struct esa_softc *sc)
! 1287: {
! 1288: struct esa_voice *vc;
! 1289: bus_space_tag_t iot = sc->sc_iot;
! 1290: bus_space_handle_t ioh = sc->sc_ioh;
! 1291: pcitag_t tag = sc->sc_tag;
! 1292: pci_chipset_tag_t pc = sc->sc_pct;
! 1293: u_int32_t data, i, size;
! 1294: u_int8_t reset_state;
! 1295: int data_bytes = (((ESA_MINISRC_TMP_BUFFER_SIZE & ~1) +
! 1296: (ESA_MINISRC_IN_BUFFER_SIZE & ~1) +
! 1297: (ESA_MINISRC_OUT_BUFFER_SIZE & ~1) + 4) + 255)
! 1298: &~ 255;
! 1299:
! 1300: /* Disable legacy emulation */
! 1301: data = pci_conf_read(pc, tag, PCI_LEGACY_AUDIO_CTRL);
! 1302: data |= DISABLE_LEGACY;
! 1303: pci_conf_write(pc, tag, PCI_LEGACY_AUDIO_CTRL, data);
! 1304:
! 1305: esa_config(sc);
! 1306:
! 1307: reset_state = esa_assp_halt(sc);
! 1308:
! 1309: esa_init_codec(sc);
! 1310: esa_codec_reset(sc);
! 1311:
! 1312: /* Zero kernel and mixer data */
! 1313: size = ESA_REV_B_DATA_MEMORY_UNIT_LENGTH * ESA_NUM_UNITS_KERNEL_DATA;
! 1314: for (i = 0; i < size / 2; i++) {
! 1315: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 1316: ESA_KDATA_BASE_ADDR + i, 0);
! 1317: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 1318: ESA_KDATA_BASE_ADDR2 + i, 0);
! 1319: }
! 1320:
! 1321: /* Init DMA pointer */
! 1322: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, ESA_KDATA_CURRENT_DMA,
! 1323: ESA_KDATA_DMA_XFER0);
! 1324:
! 1325: /* Write kernel code into memory */
! 1326: size = sizeof(esa_assp_kernel_image);
! 1327: for (i = 0; i < size / 2; i++)
! 1328: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_CODE,
! 1329: ESA_REV_B_CODE_MEMORY_BEGIN + i, esa_assp_kernel_image[i]);
! 1330:
! 1331: size = sizeof(esa_assp_minisrc_image);
! 1332: for (i = 0; i < size / 2; i++)
! 1333: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_CODE, 0x400 + i,
! 1334: esa_assp_minisrc_image[i]);
! 1335:
! 1336: /* Write the coefficients for the low pass filter */
! 1337: size = sizeof(esa_minisrc_lpf_image);
! 1338: for (i = 0; i < size / 2; i++)
! 1339: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_CODE,
! 1340: 0x400 + ESA_MINISRC_COEF_LOC + i, esa_minisrc_lpf_image[i]);
! 1341: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_CODE,
! 1342: 0x400 + ESA_MINISRC_COEF_LOC + size, 0x8000);
! 1343: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, ESA_KDATA_TASK0, 0x400);
! 1344: /* Init the mixer number */
! 1345: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 1346: ESA_KDATA_MIXER_TASK_NUMBER, 0);
! 1347: /* Extreme kernel master volume */
! 1348: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 1349: ESA_KDATA_DAC_LEFT_VOLUME, ESA_ARB_VOLUME);
! 1350: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 1351: ESA_KDATA_DAC_RIGHT_VOLUME, ESA_ARB_VOLUME);
! 1352:
! 1353: if (esa_amp_enable(sc))
! 1354: return (-1);
! 1355:
! 1356: /* Zero entire DAC/ADC area */
! 1357: for (i = 0x1100; i < 0x1c00; i++)
! 1358: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, i, 0);
! 1359:
! 1360: /* set some sane defaults */
! 1361: for (i = 0; i < ESA_NUM_VOICES; i++) {
! 1362: vc = &sc->voice[i];
! 1363: vc->play.data_offset = ESA_DAC_DATA + (data_bytes * i);
! 1364: vc->rec.data_offset = ESA_DAC_DATA + (data_bytes * i * 2);
! 1365: }
! 1366:
! 1367: esa_enable_interrupts(sc);
! 1368:
! 1369: bus_space_write_1(iot, ioh, ESA_DSP_PORT_CONTROL_REG_B,
! 1370: reset_state | ESA_REGB_ENABLE_RESET);
! 1371:
! 1372: return (0);
! 1373: }
! 1374:
! 1375: void
! 1376: esa_config(struct esa_softc *sc)
! 1377: {
! 1378: bus_space_tag_t iot = sc->sc_iot;
! 1379: bus_space_handle_t ioh = sc->sc_ioh;
! 1380: pcitag_t tag = sc->sc_tag;
! 1381: pci_chipset_tag_t pc = sc->sc_pct;
! 1382: u_int32_t data;
! 1383:
! 1384: data = pci_conf_read(pc, tag, ESA_PCI_ALLEGRO_CONFIG);
! 1385: data &= ESA_REDUCED_DEBOUNCE;
! 1386: data |= ESA_PM_CTRL_ENABLE | ESA_CLK_DIV_BY_49 | ESA_USE_PCI_TIMING;
! 1387: pci_conf_write(pc, tag, ESA_PCI_ALLEGRO_CONFIG, data);
! 1388:
! 1389: bus_space_write_1(iot, ioh, ESA_ASSP_CONTROL_B, ESA_RESET_ASSP);
! 1390: data = pci_conf_read(pc, tag, ESA_PCI_ALLEGRO_CONFIG);
! 1391: data &= ~ESA_INT_CLK_SELECT;
! 1392: if (sc->type == ESS_MAESTRO3) {
! 1393: data &= ~ESA_INT_CLK_MULT_ENABLE;
! 1394: data |= ESA_INT_CLK_SRC_NOT_PCI;
! 1395: }
! 1396: data &= ~(ESA_CLK_MULT_MODE_SELECT | ESA_CLK_MULT_MODE_SELECT_2);
! 1397: pci_conf_write(pc, tag, ESA_PCI_ALLEGRO_CONFIG, data);
! 1398:
! 1399: if (sc->type == ESS_ALLEGRO1) {
! 1400: data = pci_conf_read(pc, tag, ESA_PCI_USER_CONFIG);
! 1401: data |= ESA_IN_CLK_12MHZ_SELECT;
! 1402: pci_conf_write(pc, tag, ESA_PCI_USER_CONFIG, data);
! 1403: }
! 1404:
! 1405: data = bus_space_read_1(iot, ioh, ESA_ASSP_CONTROL_A);
! 1406: data &= ~(ESA_DSP_CLK_36MHZ_SELECT | ESA_ASSP_CLK_49MHZ_SELECT);
! 1407: data |= ESA_ASSP_CLK_49MHZ_SELECT; /* XXX: Assumes 49MHz DSP */
! 1408: data |= ESA_ASSP_0_WS_ENABLE;
! 1409: bus_space_write_1(iot, ioh, ESA_ASSP_CONTROL_A, data);
! 1410:
! 1411: bus_space_write_1(iot, ioh, ESA_ASSP_CONTROL_B, ESA_RUN_ASSP);
! 1412:
! 1413: return;
! 1414: }
! 1415:
! 1416: u_int8_t
! 1417: esa_assp_halt(struct esa_softc *sc)
! 1418: {
! 1419: bus_space_tag_t iot = sc->sc_iot;
! 1420: bus_space_handle_t ioh = sc->sc_ioh;
! 1421: u_int8_t data, reset_state;
! 1422:
! 1423: data = bus_space_read_1(iot, ioh, ESA_DSP_PORT_CONTROL_REG_B);
! 1424: reset_state = data & ~ESA_REGB_STOP_CLOCK;
! 1425: delay(10000); /* XXX use tsleep */
! 1426: bus_space_write_1(iot, ioh, ESA_DSP_PORT_CONTROL_REG_B,
! 1427: reset_state & ~ESA_REGB_ENABLE_RESET);
! 1428: delay(10000); /* XXX use tsleep */
! 1429:
! 1430: return (reset_state);
! 1431: }
! 1432:
! 1433: void
! 1434: esa_codec_reset(struct esa_softc *sc)
! 1435: {
! 1436: bus_space_tag_t iot = sc->sc_iot;
! 1437: bus_space_handle_t ioh = sc->sc_ioh;
! 1438: u_int16_t data, dir;
! 1439: int retry = 0;
! 1440:
! 1441: do {
! 1442: data = bus_space_read_2(iot, ioh, ESA_GPIO_DIRECTION);
! 1443: dir = data | 0x10; /* assuming pci bus master? */
! 1444:
! 1445: /* remote codec config */
! 1446: data = bus_space_read_2(iot, ioh, ESA_RING_BUS_CTRL_B);
! 1447: bus_space_write_2(iot, ioh, ESA_RING_BUS_CTRL_B,
! 1448: data & ~ESA_SECOND_CODEC_ID_MASK);
! 1449: data = bus_space_read_2(iot, ioh, ESA_SDO_OUT_DEST_CTRL);
! 1450: bus_space_write_2(iot, ioh, ESA_SDO_OUT_DEST_CTRL,
! 1451: data & ~ESA_COMMAND_ADDR_OUT);
! 1452: data = bus_space_read_2(iot, ioh, ESA_SDO_IN_DEST_CTRL);
! 1453: bus_space_write_2(iot, ioh, ESA_SDO_IN_DEST_CTRL,
! 1454: data & ~ESA_STATUS_ADDR_IN);
! 1455:
! 1456: bus_space_write_2(iot, ioh, ESA_RING_BUS_CTRL_A,
! 1457: ESA_IO_SRAM_ENABLE);
! 1458: delay(20);
! 1459:
! 1460: bus_space_write_2(iot, ioh, ESA_GPIO_DIRECTION,
! 1461: dir & ~ESA_GPO_PRIMARY_AC97);
! 1462: bus_space_write_2(iot, ioh, ESA_GPIO_MASK,
! 1463: ~ESA_GPO_PRIMARY_AC97);
! 1464: bus_space_write_2(iot, ioh, ESA_GPIO_DATA, 0);
! 1465: bus_space_write_2(iot, ioh, ESA_GPIO_DIRECTION,
! 1466: dir | ESA_GPO_PRIMARY_AC97);
! 1467: delay(sc->delay1 * 1000);
! 1468: bus_space_write_2(iot, ioh, ESA_GPIO_DATA,
! 1469: ESA_GPO_PRIMARY_AC97);
! 1470: delay(5);
! 1471: bus_space_write_2(iot, ioh, ESA_RING_BUS_CTRL_A,
! 1472: ESA_IO_SRAM_ENABLE | ESA_SERIAL_AC_LINK_ENABLE);
! 1473: bus_space_write_2(iot, ioh, ESA_GPIO_MASK, ~0);
! 1474: delay(sc->delay2 * 1000);
! 1475:
! 1476: esa_read_codec(sc, 0x7c, &data);
! 1477: if ((data == 0) || (data == 0xffff)) {
! 1478: retry++;
! 1479: if (retry > 3) {
! 1480: printf("%s: esa_codec_reset: failed\n",
! 1481: sc->sc_dev.dv_xname);
! 1482: break;
! 1483: }
! 1484: printf("%s: esa_codec_reset: retrying\n",
! 1485: sc->sc_dev.dv_xname);
! 1486: } else
! 1487: retry = 0;
! 1488: } while (retry);
! 1489:
! 1490: return;
! 1491: }
! 1492:
! 1493: int
! 1494: esa_amp_enable(struct esa_softc *sc)
! 1495: {
! 1496: bus_space_tag_t iot = sc->sc_iot;
! 1497: bus_space_handle_t ioh = sc->sc_ioh;
! 1498: u_int32_t gpo, polarity_port, polarity;
! 1499: u_int16_t data;
! 1500:
! 1501: switch (sc->type) {
! 1502: case ESS_ALLEGRO1:
! 1503: polarity_port = 0x1800;
! 1504: break;
! 1505: case ESS_MAESTRO3:
! 1506: polarity_port = 0x1100;
! 1507: break;
! 1508: default:
! 1509: printf("%s: esa_amp_enable: Unknown chip type!!!\n",
! 1510: sc->sc_dev.dv_xname);
! 1511: return (1);
! 1512: }
! 1513:
! 1514: gpo = (polarity_port >> 8) & 0x0f;
! 1515: polarity = polarity_port >> 12;
! 1516: polarity = !polarity; /* Enable */
! 1517: polarity = polarity << gpo;
! 1518: gpo = 1 << gpo;
! 1519: bus_space_write_2(iot, ioh, ESA_GPIO_MASK, ~gpo);
! 1520: data = bus_space_read_2(iot, ioh, ESA_GPIO_DIRECTION);
! 1521: bus_space_write_2(iot, ioh, ESA_GPIO_DIRECTION, data | gpo);
! 1522: data = ESA_GPO_SECONDARY_AC97 | ESA_GPO_PRIMARY_AC97 | polarity;
! 1523: bus_space_write_2(iot, ioh, ESA_GPIO_DATA, data);
! 1524: bus_space_write_2(iot, ioh, ESA_GPIO_MASK, ~0);
! 1525:
! 1526: return (0);
! 1527: }
! 1528:
! 1529: void
! 1530: esa_enable_interrupts(struct esa_softc *sc)
! 1531: {
! 1532: bus_space_tag_t iot = sc->sc_iot;
! 1533: bus_space_handle_t ioh = sc->sc_ioh;
! 1534: u_int8_t data;
! 1535:
! 1536: bus_space_write_2(iot, ioh, ESA_HOST_INT_CTRL,
! 1537: ESA_ASSP_INT_ENABLE | ESA_HV_INT_ENABLE);
! 1538: data = bus_space_read_1(iot, ioh, ESA_ASSP_CONTROL_C);
! 1539: bus_space_write_1(iot, ioh, ESA_ASSP_CONTROL_C,
! 1540: data | ESA_ASSP_HOST_INT_ENABLE);
! 1541: }
! 1542:
! 1543: /*
! 1544: * List management
! 1545: */
! 1546: int
! 1547: esa_add_list(struct esa_voice *vc, struct esa_list *el,
! 1548: u_int16_t val, int index)
! 1549: {
! 1550: struct esa_softc *sc = (struct esa_softc *)vc->parent;
! 1551:
! 1552: el->indexmap[index] = el->currlen;
! 1553: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 1554: el->mem_addr + el->currlen,
! 1555: val);
! 1556:
! 1557: return (el->currlen++);
! 1558: }
! 1559:
! 1560: void
! 1561: esa_remove_list(struct esa_voice *vc, struct esa_list *el, int index)
! 1562: {
! 1563: struct esa_softc *sc = (struct esa_softc *)vc->parent;
! 1564: u_int16_t val;
! 1565: int lastindex = el->currlen - 1;
! 1566: int vindex = el->indexmap[index];
! 1567: int i;
! 1568:
! 1569: /* reset our virtual index */
! 1570: el->indexmap[index] = -1;
! 1571:
! 1572: if (vindex != lastindex) {
! 1573: val = esa_read_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 1574: el->mem_addr + lastindex);
! 1575: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 1576: el->mem_addr + vindex,
! 1577: val);
! 1578: for (i = 0; i < ESA_NUM_VOICES * 2; i++)
! 1579: if (el->indexmap[i] == lastindex)
! 1580: break;
! 1581: if (i >= ESA_NUM_VOICES * 2)
! 1582: printf("%s: esa_remove_list: invalid task index\n",
! 1583: sc->sc_dev.dv_xname);
! 1584: else
! 1585: el->indexmap[i] = vindex;
! 1586: }
! 1587:
! 1588: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA,
! 1589: el->mem_addr + lastindex, 0);
! 1590: el->currlen--;
! 1591:
! 1592: return;
! 1593: }
! 1594:
! 1595: int
! 1596: esa_power(struct esa_softc *sc, int state)
! 1597: {
! 1598: pcitag_t tag = sc->sc_tag;
! 1599: pci_chipset_tag_t pc = sc->sc_pct;
! 1600: pcireg_t data;
! 1601: int pmcapreg;
! 1602:
! 1603: if (pci_get_capability(pc, tag, PCI_CAP_PWRMGMT, &pmcapreg, 0)) {
! 1604: data = pci_conf_read(pc, tag, pmcapreg + PCI_PMCSR);
! 1605: if ((data & PCI_PMCSR_STATE_MASK) != state)
! 1606: pci_conf_write(pc, tag, pmcapreg + PCI_PMCSR, state);
! 1607: }
! 1608:
! 1609: return (0);
! 1610: }
! 1611:
! 1612: void
! 1613: esa_powerhook(int why, void *hdl)
! 1614: {
! 1615: struct esa_softc *sc = (struct esa_softc *)hdl;
! 1616:
! 1617: switch (why) {
! 1618: case PWR_SUSPEND:
! 1619: case PWR_STANDBY:
! 1620: esa_suspend(sc);
! 1621: break;
! 1622: case PWR_RESUME:
! 1623: esa_resume(sc);
! 1624: (sc->codec_if->vtbl->restore_ports)(sc->codec_if);
! 1625: break;
! 1626: }
! 1627: }
! 1628:
! 1629: int
! 1630: esa_suspend(struct esa_softc *sc)
! 1631: {
! 1632: bus_space_tag_t iot = sc->sc_iot;
! 1633: bus_space_handle_t ioh = sc->sc_ioh;
! 1634: int i, index;
! 1635:
! 1636: index = 0;
! 1637:
! 1638: bus_space_write_2(iot, ioh, ESA_HOST_INT_CTRL, 0);
! 1639: bus_space_write_1(iot, ioh, ESA_ASSP_CONTROL_C, 0);
! 1640:
! 1641: esa_assp_halt(sc);
! 1642:
! 1643: /* Save ASSP state */
! 1644: for (i = ESA_REV_B_CODE_MEMORY_BEGIN; i <= ESA_REV_B_CODE_MEMORY_END;
! 1645: i++)
! 1646: sc->savemem[index++] = esa_read_assp(sc,
! 1647: ESA_MEMTYPE_INTERNAL_CODE, i);
! 1648: for (i = ESA_REV_B_DATA_MEMORY_BEGIN; i <= ESA_REV_B_DATA_MEMORY_END;
! 1649: i++)
! 1650: sc->savemem[index++] = esa_read_assp(sc,
! 1651: ESA_MEMTYPE_INTERNAL_DATA, i);
! 1652:
! 1653: esa_power(sc, PCI_PMCSR_STATE_D3);
! 1654:
! 1655: return (0);
! 1656: }
! 1657:
! 1658: int
! 1659: esa_resume(struct esa_softc *sc) {
! 1660: bus_space_tag_t iot = sc->sc_iot;
! 1661: bus_space_handle_t ioh = sc->sc_ioh;
! 1662: int i, index;
! 1663: u_int8_t reset_state;
! 1664:
! 1665: index = 0;
! 1666:
! 1667: esa_power(sc, PCI_PMCSR_STATE_D0);
! 1668: delay(10000);
! 1669:
! 1670: esa_config(sc);
! 1671:
! 1672: reset_state = esa_assp_halt(sc);
! 1673:
! 1674: esa_codec_reset(sc);
! 1675:
! 1676: /* restore ASSP */
! 1677: for (i = ESA_REV_B_CODE_MEMORY_BEGIN; i <= ESA_REV_B_CODE_MEMORY_END;
! 1678: i++)
! 1679: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_CODE, i,
! 1680: sc->savemem[index++]);
! 1681: for (i = ESA_REV_B_DATA_MEMORY_BEGIN; i <= ESA_REV_B_DATA_MEMORY_END;
! 1682: i++)
! 1683: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, i,
! 1684: sc->savemem[index++]);
! 1685:
! 1686: esa_write_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, ESA_KDATA_DMA_ACTIVE, 0);
! 1687: bus_space_write_1(iot, ioh, ESA_DSP_PORT_CONTROL_REG_B,
! 1688: reset_state | ESA_REGB_ENABLE_RESET);
! 1689:
! 1690: esa_enable_interrupts(sc);
! 1691: esa_amp_enable(sc);
! 1692:
! 1693: return (0);
! 1694: }
! 1695:
! 1696: u_int32_t
! 1697: esa_get_pointer(struct esa_softc *sc, struct esa_channel *ch)
! 1698: {
! 1699: u_int16_t hi = 0, lo = 0;
! 1700: u_int32_t addr;
! 1701: int data_offset = ch->data_offset;
! 1702:
! 1703: hi = esa_read_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, data_offset +
! 1704: ESA_CDATA_HOST_SRC_CURRENTH);
! 1705: lo = esa_read_assp(sc, ESA_MEMTYPE_INTERNAL_DATA, data_offset +
! 1706: ESA_CDATA_HOST_SRC_CURRENTL);
! 1707:
! 1708: addr = lo | ((u_int32_t)hi << 16);
! 1709: return (addr - ch->start);
! 1710: }
! 1711:
! 1712: paddr_t
! 1713: esa_mappage(void *addr, void *mem, off_t off, int prot)
! 1714: {
! 1715: struct esa_voice *vc = addr;
! 1716: struct esa_softc *sc = (struct esa_softc *)vc->parent;
! 1717: struct esa_dma *p;
! 1718:
! 1719: if (off < 0)
! 1720: return (-1);
! 1721: for (p = vc->dma; p && KERNADDR(p) != mem; p = p->next)
! 1722: ;
! 1723: if (!p)
! 1724: return (-1);
! 1725: return (bus_dmamem_mmap(sc->sc_dmat, p->segs, p->nsegs,
! 1726: off, prot, BUS_DMA_WAITOK));
! 1727: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to esa.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pci