Annotation of sys/dev/pci/fms.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: fms.c,v 1.17 2005/04/16 21:57:23 mickey Exp $ */
! 2: /* $NetBSD: fms.c,v 1.5.4.1 2000/06/30 16:27:50 simonb Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 1999 The NetBSD Foundation, Inc.
! 6: * All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to The NetBSD Foundation
! 9: * by Witold J. Wnuk.
! 10: *
! 11: * Redistribution and use in source and binary forms, with or without
! 12: * modification, are permitted provided that the following conditions
! 13: * are met:
! 14: * 1. Redistributions of source code must retain the above copyright
! 15: * notice, this list of conditions and the following disclaimer.
! 16: * 2. Redistributions in binary form must reproduce the above copyright
! 17: * notice, this list of conditions and the following disclaimer in the
! 18: * documentation and/or other materials provided with the distribution.
! 19: * 3. All advertising materials mentioning features or use of this software
! 20: * must display the following acknowledgement:
! 21: * This product includes software developed by the NetBSD
! 22: * Foundation, Inc. and its contributors.
! 23: * 4. Neither the name of The NetBSD Foundation nor the names of its
! 24: * contributors may be used to endorse or promote products derived
! 25: * from this software without specific prior written permission.
! 26: *
! 27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
! 28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
! 31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
! 34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 37: * POSSIBILITY OF SUCH DAMAGE.
! 38: */
! 39:
! 40: /*
! 41: * Forte Media FM801 Audio Device Driver
! 42: */
! 43:
! 44: #include "radio.h"
! 45:
! 46: #include <sys/param.h>
! 47: #include <sys/systm.h>
! 48: #include <sys/kernel.h>
! 49: #include <sys/malloc.h>
! 50: #include <sys/device.h>
! 51: #include <sys/audioio.h>
! 52:
! 53: #include <machine/bus.h>
! 54: #include <machine/cpu.h>
! 55:
! 56: #include <dev/pci/pcidevs.h>
! 57: #include <dev/pci/pcivar.h>
! 58:
! 59: #include <dev/audio_if.h>
! 60: #include <dev/mulaw.h>
! 61: #include <dev/auconv.h>
! 62:
! 63: #include <dev/ic/ac97.h>
! 64: #if 0
! 65: #include <dev/ic/mpuvar.h>
! 66: #endif
! 67:
! 68: #include <dev/pci/fmsreg.h>
! 69: #include <dev/pci/fmsvar.h>
! 70:
! 71:
! 72: struct fms_dma {
! 73: struct fms_dma *next;
! 74: caddr_t addr;
! 75: size_t size;
! 76: bus_dmamap_t map;
! 77: bus_dma_segment_t seg;
! 78: };
! 79:
! 80:
! 81:
! 82: int fms_match(struct device *, void *, void *);
! 83: void fms_attach(struct device *, struct device *, void *);
! 84: int fms_intr(void *);
! 85:
! 86: int fms_open(void *, int);
! 87: void fms_close(void *);
! 88: int fms_query_encoding(void *, struct audio_encoding *);
! 89: int fms_set_params(void *, int, int, struct audio_params *,
! 90: struct audio_params *);
! 91: int fms_round_blocksize(void *, int);
! 92: int fms_halt_output(void *);
! 93: int fms_halt_input(void *);
! 94: int fms_getdev(void *, struct audio_device *);
! 95: int fms_set_port(void *, mixer_ctrl_t *);
! 96: int fms_get_port(void *, mixer_ctrl_t *);
! 97: int fms_query_devinfo(void *, mixer_devinfo_t *);
! 98: void *fms_malloc(void *, int, size_t, int, int);
! 99: void fms_free(void *, void *, int);
! 100: paddr_t fms_mappage(void *, void *, off_t, int);
! 101: int fms_get_props(void *);
! 102: int fms_trigger_output(void *, void *, void *, int, void (*)(void *),
! 103: void *, struct audio_params *);
! 104: int fms_trigger_input(void *, void *, void *, int, void (*)(void *),
! 105: void *, struct audio_params *);
! 106:
! 107: struct cfdriver fms_cd = {
! 108: NULL, "fms", DV_DULL
! 109: };
! 110:
! 111: struct cfattach fms_ca = {
! 112: sizeof (struct fms_softc), fms_match, fms_attach
! 113: };
! 114:
! 115: struct audio_device fms_device = {
! 116: "Forte Media 801",
! 117: "1.0",
! 118: "fms"
! 119: };
! 120:
! 121:
! 122: struct audio_hw_if fms_hw_if = {
! 123: fms_open,
! 124: fms_close,
! 125: NULL,
! 126: fms_query_encoding,
! 127: fms_set_params,
! 128: fms_round_blocksize,
! 129: NULL,
! 130: NULL,
! 131: NULL,
! 132: NULL,
! 133: NULL,
! 134: fms_halt_output,
! 135: fms_halt_input,
! 136: NULL,
! 137: fms_getdev,
! 138: NULL,
! 139: fms_set_port,
! 140: fms_get_port,
! 141: fms_query_devinfo,
! 142: fms_malloc,
! 143: fms_free,
! 144: NULL,
! 145: fms_mappage,
! 146: fms_get_props,
! 147: fms_trigger_output,
! 148: fms_trigger_input
! 149: };
! 150:
! 151: int fms_attach_codec(void *, struct ac97_codec_if *);
! 152: int fms_read_codec(void *, u_int8_t, u_int16_t *);
! 153: int fms_write_codec(void *, u_int8_t, u_int16_t);
! 154: void fms_reset_codec(void *);
! 155:
! 156: int fms_allocmem(struct fms_softc *, size_t, size_t,
! 157: struct fms_dma *);
! 158: int fms_freemem(struct fms_softc *, struct fms_dma *);
! 159:
! 160: int
! 161: fms_match(parent, match, aux)
! 162: struct device *parent;
! 163: void *match;
! 164: void *aux;
! 165: {
! 166: struct pci_attach_args *pa = (struct pci_attach_args *) aux;
! 167:
! 168: if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_FORTEMEDIA &&
! 169: PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_FORTEMEDIA_FM801)
! 170: return (1);
! 171: return (0);
! 172: }
! 173:
! 174: void
! 175: fms_attach(parent, self, aux)
! 176: struct device *parent;
! 177: struct device *self;
! 178: void *aux;
! 179: {
! 180: struct pci_attach_args *pa = aux;
! 181: struct fms_softc *sc = (struct fms_softc *) self;
! 182: struct audio_attach_args aa;
! 183: pci_chipset_tag_t pc = pa->pa_pc;
! 184: pcitag_t pt = pa->pa_tag;
! 185: pci_intr_handle_t ih;
! 186: bus_size_t iosize;
! 187: const char *intrstr;
! 188: u_int16_t k1;
! 189: int i;
! 190:
! 191: if (pci_mapreg_map(pa, 0x10, PCI_MAPREG_TYPE_IO, 0, &sc->sc_iot,
! 192: &sc->sc_ioh, NULL, &iosize, 0)) {
! 193: printf(": can't map i/o space\n");
! 194: return;
! 195: }
! 196:
! 197: if (bus_space_subregion(sc->sc_iot, sc->sc_ioh, 0x30, 2,
! 198: &sc->sc_mpu_ioh)) {
! 199: printf(": can't get mpu subregion handle\n");
! 200: bus_space_unmap(sc->sc_iot, sc->sc_ioh, iosize);
! 201: return;
! 202: }
! 203:
! 204: if (bus_space_subregion(sc->sc_iot, sc->sc_ioh, 0x68, 4,
! 205: &sc->sc_opl_ioh)) {
! 206: printf(": can't get opl subregion handle\n");
! 207: bus_space_unmap(sc->sc_iot, sc->sc_ioh, iosize);
! 208: return;
! 209: }
! 210:
! 211: if (pci_intr_map(pa, &ih)) {
! 212: printf(": couldn't map interrupt\n");
! 213: bus_space_unmap(sc->sc_iot, sc->sc_ioh, iosize);
! 214: return;
! 215: }
! 216: intrstr = pci_intr_string(pc, ih);
! 217:
! 218: sc->sc_ih = pci_intr_establish(pc, ih, IPL_AUDIO, fms_intr, sc,
! 219: sc->sc_dev.dv_xname);
! 220: if (sc->sc_ih == NULL) {
! 221: printf(": couldn't establish interrupt");
! 222: if (intrstr != NULL)
! 223: printf(" at %s", intrstr);
! 224: printf("\n");
! 225: bus_space_unmap(sc->sc_iot, sc->sc_ioh, iosize);
! 226: return;
! 227: }
! 228:
! 229: printf(": %s\n", intrstr);
! 230:
! 231: sc->sc_dmat = pa->pa_dmat;
! 232:
! 233: /* Disable legacy audio (SBPro compatibility) */
! 234: pci_conf_write(pc, pt, 0x40, 0);
! 235:
! 236: /* Reset codec and AC'97 */
! 237: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_CODEC_CTL, 0x0020);
! 238: delay(2); /* > 1us according to AC'97 documentation */
! 239: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_CODEC_CTL, 0x0000);
! 240: delay(1); /* > 168.2ns according to AC'97 documentation */
! 241:
! 242: /* Set up volume */
! 243: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_PCM_VOLUME, 0x0808);
! 244: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_FM_VOLUME, 0x0808);
! 245: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_I2S_VOLUME, 0x0808);
! 246:
! 247: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_RECORD_SOURCE, 0x0000);
! 248:
! 249: /* Unmask playback, record and mpu interrupts, mask the rest */
! 250: k1 = bus_space_read_2(sc->sc_iot, sc->sc_ioh, FM_INTMASK);
! 251: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_INTMASK,
! 252: (k1 & ~(FM_INTMASK_PLAY | FM_INTMASK_REC | FM_INTMASK_MPU)) |
! 253: FM_INTMASK_VOL);
! 254: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_INTSTATUS,
! 255: FM_INTSTATUS_PLAY | FM_INTSTATUS_REC | FM_INTSTATUS_MPU |
! 256: FM_INTSTATUS_VOL);
! 257:
! 258: #if NRADIO > 0
! 259: fmsradio_attach(sc);
! 260: #endif /* NRADIO > 0 */
! 261:
! 262: sc->host_if.arg = sc;
! 263: sc->host_if.attach = fms_attach_codec;
! 264: sc->host_if.read = fms_read_codec;
! 265: sc->host_if.write = fms_write_codec;
! 266: sc->host_if.reset = fms_reset_codec;
! 267:
! 268: if (ac97_attach(&sc->host_if) != 0)
! 269: return;
! 270:
! 271: /* Turn mute off */
! 272: for (i = 0; i < 3; i++) {
! 273: static struct {
! 274: char *class, *device;
! 275: } d[] = {
! 276: { AudioCoutputs, AudioNmaster },
! 277: { AudioCinputs, AudioNdac },
! 278: { AudioCrecord, AudioNvolume }
! 279: };
! 280: struct mixer_ctrl ctl;
! 281:
! 282: ctl.type = AUDIO_MIXER_ENUM;
! 283: ctl.un.ord = 0;
! 284: ctl.dev = sc->codec_if->vtbl->get_portnum_by_name(sc->codec_if,
! 285: d[i].class, d[i].device, AudioNmute);
! 286: fms_set_port(sc, &ctl);
! 287: }
! 288:
! 289: audio_attach_mi(&fms_hw_if, sc, &sc->sc_dev);
! 290:
! 291: aa.type = AUDIODEV_TYPE_OPL;
! 292: aa.hwif = NULL;
! 293: aa.hdl = NULL;
! 294: config_found(&sc->sc_dev, &aa, audioprint);
! 295:
! 296: aa.type = AUDIODEV_TYPE_MPU;
! 297: aa.hwif = NULL;
! 298: aa.hdl = NULL;
! 299: sc->sc_mpu_dev = config_found(&sc->sc_dev, &aa, audioprint);
! 300: }
! 301:
! 302: /*
! 303: * Each AC-link frame takes 20.8us, data should be ready in next frame,
! 304: * we allow more than two.
! 305: */
! 306: #define TIMO 50
! 307: int
! 308: fms_read_codec(addr, reg, val)
! 309: void *addr;
! 310: u_int8_t reg;
! 311: u_int16_t *val;
! 312: {
! 313: struct fms_softc *sc = addr;
! 314: int i;
! 315:
! 316: /* Poll until codec is ready */
! 317: for (i = 0; i < TIMO && bus_space_read_2(sc->sc_iot, sc->sc_ioh,
! 318: FM_CODEC_CMD) & FM_CODEC_CMD_BUSY; i++)
! 319: delay(1);
! 320: if (i >= TIMO) {
! 321: printf("fms: codec busy\n");
! 322: return 1;
! 323: }
! 324:
! 325: /* Write register index, read access */
! 326: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_CODEC_CMD,
! 327: reg | FM_CODEC_CMD_READ);
! 328:
! 329: /* Poll until we have valid data */
! 330: for (i = 0; i < TIMO && !(bus_space_read_2(sc->sc_iot, sc->sc_ioh,
! 331: FM_CODEC_CMD) & FM_CODEC_CMD_VALID); i++)
! 332: delay(1);
! 333: if (i >= TIMO) {
! 334: printf("fms: no data from codec\n");
! 335: return 1;
! 336: }
! 337:
! 338: /* Read data */
! 339: *val = bus_space_read_2(sc->sc_iot, sc->sc_ioh, FM_CODEC_DATA);
! 340: return 0;
! 341: }
! 342:
! 343: int
! 344: fms_write_codec(addr, reg, val)
! 345: void *addr;
! 346: u_int8_t reg;
! 347: u_int16_t val;
! 348: {
! 349: struct fms_softc *sc = addr;
! 350: int i;
! 351:
! 352: /* Poll until codec is ready */
! 353: for (i = 0; i < TIMO && bus_space_read_2(sc->sc_iot, sc->sc_ioh,
! 354: FM_CODEC_CMD) & FM_CODEC_CMD_BUSY; i++)
! 355: delay(1);
! 356: if (i >= TIMO) {
! 357: printf("fms: codec busy\n");
! 358: return 1;
! 359: }
! 360:
! 361: /* Write data */
! 362: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_CODEC_DATA, val);
! 363: /* Write index register, write access */
! 364: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_CODEC_CMD, reg);
! 365: return 0;
! 366: }
! 367: #undef TIMO
! 368:
! 369: int
! 370: fms_attach_codec(addr, cif)
! 371: void *addr;
! 372: struct ac97_codec_if *cif;
! 373: {
! 374: struct fms_softc *sc = addr;
! 375:
! 376: sc->codec_if = cif;
! 377: return 0;
! 378: }
! 379:
! 380: /* Cold Reset */
! 381: void
! 382: fms_reset_codec(addr)
! 383: void *addr;
! 384: {
! 385: struct fms_softc *sc = addr;
! 386: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_CODEC_CTL, 0x0020);
! 387: delay(2);
! 388: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_CODEC_CTL, 0x0000);
! 389: delay(1);
! 390: }
! 391:
! 392: int
! 393: fms_intr(arg)
! 394: void *arg;
! 395: {
! 396: struct fms_softc *sc = arg;
! 397: u_int16_t istat;
! 398:
! 399: istat = bus_space_read_2(sc->sc_iot, sc->sc_ioh, FM_INTSTATUS);
! 400:
! 401: if (istat & FM_INTSTATUS_PLAY) {
! 402: if ((sc->sc_play_nextblk += sc->sc_play_blksize) >=
! 403: sc->sc_play_end)
! 404: sc->sc_play_nextblk = sc->sc_play_start;
! 405:
! 406: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 407: sc->sc_play_flip++ & 1 ?
! 408: FM_PLAY_DMABUF2 : FM_PLAY_DMABUF1, sc->sc_play_nextblk);
! 409:
! 410: if (sc->sc_pintr)
! 411: sc->sc_pintr(sc->sc_parg);
! 412: else
! 413: printf("unexpected play intr\n");
! 414: }
! 415:
! 416: if (istat & FM_INTSTATUS_REC) {
! 417: if ((sc->sc_rec_nextblk += sc->sc_rec_blksize) >=
! 418: sc->sc_rec_end)
! 419: sc->sc_rec_nextblk = sc->sc_rec_start;
! 420:
! 421: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 422: sc->sc_rec_flip++ & 1 ?
! 423: FM_REC_DMABUF2 : FM_REC_DMABUF1, sc->sc_rec_nextblk);
! 424:
! 425: if (sc->sc_rintr)
! 426: sc->sc_rintr(sc->sc_rarg);
! 427: else
! 428: printf("unexpected rec intr\n");
! 429: }
! 430:
! 431: #if 0
! 432: if (istat & FM_INTSTATUS_MPU)
! 433: mpu_intr(sc->sc_mpu_dev);
! 434: #endif
! 435:
! 436: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_INTSTATUS,
! 437: istat & (FM_INTSTATUS_PLAY | FM_INTSTATUS_REC));
! 438:
! 439: return 1;
! 440: }
! 441:
! 442: int
! 443: fms_open(addr, flags)
! 444: void *addr;
! 445: int flags;
! 446: {
! 447: /* UNUSED struct fms_softc *sc = addr;*/
! 448:
! 449: return 0;
! 450: }
! 451:
! 452: void
! 453: fms_close(addr)
! 454: void *addr;
! 455: {
! 456: /* UNUSED struct fms_softc *sc = addr;*/
! 457: }
! 458:
! 459: int
! 460: fms_query_encoding(addr, fp)
! 461: void *addr;
! 462: struct audio_encoding *fp;
! 463: {
! 464:
! 465: switch (fp->index) {
! 466: case 0:
! 467: strlcpy(fp->name, AudioEmulaw, sizeof fp->name);
! 468: fp->encoding = AUDIO_ENCODING_ULAW;
! 469: fp->precision = 8;
! 470: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 471: return 0;
! 472: case 1:
! 473: strlcpy(fp->name, AudioEslinear_le, sizeof fp->name);
! 474: fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
! 475: fp->precision = 16;
! 476: fp->flags = 0;
! 477: return 0;
! 478: case 2:
! 479: strlcpy(fp->name, AudioEulinear, sizeof fp->name);
! 480: fp->encoding = AUDIO_ENCODING_ULINEAR;
! 481: fp->precision = 8;
! 482: fp->flags = 0;
! 483: return 0;
! 484: case 3:
! 485: strlcpy(fp->name, AudioEalaw, sizeof fp->name);
! 486: fp->encoding = AUDIO_ENCODING_ALAW;
! 487: fp->precision = 8;
! 488: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 489: return 0;
! 490: case 4:
! 491: strlcpy(fp->name, AudioEulinear_le, sizeof fp->name);
! 492: fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
! 493: fp->precision = 16;
! 494: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 495: return 0;
! 496: case 5:
! 497: strlcpy(fp->name, AudioEslinear, sizeof fp->name);
! 498: fp->encoding = AUDIO_ENCODING_SLINEAR;
! 499: fp->precision = 8;
! 500: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 501: return 0;
! 502: case 6:
! 503: strlcpy(fp->name, AudioEulinear_be, sizeof fp->name);
! 504: fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
! 505: fp->precision = 16;
! 506: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 507: return 0;
! 508: case 7:
! 509: strlcpy(fp->name, AudioEslinear_be, sizeof fp->name);
! 510: fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
! 511: fp->precision = 16;
! 512: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 513: return 0;
! 514: default:
! 515: return EINVAL;
! 516: }
! 517: }
! 518:
! 519: /*
! 520: * Range below -limit- is set to -rate-
! 521: * What a pity FM801 does not have 24000
! 522: * 24000 -> 22050 sounds rather poor
! 523: */
! 524: struct {
! 525: int limit;
! 526: int rate;
! 527: } fms_rates[11] = {
! 528: { 6600, 5500 },
! 529: { 8750, 8000 },
! 530: { 10250, 9600 },
! 531: { 13200, 11025 },
! 532: { 17500, 16000 },
! 533: { 20500, 19200 },
! 534: { 26500, 22050 },
! 535: { 35000, 32000 },
! 536: { 41000, 38400 },
! 537: { 46000, 44100 },
! 538: { 48000, 48000 },
! 539: /* anything above -> 48000 */
! 540: };
! 541:
! 542: int
! 543: fms_set_params(addr, setmode, usemode, play, rec)
! 544: void *addr;
! 545: int setmode, usemode;
! 546: struct audio_params *play, *rec;
! 547: {
! 548: struct fms_softc *sc = addr;
! 549: int i;
! 550:
! 551: if (setmode & AUMODE_PLAY) {
! 552: play->factor = 1;
! 553: play->sw_code = 0;
! 554: switch(play->encoding) {
! 555: case AUDIO_ENCODING_ULAW:
! 556: play->factor = 2;
! 557: play->sw_code = mulaw_to_slinear16_le;
! 558: break;
! 559: case AUDIO_ENCODING_SLINEAR_LE:
! 560: if (play->precision == 8)
! 561: play->sw_code = change_sign8;
! 562: break;
! 563: case AUDIO_ENCODING_ULINEAR_LE:
! 564: if (play->precision == 16)
! 565: play->sw_code = change_sign16_le;
! 566: break;
! 567: case AUDIO_ENCODING_ALAW:
! 568: play->factor = 2;
! 569: play->sw_code = alaw_to_slinear16_le;
! 570: break;
! 571: case AUDIO_ENCODING_SLINEAR_BE:
! 572: if (play->precision == 16)
! 573: play->sw_code = swap_bytes;
! 574: else
! 575: play->sw_code = change_sign8;
! 576: break;
! 577: case AUDIO_ENCODING_ULINEAR_BE:
! 578: if (play->precision == 16)
! 579: play->sw_code = change_sign16_swap_bytes_le;
! 580: break;
! 581: default:
! 582: return EINVAL;
! 583: }
! 584: for (i = 0; i < 10 && play->sample_rate > fms_rates[i].limit;
! 585: i++)
! 586: ;
! 587: play->sample_rate = fms_rates[i].rate;
! 588: sc->sc_play_reg = (play->channels == 2 ? FM_PLAY_STEREO : 0) |
! 589: (play->precision * play->factor == 16 ? FM_PLAY_16BIT : 0) |
! 590: (i << 8);
! 591: }
! 592:
! 593: if (setmode & AUMODE_RECORD) {
! 594:
! 595: rec->factor = 1;
! 596: rec->sw_code = 0;
! 597: switch(rec->encoding) {
! 598: case AUDIO_ENCODING_ULAW:
! 599: rec->sw_code = ulinear8_to_mulaw;
! 600: break;
! 601: case AUDIO_ENCODING_SLINEAR_LE:
! 602: if (rec->precision == 8)
! 603: rec->sw_code = change_sign8;
! 604: break;
! 605: case AUDIO_ENCODING_ULINEAR_LE:
! 606: if (rec->precision == 16)
! 607: rec->sw_code = change_sign16_le;
! 608: break;
! 609: case AUDIO_ENCODING_ALAW:
! 610: rec->sw_code = ulinear8_to_alaw;
! 611: break;
! 612: case AUDIO_ENCODING_SLINEAR_BE:
! 613: if (play->precision == 16)
! 614: play->sw_code = swap_bytes;
! 615: else
! 616: play->sw_code = change_sign8;
! 617: break;
! 618: case AUDIO_ENCODING_ULINEAR_BE:
! 619: if (play->precision == 16)
! 620: play->sw_code = swap_bytes_change_sign16_le;
! 621: break;
! 622: default:
! 623: return EINVAL;
! 624: }
! 625: for (i = 0; i < 10 && rec->sample_rate > fms_rates[i].limit;
! 626: i++)
! 627: ;
! 628: rec->sample_rate = fms_rates[i].rate;
! 629: sc->sc_rec_reg =
! 630: (rec->channels == 2 ? FM_REC_STEREO : 0) |
! 631: (rec->precision * rec->factor == 16 ? FM_REC_16BIT : 0) |
! 632: (i << 8);
! 633: }
! 634:
! 635: return 0;
! 636: }
! 637:
! 638: int
! 639: fms_round_blocksize(addr, blk)
! 640: void *addr;
! 641: int blk;
! 642: {
! 643: return (blk + 0xf) & ~0xf;
! 644: }
! 645:
! 646: int
! 647: fms_halt_output(addr)
! 648: void *addr;
! 649: {
! 650: struct fms_softc *sc = addr;
! 651: u_int16_t k1;
! 652:
! 653: k1 = bus_space_read_2(sc->sc_iot, sc->sc_ioh, FM_PLAY_CTL);
! 654: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_PLAY_CTL,
! 655: (k1 & ~(FM_PLAY_STOPNOW | FM_PLAY_START)) |
! 656: FM_PLAY_BUF1_LAST | FM_PLAY_BUF2_LAST);
! 657:
! 658: return 0;
! 659: }
! 660:
! 661: int
! 662: fms_halt_input(addr)
! 663: void *addr;
! 664: {
! 665: struct fms_softc *sc = addr;
! 666: u_int16_t k1;
! 667:
! 668: k1 = bus_space_read_2(sc->sc_iot, sc->sc_ioh, FM_REC_CTL);
! 669: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_REC_CTL,
! 670: (k1 & ~(FM_REC_STOPNOW | FM_REC_START)) |
! 671: FM_REC_BUF1_LAST | FM_REC_BUF2_LAST);
! 672:
! 673: return 0;
! 674: }
! 675:
! 676: int
! 677: fms_getdev(addr, retp)
! 678: void *addr;
! 679: struct audio_device *retp;
! 680: {
! 681: *retp = fms_device;
! 682: return 0;
! 683: }
! 684:
! 685: int
! 686: fms_set_port(addr, cp)
! 687: void *addr;
! 688: mixer_ctrl_t *cp;
! 689: {
! 690: struct fms_softc *sc = addr;
! 691:
! 692: return (sc->codec_if->vtbl->mixer_set_port(sc->codec_if, cp));
! 693: }
! 694:
! 695: int
! 696: fms_get_port(addr, cp)
! 697: void *addr;
! 698: mixer_ctrl_t *cp;
! 699: {
! 700: struct fms_softc *sc = addr;
! 701:
! 702: return (sc->codec_if->vtbl->mixer_get_port(sc->codec_if, cp));
! 703: }
! 704:
! 705: void *
! 706: fms_malloc(addr, direction, size, pool, flags)
! 707: void *addr;
! 708: int direction;
! 709: size_t size;
! 710: int pool, flags;
! 711: {
! 712: struct fms_softc *sc = addr;
! 713: struct fms_dma *p;
! 714: int error;
! 715: int rseg;
! 716:
! 717: p = malloc(sizeof(*p), pool, flags);
! 718: if (!p)
! 719: return 0;
! 720:
! 721: p->size = size;
! 722: if ((error = bus_dmamem_alloc(sc->sc_dmat, size, NBPG, 0, &p->seg, 1,
! 723: &rseg, BUS_DMA_NOWAIT)) != 0) {
! 724: printf("%s: unable to allocate dma, error = %d\n",
! 725: sc->sc_dev.dv_xname, error);
! 726: goto fail_alloc;
! 727: }
! 728:
! 729: if ((error = bus_dmamem_map(sc->sc_dmat, &p->seg, rseg, size, &p->addr,
! 730: BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) != 0) {
! 731: printf("%s: unable to map dma, error = %d\n",
! 732: sc->sc_dev.dv_xname, error);
! 733: goto fail_map;
! 734: }
! 735:
! 736: if ((error = bus_dmamap_create(sc->sc_dmat, size, 1, size, 0,
! 737: BUS_DMA_NOWAIT, &p->map)) != 0) {
! 738: printf("%s: unable to create dma map, error = %d\n",
! 739: sc->sc_dev.dv_xname, error);
! 740: goto fail_create;
! 741: }
! 742:
! 743: if ((error = bus_dmamap_load(sc->sc_dmat, p->map, p->addr, size, NULL,
! 744: BUS_DMA_NOWAIT)) != 0) {
! 745: printf("%s: unable to load dma map, error = %d\n",
! 746: sc->sc_dev.dv_xname, error);
! 747: goto fail_load;
! 748: }
! 749:
! 750: p->next = sc->sc_dmas;
! 751: sc->sc_dmas = p;
! 752:
! 753: return p->addr;
! 754:
! 755:
! 756: fail_load:
! 757: bus_dmamap_destroy(sc->sc_dmat, p->map);
! 758: fail_create:
! 759: bus_dmamem_unmap(sc->sc_dmat, p->addr, size);
! 760: fail_map:
! 761: bus_dmamem_free(sc->sc_dmat, &p->seg, 1);
! 762: fail_alloc:
! 763: free(p, pool);
! 764: return 0;
! 765: }
! 766:
! 767: void
! 768: fms_free(addr, ptr, pool)
! 769: void *addr;
! 770: void *ptr;
! 771: int pool;
! 772: {
! 773: struct fms_softc *sc = addr;
! 774: struct fms_dma **pp, *p;
! 775:
! 776: for (pp = &(sc->sc_dmas); (p = *pp) != NULL; pp = &p->next)
! 777: if (p->addr == ptr) {
! 778: bus_dmamap_unload(sc->sc_dmat, p->map);
! 779: bus_dmamap_destroy(sc->sc_dmat, p->map);
! 780: bus_dmamem_unmap(sc->sc_dmat, p->addr, p->size);
! 781: bus_dmamem_free(sc->sc_dmat, &p->seg, 1);
! 782:
! 783: *pp = p->next;
! 784: free(p, pool);
! 785: return;
! 786: }
! 787:
! 788: panic("fms_free: trying to free unallocated memory");
! 789: }
! 790:
! 791: paddr_t
! 792: fms_mappage(addr, mem, off, prot)
! 793: void *addr;
! 794: void *mem;
! 795: off_t off;
! 796: int prot;
! 797: {
! 798: struct fms_softc *sc = addr;
! 799: struct fms_dma *p;
! 800:
! 801: if (off < 0)
! 802: return -1;
! 803:
! 804: for (p = sc->sc_dmas; p && p->addr != mem; p = p->next)
! 805: ;
! 806: if (!p)
! 807: return -1;
! 808:
! 809: return bus_dmamem_mmap(sc->sc_dmat, &p->seg, 1, off, prot,
! 810: BUS_DMA_WAITOK);
! 811: }
! 812:
! 813: int
! 814: fms_get_props(addr)
! 815: void *addr;
! 816: {
! 817: return AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT |
! 818: AUDIO_PROP_FULLDUPLEX;
! 819: }
! 820:
! 821: int
! 822: fms_query_devinfo(addr, dip)
! 823: void *addr;
! 824: mixer_devinfo_t *dip;
! 825: {
! 826: struct fms_softc *sc = addr;
! 827:
! 828: return (sc->codec_if->vtbl->query_devinfo(sc->codec_if, dip));
! 829: }
! 830:
! 831: int
! 832: fms_trigger_output(addr, start, end, blksize, intr, arg, param)
! 833: void *addr;
! 834: void *start, *end;
! 835: int blksize;
! 836: void (*intr)(void *);
! 837: void *arg;
! 838: struct audio_params *param;
! 839: {
! 840: struct fms_softc *sc = addr;
! 841: struct fms_dma *p;
! 842:
! 843: sc->sc_pintr = intr;
! 844: sc->sc_parg = arg;
! 845:
! 846: for (p = sc->sc_dmas; p && p->addr != start; p = p->next)
! 847: ;
! 848:
! 849: if (!p)
! 850: panic("fms_trigger_output: request with bad start "
! 851: "address (%p)", start);
! 852:
! 853: sc->sc_play_start = p->map->dm_segs[0].ds_addr;
! 854: sc->sc_play_end = sc->sc_play_start + ((char *)end - (char *)start);
! 855: sc->sc_play_blksize = blksize;
! 856: sc->sc_play_nextblk = sc->sc_play_start + sc->sc_play_blksize;
! 857: sc->sc_play_flip = 0;
! 858: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_PLAY_DMALEN, blksize - 1);
! 859: bus_space_write_4(sc->sc_iot, sc->sc_ioh, FM_PLAY_DMABUF1,
! 860: sc->sc_play_start);
! 861: bus_space_write_4(sc->sc_iot, sc->sc_ioh, FM_PLAY_DMABUF2,
! 862: sc->sc_play_nextblk);
! 863: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_PLAY_CTL,
! 864: FM_PLAY_START | FM_PLAY_STOPNOW | sc->sc_play_reg);
! 865: return 0;
! 866: }
! 867:
! 868:
! 869: int
! 870: fms_trigger_input(addr, start, end, blksize, intr, arg, param)
! 871: void *addr;
! 872: void *start, *end;
! 873: int blksize;
! 874: void (*intr)(void *);
! 875: void *arg;
! 876: struct audio_params *param;
! 877: {
! 878: struct fms_softc *sc = addr;
! 879: struct fms_dma *p;
! 880:
! 881: sc->sc_rintr = intr;
! 882: sc->sc_rarg = arg;
! 883:
! 884: for (p = sc->sc_dmas; p && p->addr != start; p = p->next)
! 885: ;
! 886:
! 887: if (!p)
! 888: panic("fms_trigger_input: request with bad start "
! 889: "address (%p)", start);
! 890:
! 891: sc->sc_rec_start = p->map->dm_segs[0].ds_addr;
! 892: sc->sc_rec_end = sc->sc_rec_start + ((char *)end - (char *)start);
! 893: sc->sc_rec_blksize = blksize;
! 894: sc->sc_rec_nextblk = sc->sc_rec_start + sc->sc_rec_blksize;
! 895: sc->sc_rec_flip = 0;
! 896: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_REC_DMALEN, blksize - 1);
! 897: bus_space_write_4(sc->sc_iot, sc->sc_ioh, FM_REC_DMABUF1,
! 898: sc->sc_rec_start);
! 899: bus_space_write_4(sc->sc_iot, sc->sc_ioh, FM_REC_DMABUF2,
! 900: sc->sc_rec_nextblk);
! 901: bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_REC_CTL,
! 902: FM_REC_START | FM_REC_STOPNOW | sc->sc_rec_reg);
! 903: return 0;
! 904: }
! 905:
! 906:
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to fms.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pci