Annotation of sys/dev/pci/azalia.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: azalia.c,v 1.29 2007/08/02 17:13:31 reyk Exp $ */
! 2: /* $NetBSD: azalia.c,v 1.20 2006/05/07 08:31:44 kent Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 2005 The NetBSD Foundation, Inc.
! 6: * All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to The NetBSD Foundation
! 9: * by TAMURA Kent
! 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: * High Definition Audio Specification
! 42: * ftp://download.intel.com/standards/hdaudio/pdf/HDAudio_03.pdf
! 43: *
! 44: *
! 45: * TO DO:
! 46: * - S/PDIF
! 47: * - power hook
! 48: * - multiple codecs (needed?)
! 49: * - multiple streams (needed?)
! 50: */
! 51:
! 52: #include <sys/cdefs.h>
! 53: #ifdef NETBSD_GOOP
! 54: __KERNEL_RCSID(0, "$NetBSD: azalia.c,v 1.15 2005/09/29 04:14:03 kent Exp $");
! 55: #endif
! 56:
! 57: #include <sys/param.h>
! 58: #include <sys/device.h>
! 59: #include <sys/malloc.h>
! 60: #include <sys/systm.h>
! 61: #include <uvm/uvm_param.h>
! 62: #include <dev/audio_if.h>
! 63: #include <dev/auconv.h>
! 64: #include <dev/pci/pcidevs.h>
! 65: #include <dev/pci/pcivar.h>
! 66:
! 67: #include <dev/pci/azalia.h>
! 68:
! 69: typedef struct audio_params audio_params_t;
! 70: #ifndef BUS_DMA_NOCACHE
! 71: #define BUS_DMA_NOCACHE 0
! 72: #endif
! 73: #define auconv_delete_encodings(x...)
! 74: #define auconv_query_encoding(x...) (EINVAL)
! 75: #define auconv_create_encodings(x...) (0)
! 76:
! 77: struct audio_format {
! 78: void *driver_data;
! 79: int32_t mode;
! 80: u_int encoding;
! 81: u_int validbits;
! 82: u_int precision;
! 83: u_int channels;
! 84: u_int channel_mask;
! 85: #define AUFMT_UNKNOWN_POSITION 0U
! 86: #define AUFMT_FRONT_LEFT 0x00001U /* USB audio compatible */
! 87: #define AUFMT_FRONT_RIGHT 0x00002U /* USB audio compatible */
! 88: #define AUFMT_FRONT_CENTER 0x00004U /* USB audio compatible */
! 89: #define AUFMT_LOW_FREQUENCY 0x00008U /* USB audio compatible */
! 90: #define AUFMT_BACK_LEFT 0x00010U /* USB audio compatible */
! 91: #define AUFMT_BACK_RIGHT 0x00020U /* USB audio compatible */
! 92: #define AUFMT_FRONT_LEFT_OF_CENTER 0x00040U /* USB audio compatible */
! 93: #define AUFMT_FRONT_RIGHT_OF_CENTER 0x00080U /* USB audio compatible */
! 94: #define AUFMT_BACK_CENTER 0x00100U /* USB audio compatible */
! 95: #define AUFMT_SIDE_LEFT 0x00200U /* USB audio compatible */
! 96: #define AUFMT_SIDE_RIGHT 0x00400U /* USB audio compatible */
! 97: #define AUFMT_TOP_CENTER 0x00800U /* USB audio compatible */
! 98: #define AUFMT_TOP_FRONT_LEFT 0x01000U
! 99: #define AUFMT_TOP_FRONT_CENTER 0x02000U
! 100: #define AUFMT_TOP_FRONT_RIGHT 0x04000U
! 101: #define AUFMT_TOP_BACK_LEFT 0x08000U
! 102: #define AUFMT_TOP_BACK_CENTER 0x10000U
! 103: #define AUFMT_TOP_BACK_RIGHT 0x20000U
! 104:
! 105: #define AUFMT_MONAURAL AUFMT_FRONT_CENTER
! 106: #define AUFMT_STEREO (AUFMT_FRONT_LEFT | AUFMT_FRONT_RIGHT)
! 107: #define AUFMT_SURROUND4 (AUFMT_STEREO | AUFMT_BACK_LEFT \
! 108: | AUFMT_BACK_RIGHT)
! 109: #define AUFMT_DOLBY_5_1 (AUFMT_SURROUND4 | AUFMT_FRONT_CENTER \
! 110: | AUFMT_LOW_FREQUENCY)
! 111:
! 112: /**
! 113: * 0: frequency[0] is lower limit, and frequency[1] is higher limit.
! 114: * 1-16: frequency[0] to frequency[frequency_type-1] are valid.
! 115: */
! 116: u_int frequency_type;
! 117:
! 118: #define AUFMT_MAX_FREQUENCIES 16
! 119: /**
! 120: * sampling rates
! 121: */
! 122: u_int frequency[AUFMT_MAX_FREQUENCIES];
! 123: };
! 124:
! 125: #define AUFMT_INVALIDATE(fmt) (fmt)->mode |= 0x80000000
! 126: #define AUFMT_VALIDATE(fmt) (fmt)->mode &= 0x7fffffff
! 127: #define AUFMT_IS_VALID(fmt) (((fmt)->mode & 0x80000000) == 0)
! 128:
! 129: /* ----------------------------------------------------------------
! 130: * ICH6/ICH7 constant values
! 131: * ---------------------------------------------------------------- */
! 132:
! 133: /* PCI registers */
! 134: #define ICH_PCI_HDBARL 0x10
! 135: #define ICH_PCI_HDBARU 0x14
! 136: #define ICH_PCI_HDCTL 0x40
! 137: #define ICH_PCI_HDCTL_CLKDETCLR 0x08
! 138: #define ICH_PCI_HDCTL_CLKDETEN 0x04
! 139: #define ICH_PCI_HDCTL_CLKDETINV 0x02
! 140: #define ICH_PCI_HDCTL_SIGNALMODE 0x01
! 141:
! 142: /* internal types */
! 143:
! 144: typedef struct {
! 145: bus_dmamap_t map;
! 146: caddr_t addr; /* kernel virtual address */
! 147: bus_dma_segment_t segments[1];
! 148: size_t size;
! 149: } azalia_dma_t;
! 150: #define AZALIA_DMA_DMAADDR(p) ((p)->map->dm_segs[0].ds_addr)
! 151:
! 152: typedef struct {
! 153: struct azalia_t *az;
! 154: int regbase;
! 155: int number;
! 156: int dir; /* AUMODE_PLAY or AUMODE_RECORD */
! 157: uint32_t intr_bit;
! 158: azalia_dma_t bdlist;
! 159: azalia_dma_t buffer;
! 160: void (*intr)(void*);
! 161: void *intr_arg;
! 162: } stream_t;
! 163: #define STR_READ_1(s, r) \
! 164: bus_space_read_1((s)->az->iot, (s)->az->ioh, (s)->regbase + HDA_SD_##r)
! 165: #define STR_READ_2(s, r) \
! 166: bus_space_read_2((s)->az->iot, (s)->az->ioh, (s)->regbase + HDA_SD_##r)
! 167: #define STR_READ_4(s, r) \
! 168: bus_space_read_4((s)->az->iot, (s)->az->ioh, (s)->regbase + HDA_SD_##r)
! 169: #define STR_WRITE_1(s, r, v) \
! 170: bus_space_write_1((s)->az->iot, (s)->az->ioh, (s)->regbase + HDA_SD_##r, v)
! 171: #define STR_WRITE_2(s, r, v) \
! 172: bus_space_write_2((s)->az->iot, (s)->az->ioh, (s)->regbase + HDA_SD_##r, v)
! 173: #define STR_WRITE_4(s, r, v) \
! 174: bus_space_write_4((s)->az->iot, (s)->az->ioh, (s)->regbase + HDA_SD_##r, v)
! 175:
! 176: typedef struct azalia_t {
! 177: struct device dev;
! 178: struct device *audiodev;
! 179:
! 180: pci_chipset_tag_t pc;
! 181: void *ih;
! 182: bus_space_tag_t iot;
! 183: bus_space_handle_t ioh;
! 184: bus_size_t map_size;
! 185: bus_dma_tag_t dmat;
! 186: pcireg_t pciid;
! 187: uint32_t subid;
! 188:
! 189: codec_t codecs[15];
! 190: int ncodecs; /* number of codecs */
! 191: int codecno; /* index of the using codec */
! 192:
! 193: azalia_dma_t corb_dma;
! 194: int corb_size;
! 195: azalia_dma_t rirb_dma;
! 196: int rirb_size;
! 197: int rirb_rp;
! 198: #define UNSOLQ_SIZE 256
! 199: rirb_entry_t *unsolq;
! 200: int unsolq_wp;
! 201: int unsolq_rp;
! 202: boolean_t unsolq_kick;
! 203:
! 204: boolean_t ok64;
! 205: int nistreams, nostreams, nbstreams;
! 206: stream_t pstream;
! 207: stream_t rstream;
! 208: } azalia_t;
! 209: #define XNAME(sc) ((sc)->dev.dv_xname)
! 210: #define AZ_READ_1(z, r) bus_space_read_1((z)->iot, (z)->ioh, HDA_##r)
! 211: #define AZ_READ_2(z, r) bus_space_read_2((z)->iot, (z)->ioh, HDA_##r)
! 212: #define AZ_READ_4(z, r) bus_space_read_4((z)->iot, (z)->ioh, HDA_##r)
! 213: #define AZ_WRITE_1(z, r, v) bus_space_write_1((z)->iot, (z)->ioh, HDA_##r, v)
! 214: #define AZ_WRITE_2(z, r, v) bus_space_write_2((z)->iot, (z)->ioh, HDA_##r, v)
! 215: #define AZ_WRITE_4(z, r, v) bus_space_write_4((z)->iot, (z)->ioh, HDA_##r, v)
! 216:
! 217:
! 218: /* prototypes */
! 219: int azalia_pci_match(struct device *, void *, void *);
! 220: void azalia_pci_attach(struct device *, struct device *, void *);
! 221: int azalia_pci_activate(struct device *, enum devact);
! 222: int azalia_pci_detach(struct device *, int);
! 223: int azalia_intr(void *);
! 224: int azalia_attach(azalia_t *);
! 225: void azalia_attach_intr(struct device *);
! 226: int azalia_init_corb(azalia_t *);
! 227: int azalia_delete_corb(azalia_t *);
! 228: int azalia_init_rirb(azalia_t *);
! 229: int azalia_delete_rirb(azalia_t *);
! 230: int azalia_set_command(azalia_t *, nid_t, int, uint32_t,
! 231: uint32_t);
! 232: int azalia_get_response(azalia_t *, uint32_t *);
! 233: void azalia_rirb_kick_unsol_events(azalia_t *);
! 234: void azalia_rirb_intr(azalia_t *);
! 235: int azalia_alloc_dmamem(azalia_t *, size_t, size_t, azalia_dma_t *);
! 236: int azalia_free_dmamem(const azalia_t *, azalia_dma_t*);
! 237:
! 238: int azalia_codec_init(codec_t *);
! 239: int azalia_codec_delete(codec_t *);
! 240: void azalia_codec_add_bits(codec_t *, int, uint32_t, int);
! 241: void azalia_codec_add_format(codec_t *, int, int, int, uint32_t,
! 242: int32_t);
! 243: int azalia_codec_comresp(const codec_t *, nid_t, uint32_t,
! 244: uint32_t, uint32_t *);
! 245: int azalia_codec_connect_stream(codec_t *, int, uint16_t, int);
! 246:
! 247: int azalia_widget_init(widget_t *, const codec_t *, int);
! 248: int azalia_widget_init_audio(widget_t *, const codec_t *);
! 249: int azalia_widget_print_audio(const widget_t *, const char *);
! 250: int azalia_widget_init_pin(widget_t *, const codec_t *);
! 251: int azalia_widget_print_pin(const widget_t *);
! 252: int azalia_widget_init_connection(widget_t *, const codec_t *);
! 253:
! 254: int azalia_stream_init(stream_t *, azalia_t *, int, int, int);
! 255: int azalia_stream_delete(stream_t *, azalia_t *);
! 256: int azalia_stream_reset(stream_t *);
! 257: int azalia_stream_start(stream_t *, void *, void *, int,
! 258: void (*)(void *), void *, uint16_t);
! 259: int azalia_stream_halt(stream_t *);
! 260: int azalia_stream_intr(stream_t *, uint32_t);
! 261:
! 262: int azalia_open(void *, int);
! 263: void azalia_close(void *);
! 264: int azalia_query_encoding(void *, audio_encoding_t *);
! 265: int azalia_set_params(void *, int, int, audio_params_t *,
! 266: audio_params_t *);
! 267: int azalia_round_blocksize(void *, int);
! 268: int azalia_halt_output(void *);
! 269: int azalia_halt_input(void *);
! 270: int azalia_getdev(void *, struct audio_device *);
! 271: int azalia_set_port(void *, mixer_ctrl_t *);
! 272: int azalia_get_port(void *, mixer_ctrl_t *);
! 273: int azalia_query_devinfo(void *, mixer_devinfo_t *);
! 274: void *azalia_allocm(void *, int, size_t, int, int);
! 275: void azalia_freem(void *, void *, int);
! 276: size_t azalia_round_buffersize(void *, int, size_t);
! 277: int azalia_get_props(void *);
! 278: int azalia_trigger_output(void *, void *, void *, int,
! 279: void (*)(void *), void *, audio_params_t *);
! 280: int azalia_trigger_input(void *, void *, void *, int,
! 281: void (*)(void *), void *, audio_params_t *);
! 282:
! 283: int azalia_params2fmt(const audio_params_t *, uint16_t *);
! 284: int azalia_create_encodings(struct audio_format *, int,
! 285: struct audio_encoding_set **);
! 286:
! 287: /* variables */
! 288: struct cfattach azalia_ca = {
! 289: sizeof(azalia_t), azalia_pci_match, azalia_pci_attach,
! 290: azalia_pci_detach, azalia_pci_activate
! 291: };
! 292:
! 293: struct cfdriver azalia_cd = {
! 294: NULL, "azalia", DV_DULL
! 295: };
! 296:
! 297: struct audio_hw_if azalia_hw_if = {
! 298: azalia_open,
! 299: azalia_close,
! 300: NULL, /* drain */
! 301: azalia_query_encoding,
! 302: azalia_set_params,
! 303: azalia_round_blocksize,
! 304: NULL, /* commit_settings */
! 305: NULL, /* init_output */
! 306: NULL, /* init_input */
! 307: NULL, /* start_output */
! 308: NULL, /* start_input */
! 309: azalia_halt_output,
! 310: azalia_halt_input,
! 311: NULL, /* speaker_ctl */
! 312: azalia_getdev,
! 313: NULL, /* setfd */
! 314: azalia_set_port,
! 315: azalia_get_port,
! 316: azalia_query_devinfo,
! 317: azalia_allocm,
! 318: azalia_freem,
! 319: azalia_round_buffersize,
! 320: NULL, /* mappage */
! 321: azalia_get_props,
! 322: azalia_trigger_output,
! 323: azalia_trigger_input,
! 324: };
! 325:
! 326: static const char *pin_colors[16] = {
! 327: "unknown", "black", "gray", "blue",
! 328: "green", "red", "orange", "yellow",
! 329: "purple", "pink", "col0a", "col0b",
! 330: "col0c", "col0d", "white", "other"};
! 331: #ifdef AZALIA_DEBUG
! 332: static const char *pin_devices[16] = {
! 333: "line-out", AudioNspeaker, AudioNheadphone, AudioNcd,
! 334: "SPDIF-out", "digital-out", "modem-line", "modem-handset",
! 335: "line-in", AudioNaux, AudioNmicrophone, "telephony",
! 336: "SPDIF-in", "digital-in", "dev0e", "other"};
! 337: #endif
! 338:
! 339: /* ================================================================
! 340: * PCI functions
! 341: * ================================================================ */
! 342:
! 343: #define PCI_ID_CODE0(v, p) PCI_ID_CODE(PCI_VENDOR_##v, PCI_PRODUCT_##v##_##p)
! 344: #define PCIID_NVIDIA_MCP51 PCI_ID_CODE0(NVIDIA, MCP51_HDA)
! 345: #define PCIID_NVIDIA_MCP55 PCI_ID_CODE0(NVIDIA, MCP55_HDA)
! 346: #define PCIID_ALI_M5461 PCI_ID_CODE0(ALI, M5461)
! 347: #define PCIID_VIATECH_HDA PCI_ID_CODE0(VIATECH, HDA)
! 348:
! 349: int
! 350: azalia_pci_match(struct device *parent, void *match, void *aux)
! 351: {
! 352: struct pci_attach_args *pa;
! 353:
! 354: pa = aux;
! 355: if (PCI_CLASS(pa->pa_class) == PCI_CLASS_MULTIMEDIA
! 356: && PCI_SUBCLASS(pa->pa_class) == PCI_SUBCLASS_MULTIMEDIA_HDAUDIO)
! 357: return 1;
! 358: return 0;
! 359: }
! 360:
! 361: void
! 362: azalia_pci_attach(struct device *parent, struct device *self, void *aux)
! 363: {
! 364: azalia_t *sc;
! 365: struct pci_attach_args *pa;
! 366: pcireg_t v;
! 367: pci_intr_handle_t ih;
! 368: const char *intrrupt_str;
! 369:
! 370: sc = (azalia_t*)self;
! 371: pa = aux;
! 372:
! 373: sc->dmat = pa->pa_dmat;
! 374:
! 375: v = pci_conf_read(pa->pa_pc, pa->pa_tag, ICH_PCI_HDBARL);
! 376: v &= PCI_MAPREG_TYPE_MASK | PCI_MAPREG_MEM_TYPE_MASK;
! 377: if (pci_mapreg_map(pa, ICH_PCI_HDBARL, v, 0,
! 378: &sc->iot, &sc->ioh, NULL, &sc->map_size, 0)) {
! 379: printf(": can't map device i/o space\n");
! 380: return;
! 381: }
! 382:
! 383: /* enable back-to-back */
! 384: v = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG);
! 385: pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG,
! 386: v | PCI_COMMAND_BACKTOBACK_ENABLE);
! 387:
! 388: v = pci_conf_read(pa->pa_pc, pa->pa_tag, 0x44);
! 389: pci_conf_write(pa->pa_pc, pa->pa_tag, 0x44, v & (~0x7));
! 390:
! 391: /* interrupt */
! 392: if (pci_intr_map(pa, &ih)) {
! 393: printf(": can't map interrupt\n");
! 394: return;
! 395: }
! 396: sc->pc = pa->pa_pc;
! 397: intrrupt_str = pci_intr_string(pa->pa_pc, ih);
! 398: sc->ih = pci_intr_establish(pa->pa_pc, ih, IPL_AUDIO, azalia_intr,
! 399: sc, sc->dev.dv_xname);
! 400: if (sc->ih == NULL) {
! 401: printf(": can't establish interrupt");
! 402: if (intrrupt_str != NULL)
! 403: printf(" at %s", intrrupt_str);
! 404: printf("\n");
! 405: return;
! 406: }
! 407: printf(": %s\n", intrrupt_str);
! 408:
! 409: sc->pciid = pa->pa_id;
! 410:
! 411: if (azalia_attach(sc)) {
! 412: printf("%s: initialization failure\n", XNAME(sc));
! 413: azalia_pci_detach(self, 0);
! 414: return;
! 415: }
! 416: sc->subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG);
! 417:
! 418: azalia_attach_intr(self);
! 419: }
! 420:
! 421: int
! 422: azalia_pci_activate(struct device *self, enum devact act)
! 423: {
! 424: azalia_t *sc;
! 425: int ret;
! 426:
! 427: sc = (azalia_t*)self;
! 428: ret = 0;
! 429: switch (act) {
! 430: case DVACT_ACTIVATE:
! 431: return ret;
! 432: case DVACT_DEACTIVATE:
! 433: if (sc->audiodev != NULL)
! 434: ret = config_deactivate(sc->audiodev);
! 435: return ret;
! 436: }
! 437: return EOPNOTSUPP;
! 438: }
! 439:
! 440: int
! 441: azalia_pci_detach(struct device *self, int flags)
! 442: {
! 443: azalia_t *az;
! 444: int i;
! 445:
! 446: DPRINTF(("%s\n", __func__));
! 447: az = (azalia_t*)self;
! 448: if (az->audiodev != NULL) {
! 449: config_detach(az->audiodev, flags);
! 450: az->audiodev = NULL;
! 451: }
! 452:
! 453: DPRINTF(("%s: delete streams\n", __func__));
! 454: azalia_stream_delete(&az->rstream, az);
! 455: azalia_stream_delete(&az->pstream, az);
! 456:
! 457: DPRINTF(("%s: delete codecs\n", __func__));
! 458: for (i = 0; i < az->ncodecs; i++) {
! 459: azalia_codec_delete(&az->codecs[i]);
! 460: }
! 461: az->ncodecs = 0;
! 462:
! 463: DPRINTF(("%s: delete CORB and RIRB\n", __func__));
! 464: azalia_delete_corb(az);
! 465: azalia_delete_rirb(az);
! 466:
! 467: DPRINTF(("%s: delete PCI resources\n", __func__));
! 468: if (az->ih != NULL) {
! 469: pci_intr_disestablish(az->pc, az->ih);
! 470: az->ih = NULL;
! 471: }
! 472: if (az->map_size != 0) {
! 473: bus_space_unmap(az->iot, az->ioh, az->map_size);
! 474: az->map_size = 0;
! 475: }
! 476: return 0;
! 477: }
! 478:
! 479: int
! 480: azalia_intr(void *v)
! 481: {
! 482: azalia_t *az = v;
! 483: int ret = 0;
! 484: uint32_t intsts;
! 485: uint8_t rirbsts, rirbctl;
! 486:
! 487: intsts = AZ_READ_4(az, INTSTS);
! 488: if (intsts == 0)
! 489: return (0);
! 490:
! 491: AZ_WRITE_4(az, INTSTS, intsts);
! 492:
! 493: ret += azalia_stream_intr(&az->pstream, intsts);
! 494: ret += azalia_stream_intr(&az->rstream, intsts);
! 495:
! 496: rirbctl = AZ_READ_1(az, RIRBCTL);
! 497: rirbsts = AZ_READ_1(az, RIRBSTS);
! 498:
! 499: if (intsts & HDA_INTCTL_CIE) {
! 500: if (rirbctl & HDA_RIRBCTL_RINTCTL) {
! 501: if (rirbsts & HDA_RIRBSTS_RINTFL)
! 502: azalia_rirb_intr(az);
! 503: }
! 504: }
! 505:
! 506: return (1);
! 507: }
! 508:
! 509: /* ================================================================
! 510: * HDA controller functions
! 511: * ================================================================ */
! 512:
! 513: int
! 514: azalia_attach(azalia_t *az)
! 515: {
! 516: int i, n;
! 517: uint32_t gctl;
! 518: uint16_t gcap;
! 519: uint16_t statests;
! 520:
! 521: printf("%s: host: High Definition Audio rev. %d.%d\n",
! 522: XNAME(az), AZ_READ_1(az, VMAJ), AZ_READ_1(az, VMIN));
! 523: gcap = AZ_READ_2(az, GCAP);
! 524: az->nistreams = HDA_GCAP_ISS(gcap);
! 525: az->nostreams = HDA_GCAP_OSS(gcap);
! 526: az->nbstreams = HDA_GCAP_BSS(gcap);
! 527: az->ok64 = (gcap & HDA_GCAP_64OK) != 0;
! 528: DPRINTF(("%s: host: %d output, %d input, and %d bidi streams\n",
! 529: XNAME(az), az->nostreams, az->nistreams, az->nbstreams));
! 530:
! 531: /* 4.2.2 Starting the High Definition Audio Controller */
! 532: DPRINTF(("%s: resetting\n", __func__));
! 533: gctl = AZ_READ_4(az, GCTL);
! 534: AZ_WRITE_4(az, GCTL, gctl & ~HDA_GCTL_CRST);
! 535: for (i = 5000; i >= 0; i--) {
! 536: DELAY(10);
! 537: if ((AZ_READ_4(az, GCTL) & HDA_GCTL_CRST) == 0)
! 538: break;
! 539: }
! 540: DPRINTF(("%s: reset counter = %d\n", __func__, i));
! 541: if (i <= 0) {
! 542: printf("%s: reset failure\n", XNAME(az));
! 543: return ETIMEDOUT;
! 544: }
! 545: DELAY(1000);
! 546: gctl = AZ_READ_4(az, GCTL);
! 547: AZ_WRITE_4(az, GCTL, gctl | HDA_GCTL_CRST);
! 548: for (i = 5000; i >= 0; i--) {
! 549: DELAY(10);
! 550: if (AZ_READ_4(az, GCTL) & HDA_GCTL_CRST)
! 551: break;
! 552: }
! 553: DPRINTF(("%s: reset counter = %d\n", __func__, i));
! 554: if (i <= 0) {
! 555: printf("%s: reset-exit failure\n", XNAME(az));
! 556: return ETIMEDOUT;
! 557: }
! 558:
! 559: /* enable unsolicited response */
! 560: gctl = AZ_READ_4(az, GCTL);
! 561: AZ_WRITE_4(az, GCTL, gctl | HDA_GCTL_UNSOL);
! 562:
! 563: /* 4.3 Codec discovery */
! 564: DELAY(1000);
! 565: statests = AZ_READ_2(az, STATESTS);
! 566: for (i = 0, n = 0; i < 15; i++) {
! 567: if ((statests >> i) & 1) {
! 568: DPRINTF(("%s: found a codec at #%d\n", XNAME(az), i));
! 569: az->codecs[n].address = i;
! 570: az->codecs[n++].az = az;
! 571: }
! 572: }
! 573: az->ncodecs = n;
! 574: if (az->ncodecs < 1) {
! 575: printf("%s: No HD-Audio codecs\n", XNAME(az));
! 576: return -1;
! 577: }
! 578: return 0;
! 579: }
! 580:
! 581: void
! 582: azalia_attach_intr(struct device *self)
! 583: {
! 584: azalia_t *az;
! 585: int err, i, c;
! 586:
! 587: az = (azalia_t*)self;
! 588:
! 589: AZ_WRITE_2(az, STATESTS, HDA_STATESTS_SDIWAKE);
! 590: AZ_WRITE_1(az, RIRBSTS, HDA_RIRBSTS_RINTFL | HDA_RIRBSTS_RIRBOIS);
! 591: AZ_WRITE_4(az, INTSTS, HDA_INTSTS_CIS | HDA_INTSTS_GIS);
! 592: AZ_WRITE_4(az, DPLBASE, 0);
! 593: AZ_WRITE_4(az, DPUBASE, 0);
! 594:
! 595: /* 4.4.1 Command Outbound Ring Buffer */
! 596: if (azalia_init_corb(az))
! 597: goto err_exit;
! 598: /* 4.4.2 Response Inbound Ring Buffer */
! 599: if (azalia_init_rirb(az))
! 600: goto err_exit;
! 601:
! 602: AZ_WRITE_4(az, INTCTL,
! 603: AZ_READ_4(az, INTCTL) | HDA_INTCTL_CIE | HDA_INTCTL_GIE);
! 604:
! 605: c = -1;
! 606: for (i = 0; i < az->ncodecs; i++) {
! 607: err = azalia_codec_init(&az->codecs[i]);
! 608: if (!err && c < 0)
! 609: c = i;
! 610: }
! 611: if (c < 0)
! 612: goto err_exit;
! 613: /* Use the first audio codec */
! 614: az->codecno = c;
! 615: DPRINTF(("%s: using the #%d codec\n", XNAME(az), az->codecno));
! 616:
! 617: if (azalia_stream_init(&az->pstream, az, az->nistreams + 0,
! 618: 1, AUMODE_PLAY))
! 619: goto err_exit;
! 620: if (azalia_stream_init(&az->rstream, az, 0, 2, AUMODE_RECORD))
! 621: goto err_exit;
! 622:
! 623: az->audiodev = audio_attach_mi(&azalia_hw_if, az, &az->dev);
! 624: return;
! 625: err_exit:
! 626: azalia_pci_detach(self, 0);
! 627: return;
! 628: }
! 629:
! 630: int
! 631: azalia_init_corb(azalia_t *az)
! 632: {
! 633: int entries, err, i;
! 634: uint16_t corbrp, corbwp;
! 635: uint8_t corbsize, cap, corbctl;
! 636:
! 637: /* stop the CORB */
! 638: corbctl = AZ_READ_1(az, CORBCTL);
! 639: if (corbctl & HDA_CORBCTL_CORBRUN) { /* running? */
! 640: AZ_WRITE_1(az, CORBCTL, corbctl & ~HDA_CORBCTL_CORBRUN);
! 641: for (i = 5000; i >= 0; i--) {
! 642: DELAY(10);
! 643: corbctl = AZ_READ_1(az, CORBCTL);
! 644: if ((corbctl & HDA_CORBCTL_CORBRUN) == 0)
! 645: break;
! 646: }
! 647: if (i <= 0) {
! 648: printf("%s: CORB is running\n", XNAME(az));
! 649: return EBUSY;
! 650: }
! 651: }
! 652:
! 653: /* determine CORB size */
! 654: corbsize = AZ_READ_1(az, CORBSIZE);
! 655: cap = corbsize & HDA_CORBSIZE_CORBSZCAP_MASK;
! 656: corbsize &= ~HDA_CORBSIZE_CORBSIZE_MASK;
! 657: if (cap & HDA_CORBSIZE_CORBSZCAP_256) {
! 658: entries = 256;
! 659: corbsize |= HDA_CORBSIZE_CORBSIZE_256;
! 660: } else if (cap & HDA_CORBSIZE_CORBSZCAP_16) {
! 661: entries = 16;
! 662: corbsize |= HDA_CORBSIZE_CORBSIZE_16;
! 663: } else if (cap & HDA_CORBSIZE_CORBSZCAP_2) {
! 664: entries = 2;
! 665: corbsize |= HDA_CORBSIZE_CORBSIZE_2;
! 666: } else {
! 667: printf("%s: Invalid CORBSZCAP: 0x%2x\n", XNAME(az), cap);
! 668: return -1;
! 669: }
! 670:
! 671: err = azalia_alloc_dmamem(az, entries * sizeof(corb_entry_t),
! 672: 128, &az->corb_dma);
! 673: if (err) {
! 674: printf("%s: can't allocate CORB buffer\n", XNAME(az));
! 675: return err;
! 676: }
! 677: AZ_WRITE_4(az, CORBLBASE, (uint32_t)AZALIA_DMA_DMAADDR(&az->corb_dma));
! 678: AZ_WRITE_4(az, CORBUBASE, PTR_UPPER32(AZALIA_DMA_DMAADDR(&az->corb_dma)));
! 679: AZ_WRITE_1(az, CORBSIZE, corbsize);
! 680: az->corb_size = entries;
! 681:
! 682: DPRINTF(("%s: CORB allocation succeeded.\n", __func__));
! 683:
! 684: /* reset CORBRP */
! 685: corbrp = AZ_READ_2(az, CORBRP);
! 686: AZ_WRITE_2(az, CORBRP, corbrp | HDA_CORBRP_CORBRPRST);
! 687: AZ_WRITE_2(az, CORBRP, corbrp & ~HDA_CORBRP_CORBRPRST);
! 688: for (i = 5000; i >= 0; i--) {
! 689: DELAY(10);
! 690: corbrp = AZ_READ_2(az, CORBRP);
! 691: if ((corbrp & HDA_CORBRP_CORBRPRST) == 0)
! 692: break;
! 693: }
! 694: if (i <= 0) {
! 695: printf("%s: CORBRP reset failure\n", XNAME(az));
! 696: return -1;
! 697: }
! 698: DPRINTF(("%s: CORBWP=%d; size=%d\n", __func__,
! 699: AZ_READ_2(az, CORBRP) & HDA_CORBRP_CORBRP, az->corb_size));
! 700:
! 701: /* clear CORBWP */
! 702: corbwp = AZ_READ_2(az, CORBWP);
! 703: AZ_WRITE_2(az, CORBWP, corbwp & ~HDA_CORBWP_CORBWP);
! 704:
! 705: /* Run! */
! 706: corbctl = AZ_READ_1(az, CORBCTL);
! 707: AZ_WRITE_1(az, CORBCTL, corbctl | HDA_CORBCTL_CORBRUN);
! 708: return 0;
! 709: }
! 710:
! 711: int
! 712: azalia_delete_corb(azalia_t *az)
! 713: {
! 714: int i;
! 715: uint8_t corbctl;
! 716:
! 717: if (az->corb_dma.addr == NULL)
! 718: return 0;
! 719: /* stop the CORB */
! 720: corbctl = AZ_READ_1(az, CORBCTL);
! 721: AZ_WRITE_1(az, CORBCTL, corbctl & ~HDA_CORBCTL_CORBRUN);
! 722: for (i = 5000; i >= 0; i--) {
! 723: DELAY(10);
! 724: corbctl = AZ_READ_1(az, CORBCTL);
! 725: if ((corbctl & HDA_CORBCTL_CORBRUN) == 0)
! 726: break;
! 727: }
! 728: azalia_free_dmamem(az, &az->corb_dma);
! 729: return 0;
! 730: }
! 731:
! 732: int
! 733: azalia_init_rirb(azalia_t *az)
! 734: {
! 735: int entries, err, i;
! 736: uint16_t rirbwp;
! 737: uint8_t rirbsize, cap, rirbctl;
! 738:
! 739: /* stop the RIRB */
! 740: rirbctl = AZ_READ_1(az, RIRBCTL);
! 741: if (rirbctl & HDA_RIRBCTL_RIRBDMAEN) { /* running? */
! 742: AZ_WRITE_1(az, RIRBCTL, rirbctl & ~HDA_RIRBCTL_RIRBDMAEN);
! 743: for (i = 5000; i >= 0; i--) {
! 744: DELAY(10);
! 745: rirbctl = AZ_READ_1(az, RIRBCTL);
! 746: if ((rirbctl & HDA_RIRBCTL_RIRBDMAEN) == 0)
! 747: break;
! 748: }
! 749: if (i <= 0) {
! 750: printf("%s: RIRB is running\n", XNAME(az));
! 751: return EBUSY;
! 752: }
! 753: }
! 754:
! 755: /* determine RIRB size */
! 756: rirbsize = AZ_READ_1(az, RIRBSIZE);
! 757: cap = rirbsize & HDA_RIRBSIZE_RIRBSZCAP_MASK;
! 758: rirbsize &= ~HDA_RIRBSIZE_RIRBSIZE_MASK;
! 759: if (cap & HDA_RIRBSIZE_RIRBSZCAP_256) {
! 760: entries = 256;
! 761: rirbsize |= HDA_RIRBSIZE_RIRBSIZE_256;
! 762: } else if (cap & HDA_RIRBSIZE_RIRBSZCAP_16) {
! 763: entries = 16;
! 764: rirbsize |= HDA_RIRBSIZE_RIRBSIZE_16;
! 765: } else if (cap & HDA_RIRBSIZE_RIRBSZCAP_2) {
! 766: entries = 2;
! 767: rirbsize |= HDA_RIRBSIZE_RIRBSIZE_2;
! 768: } else {
! 769: printf("%s: Invalid RIRBSZCAP: 0x%2x\n", XNAME(az), cap);
! 770: return -1;
! 771: }
! 772:
! 773: err = azalia_alloc_dmamem(az, entries * sizeof(rirb_entry_t),
! 774: 128, &az->rirb_dma);
! 775: if (err) {
! 776: printf("%s: can't allocate RIRB buffer\n", XNAME(az));
! 777: return err;
! 778: }
! 779: AZ_WRITE_4(az, RIRBLBASE, (uint32_t)AZALIA_DMA_DMAADDR(&az->rirb_dma));
! 780: AZ_WRITE_4(az, RIRBUBASE, PTR_UPPER32(AZALIA_DMA_DMAADDR(&az->rirb_dma)));
! 781: AZ_WRITE_1(az, RIRBSIZE, rirbsize);
! 782: az->rirb_size = entries;
! 783:
! 784: DPRINTF(("%s: RIRB allocation succeeded.\n", __func__));
! 785:
! 786: /* setup the unsolicited response queue */
! 787: az->unsolq_rp = 0;
! 788: az->unsolq_wp = 0;
! 789: az->unsolq_kick = FALSE;
! 790: az->unsolq = malloc(sizeof(rirb_entry_t) * UNSOLQ_SIZE,
! 791: M_DEVBUF, M_NOWAIT);
! 792: if (az->unsolq == NULL) {
! 793: DPRINTF(("%s: can't allocate unsolicited response queue.\n",
! 794: XNAME(az)));
! 795: azalia_free_dmamem(az, &az->rirb_dma);
! 796: return ENOMEM;
! 797: }
! 798: bzero(az->unsolq, sizeof(rirb_entry_t) * UNSOLQ_SIZE);
! 799:
! 800: /* reset the write pointer */
! 801: rirbwp = AZ_READ_2(az, RIRBWP);
! 802: AZ_WRITE_2(az, RIRBWP, rirbwp | HDA_RIRBWP_RIRBWPRST);
! 803:
! 804: /* clear the read pointer */
! 805: az->rirb_rp = AZ_READ_2(az, RIRBWP) & HDA_RIRBWP_RIRBWP;
! 806: DPRINTF(("%s: RIRBRP=%d, size=%d\n", __func__, az->rirb_rp, az->rirb_size));
! 807:
! 808: AZ_WRITE_2(az, RINTCNT, 1);
! 809:
! 810: /* Run! */
! 811: rirbctl = AZ_READ_1(az, RIRBCTL);
! 812: AZ_WRITE_1(az, RIRBCTL, rirbctl |
! 813: HDA_RIRBCTL_RIRBDMAEN | HDA_RIRBCTL_RINTCTL);
! 814:
! 815: return (0);
! 816: }
! 817:
! 818: int
! 819: azalia_delete_rirb(azalia_t *az)
! 820: {
! 821: int i;
! 822: uint8_t rirbctl;
! 823:
! 824: if (az->unsolq != NULL) {
! 825: free(az->unsolq, M_DEVBUF);
! 826: az->unsolq = NULL;
! 827: }
! 828: if (az->rirb_dma.addr == NULL)
! 829: return 0;
! 830: /* stop the RIRB */
! 831: rirbctl = AZ_READ_1(az, RIRBCTL);
! 832: AZ_WRITE_1(az, RIRBCTL, rirbctl & ~HDA_RIRBCTL_RIRBDMAEN);
! 833: for (i = 5000; i >= 0; i--) {
! 834: DELAY(10);
! 835: rirbctl = AZ_READ_1(az, RIRBCTL);
! 836: if ((rirbctl & HDA_RIRBCTL_RIRBDMAEN) == 0)
! 837: break;
! 838: }
! 839: azalia_free_dmamem(az, &az->rirb_dma);
! 840: return 0;
! 841: }
! 842:
! 843: int
! 844: azalia_set_command(azalia_t *az, int caddr, nid_t nid, uint32_t control,
! 845: uint32_t param)
! 846: {
! 847: corb_entry_t *corb;
! 848: int wp;
! 849: uint32_t verb;
! 850: uint16_t corbwp;
! 851: uint8_t rirbctl;
! 852:
! 853: #ifdef DIAGNOSTIC
! 854: if ((AZ_READ_1(az, CORBCTL) & HDA_CORBCTL_CORBRUN) == 0) {
! 855: printf("%s: CORB is not running.\n", XNAME(az));
! 856: return -1;
! 857: }
! 858: #endif
! 859: verb = (caddr << 28) | (nid << 20) | (control << 8) | param;
! 860: corbwp = AZ_READ_2(az, CORBWP);
! 861: wp = corbwp & HDA_CORBWP_CORBWP;
! 862: corb = (corb_entry_t*)az->corb_dma.addr;
! 863: if (++wp >= az->corb_size)
! 864: wp = 0;
! 865: corb[wp] = verb;
! 866:
! 867: /* disable RIRB interrupts */
! 868: rirbctl = AZ_READ_1(az, RIRBCTL);
! 869: if (rirbctl & HDA_RIRBCTL_RINTCTL) {
! 870: AZ_WRITE_1(az, RIRBCTL, rirbctl & ~HDA_RIRBCTL_RINTCTL);
! 871: azalia_rirb_intr(az);
! 872: }
! 873:
! 874: AZ_WRITE_2(az, CORBWP, (corbwp & ~HDA_CORBWP_CORBWP) | wp);
! 875: #if 0
! 876: DPRINTF(("%s: caddr=%d nid=%d control=0x%x param=0x%x verb=0x%8.8x wp=%d\n",
! 877: __func__, caddr, nid, control, param, verb, wp));
! 878: #endif
! 879: return 0;
! 880: }
! 881:
! 882: int
! 883: azalia_get_response(azalia_t *az, uint32_t *result)
! 884: {
! 885: const rirb_entry_t *rirb;
! 886: int i;
! 887: uint16_t wp;
! 888: uint8_t rirbctl;
! 889:
! 890: #ifdef DIAGNOSTIC
! 891: if ((AZ_READ_1(az, RIRBCTL) & HDA_RIRBCTL_RIRBDMAEN) == 0) {
! 892: printf("%s: RIRB is not running.\n", XNAME(az));
! 893: return -1;
! 894: }
! 895: #endif
! 896: for (i = 5000; i >= 0; i--) {
! 897: wp = AZ_READ_2(az, RIRBWP) & HDA_RIRBWP_RIRBWP;
! 898: if (az->rirb_rp != wp)
! 899: break;
! 900: DELAY(10);
! 901: }
! 902: if (i <= 0) {
! 903: printf("%s: RIRB time out\n", XNAME(az));
! 904: return ETIMEDOUT;
! 905: }
! 906: rirb = (rirb_entry_t*)az->rirb_dma.addr;
! 907: for (;;) {
! 908: if (++az->rirb_rp >= az->rirb_size)
! 909: az->rirb_rp = 0;
! 910: if (rirb[az->rirb_rp].resp_ex & RIRB_RESP_UNSOL) {
! 911: az->unsolq[az->unsolq_wp].resp = rirb[az->rirb_rp].resp;
! 912: az->unsolq[az->unsolq_wp++].resp_ex = rirb[az->rirb_rp].resp_ex;
! 913: az->unsolq_wp %= UNSOLQ_SIZE;
! 914: } else
! 915: break;
! 916: }
! 917: if (result != NULL)
! 918: *result = rirb[az->rirb_rp].resp;
! 919:
! 920: azalia_rirb_kick_unsol_events(az);
! 921: #if 0
! 922: for (i = 0; i < 16 /*az->rirb_size*/; i++) {
! 923: DPRINTF(("rirb[%d] 0x%8.8x:0x%8.8x ", i, rirb[i].resp, rirb[i].resp_ex));
! 924: if ((i % 2) == 1)
! 925: DPRINTF(("\n"));
! 926: }
! 927: #endif
! 928:
! 929: /* re-enable RIRB interrupts */
! 930: rirbctl = AZ_READ_1(az, RIRBCTL);
! 931: AZ_WRITE_1(az, RIRBCTL, rirbctl | HDA_RIRBCTL_RINTCTL);
! 932:
! 933: return 0;
! 934: }
! 935:
! 936: void
! 937: azalia_rirb_kick_unsol_events(azalia_t *az)
! 938: {
! 939: if (az->unsolq_kick)
! 940: return;
! 941: az->unsolq_kick = TRUE;
! 942: while (az->unsolq_rp != az->unsolq_wp) {
! 943: int i;
! 944: int tag;
! 945: codec_t *codec;
! 946: i = RIRB_RESP_CODEC(az->unsolq[az->unsolq_rp].resp_ex);
! 947: tag = RIRB_UNSOL_TAG(az->unsolq[az->unsolq_rp].resp);
! 948: codec = &az->codecs[i];
! 949: DPRINTF(("%s: codec#=%d tag=%d\n", __func__, i, tag));
! 950: az->unsolq_rp++;
! 951: az->unsolq_rp %= UNSOLQ_SIZE;
! 952: if (codec->unsol_event != NULL)
! 953: codec->unsol_event(codec, tag);
! 954: }
! 955: az->unsolq_kick = FALSE;
! 956: }
! 957:
! 958: void
! 959: azalia_rirb_intr(azalia_t *az)
! 960: {
! 961: const rirb_entry_t *rirb;
! 962: uint16_t wp, rp;
! 963: uint8_t rirbsts;
! 964:
! 965: rirbsts = AZ_READ_1(az, RIRBSTS);
! 966:
! 967: wp = AZ_READ_2(az, RIRBWP) & HDA_RIRBWP_RIRBWP;
! 968: if (rp == wp)
! 969: return; /* interrupted but no data in RIRB */
! 970: rirb = (rirb_entry_t*)az->rirb_dma.addr;
! 971: while (az->rirb_rp != wp) {
! 972: if (++az->rirb_rp >= az->rirb_size)
! 973: az->rirb_rp = 0;
! 974: if (rirb[az->rirb_rp].resp_ex & RIRB_RESP_UNSOL) {
! 975: az->unsolq[az->unsolq_wp].resp = rirb[az->rirb_rp].resp;
! 976: az->unsolq[az->unsolq_wp++].resp_ex = rirb[az->rirb_rp].resp_ex;
! 977: az->unsolq_wp %= UNSOLQ_SIZE;
! 978: } else {
! 979: break;
! 980: }
! 981: }
! 982:
! 983: azalia_rirb_kick_unsol_events(az);
! 984:
! 985: AZ_WRITE_1(az, RIRBSTS,
! 986: rirbsts | HDA_RIRBSTS_RIRBOIS | HDA_RIRBSTS_RINTFL);
! 987: }
! 988:
! 989: int
! 990: azalia_alloc_dmamem(azalia_t *az, size_t size, size_t align, azalia_dma_t *d)
! 991: {
! 992: int err;
! 993: int nsegs;
! 994:
! 995: d->size = size;
! 996: err = bus_dmamem_alloc(az->dmat, size, align, 0, d->segments, 1,
! 997: &nsegs, BUS_DMA_NOWAIT);
! 998: if (err)
! 999: return err;
! 1000: if (nsegs != 1)
! 1001: goto free;
! 1002: err = bus_dmamem_map(az->dmat, d->segments, 1, size,
! 1003: &d->addr, BUS_DMA_NOWAIT | BUS_DMA_COHERENT | BUS_DMA_NOCACHE);
! 1004: if (err)
! 1005: goto free;
! 1006: err = bus_dmamap_create(az->dmat, size, 1, size, 0,
! 1007: BUS_DMA_NOWAIT, &d->map);
! 1008: if (err)
! 1009: goto unmap;
! 1010: err = bus_dmamap_load(az->dmat, d->map, d->addr, size,
! 1011: NULL, BUS_DMA_NOWAIT);
! 1012: if (err)
! 1013: goto destroy;
! 1014:
! 1015: if (!az->ok64 && PTR_UPPER32(AZALIA_DMA_DMAADDR(d)) != 0) {
! 1016: azalia_free_dmamem(az, d);
! 1017: return -1;
! 1018: }
! 1019: return 0;
! 1020:
! 1021: destroy:
! 1022: bus_dmamap_destroy(az->dmat, d->map);
! 1023: unmap:
! 1024: bus_dmamem_unmap(az->dmat, d->addr, size);
! 1025: free:
! 1026: bus_dmamem_free(az->dmat, d->segments, 1);
! 1027: d->addr = NULL;
! 1028: return err;
! 1029: }
! 1030:
! 1031: int
! 1032: azalia_free_dmamem(const azalia_t *az, azalia_dma_t* d)
! 1033: {
! 1034: if (d->addr == NULL)
! 1035: return 0;
! 1036: bus_dmamap_unload(az->dmat, d->map);
! 1037: bus_dmamap_destroy(az->dmat, d->map);
! 1038: bus_dmamem_unmap(az->dmat, d->addr, d->size);
! 1039: bus_dmamem_free(az->dmat, d->segments, 1);
! 1040: d->addr = NULL;
! 1041: return 0;
! 1042: }
! 1043:
! 1044: /* ================================================================
! 1045: * HDA codec functions
! 1046: * ================================================================ */
! 1047:
! 1048: int
! 1049: azalia_codec_init(codec_t *this)
! 1050: {
! 1051: uint32_t rev, id, result;
! 1052: int err, addr, n, i;
! 1053: const char *vendor;
! 1054:
! 1055: this->comresp = azalia_codec_comresp;
! 1056: addr = this->address;
! 1057: DPRINTF(("%s: information of codec[%d] follows:\n",
! 1058: XNAME(this->az), addr));
! 1059: /* codec vendor/device/revision */
! 1060: err = this->comresp(this, CORB_NID_ROOT, CORB_GET_PARAMETER,
! 1061: COP_REVISION_ID, &rev);
! 1062: if (err)
! 1063: return err;
! 1064: err = this->comresp(this, CORB_NID_ROOT, CORB_GET_PARAMETER,
! 1065: COP_VENDOR_ID, &id);
! 1066: if (err)
! 1067: return err;
! 1068: this->vid = id;
! 1069: this->subid = this->az->subid;
! 1070: azalia_codec_init_vtbl(this);
! 1071:
! 1072: printf("%s: codec:", XNAME(this->az));
! 1073: if (this->name == NULL) {
! 1074: vendor = pci_findvendor(id >> 16);
! 1075: if (vendor == NULL)
! 1076: printf(" 0x%04x/0x%04x", id >> 16, id & 0xffff);
! 1077: else
! 1078: printf(" %s/0x%04x", vendor, id & 0xffff);
! 1079: } else
! 1080: printf(" %s", this->name);
! 1081: printf(" (rev. %u.%u), HDA version %u.%u\n",
! 1082: COP_RID_REVISION(rev), COP_RID_STEPPING(rev),
! 1083: COP_RID_MAJ(rev), COP_RID_MIN(rev));
! 1084:
! 1085: /* identify function nodes */
! 1086: err = this->comresp(this, CORB_NID_ROOT, CORB_GET_PARAMETER,
! 1087: COP_SUBORDINATE_NODE_COUNT, &result);
! 1088: if (err)
! 1089: return err;
! 1090: this->nfunctions = COP_NSUBNODES(result);
! 1091: if (COP_NSUBNODES(result) <= 0) {
! 1092: printf("%s: No function groups\n", XNAME(this->az));
! 1093: return -1;
! 1094: }
! 1095: /* iterate function nodes and find an audio function */
! 1096: n = COP_START_NID(result);
! 1097: DPRINTF(("%s: nidstart=%d #functions=%d\n",
! 1098: __func__, n, this->nfunctions));
! 1099: this->audiofunc = -1;
! 1100: for (i = 0; i < this->nfunctions; i++) {
! 1101: err = this->comresp(this, n + i, CORB_GET_PARAMETER,
! 1102: COP_FUNCTION_GROUP_TYPE, &result);
! 1103: if (err)
! 1104: continue;
! 1105: DPRINTF(("%s: FTYPE result = 0x%8.8x\n", __func__, result));
! 1106: if (COP_FTYPE(result) == COP_FTYPE_AUDIO) {
! 1107: this->audiofunc = n + i;
! 1108: break; /* XXX multiple audio functions? */
! 1109: } else if (COP_FTYPE(result) == COP_FTYPE_MODEM) {
! 1110: printf("%s: codec[%d]: No support for modem function groups\n",
! 1111: XNAME(this->az), addr);
! 1112: }
! 1113: }
! 1114: if (this->audiofunc < 0) {
! 1115: printf("%s: codec[%d]: No audio function groups\n",
! 1116: XNAME(this->az), addr);
! 1117: return -1;
! 1118: }
! 1119:
! 1120: /* power the audio function */
! 1121: this->comresp(this, this->audiofunc, CORB_SET_POWER_STATE, CORB_PS_D0, &result);
! 1122: DELAY(100);
! 1123:
! 1124: /* check widgets in the audio function */
! 1125: err = this->comresp(this, this->audiofunc,
! 1126: CORB_GET_PARAMETER, COP_SUBORDINATE_NODE_COUNT, &result);
! 1127: if (err)
! 1128: return err;
! 1129: DPRINTF(("%s: There are %d widgets in the audio function.\n",
! 1130: __func__, COP_NSUBNODES(result)));
! 1131: this->wstart = COP_START_NID(result);
! 1132: if (this->wstart < 2) {
! 1133: printf("%s: invalid node structure\n", XNAME(this->az));
! 1134: return -1;
! 1135: }
! 1136: this->wend = this->wstart + COP_NSUBNODES(result);
! 1137: this->w = malloc(sizeof(widget_t) * this->wend, M_DEVBUF, M_NOWAIT);
! 1138: if (this->w == NULL) {
! 1139: printf("%s: out of memory\n", XNAME(this->az));
! 1140: return ENOMEM;
! 1141: }
! 1142: bzero(this->w, sizeof(widget_t) * this->wend);
! 1143:
! 1144: /* query the base parameters */
! 1145: this->comresp(this, this->audiofunc, CORB_GET_PARAMETER,
! 1146: COP_STREAM_FORMATS, &result);
! 1147: this->w[this->audiofunc].d.audio.encodings = result;
! 1148: this->comresp(this, this->audiofunc, CORB_GET_PARAMETER,
! 1149: COP_PCM, &result);
! 1150: this->w[this->audiofunc].d.audio.bits_rates = result;
! 1151: this->comresp(this, this->audiofunc, CORB_GET_PARAMETER,
! 1152: COP_INPUT_AMPCAP, &result);
! 1153: this->w[this->audiofunc].inamp_cap = result;
! 1154: this->comresp(this, this->audiofunc, CORB_GET_PARAMETER,
! 1155: COP_OUTPUT_AMPCAP, &result);
! 1156: this->w[this->audiofunc].outamp_cap = result;
! 1157: #ifdef AZALIA_DEBUG
! 1158: azalia_widget_print_audio(&this->w[this->audiofunc], "\t");
! 1159: result = this->w[this->audiofunc].inamp_cap;
! 1160: DPRINTF(("\tinamp: mute=%u size=%u steps=%u offset=%u\n",
! 1161: (result & COP_AMPCAP_MUTE) != 0, COP_AMPCAP_STEPSIZE(result),
! 1162: COP_AMPCAP_NUMSTEPS(result), COP_AMPCAP_OFFSET(result)));
! 1163: result = this->w[this->audiofunc].outamp_cap;
! 1164: DPRINTF(("\toutamp: mute=%u size=%u steps=%u offset=%u\n",
! 1165: (result & COP_AMPCAP_MUTE) != 0, COP_AMPCAP_STEPSIZE(result),
! 1166: COP_AMPCAP_NUMSTEPS(result), COP_AMPCAP_OFFSET(result)));
! 1167: #endif
! 1168:
! 1169: strlcpy(this->w[CORB_NID_ROOT].name, "root",
! 1170: sizeof(this->w[CORB_NID_ROOT].name));
! 1171: strlcpy(this->w[this->audiofunc].name, "hdaudio",
! 1172: sizeof(this->w[this->audiofunc].name));
! 1173: FOR_EACH_WIDGET(this, i) {
! 1174: err = azalia_widget_init(&this->w[i], this, i);
! 1175: if (err)
! 1176: return err;
! 1177: }
! 1178:
! 1179: err = this->init_dacgroup(this);
! 1180: if (err)
! 1181: return err;
! 1182: #ifdef AZALIA_DEBUG
! 1183: for (i = 0; i < this->dacs.ngroups; i++) {
! 1184: DPRINTF(("%s: dacgroup[%d]:", __func__, i));
! 1185: for (n = 0; n < this->dacs.groups[i].nconv; n++) {
! 1186: DPRINTF((" %2.2x", this->dacs.groups[i].conv[n]));
! 1187: }
! 1188: DPRINTF(("\n"));
! 1189: }
! 1190: #endif
! 1191:
! 1192: /* set invalid values for azalia_codec_construct_format() to work */
! 1193: this->dacs.cur = -1;
! 1194: this->adcs.cur = -1;
! 1195: err = azalia_codec_construct_format(this, 0, 0);
! 1196: if (err)
! 1197: return err;
! 1198:
! 1199: return this->mixer_init(this);
! 1200: }
! 1201:
! 1202: int
! 1203: azalia_codec_delete(codec_t *this)
! 1204: {
! 1205: if (this->mixer_delete != NULL)
! 1206: this->mixer_delete(this);
! 1207: if (this->formats != NULL) {
! 1208: free(this->formats, M_DEVBUF);
! 1209: this->formats = NULL;
! 1210: }
! 1211: printf("delete_encodings...\n");
! 1212: auconv_delete_encodings(this->encodings);
! 1213: this->encodings = NULL;
! 1214: return 0;
! 1215: }
! 1216:
! 1217: int
! 1218: azalia_codec_construct_format(codec_t *this, int newdac, int newadc)
! 1219: {
! 1220: const convgroup_t *group;
! 1221: uint32_t bits_rates;
! 1222: int prev_dac, prev_adc;
! 1223: int pvariation, rvariation;
! 1224: int nbits, c, chan, i, err;
! 1225: nid_t nid;
! 1226:
! 1227: prev_dac = this->dacs.cur;
! 1228: this->dacs.cur = newdac;
! 1229: group = &this->dacs.groups[this->dacs.cur];
! 1230: bits_rates = this->w[group->conv[0]].d.audio.bits_rates;
! 1231: nbits = 0;
! 1232: if (bits_rates & COP_PCM_B8)
! 1233: nbits++;
! 1234: if (bits_rates & COP_PCM_B16)
! 1235: nbits++;
! 1236: if (bits_rates & COP_PCM_B20)
! 1237: nbits++;
! 1238: if (bits_rates & COP_PCM_B24)
! 1239: nbits++;
! 1240: if (bits_rates & COP_PCM_B32)
! 1241: nbits++;
! 1242: if (nbits == 0) {
! 1243: printf("%s: %s/%d invalid PCM format: 0x%8.8x\n",
! 1244: XNAME(this->az), __FILE__, __LINE__, bits_rates);
! 1245: return -1;
! 1246: }
! 1247: pvariation = group->nconv * nbits;
! 1248:
! 1249: prev_adc = this->adcs.cur;
! 1250: this->adcs.cur = newadc;
! 1251: group = &this->adcs.groups[this->adcs.cur];
! 1252: bits_rates = this->w[group->conv[0]].d.audio.bits_rates;
! 1253: nbits = 0;
! 1254: if (bits_rates & COP_PCM_B8)
! 1255: nbits++;
! 1256: if (bits_rates & COP_PCM_B16)
! 1257: nbits++;
! 1258: if (bits_rates & COP_PCM_B20)
! 1259: nbits++;
! 1260: if (bits_rates & COP_PCM_B24)
! 1261: nbits++;
! 1262: if (bits_rates & COP_PCM_B32)
! 1263: nbits++;
! 1264: if (nbits == 0) {
! 1265: printf("%s: %s/%d invalid PCM format: 0x%8.8x\n",
! 1266: XNAME(this->az), __FILE__, __LINE__, bits_rates);
! 1267: return -1;
! 1268: }
! 1269: rvariation = group->nconv * nbits;
! 1270:
! 1271: if (this->formats != NULL)
! 1272: free(this->formats, M_DEVBUF);
! 1273: this->nformats = 0;
! 1274: this->formats = malloc(sizeof(struct audio_format) *
! 1275: (pvariation + rvariation), M_DEVBUF, M_NOWAIT);
! 1276: if (this->formats == NULL) {
! 1277: printf("%s: out of memory in %s\n",
! 1278: XNAME(this->az), __func__);
! 1279: return ENOMEM;
! 1280: }
! 1281: bzero(this->formats, sizeof(struct audio_format) *
! 1282: (pvariation + rvariation));
! 1283:
! 1284: /* register formats for playback */
! 1285: group = &this->dacs.groups[this->dacs.cur];
! 1286: nid = group->conv[0];
! 1287: chan = 0;
! 1288: bits_rates = this->w[nid].d.audio.bits_rates;
! 1289: for (c = 0; c < group->nconv; c++) {
! 1290: for (chan = 0, i = 0; i <= c; i++)
! 1291: chan += WIDGET_CHANNELS(&this->w[group->conv[c]]);
! 1292: azalia_codec_add_bits(this, chan, bits_rates, AUMODE_PLAY);
! 1293: }
! 1294:
! 1295: /* register formats for recording */
! 1296: group = &this->adcs.groups[this->adcs.cur];
! 1297: nid = group->conv[0];
! 1298: chan = 0;
! 1299: bits_rates = this->w[nid].d.audio.bits_rates;
! 1300: for (c = 0; c < group->nconv; c++) {
! 1301: for (chan = 0, i = 0; i <= c; i++)
! 1302: chan += WIDGET_CHANNELS(&this->w[group->conv[c]]);
! 1303: azalia_codec_add_bits(this, chan, bits_rates, AUMODE_RECORD);
! 1304: }
! 1305:
! 1306: err = azalia_create_encodings(this->formats, this->nformats,
! 1307: &this->encodings);
! 1308: if (err)
! 1309: return err;
! 1310: return 0;
! 1311: }
! 1312:
! 1313: void
! 1314: azalia_codec_add_bits(codec_t *this, int chan, uint32_t bits_rates, int mode)
! 1315: {
! 1316: if (bits_rates & COP_PCM_B8)
! 1317: azalia_codec_add_format(this, chan, 8, 16, bits_rates, mode);
! 1318: if (bits_rates & COP_PCM_B16)
! 1319: azalia_codec_add_format(this, chan, 16, 16, bits_rates, mode);
! 1320: if (bits_rates & COP_PCM_B20)
! 1321: azalia_codec_add_format(this, chan, 20, 32, bits_rates, mode);
! 1322: if (bits_rates & COP_PCM_B24)
! 1323: azalia_codec_add_format(this, chan, 24, 32, bits_rates, mode);
! 1324: if (bits_rates & COP_PCM_B32)
! 1325: azalia_codec_add_format(this, chan, 32, 32, bits_rates, mode);
! 1326: }
! 1327:
! 1328: void
! 1329: azalia_codec_add_format(codec_t *this, int chan, int valid, int prec,
! 1330: uint32_t rates, int32_t mode)
! 1331: {
! 1332: struct audio_format *f;
! 1333:
! 1334: f = &this->formats[this->nformats++];
! 1335: f->mode = mode;
! 1336: f->encoding = AUDIO_ENCODING_SLINEAR_LE;
! 1337: if (valid == 8 && prec == 8)
! 1338: f->encoding = AUDIO_ENCODING_ULINEAR_LE;
! 1339: f->validbits = valid;
! 1340: f->precision = prec;
! 1341: f->channels = chan;
! 1342: switch (chan) {
! 1343: case 1:
! 1344: f->channel_mask = AUFMT_MONAURAL;
! 1345: break;
! 1346: case 2:
! 1347: f->channel_mask = AUFMT_STEREO;
! 1348: break;
! 1349: case 4:
! 1350: f->channel_mask = AUFMT_SURROUND4;
! 1351: break;
! 1352: case 6:
! 1353: f->channel_mask = AUFMT_DOLBY_5_1;
! 1354: break;
! 1355: case 8:
! 1356: f->channel_mask = AUFMT_DOLBY_5_1
! 1357: | AUFMT_SIDE_LEFT | AUFMT_SIDE_RIGHT;
! 1358: break;
! 1359: default:
! 1360: f->channel_mask = 0;
! 1361: }
! 1362: if (rates & COP_PCM_R80)
! 1363: f->frequency[f->frequency_type++] = 8000;
! 1364: if (rates & COP_PCM_R110)
! 1365: f->frequency[f->frequency_type++] = 11025;
! 1366: if (rates & COP_PCM_R160)
! 1367: f->frequency[f->frequency_type++] = 16000;
! 1368: if (rates & COP_PCM_R220)
! 1369: f->frequency[f->frequency_type++] = 22050;
! 1370: if (rates & COP_PCM_R320)
! 1371: f->frequency[f->frequency_type++] = 32000;
! 1372: if (rates & COP_PCM_R441)
! 1373: f->frequency[f->frequency_type++] = 44100;
! 1374: if (rates & COP_PCM_R480)
! 1375: f->frequency[f->frequency_type++] = 48000;
! 1376: if (rates & COP_PCM_R882)
! 1377: f->frequency[f->frequency_type++] = 88200;
! 1378: if (rates & COP_PCM_R960)
! 1379: f->frequency[f->frequency_type++] = 96000;
! 1380: if (rates & COP_PCM_R1764)
! 1381: f->frequency[f->frequency_type++] = 176400;
! 1382: if (rates & COP_PCM_R1920)
! 1383: f->frequency[f->frequency_type++] = 192000;
! 1384: if (rates & COP_PCM_R3840)
! 1385: f->frequency[f->frequency_type++] = 384000;
! 1386: }
! 1387:
! 1388: int
! 1389: azalia_codec_comresp(const codec_t *codec, nid_t nid, uint32_t control,
! 1390: uint32_t param, uint32_t* result)
! 1391: {
! 1392: int err;
! 1393:
! 1394: err = azalia_set_command(codec->az, codec->address, nid, control, param);
! 1395: if (err)
! 1396: return err;
! 1397: return azalia_get_response(codec->az, result);
! 1398: }
! 1399:
! 1400: int
! 1401: azalia_codec_connect_stream(codec_t *this, int dir, uint16_t fmt, int number)
! 1402: {
! 1403: const convgroup_t *group;
! 1404: int i, err, startchan, nchan;
! 1405: nid_t nid;
! 1406: boolean_t flag222;
! 1407:
! 1408: DPRINTF(("%s: fmt=0x%4.4x number=%d\n", __func__, fmt, number));
! 1409: err = 0;
! 1410: if (dir == AUMODE_RECORD)
! 1411: group = &this->adcs.groups[this->adcs.cur];
! 1412: else
! 1413: group = &this->dacs.groups[this->dacs.cur];
! 1414: flag222 = group->nconv >= 3 &&
! 1415: (WIDGET_CHANNELS(&this->w[group->conv[0]]) == 2) &&
! 1416: (WIDGET_CHANNELS(&this->w[group->conv[1]]) == 2) &&
! 1417: (WIDGET_CHANNELS(&this->w[group->conv[2]]) == 2);
! 1418: nchan = (fmt & HDA_SD_FMT_CHAN) + 1;
! 1419: startchan = 0;
! 1420: for (i = 0; i < group->nconv; i++) {
! 1421: nid = group->conv[i];
! 1422:
! 1423: /* surround and c/lfe handling */
! 1424: if (nchan >= 6 && flag222 && i == 1) {
! 1425: nid = group->conv[2];
! 1426: } else if (nchan >= 6 && flag222 && i == 2) {
! 1427: nid = group->conv[1];
! 1428: }
! 1429:
! 1430: err = this->comresp(this, nid, CORB_SET_CONVERTER_FORMAT, fmt, NULL);
! 1431: if (err)
! 1432: goto exit;
! 1433: err = this->comresp(this, nid, CORB_SET_CONVERTER_STREAM_CHANNEL,
! 1434: (number << 4) | startchan, NULL);
! 1435: if (err)
! 1436: goto exit;
! 1437: if (nchan > 2)
! 1438: startchan += WIDGET_CHANNELS(&this->w[nid]);
! 1439: }
! 1440:
! 1441: exit:
! 1442: DPRINTF(("%s: leave with %d\n", __func__, err));
! 1443: return err;
! 1444: }
! 1445:
! 1446: /* ================================================================
! 1447: * HDA widget functions
! 1448: * ================================================================ */
! 1449:
! 1450: #define WIDGETCAP_BITS \
! 1451: "\20\014LRSWAP\013POWER\012DIGITAL" \
! 1452: "\011CONNLIST\010UNSOL\07PROC\06STRIPE\05FORMATOV\04AMPOV\03OUTAMP" \
! 1453: "\02INAMP\01STEREO"
! 1454:
! 1455: int
! 1456: azalia_widget_init(widget_t *this, const codec_t *codec, nid_t nid)
! 1457: {
! 1458: uint32_t result;
! 1459: int err;
! 1460:
! 1461: err = codec->comresp(codec, nid, CORB_GET_PARAMETER,
! 1462: COP_AUDIO_WIDGET_CAP, &result);
! 1463: if (err)
! 1464: return err;
! 1465: this->nid = nid;
! 1466: this->widgetcap = result;
! 1467: this->type = COP_AWCAP_TYPE(result);
! 1468: DPRINTF(("%s: ", XNAME(codec->az)));
! 1469: if (this->widgetcap & COP_AWCAP_POWER) {
! 1470: codec->comresp(codec, nid, CORB_SET_POWER_STATE, CORB_PS_D0, &result);
! 1471: DELAY(100);
! 1472: }
! 1473: switch (this->type) {
! 1474: case COP_AWTYPE_AUDIO_OUTPUT:
! 1475: snprintf(this->name, sizeof(this->name), "dac%2.2x", nid);
! 1476: DPRINTF(("%s wcap=%b\n", this->name,
! 1477: this->widgetcap, WIDGETCAP_BITS));
! 1478: azalia_widget_init_audio(this, codec);
! 1479: break;
! 1480: case COP_AWTYPE_AUDIO_INPUT:
! 1481: snprintf(this->name, sizeof(this->name), "adc%2.2x", nid);
! 1482: DPRINTF(("%s wcap=%b\n", this->name,
! 1483: this->widgetcap, WIDGETCAP_BITS));
! 1484: azalia_widget_init_audio(this, codec);
! 1485: break;
! 1486: case COP_AWTYPE_AUDIO_MIXER:
! 1487: snprintf(this->name, sizeof(this->name), "mix%2.2x", nid);
! 1488: DPRINTF(("%s wcap=%b\n", this->name,
! 1489: this->widgetcap, WIDGETCAP_BITS));
! 1490: break;
! 1491: case COP_AWTYPE_AUDIO_SELECTOR:
! 1492: snprintf(this->name, sizeof(this->name), "sel%2.2x", nid);
! 1493: DPRINTF(("%s wcap=%b\n", this->name,
! 1494: this->widgetcap, WIDGETCAP_BITS));
! 1495: break;
! 1496: case COP_AWTYPE_PIN_COMPLEX:
! 1497: azalia_widget_init_pin(this, codec);
! 1498: snprintf(this->name, sizeof(this->name), "%s%2.2x",
! 1499: pin_colors[this->d.pin.color], nid);
! 1500: DPRINTF(("%s wcap=%b\n", this->name,
! 1501: this->widgetcap, WIDGETCAP_BITS));
! 1502: azalia_widget_print_pin(this);
! 1503: break;
! 1504: case COP_AWTYPE_POWER:
! 1505: snprintf(this->name, sizeof(this->name), "pow%2.2x", nid);
! 1506: DPRINTF(("%s wcap=%b\n", this->name,
! 1507: this->widgetcap, WIDGETCAP_BITS));
! 1508: break;
! 1509: case COP_AWTYPE_VOLUME_KNOB:
! 1510: snprintf(this->name, sizeof(this->name), "volume%2.2x", nid);
! 1511: DPRINTF(("%s wcap=%b\n", this->name,
! 1512: this->widgetcap, WIDGETCAP_BITS));
! 1513: err = codec->comresp(codec, nid, CORB_GET_PARAMETER,
! 1514: COP_VOLUME_KNOB_CAPABILITIES, &result);
! 1515: if (!err) {
! 1516: this->d.volume.cap = result;
! 1517: DPRINTF(("\tdelta=%d steps=%d\n",
! 1518: !!(result & COP_VKCAP_DELTA),
! 1519: COP_VKCAP_NUMSTEPS(result)));
! 1520: }
! 1521: break;
! 1522: case COP_AWTYPE_BEEP_GENERATOR:
! 1523: snprintf(this->name, sizeof(this->name), "beep%2.2x", nid);
! 1524: DPRINTF(("%s wcap=%b\n", this->name,
! 1525: this->widgetcap, WIDGETCAP_BITS));
! 1526: break;
! 1527: default:
! 1528: snprintf(this->name, sizeof(this->name), "widget%2.2x", nid);
! 1529: DPRINTF(("%s wcap=%b\n", this->name,
! 1530: this->widgetcap, WIDGETCAP_BITS));
! 1531: break;
! 1532: }
! 1533: azalia_widget_init_connection(this, codec);
! 1534:
! 1535: /* amplifier information */
! 1536: if (this->widgetcap & COP_AWCAP_INAMP) {
! 1537: if (this->widgetcap & COP_AWCAP_AMPOV)
! 1538: codec->comresp(codec, nid, CORB_GET_PARAMETER,
! 1539: COP_INPUT_AMPCAP, &this->inamp_cap);
! 1540: else
! 1541: this->inamp_cap = codec->w[codec->audiofunc].inamp_cap;
! 1542: DPRINTF(("\tinamp: mute=%u size=%u steps=%u offset=%u\n",
! 1543: (this->inamp_cap & COP_AMPCAP_MUTE) != 0,
! 1544: COP_AMPCAP_STEPSIZE(this->inamp_cap),
! 1545: COP_AMPCAP_NUMSTEPS(this->inamp_cap),
! 1546: COP_AMPCAP_OFFSET(this->inamp_cap)));
! 1547: }
! 1548: if (this->widgetcap & COP_AWCAP_OUTAMP) {
! 1549: if (this->widgetcap & COP_AWCAP_AMPOV)
! 1550: codec->comresp(codec, nid, CORB_GET_PARAMETER,
! 1551: COP_OUTPUT_AMPCAP, &this->outamp_cap);
! 1552: else
! 1553: this->outamp_cap = codec->w[codec->audiofunc].outamp_cap;
! 1554: DPRINTF(("\toutamp: mute=%u size=%u steps=%u offset=%u\n",
! 1555: (this->outamp_cap & COP_AMPCAP_MUTE) != 0,
! 1556: COP_AMPCAP_STEPSIZE(this->outamp_cap),
! 1557: COP_AMPCAP_NUMSTEPS(this->outamp_cap),
! 1558: COP_AMPCAP_OFFSET(this->outamp_cap)));
! 1559: }
! 1560: if (codec->init_widget != NULL)
! 1561: codec->init_widget(codec, this, nid);
! 1562: return 0;
! 1563: }
! 1564:
! 1565: int
! 1566: azalia_widget_init_audio(widget_t *this, const codec_t *codec)
! 1567: {
! 1568: uint32_t result;
! 1569: int err;
! 1570:
! 1571: /* check audio format */
! 1572: if (this->widgetcap & COP_AWCAP_FORMATOV) {
! 1573: err = codec->comresp(codec, this->nid,
! 1574: CORB_GET_PARAMETER, COP_STREAM_FORMATS, &result);
! 1575: if (err)
! 1576: return err;
! 1577: this->d.audio.encodings = result;
! 1578: if (result == 0) { /* quirk for CMI9880.
! 1579: * This must not occuur usually... */
! 1580: this->d.audio.encodings =
! 1581: codec->w[codec->audiofunc].d.audio.encodings;
! 1582: this->d.audio.bits_rates =
! 1583: codec->w[codec->audiofunc].d.audio.bits_rates;
! 1584: } else {
! 1585: if ((result & COP_STREAM_FORMAT_PCM) == 0) {
! 1586: printf("%s: %s: No PCM support: %x\n",
! 1587: XNAME(codec->az), this->name, result);
! 1588: return -1;
! 1589: }
! 1590: err = codec->comresp(codec, this->nid, CORB_GET_PARAMETER,
! 1591: COP_PCM, &result);
! 1592: if (err)
! 1593: return err;
! 1594: this->d.audio.bits_rates = result;
! 1595: }
! 1596: this->d.audio.bits_rates = result;
! 1597: } else {
! 1598: this->d.audio.encodings =
! 1599: codec->w[codec->audiofunc].d.audio.encodings;
! 1600: this->d.audio.bits_rates =
! 1601: codec->w[codec->audiofunc].d.audio.bits_rates;
! 1602: }
! 1603: #ifdef AZALIA_DEBUG
! 1604: azalia_widget_print_audio(this, "\t");
! 1605: #endif
! 1606: return 0;
! 1607: }
! 1608:
! 1609: #define ENCODING_BITS "\20\3AC3\2FLOAT32\1PCM"
! 1610: #define BITSRATES_BITS "\20\x15""32bit\x14""24bit\x13""20bit" \
! 1611: "\x12""16bit\x11""8bit""\x0c""384kHz\x0b""192kHz\x0a""176.4kHz" \
! 1612: "\x09""96kHz\x08""88.2kHz\x07""48kHz\x06""44.1kHz\x05""32kHz\x04" \
! 1613: "22.05kHz\x03""16kHz\x02""11.025kHz\x01""8kHz"
! 1614:
! 1615: int
! 1616: azalia_widget_print_audio(const widget_t *this, const char *lead)
! 1617: {
! 1618: printf("%sencodings=%b\n", lead, this->d.audio.encodings,
! 1619: ENCODING_BITS);
! 1620: printf("%sPCM formats=%b\n", lead, this->d.audio.bits_rates,
! 1621: BITSRATES_BITS);
! 1622: return 0;
! 1623: }
! 1624:
! 1625: int
! 1626: azalia_widget_init_pin(widget_t *this, const codec_t *codec)
! 1627: {
! 1628: uint32_t result;
! 1629: int err;
! 1630:
! 1631: err = codec->comresp(codec, this->nid, CORB_GET_CONFIGURATION_DEFAULT,
! 1632: 0, &result);
! 1633: if (err)
! 1634: return err;
! 1635: this->d.pin.config = result;
! 1636: this->d.pin.sequence = CORB_CD_SEQUENCE(result);
! 1637: this->d.pin.association = CORB_CD_ASSOCIATION(result);
! 1638: this->d.pin.color = CORB_CD_COLOR(result);
! 1639: this->d.pin.device = CORB_CD_DEVICE(result);
! 1640:
! 1641: err = codec->comresp(codec, this->nid, CORB_GET_PARAMETER,
! 1642: COP_PINCAP, &result);
! 1643: if (err)
! 1644: return err;
! 1645: this->d.pin.cap = result;
! 1646: return 0;
! 1647: }
! 1648:
! 1649: #define PINCAP_BITS "\20\021EAPD\07BALANCE\06INPUT" \
! 1650: "\05OUTPUT\04HEADPHONE\03PRESENCE\02TRIGGER\01IMPEDANCE"
! 1651:
! 1652: int
! 1653: azalia_widget_print_pin(const widget_t *this)
! 1654: {
! 1655: DPRINTF(("\tpin config; device=%s color=%s assoc=%d seq=%d",
! 1656: pin_devices[this->d.pin.device], pin_colors[this->d.pin.color],
! 1657: this->d.pin.association, this->d.pin.sequence));
! 1658: DPRINTF((" cap=%b\n", this->d.pin.cap, PINCAP_BITS));
! 1659: return 0;
! 1660: }
! 1661:
! 1662: int
! 1663: azalia_widget_init_connection(widget_t *this, const codec_t *codec)
! 1664: {
! 1665: uint32_t result;
! 1666: int err;
! 1667: boolean_t longform;
! 1668: int length, i;
! 1669:
! 1670: this->selected = -1;
! 1671: if ((this->widgetcap & COP_AWCAP_CONNLIST) == 0)
! 1672: return 0;
! 1673:
! 1674: err = codec->comresp(codec, this->nid, CORB_GET_PARAMETER,
! 1675: COP_CONNECTION_LIST_LENGTH, &result);
! 1676: if (err)
! 1677: return err;
! 1678: longform = (result & COP_CLL_LONG) != 0;
! 1679: length = COP_CLL_LENGTH(result);
! 1680: if (length == 0)
! 1681: return 0;
! 1682: this->nconnections = length;
! 1683: this->connections = malloc(sizeof(nid_t) * (length + 3),
! 1684: M_DEVBUF, M_NOWAIT);
! 1685: if (this->connections == NULL) {
! 1686: printf("%s: out of memory\n", XNAME(codec->az));
! 1687: return ENOMEM;
! 1688: }
! 1689: if (longform) {
! 1690: for (i = 0; i < length;) {
! 1691: err = codec->comresp(codec, this->nid,
! 1692: CORB_GET_CONNECTION_LIST_ENTRY, i, &result);
! 1693: if (err)
! 1694: return err;
! 1695: this->connections[i++] = CORB_CLE_LONG_0(result);
! 1696: this->connections[i++] = CORB_CLE_LONG_1(result);
! 1697: }
! 1698: } else {
! 1699: for (i = 0; i < length;) {
! 1700: err = codec->comresp(codec, this->nid,
! 1701: CORB_GET_CONNECTION_LIST_ENTRY, i, &result);
! 1702: if (err)
! 1703: return err;
! 1704: this->connections[i++] = CORB_CLE_SHORT_0(result);
! 1705: this->connections[i++] = CORB_CLE_SHORT_1(result);
! 1706: this->connections[i++] = CORB_CLE_SHORT_2(result);
! 1707: this->connections[i++] = CORB_CLE_SHORT_3(result);
! 1708: }
! 1709: }
! 1710: if (length > 0) {
! 1711: DPRINTF(("\tconnections=0x%x", this->connections[0]));
! 1712: for (i = 1; i < length; i++) {
! 1713: DPRINTF((",0x%x", this->connections[i]));
! 1714: }
! 1715:
! 1716: err = codec->comresp(codec, this->nid,
! 1717: CORB_GET_CONNECTION_SELECT_CONTROL, 0, &result);
! 1718: if (err)
! 1719: return err;
! 1720: this->selected = CORB_CSC_INDEX(result);
! 1721: DPRINTF(("; selected=0x%x\n", this->connections[result]));
! 1722: }
! 1723: return 0;
! 1724: }
! 1725:
! 1726: /* ================================================================
! 1727: * Stream functions
! 1728: * ================================================================ */
! 1729:
! 1730: int
! 1731: azalia_stream_init(stream_t *this, azalia_t *az, int regindex, int strnum, int dir)
! 1732: {
! 1733: int err;
! 1734:
! 1735: this->az = az;
! 1736: this->regbase = HDA_SD_BASE + regindex * HDA_SD_SIZE;
! 1737: this->intr_bit = 1 << regindex;
! 1738: this->number = strnum;
! 1739: this->dir = dir;
! 1740:
! 1741: /* setup BDL buffers */
! 1742: err = azalia_alloc_dmamem(az, sizeof(bdlist_entry_t) * HDA_BDL_MAX,
! 1743: 128, &this->bdlist);
! 1744: if (err) {
! 1745: printf("%s: can't allocate a BDL buffer\n", XNAME(az));
! 1746: return err;
! 1747: }
! 1748: return 0;
! 1749: }
! 1750:
! 1751: int
! 1752: azalia_stream_delete(stream_t *this, azalia_t *az)
! 1753: {
! 1754: if (this->bdlist.addr == NULL)
! 1755: return 0;
! 1756: azalia_free_dmamem(az, &this->bdlist);
! 1757: return 0;
! 1758: }
! 1759:
! 1760: int
! 1761: azalia_stream_reset(stream_t *this)
! 1762: {
! 1763: int i;
! 1764: uint16_t ctl;
! 1765: uint8_t sts;
! 1766:
! 1767: /* Make sure RUN bit is zero before resetting */
! 1768: ctl = STR_READ_2(this, CTL);
! 1769: ctl &= ~HDA_SD_CTL_RUN;
! 1770: STR_WRITE_2(this, CTL, ctl);
! 1771:
! 1772: /* Start reset and wait for chip to enter. */
! 1773: ctl = STR_READ_2(this, CTL);
! 1774: STR_WRITE_2(this, CTL, ctl | HDA_SD_CTL_SRST);
! 1775: for (i = 5000; i >= 0; i--) {
! 1776: DELAY(10);
! 1777: ctl = STR_READ_2(this, CTL);
! 1778: if (ctl & HDA_SD_CTL_SRST)
! 1779: break;
! 1780: }
! 1781: if (i <= 0) {
! 1782: printf("%s: stream reset failure 1\n", XNAME(this->az));
! 1783: return -1;
! 1784: }
! 1785:
! 1786: /* Clear reset and wait for chip to finish */
! 1787: STR_WRITE_2(this, CTL, ctl & ~HDA_SD_CTL_SRST);
! 1788: for (i = 5000; i >= 0; i--) {
! 1789: DELAY(10);
! 1790: ctl = STR_READ_2(this, CTL);
! 1791: if ((ctl & HDA_SD_CTL_SRST) == 0)
! 1792: break;
! 1793: }
! 1794: if (i <= 0) {
! 1795: printf("%s: stream reset failure 2\n", XNAME(this->az));
! 1796: return -1;
! 1797: }
! 1798:
! 1799: sts = STR_READ_1(this, STS);
! 1800: sts |= HDA_SD_STS_DESE | HDA_SD_STS_FIFOE | HDA_SD_STS_BCIS;
! 1801: STR_WRITE_1(this, STS, sts);
! 1802:
! 1803: return (0);
! 1804: }
! 1805:
! 1806: int
! 1807: azalia_stream_start(stream_t *this, void *start, void *end, int blk,
! 1808: void (*intr)(void *), void *arg, uint16_t fmt)
! 1809: {
! 1810: bdlist_entry_t *bdlist;
! 1811: bus_addr_t dmaaddr, dmaend;
! 1812: int err, index;
! 1813: uint32_t intctl;
! 1814: uint8_t ctl2;
! 1815:
! 1816: this->intr = intr;
! 1817: this->intr_arg = arg;
! 1818:
! 1819: err = azalia_stream_reset(this);
! 1820: if (err) {
! 1821: printf("%s: stream reset failed\n", "azalia");
! 1822: return err;
! 1823: }
! 1824:
! 1825: STR_WRITE_4(this, BDPL, 0);
! 1826: STR_WRITE_4(this, BDPU, 0);
! 1827:
! 1828: /* setup BDL */
! 1829: dmaaddr = AZALIA_DMA_DMAADDR(&this->buffer);
! 1830: dmaend = dmaaddr + ((caddr_t)end - (caddr_t)start);
! 1831: bdlist = (bdlist_entry_t*)this->bdlist.addr;
! 1832: for (index = 0; index < HDA_BDL_MAX; index++) {
! 1833: bdlist[index].low = htole32(dmaaddr);
! 1834: bdlist[index].high = htole32(PTR_UPPER32(dmaaddr));
! 1835: bdlist[index].length = htole32(blk);
! 1836: bdlist[index].flags = htole32(BDLIST_ENTRY_IOC);
! 1837: dmaaddr += blk;
! 1838: if (dmaaddr >= dmaend) {
! 1839: index++;
! 1840: break;
! 1841: }
! 1842: }
! 1843:
! 1844: dmaaddr = AZALIA_DMA_DMAADDR(&this->bdlist);
! 1845: STR_WRITE_4(this, BDPL, dmaaddr);
! 1846: STR_WRITE_4(this, BDPU, PTR_UPPER32(dmaaddr));
! 1847: STR_WRITE_2(this, LVI, (index - 1) & HDA_SD_LVI_LVI);
! 1848: ctl2 = STR_READ_1(this, CTL2);
! 1849: STR_WRITE_1(this, CTL2,
! 1850: (ctl2 & ~HDA_SD_CTL2_STRM) | (this->number << HDA_SD_CTL2_STRM_SHIFT));
! 1851: STR_WRITE_4(this, CBL, ((caddr_t)end - (caddr_t)start));
! 1852: STR_WRITE_2(this, FMT, fmt);
! 1853:
! 1854: err = azalia_codec_connect_stream(&this->az->codecs[this->az->codecno],
! 1855: this->dir, fmt, this->number);
! 1856: if (err)
! 1857: return EINVAL;
! 1858:
! 1859: intctl = AZ_READ_4(this->az, INTCTL);
! 1860: intctl |= this->intr_bit;
! 1861: AZ_WRITE_4(this->az, INTCTL, intctl);
! 1862:
! 1863: STR_WRITE_1(this, CTL, STR_READ_1(this, CTL) |
! 1864: HDA_SD_CTL_DEIE | HDA_SD_CTL_FEIE | HDA_SD_CTL_IOCE |
! 1865: HDA_SD_CTL_RUN);
! 1866:
! 1867: return (0);
! 1868: }
! 1869:
! 1870: int
! 1871: azalia_stream_halt(stream_t *this)
! 1872: {
! 1873: uint16_t ctl;
! 1874:
! 1875: ctl = STR_READ_2(this, CTL);
! 1876: ctl &= ~(HDA_SD_CTL_DEIE | HDA_SD_CTL_FEIE | HDA_SD_CTL_IOCE | HDA_SD_CTL_RUN);
! 1877: STR_WRITE_2(this, CTL, ctl);
! 1878: AZ_WRITE_4(this->az, INTCTL,
! 1879: AZ_READ_4(this->az, INTCTL) & ~this->intr_bit);
! 1880: return (0);
! 1881: }
! 1882:
! 1883: #define HDA_SD_STS_BITS "\20\3BCIS\4FIFOE\5DESE\6FIFORDY"
! 1884:
! 1885: int
! 1886: azalia_stream_intr(stream_t *this, uint32_t intsts)
! 1887: {
! 1888: u_int8_t sts;
! 1889:
! 1890: if ((intsts & this->intr_bit) == 0)
! 1891: return (0);
! 1892:
! 1893: sts = STR_READ_1(this, STS);
! 1894: STR_WRITE_1(this, STS, sts |
! 1895: HDA_SD_STS_DESE | HDA_SD_STS_FIFOE | HDA_SD_STS_BCIS);
! 1896:
! 1897: if (sts & (HDA_SD_STS_DESE | HDA_SD_STS_FIFOE))
! 1898: printf("%s: stream %d: sts=%b\n", XNAME(this->az),
! 1899: this->number, sts, HDA_SD_STS_BITS);
! 1900: if (sts & HDA_SD_STS_BCIS)
! 1901: this->intr(this->intr_arg);
! 1902: return (1);
! 1903: }
! 1904:
! 1905: /* ================================================================
! 1906: * MI audio entries
! 1907: * ================================================================ */
! 1908:
! 1909: int
! 1910: azalia_open(void *v, int flags)
! 1911: {
! 1912: azalia_t *az;
! 1913: codec_t *codec;
! 1914:
! 1915: DPRINTF(("%s: flags=0x%x\n", __func__, flags));
! 1916: az = v;
! 1917: codec = &az->codecs[az->codecno];
! 1918: codec->running++;
! 1919: return 0;
! 1920: }
! 1921:
! 1922: void
! 1923: azalia_close(void *v)
! 1924: {
! 1925: azalia_t *az;
! 1926: codec_t *codec;
! 1927:
! 1928: DPRINTF(("%s\n", __func__));
! 1929: az = v;
! 1930: codec = &az->codecs[az->codecno];
! 1931: codec->running--;
! 1932: }
! 1933:
! 1934: int
! 1935: azalia_query_encoding(void *v, audio_encoding_t *enc)
! 1936: {
! 1937: azalia_t *az;
! 1938: codec_t *codec;
! 1939: int i, j;
! 1940:
! 1941: az = v;
! 1942: codec = &az->codecs[az->codecno];
! 1943: for (j = 0, i = 0; j < codec->nformats; j++) {
! 1944: if (codec->formats[j].validbits !=
! 1945: codec->formats[j].precision)
! 1946: continue;
! 1947: if (i == enc->index) {
! 1948: enc->encoding = codec->formats[j].encoding;
! 1949: enc->precision = codec->formats[j].precision;
! 1950: switch (enc->encoding) {
! 1951: case AUDIO_ENCODING_SLINEAR_LE:
! 1952: strlcpy(enc->name, enc->precision == 8 ?
! 1953: AudioEslinear : AudioEslinear_le,
! 1954: sizeof enc->name);
! 1955: break;
! 1956: case AUDIO_ENCODING_ULINEAR_LE:
! 1957: strlcpy(enc->name, enc->precision == 8 ?
! 1958: AudioEulinear : AudioEulinear_le,
! 1959: sizeof enc->name);
! 1960: break;
! 1961: default:
! 1962: strlcpy(enc->name, "unknown", sizeof enc->name);
! 1963: break;
! 1964: }
! 1965: return (0);
! 1966: }
! 1967: i++;
! 1968: }
! 1969: return (EINVAL);
! 1970: }
! 1971:
! 1972: int
! 1973: azalia_set_params(void *v, int smode, int umode, audio_params_t *p,
! 1974: audio_params_t *r)
! 1975: {
! 1976: azalia_t *az;
! 1977: codec_t *codec;
! 1978: void (*pswcode)(void *, u_char *, int) = NULL;
! 1979: void (*rswcode)(void *, u_char *, int) = NULL;
! 1980: int i, j;
! 1981:
! 1982: az = v;
! 1983: codec = &az->codecs[az->codecno];
! 1984: if (smode & AUMODE_RECORD && r != NULL) {
! 1985: if (r->encoding == AUDIO_ENCODING_ULAW) { /*XXX*/
! 1986: r->encoding = AUDIO_ENCODING_SLINEAR_LE;
! 1987: r->precision = 16;
! 1988: r->channels = 2;
! 1989: r->sample_rate = 44100;
! 1990: }
! 1991: for (i = 0; i < codec->nformats; i++) {
! 1992: if (r->encoding != codec->formats[i].encoding)
! 1993: continue;
! 1994: if (r->precision != codec->formats[i].precision)
! 1995: continue;
! 1996: if (r->channels != codec->formats[i].channels)
! 1997: continue;
! 1998: break;
! 1999: }
! 2000: if (i == codec->nformats) {
! 2001: printf("didn't find Record format %u/%u/%u\n",
! 2002: r->encoding, r->precision, r->channels);
! 2003: return (EINVAL);
! 2004: }
! 2005: for (j = 0; j < codec->formats[i].frequency_type; j++) {
! 2006: if (r->sample_rate != codec->formats[i].frequency[j])
! 2007: continue;
! 2008: break;
! 2009: }
! 2010: if (j == codec->formats[i].frequency_type) {
! 2011: printf("didn't find Record rate %u\n",
! 2012: r->sample_rate);
! 2013: return (EINVAL);
! 2014: }
! 2015: r->sw_code = rswcode;
! 2016: }
! 2017: if (smode & AUMODE_PLAY && p != NULL) {
! 2018: if (p->encoding == AUDIO_ENCODING_ULAW) { /*XXX*/
! 2019: p->encoding = AUDIO_ENCODING_SLINEAR_LE;
! 2020: p->precision = 16;
! 2021: p->channels = 2;
! 2022: p->sample_rate = 44100;
! 2023: }
! 2024: for (i = 0; i < codec->nformats; i++) {
! 2025: if (p->encoding != codec->formats[i].encoding)
! 2026: continue;
! 2027: if (p->precision != codec->formats[i].precision)
! 2028: continue;
! 2029: if (p->channels != codec->formats[i].channels)
! 2030: continue;
! 2031: break;
! 2032: }
! 2033: if (i == codec->nformats) {
! 2034: printf("can't find playback format %u/%u/%u\n",
! 2035: r->encoding, r->precision, r->channels);
! 2036: return (EINVAL);
! 2037: }
! 2038: for (j = 0; j < codec->formats[i].frequency_type; j++) {
! 2039: if (p->sample_rate != codec->formats[i].frequency[j])
! 2040: continue;
! 2041: break;
! 2042: }
! 2043: if (j == codec->formats[i].frequency_type) {
! 2044: printf("can't find playback rate %u\n",
! 2045: p->sample_rate);
! 2046: return (EINVAL);
! 2047: }
! 2048: p->sw_code = pswcode;
! 2049: }
! 2050:
! 2051: return (0);
! 2052: }
! 2053:
! 2054: int
! 2055: azalia_round_blocksize(void *v, int blk)
! 2056: {
! 2057: azalia_t *az;
! 2058: size_t size;
! 2059:
! 2060: blk &= ~0x7f; /* must be multiple of 128 */
! 2061: if (blk <= 0)
! 2062: blk = 128;
! 2063: /* number of blocks must be <= HDA_BDL_MAX */
! 2064: az = v;
! 2065: size = az->pstream.buffer.size;
! 2066: #ifdef DIAGNOSTIC
! 2067: if (size <= 0) {
! 2068: printf("%s: size is 0", __func__);
! 2069: return 256;
! 2070: }
! 2071: #endif
! 2072: if (size > HDA_BDL_MAX * blk) {
! 2073: blk = size / HDA_BDL_MAX;
! 2074: if (blk & 0x7f)
! 2075: blk = (blk + 0x7f) & ~0x7f;
! 2076: }
! 2077: DPRINTF(("%s: resultant block size = %d\n", __func__, blk));
! 2078: return blk;
! 2079: }
! 2080:
! 2081: int
! 2082: azalia_halt_output(void *v)
! 2083: {
! 2084: azalia_t *az;
! 2085:
! 2086: DPRINTF(("%s\n", __func__));
! 2087: az = v;
! 2088: return azalia_stream_halt(&az->pstream);
! 2089: }
! 2090:
! 2091: int
! 2092: azalia_halt_input(void *v)
! 2093: {
! 2094: azalia_t *az;
! 2095:
! 2096: DPRINTF(("%s\n", __func__));
! 2097: az = v;
! 2098: return azalia_stream_halt(&az->rstream);
! 2099: }
! 2100:
! 2101: int
! 2102: azalia_getdev(void *v, struct audio_device *dev)
! 2103: {
! 2104: azalia_t *az;
! 2105:
! 2106: az = v;
! 2107: strlcpy(dev->name, "HD-Audio", MAX_AUDIO_DEV_LEN);
! 2108: snprintf(dev->version, MAX_AUDIO_DEV_LEN,
! 2109: "%d.%d", AZ_READ_1(az, VMAJ), AZ_READ_1(az, VMIN));
! 2110: strlcpy(dev->config, XNAME(az), MAX_AUDIO_DEV_LEN);
! 2111: return 0;
! 2112: }
! 2113:
! 2114: int
! 2115: azalia_set_port(void *v, mixer_ctrl_t *mc)
! 2116: {
! 2117: azalia_t *az;
! 2118: codec_t *co;
! 2119:
! 2120: az = v;
! 2121: co = &az->codecs[az->codecno];
! 2122: return co->set_port(co, mc);
! 2123: }
! 2124:
! 2125: int
! 2126: azalia_get_port(void *v, mixer_ctrl_t *mc)
! 2127: {
! 2128: azalia_t *az;
! 2129: codec_t *co;
! 2130:
! 2131: az = v;
! 2132: co = &az->codecs[az->codecno];
! 2133: return co->get_port(co, mc);
! 2134: }
! 2135:
! 2136: int
! 2137: azalia_query_devinfo(void *v, mixer_devinfo_t *mdev)
! 2138: {
! 2139: azalia_t *az;
! 2140: const codec_t *co;
! 2141:
! 2142: az = v;
! 2143: co = &az->codecs[az->codecno];
! 2144: if (mdev->index >= co->nmixers)
! 2145: return ENXIO;
! 2146: *mdev = co->mixers[mdev->index].devinfo;
! 2147: return 0;
! 2148: }
! 2149:
! 2150: void *
! 2151: azalia_allocm(void *v, int dir, size_t size, int pool, int flags)
! 2152: {
! 2153: azalia_t *az;
! 2154: stream_t *stream;
! 2155: int err;
! 2156:
! 2157: az = v;
! 2158: stream = dir == AUMODE_PLAY ? &az->pstream : &az->rstream;
! 2159: err = azalia_alloc_dmamem(az, size, 128, &stream->buffer);
! 2160: if (err) {
! 2161: printf("%s: allocm failed\n", az->dev.dv_xname);
! 2162: return NULL;
! 2163: }
! 2164: return stream->buffer.addr;
! 2165: }
! 2166:
! 2167: void
! 2168: azalia_freem(void *v, void *addr, int pool)
! 2169: {
! 2170: azalia_t *az;
! 2171: stream_t *stream;
! 2172:
! 2173: az = v;
! 2174: if (addr == az->pstream.buffer.addr) {
! 2175: stream = &az->pstream;
! 2176: } else if (addr == az->rstream.buffer.addr) {
! 2177: stream = &az->rstream;
! 2178: } else {
! 2179: return;
! 2180: }
! 2181: azalia_free_dmamem(az, &stream->buffer);
! 2182: }
! 2183:
! 2184: size_t
! 2185: azalia_round_buffersize(void *v, int dir, size_t size)
! 2186: {
! 2187: size &= ~0x7f; /* must be multiple of 128 */
! 2188: if (size <= 0)
! 2189: size = 128;
! 2190: return size;
! 2191: }
! 2192:
! 2193: int
! 2194: azalia_get_props(void *v)
! 2195: {
! 2196: return AUDIO_PROP_INDEPENDENT | AUDIO_PROP_FULLDUPLEX;
! 2197: }
! 2198:
! 2199: int
! 2200: azalia_trigger_output(void *v, void *start, void *end, int blk,
! 2201: void (*intr)(void *), void *arg, audio_params_t *param)
! 2202: {
! 2203: azalia_t *az;
! 2204: int err;
! 2205: uint16_t fmt;
! 2206:
! 2207: err = azalia_params2fmt(param, &fmt);
! 2208: if (err)
! 2209: return EINVAL;
! 2210:
! 2211: az = v;
! 2212: return azalia_stream_start(&az->pstream, start, end, blk, intr, arg, fmt);
! 2213: }
! 2214:
! 2215: int
! 2216: azalia_trigger_input(void *v, void *start, void *end, int blk,
! 2217: void (*intr)(void *), void *arg, audio_params_t *param)
! 2218: {
! 2219: azalia_t *az;
! 2220: int err;
! 2221: uint16_t fmt;
! 2222:
! 2223: DPRINTF(("%s: this=%p start=%p end=%p blk=%d {enc=%u %uch %u/%ubit %uHz}\n",
! 2224: __func__, v, start, end, blk, param->encoding, param->channels,
! 2225: param->precision, param->precision, param->sample_rate));
! 2226:
! 2227: err = azalia_params2fmt(param, &fmt);
! 2228: if (err)
! 2229: return EINVAL;
! 2230:
! 2231: az = v;
! 2232: return azalia_stream_start(&az->rstream, start, end, blk, intr, arg, fmt);
! 2233: }
! 2234:
! 2235: /* --------------------------------
! 2236: * helpers for MI audio functions
! 2237: * -------------------------------- */
! 2238: int
! 2239: azalia_params2fmt(const audio_params_t *param, uint16_t *fmt)
! 2240: {
! 2241: uint16_t ret;
! 2242:
! 2243: ret = 0;
! 2244: #ifdef DIAGNOSTIC
! 2245: if (param->channels > HDA_MAX_CHANNELS) {
! 2246: printf("%s: too many channels: %u\n", __func__,
! 2247: param->channels);
! 2248: return EINVAL;
! 2249: }
! 2250: #endif
! 2251: ret |= param->channels - 1;
! 2252:
! 2253: switch (param->precision) {
! 2254: case 8:
! 2255: ret |= HDA_SD_FMT_BITS_8_16;
! 2256: break;
! 2257: case 16:
! 2258: ret |= HDA_SD_FMT_BITS_16_16;
! 2259: break;
! 2260: case 32:
! 2261: ret |= HDA_SD_FMT_BITS_32_32;
! 2262: break;
! 2263: }
! 2264:
! 2265: #if 0
! 2266: switch (param->validbits) {
! 2267: case 8:
! 2268: ret |= HDA_SD_FMT_BITS_8_16;
! 2269: break;
! 2270: case 16:
! 2271: ret |= HDA_SD_FMT_BITS_16_16;
! 2272: break;
! 2273: case 20:
! 2274: ret |= HDA_SD_FMT_BITS_20_32;
! 2275: break;
! 2276: case 24:
! 2277: ret |= HDA_SD_FMT_BITS_24_32;
! 2278: break;
! 2279: case 32:
! 2280: ret |= HDA_SD_FMT_BITS_32_32;
! 2281: break;
! 2282: default:
! 2283: printf("%s: invalid validbits: %u\n", __func__,
! 2284: param->validbits);
! 2285: }
! 2286: #endif
! 2287:
! 2288: if (param->sample_rate == 384000) {
! 2289: printf("%s: invalid sample_rate: %u\n", __func__,
! 2290: param->sample_rate);
! 2291: return EINVAL;
! 2292: } else if (param->sample_rate == 192000) {
! 2293: ret |= HDA_SD_FMT_BASE_48 | HDA_SD_FMT_MULT_X4 | HDA_SD_FMT_DIV_BY1;
! 2294: } else if (param->sample_rate == 176400) {
! 2295: ret |= HDA_SD_FMT_BASE_44 | HDA_SD_FMT_MULT_X4 | HDA_SD_FMT_DIV_BY1;
! 2296: } else if (param->sample_rate == 96000) {
! 2297: ret |= HDA_SD_FMT_BASE_48 | HDA_SD_FMT_MULT_X2 | HDA_SD_FMT_DIV_BY1;
! 2298: } else if (param->sample_rate == 88200) {
! 2299: ret |= HDA_SD_FMT_BASE_44 | HDA_SD_FMT_MULT_X2 | HDA_SD_FMT_DIV_BY1;
! 2300: } else if (param->sample_rate == 48000) {
! 2301: ret |= HDA_SD_FMT_BASE_48 | HDA_SD_FMT_MULT_X1 | HDA_SD_FMT_DIV_BY1;
! 2302: } else if (param->sample_rate == 44100) {
! 2303: ret |= HDA_SD_FMT_BASE_44 | HDA_SD_FMT_MULT_X1 | HDA_SD_FMT_DIV_BY1;
! 2304: } else if (param->sample_rate == 32000) {
! 2305: ret |= HDA_SD_FMT_BASE_48 | HDA_SD_FMT_MULT_X2 | HDA_SD_FMT_DIV_BY3;
! 2306: } else if (param->sample_rate == 22050) {
! 2307: ret |= HDA_SD_FMT_BASE_44 | HDA_SD_FMT_MULT_X1 | HDA_SD_FMT_DIV_BY2;
! 2308: } else if (param->sample_rate == 16000) {
! 2309: ret |= HDA_SD_FMT_BASE_48 | HDA_SD_FMT_MULT_X1 | HDA_SD_FMT_DIV_BY3;
! 2310: } else if (param->sample_rate == 11025) {
! 2311: ret |= HDA_SD_FMT_BASE_44 | HDA_SD_FMT_MULT_X1 | HDA_SD_FMT_DIV_BY4;
! 2312: } else if (param->sample_rate == 8000) {
! 2313: ret |= HDA_SD_FMT_BASE_48 | HDA_SD_FMT_MULT_X1 | HDA_SD_FMT_DIV_BY6;
! 2314: } else {
! 2315: printf("%s: invalid sample_rate: %u\n", __func__,
! 2316: param->sample_rate);
! 2317: return EINVAL;
! 2318: }
! 2319: *fmt = ret;
! 2320: return 0;
! 2321: }
! 2322:
! 2323: int
! 2324: azalia_create_encodings(struct audio_format *formats, int nformats,
! 2325: struct audio_encoding_set **encodings)
! 2326: {
! 2327: #if 0
! 2328: int i;
! 2329: u_int j;
! 2330:
! 2331: for (i = 0; i < nformats; i++) {
! 2332: printf("format(%d): encoding %u vbits %u prec %u chans %u cmask 0x%x\n",
! 2333: i, formats[i].encoding, formats[i].validbits,
! 2334: formats[i].precision, formats[i].channels,
! 2335: formats[i].channel_mask);
! 2336: printf("format(%d) rates:", i);
! 2337: for (j = 0; j < formats[i].frequency_type; j++) {
! 2338: printf(" %u", formats[i].frequency[j]);
! 2339: }
! 2340: printf("\n");
! 2341: }
! 2342: #endif
! 2343: return (0);
! 2344: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to azalia.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pci