Annotation of sys/dev/pci/azalia_codec.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: azalia_codec.c,v 1.29 2007/07/31 17:06:25 deanna Exp $ */
! 2: /* $NetBSD: azalia_codec.c,v 1.8 2006/05/10 11:17:27 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: #include <sys/cdefs.h>
! 41: #ifdef NETBSD_GOOP
! 42: __KERNEL_RCSID(0, "$NetBSD: azalia_codec.c,v 1.3 2005/09/29 04:14:03 kent Exp $");
! 43: #endif
! 44:
! 45: #include <sys/param.h>
! 46: #include <sys/device.h>
! 47: #include <sys/malloc.h>
! 48: #include <sys/systm.h>
! 49: #include <uvm/uvm_param.h>
! 50: #include <dev/pci/azalia.h>
! 51:
! 52: #define XNAME(co) (((struct device *)co->az)->dv_xname)
! 53: #ifdef MAX_VOLUME_255
! 54: # define MIXER_DELTA(n) (AUDIO_MAX_GAIN / (n))
! 55: #else
! 56: # define MIXER_DELTA(n) (1)
! 57: #endif
! 58: #define AZ_CLASS_INPUT 0
! 59: #define AZ_CLASS_OUTPUT 1
! 60: #define AZ_CLASS_RECORD 2
! 61: #define ENUM_OFFON .un.e={2, {{{AudioNoff}, 0}, {{AudioNon}, 1}}}
! 62: #define ENUM_IO .un.e={2, {{{"input"}, 0}, {{"output"}, 1}}}
! 63: #define AzaliaNfront "front"
! 64: #define AzaliaNclfe "clfe"
! 65: #define AzaliaNside "side"
! 66:
! 67:
! 68: int azalia_generic_codec_init_dacgroup(codec_t *);
! 69: int azalia_generic_codec_add_dacgroup(codec_t *, int, uint32_t);
! 70: int azalia_generic_codec_find_pin(const codec_t *, int, int, uint32_t);
! 71: int azalia_generic_codec_find_dac(const codec_t *, int, int);
! 72:
! 73: int azalia_generic_mixer_init(codec_t *);
! 74: int azalia_generic_mixer_fix_indexes(codec_t *);
! 75: int azalia_generic_mixer_default(codec_t *);
! 76: int azalia_generic_mixer_delete(codec_t *);
! 77: int azalia_generic_mixer_ensure_capacity(codec_t *, size_t);
! 78: int azalia_generic_mixer_get(const codec_t *, nid_t, int, mixer_ctrl_t *);
! 79: int azalia_generic_mixer_set(codec_t *, nid_t, int, const mixer_ctrl_t *);
! 80: int azalia_generic_mixer_pinctrl(codec_t *, nid_t, uint32_t);
! 81: u_char azalia_generic_mixer_from_device_value
! 82: (const codec_t *, nid_t, int, uint32_t );
! 83: uint32_t azalia_generic_mixer_to_device_value
! 84: (const codec_t *, nid_t, int, u_char);
! 85: uint32_t azalia_generic_mixer_max(const codec_t *, nid_t, int);
! 86: boolean_t azalia_generic_mixer_validate_value
! 87: (const codec_t *, nid_t, int, u_char);
! 88: int azalia_generic_set_port(codec_t *, mixer_ctrl_t *);
! 89: int azalia_generic_get_port(codec_t *, mixer_ctrl_t *);
! 90:
! 91: int azalia_alc260_init_dacgroup(codec_t *);
! 92: int azalia_alc260_mixer_init(codec_t *);
! 93: int azalia_alc260_set_port(codec_t *, mixer_ctrl_t *);
! 94: int azalia_alc880_init_dacgroup(codec_t *);
! 95: int azalia_alc882_init_dacgroup(codec_t *);
! 96: int azalia_alc882_mixer_init(codec_t *);
! 97: int azalia_alc882_set_port(codec_t *, mixer_ctrl_t *);
! 98: int azalia_alc882_get_port(codec_t *, mixer_ctrl_t *);
! 99: int azalia_alc883_init_dacgroup(codec_t *);
! 100: int azalia_alc883_mixer_init(codec_t *);
! 101: int azalia_ad1981hd_init_widget(const codec_t *, widget_t *, nid_t);
! 102: int azalia_ad1981hd_mixer_init(codec_t *);
! 103: int azalia_cmi9880_init_dacgroup(codec_t *);
! 104: int azalia_cmi9880_mixer_init(codec_t *);
! 105: int azalia_stac9221_init_dacgroup(codec_t *);
! 106: int azalia_stac9200_mixer_init(codec_t *);
! 107: int azalia_stac9200_unsol_event(codec_t *, int);
! 108: int azalia_stac9221_apple_mixer_init(codec_t *);
! 109: int azalia_stac9221_apple_init_dacgroup(codec_t *);
! 110: int azalia_stac9221_gpio_unmute(codec_t *, int);
! 111: int azalia_stac7661_init_dacgroup(codec_t *);
! 112: int azalia_stac7661_mixer_init(codec_t *);
! 113: int azalia_stac7661_set_port(codec_t *, mixer_ctrl_t *);
! 114: int azalia_stac7661_get_port(codec_t *, mixer_ctrl_t *);
! 115:
! 116: int
! 117: azalia_codec_init_vtbl(codec_t *this)
! 118: {
! 119: /**
! 120: * We can refer this->vid and this->subid.
! 121: */
! 122: DPRINTF(("%s: vid=%08x subid=%08x\n", __func__, this->vid, this->subid));
! 123: this->name = NULL;
! 124: this->init_dacgroup = azalia_generic_codec_init_dacgroup;
! 125: this->mixer_init = azalia_generic_mixer_init;
! 126: this->mixer_delete = azalia_generic_mixer_delete;
! 127: this->set_port = azalia_generic_set_port;
! 128: this->get_port = azalia_generic_get_port;
! 129: switch (this->vid) {
! 130: case 0x10ec0260:
! 131: this->name = "Realtek ALC260";
! 132: this->mixer_init = azalia_alc260_mixer_init;
! 133: this->init_dacgroup = azalia_alc260_init_dacgroup;
! 134: this->set_port = azalia_alc260_set_port;
! 135: break;
! 136: case 0x10ec0880:
! 137: this->name = "Realtek ALC880";
! 138: this->init_dacgroup = azalia_alc880_init_dacgroup;
! 139: break;
! 140: case 0x10ec0882:
! 141: this->name = "Realtek ALC882";
! 142: this->init_dacgroup = azalia_alc882_init_dacgroup;
! 143: this->mixer_init = azalia_alc882_mixer_init;
! 144: this->get_port = azalia_alc882_get_port;
! 145: this->set_port = azalia_alc882_set_port;
! 146: break;
! 147: case 0x10ec0883:
! 148: /* ftp://209.216.61.149/pc/audio/ALC883_DataSheet_1.3.pdf */
! 149: this->name = "Realtek ALC883";
! 150: this->init_dacgroup = azalia_alc883_init_dacgroup;
! 151: this->mixer_init = azalia_alc883_mixer_init;
! 152: this->get_port = azalia_alc882_get_port;
! 153: this->set_port = azalia_alc882_set_port;
! 154: break;
! 155: case 0x11d41981:
! 156: /* http://www.analog.com/en/prod/0,2877,AD1981HD,00.html */
! 157: this->name = "Analog Devices AD1981HD";
! 158: this->init_widget = azalia_ad1981hd_init_widget;
! 159: this->mixer_init = azalia_ad1981hd_mixer_init;
! 160: break;
! 161: case 0x11d41983:
! 162: /* http://www.analog.com/en/prod/0,2877,AD1983,00.html */
! 163: this->name = "Analog Devices AD1983";
! 164: break;
! 165: case 0x434d4980:
! 166: this->name = "CMedia CMI9880";
! 167: this->init_dacgroup = azalia_cmi9880_init_dacgroup;
! 168: this->mixer_init = azalia_cmi9880_mixer_init;
! 169: break;
! 170: case 0x83847680:
! 171: this->name = "Sigmatel STAC9221";
! 172: this->init_dacgroup = azalia_stac9221_init_dacgroup;
! 173: if (this->subid == 0x76808384) {
! 174: this->init_dacgroup =
! 175: azalia_stac9221_apple_init_dacgroup;
! 176: this->mixer_init =
! 177: azalia_stac9221_apple_mixer_init;
! 178: break;
! 179: }
! 180: break;
! 181: case 0x83847683:
! 182: this->name = "Sigmatel STAC9221D";
! 183: this->init_dacgroup = azalia_stac9221_init_dacgroup;
! 184: break;
! 185: case 0x83847690:
! 186: /* http://www.idt.com/products/getDoc.cfm?docID=17812077 */
! 187: this->name = "Sigmatel STAC9200";
! 188: this->mixer_init = azalia_stac9200_mixer_init;
! 189: this->unsol_event = azalia_stac9200_unsol_event;
! 190: break;
! 191: case 0x83847691:
! 192: this->name = "Sigmatel STAC9200D";
! 193: break;
! 194: case 0x83847661:
! 195: this->name = "Sigmatel 83847661";
! 196: this->init_dacgroup = azalia_stac7661_init_dacgroup;
! 197: this->mixer_init = azalia_stac7661_mixer_init;
! 198: this->get_port = azalia_stac7661_get_port;
! 199: this->set_port = azalia_stac7661_set_port;
! 200: break;
! 201: }
! 202: return 0;
! 203: }
! 204:
! 205: /* ----------------------------------------------------------------
! 206: * functions for generic codecs
! 207: * ---------------------------------------------------------------- */
! 208:
! 209: int
! 210: azalia_generic_codec_init_dacgroup(codec_t *this)
! 211: {
! 212: int i, j, assoc, group;
! 213:
! 214: /*
! 215: * grouping DACs
! 216: * [0] the lowest assoc DACs
! 217: * [1] the lowest assoc digital outputs
! 218: * [2] the 2nd assoc DACs
! 219: * :
! 220: */
! 221: this->dacs.ngroups = 0;
! 222: for (assoc = 0; assoc < CORB_CD_ASSOCIATION_MAX; assoc++) {
! 223: azalia_generic_codec_add_dacgroup(this, assoc, 0);
! 224: azalia_generic_codec_add_dacgroup(this, assoc, COP_AWCAP_DIGITAL);
! 225: }
! 226:
! 227: /* find DACs which do not connect with any pins by default */
! 228: DPRINTF(("%s: find non-connected DACs\n", __func__));
! 229: FOR_EACH_WIDGET(this, i) {
! 230: boolean_t found;
! 231:
! 232: if (this->w[i].type != COP_AWTYPE_AUDIO_OUTPUT)
! 233: continue;
! 234: found = FALSE;
! 235: for (group = 0; group < this->dacs.ngroups; group++) {
! 236: for (j = 0; j < this->dacs.groups[group].nconv; j++) {
! 237: if (i == this->dacs.groups[group].conv[j]) {
! 238: found = TRUE;
! 239: group = this->dacs.ngroups;
! 240: break;
! 241: }
! 242: }
! 243: }
! 244: if (found)
! 245: continue;
! 246: if (this->dacs.ngroups >= 32)
! 247: break;
! 248: this->dacs.groups[this->dacs.ngroups].nconv = 1;
! 249: this->dacs.groups[this->dacs.ngroups].conv[0] = i;
! 250: this->dacs.ngroups++;
! 251: }
! 252: this->dacs.cur = 0;
! 253:
! 254: /* enumerate ADCs */
! 255: this->adcs.ngroups = 0;
! 256: FOR_EACH_WIDGET(this, i) {
! 257: if (this->w[i].type != COP_AWTYPE_AUDIO_INPUT)
! 258: continue;
! 259: this->adcs.groups[this->adcs.ngroups].nconv = 1;
! 260: this->adcs.groups[this->adcs.ngroups].conv[0] = i;
! 261: this->adcs.ngroups++;
! 262: if (this->adcs.ngroups >= 32)
! 263: break;
! 264: }
! 265: this->adcs.cur = 0;
! 266: return 0;
! 267: }
! 268:
! 269: int
! 270: azalia_generic_codec_add_dacgroup(codec_t *this, int assoc, uint32_t digital)
! 271: {
! 272: int i, j, n, dac, seq;
! 273:
! 274: n = 0;
! 275: for (seq = 0 ; seq < CORB_CD_SEQUENCE_MAX; seq++) {
! 276: i = azalia_generic_codec_find_pin(this, assoc, seq, digital);
! 277: if (i < 0)
! 278: continue;
! 279: dac = azalia_generic_codec_find_dac(this, i, 0);
! 280: if (dac < 0)
! 281: continue;
! 282: /* duplication check */
! 283: for (j = 0; j < n; j++) {
! 284: if (this->dacs.groups[this->dacs.ngroups].conv[j] == dac)
! 285: break;
! 286: }
! 287: if (j < n) /* this group already has <dac> */
! 288: continue;
! 289: this->dacs.groups[this->dacs.ngroups].conv[n++] = dac;
! 290: DPRINTF(("%s: assoc=%d seq=%d ==> g=%d n=%d\n",
! 291: __func__, assoc, seq, this->dacs.ngroups, n-1));
! 292: }
! 293: if (n <= 0) /* no such DACs */
! 294: return 0;
! 295: this->dacs.groups[this->dacs.ngroups].nconv = n;
! 296:
! 297: /* check if the same combination is already registered */
! 298: for (i = 0; i < this->dacs.ngroups; i++) {
! 299: if (n != this->dacs.groups[i].nconv)
! 300: continue;
! 301: for (j = 0; j < n; j++) {
! 302: if (this->dacs.groups[this->dacs.ngroups].conv[j] !=
! 303: this->dacs.groups[i].conv[j])
! 304: break;
! 305: }
! 306: if (j >= n) /* matched */
! 307: return 0;
! 308: }
! 309: /* found no equivalent group */
! 310: this->dacs.ngroups++;
! 311: return 0;
! 312: }
! 313:
! 314: int
! 315: azalia_generic_codec_find_pin(const codec_t *this, int assoc, int seq, uint32_t digital)
! 316: {
! 317: int i;
! 318:
! 319: FOR_EACH_WIDGET(this, i) {
! 320: if (this->w[i].type != COP_AWTYPE_PIN_COMPLEX)
! 321: continue;
! 322: if ((this->w[i].d.pin.cap & COP_PINCAP_OUTPUT) == 0)
! 323: continue;
! 324: if ((this->w[i].widgetcap & COP_AWCAP_DIGITAL) != digital)
! 325: continue;
! 326: if (this->w[i].d.pin.association != assoc)
! 327: continue;
! 328: if (this->w[i].d.pin.sequence == seq) {
! 329: return i;
! 330: }
! 331: }
! 332: return -1;
! 333: }
! 334:
! 335: int
! 336: azalia_generic_codec_find_dac(const codec_t *this, int index, int depth)
! 337: {
! 338: const widget_t *w;
! 339: int i, j, ret;
! 340:
! 341: w = &this->w[index];
! 342: if (w->type == COP_AWTYPE_AUDIO_OUTPUT) {
! 343: DPRINTF(("%s: DAC: nid=0x%x index=%d\n",
! 344: __func__, w->nid, index));
! 345: return index;
! 346: }
! 347: if (++depth > 50) {
! 348: return -1;
! 349: }
! 350: if (w->selected >= 0) {
! 351: j = w->connections[w->selected];
! 352: if (VALID_WIDGET_NID(j, this)) {
! 353: ret = azalia_generic_codec_find_dac(this, j, depth);
! 354: if (ret >= 0) {
! 355: DPRINTF(("%s: DAC path: nid=0x%x index=%d\n",
! 356: __func__, w->nid, index));
! 357: return ret;
! 358: }
! 359: }
! 360: }
! 361: for (i = 0; i < w->nconnections; i++) {
! 362: j = w->connections[i];
! 363: if (!VALID_WIDGET_NID(j, this))
! 364: continue;
! 365: ret = azalia_generic_codec_find_dac(this, j, depth);
! 366: if (ret >= 0) {
! 367: DPRINTF(("%s: DAC path: nid=0x%x index=%d\n",
! 368: __func__, w->nid, index));
! 369: return ret;
! 370: }
! 371: }
! 372: return -1;
! 373: }
! 374:
! 375: /* ----------------------------------------------------------------
! 376: * Generic mixer functions
! 377: * ---------------------------------------------------------------- */
! 378:
! 379: int
! 380: azalia_generic_mixer_init(codec_t *this)
! 381: {
! 382: /*
! 383: * pin "<color>%2.2x"
! 384: * audio output "dac%2.2x"
! 385: * audio input "adc%2.2x"
! 386: * mixer "mixer%2.2x"
! 387: * selector "sel%2.2x"
! 388: */
! 389: mixer_item_t *m;
! 390: int err, i, j, k;
! 391:
! 392: this->maxmixers = 10;
! 393: this->nmixers = 0;
! 394: this->mixers = malloc(sizeof(mixer_item_t) * this->maxmixers,
! 395: M_DEVBUF, M_NOWAIT);
! 396: if (this->mixers == NULL) {
! 397: printf("%s: out of memory in %s\n", XNAME(this), __func__);
! 398: return ENOMEM;
! 399: }
! 400: bzero(this->mixers, sizeof(mixer_item_t) * this->maxmixers);
! 401:
! 402: /* register classes */
! 403: DPRINTF(("%s: register classes\n", __func__));
! 404: m = &this->mixers[AZ_CLASS_INPUT];
! 405: m->devinfo.index = AZ_CLASS_INPUT;
! 406: strlcpy(m->devinfo.label.name, AudioCinputs,
! 407: sizeof(m->devinfo.label.name));
! 408: m->devinfo.type = AUDIO_MIXER_CLASS;
! 409: m->devinfo.mixer_class = AZ_CLASS_INPUT;
! 410: m->devinfo.next = AUDIO_MIXER_LAST;
! 411: m->devinfo.prev = AUDIO_MIXER_LAST;
! 412: m->nid = 0;
! 413:
! 414: m = &this->mixers[AZ_CLASS_OUTPUT];
! 415: m->devinfo.index = AZ_CLASS_OUTPUT;
! 416: strlcpy(m->devinfo.label.name, AudioCoutputs,
! 417: sizeof(m->devinfo.label.name));
! 418: m->devinfo.type = AUDIO_MIXER_CLASS;
! 419: m->devinfo.mixer_class = AZ_CLASS_OUTPUT;
! 420: m->devinfo.next = AUDIO_MIXER_LAST;
! 421: m->devinfo.prev = AUDIO_MIXER_LAST;
! 422: m->nid = 0;
! 423:
! 424: m = &this->mixers[AZ_CLASS_RECORD];
! 425: m->devinfo.index = AZ_CLASS_RECORD;
! 426: strlcpy(m->devinfo.label.name, AudioCrecord,
! 427: sizeof(m->devinfo.label.name));
! 428: m->devinfo.type = AUDIO_MIXER_CLASS;
! 429: m->devinfo.mixer_class = AZ_CLASS_RECORD;
! 430: m->devinfo.next = AUDIO_MIXER_LAST;
! 431: m->devinfo.prev = AUDIO_MIXER_LAST;
! 432: m->nid = 0;
! 433:
! 434: this->nmixers = AZ_CLASS_RECORD + 1;
! 435:
! 436: #define MIXER_REG_PROLOG \
! 437: mixer_devinfo_t *d; \
! 438: err = azalia_generic_mixer_ensure_capacity(this, this->nmixers + 1); \
! 439: if (err) \
! 440: return err; \
! 441: m = &this->mixers[this->nmixers]; \
! 442: d = &m->devinfo; \
! 443: m->nid = i
! 444:
! 445: FOR_EACH_WIDGET(this, i) {
! 446: const widget_t *w;
! 447:
! 448: w = &this->w[i];
! 449:
! 450: /* selector */
! 451: if (w->type != COP_AWTYPE_AUDIO_MIXER && w->nconnections >= 2) {
! 452: MIXER_REG_PROLOG;
! 453: DPRINTF(("%s: selector %s\n", __func__, w->name));
! 454: snprintf(d->label.name, sizeof(d->label.name),
! 455: "%s.source", w->name);
! 456: d->type = AUDIO_MIXER_ENUM;
! 457: if (w->type == COP_AWTYPE_AUDIO_MIXER)
! 458: d->mixer_class = AZ_CLASS_RECORD;
! 459: else if (w->type == COP_AWTYPE_AUDIO_SELECTOR)
! 460: d->mixer_class = AZ_CLASS_INPUT;
! 461: else
! 462: d->mixer_class = AZ_CLASS_OUTPUT;
! 463: m->target = MI_TARGET_CONNLIST;
! 464: for (j = 0, k = 0; j < w->nconnections && k < 32; j++) {
! 465: if (!VALID_WIDGET_NID(w->connections[j], this))
! 466: continue;
! 467: DPRINTF(("%s: selector %d=%s\n", __func__, j,
! 468: this->w[w->connections[j]].name));
! 469: d->un.e.member[k].ord = j;
! 470: strlcpy(d->un.e.member[k].label.name,
! 471: this->w[w->connections[j]].name,
! 472: MAX_AUDIO_DEV_LEN);
! 473: k++;
! 474: }
! 475: d->un.e.num_mem = k;
! 476: this->nmixers++;
! 477: }
! 478:
! 479: /* output mute */
! 480: if (w->widgetcap & COP_AWCAP_OUTAMP &&
! 481: w->outamp_cap & COP_AMPCAP_MUTE) {
! 482: MIXER_REG_PROLOG;
! 483: DPRINTF(("%s: output mute %s\n", __func__, w->name));
! 484: snprintf(d->label.name, sizeof(d->label.name),
! 485: "%s.mute", w->name);
! 486: d->type = AUDIO_MIXER_ENUM;
! 487: if (w->type == COP_AWTYPE_AUDIO_MIXER)
! 488: d->mixer_class = AZ_CLASS_OUTPUT;
! 489: else if (w->type == COP_AWTYPE_AUDIO_SELECTOR)
! 490: d->mixer_class = AZ_CLASS_OUTPUT;
! 491: else if (w->type == COP_AWTYPE_PIN_COMPLEX)
! 492: d->mixer_class = AZ_CLASS_OUTPUT;
! 493: else
! 494: d->mixer_class = AZ_CLASS_INPUT;
! 495: m->target = MI_TARGET_OUTAMP;
! 496: d->un.e.num_mem = 2;
! 497: d->un.e.member[0].ord = 0;
! 498: strlcpy(d->un.e.member[0].label.name, AudioNoff,
! 499: MAX_AUDIO_DEV_LEN);
! 500: d->un.e.member[1].ord = 1;
! 501: strlcpy(d->un.e.member[1].label.name, AudioNon,
! 502: MAX_AUDIO_DEV_LEN);
! 503: this->nmixers++;
! 504: }
! 505:
! 506: /* output gain */
! 507: if (w->widgetcap & COP_AWCAP_OUTAMP
! 508: && COP_AMPCAP_NUMSTEPS(w->outamp_cap)) {
! 509: MIXER_REG_PROLOG;
! 510: DPRINTF(("%s: output gain %s\n", __func__, w->name));
! 511: snprintf(d->label.name, sizeof(d->label.name),
! 512: "%s", w->name);
! 513: d->type = AUDIO_MIXER_VALUE;
! 514: if (w->type == COP_AWTYPE_AUDIO_MIXER)
! 515: d->mixer_class = AZ_CLASS_OUTPUT;
! 516: else if (w->type == COP_AWTYPE_AUDIO_SELECTOR)
! 517: d->mixer_class = AZ_CLASS_OUTPUT;
! 518: else if (w->type == COP_AWTYPE_PIN_COMPLEX)
! 519: d->mixer_class = AZ_CLASS_OUTPUT;
! 520: else
! 521: d->mixer_class = AZ_CLASS_INPUT;
! 522: m->target = MI_TARGET_OUTAMP;
! 523: d->un.v.num_channels = WIDGET_CHANNELS(w);
! 524: #ifdef MAX_VOLUME_255
! 525: d->un.v.units.name[0] = 0;
! 526: #else
! 527: snprintf(d->un.v.units.name, sizeof(d->un.v.units.name),
! 528: "0.25x%ddB", COP_AMPCAP_STEPSIZE(w->outamp_cap)+1);
! 529: #endif
! 530: d->un.v.delta =
! 531: MIXER_DELTA(COP_AMPCAP_NUMSTEPS(w->outamp_cap));
! 532: this->nmixers++;
! 533: }
! 534:
! 535: /* input mute */
! 536: if (w->widgetcap & COP_AWCAP_INAMP &&
! 537: w->inamp_cap & COP_AMPCAP_MUTE) {
! 538: DPRINTF(("%s: input mute %s\n", __func__, w->name));
! 539: if (w->type != COP_AWTYPE_AUDIO_SELECTOR &&
! 540: w->type != COP_AWTYPE_AUDIO_MIXER) {
! 541: MIXER_REG_PROLOG;
! 542: snprintf(d->label.name, sizeof(d->label.name),
! 543: "%s.mute", w->name);
! 544: d->type = AUDIO_MIXER_ENUM;
! 545: if (w->type == COP_AWTYPE_PIN_COMPLEX)
! 546: d->mixer_class = AZ_CLASS_OUTPUT;
! 547: else if (w->type == COP_AWTYPE_AUDIO_INPUT)
! 548: d->mixer_class = AZ_CLASS_RECORD;
! 549: else
! 550: d->mixer_class = AZ_CLASS_INPUT;
! 551: m->target = 0;
! 552: d->un.e.num_mem = 2;
! 553: d->un.e.member[0].ord = 0;
! 554: strlcpy(d->un.e.member[0].label.name,
! 555: AudioNoff, MAX_AUDIO_DEV_LEN);
! 556: d->un.e.member[1].ord = 1;
! 557: strlcpy(d->un.e.member[1].label.name,
! 558: AudioNon, MAX_AUDIO_DEV_LEN);
! 559: this->nmixers++;
! 560: } else {
! 561: for (j = 0; j < w->nconnections; j++) {
! 562: MIXER_REG_PROLOG;
! 563: if (!VALID_WIDGET_NID(w->connections[j], this))
! 564: continue;
! 565: DPRINTF(("%s: input mute %s.%s\n", __func__,
! 566: w->name, this->w[w->connections[j]].name));
! 567: snprintf(d->label.name, sizeof(d->label.name),
! 568: "%s.%s.mute", w->name,
! 569: this->w[w->connections[j]].name);
! 570: d->type = AUDIO_MIXER_ENUM;
! 571: if (w->type == COP_AWTYPE_PIN_COMPLEX)
! 572: d->mixer_class = AZ_CLASS_OUTPUT;
! 573: else if (w->type == COP_AWTYPE_AUDIO_INPUT)
! 574: d->mixer_class = AZ_CLASS_RECORD;
! 575: else
! 576: d->mixer_class = AZ_CLASS_INPUT;
! 577: m->target = j;
! 578: d->un.e.num_mem = 2;
! 579: d->un.e.member[0].ord = 0;
! 580: strlcpy(d->un.e.member[0].label.name,
! 581: AudioNoff, MAX_AUDIO_DEV_LEN);
! 582: d->un.e.member[1].ord = 1;
! 583: strlcpy(d->un.e.member[1].label.name,
! 584: AudioNon, MAX_AUDIO_DEV_LEN);
! 585: this->nmixers++;
! 586: }
! 587: }
! 588: }
! 589:
! 590: /* input gain */
! 591: if (w->widgetcap & COP_AWCAP_INAMP
! 592: && COP_AMPCAP_NUMSTEPS(w->inamp_cap)) {
! 593: DPRINTF(("%s: input gain %s\n", __func__, w->name));
! 594: if (w->type != COP_AWTYPE_AUDIO_SELECTOR &&
! 595: w->type != COP_AWTYPE_AUDIO_MIXER) {
! 596: MIXER_REG_PROLOG;
! 597: snprintf(d->label.name, sizeof(d->label.name),
! 598: "%s", w->name);
! 599: d->type = AUDIO_MIXER_VALUE;
! 600: if (w->type == COP_AWTYPE_PIN_COMPLEX)
! 601: d->mixer_class = AZ_CLASS_OUTPUT;
! 602: else if (w->type == COP_AWTYPE_AUDIO_INPUT)
! 603: d->mixer_class = AZ_CLASS_RECORD;
! 604: else
! 605: d->mixer_class = AZ_CLASS_INPUT;
! 606: m->target = 0;
! 607: d->un.v.num_channels = WIDGET_CHANNELS(w);
! 608: #ifdef MAX_VOLUME_255
! 609: d->un.v.units.name[0] = 0;
! 610: #else
! 611: snprintf(d->un.v.units.name,
! 612: sizeof(d->un.v.units.name), "0.25x%ddB",
! 613: COP_AMPCAP_STEPSIZE(w->inamp_cap)+1);
! 614: #endif
! 615: d->un.v.delta =
! 616: MIXER_DELTA(COP_AMPCAP_NUMSTEPS(w->inamp_cap));
! 617: this->nmixers++;
! 618: } else {
! 619: for (j = 0; j < w->nconnections; j++) {
! 620: MIXER_REG_PROLOG;
! 621: if (!VALID_WIDGET_NID(w->connections[j], this))
! 622: continue;
! 623: DPRINTF(("%s: input gain %s.%s\n", __func__,
! 624: w->name, this->w[w->connections[j]].name));
! 625: snprintf(d->label.name, sizeof(d->label.name),
! 626: "%s.%s", w->name,
! 627: this->w[w->connections[j]].name);
! 628: d->type = AUDIO_MIXER_VALUE;
! 629: if (w->type == COP_AWTYPE_PIN_COMPLEX)
! 630: d->mixer_class = AZ_CLASS_OUTPUT;
! 631: else if (w->type == COP_AWTYPE_AUDIO_INPUT)
! 632: d->mixer_class = AZ_CLASS_RECORD;
! 633: else
! 634: d->mixer_class = AZ_CLASS_INPUT;
! 635: m->target = j;
! 636: d->un.v.num_channels = WIDGET_CHANNELS(w);
! 637: #ifdef MAX_VOLUME_255
! 638: d->un.v.units.name[0] = 0;
! 639: #else
! 640: snprintf(d->un.v.units.name,
! 641: sizeof(d->un.v.units.name), "0.25x%ddB",
! 642: COP_AMPCAP_STEPSIZE(w->inamp_cap)+1);
! 643: #endif
! 644: d->un.v.delta =
! 645: MIXER_DELTA(COP_AMPCAP_NUMSTEPS(w->inamp_cap));
! 646: this->nmixers++;
! 647: }
! 648: }
! 649: }
! 650:
! 651: /* pin direction */
! 652: if (w->type == COP_AWTYPE_PIN_COMPLEX &&
! 653: w->d.pin.cap & COP_PINCAP_OUTPUT &&
! 654: w->d.pin.cap & COP_PINCAP_INPUT) {
! 655: MIXER_REG_PROLOG;
! 656: DPRINTF(("%s: pin dir %s\n", __func__, w->name));
! 657: snprintf(d->label.name, sizeof(d->label.name),
! 658: "%s.dir", w->name);
! 659: d->type = AUDIO_MIXER_ENUM;
! 660: d->mixer_class = AZ_CLASS_OUTPUT;
! 661: m->target = MI_TARGET_PINDIR;
! 662: d->un.e.num_mem = 2;
! 663: d->un.e.member[0].ord = 0;
! 664: strlcpy(d->un.e.member[0].label.name, AudioNinput,
! 665: MAX_AUDIO_DEV_LEN);
! 666: d->un.e.member[1].ord = 1;
! 667: strlcpy(d->un.e.member[1].label.name, AudioNoutput,
! 668: MAX_AUDIO_DEV_LEN);
! 669: this->nmixers++;
! 670: }
! 671:
! 672: /* pin headphone-boost */
! 673: if (w->type == COP_AWTYPE_PIN_COMPLEX &&
! 674: w->d.pin.cap & COP_PINCAP_HEADPHONE) {
! 675: MIXER_REG_PROLOG;
! 676: DPRINTF(("%s: hpboost %s\n", __func__, w->name));
! 677: snprintf(d->label.name, sizeof(d->label.name),
! 678: "%s.boost", w->name);
! 679: d->type = AUDIO_MIXER_ENUM;
! 680: d->mixer_class = AZ_CLASS_OUTPUT;
! 681: m->target = MI_TARGET_PINBOOST;
! 682: d->un.e.num_mem = 2;
! 683: d->un.e.member[0].ord = 0;
! 684: strlcpy(d->un.e.member[0].label.name, AudioNoff,
! 685: MAX_AUDIO_DEV_LEN);
! 686: d->un.e.member[1].ord = 1;
! 687: strlcpy(d->un.e.member[1].label.name, AudioNon,
! 688: MAX_AUDIO_DEV_LEN);
! 689: this->nmixers++;
! 690: }
! 691:
! 692: /* volume knob */
! 693: if (w->type == COP_AWTYPE_VOLUME_KNOB &&
! 694: w->d.volume.cap & COP_VKCAP_DELTA) {
! 695: MIXER_REG_PROLOG;
! 696: DPRINTF(("%s: volume knob %s\n", __func__, w->name));
! 697: strlcpy(d->label.name, w->name, sizeof(d->label.name));
! 698: d->type = AUDIO_MIXER_VALUE;
! 699: d->mixer_class = AZ_CLASS_OUTPUT;
! 700: m->target = MI_TARGET_VOLUME;
! 701: d->un.v.num_channels = 1;
! 702: d->un.v.units.name[0] = 0;
! 703: d->un.v.delta =
! 704: MIXER_DELTA(COP_VKCAP_NUMSTEPS(w->d.volume.cap));
! 705: this->nmixers++;
! 706: }
! 707: }
! 708:
! 709: /* if the codec has multiple DAC groups, create "inputs.usingdac" */
! 710: if (this->dacs.ngroups > 1) {
! 711: MIXER_REG_PROLOG;
! 712: DPRINTF(("%s: create inputs.usingdac\n", __func__));
! 713: strlcpy(d->label.name, "usingdac", sizeof(d->label.name));
! 714: d->type = AUDIO_MIXER_ENUM;
! 715: d->mixer_class = AZ_CLASS_INPUT;
! 716: m->target = MI_TARGET_DAC;
! 717: for (i = 0; i < this->dacs.ngroups && i < 32; i++) {
! 718: d->un.e.member[i].ord = i;
! 719: for (j = 0; j < this->dacs.groups[i].nconv; j++) {
! 720: if (j * 2 >= MAX_AUDIO_DEV_LEN)
! 721: break;
! 722: snprintf(d->un.e.member[i].label.name + j*2,
! 723: MAX_AUDIO_DEV_LEN - j*2, "%2.2x",
! 724: this->dacs.groups[i].conv[j]);
! 725: }
! 726: }
! 727: d->un.e.num_mem = i;
! 728: this->nmixers++;
! 729: }
! 730:
! 731: /* if the codec has multiple ADC groups, create "record.usingadc" */
! 732: if (this->adcs.ngroups > 1) {
! 733: MIXER_REG_PROLOG;
! 734: DPRINTF(("%s: create inputs.usingadc\n", __func__));
! 735: strlcpy(d->label.name, "usingadc", sizeof(d->label.name));
! 736: d->type = AUDIO_MIXER_ENUM;
! 737: d->mixer_class = AZ_CLASS_RECORD;
! 738: m->target = MI_TARGET_ADC;
! 739: for (i = 0; i < this->adcs.ngroups && i < 32; i++) {
! 740: d->un.e.member[i].ord = i;
! 741: for (j = 0; j < this->adcs.groups[i].nconv; j++) {
! 742: if (j * 2 >= MAX_AUDIO_DEV_LEN)
! 743: break;
! 744: snprintf(d->un.e.member[i].label.name + j*2,
! 745: MAX_AUDIO_DEV_LEN - j*2, "%2.2x",
! 746: this->adcs.groups[i].conv[j]);
! 747: }
! 748: }
! 749: d->un.e.num_mem = i;
! 750: this->nmixers++;
! 751: }
! 752:
! 753: azalia_generic_mixer_fix_indexes(this);
! 754: azalia_generic_mixer_default(this);
! 755: return 0;
! 756: }
! 757:
! 758: int
! 759: azalia_generic_mixer_ensure_capacity(codec_t *this, size_t newsize)
! 760: {
! 761: size_t newmax;
! 762: void *newbuf;
! 763:
! 764: if (this->maxmixers >= newsize)
! 765: return 0;
! 766: newmax = this->maxmixers + 10;
! 767: if (newmax < newsize)
! 768: newmax = newsize;
! 769: newbuf = malloc(sizeof(mixer_item_t) * newmax, M_DEVBUF, M_NOWAIT);
! 770: if (newbuf == NULL) {
! 771: printf("%s: out of memory in %s\n", XNAME(this), __func__);
! 772: return ENOMEM;
! 773: }
! 774: bzero(newbuf, sizeof(mixer_item_t) * newmax);
! 775: bcopy(this->mixers, newbuf, this->maxmixers * sizeof(mixer_item_t));
! 776: free(this->mixers, M_DEVBUF);
! 777: this->mixers = newbuf;
! 778: this->maxmixers = newmax;
! 779: return 0;
! 780: }
! 781:
! 782: int
! 783: azalia_generic_mixer_fix_indexes(codec_t *this)
! 784: {
! 785: int i;
! 786: mixer_devinfo_t *d;
! 787:
! 788: for (i = 0; i < this->nmixers; i++) {
! 789: d = &this->mixers[i].devinfo;
! 790: #ifdef DIAGNOSTIC
! 791: if (d->index != 0 && d->index != i)
! 792: printf("%s: index mismatch %d %d\n", __func__,
! 793: d->index, i);
! 794: #endif
! 795: d->index = i;
! 796: if (d->prev == 0)
! 797: d->prev = AUDIO_MIXER_LAST;
! 798: if (d->next == 0)
! 799: d->next = AUDIO_MIXER_LAST;
! 800: }
! 801: return 0;
! 802: }
! 803:
! 804: int
! 805: azalia_generic_mixer_default(codec_t *this)
! 806: {
! 807: int i;
! 808: mixer_item_t *m;
! 809: /* unmute all */
! 810: DPRINTF(("%s: unmute\n", __func__));
! 811: for (i = 0; i < this->nmixers; i++) {
! 812: mixer_ctrl_t mc;
! 813:
! 814: m = &this->mixers[i];
! 815: if (!IS_MI_TARGET_INAMP(m->target) &&
! 816: m->target != MI_TARGET_OUTAMP)
! 817: continue;
! 818: if (m->devinfo.type != AUDIO_MIXER_ENUM)
! 819: continue;
! 820: mc.dev = i;
! 821: mc.type = AUDIO_MIXER_ENUM;
! 822: mc.un.ord = 0;
! 823: azalia_generic_mixer_set(this, m->nid, m->target, &mc);
! 824: }
! 825:
! 826: /*
! 827: * For bidirectional pins,
! 828: * Output: lineout, speaker, headphone, spdifout, digitalout, other
! 829: * Input: others
! 830: */
! 831: DPRINTF(("%s: process bidirectional pins\n", __func__));
! 832: for (i = 0; i < this->nmixers; i++) {
! 833: mixer_ctrl_t mc;
! 834:
! 835: m = &this->mixers[i];
! 836: if (m->target != MI_TARGET_PINDIR)
! 837: continue;
! 838: mc.dev = i;
! 839: mc.type = AUDIO_MIXER_ENUM;
! 840: switch (this->w[m->nid].d.pin.device) {
! 841: case CORB_CD_LINEOUT:
! 842: case CORB_CD_SPEAKER:
! 843: case CORB_CD_HEADPHONE:
! 844: case CORB_CD_SPDIFOUT:
! 845: case CORB_CD_DIGITALOUT:
! 846: case CORB_CD_DEVICE_OTHER:
! 847: mc.un.ord = 1;
! 848: break;
! 849: default:
! 850: mc.un.ord = 0;
! 851: }
! 852: azalia_generic_mixer_set(this, m->nid, m->target, &mc);
! 853: }
! 854:
! 855: /* set unextreme volume */
! 856: DPRINTF(("%s: set volume\n", __func__));
! 857: for (i = 0; i < this->nmixers; i++) {
! 858: mixer_ctrl_t mc;
! 859:
! 860: m = &this->mixers[i];
! 861: if (!IS_MI_TARGET_INAMP(m->target) &&
! 862: m->target != MI_TARGET_OUTAMP &&
! 863: m->target != MI_TARGET_VOLUME)
! 864: continue;
! 865: if (m->devinfo.type != AUDIO_MIXER_VALUE)
! 866: continue;
! 867: mc.dev = i;
! 868: mc.type = AUDIO_MIXER_VALUE;
! 869: mc.un.value.num_channels = 1;
! 870: mc.un.value.level[0] = AUDIO_MAX_GAIN / 2;
! 871: if (m->target != MI_TARGET_VOLUME &&
! 872: WIDGET_CHANNELS(&this->w[m->nid]) == 2) {
! 873: mc.un.value.num_channels = 2;
! 874: mc.un.value.level[1] = AUDIO_MAX_GAIN / 2;
! 875: }
! 876: azalia_generic_mixer_set(this, m->nid, m->target, &mc);
! 877: }
! 878:
! 879: return 0;
! 880: }
! 881:
! 882: int
! 883: azalia_generic_mixer_delete(codec_t *this)
! 884: {
! 885: if (this->mixers == NULL)
! 886: return 0;
! 887: free(this->mixers, M_DEVBUF);
! 888: this->mixers = NULL;
! 889: return 0;
! 890: }
! 891:
! 892: /**
! 893: * @param mc mc->type must be set by the caller before the call
! 894: */
! 895: int
! 896: azalia_generic_mixer_get(const codec_t *this, nid_t nid, int target, mixer_ctrl_t *mc)
! 897: {
! 898: uint32_t result;
! 899: nid_t n;
! 900: int err;
! 901:
! 902: /* inamp mute */
! 903: if (IS_MI_TARGET_INAMP(target) && mc->type == AUDIO_MIXER_ENUM) {
! 904: err = this->comresp(this, nid, CORB_GET_AMPLIFIER_GAIN_MUTE,
! 905: CORB_GAGM_INPUT | CORB_GAGM_LEFT |
! 906: MI_TARGET_INAMP(target), &result);
! 907: if (err)
! 908: return err;
! 909: mc->un.ord = result & CORB_GAGM_MUTE ? 1 : 0;
! 910: }
! 911:
! 912: /* inamp gain */
! 913: else if (IS_MI_TARGET_INAMP(target) && mc->type == AUDIO_MIXER_VALUE) {
! 914: err = this->comresp(this, nid, CORB_GET_AMPLIFIER_GAIN_MUTE,
! 915: CORB_GAGM_INPUT | CORB_GAGM_LEFT |
! 916: MI_TARGET_INAMP(target), &result);
! 917: if (err)
! 918: return err;
! 919: mc->un.value.level[0] = azalia_generic_mixer_from_device_value(this,
! 920: nid, target, CORB_GAGM_GAIN(result));
! 921: if (this->w[nid].type == COP_AWTYPE_AUDIO_SELECTOR ||
! 922: this->w[nid].type == COP_AWTYPE_AUDIO_MIXER) {
! 923: n = this->w[nid].connections[MI_TARGET_INAMP(target)];
! 924: #ifdef AZALIA_DEBUG
! 925: if (!VALID_WIDGET_NID(n, this)) {
! 926: DPRINTF(("%s: invalid target: nid=%d nconn=%d index=%d\n",
! 927: __func__, nid, this->w[nid].nconnections,
! 928: MI_TARGET_INAMP(target)));
! 929: return EINVAL;
! 930: }
! 931: #endif
! 932: } else
! 933: n = nid;
! 934: mc->un.value.num_channels = WIDGET_CHANNELS(&this->w[n]);
! 935: if (mc->un.value.num_channels == 2) {
! 936: err = this->comresp(this, nid,
! 937: CORB_GET_AMPLIFIER_GAIN_MUTE, CORB_GAGM_INPUT |
! 938: CORB_GAGM_RIGHT | MI_TARGET_INAMP(target),
! 939: &result);
! 940: if (err)
! 941: return err;
! 942: mc->un.value.level[1] = azalia_generic_mixer_from_device_value
! 943: (this, nid, target, CORB_GAGM_GAIN(result));
! 944: }
! 945: }
! 946:
! 947: /* outamp mute */
! 948: else if (target == MI_TARGET_OUTAMP && mc->type == AUDIO_MIXER_ENUM) {
! 949: err = this->comresp(this, nid, CORB_GET_AMPLIFIER_GAIN_MUTE,
! 950: CORB_GAGM_OUTPUT | CORB_GAGM_LEFT | 0, &result);
! 951: if (err)
! 952: return err;
! 953: mc->un.ord = result & CORB_GAGM_MUTE ? 1 : 0;
! 954: }
! 955:
! 956: /* outamp gain */
! 957: else if (target == MI_TARGET_OUTAMP && mc->type == AUDIO_MIXER_VALUE) {
! 958: err = this->comresp(this, nid, CORB_GET_AMPLIFIER_GAIN_MUTE,
! 959: CORB_GAGM_OUTPUT | CORB_GAGM_LEFT | 0, &result);
! 960: if (err)
! 961: return err;
! 962: mc->un.value.level[0] = azalia_generic_mixer_from_device_value(this,
! 963: nid, target, CORB_GAGM_GAIN(result));
! 964: mc->un.value.num_channels = WIDGET_CHANNELS(&this->w[nid]);
! 965: if (mc->un.value.num_channels == 2) {
! 966: err = this->comresp(this, nid,
! 967: CORB_GET_AMPLIFIER_GAIN_MUTE,
! 968: CORB_GAGM_OUTPUT | CORB_GAGM_RIGHT | 0, &result);
! 969: if (err)
! 970: return err;
! 971: mc->un.value.level[1] = azalia_generic_mixer_from_device_value
! 972: (this, nid, target, CORB_GAGM_GAIN(result));
! 973: }
! 974: }
! 975:
! 976: /* selection */
! 977: else if (target == MI_TARGET_CONNLIST) {
! 978: err = this->comresp(this, nid,
! 979: CORB_GET_CONNECTION_SELECT_CONTROL, 0, &result);
! 980: if (err)
! 981: return err;
! 982: result = CORB_CSC_INDEX(result);
! 983: if (!VALID_WIDGET_NID(this->w[nid].connections[result], this))
! 984: mc->un.ord = -1;
! 985: else
! 986: mc->un.ord = result;
! 987: }
! 988:
! 989: /* pin I/O */
! 990: else if (target == MI_TARGET_PINDIR) {
! 991: err = this->comresp(this, nid,
! 992: CORB_GET_PIN_WIDGET_CONTROL, 0, &result);
! 993: if (err)
! 994: return err;
! 995: mc->un.ord = result & CORB_PWC_OUTPUT ? 1 : 0;
! 996: }
! 997:
! 998: /* pin headphone-boost */
! 999: else if (target == MI_TARGET_PINBOOST) {
! 1000: err = this->comresp(this, nid,
! 1001: CORB_GET_PIN_WIDGET_CONTROL, 0, &result);
! 1002: if (err)
! 1003: return err;
! 1004: mc->un.ord = result & CORB_PWC_HEADPHONE ? 1 : 0;
! 1005: }
! 1006:
! 1007: /* DAC group selection */
! 1008: else if (target == MI_TARGET_DAC) {
! 1009: mc->un.ord = this->dacs.cur;
! 1010: }
! 1011:
! 1012: /* ADC selection */
! 1013: else if (target == MI_TARGET_ADC) {
! 1014: mc->un.ord = this->adcs.cur;
! 1015: }
! 1016:
! 1017: /* Volume knob */
! 1018: else if (target == MI_TARGET_VOLUME) {
! 1019: err = this->comresp(this, nid, CORB_GET_VOLUME_KNOB,
! 1020: 0, &result);
! 1021: if (err)
! 1022: return err;
! 1023: mc->un.value.level[0] = azalia_generic_mixer_from_device_value(this,
! 1024: nid, target, CORB_VKNOB_VOLUME(result));
! 1025: mc->un.value.num_channels = 1;
! 1026: }
! 1027:
! 1028: else {
! 1029: printf("%s: internal error in %s: target=%x\n",
! 1030: XNAME(this), __func__, target);
! 1031: return -1;
! 1032: }
! 1033: return 0;
! 1034: }
! 1035:
! 1036: int
! 1037: azalia_generic_mixer_set(codec_t *this, nid_t nid, int target, const mixer_ctrl_t *mc)
! 1038: {
! 1039: uint32_t result, value;
! 1040: int err;
! 1041:
! 1042: /* inamp mute */
! 1043: if (IS_MI_TARGET_INAMP(target) && mc->type == AUDIO_MIXER_ENUM) {
! 1044: /* We have to set stereo mute separately to keep each gain value. */
! 1045: err = this->comresp(this, nid, CORB_GET_AMPLIFIER_GAIN_MUTE,
! 1046: CORB_GAGM_INPUT | CORB_GAGM_LEFT |
! 1047: MI_TARGET_INAMP(target), &result);
! 1048: if (err)
! 1049: return err;
! 1050: value = CORB_AGM_INPUT | CORB_AGM_LEFT |
! 1051: (target << CORB_AGM_INDEX_SHIFT) |
! 1052: CORB_GAGM_GAIN(result);
! 1053: if (mc->un.ord)
! 1054: value |= CORB_AGM_MUTE;
! 1055: err = this->comresp(this, nid, CORB_SET_AMPLIFIER_GAIN_MUTE,
! 1056: value, &result);
! 1057: if (err)
! 1058: return err;
! 1059: if (WIDGET_CHANNELS(&this->w[nid]) == 2) {
! 1060: err = this->comresp(this, nid,
! 1061: CORB_GET_AMPLIFIER_GAIN_MUTE, CORB_GAGM_INPUT |
! 1062: CORB_GAGM_RIGHT | MI_TARGET_INAMP(target),
! 1063: &result);
! 1064: if (err)
! 1065: return err;
! 1066: value = CORB_AGM_INPUT | CORB_AGM_RIGHT |
! 1067: (target << CORB_AGM_INDEX_SHIFT) |
! 1068: CORB_GAGM_GAIN(result);
! 1069: if (mc->un.ord)
! 1070: value |= CORB_AGM_MUTE;
! 1071: err = this->comresp(this, nid,
! 1072: CORB_SET_AMPLIFIER_GAIN_MUTE, value, &result);
! 1073: if (err)
! 1074: return err;
! 1075: }
! 1076: }
! 1077:
! 1078: /* inamp gain */
! 1079: else if (IS_MI_TARGET_INAMP(target) && mc->type == AUDIO_MIXER_VALUE) {
! 1080: if (mc->un.value.num_channels < 1)
! 1081: return EINVAL;
! 1082: if (!azalia_generic_mixer_validate_value(this, nid, target,
! 1083: mc->un.value.level[0]))
! 1084: return EINVAL;
! 1085: err = this->comresp(this, nid, CORB_GET_AMPLIFIER_GAIN_MUTE,
! 1086: CORB_GAGM_INPUT | CORB_GAGM_LEFT |
! 1087: MI_TARGET_INAMP(target), &result);
! 1088: if (err)
! 1089: return err;
! 1090: value = azalia_generic_mixer_to_device_value(this, nid, target,
! 1091: mc->un.value.level[0]);
! 1092: value = CORB_AGM_INPUT | CORB_AGM_LEFT |
! 1093: (target << CORB_AGM_INDEX_SHIFT) |
! 1094: (result & CORB_GAGM_MUTE ? CORB_AGM_MUTE : 0) |
! 1095: (value & CORB_AGM_GAIN_MASK);
! 1096: err = this->comresp(this, nid, CORB_SET_AMPLIFIER_GAIN_MUTE,
! 1097: value, &result);
! 1098: if (err)
! 1099: return err;
! 1100: if (mc->un.value.num_channels >= 2 &&
! 1101: WIDGET_CHANNELS(&this->w[nid]) == 2) {
! 1102: if (!azalia_generic_mixer_validate_value(this, nid, target,
! 1103: mc->un.value.level[1]))
! 1104: return EINVAL;
! 1105: err = this->comresp(this, nid,
! 1106: CORB_GET_AMPLIFIER_GAIN_MUTE, CORB_GAGM_INPUT |
! 1107: CORB_GAGM_RIGHT | MI_TARGET_INAMP(target),
! 1108: &result);
! 1109: if (err)
! 1110: return err;
! 1111: value = azalia_generic_mixer_to_device_value(this, nid, target,
! 1112: mc->un.value.level[1]);
! 1113: value = CORB_AGM_INPUT | CORB_AGM_RIGHT |
! 1114: (target << CORB_AGM_INDEX_SHIFT) |
! 1115: (result & CORB_GAGM_MUTE ? CORB_AGM_MUTE : 0) |
! 1116: (value & CORB_AGM_GAIN_MASK);
! 1117: err = this->comresp(this, nid,
! 1118: CORB_SET_AMPLIFIER_GAIN_MUTE, value, &result);
! 1119: if (err)
! 1120: return err;
! 1121: }
! 1122: }
! 1123:
! 1124: /* outamp mute */
! 1125: else if (target == MI_TARGET_OUTAMP && mc->type == AUDIO_MIXER_ENUM) {
! 1126: err = this->comresp(this, nid, CORB_GET_AMPLIFIER_GAIN_MUTE,
! 1127: CORB_GAGM_OUTPUT | CORB_GAGM_LEFT, &result);
! 1128: if (err)
! 1129: return err;
! 1130: value = CORB_AGM_OUTPUT | CORB_AGM_LEFT | CORB_GAGM_GAIN(result);
! 1131: if (mc->un.ord)
! 1132: value |= CORB_AGM_MUTE;
! 1133: err = this->comresp(this, nid, CORB_SET_AMPLIFIER_GAIN_MUTE,
! 1134: value, &result);
! 1135: if (err)
! 1136: return err;
! 1137: if (WIDGET_CHANNELS(&this->w[nid]) == 2) {
! 1138: err = this->comresp(this, nid,
! 1139: CORB_GET_AMPLIFIER_GAIN_MUTE,
! 1140: CORB_GAGM_OUTPUT | CORB_GAGM_RIGHT, &result);
! 1141: if (err)
! 1142: return err;
! 1143: value = CORB_AGM_OUTPUT | CORB_AGM_RIGHT |
! 1144: CORB_GAGM_GAIN(result);
! 1145: if (mc->un.ord)
! 1146: value |= CORB_AGM_MUTE;
! 1147: err = this->comresp(this, nid,
! 1148: CORB_SET_AMPLIFIER_GAIN_MUTE, value, &result);
! 1149: if (err)
! 1150: return err;
! 1151: }
! 1152: }
! 1153:
! 1154: /* outamp gain */
! 1155: else if (target == MI_TARGET_OUTAMP && mc->type == AUDIO_MIXER_VALUE) {
! 1156: if (mc->un.value.num_channels < 1)
! 1157: return EINVAL;
! 1158: if (!azalia_generic_mixer_validate_value(this, nid, target,
! 1159: mc->un.value.level[0]))
! 1160: return EINVAL;
! 1161: err = this->comresp(this, nid, CORB_GET_AMPLIFIER_GAIN_MUTE,
! 1162: CORB_GAGM_OUTPUT | CORB_GAGM_LEFT, &result);
! 1163: if (err)
! 1164: return err;
! 1165: value = azalia_generic_mixer_to_device_value(this, nid, target,
! 1166: mc->un.value.level[0]);
! 1167: value = CORB_AGM_OUTPUT | CORB_AGM_LEFT |
! 1168: (result & CORB_GAGM_MUTE ? CORB_AGM_MUTE : 0) |
! 1169: (value & CORB_AGM_GAIN_MASK);
! 1170: err = this->comresp(this, nid, CORB_SET_AMPLIFIER_GAIN_MUTE,
! 1171: value, &result);
! 1172: if (err)
! 1173: return err;
! 1174: if (mc->un.value.num_channels >= 2 &&
! 1175: WIDGET_CHANNELS(&this->w[nid]) == 2) {
! 1176: if (!azalia_generic_mixer_validate_value(this, nid, target,
! 1177: mc->un.value.level[1]))
! 1178: return EINVAL;
! 1179: err = this->comresp(this, nid,
! 1180: CORB_GET_AMPLIFIER_GAIN_MUTE, CORB_GAGM_OUTPUT |
! 1181: CORB_GAGM_RIGHT, &result);
! 1182: if (err)
! 1183: return err;
! 1184: value = azalia_generic_mixer_to_device_value(this, nid, target,
! 1185: mc->un.value.level[1]);
! 1186: value = CORB_AGM_OUTPUT | CORB_AGM_RIGHT |
! 1187: (result & CORB_GAGM_MUTE ? CORB_AGM_MUTE : 0) |
! 1188: (value & CORB_AGM_GAIN_MASK);
! 1189: err = this->comresp(this, nid,
! 1190: CORB_SET_AMPLIFIER_GAIN_MUTE, value, &result);
! 1191: if (err)
! 1192: return err;
! 1193: }
! 1194: }
! 1195:
! 1196: /* selection */
! 1197: else if (target == MI_TARGET_CONNLIST) {
! 1198: if (mc->un.ord < 0 ||
! 1199: mc->un.ord >= this->w[nid].nconnections ||
! 1200: !VALID_WIDGET_NID(this->w[nid].connections[mc->un.ord], this))
! 1201: return EINVAL;
! 1202: err = this->comresp(this, nid,
! 1203: CORB_SET_CONNECTION_SELECT_CONTROL, mc->un.ord, &result);
! 1204: if (err)
! 1205: return err;
! 1206: }
! 1207:
! 1208: /* pin I/O */
! 1209: else if (target == MI_TARGET_PINDIR) {
! 1210: if (mc->un.ord >= 2)
! 1211: return EINVAL;
! 1212: err = this->comresp(this, nid,
! 1213: CORB_GET_PIN_WIDGET_CONTROL, 0, &result);
! 1214: if (err)
! 1215: return err;
! 1216: if (mc->un.ord == 0) {
! 1217: result &= ~CORB_PWC_OUTPUT;
! 1218: result |= CORB_PWC_INPUT;
! 1219: } else {
! 1220: result &= ~CORB_PWC_INPUT;
! 1221: result |= CORB_PWC_OUTPUT;
! 1222: }
! 1223: err = this->comresp(this, nid,
! 1224: CORB_SET_PIN_WIDGET_CONTROL, result, &result);
! 1225: if (err)
! 1226: return err;
! 1227: }
! 1228:
! 1229: /* pin headphone-boost */
! 1230: else if (target == MI_TARGET_PINBOOST) {
! 1231: if (mc->un.ord >= 2)
! 1232: return EINVAL;
! 1233: err = this->comresp(this, nid,
! 1234: CORB_GET_PIN_WIDGET_CONTROL, 0, &result);
! 1235: if (err)
! 1236: return err;
! 1237: if (mc->un.ord == 0) {
! 1238: result &= ~CORB_PWC_HEADPHONE;
! 1239: } else {
! 1240: result |= CORB_PWC_HEADPHONE;
! 1241: }
! 1242: err = this->comresp(this, nid,
! 1243: CORB_SET_PIN_WIDGET_CONTROL, result, &result);
! 1244: if (err)
! 1245: return err;
! 1246: }
! 1247:
! 1248: /* DAC group selection */
! 1249: else if (target == MI_TARGET_DAC) {
! 1250: if (this->running)
! 1251: return EBUSY;
! 1252: if (mc->un.ord >= this->dacs.ngroups)
! 1253: return EINVAL;
! 1254: return azalia_codec_construct_format(this,
! 1255: mc->un.ord, this->adcs.cur);
! 1256: }
! 1257:
! 1258: /* ADC selection */
! 1259: else if (target == MI_TARGET_ADC) {
! 1260: if (this->running)
! 1261: return EBUSY;
! 1262: if (mc->un.ord >= this->adcs.ngroups)
! 1263: return EINVAL;
! 1264: return azalia_codec_construct_format(this,
! 1265: this->dacs.cur, mc->un.ord);
! 1266: }
! 1267:
! 1268: /* Volume knob */
! 1269: else if (target == MI_TARGET_VOLUME) {
! 1270: if (mc->un.value.num_channels != 1)
! 1271: return EINVAL;
! 1272: if (!azalia_generic_mixer_validate_value(this, nid,
! 1273: target, mc->un.value.level[0]))
! 1274: return EINVAL;
! 1275: value = azalia_generic_mixer_to_device_value(this, nid, target,
! 1276: mc->un.value.level[0]) | CORB_VKNOB_DIRECT;
! 1277: err = this->comresp(this, nid, CORB_SET_VOLUME_KNOB,
! 1278: value, &result);
! 1279: if (err)
! 1280: return err;
! 1281: }
! 1282:
! 1283: else {
! 1284: printf("%s: internal error in %s: target=%x\n",
! 1285: XNAME(this), __func__, target);
! 1286: return -1;
! 1287: }
! 1288: return 0;
! 1289: }
! 1290:
! 1291: int
! 1292: azalia_generic_mixer_pinctrl(codec_t *this, nid_t nid, uint32_t value)
! 1293: {
! 1294: int err;
! 1295: uint32_t result;
! 1296:
! 1297: err = this->comresp(this, nid, CORB_GET_PIN_WIDGET_CONTROL, 0, &result);
! 1298: if (err)
! 1299: return err;
! 1300: result &= ~(CORB_PWC_OUTPUT | CORB_PWC_INPUT);
! 1301: result |= value & (CORB_PWC_OUTPUT | CORB_PWC_INPUT);
! 1302: return this->comresp(this, nid,
! 1303: CORB_SET_PIN_WIDGET_CONTROL, result, NULL);
! 1304: }
! 1305:
! 1306: u_char
! 1307: azalia_generic_mixer_from_device_value(const codec_t *this, nid_t nid, int target,
! 1308: uint32_t dv)
! 1309: {
! 1310: #ifdef MAX_VOLUME_255
! 1311: uint32_t dmax;
! 1312:
! 1313: if (IS_MI_TARGET_INAMP(target))
! 1314: dmax = COP_AMPCAP_NUMSTEPS(this->w[nid].inamp_cap);
! 1315: else if (target == MI_TARGET_OUTAMP)
! 1316: dmax = COP_AMPCAP_NUMSTEPS(this->w[nid].outamp_cap);
! 1317: else if (target == MI_TARGET_VOLUME)
! 1318: dmax = COP_VKCAP_NUMSTEPS(this->w[nid].d.volume.cap);
! 1319: else {
! 1320: printf("unknown target: %d\n", target);
! 1321: dmax = 255;
! 1322: }
! 1323: if (dv <= 0 || dmax == 0)
! 1324: return AUDIO_MIN_GAIN;
! 1325: if (dv >= dmax)
! 1326: return AUDIO_MAX_GAIN - AUDIO_MAX_GAIN % dmax;
! 1327: return dv * (AUDIO_MAX_GAIN - AUDIO_MAX_GAIN % dmax) / dmax;
! 1328: #else
! 1329: return dv;
! 1330: #endif
! 1331: }
! 1332:
! 1333: uint32_t
! 1334: azalia_generic_mixer_to_device_value(const codec_t *this, nid_t nid, int target,
! 1335: u_char uv)
! 1336: {
! 1337: #ifdef MAX_VOLUME_255
! 1338: uint32_t dmax;
! 1339:
! 1340: if (IS_MI_TARGET_INAMP(target))
! 1341: dmax = COP_AMPCAP_NUMSTEPS(this->w[nid].inamp_cap);
! 1342: else if (target == MI_TARGET_OUTAMP)
! 1343: dmax = COP_AMPCAP_NUMSTEPS(this->w[nid].outamp_cap);
! 1344: else if (target == MI_TARGET_VOLUME)
! 1345: dmax = COP_VKCAP_NUMSTEPS(this->w[nid].d.volume.cap);
! 1346: else {
! 1347: printf("unknown target: %d\n", target);
! 1348: dmax = 255;
! 1349: }
! 1350: if (uv <= AUDIO_MIN_GAIN || dmax == 0)
! 1351: return 0;
! 1352: if (uv >= AUDIO_MAX_GAIN - AUDIO_MAX_GAIN % dmax)
! 1353: return dmax;
! 1354: return uv * dmax / (AUDIO_MAX_GAIN - AUDIO_MAX_GAIN % dmax);
! 1355: #else
! 1356: return uv;
! 1357: #endif
! 1358: }
! 1359:
! 1360: uint32_t
! 1361: azalia_generic_mixer_max(const codec_t *this, nid_t nid, int target)
! 1362: {
! 1363: #ifdef MAX_VOLUME_255
! 1364: return AUDIO_MAX_GAIN;
! 1365: #else
! 1366: uint32_t dmax;
! 1367:
! 1368: if (IS_MI_TARGET_INAMP(target))
! 1369: dmax = COP_AMPCAP_NUMSTEPS(this->w[nid].inamp_cap);
! 1370: else if (target == MI_TARGET_OUTAMP)
! 1371: dmax = COP_AMPCAP_NUMSTEPS(this->w[nid].outamp_cap);
! 1372: else if (target == MI_TARGET_VOLUME)
! 1373: dmax = COP_VKCAP_NUMSTEPS(this->w[nid].d.volume.cap);
! 1374: return dmax;
! 1375: #endif
! 1376: }
! 1377:
! 1378: boolean_t
! 1379: azalia_generic_mixer_validate_value(const codec_t *this, nid_t nid, int target,
! 1380: u_char uv)
! 1381: {
! 1382: #ifdef MAX_VOLUME_255
! 1383: return TRUE;
! 1384: #else
! 1385: return uv <= generic_mixer_max(this, nid, target);
! 1386: #endif
! 1387: }
! 1388:
! 1389: int
! 1390: azalia_generic_set_port(codec_t *this, mixer_ctrl_t *mc)
! 1391: {
! 1392: const mixer_item_t *m;
! 1393:
! 1394: if (mc->dev >= this->nmixers)
! 1395: return ENXIO;
! 1396: m = &this->mixers[mc->dev];
! 1397: if (mc->type != m->devinfo.type)
! 1398: return EINVAL;
! 1399: if (mc->type == AUDIO_MIXER_CLASS)
! 1400: return 0; /* nothing to do */
! 1401: return azalia_generic_mixer_set(this, m->nid, m->target, mc);
! 1402: }
! 1403:
! 1404: int
! 1405: azalia_generic_get_port(codec_t *this, mixer_ctrl_t *mc)
! 1406: {
! 1407: const mixer_item_t *m;
! 1408:
! 1409: if (mc->dev >= this->nmixers)
! 1410: return ENXIO;
! 1411: m = &this->mixers[mc->dev];
! 1412: mc->type = m->devinfo.type;
! 1413: if (mc->type == AUDIO_MIXER_CLASS)
! 1414: return 0; /* nothing to do */
! 1415: return azalia_generic_mixer_get(this, m->nid, m->target, mc);
! 1416: }
! 1417:
! 1418:
! 1419: /* ----------------------------------------------------------------
! 1420: * Realtek ALC260
! 1421: *
! 1422: * Fujitsu LOOX T70M/T
! 1423: * Internal Speaker: 0x10
! 1424: * Front Headphone: 0x14
! 1425: * Front mic: 0x12
! 1426: * ---------------------------------------------------------------- */
! 1427:
! 1428: #define ALC260_FUJITSU_ID 0x132610cf
! 1429: static const mixer_item_t alc260_mixer_items[] = {
! 1430: {{AZ_CLASS_INPUT, {AudioCinputs}, AUDIO_MIXER_CLASS, AZ_CLASS_INPUT, 0, 0}, 0},
! 1431: {{AZ_CLASS_OUTPUT, {AudioCoutputs}, AUDIO_MIXER_CLASS, AZ_CLASS_OUTPUT, 0, 0}, 0},
! 1432: {{AZ_CLASS_RECORD, {AudioCrecord}, AUDIO_MIXER_CLASS, AZ_CLASS_RECORD, 0, 0}, 0},
! 1433:
! 1434: {{0, {AudioNmaster}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 1435: 0, 0, .un.v={{""}, 2, 3}}, 0x08, MI_TARGET_OUTAMP}, /* and 0x09, 0x0a(mono) */
! 1436: {{0, {AudioNmaster".mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1437: 0, 0, ENUM_OFFON}, 0x0f, MI_TARGET_OUTAMP},
! 1438: {{0, {AudioNheadphone".mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1439: 0, 0, ENUM_OFFON}, 0x10, MI_TARGET_OUTAMP},
! 1440: {{0, {AudioNheadphone".boost"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1441: 0, 0, ENUM_OFFON}, 0x10, MI_TARGET_PINBOOST},
! 1442: {{0, {AudioNmono".mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1443: 0, 0, ENUM_OFFON}, 0x11, MI_TARGET_OUTAMP},
! 1444: {{0, {"mic1.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1445: 0, 0, ENUM_OFFON}, 0x12, MI_TARGET_OUTAMP},
! 1446: {{0, {"mic1"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1447: 0, 0, ENUM_IO}, 0x12, MI_TARGET_PINDIR},
! 1448: {{0, {"mic2.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1449: 0, 0, ENUM_OFFON}, 0x13, MI_TARGET_OUTAMP},
! 1450: {{0, {"mic2"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1451: 0, 0, ENUM_IO}, 0x13, MI_TARGET_PINDIR},
! 1452: {{0, {"line1.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1453: 0, 0, ENUM_OFFON}, 0x14, MI_TARGET_OUTAMP},
! 1454: {{0, {"line1"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1455: 0, 0, ENUM_IO}, 0x14, MI_TARGET_PINDIR},
! 1456: {{0, {"line2.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1457: 0, 0, ENUM_OFFON}, 0x15, MI_TARGET_OUTAMP},
! 1458: {{0, {"line2"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1459: 0, 0, ENUM_IO}, 0x15, MI_TARGET_PINDIR},
! 1460:
! 1461: {{0, {AudioNdac".mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1462: 0, 0, ENUM_OFFON}, 0x08, MI_TARGET_INAMP(0)}, /* and 0x09, 0x0a(mono) */
! 1463: {{0, {"mic1.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1464: 0, 0, ENUM_OFFON}, 0x07, MI_TARGET_INAMP(0)},
! 1465: {{0, {"mic1"}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 1466: 0, 0, .un.v={{""}, 2, MIXER_DELTA(65)}}, 0x07, MI_TARGET_INAMP(0)},
! 1467: {{0, {"mic2.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1468: 0, 0, ENUM_OFFON}, 0x07, MI_TARGET_INAMP(1)},
! 1469: {{0, {"mic2"}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 1470: 0, 0, .un.v={{""}, 2, MIXER_DELTA(65)}}, 0x07, MI_TARGET_INAMP(1)},
! 1471: {{0, {"line1.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1472: 0, 0, ENUM_OFFON}, 0x07, MI_TARGET_INAMP(2)},
! 1473: {{0, {"line1"}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 1474: 0, 0, .un.v={{""}, 2, 3}}, 0x07, MI_TARGET_INAMP(2)},
! 1475: {{0, {"line2.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1476: 0, 0, ENUM_OFFON}, 0x07, MI_TARGET_INAMP(3)},
! 1477: {{0, {"line2"}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 1478: 0, 0, .un.v={{""}, 2, MIXER_DELTA(65)}}, 0x07, MI_TARGET_INAMP(3)},
! 1479: {{0, {AudioNcd".mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1480: 0, 0, ENUM_OFFON}, 0x07, MI_TARGET_INAMP(4)},
! 1481: {{0, {AudioNcd}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 1482: 0, 0, .un.v={{""}, 2, MIXER_DELTA(65)}}, 0x07, MI_TARGET_INAMP(4)},
! 1483: {{0, {AudioNspeaker".mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1484: 0, 0, ENUM_OFFON}, 0x07, MI_TARGET_INAMP(5)},
! 1485: {{0, {AudioNspeaker}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 1486: 0, 0, .un.v={{""}, 2, MIXER_DELTA(65)}}, 0x07, MI_TARGET_INAMP(5)},
! 1487:
! 1488: {{0, {"adc04.source"}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD, 0, 0,
! 1489: .un.e={5, {{{"mic1"}, 0}, {{"mic2"}, 1}, {{"line1"}, 2},
! 1490: {{"line2"}, 3}, {{AudioNcd}, 4}}}},
! 1491: 0x04, MI_TARGET_CONNLIST},
! 1492: {{0, {"adc04.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD, 0, 0,
! 1493: ENUM_OFFON}, 0x04, MI_TARGET_INAMP(0)},
! 1494: {{0, {"adc04"}, AUDIO_MIXER_VALUE, AZ_CLASS_RECORD, 0, 0,
! 1495: .un.v={{""}, 2, MIXER_DELTA(35)}}, 0x04, MI_TARGET_INAMP(0)},
! 1496: {{0, {"adc05.source"}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD, 0, 0,
! 1497: .un.e={6, {{{"mic1"}, 0}, {{"mic2"}, 1}, {{"line1"}, 2},
! 1498: {{"line2"}, 3}, {{AudioNcd}, 4}, {{AudioNmixerout}, 5}}}},
! 1499: 0x05, MI_TARGET_CONNLIST},
! 1500: {{0, {"adc05.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD, 0, 0,
! 1501: ENUM_OFFON}, 0x05, MI_TARGET_INAMP(0)},
! 1502: {{0, {"adc05"}, AUDIO_MIXER_VALUE, AZ_CLASS_RECORD, 0, 0,
! 1503: .un.v={{""}, 2, MIXER_DELTA(35)}}, 0x05, MI_TARGET_INAMP(0)},
! 1504:
! 1505: {{0, {"usingdac"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT, 0, 0,
! 1506: .un.e={2, {{{"analog"}, 0}, {{"digital"}, 1}}}}, 0, MI_TARGET_DAC},
! 1507: {{0, {"usingadc"}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD, 0, 0,
! 1508: .un.e={3, {{{"adc04"}, 0}, {{"adc05"}, 1}, {{"digital"}, 2}}}}, 0, MI_TARGET_ADC},
! 1509: };
! 1510:
! 1511: static const mixer_item_t alc260_loox_mixer_items[] = {
! 1512: {{AZ_CLASS_INPUT, {AudioCinputs}, AUDIO_MIXER_CLASS, AZ_CLASS_INPUT, 0, 0}, 0},
! 1513: {{AZ_CLASS_OUTPUT, {AudioCoutputs}, AUDIO_MIXER_CLASS, AZ_CLASS_OUTPUT, 0, 0}, 0},
! 1514: {{AZ_CLASS_RECORD, {AudioCrecord}, AUDIO_MIXER_CLASS, AZ_CLASS_RECORD, 0, 0}, 0},
! 1515:
! 1516: {{0, {AudioNmaster}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 1517: 0, 0, .un.v={{""}, 2, 3}}, 0x08, MI_TARGET_OUTAMP}, /* and 0x09, 0x0a(mono) */
! 1518: {{0, {AudioNmaster".mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1519: 0, 0, ENUM_OFFON}, 0x10, MI_TARGET_OUTAMP},
! 1520: {{0, {AudioNmaster".boost"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1521: 0, 0, ENUM_OFFON}, 0x10, MI_TARGET_PINBOOST},
! 1522: {{0, {AudioNheadphone".mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1523: 0, 0, ENUM_OFFON}, 0x14, MI_TARGET_OUTAMP},
! 1524: {{0, {AudioNheadphone".boost"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1525: 0, 0, ENUM_OFFON}, 0x14, MI_TARGET_PINBOOST},
! 1526:
! 1527: {{0, {AudioNdac".mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1528: 0, 0, ENUM_OFFON}, 0x08, MI_TARGET_INAMP(0)}, /* and 0x09, 0x0a(mono) */
! 1529: {{0, {AudioNmicrophone".mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1530: 0, 0, ENUM_OFFON}, 0x07, MI_TARGET_INAMP(0)},
! 1531: {{0, {AudioNmicrophone}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 1532: 0, 0, .un.v={{""}, 2, MIXER_DELTA(65)}}, 0x07, MI_TARGET_INAMP(0)},
! 1533: {{0, {AudioNcd".mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1534: 0, 0, ENUM_OFFON}, 0x07, MI_TARGET_INAMP(4)},
! 1535: {{0, {AudioNcd}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 1536: 0, 0, .un.v={{""}, 2, MIXER_DELTA(65)}}, 0x07, MI_TARGET_INAMP(4)},
! 1537: {{0, {AudioNspeaker".mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1538: 0, 0, ENUM_OFFON}, 0x07, MI_TARGET_INAMP(5)},
! 1539: {{0, {AudioNspeaker}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 1540: 0, 0, .un.v={{""}, 2, MIXER_DELTA(65)}}, 0x07, MI_TARGET_INAMP(5)},
! 1541:
! 1542: {{0, {"adc04.source"}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD, 0, 0,
! 1543: .un.e={2, {{{AudioNmicrophone}, 0}, {{AudioNcd}, 4}}}}, 0x04, MI_TARGET_CONNLIST},
! 1544: {{0, {"adc04.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD, 0, 0,
! 1545: ENUM_OFFON}, 0x04, MI_TARGET_INAMP(0)},
! 1546: {{0, {"adc04"}, AUDIO_MIXER_VALUE, AZ_CLASS_RECORD, 0, 0,
! 1547: .un.v={{""}, 2, MIXER_DELTA(35)}}, 0x04, MI_TARGET_INAMP(0)},
! 1548: {{0, {"adc05.source"}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD, 0, 0,
! 1549: .un.e={3, {{{AudioNmicrophone}, 0}, {{AudioNcd}, 4}, {{AudioNmixerout}, 5}}}},
! 1550: 0x05, MI_TARGET_CONNLIST},
! 1551: {{0, {"adc05.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD, 0, 0,
! 1552: ENUM_OFFON}, 0x05, MI_TARGET_INAMP(0)},
! 1553: {{0, {"adc05"}, AUDIO_MIXER_VALUE, AZ_CLASS_RECORD, 0, 0,
! 1554: .un.v={{""}, 2, MIXER_DELTA(35)}}, 0x05, MI_TARGET_INAMP(0)},
! 1555:
! 1556: {{0, {"usingdac"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT, 0, 0,
! 1557: .un.e={2, {{{"analog"}, 0}, {{"digital"}, 1}}}}, 0, MI_TARGET_DAC},
! 1558: {{0, {"usingadc"}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD, 0, 0,
! 1559: .un.e={3, {{{"adc04"}, 0}, {{"adc05"}, 1}, {{"digital"}, 2}}}}, 0, MI_TARGET_ADC},
! 1560: };
! 1561:
! 1562: int
! 1563: azalia_alc260_mixer_init(codec_t *this)
! 1564: {
! 1565: const mixer_item_t *mi;
! 1566: mixer_ctrl_t mc;
! 1567:
! 1568: switch (this->subid) {
! 1569: case ALC260_FUJITSU_ID:
! 1570: this->nmixers = sizeof(alc260_loox_mixer_items) / sizeof(mixer_item_t);
! 1571: mi = alc260_loox_mixer_items;
! 1572: break;
! 1573: default:
! 1574: this->nmixers = sizeof(alc260_mixer_items) / sizeof(mixer_item_t);
! 1575: mi = alc260_mixer_items;
! 1576: }
! 1577: this->mixers = malloc(sizeof(mixer_item_t) * this->nmixers,
! 1578: M_DEVBUF, M_NOWAIT);
! 1579: if (this->mixers == NULL) {
! 1580: printf("%s: out of memory in %s\n", XNAME(this), __func__);
! 1581: return ENOMEM;
! 1582: }
! 1583: bzero(this->mixers, sizeof(mixer_item_t) * this->nmixers);
! 1584: memcpy(this->mixers, mi, sizeof(mixer_item_t) * this->nmixers);
! 1585: azalia_generic_mixer_fix_indexes(this);
! 1586: azalia_generic_mixer_default(this);
! 1587:
! 1588: mc.dev = -1; /* no need for generic_mixer_set() */
! 1589: mc.type = AUDIO_MIXER_ENUM;
! 1590: mc.un.ord = 1; /* pindir: output */
! 1591: azalia_generic_mixer_set(this, 0x0f, MI_TARGET_PINDIR, &mc); /* lineout */
! 1592: azalia_generic_mixer_set(this, 0x10, MI_TARGET_PINDIR, &mc); /* headphones */
! 1593: mc.un.ord = 0; /* pindir: input */
! 1594: azalia_generic_mixer_set(this, 0x12, MI_TARGET_PINDIR, &mc); /* mic1 */
! 1595: azalia_generic_mixer_set(this, 0x13, MI_TARGET_PINDIR, &mc); /* mic2 */
! 1596: azalia_generic_mixer_set(this, 0x14, MI_TARGET_PINDIR, &mc); /* line1 */
! 1597: azalia_generic_mixer_set(this, 0x15, MI_TARGET_PINDIR, &mc); /* line2 */
! 1598: mc.un.ord = 0; /* mute: off */
! 1599: azalia_generic_mixer_set(this, 0x08, MI_TARGET_INAMP(0), &mc);
! 1600: azalia_generic_mixer_set(this, 0x08, MI_TARGET_INAMP(1), &mc);
! 1601: azalia_generic_mixer_set(this, 0x09, MI_TARGET_INAMP(0), &mc);
! 1602: azalia_generic_mixer_set(this, 0x09, MI_TARGET_INAMP(1), &mc);
! 1603: azalia_generic_mixer_set(this, 0x0a, MI_TARGET_INAMP(0), &mc);
! 1604: azalia_generic_mixer_set(this, 0x0a, MI_TARGET_INAMP(1), &mc);
! 1605: if (this->subid == ALC260_FUJITSU_ID) {
! 1606: mc.un.ord = 1; /* pindir: output */
! 1607: azalia_generic_mixer_set(this, 0x14, MI_TARGET_PINDIR, &mc); /* line1 */
! 1608: mc.un.ord = 4; /* connlist: cd */
! 1609: azalia_generic_mixer_set(this, 0x05, MI_TARGET_CONNLIST, &mc);
! 1610: }
! 1611: return 0;
! 1612: }
! 1613:
! 1614: int
! 1615: azalia_alc260_init_dacgroup(codec_t *this)
! 1616: {
! 1617: static const convgroupset_t dacs = {
! 1618: -1, 2,
! 1619: {{1, {0x02}}, /* analog 2ch */
! 1620: {1, {0x03}}}}; /* digital */
! 1621: static const convgroupset_t adcs = {
! 1622: -1, 3,
! 1623: {{1, {0x04}}, /* analog 2ch */
! 1624: {1, {0x05}}, /* analog 2ch */
! 1625: {1, {0x06}}}}; /* digital */
! 1626:
! 1627: this->dacs = dacs;
! 1628: this->adcs = adcs;
! 1629: return 0;
! 1630: }
! 1631:
! 1632: int
! 1633: azalia_alc260_set_port(codec_t *this, mixer_ctrl_t *mc)
! 1634: {
! 1635: const mixer_item_t *m;
! 1636: mixer_ctrl_t mc2;
! 1637: int err;
! 1638:
! 1639: if (mc->dev >= this->nmixers)
! 1640: return ENXIO;
! 1641: m = &this->mixers[mc->dev];
! 1642: if (mc->type != m->devinfo.type)
! 1643: return EINVAL;
! 1644: if (mc->type == AUDIO_MIXER_CLASS)
! 1645: return 0;
! 1646: if (m->nid == 0x08 && m->target == MI_TARGET_OUTAMP) {
! 1647: DPRINTF(("%s: hook for outputs.master\n", __func__));
! 1648: err = azalia_generic_mixer_set(this, m->nid, m->target, mc);
! 1649: if (!err) {
! 1650: azalia_generic_mixer_set(this, 0x09, m->target, mc);
! 1651: mc2 = *mc;
! 1652: mc2.un.value.num_channels = 1;
! 1653: mc2.un.value.level[0] = (mc2.un.value.level[0]
! 1654: + mc2.un.value.level[1]) / 2;
! 1655: azalia_generic_mixer_set(this, 0x0a, m->target, &mc2);
! 1656: }
! 1657: return err;
! 1658: } else if (m->nid == 0x08 && m->target == MI_TARGET_INAMP(0)) {
! 1659: DPRINTF(("%s: hook for inputs.dac.mute\n", __func__));
! 1660: err = azalia_generic_mixer_set(this, m->nid, m->target, mc);
! 1661: if (!err) {
! 1662: azalia_generic_mixer_set(this, 0x09, m->target, mc);
! 1663: azalia_generic_mixer_set(this, 0x0a, m->target, mc);
! 1664: }
! 1665: return err;
! 1666: } else if (m->nid == 0x04 &&
! 1667: m->target == MI_TARGET_CONNLIST &&
! 1668: m->devinfo.un.e.num_mem == 2) {
! 1669: if (1 <= mc->un.ord && mc->un.ord <= 3)
! 1670: return EINVAL;
! 1671: } else if (m->nid == 0x05 &&
! 1672: m->target == MI_TARGET_CONNLIST &&
! 1673: m->devinfo.un.e.num_mem == 3) {
! 1674: if (1 <= mc->un.ord && mc->un.ord <= 3)
! 1675: return EINVAL;
! 1676: }
! 1677: return azalia_generic_mixer_set(this, m->nid, m->target, mc);
! 1678: }
! 1679:
! 1680: /* ----------------------------------------------------------------
! 1681: * Realtek ALC880
! 1682: * ---------------------------------------------------------------- */
! 1683:
! 1684: int
! 1685: azalia_alc880_init_dacgroup(codec_t *this)
! 1686: {
! 1687: static const convgroupset_t dacs = {
! 1688: -1, 2,
! 1689: {{4, {0x02, 0x03, 0x04, 0x05}}, /* analog 8ch */
! 1690: {1, {0x06}}}}; /* digital */
! 1691: static const convgroupset_t adcs = {
! 1692: -1, 2,
! 1693: {{2, {0x08, 0x09}}, /* analog 4ch */
! 1694: {1, {0x0a}}}}; /* digital */
! 1695:
! 1696: this->dacs = dacs;
! 1697: this->adcs = adcs;
! 1698: return 0;
! 1699: }
! 1700:
! 1701: /* ----------------------------------------------------------------
! 1702: * Realtek ALC882
! 1703: * ---------------------------------------------------------------- */
! 1704:
! 1705: static const mixer_item_t alc882_mixer_items[] = {
! 1706: {{AZ_CLASS_INPUT, {AudioCinputs}, AUDIO_MIXER_CLASS, AZ_CLASS_INPUT, 0, 0}, 0},
! 1707: {{AZ_CLASS_OUTPUT, {AudioCoutputs}, AUDIO_MIXER_CLASS, AZ_CLASS_OUTPUT, 0, 0}, 0},
! 1708: {{AZ_CLASS_RECORD, {AudioCrecord}, AUDIO_MIXER_CLASS, AZ_CLASS_RECORD, 0, 0}, 0},
! 1709:
! 1710: /* 0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x14,0x15,0x16,0x17 */
! 1711: {{0, {"mic1."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1712: 0, 0, ENUM_OFFON}, 0x0b, MI_TARGET_INAMP(0)},
! 1713: {{0, {"mic1"}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 1714: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x0b, MI_TARGET_INAMP(0)},
! 1715: {{0, {"mic2."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1716: 0, 0, ENUM_OFFON}, 0x0b, MI_TARGET_INAMP(1)},
! 1717: {{0, {"mic2"}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 1718: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x0b, MI_TARGET_INAMP(1)},
! 1719: {{0, {AudioNline"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1720: 0, 0, ENUM_OFFON}, 0x0b, MI_TARGET_INAMP(2)},
! 1721: {{0, {AudioNline}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 1722: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x0b, MI_TARGET_INAMP(2)},
! 1723: {{0, {AudioNcd"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1724: 0, 0, ENUM_OFFON}, 0x0b, MI_TARGET_INAMP(4)},
! 1725: {{0, {AudioNcd}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 1726: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x0b, MI_TARGET_INAMP(4)},
! 1727: {{0, {AudioNspeaker"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1728: 0, 0, ENUM_OFFON}, 0x0b, MI_TARGET_INAMP(5)},
! 1729: {{0, {AudioNspeaker}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 1730: 0, 0, .un.v={{""}, 1, MIXER_DELTA(31)}}, 0x0b, MI_TARGET_INAMP(5)},
! 1731:
! 1732: {{0, {AudioNmaster}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 1733: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x0c, MI_TARGET_OUTAMP},
! 1734: {{0, {AudioNmaster"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1735: 0, 0, ENUM_OFFON}, 0x14, MI_TARGET_OUTAMP},
! 1736: {{0, {AudioNmaster".boost"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1737: 0, 0, ENUM_OFFON}, 0x14, MI_TARGET_PINBOOST},
! 1738: {{0, {AudioNheadphone"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1739: 0, 0, ENUM_OFFON}, 0x1b, MI_TARGET_OUTAMP},
! 1740: {{0, {AudioNheadphone".boost"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1741: 0, 0, ENUM_OFFON}, 0x1b, MI_TARGET_PINBOOST},
! 1742: {{0, {AzaliaNfront".dac.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1743: 0, 0, ENUM_OFFON}, 0x0c, MI_TARGET_INAMP(0)},
! 1744: {{0, {AzaliaNfront".mixer.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1745: 0, 0, ENUM_OFFON}, 0x0c, MI_TARGET_INAMP(1)},
! 1746:
! 1747: {{0, {AudioNsurround}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 1748: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x0d, MI_TARGET_OUTAMP},
! 1749: {{0, {AudioNsurround"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1750: 0, 0, ENUM_OFFON}, 0x15, MI_TARGET_OUTAMP},
! 1751: {{0, {AudioNsurround".boost"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1752: 0, 0, ENUM_OFFON}, 0x15, MI_TARGET_PINBOOST},
! 1753: {{0, {AudioNsurround".dac.mut"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1754: 0, 0, ENUM_OFFON}, 0x0d, MI_TARGET_INAMP(0)},
! 1755: {{0, {AudioNsurround".mixer.m"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1756: 0, 0, ENUM_OFFON}, 0x0d, MI_TARGET_INAMP(1)},
! 1757:
! 1758: {{0, {AzaliaNclfe}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 1759: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x0e, MI_TARGET_OUTAMP},
! 1760: {{0, {AzaliaNclfe"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1761: 0, 0, ENUM_OFFON}, 0x16, MI_TARGET_OUTAMP},
! 1762: {{0, {AzaliaNclfe".boost"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1763: 0, 0, ENUM_OFFON}, 0x16, MI_TARGET_PINBOOST},
! 1764: {{0, {AzaliaNclfe".dac.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1765: 0, 0, ENUM_OFFON}, 0x0e, MI_TARGET_INAMP(0)},
! 1766: {{0, {AzaliaNclfe".mixer.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1767: 0, 0, ENUM_OFFON}, 0x0e, MI_TARGET_INAMP(1)},
! 1768:
! 1769: {{0, {AzaliaNside}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 1770: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x0f, MI_TARGET_OUTAMP},
! 1771: {{0, {AzaliaNside"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1772: 0, 0, ENUM_OFFON}, 0x17, MI_TARGET_OUTAMP},
! 1773: {{0, {AzaliaNside".boost"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 1774: 0, 0, ENUM_OFFON}, 0x17, MI_TARGET_PINBOOST},
! 1775: {{0, {AzaliaNside".dac.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1776: 0, 0, ENUM_OFFON}, 0x0f, MI_TARGET_INAMP(0)},
! 1777: {{0, {AzaliaNside".mixer.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1778: 0, 0, ENUM_OFFON}, 0x0f, MI_TARGET_INAMP(1)},
! 1779:
! 1780: /* 0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x14,0x15,0x16,0x17,0xb */
! 1781: #define ALC882_MIC1 0x001
! 1782: #define ALC882_MIC2 0x002
! 1783: #define ALC882_LINE 0x004
! 1784: #define ALC882_CD 0x010
! 1785: #define ALC882_BEEP 0x020
! 1786: #define ALC882_MIX 0x400
! 1787: #define ALC882_MASK 0x437
! 1788: {{0, {AzaliaNfront"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD,
! 1789: 0, 0, ENUM_OFFON}, 0x07, MI_TARGET_INAMP(0)},
! 1790: {{0, {AzaliaNfront}, AUDIO_MIXER_VALUE, AZ_CLASS_RECORD,
! 1791: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x07, MI_TARGET_INAMP(0)},
! 1792: {{0, {AzaliaNfront"."AudioNsource}, AUDIO_MIXER_SET, AZ_CLASS_RECORD,
! 1793: 0, 0, .un.s={6, {{{"mic1"}, ALC882_MIC1}, {{"mic2"}, ALC882_MIC2},
! 1794: {{AudioNline}, ALC882_LINE}, {{AudioNcd}, ALC882_CD},
! 1795: {{AudioNspeaker}, ALC882_BEEP},
! 1796: {{AudioNmixerout}, ALC882_MIX}}}}, 0x24, -1},
! 1797: {{0, {AudioNsurround"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD,
! 1798: 0, 0, ENUM_OFFON}, 0x08, MI_TARGET_INAMP(0)},
! 1799: {{0, {AudioNsurround}, AUDIO_MIXER_VALUE, AZ_CLASS_RECORD,
! 1800: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x08, MI_TARGET_INAMP(0)},
! 1801: {{0, {AudioNsurround"."AudioNsource}, AUDIO_MIXER_SET, AZ_CLASS_RECORD,
! 1802: 0, 0, .un.s={6, {{{"mic1"}, ALC882_MIC1}, {{"mic2"}, ALC882_MIC2},
! 1803: {{AudioNline}, ALC882_LINE}, {{AudioNcd}, ALC882_CD},
! 1804: {{AudioNspeaker}, ALC882_BEEP},
! 1805: {{AudioNmixerout}, ALC882_MIX}}}}, 0x23, -1},
! 1806: {{0, {AzaliaNclfe"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD,
! 1807: 0, 0, ENUM_OFFON}, 0x09, MI_TARGET_INAMP(0)},
! 1808: {{0, {AzaliaNclfe}, AUDIO_MIXER_VALUE, AZ_CLASS_RECORD,
! 1809: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x09, MI_TARGET_INAMP(0)},
! 1810: {{0, {AzaliaNclfe"."AudioNsource}, AUDIO_MIXER_SET, AZ_CLASS_RECORD,
! 1811: 0, 0, .un.s={6, {{{"mic1"}, ALC882_MIC1}, {{"mic2"}, ALC882_MIC2},
! 1812: {{AudioNline}, ALC882_LINE}, {{AudioNcd}, ALC882_CD},
! 1813: {{AudioNspeaker}, ALC882_BEEP},
! 1814: {{AudioNmixerout}, ALC882_MIX}}}}, 0x22, -1},
! 1815:
! 1816: {{0, {"usingdac"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT, 0, 0,
! 1817: .un.e={2, {{{"analog"}, 0}, {{"digital"}, 1}}}}, 0, MI_TARGET_DAC},
! 1818: {{0, {"usingadc"}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD, 0, 0,
! 1819: .un.e={2, {{{"analog"}, 0}, {{"digital"}, 1}}}}, 0, MI_TARGET_ADC},
! 1820: };
! 1821:
! 1822: int
! 1823: azalia_alc882_mixer_init(codec_t *this)
! 1824: {
! 1825: mixer_ctrl_t mc;
! 1826:
! 1827: this->nmixers = sizeof(alc882_mixer_items) / sizeof(mixer_item_t);
! 1828: this->mixers = malloc(sizeof(mixer_item_t) * this->nmixers,
! 1829: M_DEVBUF, M_NOWAIT);
! 1830: if (this->mixers == NULL) {
! 1831: printf("%s: out of memory in %s\n", XNAME(this), __func__);
! 1832: return ENOMEM;
! 1833: }
! 1834: bzero(this->mixers, sizeof(mixer_item_t) * this->maxmixers);
! 1835: memcpy(this->mixers, alc882_mixer_items,
! 1836: sizeof(mixer_item_t) * this->nmixers);
! 1837: azalia_generic_mixer_fix_indexes(this);
! 1838: azalia_generic_mixer_default(this);
! 1839:
! 1840: mc.dev = -1;
! 1841: mc.type = AUDIO_MIXER_ENUM;
! 1842: mc.un.ord = 1; /* pindir: output */
! 1843: azalia_generic_mixer_set(this, 0x14, MI_TARGET_PINDIR, &mc);
! 1844: azalia_generic_mixer_set(this, 0x1b, MI_TARGET_PINDIR, &mc);
! 1845: azalia_generic_mixer_set(this, 0x15, MI_TARGET_PINDIR, &mc);
! 1846: azalia_generic_mixer_set(this, 0x16, MI_TARGET_PINDIR, &mc);
! 1847: azalia_generic_mixer_set(this, 0x17, MI_TARGET_PINDIR, &mc);
! 1848: mc.un.ord = 0; /* [0] 0x0c */
! 1849: azalia_generic_mixer_set(this, 0x14, MI_TARGET_CONNLIST, &mc);
! 1850: azalia_generic_mixer_set(this, 0x1b, MI_TARGET_CONNLIST, &mc);
! 1851: mc.un.ord = 1; /* [1] 0x0d */
! 1852: azalia_generic_mixer_set(this, 0x15, MI_TARGET_CONNLIST, &mc);
! 1853: mc.un.ord = 2; /* [2] 0x0e */
! 1854: azalia_generic_mixer_set(this, 0x16, MI_TARGET_CONNLIST, &mc);
! 1855: mc.un.ord = 2; /* [3] 0x0fb */
! 1856: azalia_generic_mixer_set(this, 0x17, MI_TARGET_CONNLIST, &mc);
! 1857:
! 1858: mc.un.ord = 0; /* pindir: input */
! 1859: azalia_generic_mixer_set(this, 0x18, MI_TARGET_PINDIR, &mc);
! 1860: azalia_generic_mixer_set(this, 0x19, MI_TARGET_PINDIR, &mc);
! 1861: azalia_generic_mixer_set(this, 0x1a, MI_TARGET_PINDIR, &mc);
! 1862: /* XXX: inamp for 18/19/1a */
! 1863:
! 1864: mc.un.ord = 0; /* unmute */
! 1865: azalia_generic_mixer_set(this, 0x24, MI_TARGET_INAMP(0), &mc);
! 1866: azalia_generic_mixer_set(this, 0x23, MI_TARGET_INAMP(1), &mc);
! 1867: azalia_generic_mixer_set(this, 0x22, MI_TARGET_INAMP(2), &mc);
! 1868: return 0;
! 1869: }
! 1870:
! 1871: int
! 1872: azalia_alc882_init_dacgroup(codec_t *this)
! 1873: {
! 1874: #if 0
! 1875: static const convgroupset_t dacs = {
! 1876: -1, 3,
! 1877: {{4, {0x02, 0x03, 0x04, 0x05}}, /* analog 8ch */
! 1878: {1, {0x06}}, /* digital */
! 1879: {1, {0x25}}}}; /* another analog */
! 1880: #else
! 1881: static const convgroupset_t dacs = {
! 1882: -1, 2,
! 1883: {{4, {0x02, 0x03, 0x04, 0x05}}, /* analog 8ch */
! 1884: {1, {0x06}}}}; /* digital */
! 1885: #endif
! 1886: static const convgroupset_t adcs = {
! 1887: -1, 2,
! 1888: {{3, {0x07, 0x08, 0x09}}, /* analog 6ch */
! 1889: {1, {0x0a}}}}; /* digital */
! 1890:
! 1891: this->dacs = dacs;
! 1892: this->adcs = adcs;
! 1893: return 0;
! 1894: }
! 1895:
! 1896: int
! 1897: azalia_alc882_set_port(codec_t *this, mixer_ctrl_t *mc)
! 1898: {
! 1899: const mixer_item_t *m;
! 1900: mixer_ctrl_t mc2;
! 1901: uint32_t mask, bit;
! 1902: int i, err;
! 1903:
! 1904: if (mc->dev >= this->nmixers)
! 1905: return ENXIO;
! 1906: m = &this->mixers[mc->dev];
! 1907: if (mc->type != m->devinfo.type)
! 1908: return EINVAL;
! 1909: if (mc->type == AUDIO_MIXER_CLASS)
! 1910: return 0;
! 1911: if ((m->nid == 0x22 || m->nid == 0x23 || m->nid == 0x24)
! 1912: && m->target == -1) {
! 1913: DPRINTF(("%s: hook for record.*.source\n", __func__));
! 1914: mc2.dev = -1;
! 1915: mc2.type = AUDIO_MIXER_ENUM;
! 1916: bit = 1;
! 1917: mask = mc->un.mask & ALC882_MASK;
! 1918: for (i = 0; i < this->w[m->nid].nconnections && i < 32; i++) {
! 1919: mc2.un.ord = (mask & bit) ? 0 : 1;
! 1920: err = azalia_generic_mixer_set(this, m->nid,
! 1921: MI_TARGET_INAMP(i), &mc2);
! 1922: if (err)
! 1923: return err;
! 1924: bit = bit << 1;
! 1925: }
! 1926: return 0;
! 1927: }
! 1928: return azalia_generic_mixer_set(this, m->nid, m->target, mc);
! 1929: }
! 1930:
! 1931: int
! 1932: azalia_alc882_get_port(codec_t *this, mixer_ctrl_t *mc)
! 1933: {
! 1934: const mixer_item_t *m;
! 1935: uint32_t mask, bit, result;
! 1936: int i, err;
! 1937:
! 1938: if (mc->dev >= this->nmixers)
! 1939: return ENXIO;
! 1940: m = &this->mixers[mc->dev];
! 1941: mc->type = m->devinfo.type;
! 1942: if (mc->type == AUDIO_MIXER_CLASS)
! 1943: return 0;
! 1944: if ((m->nid == 0x22 || m->nid == 0x23 || m->nid == 0x24)
! 1945: && m->target == -1) {
! 1946: DPRINTF(("%s: hook for record.*.source\n", __func__));
! 1947: mask = 0;
! 1948: bit = 1;
! 1949: for (i = 0; i < this->w[m->nid].nconnections && i < 32; i++) {
! 1950: err = this->comresp(this, m->nid, CORB_GET_AMPLIFIER_GAIN_MUTE,
! 1951: CORB_GAGM_INPUT | CORB_GAGM_LEFT |
! 1952: i, &result);
! 1953: if (err)
! 1954: return err;
! 1955: if ((result & CORB_GAGM_MUTE) == 0)
! 1956: mask |= bit;
! 1957: bit = bit << 1;
! 1958: }
! 1959: mc->un.mask = mask & ALC882_MASK;
! 1960: return 0;
! 1961: }
! 1962: return azalia_generic_mixer_get(this, m->nid, m->target, mc);
! 1963: }
! 1964:
! 1965: /* ----------------------------------------------------------------
! 1966: * Realtek ALC883
! 1967: * ALC882 without adc07 and mix24.
! 1968: * ---------------------------------------------------------------- */
! 1969:
! 1970: int
! 1971: azalia_alc883_init_dacgroup(codec_t *this)
! 1972: {
! 1973: static const convgroupset_t dacs = {
! 1974: -1, 2,
! 1975: {{4, {0x02, 0x03, 0x04, 0x05}}, /* analog 8ch */
! 1976: {1, {0x06}}}}; /* digital */
! 1977:
! 1978: static const convgroupset_t adcs = {
! 1979: -1, 2,
! 1980: {{2, {0x08, 0x09}}, /* analog 4ch */
! 1981: {1, {0x0a}}}}; /* digital */
! 1982:
! 1983: this->dacs = dacs;
! 1984: this->adcs = adcs;
! 1985: return 0;
! 1986: }
! 1987:
! 1988: static const mixer_item_t alc883_mixer_items[] = {
! 1989: {{AZ_CLASS_INPUT, {AudioCinputs}, AUDIO_MIXER_CLASS, AZ_CLASS_INPUT, 0, 0}, 0},
! 1990: {{AZ_CLASS_OUTPUT, {AudioCoutputs}, AUDIO_MIXER_CLASS, AZ_CLASS_OUTPUT, 0, 0}, 0},
! 1991: {{AZ_CLASS_RECORD, {AudioCrecord}, AUDIO_MIXER_CLASS, AZ_CLASS_RECORD, 0, 0}, 0},
! 1992:
! 1993: /* 0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x14,0x15,0x16,0x17 */
! 1994: {{0, {"mic1."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1995: 0, 0, ENUM_OFFON}, 0x0b, MI_TARGET_INAMP(0)},
! 1996: {{0, {"mic1"}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 1997: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x0b, MI_TARGET_INAMP(0)},
! 1998: {{0, {"mic2."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 1999: 0, 0, ENUM_OFFON}, 0x0b, MI_TARGET_INAMP(1)},
! 2000: {{0, {"mic2"}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 2001: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x0b, MI_TARGET_INAMP(1)},
! 2002: {{0, {AudioNline"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 2003: 0, 0, ENUM_OFFON}, 0x0b, MI_TARGET_INAMP(2)},
! 2004: {{0, {AudioNline}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 2005: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x0b, MI_TARGET_INAMP(2)},
! 2006: {{0, {AudioNcd"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 2007: 0, 0, ENUM_OFFON}, 0x0b, MI_TARGET_INAMP(4)},
! 2008: {{0, {AudioNcd}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 2009: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x0b, MI_TARGET_INAMP(4)},
! 2010: {{0, {AudioNspeaker"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 2011: 0, 0, ENUM_OFFON}, 0x0b, MI_TARGET_INAMP(5)},
! 2012: {{0, {AudioNspeaker}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 2013: 0, 0, .un.v={{""}, 1, MIXER_DELTA(31)}}, 0x0b, MI_TARGET_INAMP(5)},
! 2014:
! 2015: {{0, {AudioNmaster}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 2016: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x0c, MI_TARGET_OUTAMP},
! 2017: {{0, {AudioNmaster"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2018: 0, 0, ENUM_OFFON}, 0x14, MI_TARGET_OUTAMP},
! 2019: {{0, {AudioNmaster".boost"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2020: 0, 0, ENUM_OFFON}, 0x14, MI_TARGET_PINBOOST},
! 2021: {{0, {AudioNheadphone"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2022: 0, 0, ENUM_OFFON}, 0x1b, MI_TARGET_OUTAMP},
! 2023: {{0, {AudioNheadphone".boost"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2024: 0, 0, ENUM_OFFON}, 0x1b, MI_TARGET_PINBOOST},
! 2025: {{0, {AzaliaNfront".dac.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 2026: 0, 0, ENUM_OFFON}, 0x0c, MI_TARGET_INAMP(0)},
! 2027: {{0, {AzaliaNfront".mixer.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 2028: 0, 0, ENUM_OFFON}, 0x0c, MI_TARGET_INAMP(1)},
! 2029: {{0, {AudioNsurround}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 2030: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x0d, MI_TARGET_OUTAMP},
! 2031: {{0, {AudioNsurround"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2032: 0, 0, ENUM_OFFON}, 0x15, MI_TARGET_OUTAMP},
! 2033: {{0, {AudioNsurround".boost"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2034: 0, 0, ENUM_OFFON}, 0x15, MI_TARGET_PINBOOST},
! 2035: {{0, {AudioNsurround".dac.mut"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 2036: 0, 0, ENUM_OFFON}, 0x0d, MI_TARGET_INAMP(0)},
! 2037: {{0, {AudioNsurround".mixer.m"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 2038: 0, 0, ENUM_OFFON}, 0x0d, MI_TARGET_INAMP(1)},
! 2039:
! 2040: {{0, {AzaliaNclfe}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 2041: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x0e, MI_TARGET_OUTAMP},
! 2042: {{0, {AzaliaNclfe"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2043: 0, 0, ENUM_OFFON}, 0x16, MI_TARGET_OUTAMP},
! 2044: {{0, {AzaliaNclfe".boost"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2045: 0, 0, ENUM_OFFON}, 0x16, MI_TARGET_PINBOOST},
! 2046: {{0, {AzaliaNclfe".dac.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 2047: 0, 0, ENUM_OFFON}, 0x0e, MI_TARGET_INAMP(0)},
! 2048: {{0, {AzaliaNclfe".mixer.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 2049: 0, 0, ENUM_OFFON}, 0x0e, MI_TARGET_INAMP(1)},
! 2050:
! 2051: {{0, {AzaliaNside}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 2052: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x0f, MI_TARGET_OUTAMP},
! 2053: {{0, {AzaliaNside"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2054: 0, 0, ENUM_OFFON}, 0x17, MI_TARGET_OUTAMP},
! 2055: {{0, {AzaliaNside".boost"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2056: 0, 0, ENUM_OFFON}, 0x17, MI_TARGET_PINBOOST},
! 2057: {{0, {AzaliaNside".dac.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 2058: 0, 0, ENUM_OFFON}, 0x0f, MI_TARGET_INAMP(0)},
! 2059: {{0, {AzaliaNside".mixer.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 2060: 0, 0, ENUM_OFFON}, 0x0f, MI_TARGET_INAMP(1)},
! 2061:
! 2062: {{0, {AudioNsurround"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD,
! 2063: 0, 0, ENUM_OFFON}, 0x08, MI_TARGET_INAMP(0)},
! 2064: {{0, {AudioNsurround}, AUDIO_MIXER_VALUE, AZ_CLASS_RECORD,
! 2065: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x08, MI_TARGET_INAMP(0)},
! 2066: {{0, {AudioNsurround"."AudioNsource}, AUDIO_MIXER_SET, AZ_CLASS_RECORD,
! 2067: 0, 0, .un.s={6, {{{"mic1"}, ALC882_MIC1}, {{"mic2"}, ALC882_MIC2},
! 2068: {{AudioNline}, ALC882_LINE}, {{AudioNcd}, ALC882_CD},
! 2069: {{AudioNspeaker}, ALC882_BEEP},
! 2070: {{AudioNmixerout}, ALC882_MIX}}}}, 0x23, -1},
! 2071:
! 2072: {{0, {AzaliaNclfe"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD,
! 2073: 0, 0, ENUM_OFFON}, 0x09, MI_TARGET_INAMP(0)},
! 2074: {{0, {AzaliaNclfe}, AUDIO_MIXER_VALUE, AZ_CLASS_RECORD,
! 2075: 0, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x09, MI_TARGET_INAMP(0)},
! 2076: {{0, {AzaliaNclfe"."AudioNsource}, AUDIO_MIXER_SET, AZ_CLASS_RECORD,
! 2077: 0, 0, .un.s={6, {{{"mic1"}, ALC882_MIC1}, {{"mic2"}, ALC882_MIC2},
! 2078: {{AudioNline}, ALC882_LINE}, {{AudioNcd}, ALC882_CD},
! 2079: {{AudioNspeaker}, ALC882_BEEP},
! 2080: {{AudioNmixerout}, ALC882_MIX}}}}, 0x22, -1},
! 2081:
! 2082: {{0, {"usingdac"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT, 0, 0,
! 2083: .un.e={2, {{{"analog"}, 0}, {{"digital"}, 1}}}}, 0, MI_TARGET_DAC},
! 2084: {{0, {"usingadc"}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD, 0, 0,
! 2085: .un.e={2, {{{"analog"}, 0}, {{"digital"}, 1}}}}, 0, MI_TARGET_ADC},
! 2086: };
! 2087:
! 2088: int
! 2089: azalia_alc883_mixer_init(codec_t *this)
! 2090: {
! 2091: mixer_ctrl_t mc;
! 2092:
! 2093: this->nmixers = sizeof(alc883_mixer_items) / sizeof(mixer_item_t);
! 2094: this->mixers = malloc(sizeof(mixer_item_t) * this->nmixers,
! 2095: M_DEVBUF, M_NOWAIT);
! 2096: if (this->mixers == NULL) {
! 2097: printf("%s: out of memory in %s\n", XNAME(this), __func__);
! 2098: return ENOMEM;
! 2099: }
! 2100: bzero(this->mixers, sizeof(mixer_item_t) * this->maxmixers);
! 2101: memcpy(this->mixers, alc883_mixer_items,
! 2102: sizeof(mixer_item_t) * this->nmixers);
! 2103: azalia_generic_mixer_fix_indexes(this);
! 2104: azalia_generic_mixer_default(this);
! 2105:
! 2106: mc.dev = -1;
! 2107: mc.type = AUDIO_MIXER_ENUM;
! 2108: mc.un.ord = 1; /* pindir: output */
! 2109: azalia_generic_mixer_set(this, 0x14, MI_TARGET_PINDIR, &mc);
! 2110: azalia_generic_mixer_set(this, 0x1b, MI_TARGET_PINDIR, &mc);
! 2111: azalia_generic_mixer_set(this, 0x15, MI_TARGET_PINDIR, &mc);
! 2112: azalia_generic_mixer_set(this, 0x16, MI_TARGET_PINDIR, &mc);
! 2113: azalia_generic_mixer_set(this, 0x17, MI_TARGET_PINDIR, &mc);
! 2114: mc.un.ord = 0; /* [0] 0x0c */
! 2115: azalia_generic_mixer_set(this, 0x14, MI_TARGET_CONNLIST, &mc);
! 2116: azalia_generic_mixer_set(this, 0x1b, MI_TARGET_CONNLIST, &mc);
! 2117: mc.un.ord = 1; /* [1] 0x0d */
! 2118: azalia_generic_mixer_set(this, 0x15, MI_TARGET_CONNLIST, &mc);
! 2119: mc.un.ord = 2; /* [2] 0x0e */
! 2120: azalia_generic_mixer_set(this, 0x16, MI_TARGET_CONNLIST, &mc);
! 2121: mc.un.ord = 2; /* [3] 0x0fb */
! 2122: azalia_generic_mixer_set(this, 0x17, MI_TARGET_CONNLIST, &mc);
! 2123:
! 2124: mc.un.ord = 0; /* pindir: input */
! 2125: azalia_generic_mixer_set(this, 0x18, MI_TARGET_PINDIR, &mc);
! 2126: azalia_generic_mixer_set(this, 0x19, MI_TARGET_PINDIR, &mc);
! 2127: azalia_generic_mixer_set(this, 0x1a, MI_TARGET_PINDIR, &mc);
! 2128: /* XXX: inamp for 18/19/1a */
! 2129:
! 2130: mc.un.ord = 0; /* unmute */
! 2131: azalia_generic_mixer_set(this, 0x23, MI_TARGET_INAMP(1), &mc);
! 2132: azalia_generic_mixer_set(this, 0x22, MI_TARGET_INAMP(2), &mc);
! 2133: return 0;
! 2134: }
! 2135:
! 2136:
! 2137: /* ----------------------------------------------------------------
! 2138: * Analog Devices AD1981HD
! 2139: * ---------------------------------------------------------------- */
! 2140:
! 2141: #define AD1981HD_THINKPAD 0x201017aa
! 2142:
! 2143: int
! 2144: azalia_ad1981hd_init_widget(const codec_t *this, widget_t *w, nid_t nid)
! 2145: {
! 2146: switch (nid) {
! 2147: case 0x05:
! 2148: strlcpy(w->name, AudioNline "out", sizeof(w->name));
! 2149: break;
! 2150: case 0x06:
! 2151: strlcpy(w->name, "hp", sizeof(w->name));
! 2152: break;
! 2153: case 0x07:
! 2154: strlcpy(w->name, AudioNmono, sizeof(w->name));
! 2155: break;
! 2156: case 0x08:
! 2157: strlcpy(w->name, AudioNmicrophone, sizeof(w->name));
! 2158: break;
! 2159: case 0x09:
! 2160: strlcpy(w->name, AudioNline "in", sizeof(w->name));
! 2161: break;
! 2162: case 0x0d:
! 2163: strlcpy(w->name, "beep", sizeof(w->name));
! 2164: break;
! 2165: case 0x17:
! 2166: strlcpy(w->name, AudioNaux, sizeof(w->name));
! 2167: break;
! 2168: case 0x18:
! 2169: strlcpy(w->name, AudioNmicrophone "2", sizeof(w->name));
! 2170: break;
! 2171: case 0x19:
! 2172: strlcpy(w->name, AudioNcd, sizeof(w->name));
! 2173: break;
! 2174: case 0x1d:
! 2175: strlcpy(w->name, AudioNspeaker, sizeof(w->name));
! 2176: break;
! 2177: }
! 2178: return 0;
! 2179: }
! 2180:
! 2181: int
! 2182: azalia_ad1981hd_mixer_init(codec_t *this)
! 2183: {
! 2184: mixer_ctrl_t mc;
! 2185: int err;
! 2186:
! 2187: err = azalia_generic_mixer_init(this);
! 2188: if (err)
! 2189: return err;
! 2190: if (this->subid == AD1981HD_THINKPAD) {
! 2191: mc.dev = -1;
! 2192: mc.type = AUDIO_MIXER_ENUM;
! 2193: mc.un.ord = 1;
! 2194: azalia_generic_mixer_set(this, 0x09, MI_TARGET_PINDIR, &mc);
! 2195: }
! 2196: return 0;
! 2197: }
! 2198:
! 2199: /* ----------------------------------------------------------------
! 2200: * CMedia CMI9880
! 2201: * ---------------------------------------------------------------- */
! 2202:
! 2203: static const mixer_item_t cmi9880_mixer_items[] = {
! 2204: {{AZ_CLASS_INPUT, {AudioCinputs}, AUDIO_MIXER_CLASS, AZ_CLASS_INPUT, 0, 0}, 0},
! 2205: {{AZ_CLASS_OUTPUT, {AudioCoutputs}, AUDIO_MIXER_CLASS, AZ_CLASS_OUTPUT, 0, 0}, 0},
! 2206: {{AZ_CLASS_RECORD, {AudioCrecord}, AUDIO_MIXER_CLASS, AZ_CLASS_RECORD, 0, 0}, 0},
! 2207:
! 2208: {{0, {AudioNmaster"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2209: 0, 0, ENUM_OFFON}, 0x03, MI_TARGET_OUTAMP},
! 2210: {{0, {AudioNsurround"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2211: 0, 0, ENUM_OFFON}, 0x04, MI_TARGET_OUTAMP},
! 2212: {{0, {AzaliaNclfe"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2213: 0, 0, ENUM_OFFON}, 0x05, MI_TARGET_OUTAMP},
! 2214: {{0, {AzaliaNside"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2215: 0, 0, ENUM_OFFON}, 0x06, MI_TARGET_OUTAMP},
! 2216: {{0, {"digital."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2217: 0, 0, ENUM_OFFON}, 0x07, MI_TARGET_OUTAMP},
! 2218:
! 2219: {{0, {AzaliaNfront"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD,
! 2220: 0, 0, ENUM_OFFON}, 0x08, MI_TARGET_INAMP(0)},
! 2221: {{0, {AzaliaNfront}, AUDIO_MIXER_VALUE, AZ_CLASS_RECORD,
! 2222: 0, 0, .un.v={{""}, 2, MIXER_DELTA(30)}}, 0x08, MI_TARGET_INAMP(0)},
! 2223: {{0, {AzaliaNfront"."AudioNsource}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD,
! 2224: 0, 0, .un.e={4, {{{AudioNmicrophone}, 5}, {{AudioNcd}, 6},
! 2225: {{"line1"}, 7}, {{"line2"}, 8}}}},
! 2226: 0x08, MI_TARGET_CONNLIST},
! 2227: {{0, {AudioNsurround"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD,
! 2228: 0, 0, ENUM_OFFON}, 0x09, MI_TARGET_INAMP(0)},
! 2229: {{0, {AudioNsurround}, AUDIO_MIXER_VALUE, AZ_CLASS_RECORD,
! 2230: 0, 0, .un.v={{""}, 2, MIXER_DELTA(30)}}, 0x09, MI_TARGET_INAMP(0)},
! 2231: {{0, {AudioNsurround"."AudioNsource}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD,
! 2232: 0, 0, .un.e={4, {{{AudioNmicrophone}, 5}, {{AudioNcd}, 6},
! 2233: {{"line1"}, 7}, {{"line2"}, 8}}}},
! 2234: 0x09, MI_TARGET_CONNLIST},
! 2235:
! 2236: {{0, {AudioNspeaker"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 2237: 0, 0, ENUM_OFFON}, 0x23, MI_TARGET_OUTAMP},
! 2238: {{0, {AudioNspeaker}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 2239: 0, 0, .un.v={{""}, 1, MIXER_DELTA(15)}}, 0x23, MI_TARGET_OUTAMP}
! 2240: };
! 2241:
! 2242: int
! 2243: azalia_cmi9880_mixer_init(codec_t *this)
! 2244: {
! 2245: mixer_ctrl_t mc;
! 2246:
! 2247: this->nmixers = sizeof(cmi9880_mixer_items) / sizeof(mixer_item_t);
! 2248: this->mixers = malloc(sizeof(mixer_item_t) * this->nmixers,
! 2249: M_DEVBUF, M_NOWAIT);
! 2250: if (this->mixers == NULL) {
! 2251: printf("%s: out of memory in %s\n", XNAME(this), __func__);
! 2252: return ENOMEM;
! 2253: }
! 2254: bzero(this->mixers, sizeof(mixer_item_t) * this->maxmixers);
! 2255: memcpy(this->mixers, cmi9880_mixer_items,
! 2256: sizeof(mixer_item_t) * this->nmixers);
! 2257: azalia_generic_mixer_fix_indexes(this);
! 2258: azalia_generic_mixer_default(this);
! 2259:
! 2260: mc.dev = -1;
! 2261: mc.type = AUDIO_MIXER_ENUM;
! 2262: mc.un.ord = 5; /* record.front.source=mic */
! 2263: azalia_generic_mixer_set(this, 0x08, MI_TARGET_CONNLIST, &mc);
! 2264: mc.un.ord = 7; /* record.surround.source=line1 */
! 2265: azalia_generic_mixer_set(this, 0x09, MI_TARGET_CONNLIST, &mc);
! 2266: mc.un.ord = 1; /* pindir: output */
! 2267: azalia_generic_mixer_set(this, 0x0b, MI_TARGET_PINDIR, &mc);
! 2268: azalia_generic_mixer_set(this, 0x0c, MI_TARGET_PINDIR, &mc);
! 2269: azalia_generic_mixer_set(this, 0x0d, MI_TARGET_PINDIR, &mc);
! 2270: azalia_generic_mixer_set(this, 0x0e, MI_TARGET_PINDIR, &mc);
! 2271: azalia_generic_mixer_set(this, 0x0f, MI_TARGET_PINDIR, &mc);
! 2272: mc.un.ord = 0; /* front DAC -> headphones */
! 2273: azalia_generic_mixer_set(this, 0x0f, MI_TARGET_CONNLIST, &mc);
! 2274: mc.un.ord = 0; /* pindir: input */
! 2275: azalia_generic_mixer_set(this, 0x10, MI_TARGET_PINDIR, &mc); /* mic */
! 2276: azalia_generic_mixer_set(this, 0x13, MI_TARGET_PINDIR, &mc); /* SPDIF-in */
! 2277: azalia_generic_mixer_set(this, 0x1f, MI_TARGET_PINDIR, &mc); /* line1 */
! 2278: azalia_generic_mixer_set(this, 0x20, MI_TARGET_PINDIR, &mc); /* line2 */
! 2279: return 0;
! 2280: }
! 2281:
! 2282: int
! 2283: azalia_cmi9880_init_dacgroup(codec_t *this)
! 2284: {
! 2285: static const convgroupset_t dacs = {
! 2286: -1, 2,
! 2287: {{4, {0x03, 0x04, 0x05, 0x06}}, /* analog 8ch */
! 2288: {1, {0x07}}}}; /* digital */
! 2289: static const convgroupset_t adcs = {
! 2290: -1, 2,
! 2291: {{2, {0x08, 0x09}}, /* analog 4ch */
! 2292: {1, {0x0a}}}}; /* digital */
! 2293:
! 2294: this->dacs = dacs;
! 2295: this->adcs = adcs;
! 2296: return 0;
! 2297: }
! 2298:
! 2299: /* ----------------------------------------------------------------
! 2300: * Sigmatel STAC9221 and STAC9221D
! 2301: * ---------------------------------------------------------------- */
! 2302:
! 2303: int
! 2304: azalia_stac9221_init_dacgroup(codec_t *this)
! 2305: {
! 2306: static const convgroupset_t dacs = {
! 2307: -1, 3,
! 2308: {{4, {0x02, 0x03, 0x04, 0x05}}, /* analog 8ch */
! 2309: {1, {0x08}}, /* digital */
! 2310: {1, {0x1a}}}}; /* another digital? */
! 2311: static const convgroupset_t adcs = {
! 2312: -1, 2,
! 2313: {{2, {0x06, 0x07}}, /* analog 4ch */
! 2314: {1, {0x09}}}}; /* digital */
! 2315:
! 2316: this->dacs = dacs;
! 2317: this->adcs = adcs;
! 2318: return 0;
! 2319: }
! 2320:
! 2321: /* ----------------------------------------------------------------
! 2322: * Sigmatel STAC9200
! 2323: * ---------------------------------------------------------------- */
! 2324:
! 2325: static const mixer_item_t stac9200_mixer_items[] = {
! 2326: {{AZ_CLASS_INPUT, {AudioCinputs}, AUDIO_MIXER_CLASS, AZ_CLASS_INPUT, 0, 0}, 0},
! 2327: {{AZ_CLASS_OUTPUT, {AudioCoutputs}, AUDIO_MIXER_CLASS, AZ_CLASS_OUTPUT, 0, 0}, 0},
! 2328: {{AZ_CLASS_RECORD, {AudioCrecord}, AUDIO_MIXER_CLASS, AZ_CLASS_RECORD, 0, 0}, 0},
! 2329:
! 2330: {{0, {AudioNmaster}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 2331: 4, 0, .un.v={{""}, 2, MIXER_DELTA(31)}}, 0x0b, MI_TARGET_OUTAMP},
! 2332: {{0, {AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2333: 0, 3, ENUM_OFFON}, 0x0b, MI_TARGET_OUTAMP},
! 2334: {{0, {AudioNvolume}, AUDIO_MIXER_VALUE, AZ_CLASS_RECORD,
! 2335: 0, 0, .un.v={{""}, 2, MIXER_DELTA(15)}}, 0x0a, MI_TARGET_OUTAMP},
! 2336: {{0, {AudioNvolume"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD,
! 2337: 0, 0, ENUM_OFFON}, 0x0a, MI_TARGET_OUTAMP},
! 2338: {{0, {AudioNsource}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD,
! 2339: 0, 0, .un.e={5, {{{AudioNline}, 0}, {{AudioNmicrophone}, 1},
! 2340: {{AudioNline"2"}, 2}, {{AudioNline"3"}, 3},
! 2341: {{AudioNcd}, 4}}}},
! 2342: 0x0c, MI_TARGET_CONNLIST},
! 2343: {{0, {AudioNmicrophone}, AUDIO_MIXER_VALUE, AZ_CLASS_INPUT,
! 2344: 0, 0, .un.v={{""}, 2, MIXER_DELTA(4)}}, 0x0c, MI_TARGET_OUTAMP},
! 2345: {{0, {AudioNmicrophone"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 2346: 0, 0, ENUM_OFFON}, 0x0c, MI_TARGET_OUTAMP},
! 2347: {{0, {AudioNsource}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2348: 0, 0, .un.e={3, {{{AudioNdac}, 0}, {{"digital-in"}, 1}, {{"selector"}, 2}}}},
! 2349: 0x07, MI_TARGET_CONNLIST},
! 2350: {{0, {"digital."AudioNsource}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2351: 0, 0, .un.e={2, {{{AudioNdac}, 0}, {{"selector"}, 1}}}},
! 2352: 0x09, MI_TARGET_CONNLIST}, /* AudioNdac is not accurate name */
! 2353: {{0, {AudioNheadphone".boost"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2354: 0, 0, ENUM_OFFON}, 0x0d, MI_TARGET_PINBOOST},
! 2355: {{0, {AudioNspeaker".boost"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2356: 0, 0, ENUM_OFFON}, 0x0e, MI_TARGET_PINBOOST},
! 2357: {{0, {AudioNmono"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2358: 0, 0, ENUM_OFFON}, 0x11, MI_TARGET_OUTAMP},
! 2359: {{0, {AudioNmono}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 2360: 0, 0, .un.v={{""}, 1, MIXER_DELTA(31)}}, 0x11, MI_TARGET_OUTAMP},
! 2361: {{0, {"beep."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2362: 0, 0, ENUM_OFFON}, 0x14, MI_TARGET_OUTAMP},
! 2363: {{0, {"beep"}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 2364: 0, 0, .un.v={{""}, 1, MIXER_DELTA(3)}}, 0x14, MI_TARGET_OUTAMP},
! 2365: {{0, {"usingdac"}, AUDIO_MIXER_ENUM, AZ_CLASS_INPUT,
! 2366: 0, 0, .un.e={2, {{{"analog"}, 0}, {{"digital"}, 1}}}},
! 2367: 0, MI_TARGET_DAC},
! 2368: {{0, {"usingadc"}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD,
! 2369: 0, 0, .un.e={2, {{{"analog"}, 0}, {{"digital"}, 1}}}},
! 2370: 0, MI_TARGET_ADC},
! 2371: };
! 2372:
! 2373: int
! 2374: azalia_stac9200_mixer_init(codec_t *this)
! 2375: {
! 2376: mixer_ctrl_t mc;
! 2377:
! 2378: this->nmixers = sizeof(stac9200_mixer_items) / sizeof(mixer_item_t);
! 2379: this->mixers = malloc(sizeof(mixer_item_t) * this->nmixers,
! 2380: M_DEVBUF, M_NOWAIT);
! 2381: if (this->mixers == NULL) {
! 2382: printf("%s: out of memory in %s\n", XNAME(this), __func__);
! 2383: return ENOMEM;
! 2384: }
! 2385: bzero(this->mixers, sizeof(mixer_item_t) * this->maxmixers);
! 2386: memcpy(this->mixers, stac9200_mixer_items,
! 2387: sizeof(mixer_item_t) * this->nmixers);
! 2388: azalia_generic_mixer_fix_indexes(this);
! 2389: azalia_generic_mixer_default(this);
! 2390:
! 2391: mc.dev = -1; /* no need for generic_mixer_set() */
! 2392: mc.type = AUDIO_MIXER_ENUM;
! 2393: mc.un.ord = 1; /* pindir: output */
! 2394: azalia_generic_mixer_set(this, 0x0d, MI_TARGET_PINDIR, &mc); /* headphones */
! 2395: azalia_generic_mixer_set(this, 0x0e, MI_TARGET_PINDIR, &mc); /* speaker */
! 2396: mc.un.ord = 0; /* pindir: input */
! 2397: azalia_generic_mixer_set(this, 0x0f, MI_TARGET_PINDIR, &mc); /* mic2 */
! 2398: azalia_generic_mixer_set(this, 0x10, MI_TARGET_PINDIR, &mc); /* mic1 */
! 2399: mc.type = AUDIO_MIXER_VALUE;
! 2400: mc.un.value.num_channels = 2;
! 2401: mc.un.value.level[0] = azalia_generic_mixer_max(this, 0x0c, MI_TARGET_OUTAMP);
! 2402: mc.un.value.level[1] = mc.un.value.level[0];
! 2403: azalia_generic_mixer_set(this, 0x0c, MI_TARGET_OUTAMP, &mc);
! 2404:
! 2405: #define STAC9200_EVENT_HP 0
! 2406: #define STAC9200_NID_HP 0x0d
! 2407: #define STAC9200_NID_SPEAKER 0x0e
! 2408:
! 2409: /* register hp unsolicited event */
! 2410: this->comresp(this, STAC9200_NID_HP,
! 2411: CORB_SET_UNSOLICITED_RESPONSE,
! 2412: CORB_UNSOL_ENABLE | STAC9200_EVENT_HP, NULL);
! 2413:
! 2414: azalia_stac9200_unsol_event(this, STAC9200_EVENT_HP);
! 2415:
! 2416: return 0;
! 2417: }
! 2418: int
! 2419: azalia_stac9200_unsol_event(codec_t *this, int tag)
! 2420: {
! 2421: int err;
! 2422: uint32_t value;
! 2423:
! 2424: switch (tag) {
! 2425: case STAC9200_EVENT_HP:
! 2426: err = this->comresp(this, STAC9200_NID_HP,
! 2427: CORB_GET_PIN_SENSE, 0, &value);
! 2428: if (err)
! 2429: break;
! 2430: if (value & CORB_PS_PRESENCE) {
! 2431: DPRINTF(("%s: headphone inserted\n", __func__));
! 2432: azalia_generic_mixer_pinctrl(this,
! 2433: STAC9200_NID_SPEAKER, 0);
! 2434: } else {
! 2435: DPRINTF(("%s: headphone pulled\n", __func__));
! 2436: azalia_generic_mixer_pinctrl(this,
! 2437: STAC9200_NID_SPEAKER, CORB_PWC_OUTPUT);
! 2438: }
! 2439: break;
! 2440: default:
! 2441: DPRINTF(("%s: unknown tag: %d\n", __func__, tag));
! 2442: }
! 2443: return 0;
! 2444: }
! 2445:
! 2446: int
! 2447: azalia_stac9221_apple_init_dacgroup(codec_t *this)
! 2448: {
! 2449: static const convgroupset_t dacs = {
! 2450: -1, 1,
! 2451: {{4, {0x02, 0x03, 0x04, 0x05}}}};
! 2452:
! 2453: static const convgroupset_t adcs = {
! 2454: -1, 2,
! 2455: {{2, {0x06, 0x07}},
! 2456: {1, {0x09}}}};
! 2457:
! 2458: this->dacs = dacs;
! 2459: this->adcs = adcs;
! 2460: return 0;
! 2461: }
! 2462:
! 2463: static const mixer_item_t stac9221_apple_mixer_items[] = {
! 2464: {{AZ_CLASS_INPUT, {AudioCinputs}, AUDIO_MIXER_CLASS, AZ_CLASS_INPUT, 0, 0}, 0},
! 2465: {{AZ_CLASS_OUTPUT, {AudioCoutputs}, AUDIO_MIXER_CLASS, AZ_CLASS_OUTPUT, 0, 0}, 0},
! 2466: {{AZ_CLASS_RECORD, {AudioCrecord}, AUDIO_MIXER_CLASS, AZ_CLASS_RECORD, 0, 0}, 0},
! 2467:
! 2468: {{0, {AudioNheadphone}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 2469: 0, 0, .un.v={{""}, 2, MIXER_DELTA(15)}}, 0x02, MI_TARGET_OUTAMP},
! 2470: {{0, {AudioNheadphone".mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2471: 0, 0, ENUM_OFFON}, 0x02, MI_TARGET_OUTAMP},
! 2472:
! 2473: {{0, {AudioNspeaker}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 2474: 0, 0, .un.v={{""}, 2, MIXER_DELTA(15)}}, 0x03, MI_TARGET_OUTAMP},
! 2475: {{0, {AudioNspeaker".mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2476: 0, 0, ENUM_OFFON}, 0x03, MI_TARGET_OUTAMP},
! 2477:
! 2478: {{0, {"line"}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 2479: 0, 0, .un.v={{""}, 2, MIXER_DELTA(15)}}, 0x04, MI_TARGET_OUTAMP},
! 2480: {{0, {"line.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2481: 0, 0, ENUM_OFFON}, 0x04, MI_TARGET_OUTAMP},
! 2482:
! 2483: {{0, {"line2"}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 2484: 0, 0, .un.v={{""}, 2, MIXER_DELTA(15)}}, 0x05, MI_TARGET_OUTAMP},
! 2485: {{0, {"line2.mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2486: 0, 0, ENUM_OFFON}, 0x05, MI_TARGET_OUTAMP},
! 2487:
! 2488: {{0, {AudioNmaster}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 2489: 0, 0, .un.v={{""}, 1, MIXER_DELTA(15)}}, 0x16, MI_TARGET_VOLUME},
! 2490: };
! 2491:
! 2492: int
! 2493: azalia_stac9221_apple_mixer_init(codec_t *this)
! 2494: {
! 2495: mixer_ctrl_t mc;
! 2496:
! 2497: this->nmixers = sizeof(stac9221_apple_mixer_items) / sizeof(mixer_item_t);
! 2498: this->mixers = malloc(sizeof(mixer_item_t) * this->nmixers,
! 2499: M_DEVBUF, M_NOWAIT);
! 2500: if (this->mixers == NULL) {
! 2501: printf("%s: out of memory in %s\n", XNAME(this), __func__);
! 2502: return ENOMEM;
! 2503: }
! 2504: bzero(this->mixers, sizeof(mixer_item_t) * this->maxmixers);
! 2505: memcpy(this->mixers, stac9221_apple_mixer_items,
! 2506: sizeof(mixer_item_t) * this->nmixers);
! 2507: azalia_generic_mixer_fix_indexes(this);
! 2508: azalia_generic_mixer_default(this);
! 2509:
! 2510: mc.dev = -1;
! 2511: mc.type = AUDIO_MIXER_ENUM;
! 2512: mc.un.ord = 1; /* pindir: output */
! 2513: azalia_generic_mixer_set(this, 0x0a, MI_TARGET_PINDIR, &mc); /* headphones */
! 2514: azalia_generic_mixer_set(this, 0x0b, MI_TARGET_PINDIR, &mc); /* mic, set to output */
! 2515: azalia_generic_mixer_set(this, 0x0c, MI_TARGET_PINDIR, &mc); /* speaker */
! 2516: azalia_generic_mixer_set(this, 0x0d, MI_TARGET_PINDIR, &mc); /* line out */
! 2517: azalia_generic_mixer_set(this, 0x0f, MI_TARGET_PINDIR, &mc); /* another line out */
! 2518:
! 2519: /* max all volumes except master */
! 2520: mc.type = AUDIO_MIXER_VALUE;
! 2521: mc.un.value.num_channels = 2;
! 2522: mc.un.value.level[0] = azalia_generic_mixer_max(this, 0x02, MI_TARGET_OUTAMP);
! 2523: mc.un.value.level[1] = mc.un.value.level[0];
! 2524: azalia_generic_mixer_set(this, 0x02, MI_TARGET_OUTAMP, &mc);
! 2525:
! 2526: mc.un.value.level[0] = azalia_generic_mixer_max(this, 0x03, MI_TARGET_OUTAMP);
! 2527: mc.un.value.level[1] = mc.un.value.level[0];
! 2528: azalia_generic_mixer_set(this, 0x03, MI_TARGET_OUTAMP, &mc);
! 2529:
! 2530: mc.un.value.level[0] = azalia_generic_mixer_max(this, 0x04, MI_TARGET_OUTAMP);
! 2531: mc.un.value.level[1] = mc.un.value.level[0];
! 2532: azalia_generic_mixer_set(this, 0x04, MI_TARGET_OUTAMP, &mc);
! 2533:
! 2534: mc.un.value.level[0] = azalia_generic_mixer_max(this, 0x05, MI_TARGET_OUTAMP);
! 2535: mc.un.value.level[1] = mc.un.value.level[0];
! 2536: azalia_generic_mixer_set(this, 0x05, MI_TARGET_OUTAMP, &mc);
! 2537:
! 2538: azalia_stac9221_gpio_unmute(this, 0);
! 2539: azalia_stac9221_gpio_unmute(this, 1);
! 2540:
! 2541: return 0;
! 2542: }
! 2543:
! 2544: int
! 2545: azalia_stac9221_gpio_unmute(codec_t *this, int pin)
! 2546: {
! 2547: uint32_t data, mask, dir;
! 2548:
! 2549: this->comresp(this, this->audiofunc, CORB_GET_GPIO_DATA, 0, &data);
! 2550: this->comresp(this, this->audiofunc, CORB_GET_GPIO_ENABLE_MASK, 0, &mask);
! 2551: this->comresp(this, this->audiofunc, CORB_GET_GPIO_DIRECTION, 0, &dir);
! 2552:
! 2553: data |= 1 << pin;
! 2554: mask |= 1 << pin;
! 2555: dir |= 1 << pin;
! 2556:
! 2557: this->comresp(this, this->audiofunc, 0x7e7, 0, NULL);
! 2558: this->comresp(this, this->audiofunc, CORB_SET_GPIO_ENABLE_MASK, mask, NULL);
! 2559: this->comresp(this, this->audiofunc, CORB_SET_GPIO_DIRECTION, dir, NULL);
! 2560: DELAY(1000);
! 2561: this->comresp(this, this->audiofunc, CORB_SET_GPIO_DATA, data, NULL);
! 2562:
! 2563: return 0;
! 2564: }
! 2565:
! 2566: /* ----------------------------------------------------------------
! 2567: * Sony VAIO FE and SZ
! 2568: * ---------------------------------------------------------------- */
! 2569:
! 2570: int
! 2571: azalia_stac7661_init_dacgroup(codec_t *this)
! 2572: {
! 2573: static const convgroupset_t dacs = {
! 2574: -1, 1,
! 2575: {{2, {0x02, 0x05}}}};
! 2576:
! 2577: static const convgroupset_t adcs = {
! 2578: -1, 1,
! 2579: {{1, {0x08}}}};
! 2580:
! 2581: this->dacs = dacs;
! 2582: this->adcs = adcs;
! 2583:
! 2584: return 0;
! 2585: }
! 2586:
! 2587: static const mixer_item_t stac7661_mixer_items[] = {
! 2588: {{AZ_CLASS_INPUT, {AudioCinputs}, AUDIO_MIXER_CLASS, AZ_CLASS_INPUT, 0, 0}, 0},
! 2589: {{AZ_CLASS_OUTPUT, {AudioCoutputs}, AUDIO_MIXER_CLASS, AZ_CLASS_OUTPUT, 0, 0}, 0},
! 2590: {{AZ_CLASS_RECORD, {AudioCrecord}, AUDIO_MIXER_CLASS, AZ_CLASS_RECORD, 0, 0}, 0},
! 2591:
! 2592: #define STAC7661_DAC_HP 0x02
! 2593: #define STAC7661_DAC_SPEAKER 0x05
! 2594: #define STAC7661_TARGET_MASTER -1
! 2595:
! 2596: {{0, {AudioNvolume"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD, 0, 0,
! 2597: ENUM_OFFON}, 0x09, MI_TARGET_INAMP(0)},
! 2598: {{0, {AudioNvolume}, AUDIO_MIXER_VALUE, AZ_CLASS_RECORD, 0, 0,
! 2599: .un.v={{""}, 2, MIXER_DELTA(15)}}, 0x09, MI_TARGET_INAMP(0)},
! 2600: {{0, {AudioNsource}, AUDIO_MIXER_ENUM, AZ_CLASS_RECORD,
! 2601: 0, 0, .un.e={3, {{{AudioNmicrophone}, 1}, {{AudioNmicrophone"2"}, 2},
! 2602: {{AudioNdac}, 3}}}},
! 2603: 0x15, MI_TARGET_CONNLIST},
! 2604: {{0, {AudioNmaster}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 2605: 0, 0, .un.v={{""}, 2, MIXER_DELTA(127)}}, 0x02, STAC7661_TARGET_MASTER},
! 2606: {{0, {AudioNmaster"."AudioNmute}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2607: 0, 0, ENUM_OFFON}, 0x02, STAC7661_TARGET_MASTER},
! 2608: {{0, {AudioNvolume".knob"}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 2609: 0, 0, .un.v={{""}, 1, MIXER_DELTA(15)}}, 0x17, MI_TARGET_VOLUME},
! 2610: {{0, {AudioNheadphone".mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2611: 0, 0, ENUM_OFFON}, 0x02, MI_TARGET_OUTAMP},
! 2612: {{0, {AudioNheadphone}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 2613: 0, 0, .un.v={{""}, 2, MIXER_DELTA(127)}}, 0x02, MI_TARGET_OUTAMP},
! 2614: {{0, {AudioNspeaker".mute"}, AUDIO_MIXER_ENUM, AZ_CLASS_OUTPUT,
! 2615: 0, 0, ENUM_OFFON}, 0x05, MI_TARGET_OUTAMP},
! 2616: {{0, {AudioNspeaker}, AUDIO_MIXER_VALUE, AZ_CLASS_OUTPUT,
! 2617: 0, 0, .un.v={{""}, 2, MIXER_DELTA(127)}}, 0x05, MI_TARGET_OUTAMP}
! 2618: };
! 2619:
! 2620: int
! 2621: azalia_stac7661_mixer_init(codec_t *this)
! 2622: {
! 2623: mixer_ctrl_t mc;
! 2624:
! 2625: this->nmixers = sizeof(stac7661_mixer_items) / sizeof(mixer_item_t);
! 2626: this->mixers = malloc(sizeof(mixer_item_t) * this->nmixers,
! 2627: M_DEVBUF, M_NOWAIT);
! 2628: if (this->mixers == NULL) {
! 2629: printf("%s: out of memory in %s\n", XNAME(this), __func__);
! 2630: return ENOMEM;
! 2631: }
! 2632: bzero(this->mixers, sizeof(mixer_item_t) * this->maxmixers);
! 2633: memcpy(this->mixers, stac7661_mixer_items,
! 2634: sizeof(mixer_item_t) * this->nmixers);
! 2635: azalia_generic_mixer_fix_indexes(this);
! 2636: azalia_generic_mixer_default(this);
! 2637: mc.dev = -1;
! 2638: mc.type = AUDIO_MIXER_ENUM;
! 2639: mc.un.ord = 1;
! 2640: azalia_generic_mixer_set(this, 0x0a, MI_TARGET_PINDIR, &mc); /* headphones */
! 2641: azalia_generic_mixer_set(this, 0x0f, MI_TARGET_PINDIR, &mc); /* speaker */
! 2642: azalia_generic_mixer_set(this, 0x09, MI_TARGET_INAMP(0), &mc); /* mute input */
! 2643: mc.un.ord = 0;
! 2644: azalia_generic_mixer_set(this, 0x0d, MI_TARGET_PINDIR, &mc); /* mic */
! 2645: azalia_generic_mixer_set(this, 0x14, MI_TARGET_PINDIR, &mc); /* internal mic */
! 2646: mc.un.ord = 2; /* select internal mic for recording */
! 2647: azalia_generic_mixer_set(this, 0x15, MI_TARGET_CONNLIST, &mc);
! 2648: mc.type = AUDIO_MIXER_VALUE;
! 2649: mc.un.value.num_channels = 1;
! 2650: mc.un.value.level[0] = azalia_generic_mixer_max(this, 0x17, MI_TARGET_VOLUME);
! 2651: azalia_generic_mixer_set(this, 0x17, MI_TARGET_VOLUME, &mc);
! 2652:
! 2653: return 0;
! 2654: }
! 2655:
! 2656: int
! 2657: azalia_stac7661_set_port(codec_t *this, mixer_ctrl_t *mc)
! 2658: {
! 2659: const mixer_item_t *m;
! 2660: int err;
! 2661:
! 2662: if (mc->dev >= this->nmixers)
! 2663: return ENXIO;
! 2664: m = &this->mixers[mc->dev];
! 2665: if (mc->type != m->devinfo.type)
! 2666: return EINVAL;
! 2667: if (mc->type == AUDIO_MIXER_CLASS)
! 2668: return 0;
! 2669: if (m->target == STAC7661_TARGET_MASTER) {
! 2670: err = azalia_generic_mixer_set(this, STAC7661_DAC_HP,
! 2671: MI_TARGET_OUTAMP, mc);
! 2672: err = azalia_generic_mixer_set(this, STAC7661_DAC_SPEAKER,
! 2673: MI_TARGET_OUTAMP, mc);
! 2674: return err;
! 2675: }
! 2676: return azalia_generic_mixer_set(this, m->nid, m->target, mc);
! 2677: }
! 2678: int
! 2679: azalia_stac7661_get_port(codec_t *this, mixer_ctrl_t *mc)
! 2680: {
! 2681: const mixer_item_t *m;
! 2682:
! 2683: if (mc->dev >= this->nmixers)
! 2684: return ENXIO;
! 2685: m = &this->mixers[mc->dev];
! 2686: mc->type = m->devinfo.type;
! 2687: if (mc->type == AUDIO_MIXER_CLASS)
! 2688: return 0;
! 2689: if (m->target == STAC7661_TARGET_MASTER)
! 2690: return azalia_generic_mixer_get(this, m->nid,
! 2691: MI_TARGET_OUTAMP, mc);
! 2692: return azalia_generic_mixer_get(this, m->nid, m->target, mc);
! 2693: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to azalia_codec.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pci