Lines Matching +full:codec +full:- +full:analog +full:- +full:controls
1 // SPDX-License-Identifier: GPL-2.0-or-later
4 * Universal interface for Audio Codec '97
27 MODULE_DESCRIPTION("Universal interface for Audio Codec '97");
38 MODULE_PARM_DESC(power_save, "Automatic power-saving timeout "
55 { 0x41445300, 0xffffff00, "Analog Devices", NULL, NULL },
62 * currently used by the AC97 emulation of the almost-AC97 PCI168 card.
65 { 0x434d4900, 0xffffff00, "C-Media Electronics", NULL, NULL },
139 { 0x43585430, 0xffffffff, "Cx20468-31", patch_conexant, NULL },
152 { 0x4e534300, 0xffffffff, "LM4540,43,45,46,48", NULL, NULL }, // only guess --jk
161 { 0x54524123, 0xffffffff, "TR28602", NULL, NULL }, // only guess --jk [TR28023 = eMicro EM28023 (new CT1297)]
197 ((ac97->scaps & AC97_SCAP_POWER_SAVE) && power_save)
203 dev_err((ac97)->bus->card->dev, fmt, ##args)
205 dev_warn((ac97)->bus->card->dev, fmt, ##args)
207 dev_dbg((ac97)->bus->card->dev, fmt, ##args)
216 switch (ac97->id) {
238 case AC97_ID_AD1886A: /* AD1886A - !!verify!! --jk */
239 case AC97_ID_AD1887: /* AD1887 - !!verify!! --jk */
260 * snd_ac97_write - write a value on the given register
275 if ((ac97->id & 0xffffff00) == AC97_ID_ALC100) {
278 ac97->bus->ops->write(ac97, AC97_RESET, 0); /* reset audio codec */
280 ac97->bus->ops->write(ac97, reg, value);
286 * snd_ac97_read - read a value from the given register
300 return ac97->bus->ops->read(ac97, reg);
303 /* read a register - return the cached value if already read */
306 if (! test_bit(reg, ac97->reg_accessed)) {
307 ac97->regs[reg] = ac97->bus->ops->read(ac97, reg);
308 // set_bit(reg, ac97->reg_accessed);
310 return ac97->regs[reg];
316 * snd_ac97_write_cache - write a value on the given register and update the cache
322 * cache. The cached values are used for the cached-read and the
329 guard(mutex)(&ac97->reg_mutex);
330 ac97->regs[reg] = value;
331 ac97->bus->ops->write(ac97, reg, value);
332 set_bit(reg, ac97->reg_accessed);
338 * snd_ac97_update - update the value on the given register
354 return -EINVAL;
355 guard(mutex)(&ac97->reg_mutex);
356 change = ac97->regs[reg] != value;
358 ac97->regs[reg] = value;
359 ac97->bus->ops->write(ac97, reg, value);
361 set_bit(reg, ac97->reg_accessed);
368 * snd_ac97_update_bits - update the bits on the given register
371 * @mask: the bit-mask to change
374 * Updates the masked-bits on the given register only when the value
383 return -EINVAL;
384 guard(mutex)(&ac97->reg_mutex);
390 /* no lock version - see snd_ac97_update_bits() */
401 ac97->regs[reg] = new;
402 ac97->bus->ops->write(ac97, reg, new);
404 set_bit(reg, ac97->reg_accessed);
408 static int snd_ac97_ad18xx_update_pcm_bits(struct snd_ac97 *ac97, int codec, unsigned short mask, unsigned short value)
413 guard(mutex)(&ac97->page_mutex);
414 old = ac97->spec.ad18xx.pcmreg[codec];
418 guard(mutex)(&ac97->reg_mutex);
420 ac97->spec.ad18xx.pcmreg[codec] = new;
421 /* select single codec */
422 ac97->bus->ops->write(ac97, AC97_AD_SERIAL_CFG,
424 ac97->spec.ad18xx.unchained[codec] | ac97->spec.ad18xx.chained[codec]);
426 ac97->bus->ops->write(ac97, AC97_PCM, new);
428 ac97->bus->ops->write(ac97, AC97_AD_SERIAL_CFG,
435 * Controls
441 struct ac97_enum *e = (struct ac97_enum *)kcontrol->private_value;
443 return snd_ctl_enum_info(uinfo, e->shift_l == e->shift_r ? 1 : 2,
444 e->mask, e->texts);
451 struct ac97_enum *e = (struct ac97_enum *)kcontrol->private_value;
454 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
456 val = snd_ac97_read_cache(ac97, e->reg);
457 ucontrol->value.enumerated.item[0] = (val >> e->shift_l) & (bitmask - 1);
458 if (e->shift_l != e->shift_r)
459 ucontrol->value.enumerated.item[1] = (val >> e->shift_r) & (bitmask - 1);
468 struct ac97_enum *e = (struct ac97_enum *)kcontrol->private_value;
472 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
474 if (ucontrol->value.enumerated.item[0] > e->mask - 1)
475 return -EINVAL;
476 val = ucontrol->value.enumerated.item[0] << e->shift_l;
477 mask = (bitmask - 1) << e->shift_l;
478 if (e->shift_l != e->shift_r) {
479 if (ucontrol->value.enumerated.item[1] > e->mask - 1)
480 return -EINVAL;
481 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
482 mask |= (bitmask - 1) << e->shift_r;
484 return snd_ac97_update_bits(ac97, e->reg, mask, val);
490 int page_save = -1;
491 if ((kcontrol->private_value & (1<<25)) &&
492 (ac97->ext_id & AC97_EI_REV_MASK) >= AC97_EI_REV_23 &&
494 unsigned short page = (kcontrol->private_value >> 26) & 0x0f;
495 mutex_lock(&ac97->page_mutex); /* lock paging */
506 mutex_unlock(&ac97->page_mutex); /* unlock paging */
510 /* volume and switch controls */
514 int mask = (kcontrol->private_value >> 16) & 0xff;
515 int shift = (kcontrol->private_value >> 8) & 0x0f;
516 int rshift = (kcontrol->private_value >> 12) & 0x0f;
518 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
519 uinfo->count = shift == rshift ? 1 : 2;
520 uinfo->value.integer.min = 0;
521 uinfo->value.integer.max = mask;
529 int reg = kcontrol->private_value & 0xff;
530 int shift = (kcontrol->private_value >> 8) & 0x0f;
531 int rshift = (kcontrol->private_value >> 12) & 0x0f;
532 int mask = (kcontrol->private_value >> 16) & 0xff;
533 int invert = (kcontrol->private_value >> 24) & 0x01;
537 ucontrol->value.integer.value[0] = (snd_ac97_read_cache(ac97, reg) >> shift) & mask;
539 ucontrol->value.integer.value[1] = (snd_ac97_read_cache(ac97, reg) >> rshift) & mask;
541 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
543 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
553 int reg = kcontrol->private_value & 0xff;
554 int shift = (kcontrol->private_value >> 8) & 0x0f;
555 int rshift = (kcontrol->private_value >> 12) & 0x0f;
556 int mask = (kcontrol->private_value >> 16) & 0xff;
557 int invert = (kcontrol->private_value >> 24) & 0x01;
562 val = (ucontrol->value.integer.value[0] & mask);
564 val = mask - val;
568 val2 = (ucontrol->value.integer.value[1] & mask);
570 val2 = mask - val2;
577 /* check analog mixer power-down */
579 (kcontrol->private_value & (1<<30))) {
581 ac97->power_up &= ~(1 << (reg>>1));
583 ac97->power_up |= 1 << (reg>>1);
591 AC97_SINGLE("Tone Control - Bass", AC97_MASTER_TONE, 8, 15, 1),
592 AC97_SINGLE("Tone Control - Treble", AC97_MASTER_TONE, 0, 15, 1)
640 AC97_SINGLE("3D Control - Switch", AC97_GENERAL_PURPOSE, 13, 1, 0),
648 AC97_SINGLE("3D Control - Center", AC97_3D_CONTROL, 8, 15, 0),
649 AC97_SINGLE("3D Control - Depth", AC97_3D_CONTROL, 0, 15, 0)
666 AC97_SINGLE("Off-hook Switch", AC97_GPIO_STATUS, 0, 1, 0),
673 kctl->private_value = AC97_SINGLE_VALUE(AC97_POWERDOWN, 15, 1, 0);
675 ac97->scaps |= AC97_SCAP_INV_EAPD;
680 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
681 uinfo->count = 1;
687 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
691 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
693 ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS;
700 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
711 guard(mutex)(&ac97->reg_mutex);
712 ucontrol->value.iec958.status[0] = ac97->spdif_status & 0xff;
713 ucontrol->value.iec958.status[1] = (ac97->spdif_status >> 8) & 0xff;
714 ucontrol->value.iec958.status[2] = (ac97->spdif_status >> 16) & 0xff;
715 ucontrol->value.iec958.status[3] = (ac97->spdif_status >> 24) & 0xff;
726 new = val = ucontrol->value.iec958.status[0] & (IEC958_AES0_PROFESSIONAL|IEC958_AES0_NONAUDIO);
727 if (ucontrol->value.iec958.status[0] & IEC958_AES0_PROFESSIONAL) {
728 new |= ucontrol->value.iec958.status[0] & (IEC958_AES0_PRO_FS|IEC958_AES0_PRO_EMPHASIS_5015);
738 new |= ucontrol->value.iec958.status[0] & (IEC958_AES0_CON_EMPHASIS_5015|IEC958_AES0_CON_NOT_COPYRIGHT);
739 new |= ((ucontrol->value.iec958.status[1] & (IEC958_AES1_CON_CATEGORY|IEC958_AES1_CON_ORIGINAL)) << 8);
740 new |= ((ucontrol->value.iec958.status[3] & IEC958_AES3_CON_FS) << 24);
754 guard(mutex)(&ac97->reg_mutex);
755 change = ac97->spdif_status != new;
756 ac97->spdif_status = new;
758 if (ac97->flags & AC97_CS_SPDIF) {
766 } else if (ac97->flags & AC97_CX_SPDIF) {
773 } else if (ac97->id == AC97_ID_YMF743) {
795 int reg = kcontrol->private_value & 0xff;
796 int shift = (kcontrol->private_value >> 8) & 0x0f;
797 int mask = (kcontrol->private_value >> 16) & 0xff;
798 // int invert = (kcontrol->private_value >> 24) & 0xff;
802 value = (ucontrol->value.integer.value[0] & mask);
804 guard(mutex)(&ac97->reg_mutex);
847 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "AC97-SPSA",
855 #define AD18XX_PCM_BITS(xname, codec, lshift, rshift, mask) \
858 .private_value = (codec) | ((lshift) << 8) | ((rshift) << 12) | ((mask) << 16) }
863 int mask = (kcontrol->private_value >> 16) & 0x0f;
864 int lshift = (kcontrol->private_value >> 8) & 0x0f;
865 int rshift = (kcontrol->private_value >> 12) & 0x0f;
867 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
868 if (lshift != rshift && (ac97->flags & AC97_STEREO_MUTES))
869 uinfo->count = 2;
871 uinfo->count = 1;
872 uinfo->value.integer.min = 0;
873 uinfo->value.integer.max = mask;
880 int codec = kcontrol->private_value & 3;
881 int lshift = (kcontrol->private_value >> 8) & 0x0f;
882 int rshift = (kcontrol->private_value >> 12) & 0x0f;
883 int mask = (kcontrol->private_value >> 16) & 0xff;
885 ucontrol->value.integer.value[0] = mask - ((ac97->spec.ad18xx.pcmreg[codec] >> lshift) & mask);
886 if (lshift != rshift && (ac97->flags & AC97_STEREO_MUTES))
887 ucontrol->value.integer.value[1] = mask - ((ac97->spec.ad18xx.pcmreg[codec] >> rshift) & mask);
894 int codec = kcontrol->private_value & 3;
895 int lshift = (kcontrol->private_value >> 8) & 0x0f;
896 int rshift = (kcontrol->private_value >> 12) & 0x0f;
897 int mask = (kcontrol->private_value >> 16) & 0xff;
900 val = (mask - (ucontrol->value.integer.value[0] & mask)) << lshift;
902 if (lshift != rshift && (ac97->flags & AC97_STEREO_MUTES)) {
903 val |= (mask - (ucontrol->value.integer.value[1] & mask)) << rshift;
906 return snd_ac97_ad18xx_update_pcm_bits(ac97, codec, valmask, val);
909 #define AD18XX_PCM_VOLUME(xname, codec) \
912 .private_value = codec }
916 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
917 uinfo->count = 2;
918 uinfo->value.integer.min = 0;
919 uinfo->value.integer.max = 31;
926 int codec = kcontrol->private_value & 3;
928 guard(mutex)(&ac97->page_mutex);
929 ucontrol->value.integer.value[0] = 31 - ((ac97->spec.ad18xx.pcmreg[codec] >> 8) & 31);
930 ucontrol->value.integer.value[1] = 31 - ((ac97->spec.ad18xx.pcmreg[codec] >> 0) & 31);
937 int codec = kcontrol->private_value & 3;
940 val1 = 31 - (ucontrol->value.integer.value[0] & 31);
941 val2 = 31 - (ucontrol->value.integer.value[1] & 31);
942 return snd_ac97_ad18xx_update_pcm_bits(ac97, codec, 0x1f1f, (val1 << 8) | val2);
975 kfree(bus->pcms);
976 if (bus->private_free)
977 bus->private_free(bus);
985 struct snd_ac97_bus *bus = device->device_data;
993 cancel_delayed_work_sync(&ac97->power_work);
996 if (ac97->bus)
997 ac97->bus->codec[ac97->num] = NULL;
998 if (ac97->private_free)
999 ac97->private_free(ac97);
1007 struct snd_ac97 *ac97 = device->device_data;
1021 return ac97->caps & AC97_BC_BASS_TREBLE ? 1 : 0;
1023 return ac97->caps & AC97_BC_HEADPHONE ? 1 : 0;
1025 return ac97->caps & AC97_BC_DEDICATED_MIC ? 1 : 0;
1027 if (ac97->caps & AC97_BC_3D_TECH_ID_MASK) {
1029 /* if nonzero - fixed and we can't set it */
1034 if ((ac97->ext_id & AC97_EI_CDAC) == 0)
1038 if ((ac97->ext_id & AC97_EI_LDAC) == 0)
1044 if ((ac97->ext_id & AC97_EI_SDAC) == 0)
1051 /* nothing seems to be here - mute flag is not set */
1069 if (ac97->res_table) {
1071 for (tbl = ac97->res_table; tbl->reg; tbl++) {
1072 if (tbl->reg == reg) {
1073 *lo_max = tbl->bits & 0xff;
1074 *hi_max = (tbl->bits >> 8) & 0xff;
1136 return x - 0x71 + 'A';
1147 template.index = ac97->num;
1152 * create mute switch(es) for normal stereo controls
1167 if (check_stereo || (ac97->flags & AC97_STEREO_MUTES)) {
1178 tmp.index = ac97->num;
1184 tmp.index = ac97->num;
1198 static const DECLARE_TLV_DB_SCALE(db_scale_4bit, -4500, 300, 0);
1199 static const DECLARE_TLV_DB_SCALE(db_scale_5bit, -4650, 150, 0);
1200 static const DECLARE_TLV_DB_SCALE(db_scale_6bit, -9450, 150, 0);
1201 static const DECLARE_TLV_DB_SCALE(db_scale_5bit_12db_max, -3450, 150, 0);
1216 kctl->tlv.p = tlv;
1218 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
1222 * create a volume for normal stereo/mono controls
1235 tmp.index = ac97->num;
1240 tmp.index = ac97->num;
1244 return -ENOMEM;
1261 * create a mute-switch and a volume for normal stereo/mono controls
1301 struct snd_card *card = ac97->bus->card;
1307 /* build master controls */
1310 if (ac97->flags & AC97_HAS_NO_MASTER_VOL)
1320 ac97->regs[AC97_CENTER_LFE_MASTER] = AC97_MUTE_MASK_STEREO;
1322 /* build center controls */
1324 && !(ac97->flags & AC97_AD_MULTI)) {
1332 kctl->private_value &= ~(0xff << 16);
1333 kctl->private_value |= (int)max << 16;
1335 snd_ac97_write_cache(ac97, AC97_CENTER_LFE_MASTER, ac97->regs[AC97_CENTER_LFE_MASTER] | max);
1338 /* build LFE controls */
1340 && !(ac97->flags & AC97_AD_MULTI)) {
1348 kctl->private_value &= ~(0xff << 16);
1349 kctl->private_value |= (int)max << 16;
1351 snd_ac97_write_cache(ac97, AC97_CENTER_LFE_MASTER, ac97->regs[AC97_CENTER_LFE_MASTER] | max << 8);
1354 /* build surround controls */
1356 && !(ac97->flags & AC97_AD_MULTI)) {
1365 /* build headphone controls */
1373 /* build master mono controls */
1381 /* build master tone controls */
1382 if (!(ac97->flags & AC97_HAS_NO_TONE)) {
1389 if (ac97->id == AC97_ID_YMF743 ||
1390 ac97->id == AC97_ID_YMF753) {
1391 kctl->private_value &= ~(0xff << 16);
1392 kctl->private_value |= 7 << 16;
1399 /* build Beep controls */
1400 if (!(ac97->flags & AC97_HAS_NO_PC_BEEP) &&
1401 ((ac97->flags & AC97_HAS_PC_BEEP) ||
1418 /* build Phone controls */
1419 if (!(ac97->flags & AC97_HAS_NO_PHONE)) {
1428 /* build MIC controls */
1429 if (!(ac97->flags & AC97_HAS_NO_MIC)) {
1441 /* build Line controls */
1449 /* build CD controls */
1450 if (!(ac97->flags & AC97_HAS_NO_CD)) {
1459 /* build Video controls */
1460 if (!(ac97->flags & AC97_HAS_NO_VIDEO)) {
1469 /* build Aux controls */
1470 if (!(ac97->flags & AC97_HAS_NO_AUX)) {
1479 /* build PCM controls */
1480 if (ac97->flags & AC97_AD_MULTI) {
1482 if (ac97->flags & AC97_STEREO_MUTES)
1493 ac97->spec.ad18xx.pcmreg[0] = init_val;
1494 if (ac97->scaps & AC97_SCAP_SURROUND_DAC) {
1502 ac97->spec.ad18xx.pcmreg[1] = init_val;
1504 if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC) {
1519 ac97->spec.ad18xx.pcmreg[2] = init_val;
1523 if (!(ac97->flags & AC97_HAS_NO_STD_PCM)) {
1524 if (ac97->flags & AC97_HAS_NO_PCM_VOL)
1536 /* build Capture controls */
1537 if (!(ac97->flags & AC97_HAS_NO_REC_GAIN)) {
1555 /* build MIC Capture controls */
1575 if (ac97->caps & AC97_BC_SIM_STEREO) {
1589 if (ac97->caps & AC97_BC_LOUDNESS) {
1618 /* build 3D controls */
1619 if (ac97->build_ops->build_3d) {
1620 ac97->build_ops->build_3d(ac97);
1633 kctl->private_value = AC97_3D_CONTROL | (9 << 8) | (7 << 16);
1639 kctl->private_value = AC97_3D_CONTROL | (1 << 8) | (7 << 16);
1644 /* build S/PDIF controls */
1646 /* Hack for ASUS P5P800-VM, which does not indicate S/PDIF capability */
1647 if (ac97->subsystem_vendor == 0x1043 &&
1648 ac97->subsystem_device == 0x810f)
1649 ac97->ext_id |= AC97_EI_SPDIF;
1651 if ((ac97->ext_id & AC97_EI_SPDIF) && !(ac97->scaps & AC97_SCAP_NO_SPDIF)) {
1652 if (ac97->build_ops->build_spdif) {
1653 err = ac97->build_ops->build_spdif(ac97);
1662 if (ac97->build_ops->build_post_spdif) {
1663 err = ac97->build_ops->build_post_spdif(ac97);
1670 ac97->rates[AC97_RATES_SPDIF] = snd_ac97_determine_spdif_rates(ac97);
1672 ac97->spdif_status = SNDRV_PCM_DEFAULT_CON_SPDIF;
1675 /* build chip specific controls */
1676 if (ac97->build_ops->build_specific) {
1677 err = ac97->build_ops->build_specific(ac97);
1685 return -ENOMEM;
1686 if (ac97->scaps & AC97_SCAP_INV_EAPD)
1717 /* build chip specific controls */
1718 if (ac97->build_ops->build_specific) {
1719 err = ac97->build_ops->build_specific(ac97);
1732 tmp = ((unsigned int)rate * ac97->bus->clock) / 48000;
1745 if (ac97->bus->no_vra) {
1747 if ((ac97->flags & AC97_DOUBLE_RATE) &&
1754 if ((ac97->ext_id & AC97_EI_DRA) && reg == AC97_PCM_FRONT_DAC_RATE)
1757 /* test a non-standard rate */
1775 if ((ac97->flags & AC97_DOUBLE_RATE) &&
1819 /* look for the codec id table matching with the given id */
1825 for (pid = table; pid->id; pid++)
1826 if (pid->id == (id & pid->mask))
1844 strscpy(name, pid->name, maxlen);
1845 if (ac97 && pid->patch) {
1846 if ((modem && (pid->flags & AC97_MODEM_PATCH)) ||
1847 (! modem && ! (pid->flags & AC97_MODEM_PATCH)))
1848 pid->patch(ac97);
1854 strlcat(name, pid->name, maxlen);
1855 if (pid->mask != 0xffffffff)
1856 sprintf(name + strlen(name), " rev %u", id & ~pid->mask);
1857 if (ac97 && pid->patch) {
1858 if ((modem && (pid->flags & AC97_MODEM_PATCH)) ||
1859 (! modem && ! (pid->flags & AC97_MODEM_PATCH)))
1860 pid->patch(ac97);
1864 snprintf(name + l, maxlen - l, " id %x", id & 0xff);
1869 * snd_ac97_get_short_name - retrieve codec name
1870 * @ac97: the codec instance
1872 * Return: The short identifying name of the codec.
1878 for (pid = snd_ac97_codec_ids; pid->id; pid++)
1879 if (pid->id == (ac97->id & pid->mask))
1880 return pid->name;
1881 return "unknown codec";
1907 if (ac97->scaps & AC97_SCAP_DETECT_BY_VENDOR) {
1908 /* probably only Xbox issue - all registers are read as zero */
1923 return -ENODEV;
1927 * snd_ac97_bus - create an AC97 bus component
1941 * ``(*rbus)->clock`` manually.
1943 * The AC97 bus instance is registered as a low-level device, so you don't
1959 return -EINVAL;
1962 return -ENOMEM;
1963 bus->card = card;
1964 bus->num = num;
1965 bus->ops = ops;
1966 bus->private_data = private_data;
1967 bus->clock = 48000;
1968 spin_lock_init(&bus->bus_lock);
1987 /* register ac97 codec to bus */
1990 struct snd_ac97 *ac97 = device->device_data;
1993 ac97->dev.bus = &ac97_bus_type;
1994 ac97->dev.parent = ac97->bus->card->dev;
1995 ac97->dev.release = ac97_device_release;
1996 dev_set_name(&ac97->dev, "%d-%d:%s",
1997 ac97->bus->card->number, ac97->num,
1999 err = device_register(&ac97->dev);
2002 put_device(&ac97->dev);
2003 ac97->dev.bus = NULL;
2009 /* disconnect ac97 codec */
2012 struct snd_ac97 *ac97 = device->device_data;
2013 if (ac97->dev.bus)
2014 device_unregister(&ac97->dev);
2030 * snd_ac97_mixer - create an Codec97 component
2031 * @bus: the AC97 bus which codec is attached to
2037 * allocated and initialized from the template. The codec
2040 * The template must include the codec number (num) and address (addr),
2043 * The ac97 instance is registered as a low-level device, so you don't
2064 return -EINVAL;
2066 if (snd_BUG_ON(template->num >= 4))
2067 return -EINVAL;
2068 if (bus->codec[template->num])
2069 return -EBUSY;
2071 card = bus->card;
2074 return -ENOMEM;
2075 ac97->private_data = template->private_data;
2076 ac97->private_free = template->private_free;
2077 ac97->bus = bus;
2078 ac97->pci = template->pci;
2079 ac97->num = template->num;
2080 ac97->addr = template->addr;
2081 ac97->scaps = template->scaps;
2082 ac97->res_table = template->res_table;
2083 bus->codec[ac97->num] = ac97;
2084 mutex_init(&ac97->reg_mutex);
2085 mutex_init(&ac97->page_mutex);
2087 INIT_DELAYED_WORK(&ac97->power_work, do_update_power);
2091 if (ac97->pci) {
2092 pci_read_config_word(ac97->pci, PCI_SUBSYSTEM_VENDOR_ID, &ac97->subsystem_vendor);
2093 pci_read_config_word(ac97->pci, PCI_SUBSYSTEM_ID, &ac97->subsystem_device);
2096 if (bus->ops->reset) {
2097 bus->ops->reset(ac97);
2101 ac97->id = snd_ac97_read(ac97, AC97_VENDOR_ID1) << 16;
2102 ac97->id |= snd_ac97_read(ac97, AC97_VENDOR_ID2);
2103 if (ac97->id && ac97->id != (unsigned int)-1) {
2104 pid = look_for_codec_id(snd_ac97_codec_ids, ac97->id);
2105 if (pid && (pid->flags & AC97_DEFAULT_POWER_OFF))
2110 if (!(ac97->scaps & AC97_SCAP_SKIP_AUDIO))
2112 if (!(ac97->scaps & AC97_SCAP_SKIP_MODEM))
2114 if (bus->ops->wait)
2115 bus->ops->wait(ac97);
2118 if (ac97->scaps & AC97_SCAP_SKIP_AUDIO)
2127 ac97_warn(ac97, "AC'97 %d does not respond - RESET\n",
2128 ac97->num);
2129 /* proceed anyway - it's often non-critical */
2133 ac97->id = snd_ac97_read(ac97, AC97_VENDOR_ID1) << 16;
2134 ac97->id |= snd_ac97_read(ac97, AC97_VENDOR_ID2);
2135 if (! (ac97->scaps & AC97_SCAP_DETECT_BY_VENDOR) &&
2136 (ac97->id == 0x00000000 || ac97->id == 0xffffffff)) {
2139 ac97->num, ac97->id);
2141 return -EIO;
2143 pid = look_for_codec_id(snd_ac97_codec_ids, ac97->id);
2145 ac97->flags |= pid->flags;
2148 if (!(ac97->scaps & AC97_SCAP_SKIP_AUDIO) && !(ac97->scaps & AC97_SCAP_AUDIO)) {
2153 ac97->scaps |= AC97_SCAP_AUDIO;
2155 if (ac97->scaps & AC97_SCAP_AUDIO) {
2156 ac97->caps = snd_ac97_read(ac97, AC97_RESET);
2157 ac97->ext_id = snd_ac97_read(ac97, AC97_EXTENDED_ID);
2158 if (ac97->ext_id == 0xffff) /* invalid combination */
2159 ac97->ext_id = 0;
2163 if (!(ac97->scaps & AC97_SCAP_SKIP_MODEM) && !(ac97->scaps & AC97_SCAP_MODEM)) {
2164 ac97->ext_mid = snd_ac97_read(ac97, AC97_EXTENDED_MID);
2165 if (ac97->ext_mid == 0xffff) /* invalid combination */
2166 ac97->ext_mid = 0;
2167 if (ac97->ext_mid & 1)
2168 ac97->scaps |= AC97_SCAP_MODEM;
2172 if (!(ac97->scaps & (AC97_SCAP_SKIP_AUDIO|AC97_SCAP_SKIP_MODEM)))
2174 "AC'97 %d access error (not audio or modem codec)\n",
2175 ac97->num);
2177 return -EACCES;
2180 if (bus->ops->reset) // FIXME: always skipping?
2187 if (! (ac97->flags & AC97_DEFAULT_POWER_OFF)) {
2201 "AC'97 %d analog subsections not ready\n", ac97->num);
2211 if (ac97->ext_mid & AC97_MEI_LINE1) {
2215 if (ac97->ext_mid & AC97_MEI_LINE2) {
2219 if (ac97->ext_mid & AC97_MEI_HANDSET) {
2235 ac97->num,
2241 ac97->addr = (ac97->ext_id & AC97_EI_ADDR_MASK) >> AC97_EI_ADDR_SHIFT;
2243 ac97->addr = (ac97->ext_mid & AC97_MEI_ADDR_MASK) >> AC97_MEI_ADDR_SHIFT;
2244 if (ac97->ext_id & 0x01c9) { /* L/R, MIC, SDAC, LDAC VRA support */
2246 reg |= ac97->ext_id & 0x01c0; /* LDAC/SDAC/CDAC */
2247 if (! bus->no_vra)
2248 reg |= ac97->ext_id & 0x0009; /* VRA/VRM */
2251 if ((ac97->ext_id & AC97_EI_DRA) && bus->dra) {
2253 * slots 7+8, so let's hope the codec supports it. */
2256 ac97->flags |= AC97_DOUBLE_RATE;
2260 if (ac97->ext_id & AC97_EI_VRA) { /* VRA support */
2261 snd_ac97_determine_rates(ac97, AC97_PCM_FRONT_DAC_RATE, 0, &ac97->rates[AC97_RATES_FRONT_DAC]);
2262 snd_ac97_determine_rates(ac97, AC97_PCM_LR_ADC_RATE, 0, &ac97->rates[AC97_RATES_ADC]);
2264 ac97->rates[AC97_RATES_FRONT_DAC] = SNDRV_PCM_RATE_48000;
2265 if (ac97->flags & AC97_DOUBLE_RATE)
2266 ac97->rates[AC97_RATES_FRONT_DAC] |= SNDRV_PCM_RATE_96000;
2267 ac97->rates[AC97_RATES_ADC] = SNDRV_PCM_RATE_48000;
2269 if (ac97->ext_id & AC97_EI_SPDIF) {
2270 /* codec specific code (patch) should override these values */
2271 ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_32000;
2273 if (ac97->ext_id & AC97_EI_VRM) { /* MIC VRA support */
2274 snd_ac97_determine_rates(ac97, AC97_PCM_MIC_ADC_RATE, 0, &ac97->rates[AC97_RATES_MIC_ADC]);
2276 ac97->rates[AC97_RATES_MIC_ADC] = SNDRV_PCM_RATE_48000;
2278 if (ac97->ext_id & AC97_EI_SDAC) { /* SDAC support */
2279 snd_ac97_determine_rates(ac97, AC97_PCM_SURR_DAC_RATE, AC97_PCM_FRONT_DAC_RATE, &ac97->rates[AC97_RATES_SURR_DAC]);
2280 ac97->scaps |= AC97_SCAP_SURROUND_DAC;
2282 if (ac97->ext_id & AC97_EI_LDAC) { /* LDAC support */
2283 snd_ac97_determine_rates(ac97, AC97_PCM_LFE_DAC_RATE, AC97_PCM_FRONT_DAC_RATE, &ac97->rates[AC97_RATES_LFE_DAC]);
2284 ac97->scaps |= AC97_SCAP_CENTER_LFE_DAC;
2287 if (bus->ops->init)
2288 bus->ops->init(ac97);
2289 snd_ac97_get_name(ac97, ac97->id, name, sizeof(name), !ac97_is_audio(ac97));
2290 snd_ac97_get_name(NULL, ac97->id, name, sizeof(name), !ac97_is_audio(ac97)); // ac97->id might be changed in the special setup code
2291 if (! ac97->build_ops)
2292 ac97->build_ops = &null_build_ops;
2296 if (card->mixername[0] == '\0') {
2297 strscpy(card->mixername, name);
2299 if (strlen(card->mixername) + 1 + strlen(name) + 1 <= sizeof(card->mixername)) {
2300 strcat(card->mixername, ",");
2301 strcat(card->mixername, name);
2304 sprintf(comp, "AC97a:%08x", ac97->id);
2312 return -ENOMEM;
2317 if (card->mixername[0] == '\0') {
2318 strscpy(card->mixername, name);
2320 if (strlen(card->mixername) + 1 + strlen(name) + 1 <= sizeof(card->mixername)) {
2321 strcat(card->mixername, ",");
2322 strcat(card->mixername, name);
2325 sprintf(comp, "AC97m:%08x", ac97->id);
2333 return -ENOMEM;
2367 power = ac97->regs[AC97_EXTENDED_STATUS];
2368 if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
2370 if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)
2376 if (ac97->scaps & AC97_SCAP_INV_EAPD)
2377 power = ac97->regs[AC97_POWERDOWN] & ~AC97_PD_EAPD;
2378 else if (! (ac97->scaps & AC97_SCAP_EAPD_LED))
2379 power = ac97->regs[AC97_POWERDOWN] | AC97_PD_EAPD;
2384 power |= AC97_PD_PR2; /* Analog Mixer powerdown (Vref on) */
2387 power |= AC97_PD_PR3; /* Analog Mixer powerdown */
2390 /* AC-link powerdown, internal Clk disable */
2419 * snd_ac97_update_power - update the powerdown register
2420 * @ac97: the codec instance
2422 * @powerup: non-zero when power up the part
2442 ac97->power_up |= (1 << i);
2444 ac97->power_up &= ~(1 << i);
2451 /* adjust power-down bits after two seconds delay
2455 schedule_delayed_work(&ac97->power_work, secs_to_jiffies(power_save));
2457 cancel_delayed_work(&ac97->power_work);
2474 if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
2476 if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)
2480 power_up = ac97->power_up;
2483 if (ac97->regs[AC97_POWERDOWN] & AC97_PD_PR2) {
2484 /* needs power-up analog mix and vref */
2501 if (! (ac97->regs[AC97_POWERDOWN] & AC97_PD_PR2)) {
2502 /* power down analog mix and vref */
2514 * snd_ac97_suspend - General suspend function for AC97 codec
2517 * Suspends the codec, power down the chip.
2523 if (ac97->build_ops->suspend)
2524 ac97->build_ops->suspend(ac97);
2526 cancel_delayed_work_sync(&ac97->power_work);
2547 if (test_bit(i, ac97->reg_accessed)) {
2548 snd_ac97_write(ac97, i, ac97->regs[i]);
2559 if (ac97->ext_id & AC97_EI_SPDIF) {
2560 if (ac97->regs[AC97_EXTENDED_STATUS] & AC97_EA_SPDIF) {
2563 snd_ac97_write(ac97, AC97_EXTENDED_STATUS, ac97->regs[AC97_EXTENDED_STATUS]);
2564 if (ac97->flags & AC97_CS_SPDIF)
2565 snd_ac97_write(ac97, AC97_CSR_SPDIF, ac97->regs[AC97_CSR_SPDIF]);
2567 snd_ac97_write(ac97, AC97_SPDIF, ac97->regs[AC97_SPDIF]);
2574 * snd_ac97_resume - General resume function for AC97 codec
2587 if (ac97->bus->ops->reset) {
2588 ac97->bus->ops->reset(ac97);
2593 if (! (ac97->flags & AC97_DEFAULT_POWER_OFF)) {
2594 if (!(ac97->scaps & AC97_SCAP_SKIP_AUDIO))
2596 else if (!(ac97->scaps & AC97_SCAP_SKIP_MODEM))
2603 snd_ac97_write(ac97, AC97_POWERDOWN, ac97->regs[AC97_POWERDOWN]);
2605 ac97->bus->ops->write(ac97, AC97_MASTER, 0x8101);
2613 ac97->bus->ops->write(ac97, AC97_MASTER, AC97_MUTE_MASK_MONO);
2627 if (ac97->bus->ops->init)
2628 ac97->bus->ops->init(ac97);
2630 if (ac97->build_ops->resume)
2631 ac97->build_ops->resume(ac97);
2668 return snd_ctl_remove_id(ac97->bus->card, &id);
2677 return snd_ctl_find_id(ac97->bus->card, &sid);
2689 snd_ctl_rename(ac97->bus->card, kctl, name);
2692 return -ENOENT;
2695 /* rename both Volume and Switch controls - don't check the return value */
2703 /* swap controls */
2714 snd_ctl_rename(ac97->bus->card, kctl1, name);
2717 snd_ctl_rename(ac97->bus->card, kctl2, name);
2721 return -ENOENT;
2725 /* bind hp and master controls instead of using only hp control */
2730 unsigned long priv_saved = kcontrol->private_value;
2731 kcontrol->private_value = (kcontrol->private_value & ~0xff) | AC97_HEADPHONE;
2733 kcontrol->private_value = priv_saved;
2738 /* ac97 tune: bind Master and Headphone controls */
2744 return -ENOENT;
2745 msw->put = bind_hp_volsw_put;
2746 mvol->put = bind_hp_volsw_put;
2757 return -ENOENT;
2765 /* ac97 tune: swap Headphone and Master controls */
2769 return -ENOENT;
2770 snd_ac97_rename_vol_ctl(ac97, "Master Playback", "Line-Out Playback");
2775 /* ac97 tune: swap Surround and Master controls */
2780 return -ENOENT;
2788 if ((ac97->id & 0xffffff00) != 0x41445300) {
2790 return -EINVAL;
2801 /* ac97 tune: set up ALC jack-select */
2804 if ((ac97->id & 0xffffff00) != 0x414c4700) {
2807 return -EINVAL;
2810 snd_ac97_update_bits(ac97, 0x7a, 0x01, 0x01); /* Line-out auto mute */
2811 if (ac97->id == AC97_ID_ALC658D)
2813 return snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&snd_ac97_alc_jack_detect, ac97));
2821 return -ENOENT;
2831 int shift = (kcontrol->private_value >> 8) & 0x0f;
2832 int rshift = (kcontrol->private_value >> 12) & 0x0f;
2839 (ac97->regs[AC97_MASTER] & mask) == mask ?
2845 /* ac97 tune: EAPD controls mute LED bound with the master mute */
2850 return -ENOENT;
2851 msw->put = master_mute_sw_put;
2857 ac97->scaps |= AC97_SCAP_EAPD_LED;
2867 int shift = (kcontrol->private_value >> 8) & 0x0f;
2868 int rshift = (kcontrol->private_value >> 12) & 0x0f;
2875 (ac97->regs[AC97_MASTER] & mask) == mask ?
2886 return -ENOENT;
2887 msw->put = hp_master_mute_sw_put;
2888 mvol->put = bind_hp_volsw_put;
2922 return -EINVAL;
2936 if (q->name && ! strcmp(typestr, q->name))
2942 return -EINVAL;
2946 * snd_ac97_tune_hardware - tune up the hardware
2949 * @override: explicit quirk value (overrides the list if non-NULL)
2952 * headphone (true line-out) control as "Master".
2953 * The quirk-list must be terminated with a zero-filled entry.
2964 if (override && strcmp(override, "-1") && strcmp(override, "default")) {
2973 return -EINVAL;
2975 for (; quirk->subvendor; quirk++) {
2976 if (quirk->subvendor != ac97->subsystem_vendor)
2978 if ((! quirk->mask && quirk->subdevice == ac97->subsystem_device) ||
2979 quirk->subdevice == (quirk->mask & ac97->subsystem_device)) {
2980 if (quirk->codec_id && quirk->codec_id != ac97->id)
2983 quirk->name, ac97->subsystem_vendor,
2984 ac97->subsystem_device);
2985 result = apply_quirk(ac97, quirk->type);
2989 quirk->type, quirk->name, result);