Annotation of sys/arch/hppa/gsc/harmony.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: harmony.c,v 1.25 2006/05/20 01:58:27 mickey Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2003 Jason L. Wright (jason@thought.net)
! 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
! 18: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
! 19: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
! 20: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
! 21: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
! 22: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 23: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
! 24: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
! 25: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 26: * POSSIBILITY OF SUCH DAMAGE.
! 27: */
! 28:
! 29: /*
! 30: * Harmony (CS4215/AD1849 LASI) audio interface.
! 31: */
! 32:
! 33: #include <sys/param.h>
! 34: #include <sys/kernel.h>
! 35: #include <sys/systm.h>
! 36: #include <sys/errno.h>
! 37: #include <sys/ioctl.h>
! 38: #include <sys/device.h>
! 39: #include <sys/proc.h>
! 40: #include <sys/malloc.h>
! 41:
! 42: #include <sys/audioio.h>
! 43: #include <dev/audio_if.h>
! 44: #include <dev/auconv.h>
! 45: #include <dev/rndvar.h>
! 46:
! 47: #include <machine/cpu.h>
! 48: #include <machine/intr.h>
! 49: #include <machine/iomod.h>
! 50: #include <machine/autoconf.h>
! 51: #include <machine/bus.h>
! 52:
! 53: #include <hppa/dev/cpudevs.h>
! 54: #include <hppa/gsc/gscbusvar.h>
! 55: #include <hppa/gsc/harmonyreg.h>
! 56: #include <hppa/gsc/harmonyvar.h>
! 57:
! 58: int harmony_open(void *, int);
! 59: void harmony_close(void *);
! 60: int harmony_query_encoding(void *, struct audio_encoding *);
! 61: int harmony_set_params(void *, int, int, struct audio_params *,
! 62: struct audio_params *);
! 63: int harmony_round_blocksize(void *, int);
! 64: int harmony_commit_settings(void *);
! 65: int harmony_halt_output(void *);
! 66: int harmony_halt_input(void *);
! 67: int harmony_getdev(void *, struct audio_device *);
! 68: int harmony_set_port(void *, mixer_ctrl_t *);
! 69: int harmony_get_port(void *, mixer_ctrl_t *);
! 70: int harmony_query_devinfo(void *addr, mixer_devinfo_t *);
! 71: void * harmony_allocm(void *, int, size_t, int, int);
! 72: void harmony_freem(void *, void *, int);
! 73: size_t harmony_round_buffersize(void *, int, size_t);
! 74: int harmony_get_props(void *);
! 75: int harmony_trigger_output(void *, void *, void *, int,
! 76: void (*intr)(void *), void *, struct audio_params *);
! 77: int harmony_trigger_input(void *, void *, void *, int,
! 78: void (*intr)(void *), void *, struct audio_params *);
! 79:
! 80: struct audio_hw_if harmony_sa_hw_if = {
! 81: harmony_open,
! 82: harmony_close,
! 83: NULL,
! 84: harmony_query_encoding,
! 85: harmony_set_params,
! 86: harmony_round_blocksize,
! 87: harmony_commit_settings,
! 88: NULL,
! 89: NULL,
! 90: NULL,
! 91: NULL,
! 92: harmony_halt_output,
! 93: harmony_halt_input,
! 94: NULL,
! 95: harmony_getdev,
! 96: NULL,
! 97: harmony_set_port,
! 98: harmony_get_port,
! 99: harmony_query_devinfo,
! 100: harmony_allocm,
! 101: harmony_freem,
! 102: harmony_round_buffersize,
! 103: NULL,
! 104: harmony_get_props,
! 105: harmony_trigger_output,
! 106: harmony_trigger_input,
! 107: };
! 108:
! 109: int harmony_match(struct device *, void *, void *);
! 110: void harmony_attach(struct device *, struct device *, void *);
! 111: int harmony_intr(void *);
! 112: void harmony_intr_enable(struct harmony_softc *);
! 113: void harmony_intr_disable(struct harmony_softc *);
! 114: u_int32_t harmony_speed_bits(struct harmony_softc *, u_long *);
! 115: int harmony_set_gainctl(struct harmony_softc *);
! 116: void harmony_reset_codec(struct harmony_softc *);
! 117: void harmony_start_cp(struct harmony_softc *);
! 118: void harmony_tick_pb(void *);
! 119: void harmony_tick_cp(void *);
! 120: void harmony_try_more(struct harmony_softc *);
! 121:
! 122: void harmony_acc_tmo(void *);
! 123: #define ADD_CLKALLICA(sc) do { \
! 124: (sc)->sc_acc <<= 1; \
! 125: (sc)->sc_acc |= READ_REG((sc), HARMONY_DIAG) & DIAG_CO; \
! 126: if ((sc)->sc_acc_cnt++ && !((sc)->sc_acc_cnt % 32)) \
! 127: add_true_randomness((sc)->sc_acc_num ^= (sc)->sc_acc); \
! 128: } while(0)
! 129:
! 130: int
! 131: harmony_match(parent, match, aux)
! 132: struct device *parent;
! 133: void *match, *aux;
! 134: {
! 135: struct gsc_attach_args *ga = aux;
! 136: bus_space_handle_t bh;
! 137: u_int32_t cntl;
! 138:
! 139: if (ga->ga_type.iodc_type == HPPA_TYPE_FIO) {
! 140: if (ga->ga_type.iodc_sv_model == HPPA_FIO_A1 ||
! 141: ga->ga_type.iodc_sv_model == HPPA_FIO_A2NB ||
! 142: ga->ga_type.iodc_sv_model == HPPA_FIO_A1NB ||
! 143: ga->ga_type.iodc_sv_model == HPPA_FIO_A2) {
! 144: if (bus_space_map(ga->ga_iot, ga->ga_hpa,
! 145: HARMONY_NREGS, 0, &bh) != 0)
! 146: return (0);
! 147: cntl = bus_space_read_4(ga->ga_iot, bh, HARMONY_ID) &
! 148: ID_REV_MASK;
! 149: bus_space_unmap(ga->ga_iot, bh, HARMONY_NREGS);
! 150: if (cntl == ID_REV_TS || cntl == ID_REV_NOTS)
! 151: return (1);
! 152: }
! 153: }
! 154: return (0);
! 155: }
! 156:
! 157: void
! 158: harmony_attach(parent, self, aux)
! 159: struct device *parent, *self;
! 160: void *aux;
! 161: {
! 162: struct harmony_softc *sc = (struct harmony_softc *)self;
! 163: struct gsc_attach_args *ga = aux;
! 164: u_int8_t rev;
! 165: u_int32_t cntl;
! 166: int i;
! 167:
! 168: sc->sc_bt = ga->ga_iot;
! 169: sc->sc_dmat = ga->ga_dmatag;
! 170:
! 171: if (bus_space_map(sc->sc_bt, ga->ga_hpa, HARMONY_NREGS, 0,
! 172: &sc->sc_bh) != 0) {
! 173: printf(": couldn't map registers\n");
! 174: return;
! 175: }
! 176:
! 177: cntl = READ_REG(sc, HARMONY_ID);
! 178: sc->sc_teleshare = (cntl & ID_REV_MASK) == ID_REV_TS;
! 179:
! 180: if (bus_dmamem_alloc(sc->sc_dmat, sizeof(struct harmony_empty),
! 181: PAGE_SIZE, 0, &sc->sc_empty_seg, 1, &sc->sc_empty_rseg,
! 182: BUS_DMA_NOWAIT) != 0) {
! 183: printf(": couldn't alloc DMA memory\n");
! 184: bus_space_unmap(sc->sc_bt, sc->sc_bh, HARMONY_NREGS);
! 185: return;
! 186: }
! 187: if (bus_dmamem_map(sc->sc_dmat, &sc->sc_empty_seg, 1,
! 188: sizeof(struct harmony_empty), (caddr_t *)&sc->sc_empty_kva,
! 189: BUS_DMA_NOWAIT) != 0) {
! 190: printf(": couldn't map DMA memory\n");
! 191: bus_dmamem_free(sc->sc_dmat, &sc->sc_empty_seg,
! 192: sc->sc_empty_rseg);
! 193: bus_space_unmap(sc->sc_bt, sc->sc_bh, HARMONY_NREGS);
! 194: return;
! 195: }
! 196: if (bus_dmamap_create(sc->sc_dmat, sizeof(struct harmony_empty), 1,
! 197: sizeof(struct harmony_empty), 0, BUS_DMA_NOWAIT,
! 198: &sc->sc_empty_map) != 0) {
! 199: printf(": can't create DMA map\n");
! 200: bus_dmamem_unmap(sc->sc_dmat, (caddr_t)sc->sc_empty_kva,
! 201: sizeof(struct harmony_empty));
! 202: bus_dmamem_free(sc->sc_dmat, &sc->sc_empty_seg,
! 203: sc->sc_empty_rseg);
! 204: bus_space_unmap(sc->sc_bt, sc->sc_bh, HARMONY_NREGS);
! 205: return;
! 206: }
! 207: if (bus_dmamap_load(sc->sc_dmat, sc->sc_empty_map, sc->sc_empty_kva,
! 208: sizeof(struct harmony_empty), NULL, BUS_DMA_NOWAIT) != 0) {
! 209: printf(": can't load DMA map\n");
! 210: bus_dmamap_destroy(sc->sc_dmat, sc->sc_empty_map);
! 211: bus_dmamem_unmap(sc->sc_dmat, (caddr_t)sc->sc_empty_kva,
! 212: sizeof(struct harmony_empty));
! 213: bus_dmamem_free(sc->sc_dmat, &sc->sc_empty_seg,
! 214: sc->sc_empty_rseg);
! 215: bus_space_unmap(sc->sc_bt, sc->sc_bh, HARMONY_NREGS);
! 216: return;
! 217: }
! 218:
! 219: sc->sc_playback_empty = 0;
! 220: for (i = 0; i < PLAYBACK_EMPTYS; i++)
! 221: sc->sc_playback_paddrs[i] =
! 222: sc->sc_empty_map->dm_segs[0].ds_addr +
! 223: offsetof(struct harmony_empty, playback[i][0]);
! 224:
! 225: sc->sc_capture_empty = 0;
! 226: for (i = 0; i < CAPTURE_EMPTYS; i++)
! 227: sc->sc_capture_paddrs[i] =
! 228: sc->sc_empty_map->dm_segs[0].ds_addr +
! 229: offsetof(struct harmony_empty, playback[i][0]);
! 230:
! 231: bus_dmamap_sync(sc->sc_dmat, sc->sc_empty_map,
! 232: offsetof(struct harmony_empty, playback[0][0]),
! 233: PLAYBACK_EMPTYS * HARMONY_BUFSIZE, BUS_DMASYNC_PREWRITE);
! 234:
! 235: (void)gsc_intr_establish((struct gsc_softc *)parent, ga->ga_irq,
! 236: IPL_AUDIO, harmony_intr, sc, sc->sc_dv.dv_xname);
! 237:
! 238: /* set defaults */
! 239: sc->sc_in_port = HARMONY_IN_LINE;
! 240: sc->sc_out_port = HARMONY_OUT_SPEAKER;
! 241: sc->sc_input_lvl.left = sc->sc_input_lvl.right = 240;
! 242: sc->sc_output_lvl.left = sc->sc_output_lvl.right = 244;
! 243: sc->sc_monitor_lvl.left = sc->sc_monitor_lvl.right = 208;
! 244: sc->sc_outputgain = 0;
! 245:
! 246: /* reset chip, and push default gain controls */
! 247: harmony_reset_codec(sc);
! 248:
! 249: cntl = READ_REG(sc, HARMONY_CNTL);
! 250: rev = (cntl & CNTL_CODEC_REV_MASK) >> CNTL_CODEC_REV_SHIFT;
! 251: printf(": rev %u", rev);
! 252:
! 253: if (sc->sc_teleshare)
! 254: printf(", teleshare");
! 255: printf("\n");
! 256:
! 257: if ((rev & CS4215_REV_VER) >= CS4215_REV_VER_E)
! 258: sc->sc_hasulinear8 = 1;
! 259:
! 260: strlcpy(sc->sc_audev.name, ga->ga_name, sizeof(sc->sc_audev.name));
! 261: snprintf(sc->sc_audev.version, sizeof sc->sc_audev.version,
! 262: "%u.%u;%u", ga->ga_type.iodc_sv_rev,
! 263: ga->ga_type.iodc_model, ga->ga_type.iodc_revision);
! 264: strlcpy(sc->sc_audev.config, sc->sc_dv.dv_xname,
! 265: sizeof(sc->sc_audev.config));
! 266:
! 267: audio_attach_mi(&harmony_sa_hw_if, sc, &sc->sc_dv);
! 268:
! 269: timeout_set(&sc->sc_acc_tmo, harmony_acc_tmo, sc);
! 270: sc->sc_acc_num = 0xa5a5a5a5;
! 271: }
! 272:
! 273: void
! 274: harmony_reset_codec(struct harmony_softc *sc)
! 275: {
! 276: /* silence */
! 277: WRITE_REG(sc, HARMONY_GAINCTL, GAINCTL_OUTPUT_LEFT_M |
! 278: GAINCTL_OUTPUT_RIGHT_M | GAINCTL_MONITOR_M);
! 279:
! 280: /* start reset */
! 281: WRITE_REG(sc, HARMONY_RESET, RESET_RST);
! 282:
! 283: DELAY(100000); /* wait at least 0.05 sec */
! 284:
! 285: harmony_set_gainctl(sc);
! 286: WRITE_REG(sc, HARMONY_RESET, 0);
! 287: }
! 288:
! 289: void
! 290: harmony_acc_tmo(void *v)
! 291: {
! 292: struct harmony_softc *sc = v;
! 293:
! 294: ADD_CLKALLICA(sc);
! 295: timeout_add(&sc->sc_acc_tmo, 1);
! 296: }
! 297:
! 298: /*
! 299: * interrupt handler
! 300: */
! 301: int
! 302: harmony_intr(vsc)
! 303: void *vsc;
! 304: {
! 305: struct harmony_softc *sc = vsc;
! 306: struct harmony_channel *c;
! 307: u_int32_t dstatus;
! 308: int r = 0;
! 309:
! 310: ADD_CLKALLICA(sc);
! 311:
! 312: harmony_intr_disable(sc);
! 313:
! 314: dstatus = READ_REG(sc, HARMONY_DSTATUS);
! 315:
! 316: if (dstatus & DSTATUS_PN) {
! 317: struct harmony_dma *d;
! 318: bus_addr_t nextaddr;
! 319: bus_size_t togo;
! 320:
! 321: r = 1;
! 322: c = &sc->sc_playback;
! 323: d = c->c_current;
! 324: togo = c->c_segsz - c->c_cnt;
! 325: if (togo == 0) {
! 326: nextaddr = d->d_map->dm_segs[0].ds_addr;
! 327: c->c_cnt = togo = c->c_blksz;
! 328: } else {
! 329: nextaddr = c->c_lastaddr;
! 330: if (togo > c->c_blksz)
! 331: togo = c->c_blksz;
! 332: c->c_cnt += togo;
! 333: }
! 334:
! 335: bus_dmamap_sync(sc->sc_dmat, d->d_map,
! 336: nextaddr - d->d_map->dm_segs[0].ds_addr,
! 337: c->c_blksz, BUS_DMASYNC_PREWRITE);
! 338:
! 339: WRITE_REG(sc, HARMONY_PNXTADD, nextaddr);
! 340: SYNC_REG(sc, HARMONY_PNXTADD, BUS_SPACE_BARRIER_WRITE);
! 341: c->c_lastaddr = nextaddr + togo;
! 342: harmony_try_more(sc);
! 343: }
! 344:
! 345: dstatus = READ_REG(sc, HARMONY_DSTATUS);
! 346:
! 347: if (dstatus & DSTATUS_RN) {
! 348: c = &sc->sc_capture;
! 349: r = 1;
! 350: harmony_start_cp(sc);
! 351: if (sc->sc_capturing && c->c_intr != NULL)
! 352: (*c->c_intr)(c->c_intrarg);
! 353: }
! 354:
! 355: if (READ_REG(sc, HARMONY_OV) & OV_OV) {
! 356: sc->sc_ov = 1;
! 357: WRITE_REG(sc, HARMONY_OV, 0);
! 358: } else
! 359: sc->sc_ov = 0;
! 360:
! 361: harmony_intr_enable(sc);
! 362:
! 363: return (r);
! 364: }
! 365:
! 366: void
! 367: harmony_intr_enable(struct harmony_softc *sc)
! 368: {
! 369: WRITE_REG(sc, HARMONY_DSTATUS, DSTATUS_IE);
! 370: SYNC_REG(sc, HARMONY_DSTATUS, BUS_SPACE_BARRIER_WRITE);
! 371: }
! 372:
! 373: void
! 374: harmony_intr_disable(struct harmony_softc *sc)
! 375: {
! 376: WRITE_REG(sc, HARMONY_DSTATUS, 0);
! 377: SYNC_REG(sc, HARMONY_DSTATUS, BUS_SPACE_BARRIER_WRITE);
! 378: }
! 379:
! 380: int
! 381: harmony_open(void *vsc, int flags)
! 382: {
! 383: struct harmony_softc *sc = vsc;
! 384:
! 385: if (sc->sc_open)
! 386: return (EBUSY);
! 387: sc->sc_open = 1;
! 388: return (0);
! 389: }
! 390:
! 391: void
! 392: harmony_close(void *vsc)
! 393: {
! 394: struct harmony_softc *sc = vsc;
! 395:
! 396: harmony_halt_input(sc);
! 397: harmony_halt_output(sc);
! 398: harmony_intr_disable(sc);
! 399: sc->sc_open = 0;
! 400: }
! 401:
! 402: int
! 403: harmony_query_encoding(void *vsc, struct audio_encoding *fp)
! 404: {
! 405: struct harmony_softc *sc = vsc;
! 406: int err = 0;
! 407:
! 408: switch (fp->index) {
! 409: case 0:
! 410: strlcpy(fp->name, AudioEmulaw, sizeof fp->name);
! 411: fp->encoding = AUDIO_ENCODING_ULAW;
! 412: fp->precision = 8;
! 413: fp->flags = 0;
! 414: break;
! 415: case 1:
! 416: strlcpy(fp->name, AudioEalaw, sizeof fp->name);
! 417: fp->encoding = AUDIO_ENCODING_ALAW;
! 418: fp->precision = 8;
! 419: fp->flags = 0;
! 420: break;
! 421: case 2:
! 422: strlcpy(fp->name, AudioEslinear_be, sizeof fp->name);
! 423: fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
! 424: fp->precision = 16;
! 425: fp->flags = 0;
! 426: break;
! 427: case 3:
! 428: strlcpy(fp->name, AudioEslinear_le, sizeof fp->name);
! 429: fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
! 430: fp->precision = 16;
! 431: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 432: break;
! 433: case 4:
! 434: strlcpy(fp->name, AudioEulinear_be, sizeof fp->name);
! 435: fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
! 436: fp->precision = 16;
! 437: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 438: break;
! 439: case 5:
! 440: strlcpy(fp->name, AudioEulinear_le, sizeof fp->name);
! 441: fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
! 442: fp->precision = 16;
! 443: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 444: break;
! 445: case 6:
! 446: if (sc->sc_hasulinear8) {
! 447: strlcpy(fp->name, AudioEulinear, sizeof fp->name);
! 448: fp->encoding = AUDIO_ENCODING_ULINEAR;
! 449: fp->precision = 8;
! 450: fp->flags = 0;
! 451: break;
! 452: }
! 453: /*FALLTHROUGH*/
! 454: case 7:
! 455: if (sc->sc_hasulinear8) {
! 456: strlcpy(fp->name, AudioEslinear, sizeof fp->name);
! 457: fp->encoding = AUDIO_ENCODING_SLINEAR;
! 458: fp->precision = 8;
! 459: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 460: break;
! 461: }
! 462: /*FALLTHROUGH*/
! 463: default:
! 464: err = EINVAL;
! 465: }
! 466: return (err);
! 467: }
! 468:
! 469: int
! 470: harmony_set_params(void *vsc, int setmode, int usemode,
! 471: struct audio_params *p, struct audio_params *r)
! 472: {
! 473: struct harmony_softc *sc = vsc;
! 474: u_int32_t bits;
! 475: void (*pswcode)(void *, u_char *, int cnt) = NULL;
! 476: void (*rswcode)(void *, u_char *, int cnt) = NULL;
! 477:
! 478: switch (p->encoding) {
! 479: case AUDIO_ENCODING_ULAW:
! 480: if (p->precision != 8)
! 481: return (EINVAL);
! 482: bits = CNTL_FORMAT_ULAW;
! 483: break;
! 484: case AUDIO_ENCODING_ALAW:
! 485: if (p->precision != 8)
! 486: return (EINVAL);
! 487: bits = CNTL_FORMAT_ALAW;
! 488: break;
! 489: case AUDIO_ENCODING_SLINEAR_BE:
! 490: if (p->precision == 8) {
! 491: bits = CNTL_FORMAT_ULINEAR8;
! 492: rswcode = pswcode = change_sign8;
! 493: break;
! 494: }
! 495: if (p->precision == 16) {
! 496: bits = CNTL_FORMAT_SLINEAR16BE;
! 497: break;
! 498: }
! 499: return (EINVAL);
! 500: case AUDIO_ENCODING_ULINEAR:
! 501: if (p->precision != 8)
! 502: return (EINVAL);
! 503: bits = CNTL_FORMAT_ULINEAR8;
! 504: break;
! 505: case AUDIO_ENCODING_SLINEAR:
! 506: if (p->precision != 8)
! 507: return (EINVAL);
! 508: bits = CNTL_FORMAT_ULINEAR8;
! 509: rswcode = pswcode = change_sign8;
! 510: break;
! 511: case AUDIO_ENCODING_SLINEAR_LE:
! 512: if (p->precision == 8) {
! 513: bits = CNTL_FORMAT_ULINEAR8;
! 514: rswcode = pswcode = change_sign8;
! 515: break;
! 516: }
! 517: if (p->precision == 16) {
! 518: bits = CNTL_FORMAT_SLINEAR16BE;
! 519: rswcode = pswcode = swap_bytes;
! 520: break;
! 521: }
! 522: return (EINVAL);
! 523: case AUDIO_ENCODING_ULINEAR_BE:
! 524: if (p->precision == 8) {
! 525: bits = CNTL_FORMAT_ULINEAR8;
! 526: break;
! 527: }
! 528: if (p->precision == 16) {
! 529: bits = CNTL_FORMAT_SLINEAR16BE;
! 530: rswcode = pswcode = change_sign16_be;
! 531: break;
! 532: }
! 533: return (EINVAL);
! 534: case AUDIO_ENCODING_ULINEAR_LE:
! 535: if (p->precision == 8) {
! 536: bits = CNTL_FORMAT_ULINEAR8;
! 537: break;
! 538: }
! 539: if (p->precision == 16) {
! 540: bits = CNTL_FORMAT_SLINEAR16BE;
! 541: pswcode = change_sign16_swap_bytes_le;
! 542: rswcode = swap_bytes_change_sign16_le;
! 543: break;
! 544: }
! 545: return (EINVAL);
! 546: default:
! 547: return (EINVAL);
! 548: }
! 549:
! 550: if (sc->sc_outputgain)
! 551: bits |= CNTL_OLB;
! 552:
! 553: if (p->channels == 1)
! 554: bits |= CNTL_CHANS_MONO;
! 555: else if (p->channels == 2)
! 556: bits |= CNTL_CHANS_STEREO;
! 557: else
! 558: return (EINVAL);
! 559:
! 560: bits |= harmony_speed_bits(sc, &p->sample_rate);
! 561: p->sw_code = pswcode;
! 562: r->sw_code = rswcode;
! 563: sc->sc_cntlbits = bits;
! 564: sc->sc_need_commit = 1;
! 565:
! 566: return (0);
! 567: }
! 568:
! 569: int
! 570: harmony_round_blocksize(void *vsc, int blk)
! 571: {
! 572: return (HARMONY_BUFSIZE);
! 573: }
! 574:
! 575: int
! 576: harmony_commit_settings(void *vsc)
! 577: {
! 578: struct harmony_softc *sc = vsc;
! 579: u_int32_t reg;
! 580: u_int8_t quietchar;
! 581: int i;
! 582:
! 583: if (sc->sc_need_commit == 0)
! 584: return (0);
! 585:
! 586: harmony_intr_disable(sc);
! 587:
! 588: for (;;) {
! 589: reg = READ_REG(sc, HARMONY_DSTATUS);
! 590: if ((reg & (DSTATUS_PC | DSTATUS_RC)) == 0)
! 591: break;
! 592: }
! 593:
! 594: /* Setting some bits in gainctl requires a reset */
! 595: harmony_reset_codec(sc);
! 596:
! 597: /* set the silence character based on the encoding type */
! 598: bus_dmamap_sync(sc->sc_dmat, sc->sc_empty_map,
! 599: offsetof(struct harmony_empty, playback[0][0]),
! 600: PLAYBACK_EMPTYS * HARMONY_BUFSIZE, BUS_DMASYNC_POSTWRITE);
! 601: switch (sc->sc_cntlbits & CNTL_FORMAT_MASK) {
! 602: case CNTL_FORMAT_ULAW:
! 603: quietchar = 0x7f;
! 604: break;
! 605: case CNTL_FORMAT_ALAW:
! 606: quietchar = 0x55;
! 607: break;
! 608: case CNTL_FORMAT_SLINEAR16BE:
! 609: case CNTL_FORMAT_ULINEAR8:
! 610: default:
! 611: quietchar = 0;
! 612: break;
! 613: }
! 614: for (i = 0; i < PLAYBACK_EMPTYS; i++)
! 615: memset(&sc->sc_empty_kva->playback[i][0],
! 616: quietchar, HARMONY_BUFSIZE);
! 617: bus_dmamap_sync(sc->sc_dmat, sc->sc_empty_map,
! 618: offsetof(struct harmony_empty, playback[0][0]),
! 619: PLAYBACK_EMPTYS * HARMONY_BUFSIZE, BUS_DMASYNC_PREWRITE);
! 620:
! 621: for (;;) {
! 622: /* Wait for it to come out of control mode */
! 623: reg = READ_REG(sc, HARMONY_CNTL);
! 624: if ((reg & CNTL_C) == 0)
! 625: break;
! 626: }
! 627:
! 628: bus_space_write_4(sc->sc_bt, sc->sc_bh, HARMONY_CNTL,
! 629: sc->sc_cntlbits | CNTL_C);
! 630:
! 631: for (;;) {
! 632: /* Wait for it to come out of control mode */
! 633: reg = READ_REG(sc, HARMONY_CNTL);
! 634: if ((reg & CNTL_C) == 0)
! 635: break;
! 636: }
! 637:
! 638: sc->sc_need_commit = 0;
! 639:
! 640: if (sc->sc_playing || sc->sc_capturing)
! 641: harmony_intr_enable(sc);
! 642:
! 643: return (0);
! 644: }
! 645:
! 646: int
! 647: harmony_halt_output(void *vsc)
! 648: {
! 649: struct harmony_softc *sc = vsc;
! 650:
! 651: sc->sc_playing = 0;
! 652: return (0);
! 653: }
! 654:
! 655: int
! 656: harmony_halt_input(void *vsc)
! 657: {
! 658: struct harmony_softc *sc = vsc;
! 659:
! 660: sc->sc_capturing = 0;
! 661: return (0);
! 662: }
! 663:
! 664: int
! 665: harmony_getdev(void *vsc, struct audio_device *retp)
! 666: {
! 667: struct harmony_softc *sc = vsc;
! 668:
! 669: *retp = sc->sc_audev;
! 670:
! 671: return (0);
! 672: }
! 673:
! 674: int
! 675: harmony_set_port(void *vsc, mixer_ctrl_t *cp)
! 676: {
! 677: struct harmony_softc *sc = vsc;
! 678: int err = EINVAL;
! 679:
! 680: switch (cp->dev) {
! 681: case HARMONY_PORT_INPUT_LVL:
! 682: if (cp->type != AUDIO_MIXER_VALUE)
! 683: break;
! 684: if (cp->un.value.num_channels == 1)
! 685: sc->sc_input_lvl.left = sc->sc_input_lvl.right =
! 686: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO];
! 687: else if (cp->un.value.num_channels == 2) {
! 688: sc->sc_input_lvl.left =
! 689: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT];
! 690: sc->sc_input_lvl.right =
! 691: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT];
! 692: } else
! 693: break;
! 694: sc->sc_need_commit = 1;
! 695: err = 0;
! 696: break;
! 697: case HARMONY_PORT_OUTPUT_LVL:
! 698: if (cp->type != AUDIO_MIXER_VALUE)
! 699: break;
! 700: if (cp->un.value.num_channels == 1)
! 701: sc->sc_output_lvl.left = sc->sc_output_lvl.right =
! 702: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO];
! 703: else if (cp->un.value.num_channels == 2) {
! 704: sc->sc_output_lvl.left =
! 705: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT];
! 706: sc->sc_output_lvl.right =
! 707: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT];
! 708: } else
! 709: break;
! 710: sc->sc_need_commit = 1;
! 711: err = 0;
! 712: break;
! 713: case HARMONY_PORT_OUTPUT_GAIN:
! 714: if (cp->type != AUDIO_MIXER_ENUM)
! 715: break;
! 716: sc->sc_outputgain = cp->un.ord ? 1 : 0;
! 717: err = 0;
! 718: break;
! 719: case HARMONY_PORT_MONITOR_LVL:
! 720: if (cp->type != AUDIO_MIXER_VALUE)
! 721: break;
! 722: if (cp->un.value.num_channels != 1)
! 723: break;
! 724: sc->sc_monitor_lvl.left = sc->sc_input_lvl.right =
! 725: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO];
! 726: sc->sc_need_commit = 1;
! 727: err = 0;
! 728: break;
! 729: case HARMONY_PORT_RECORD_SOURCE:
! 730: if (cp->type != AUDIO_MIXER_ENUM)
! 731: break;
! 732: if (cp->un.ord != HARMONY_IN_LINE &&
! 733: cp->un.ord != HARMONY_IN_MIC)
! 734: break;
! 735: sc->sc_in_port = cp->un.ord;
! 736: err = 0;
! 737: sc->sc_need_commit = 1;
! 738: break;
! 739: case HARMONY_PORT_OUTPUT_SOURCE:
! 740: if (cp->type != AUDIO_MIXER_ENUM)
! 741: break;
! 742: if (cp->un.ord != HARMONY_OUT_LINE &&
! 743: cp->un.ord != HARMONY_OUT_SPEAKER &&
! 744: cp->un.ord != HARMONY_OUT_HEADPHONE)
! 745: break;
! 746: sc->sc_out_port = cp->un.ord;
! 747: err = 0;
! 748: sc->sc_need_commit = 1;
! 749: break;
! 750: }
! 751:
! 752: return (err);
! 753: }
! 754:
! 755: int
! 756: harmony_get_port(void *vsc, mixer_ctrl_t *cp)
! 757: {
! 758: struct harmony_softc *sc = vsc;
! 759: int err = EINVAL;
! 760:
! 761: switch (cp->dev) {
! 762: case HARMONY_PORT_INPUT_LVL:
! 763: if (cp->type != AUDIO_MIXER_VALUE)
! 764: break;
! 765: if (cp->un.value.num_channels == 1) {
! 766: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
! 767: sc->sc_input_lvl.left;
! 768: } else if (cp->un.value.num_channels == 2) {
! 769: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
! 770: sc->sc_input_lvl.left;
! 771: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
! 772: sc->sc_input_lvl.right;
! 773: } else
! 774: break;
! 775: err = 0;
! 776: break;
! 777: case HARMONY_PORT_INPUT_OV:
! 778: if (cp->type != AUDIO_MIXER_ENUM)
! 779: break;
! 780: cp->un.ord = sc->sc_ov ? 1 : 0;
! 781: err = 0;
! 782: break;
! 783: case HARMONY_PORT_OUTPUT_LVL:
! 784: if (cp->type != AUDIO_MIXER_VALUE)
! 785: break;
! 786: if (cp->un.value.num_channels == 1) {
! 787: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
! 788: sc->sc_output_lvl.left;
! 789: } else if (cp->un.value.num_channels == 2) {
! 790: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
! 791: sc->sc_output_lvl.left;
! 792: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
! 793: sc->sc_output_lvl.right;
! 794: } else
! 795: break;
! 796: err = 0;
! 797: break;
! 798: case HARMONY_PORT_OUTPUT_GAIN:
! 799: if (cp->type != AUDIO_MIXER_ENUM)
! 800: break;
! 801: cp->un.ord = sc->sc_outputgain ? 1 : 0;
! 802: err = 0;
! 803: break;
! 804: case HARMONY_PORT_MONITOR_LVL:
! 805: if (cp->type != AUDIO_MIXER_VALUE)
! 806: break;
! 807: if (cp->un.value.num_channels != 1)
! 808: break;
! 809: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
! 810: sc->sc_monitor_lvl.left;
! 811: err = 0;
! 812: break;
! 813: case HARMONY_PORT_RECORD_SOURCE:
! 814: if (cp->type != AUDIO_MIXER_ENUM)
! 815: break;
! 816: cp->un.ord = sc->sc_in_port;
! 817: err = 0;
! 818: break;
! 819: case HARMONY_PORT_OUTPUT_SOURCE:
! 820: if (cp->type != AUDIO_MIXER_ENUM)
! 821: break;
! 822: cp->un.ord = sc->sc_out_port;
! 823: err = 0;
! 824: break;
! 825: }
! 826: return (0);
! 827: }
! 828:
! 829: int
! 830: harmony_query_devinfo(void *vsc, mixer_devinfo_t *dip)
! 831: {
! 832: int err = 0;
! 833:
! 834: switch (dip->index) {
! 835: case HARMONY_PORT_INPUT_LVL:
! 836: dip->type = AUDIO_MIXER_VALUE;
! 837: dip->mixer_class = HARMONY_PORT_INPUT_CLASS;
! 838: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 839: strlcpy(dip->label.name, AudioNinput, sizeof dip->label.name);
! 840: dip->un.v.num_channels = 2;
! 841: strlcpy(dip->un.v.units.name, AudioNvolume,
! 842: sizeof dip->un.v.units.name);
! 843: break;
! 844: case HARMONY_PORT_INPUT_OV:
! 845: dip->type = AUDIO_MIXER_ENUM;
! 846: dip->mixer_class = HARMONY_PORT_INPUT_CLASS;
! 847: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 848: strlcpy(dip->label.name, "overrange", sizeof dip->label.name);
! 849: dip->un.e.num_mem = 2;
! 850: strlcpy(dip->un.e.member[0].label.name, AudioNoff,
! 851: sizeof dip->un.e.member[0].label.name);
! 852: dip->un.e.member[0].ord = 0;
! 853: strlcpy(dip->un.e.member[1].label.name, AudioNon,
! 854: sizeof dip->un.e.member[1].label.name);
! 855: dip->un.e.member[1].ord = 1;
! 856: break;
! 857: case HARMONY_PORT_OUTPUT_LVL:
! 858: dip->type = AUDIO_MIXER_VALUE;
! 859: dip->mixer_class = HARMONY_PORT_OUTPUT_CLASS;
! 860: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 861: strlcpy(dip->label.name, AudioNoutput, sizeof dip->label.name);
! 862: dip->un.v.num_channels = 2;
! 863: strlcpy(dip->un.v.units.name, AudioNvolume,
! 864: sizeof dip->un.v.units.name);
! 865: break;
! 866: case HARMONY_PORT_OUTPUT_GAIN:
! 867: dip->type = AUDIO_MIXER_ENUM;
! 868: dip->mixer_class = HARMONY_PORT_OUTPUT_CLASS;
! 869: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 870: strlcpy(dip->label.name, "gain", sizeof dip->label.name);
! 871: dip->un.e.num_mem = 2;
! 872: strlcpy(dip->un.e.member[0].label.name, AudioNoff,
! 873: sizeof dip->un.e.member[0].label.name);
! 874: dip->un.e.member[0].ord = 0;
! 875: strlcpy(dip->un.e.member[1].label.name, AudioNon,
! 876: sizeof dip->un.e.member[1].label.name);
! 877: dip->un.e.member[1].ord = 1;
! 878: break;
! 879: case HARMONY_PORT_MONITOR_LVL:
! 880: dip->type = AUDIO_MIXER_VALUE;
! 881: dip->mixer_class = HARMONY_PORT_MONITOR_CLASS;
! 882: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 883: strlcpy(dip->label.name, AudioNmonitor, sizeof dip->label.name);
! 884: dip->un.v.num_channels = 1;
! 885: strlcpy(dip->un.v.units.name, AudioNvolume,
! 886: sizeof dip->un.v.units.name);
! 887: break;
! 888: case HARMONY_PORT_RECORD_SOURCE:
! 889: dip->type = AUDIO_MIXER_ENUM;
! 890: dip->mixer_class = HARMONY_PORT_RECORD_CLASS;
! 891: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 892: strlcpy(dip->label.name, AudioNsource, sizeof dip->label.name);
! 893: dip->un.e.num_mem = 2;
! 894: strlcpy(dip->un.e.member[0].label.name, AudioNmicrophone,
! 895: sizeof dip->un.e.member[0].label.name);
! 896: dip->un.e.member[0].ord = HARMONY_IN_MIC;
! 897: strlcpy(dip->un.e.member[1].label.name, AudioNline,
! 898: sizeof dip->un.e.member[1].label.name);
! 899: dip->un.e.member[1].ord = HARMONY_IN_LINE;
! 900: break;
! 901: case HARMONY_PORT_OUTPUT_SOURCE:
! 902: dip->type = AUDIO_MIXER_ENUM;
! 903: dip->mixer_class = HARMONY_PORT_MONITOR_CLASS;
! 904: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 905: strlcpy(dip->label.name, AudioNoutput, sizeof dip->label.name);
! 906: dip->un.e.num_mem = 3;
! 907: strlcpy(dip->un.e.member[0].label.name, AudioNline,
! 908: sizeof dip->un.e.member[0].label.name);
! 909: dip->un.e.member[0].ord = HARMONY_OUT_LINE;
! 910: strlcpy(dip->un.e.member[1].label.name, AudioNspeaker,
! 911: sizeof dip->un.e.member[1].label.name);
! 912: dip->un.e.member[1].ord = HARMONY_OUT_SPEAKER;
! 913: strlcpy(dip->un.e.member[2].label.name, AudioNheadphone,
! 914: sizeof dip->un.e.member[2].label.name);
! 915: dip->un.e.member[2].ord = HARMONY_OUT_HEADPHONE;
! 916: break;
! 917: case HARMONY_PORT_INPUT_CLASS:
! 918: dip->type = AUDIO_MIXER_CLASS;
! 919: dip->mixer_class = HARMONY_PORT_INPUT_CLASS;
! 920: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 921: strlcpy(dip->label.name, AudioCinputs, sizeof dip->label.name);
! 922: break;
! 923: case HARMONY_PORT_OUTPUT_CLASS:
! 924: dip->type = AUDIO_MIXER_CLASS;
! 925: dip->mixer_class = HARMONY_PORT_INPUT_CLASS;
! 926: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 927: strlcpy(dip->label.name, AudioCoutputs, sizeof dip->label.name);
! 928: break;
! 929: case HARMONY_PORT_MONITOR_CLASS:
! 930: dip->type = AUDIO_MIXER_CLASS;
! 931: dip->mixer_class = HARMONY_PORT_INPUT_CLASS;
! 932: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 933: strlcpy(dip->label.name, AudioCmonitor, sizeof dip->label.name);
! 934: break;
! 935: case HARMONY_PORT_RECORD_CLASS:
! 936: dip->type = AUDIO_MIXER_CLASS;
! 937: dip->mixer_class = HARMONY_PORT_RECORD_CLASS;
! 938: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 939: strlcpy(dip->label.name, AudioCrecord, sizeof dip->label.name);
! 940: break;
! 941: default:
! 942: err = ENXIO;
! 943: break;
! 944: }
! 945:
! 946: return (err);
! 947: }
! 948:
! 949: void *
! 950: harmony_allocm(void *vsc, int dir, size_t size, int pool, int flags)
! 951: {
! 952: struct harmony_softc *sc = vsc;
! 953: struct harmony_dma *d;
! 954: int rseg;
! 955:
! 956: d = (struct harmony_dma *)malloc(sizeof(struct harmony_dma), pool, flags);
! 957: if (d == NULL)
! 958: goto fail;
! 959:
! 960: if (bus_dmamap_create(sc->sc_dmat, size, 1, size, 0, BUS_DMA_NOWAIT,
! 961: &d->d_map) != 0)
! 962: goto fail1;
! 963:
! 964: if (bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, &d->d_seg, 1,
! 965: &rseg, BUS_DMA_NOWAIT) != 0)
! 966: goto fail2;
! 967:
! 968: if (bus_dmamem_map(sc->sc_dmat, &d->d_seg, 1, size, &d->d_kva,
! 969: BUS_DMA_NOWAIT) != 0)
! 970: goto fail3;
! 971:
! 972: if (bus_dmamap_load(sc->sc_dmat, d->d_map, d->d_kva, size, NULL,
! 973: BUS_DMA_NOWAIT) != 0)
! 974: goto fail4;
! 975:
! 976: d->d_next = sc->sc_dmas;
! 977: sc->sc_dmas = d;
! 978: d->d_size = size;
! 979: return (d->d_kva);
! 980:
! 981: fail4:
! 982: bus_dmamem_unmap(sc->sc_dmat, d->d_kva, size);
! 983: fail3:
! 984: bus_dmamem_free(sc->sc_dmat, &d->d_seg, 1);
! 985: fail2:
! 986: bus_dmamap_destroy(sc->sc_dmat, d->d_map);
! 987: fail1:
! 988: free(d, pool);
! 989: fail:
! 990: return (NULL);
! 991: }
! 992:
! 993: void
! 994: harmony_freem(void *vsc, void *ptr, int pool)
! 995: {
! 996: struct harmony_softc *sc = vsc;
! 997: struct harmony_dma *d, **dd;
! 998:
! 999: for (dd = &sc->sc_dmas; (d = *dd) != NULL; dd = &(*dd)->d_next) {
! 1000: if (d->d_kva != ptr)
! 1001: continue;
! 1002: bus_dmamap_unload(sc->sc_dmat, d->d_map);
! 1003: bus_dmamem_unmap(sc->sc_dmat, d->d_kva, d->d_size);
! 1004: bus_dmamem_free(sc->sc_dmat, &d->d_seg, 1);
! 1005: bus_dmamap_destroy(sc->sc_dmat, d->d_map);
! 1006: free(d, pool);
! 1007: return;
! 1008: }
! 1009: printf("%s: free rogue pointer\n", sc->sc_dv.dv_xname);
! 1010: }
! 1011:
! 1012: size_t
! 1013: harmony_round_buffersize(void *vsc, int direction, size_t size)
! 1014: {
! 1015: return ((size + HARMONY_BUFSIZE - 1) & (size_t)(-HARMONY_BUFSIZE));
! 1016: }
! 1017:
! 1018: int
! 1019: harmony_get_props(void *vsc)
! 1020: {
! 1021: return (AUDIO_PROP_FULLDUPLEX);
! 1022: }
! 1023:
! 1024: int
! 1025: harmony_trigger_output(void *vsc, void *start, void *end, int blksize,
! 1026: void (*intr)(void *), void *intrarg, struct audio_params *param)
! 1027: {
! 1028: struct harmony_softc *sc = vsc;
! 1029: struct harmony_channel *c = &sc->sc_playback;
! 1030: struct harmony_dma *d;
! 1031: bus_addr_t nextaddr;
! 1032: bus_size_t togo;
! 1033:
! 1034: for (d = sc->sc_dmas; d->d_kva != start; d = d->d_next)
! 1035: /*EMPTY*/;
! 1036: if (d == NULL) {
! 1037: printf("%s: trigger_output: bad addr: %p\n",
! 1038: sc->sc_dv.dv_xname, start);
! 1039: return (EINVAL);
! 1040: }
! 1041:
! 1042: c->c_intr = intr;
! 1043: c->c_intrarg = intrarg;
! 1044: c->c_blksz = blksize;
! 1045: c->c_current = d;
! 1046: c->c_segsz = (caddr_t)end - (caddr_t)start;
! 1047: c->c_cnt = 0;
! 1048: c->c_lastaddr = d->d_map->dm_segs[0].ds_addr;
! 1049:
! 1050: sc->sc_playing = 1;
! 1051:
! 1052: togo = c->c_segsz - c->c_cnt;
! 1053: if (togo == 0) {
! 1054: nextaddr = d->d_map->dm_segs[0].ds_addr;
! 1055: c->c_cnt = togo = c->c_blksz;
! 1056: } else {
! 1057: nextaddr = c->c_lastaddr;
! 1058: if (togo > c->c_blksz)
! 1059: togo = c->c_blksz;
! 1060: c->c_cnt += togo;
! 1061: }
! 1062:
! 1063: bus_dmamap_sync(sc->sc_dmat, d->d_map,
! 1064: nextaddr - d->d_map->dm_segs[0].ds_addr,
! 1065: c->c_blksz, BUS_DMASYNC_PREWRITE);
! 1066:
! 1067: WRITE_REG(sc, HARMONY_PNXTADD, nextaddr);
! 1068: c->c_theaddr = nextaddr;
! 1069: SYNC_REG(sc, HARMONY_PNXTADD, BUS_SPACE_BARRIER_WRITE);
! 1070: c->c_lastaddr = nextaddr + togo;
! 1071:
! 1072: harmony_start_cp(sc);
! 1073: harmony_intr_enable(sc);
! 1074:
! 1075: return (0);
! 1076: }
! 1077:
! 1078: void
! 1079: harmony_start_cp(struct harmony_softc *sc)
! 1080: {
! 1081: struct harmony_channel *c = &sc->sc_capture;
! 1082: struct harmony_dma *d;
! 1083: bus_addr_t nextaddr;
! 1084: bus_size_t togo;
! 1085:
! 1086: if (sc->sc_capturing == 0) {
! 1087: WRITE_REG(sc, HARMONY_RNXTADD,
! 1088: sc->sc_capture_paddrs[sc->sc_capture_empty]);
! 1089: if (++sc->sc_capture_empty == CAPTURE_EMPTYS)
! 1090: sc->sc_capture_empty = 0;
! 1091: } else {
! 1092: d = c->c_current;
! 1093: togo = c->c_segsz - c->c_cnt;
! 1094: if (togo == 0) {
! 1095: nextaddr = d->d_map->dm_segs[0].ds_addr;
! 1096: c->c_cnt = togo = c->c_blksz;
! 1097: } else {
! 1098: nextaddr = c->c_lastaddr;
! 1099: if (togo > c->c_blksz)
! 1100: togo = c->c_blksz;
! 1101: c->c_cnt += togo;
! 1102: }
! 1103:
! 1104: bus_dmamap_sync(sc->sc_dmat, d->d_map,
! 1105: nextaddr - d->d_map->dm_segs[0].ds_addr,
! 1106: c->c_blksz, BUS_DMASYNC_PREWRITE);
! 1107:
! 1108: WRITE_REG(sc, HARMONY_RNXTADD, nextaddr);
! 1109: SYNC_REG(sc, HARMONY_RNXTADD, BUS_SPACE_BARRIER_WRITE);
! 1110: c->c_lastaddr = nextaddr + togo;
! 1111: }
! 1112:
! 1113: timeout_add(&sc->sc_acc_tmo, 1);
! 1114: }
! 1115:
! 1116: int
! 1117: harmony_trigger_input(void *vsc, void *start, void *end, int blksize,
! 1118: void (*intr)(void *), void *intrarg, struct audio_params *param)
! 1119: {
! 1120: struct harmony_softc *sc = vsc;
! 1121: struct harmony_channel *c = &sc->sc_capture;
! 1122: struct harmony_dma *d;
! 1123:
! 1124: for (d = sc->sc_dmas; d->d_kva != start; d = d->d_next)
! 1125: /*EMPTY*/;
! 1126: if (d == NULL) {
! 1127: printf("%s: trigger_input: bad addr: %p\n",
! 1128: sc->sc_dv.dv_xname, start);
! 1129: return (EINVAL);
! 1130: }
! 1131:
! 1132: c->c_intr = intr;
! 1133: c->c_intrarg = intrarg;
! 1134: c->c_blksz = blksize;
! 1135: c->c_current = d;
! 1136: c->c_segsz = (caddr_t)end - (caddr_t)start;
! 1137: c->c_cnt = 0;
! 1138: c->c_lastaddr = d->d_map->dm_segs[0].ds_addr;
! 1139:
! 1140: sc->sc_capturing = 1;
! 1141: harmony_start_cp(sc);
! 1142: harmony_intr_enable(sc);
! 1143: return (0);
! 1144: }
! 1145:
! 1146: static const struct speed_struct {
! 1147: u_int32_t speed;
! 1148: u_int32_t bits;
! 1149: } harmony_speeds[] = {
! 1150: { 5125, CNTL_RATE_5125 },
! 1151: { 6615, CNTL_RATE_6615 },
! 1152: { 8000, CNTL_RATE_8000 },
! 1153: { 9600, CNTL_RATE_9600 },
! 1154: { 11025, CNTL_RATE_11025 },
! 1155: { 16000, CNTL_RATE_16000 },
! 1156: { 18900, CNTL_RATE_18900 },
! 1157: { 22050, CNTL_RATE_22050 },
! 1158: { 27428, CNTL_RATE_27428 },
! 1159: { 32000, CNTL_RATE_32000 },
! 1160: { 33075, CNTL_RATE_33075 },
! 1161: { 37800, CNTL_RATE_37800 },
! 1162: { 44100, CNTL_RATE_44100 },
! 1163: { 48000, CNTL_RATE_48000 },
! 1164: };
! 1165:
! 1166: u_int32_t
! 1167: harmony_speed_bits(struct harmony_softc *sc, u_long *speedp)
! 1168: {
! 1169: int i, n, selected = -1;
! 1170:
! 1171: n = sizeof(harmony_speeds) / sizeof(harmony_speeds[0]);
! 1172:
! 1173: if ((*speedp) <= harmony_speeds[0].speed)
! 1174: selected = 0;
! 1175: else if ((*speedp) >= harmony_speeds[n - 1].speed)
! 1176: selected = n - 1;
! 1177: else {
! 1178: for (i = 1; selected == -1 && i < n; i++) {
! 1179: if ((*speedp) == harmony_speeds[i].speed)
! 1180: selected = i;
! 1181: else if ((*speedp) < harmony_speeds[i].speed) {
! 1182: int diff1, diff2;
! 1183:
! 1184: diff1 = (*speedp) - harmony_speeds[i - 1].speed;
! 1185: diff2 = harmony_speeds[i].speed - (*speedp);
! 1186: if (diff1 < diff2)
! 1187: selected = i - 1;
! 1188: else
! 1189: selected = i;
! 1190: }
! 1191: }
! 1192: }
! 1193:
! 1194: if (selected == -1)
! 1195: selected = 2;
! 1196:
! 1197: *speedp = harmony_speeds[selected].speed;
! 1198: return (harmony_speeds[selected].bits);
! 1199: }
! 1200:
! 1201: int
! 1202: harmony_set_gainctl(struct harmony_softc *sc)
! 1203: {
! 1204: u_int32_t bits, mask, val, old;
! 1205:
! 1206: /* XXX leave these bits alone or the chip will not come out of CNTL */
! 1207: bits = GAINCTL_LE | GAINCTL_HE | GAINCTL_SE | GAINCTL_IS_MASK;
! 1208:
! 1209: /* input level */
! 1210: bits |= ((sc->sc_input_lvl.left >> (8 - GAINCTL_INPUT_BITS)) <<
! 1211: GAINCTL_INPUT_LEFT_S) & GAINCTL_INPUT_LEFT_M;
! 1212: bits |= ((sc->sc_input_lvl.right >> (8 - GAINCTL_INPUT_BITS)) <<
! 1213: GAINCTL_INPUT_RIGHT_S) & GAINCTL_INPUT_RIGHT_M;
! 1214:
! 1215: /* output level (inverted) */
! 1216: mask = (1 << GAINCTL_OUTPUT_BITS) - 1;
! 1217: val = mask - (sc->sc_output_lvl.left >> (8 - GAINCTL_OUTPUT_BITS));
! 1218: bits |= (val << GAINCTL_OUTPUT_LEFT_S) & GAINCTL_OUTPUT_LEFT_M;
! 1219: val = mask - (sc->sc_output_lvl.right >> (8 - GAINCTL_OUTPUT_BITS));
! 1220: bits |= (val << GAINCTL_OUTPUT_RIGHT_S) & GAINCTL_OUTPUT_RIGHT_M;
! 1221:
! 1222: /* monitor level (inverted) */
! 1223: mask = (1 << GAINCTL_MONITOR_BITS) - 1;
! 1224: val = mask - (sc->sc_monitor_lvl.left >> (8 - GAINCTL_MONITOR_BITS));
! 1225: bits |= (val << GAINCTL_MONITOR_S) & GAINCTL_MONITOR_M;
! 1226:
! 1227: /* XXX messing with these causes CNTL_C to get stuck... grr. */
! 1228: bits &= ~GAINCTL_IS_MASK;
! 1229: if (sc->sc_in_port == HARMONY_IN_MIC)
! 1230: bits |= GAINCTL_IS_LINE;
! 1231: else
! 1232: bits |= GAINCTL_IS_MICROPHONE;
! 1233:
! 1234: /* XXX messing with these causes CNTL_C to get stuck... grr. */
! 1235: bits &= ~(GAINCTL_LE | GAINCTL_HE | GAINCTL_SE);
! 1236: if (sc->sc_out_port == HARMONY_OUT_LINE)
! 1237: bits |= GAINCTL_LE;
! 1238: else if (sc->sc_out_port == HARMONY_OUT_SPEAKER)
! 1239: bits |= GAINCTL_SE;
! 1240: else
! 1241: bits |= GAINCTL_HE;
! 1242:
! 1243: mask = GAINCTL_LE | GAINCTL_HE | GAINCTL_SE | GAINCTL_IS_MASK;
! 1244: old = bus_space_read_4(sc->sc_bt, sc->sc_bh, HARMONY_GAINCTL);
! 1245: bus_space_write_4(sc->sc_bt, sc->sc_bh, HARMONY_GAINCTL, bits);
! 1246: if ((old & mask) != (bits & mask))
! 1247: return (1);
! 1248: return (0);
! 1249: }
! 1250:
! 1251: void
! 1252: harmony_try_more(struct harmony_softc *sc)
! 1253: {
! 1254: struct harmony_channel *c = &sc->sc_playback;
! 1255: struct harmony_dma *d = c->c_current;
! 1256: u_int32_t cur;
! 1257: int i, nsegs;
! 1258:
! 1259: cur = bus_space_read_4(sc->sc_bt, sc->sc_bh, HARMONY_PCURADD);
! 1260: cur &= PCURADD_BUFMASK;
! 1261: nsegs = 0;
! 1262:
! 1263: #ifdef DIAGNOSTIC
! 1264: if (cur < d->d_map->dm_segs[0].ds_addr ||
! 1265: cur >= (d->d_map->dm_segs[0].ds_addr + c->c_segsz))
! 1266: panic("%s: bad current %x < %lx || %x > %lx",
! 1267: sc->sc_dv.dv_xname, cur, d->d_map->dm_segs[0].ds_addr, cur,
! 1268: d->d_map->dm_segs[0].ds_addr + c->c_segsz);
! 1269: #endif /* DIAGNOSTIC */
! 1270:
! 1271: if (cur > c->c_theaddr) {
! 1272: nsegs = (cur - c->c_theaddr) / HARMONY_BUFSIZE;
! 1273: } else if (cur < c->c_theaddr) {
! 1274: nsegs = (d->d_map->dm_segs[0].ds_addr + c->c_segsz -
! 1275: c->c_theaddr) / HARMONY_BUFSIZE;
! 1276: nsegs += (cur - d->d_map->dm_segs[0].ds_addr) /
! 1277: HARMONY_BUFSIZE;
! 1278: }
! 1279:
! 1280: if (nsegs != 0 && c->c_intr != NULL) {
! 1281: for (i = 0; i < nsegs; i++)
! 1282: (*c->c_intr)(c->c_intrarg);
! 1283: c->c_theaddr = cur;
! 1284: }
! 1285: }
! 1286:
! 1287: struct cfdriver harmony_cd = {
! 1288: NULL, "harmony", DV_DULL
! 1289: };
! 1290:
! 1291: struct cfattach harmony_ca = {
! 1292: sizeof(struct harmony_softc), harmony_match, harmony_attach
! 1293: };
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to harmony.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hppa / gsc