11a59d1b8SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
21da177e4SLinus Torvalds /*
3c1017a4cSJaroslav Kysela * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
41da177e4SLinus Torvalds * Universal interface for Audio Codec '97
51da177e4SLinus Torvalds *
61da177e4SLinus Torvalds * For more details look to AC '97 component specification revision 2.2
71da177e4SLinus Torvalds * by Intel Corporation (http://developer.intel.com) and to datasheets
81da177e4SLinus Torvalds * for specific codecs.
91da177e4SLinus Torvalds */
101da177e4SLinus Torvalds
111da177e4SLinus Torvalds #include <linux/delay.h>
121da177e4SLinus Torvalds #include <linux/init.h>
131da177e4SLinus Torvalds #include <linux/slab.h>
1462932df8SIngo Molnar #include <linux/mutex.h>
15d81a6d71SPaul Gortmaker #include <linux/export.h>
1662932df8SIngo Molnar
171da177e4SLinus Torvalds #include <sound/core.h>
181da177e4SLinus Torvalds #include <sound/pcm.h>
191da177e4SLinus Torvalds #include <sound/control.h>
201da177e4SLinus Torvalds #include <sound/ac97_codec.h>
211da177e4SLinus Torvalds #include <sound/asoundef.h>
221da177e4SLinus Torvalds #include "ac97_id.h"
231da177e4SLinus Torvalds #include "ac97_local.h"
241da177e4SLinus Torvalds
251da177e4SLinus Torvalds /*
261da177e4SLinus Torvalds * PCM support
271da177e4SLinus Torvalds */
281da177e4SLinus Torvalds
291675bfc0STakashi Iwai static const unsigned char rate_reg_tables[2][4][9] = {
301da177e4SLinus Torvalds {
311da177e4SLinus Torvalds /* standard rates */
321da177e4SLinus Torvalds {
331da177e4SLinus Torvalds /* 3&4 front, 7&8 rear, 6&9 center/lfe */
341da177e4SLinus Torvalds AC97_PCM_FRONT_DAC_RATE, /* slot 3 */
351da177e4SLinus Torvalds AC97_PCM_FRONT_DAC_RATE, /* slot 4 */
361da177e4SLinus Torvalds 0xff, /* slot 5 */
371da177e4SLinus Torvalds AC97_PCM_LFE_DAC_RATE, /* slot 6 */
381da177e4SLinus Torvalds AC97_PCM_SURR_DAC_RATE, /* slot 7 */
391da177e4SLinus Torvalds AC97_PCM_SURR_DAC_RATE, /* slot 8 */
401da177e4SLinus Torvalds AC97_PCM_LFE_DAC_RATE, /* slot 9 */
411da177e4SLinus Torvalds 0xff, /* slot 10 */
421da177e4SLinus Torvalds 0xff, /* slot 11 */
431da177e4SLinus Torvalds },
441da177e4SLinus Torvalds {
451da177e4SLinus Torvalds /* 7&8 front, 6&9 rear, 10&11 center/lfe */
461da177e4SLinus Torvalds 0xff, /* slot 3 */
471da177e4SLinus Torvalds 0xff, /* slot 4 */
481da177e4SLinus Torvalds 0xff, /* slot 5 */
491da177e4SLinus Torvalds AC97_PCM_SURR_DAC_RATE, /* slot 6 */
501da177e4SLinus Torvalds AC97_PCM_FRONT_DAC_RATE, /* slot 7 */
511da177e4SLinus Torvalds AC97_PCM_FRONT_DAC_RATE, /* slot 8 */
521da177e4SLinus Torvalds AC97_PCM_SURR_DAC_RATE, /* slot 9 */
531da177e4SLinus Torvalds AC97_PCM_LFE_DAC_RATE, /* slot 10 */
541da177e4SLinus Torvalds AC97_PCM_LFE_DAC_RATE, /* slot 11 */
551da177e4SLinus Torvalds },
561da177e4SLinus Torvalds {
571da177e4SLinus Torvalds /* 6&9 front, 10&11 rear, 3&4 center/lfe */
581da177e4SLinus Torvalds AC97_PCM_LFE_DAC_RATE, /* slot 3 */
591da177e4SLinus Torvalds AC97_PCM_LFE_DAC_RATE, /* slot 4 */
601da177e4SLinus Torvalds 0xff, /* slot 5 */
611da177e4SLinus Torvalds AC97_PCM_FRONT_DAC_RATE, /* slot 6 */
621da177e4SLinus Torvalds 0xff, /* slot 7 */
631da177e4SLinus Torvalds 0xff, /* slot 8 */
641da177e4SLinus Torvalds AC97_PCM_FRONT_DAC_RATE, /* slot 9 */
651da177e4SLinus Torvalds AC97_PCM_SURR_DAC_RATE, /* slot 10 */
661da177e4SLinus Torvalds AC97_PCM_SURR_DAC_RATE, /* slot 11 */
671da177e4SLinus Torvalds },
681da177e4SLinus Torvalds {
691da177e4SLinus Torvalds /* 10&11 front, 3&4 rear, 7&8 center/lfe */
701da177e4SLinus Torvalds AC97_PCM_SURR_DAC_RATE, /* slot 3 */
711da177e4SLinus Torvalds AC97_PCM_SURR_DAC_RATE, /* slot 4 */
721da177e4SLinus Torvalds 0xff, /* slot 5 */
731da177e4SLinus Torvalds 0xff, /* slot 6 */
741da177e4SLinus Torvalds AC97_PCM_LFE_DAC_RATE, /* slot 7 */
751da177e4SLinus Torvalds AC97_PCM_LFE_DAC_RATE, /* slot 8 */
761da177e4SLinus Torvalds 0xff, /* slot 9 */
771da177e4SLinus Torvalds AC97_PCM_FRONT_DAC_RATE, /* slot 10 */
781da177e4SLinus Torvalds AC97_PCM_FRONT_DAC_RATE, /* slot 11 */
791da177e4SLinus Torvalds },
801da177e4SLinus Torvalds },
811da177e4SLinus Torvalds {
821da177e4SLinus Torvalds /* double rates */
831da177e4SLinus Torvalds {
841da177e4SLinus Torvalds /* 3&4 front, 7&8 front (t+1) */
851da177e4SLinus Torvalds AC97_PCM_FRONT_DAC_RATE, /* slot 3 */
861da177e4SLinus Torvalds AC97_PCM_FRONT_DAC_RATE, /* slot 4 */
871da177e4SLinus Torvalds 0xff, /* slot 5 */
881da177e4SLinus Torvalds 0xff, /* slot 6 */
891da177e4SLinus Torvalds AC97_PCM_FRONT_DAC_RATE, /* slot 7 */
901da177e4SLinus Torvalds AC97_PCM_FRONT_DAC_RATE, /* slot 8 */
911da177e4SLinus Torvalds 0xff, /* slot 9 */
921da177e4SLinus Torvalds 0xff, /* slot 10 */
931da177e4SLinus Torvalds 0xff, /* slot 11 */
941da177e4SLinus Torvalds },
951da177e4SLinus Torvalds {
961da177e4SLinus Torvalds /* not specified in the specification */
971da177e4SLinus Torvalds 0xff, /* slot 3 */
981da177e4SLinus Torvalds 0xff, /* slot 4 */
991da177e4SLinus Torvalds 0xff, /* slot 5 */
1001da177e4SLinus Torvalds 0xff, /* slot 6 */
1011da177e4SLinus Torvalds 0xff, /* slot 7 */
1021da177e4SLinus Torvalds 0xff, /* slot 8 */
1031da177e4SLinus Torvalds 0xff, /* slot 9 */
1041da177e4SLinus Torvalds 0xff, /* slot 10 */
1051da177e4SLinus Torvalds 0xff, /* slot 11 */
1061da177e4SLinus Torvalds },
1071da177e4SLinus Torvalds {
1081da177e4SLinus Torvalds 0xff, /* slot 3 */
1091da177e4SLinus Torvalds 0xff, /* slot 4 */
1101da177e4SLinus Torvalds 0xff, /* slot 5 */
1111da177e4SLinus Torvalds 0xff, /* slot 6 */
1121da177e4SLinus Torvalds 0xff, /* slot 7 */
1131da177e4SLinus Torvalds 0xff, /* slot 8 */
1141da177e4SLinus Torvalds 0xff, /* slot 9 */
1151da177e4SLinus Torvalds 0xff, /* slot 10 */
1161da177e4SLinus Torvalds 0xff, /* slot 11 */
1171da177e4SLinus Torvalds },
1181da177e4SLinus Torvalds {
1191da177e4SLinus Torvalds 0xff, /* slot 3 */
1201da177e4SLinus Torvalds 0xff, /* slot 4 */
1211da177e4SLinus Torvalds 0xff, /* slot 5 */
1221da177e4SLinus Torvalds 0xff, /* slot 6 */
1231da177e4SLinus Torvalds 0xff, /* slot 7 */
1241da177e4SLinus Torvalds 0xff, /* slot 8 */
1251da177e4SLinus Torvalds 0xff, /* slot 9 */
1261da177e4SLinus Torvalds 0xff, /* slot 10 */
1271da177e4SLinus Torvalds 0xff, /* slot 11 */
1281da177e4SLinus Torvalds }
1291da177e4SLinus Torvalds }};
1301da177e4SLinus Torvalds
1311da177e4SLinus Torvalds /* FIXME: more various mappings for ADC? */
1321675bfc0STakashi Iwai static const unsigned char rate_cregs[9] = {
1331da177e4SLinus Torvalds AC97_PCM_LR_ADC_RATE, /* 3 */
1341da177e4SLinus Torvalds AC97_PCM_LR_ADC_RATE, /* 4 */
1351da177e4SLinus Torvalds 0xff, /* 5 */
1361da177e4SLinus Torvalds AC97_PCM_MIC_ADC_RATE, /* 6 */
1371da177e4SLinus Torvalds 0xff, /* 7 */
1381da177e4SLinus Torvalds 0xff, /* 8 */
1391da177e4SLinus Torvalds 0xff, /* 9 */
1401da177e4SLinus Torvalds 0xff, /* 10 */
1411da177e4SLinus Torvalds 0xff, /* 11 */
1421da177e4SLinus Torvalds };
1431da177e4SLinus Torvalds
get_slot_reg(struct ac97_pcm * pcm,unsigned short cidx,unsigned short slot,int dbl)1441da177e4SLinus Torvalds static unsigned char get_slot_reg(struct ac97_pcm *pcm, unsigned short cidx,
1451da177e4SLinus Torvalds unsigned short slot, int dbl)
1461da177e4SLinus Torvalds {
1471da177e4SLinus Torvalds if (slot < 3)
1481da177e4SLinus Torvalds return 0xff;
1491da177e4SLinus Torvalds if (slot > 11)
1501da177e4SLinus Torvalds return 0xff;
1511da177e4SLinus Torvalds if (pcm->spdif)
1521da177e4SLinus Torvalds return AC97_SPDIF; /* pseudo register */
1531da177e4SLinus Torvalds if (pcm->stream == SNDRV_PCM_STREAM_PLAYBACK)
1541da177e4SLinus Torvalds return rate_reg_tables[dbl][pcm->r[dbl].rate_table[cidx]][slot - 3];
1551da177e4SLinus Torvalds else
1561da177e4SLinus Torvalds return rate_cregs[slot - 3];
1571da177e4SLinus Torvalds }
1581da177e4SLinus Torvalds
set_spdif_rate(struct snd_ac97 * ac97,unsigned short rate)159ee42381eSTakashi Iwai static int set_spdif_rate(struct snd_ac97 *ac97, unsigned short rate)
1601da177e4SLinus Torvalds {
1611da177e4SLinus Torvalds unsigned short old, bits, reg, mask;
1621da177e4SLinus Torvalds unsigned int sbits;
1631da177e4SLinus Torvalds
1641da177e4SLinus Torvalds if (! (ac97->ext_id & AC97_EI_SPDIF))
1651da177e4SLinus Torvalds return -ENODEV;
1661da177e4SLinus Torvalds
1671da177e4SLinus Torvalds /* TODO: double rate support */
1681da177e4SLinus Torvalds if (ac97->flags & AC97_CS_SPDIF) {
1691da177e4SLinus Torvalds switch (rate) {
1701da177e4SLinus Torvalds case 48000: bits = 0; break;
1711da177e4SLinus Torvalds case 44100: bits = 1 << AC97_SC_SPSR_SHIFT; break;
1721da177e4SLinus Torvalds default: /* invalid - disable output */
1731da177e4SLinus Torvalds snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0);
1741da177e4SLinus Torvalds return -EINVAL;
1751da177e4SLinus Torvalds }
1761da177e4SLinus Torvalds reg = AC97_CSR_SPDIF;
1771da177e4SLinus Torvalds mask = 1 << AC97_SC_SPSR_SHIFT;
1781da177e4SLinus Torvalds } else {
1791da177e4SLinus Torvalds if (ac97->id == AC97_ID_CM9739 && rate != 48000) {
1801da177e4SLinus Torvalds snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0);
1811da177e4SLinus Torvalds return -EINVAL;
1821da177e4SLinus Torvalds }
1831da177e4SLinus Torvalds switch (rate) {
1841da177e4SLinus Torvalds case 44100: bits = AC97_SC_SPSR_44K; break;
1851da177e4SLinus Torvalds case 48000: bits = AC97_SC_SPSR_48K; break;
1861da177e4SLinus Torvalds case 32000: bits = AC97_SC_SPSR_32K; break;
1871da177e4SLinus Torvalds default: /* invalid - disable output */
1881da177e4SLinus Torvalds snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0);
1891da177e4SLinus Torvalds return -EINVAL;
1901da177e4SLinus Torvalds }
1911da177e4SLinus Torvalds reg = AC97_SPDIF;
1921da177e4SLinus Torvalds mask = AC97_SC_SPSR_MASK;
1931da177e4SLinus Torvalds }
1941da177e4SLinus Torvalds
19562932df8SIngo Molnar mutex_lock(&ac97->reg_mutex);
1961da177e4SLinus Torvalds old = snd_ac97_read(ac97, reg) & mask;
1971da177e4SLinus Torvalds if (old != bits) {
1981da177e4SLinus Torvalds snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0);
1991da177e4SLinus Torvalds snd_ac97_update_bits_nolock(ac97, reg, mask, bits);
2001da177e4SLinus Torvalds /* update the internal spdif bits */
2011da177e4SLinus Torvalds sbits = ac97->spdif_status;
2021da177e4SLinus Torvalds if (sbits & IEC958_AES0_PROFESSIONAL) {
2031da177e4SLinus Torvalds sbits &= ~IEC958_AES0_PRO_FS;
2041da177e4SLinus Torvalds switch (rate) {
2051da177e4SLinus Torvalds case 44100: sbits |= IEC958_AES0_PRO_FS_44100; break;
2061da177e4SLinus Torvalds case 48000: sbits |= IEC958_AES0_PRO_FS_48000; break;
2071da177e4SLinus Torvalds case 32000: sbits |= IEC958_AES0_PRO_FS_32000; break;
2081da177e4SLinus Torvalds }
2091da177e4SLinus Torvalds } else {
2101da177e4SLinus Torvalds sbits &= ~(IEC958_AES3_CON_FS << 24);
2111da177e4SLinus Torvalds switch (rate) {
2121da177e4SLinus Torvalds case 44100: sbits |= IEC958_AES3_CON_FS_44100<<24; break;
2131da177e4SLinus Torvalds case 48000: sbits |= IEC958_AES3_CON_FS_48000<<24; break;
2141da177e4SLinus Torvalds case 32000: sbits |= IEC958_AES3_CON_FS_32000<<24; break;
2151da177e4SLinus Torvalds }
2161da177e4SLinus Torvalds }
2171da177e4SLinus Torvalds ac97->spdif_status = sbits;
2181da177e4SLinus Torvalds }
2191da177e4SLinus Torvalds snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF);
22062932df8SIngo Molnar mutex_unlock(&ac97->reg_mutex);
2211da177e4SLinus Torvalds return 0;
2221da177e4SLinus Torvalds }
2231da177e4SLinus Torvalds
2241da177e4SLinus Torvalds /**
2251da177e4SLinus Torvalds * snd_ac97_set_rate - change the rate of the given input/output.
2261da177e4SLinus Torvalds * @ac97: the ac97 instance
2271da177e4SLinus Torvalds * @reg: the register to change
2281da177e4SLinus Torvalds * @rate: the sample rate to set
2291da177e4SLinus Torvalds *
2301da177e4SLinus Torvalds * Changes the rate of the given input/output on the codec.
2311da177e4SLinus Torvalds * If the codec doesn't support VAR, the rate must be 48000 (except
2321da177e4SLinus Torvalds * for SPDIF).
2331da177e4SLinus Torvalds *
234*d13a8f6dSChristophe JAILLET * The valid registers are AC97_PCM_MIC_ADC_RATE,
2351da177e4SLinus Torvalds * AC97_PCM_FRONT_DAC_RATE, AC97_PCM_LR_ADC_RATE.
2361da177e4SLinus Torvalds * AC97_PCM_SURR_DAC_RATE and AC97_PCM_LFE_DAC_RATE are accepted
2371da177e4SLinus Torvalds * if the codec supports them.
2381da177e4SLinus Torvalds * AC97_SPDIF is accepted as a pseudo register to modify the SPDIF
2391da177e4SLinus Torvalds * status bits.
2401da177e4SLinus Torvalds *
241eb7c06e8SYacine Belkadi * Return: Zero if successful, or a negative error code on failure.
2421da177e4SLinus Torvalds */
snd_ac97_set_rate(struct snd_ac97 * ac97,int reg,unsigned int rate)243ee42381eSTakashi Iwai int snd_ac97_set_rate(struct snd_ac97 *ac97, int reg, unsigned int rate)
2441da177e4SLinus Torvalds {
2451da177e4SLinus Torvalds int dbl;
2461da177e4SLinus Torvalds unsigned int tmp;
2471da177e4SLinus Torvalds
2481da177e4SLinus Torvalds dbl = rate > 48000;
2491da177e4SLinus Torvalds if (dbl) {
2501da177e4SLinus Torvalds if (!(ac97->flags & AC97_DOUBLE_RATE))
2511da177e4SLinus Torvalds return -EINVAL;
2521da177e4SLinus Torvalds if (reg != AC97_PCM_FRONT_DAC_RATE)
2531da177e4SLinus Torvalds return -EINVAL;
2541da177e4SLinus Torvalds }
2551da177e4SLinus Torvalds
2566dbe6628STakashi Iwai snd_ac97_update_power(ac97, reg, 1);
2571da177e4SLinus Torvalds switch (reg) {
2581da177e4SLinus Torvalds case AC97_PCM_MIC_ADC_RATE:
2591da177e4SLinus Torvalds if ((ac97->regs[AC97_EXTENDED_STATUS] & AC97_EA_VRM) == 0) /* MIC VRA */
2601da177e4SLinus Torvalds if (rate != 48000)
2611da177e4SLinus Torvalds return -EINVAL;
2621da177e4SLinus Torvalds break;
2631da177e4SLinus Torvalds case AC97_PCM_FRONT_DAC_RATE:
2641da177e4SLinus Torvalds case AC97_PCM_LR_ADC_RATE:
2651da177e4SLinus Torvalds if ((ac97->regs[AC97_EXTENDED_STATUS] & AC97_EA_VRA) == 0) /* VRA */
2661da177e4SLinus Torvalds if (rate != 48000 && rate != 96000)
2671da177e4SLinus Torvalds return -EINVAL;
2681da177e4SLinus Torvalds break;
2691da177e4SLinus Torvalds case AC97_PCM_SURR_DAC_RATE:
2701da177e4SLinus Torvalds if (! (ac97->scaps & AC97_SCAP_SURROUND_DAC))
2711da177e4SLinus Torvalds return -EINVAL;
2721da177e4SLinus Torvalds break;
2731da177e4SLinus Torvalds case AC97_PCM_LFE_DAC_RATE:
2741da177e4SLinus Torvalds if (! (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC))
2751da177e4SLinus Torvalds return -EINVAL;
2761da177e4SLinus Torvalds break;
2771da177e4SLinus Torvalds case AC97_SPDIF:
2781da177e4SLinus Torvalds /* special case */
2791da177e4SLinus Torvalds return set_spdif_rate(ac97, rate);
2801da177e4SLinus Torvalds default:
2811da177e4SLinus Torvalds return -EINVAL;
2821da177e4SLinus Torvalds }
2831da177e4SLinus Torvalds if (dbl)
2841da177e4SLinus Torvalds rate /= 2;
2851da177e4SLinus Torvalds tmp = (rate * ac97->bus->clock) / 48000;
2861da177e4SLinus Torvalds if (tmp > 65535)
2871da177e4SLinus Torvalds return -EINVAL;
2881da177e4SLinus Torvalds if ((ac97->ext_id & AC97_EI_DRA) && reg == AC97_PCM_FRONT_DAC_RATE)
2891da177e4SLinus Torvalds snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS,
2901da177e4SLinus Torvalds AC97_EA_DRA, dbl ? AC97_EA_DRA : 0);
2911da177e4SLinus Torvalds snd_ac97_update(ac97, reg, tmp & 0xffff);
2921da177e4SLinus Torvalds snd_ac97_read(ac97, reg);
293091e95eeSTakashi Iwai if ((ac97->ext_id & AC97_EI_DRA) && reg == AC97_PCM_FRONT_DAC_RATE) {
294091e95eeSTakashi Iwai /* Intel controllers require double rate data to be put in
295091e95eeSTakashi Iwai * slots 7+8
296091e95eeSTakashi Iwai */
297091e95eeSTakashi Iwai snd_ac97_update_bits(ac97, AC97_GENERAL_PURPOSE,
298091e95eeSTakashi Iwai AC97_GP_DRSS_MASK,
299091e95eeSTakashi Iwai dbl ? AC97_GP_DRSS_78 : 0);
300091e95eeSTakashi Iwai snd_ac97_read(ac97, AC97_GENERAL_PURPOSE);
301091e95eeSTakashi Iwai }
3021da177e4SLinus Torvalds return 0;
3031da177e4SLinus Torvalds }
3041da177e4SLinus Torvalds
3057b09679cSTakashi Iwai EXPORT_SYMBOL(snd_ac97_set_rate);
3067b09679cSTakashi Iwai
get_pslots(struct snd_ac97 * ac97,unsigned char * rate_table,unsigned short * spdif_slots)307ee42381eSTakashi Iwai static unsigned short get_pslots(struct snd_ac97 *ac97, unsigned char *rate_table, unsigned short *spdif_slots)
3081da177e4SLinus Torvalds {
3091da177e4SLinus Torvalds if (!ac97_is_audio(ac97))
3101da177e4SLinus Torvalds return 0;
3111da177e4SLinus Torvalds if (ac97_is_rev22(ac97) || ac97_can_amap(ac97)) {
3121da177e4SLinus Torvalds unsigned short slots = 0;
3131da177e4SLinus Torvalds if (ac97_is_rev22(ac97)) {
3141da177e4SLinus Torvalds /* Note: it's simply emulation of AMAP behaviour */
3151da177e4SLinus Torvalds u16 es;
3161da177e4SLinus Torvalds es = ac97->regs[AC97_EXTENDED_ID] &= ~AC97_EI_DACS_SLOT_MASK;
3171da177e4SLinus Torvalds switch (ac97->addr) {
3181da177e4SLinus Torvalds case 1:
3191da177e4SLinus Torvalds case 2: es |= (1<<AC97_EI_DACS_SLOT_SHIFT); break;
3201da177e4SLinus Torvalds case 3: es |= (2<<AC97_EI_DACS_SLOT_SHIFT); break;
3211da177e4SLinus Torvalds }
3221da177e4SLinus Torvalds snd_ac97_write_cache(ac97, AC97_EXTENDED_ID, es);
3231da177e4SLinus Torvalds }
3241da177e4SLinus Torvalds switch (ac97->addr) {
3251da177e4SLinus Torvalds case 0:
3261da177e4SLinus Torvalds slots |= (1<<AC97_SLOT_PCM_LEFT)|(1<<AC97_SLOT_PCM_RIGHT);
3271da177e4SLinus Torvalds if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
3281da177e4SLinus Torvalds slots |= (1<<AC97_SLOT_PCM_SLEFT)|(1<<AC97_SLOT_PCM_SRIGHT);
3291da177e4SLinus Torvalds if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)
3301da177e4SLinus Torvalds slots |= (1<<AC97_SLOT_PCM_CENTER)|(1<<AC97_SLOT_LFE);
3311da177e4SLinus Torvalds if (ac97->ext_id & AC97_EI_SPDIF) {
3321da177e4SLinus Torvalds if (!(ac97->scaps & AC97_SCAP_SURROUND_DAC))
3331da177e4SLinus Torvalds *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT)|(1<<AC97_SLOT_SPDIF_RIGHT);
3341da177e4SLinus Torvalds else if (!(ac97->scaps & AC97_SCAP_CENTER_LFE_DAC))
3351da177e4SLinus Torvalds *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT1)|(1<<AC97_SLOT_SPDIF_RIGHT1);
3361da177e4SLinus Torvalds else
3371da177e4SLinus Torvalds *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT2)|(1<<AC97_SLOT_SPDIF_RIGHT2);
3381da177e4SLinus Torvalds }
3391da177e4SLinus Torvalds *rate_table = 0;
3401da177e4SLinus Torvalds break;
3411da177e4SLinus Torvalds case 1:
3421da177e4SLinus Torvalds case 2:
3431da177e4SLinus Torvalds slots |= (1<<AC97_SLOT_PCM_SLEFT)|(1<<AC97_SLOT_PCM_SRIGHT);
3441da177e4SLinus Torvalds if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
3451da177e4SLinus Torvalds slots |= (1<<AC97_SLOT_PCM_CENTER)|(1<<AC97_SLOT_LFE);
3461da177e4SLinus Torvalds if (ac97->ext_id & AC97_EI_SPDIF) {
3471da177e4SLinus Torvalds if (!(ac97->scaps & AC97_SCAP_SURROUND_DAC))
3481da177e4SLinus Torvalds *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT1)|(1<<AC97_SLOT_SPDIF_RIGHT1);
3491da177e4SLinus Torvalds else
3501da177e4SLinus Torvalds *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT2)|(1<<AC97_SLOT_SPDIF_RIGHT2);
3511da177e4SLinus Torvalds }
3521da177e4SLinus Torvalds *rate_table = 1;
3531da177e4SLinus Torvalds break;
3541da177e4SLinus Torvalds case 3:
3551da177e4SLinus Torvalds slots |= (1<<AC97_SLOT_PCM_CENTER)|(1<<AC97_SLOT_LFE);
3561da177e4SLinus Torvalds if (ac97->ext_id & AC97_EI_SPDIF)
3571da177e4SLinus Torvalds *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT2)|(1<<AC97_SLOT_SPDIF_RIGHT2);
3581da177e4SLinus Torvalds *rate_table = 2;
3591da177e4SLinus Torvalds break;
3601da177e4SLinus Torvalds }
3611da177e4SLinus Torvalds return slots;
3621da177e4SLinus Torvalds } else {
3631da177e4SLinus Torvalds unsigned short slots;
3641da177e4SLinus Torvalds slots = (1<<AC97_SLOT_PCM_LEFT)|(1<<AC97_SLOT_PCM_RIGHT);
3651da177e4SLinus Torvalds if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
3661da177e4SLinus Torvalds slots |= (1<<AC97_SLOT_PCM_SLEFT)|(1<<AC97_SLOT_PCM_SRIGHT);
3671da177e4SLinus Torvalds if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)
3681da177e4SLinus Torvalds slots |= (1<<AC97_SLOT_PCM_CENTER)|(1<<AC97_SLOT_LFE);
3691da177e4SLinus Torvalds if (ac97->ext_id & AC97_EI_SPDIF) {
3701da177e4SLinus Torvalds if (!(ac97->scaps & AC97_SCAP_SURROUND_DAC))
3711da177e4SLinus Torvalds *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT)|(1<<AC97_SLOT_SPDIF_RIGHT);
3721da177e4SLinus Torvalds else if (!(ac97->scaps & AC97_SCAP_CENTER_LFE_DAC))
3731da177e4SLinus Torvalds *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT1)|(1<<AC97_SLOT_SPDIF_RIGHT1);
3741da177e4SLinus Torvalds else
3751da177e4SLinus Torvalds *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT2)|(1<<AC97_SLOT_SPDIF_RIGHT2);
3761da177e4SLinus Torvalds }
3771da177e4SLinus Torvalds *rate_table = 0;
3781da177e4SLinus Torvalds return slots;
3791da177e4SLinus Torvalds }
3801da177e4SLinus Torvalds }
3811da177e4SLinus Torvalds
get_cslots(struct snd_ac97 * ac97)382ee42381eSTakashi Iwai static unsigned short get_cslots(struct snd_ac97 *ac97)
3831da177e4SLinus Torvalds {
3841da177e4SLinus Torvalds unsigned short slots;
3851da177e4SLinus Torvalds
3861da177e4SLinus Torvalds if (!ac97_is_audio(ac97))
3871da177e4SLinus Torvalds return 0;
3881da177e4SLinus Torvalds slots = (1<<AC97_SLOT_PCM_LEFT)|(1<<AC97_SLOT_PCM_RIGHT);
3891da177e4SLinus Torvalds slots |= (1<<AC97_SLOT_MIC);
3901da177e4SLinus Torvalds return slots;
3911da177e4SLinus Torvalds }
3921da177e4SLinus Torvalds
get_rates(struct ac97_pcm * pcm,unsigned int cidx,unsigned short slots,int dbl)3931da177e4SLinus Torvalds static unsigned int get_rates(struct ac97_pcm *pcm, unsigned int cidx, unsigned short slots, int dbl)
3941da177e4SLinus Torvalds {
3951da177e4SLinus Torvalds int i, idx;
3961da177e4SLinus Torvalds unsigned int rates = ~0;
3971da177e4SLinus Torvalds unsigned char reg;
3981da177e4SLinus Torvalds
3991da177e4SLinus Torvalds for (i = 3; i < 12; i++) {
4001da177e4SLinus Torvalds if (!(slots & (1 << i)))
4011da177e4SLinus Torvalds continue;
4021da177e4SLinus Torvalds reg = get_slot_reg(pcm, cidx, i, dbl);
4031da177e4SLinus Torvalds switch (reg) {
4041da177e4SLinus Torvalds case AC97_PCM_FRONT_DAC_RATE: idx = AC97_RATES_FRONT_DAC; break;
4051da177e4SLinus Torvalds case AC97_PCM_SURR_DAC_RATE: idx = AC97_RATES_SURR_DAC; break;
4061da177e4SLinus Torvalds case AC97_PCM_LFE_DAC_RATE: idx = AC97_RATES_LFE_DAC; break;
4071da177e4SLinus Torvalds case AC97_PCM_LR_ADC_RATE: idx = AC97_RATES_ADC; break;
4081da177e4SLinus Torvalds case AC97_PCM_MIC_ADC_RATE: idx = AC97_RATES_MIC_ADC; break;
4091da177e4SLinus Torvalds default: idx = AC97_RATES_SPDIF; break;
4101da177e4SLinus Torvalds }
4111da177e4SLinus Torvalds rates &= pcm->r[dbl].codec[cidx]->rates[idx];
4121da177e4SLinus Torvalds }
4131da177e4SLinus Torvalds if (!dbl)
4141da177e4SLinus Torvalds rates &= ~(SNDRV_PCM_RATE_64000 | SNDRV_PCM_RATE_88200 |
4151da177e4SLinus Torvalds SNDRV_PCM_RATE_96000);
4161da177e4SLinus Torvalds return rates;
4171da177e4SLinus Torvalds }
4181da177e4SLinus Torvalds
4191da177e4SLinus Torvalds /**
4201da177e4SLinus Torvalds * snd_ac97_pcm_assign - assign AC97 slots to given PCM streams
4211da177e4SLinus Torvalds * @bus: the ac97 bus instance
4221da177e4SLinus Torvalds * @pcms_count: count of PCMs to be assigned
4231da177e4SLinus Torvalds * @pcms: PCMs to be assigned
4241da177e4SLinus Torvalds *
4251da177e4SLinus Torvalds * It assigns available AC97 slots for given PCMs. If none or only
4261da177e4SLinus Torvalds * some slots are available, pcm->xxx.slots and pcm->xxx.rslots[] members
4271da177e4SLinus Torvalds * are reduced and might be zero.
428eb7c06e8SYacine Belkadi *
429eb7c06e8SYacine Belkadi * Return: Zero if successful, or a negative error code on failure.
4301da177e4SLinus Torvalds */
snd_ac97_pcm_assign(struct snd_ac97_bus * bus,unsigned short pcms_count,const struct ac97_pcm * pcms)431ee42381eSTakashi Iwai int snd_ac97_pcm_assign(struct snd_ac97_bus *bus,
4321da177e4SLinus Torvalds unsigned short pcms_count,
4331da177e4SLinus Torvalds const struct ac97_pcm *pcms)
4341da177e4SLinus Torvalds {
4351da177e4SLinus Torvalds int i, j, k;
4361da177e4SLinus Torvalds const struct ac97_pcm *pcm;
4371da177e4SLinus Torvalds struct ac97_pcm *rpcms, *rpcm;
4381da177e4SLinus Torvalds unsigned short avail_slots[2][4];
4391da177e4SLinus Torvalds unsigned char rate_table[2][4];
4401da177e4SLinus Torvalds unsigned short tmp, slots;
4411da177e4SLinus Torvalds unsigned short spdif_slots[4];
4421da177e4SLinus Torvalds unsigned int rates;
443ee42381eSTakashi Iwai struct snd_ac97 *codec;
4441da177e4SLinus Torvalds
4451da177e4SLinus Torvalds rpcms = kcalloc(pcms_count, sizeof(struct ac97_pcm), GFP_KERNEL);
4461da177e4SLinus Torvalds if (rpcms == NULL)
4471da177e4SLinus Torvalds return -ENOMEM;
4481da177e4SLinus Torvalds memset(avail_slots, 0, sizeof(avail_slots));
4491da177e4SLinus Torvalds memset(rate_table, 0, sizeof(rate_table));
4501da177e4SLinus Torvalds memset(spdif_slots, 0, sizeof(spdif_slots));
4511da177e4SLinus Torvalds for (i = 0; i < 4; i++) {
4521da177e4SLinus Torvalds codec = bus->codec[i];
4531da177e4SLinus Torvalds if (!codec)
4541da177e4SLinus Torvalds continue;
4551da177e4SLinus Torvalds avail_slots[0][i] = get_pslots(codec, &rate_table[0][i], &spdif_slots[i]);
4561da177e4SLinus Torvalds avail_slots[1][i] = get_cslots(codec);
4571da177e4SLinus Torvalds if (!(codec->scaps & AC97_SCAP_INDEP_SDIN)) {
4581da177e4SLinus Torvalds for (j = 0; j < i; j++) {
4591da177e4SLinus Torvalds if (bus->codec[j])
4601da177e4SLinus Torvalds avail_slots[1][i] &= ~avail_slots[1][j];
4611da177e4SLinus Torvalds }
4621da177e4SLinus Torvalds }
4631da177e4SLinus Torvalds }
4641da177e4SLinus Torvalds /* first step - exclusive devices */
4651da177e4SLinus Torvalds for (i = 0; i < pcms_count; i++) {
4661da177e4SLinus Torvalds pcm = &pcms[i];
4671da177e4SLinus Torvalds rpcm = &rpcms[i];
4681da177e4SLinus Torvalds /* low-level driver thinks that it's more clever */
4691da177e4SLinus Torvalds if (pcm->copy_flag) {
4701da177e4SLinus Torvalds *rpcm = *pcm;
4711da177e4SLinus Torvalds continue;
4721da177e4SLinus Torvalds }
4731da177e4SLinus Torvalds rpcm->stream = pcm->stream;
4741da177e4SLinus Torvalds rpcm->exclusive = pcm->exclusive;
4751da177e4SLinus Torvalds rpcm->spdif = pcm->spdif;
4761da177e4SLinus Torvalds rpcm->private_value = pcm->private_value;
4771da177e4SLinus Torvalds rpcm->bus = bus;
4781da177e4SLinus Torvalds rpcm->rates = ~0;
4791da177e4SLinus Torvalds slots = pcm->r[0].slots;
4801da177e4SLinus Torvalds for (j = 0; j < 4 && slots; j++) {
4811da177e4SLinus Torvalds if (!bus->codec[j])
4821da177e4SLinus Torvalds continue;
4831da177e4SLinus Torvalds rates = ~0;
4841da177e4SLinus Torvalds if (pcm->spdif && pcm->stream == 0)
4851da177e4SLinus Torvalds tmp = spdif_slots[j];
4861da177e4SLinus Torvalds else
4871da177e4SLinus Torvalds tmp = avail_slots[pcm->stream][j];
4881da177e4SLinus Torvalds if (pcm->exclusive) {
4891da177e4SLinus Torvalds /* exclusive access */
4901da177e4SLinus Torvalds tmp &= slots;
4911da177e4SLinus Torvalds for (k = 0; k < i; k++) {
4921da177e4SLinus Torvalds if (rpcm->stream == rpcms[k].stream)
4931da177e4SLinus Torvalds tmp &= ~rpcms[k].r[0].rslots[j];
4941da177e4SLinus Torvalds }
4951da177e4SLinus Torvalds } else {
4961da177e4SLinus Torvalds /* non-exclusive access */
4971da177e4SLinus Torvalds tmp &= pcm->r[0].slots;
4981da177e4SLinus Torvalds }
4991da177e4SLinus Torvalds if (tmp) {
5001da177e4SLinus Torvalds rpcm->r[0].rslots[j] = tmp;
5011da177e4SLinus Torvalds rpcm->r[0].codec[j] = bus->codec[j];
5021da177e4SLinus Torvalds rpcm->r[0].rate_table[j] = rate_table[pcm->stream][j];
5031da177e4SLinus Torvalds if (bus->no_vra)
5041da177e4SLinus Torvalds rates = SNDRV_PCM_RATE_48000;
5051da177e4SLinus Torvalds else
5061da177e4SLinus Torvalds rates = get_rates(rpcm, j, tmp, 0);
5071da177e4SLinus Torvalds if (pcm->exclusive)
5081da177e4SLinus Torvalds avail_slots[pcm->stream][j] &= ~tmp;
5091da177e4SLinus Torvalds }
5101da177e4SLinus Torvalds slots &= ~tmp;
5111da177e4SLinus Torvalds rpcm->r[0].slots |= tmp;
5121da177e4SLinus Torvalds rpcm->rates &= rates;
5131da177e4SLinus Torvalds }
5141da177e4SLinus Torvalds /* for double rate, we check the first codec only */
5151da177e4SLinus Torvalds if (pcm->stream == SNDRV_PCM_STREAM_PLAYBACK &&
5161da177e4SLinus Torvalds bus->codec[0] && (bus->codec[0]->flags & AC97_DOUBLE_RATE) &&
5171da177e4SLinus Torvalds rate_table[pcm->stream][0] == 0) {
5181da177e4SLinus Torvalds tmp = (1<<AC97_SLOT_PCM_LEFT) | (1<<AC97_SLOT_PCM_RIGHT) |
5191da177e4SLinus Torvalds (1<<AC97_SLOT_PCM_LEFT_0) | (1<<AC97_SLOT_PCM_RIGHT_0);
5201da177e4SLinus Torvalds if ((tmp & pcm->r[1].slots) == tmp) {
5211da177e4SLinus Torvalds rpcm->r[1].slots = tmp;
5221da177e4SLinus Torvalds rpcm->r[1].rslots[0] = tmp;
5231da177e4SLinus Torvalds rpcm->r[1].rate_table[0] = 0;
5241da177e4SLinus Torvalds rpcm->r[1].codec[0] = bus->codec[0];
5251da177e4SLinus Torvalds if (pcm->exclusive)
5261da177e4SLinus Torvalds avail_slots[pcm->stream][0] &= ~tmp;
5271da177e4SLinus Torvalds if (bus->no_vra)
5281da177e4SLinus Torvalds rates = SNDRV_PCM_RATE_96000;
5291da177e4SLinus Torvalds else
5301da177e4SLinus Torvalds rates = get_rates(rpcm, 0, tmp, 1);
5311da177e4SLinus Torvalds rpcm->rates |= rates;
5321da177e4SLinus Torvalds }
5331da177e4SLinus Torvalds }
5341da177e4SLinus Torvalds if (rpcm->rates == ~0)
5351da177e4SLinus Torvalds rpcm->rates = 0; /* not used */
5361da177e4SLinus Torvalds }
5371da177e4SLinus Torvalds bus->pcms_count = pcms_count;
5381da177e4SLinus Torvalds bus->pcms = rpcms;
5391da177e4SLinus Torvalds return 0;
5401da177e4SLinus Torvalds }
5411da177e4SLinus Torvalds
5427b09679cSTakashi Iwai EXPORT_SYMBOL(snd_ac97_pcm_assign);
5437b09679cSTakashi Iwai
5441da177e4SLinus Torvalds /**
5451da177e4SLinus Torvalds * snd_ac97_pcm_open - opens the given AC97 pcm
5461da177e4SLinus Torvalds * @pcm: the ac97 pcm instance
5471da177e4SLinus Torvalds * @rate: rate in Hz, if codec does not support VRA, this value must be 48000Hz
5481da177e4SLinus Torvalds * @cfg: output stream characteristics
5491da177e4SLinus Torvalds * @slots: a subset of allocated slots (snd_ac97_pcm_assign) for this pcm
5501da177e4SLinus Torvalds *
5511da177e4SLinus Torvalds * It locks the specified slots and sets the given rate to AC97 registers.
552eb7c06e8SYacine Belkadi *
553eb7c06e8SYacine Belkadi * Return: Zero if successful, or a negative error code on failure.
5541da177e4SLinus Torvalds */
snd_ac97_pcm_open(struct ac97_pcm * pcm,unsigned int rate,enum ac97_pcm_cfg cfg,unsigned short slots)5551da177e4SLinus Torvalds int snd_ac97_pcm_open(struct ac97_pcm *pcm, unsigned int rate,
5561da177e4SLinus Torvalds enum ac97_pcm_cfg cfg, unsigned short slots)
5571da177e4SLinus Torvalds {
558ee42381eSTakashi Iwai struct snd_ac97_bus *bus;
5591da177e4SLinus Torvalds int i, cidx, r, ok_flag;
5601da177e4SLinus Torvalds unsigned int reg_ok[4] = {0,0,0,0};
5611da177e4SLinus Torvalds unsigned char reg;
5621da177e4SLinus Torvalds int err = 0;
5631da177e4SLinus Torvalds
5641da177e4SLinus Torvalds r = rate > 48000;
5651da177e4SLinus Torvalds bus = pcm->bus;
5661da177e4SLinus Torvalds if (cfg == AC97_PCM_CFG_SPDIF) {
5671da177e4SLinus Torvalds for (cidx = 0; cidx < 4; cidx++)
5681da177e4SLinus Torvalds if (bus->codec[cidx] && (bus->codec[cidx]->ext_id & AC97_EI_SPDIF)) {
5691da177e4SLinus Torvalds err = set_spdif_rate(bus->codec[cidx], rate);
5701da177e4SLinus Torvalds if (err < 0)
5711da177e4SLinus Torvalds return err;
5721da177e4SLinus Torvalds }
5731da177e4SLinus Torvalds }
5741da177e4SLinus Torvalds spin_lock_irq(&pcm->bus->bus_lock);
5751da177e4SLinus Torvalds for (i = 3; i < 12; i++) {
5761da177e4SLinus Torvalds if (!(slots & (1 << i)))
5771da177e4SLinus Torvalds continue;
5781da177e4SLinus Torvalds ok_flag = 0;
5791da177e4SLinus Torvalds for (cidx = 0; cidx < 4; cidx++) {
5801da177e4SLinus Torvalds if (bus->used_slots[pcm->stream][cidx] & (1 << i)) {
5811da177e4SLinus Torvalds spin_unlock_irq(&pcm->bus->bus_lock);
5821da177e4SLinus Torvalds err = -EBUSY;
5831da177e4SLinus Torvalds goto error;
5841da177e4SLinus Torvalds }
5851da177e4SLinus Torvalds if (pcm->r[r].rslots[cidx] & (1 << i)) {
5861da177e4SLinus Torvalds bus->used_slots[pcm->stream][cidx] |= (1 << i);
5871da177e4SLinus Torvalds ok_flag++;
5881da177e4SLinus Torvalds }
5891da177e4SLinus Torvalds }
5901da177e4SLinus Torvalds if (!ok_flag) {
5911da177e4SLinus Torvalds spin_unlock_irq(&pcm->bus->bus_lock);
59238c16e34STakashi Iwai dev_err(bus->card->dev,
59338c16e34STakashi Iwai "cannot find configuration for AC97 slot %i\n",
59438c16e34STakashi Iwai i);
5951da177e4SLinus Torvalds err = -EAGAIN;
5961da177e4SLinus Torvalds goto error;
5971da177e4SLinus Torvalds }
5981da177e4SLinus Torvalds }
5996dbe6628STakashi Iwai pcm->cur_dbl = r;
6001da177e4SLinus Torvalds spin_unlock_irq(&pcm->bus->bus_lock);
6011da177e4SLinus Torvalds for (i = 3; i < 12; i++) {
6021da177e4SLinus Torvalds if (!(slots & (1 << i)))
6031da177e4SLinus Torvalds continue;
6041da177e4SLinus Torvalds for (cidx = 0; cidx < 4; cidx++) {
6051da177e4SLinus Torvalds if (pcm->r[r].rslots[cidx] & (1 << i)) {
6061da177e4SLinus Torvalds reg = get_slot_reg(pcm, cidx, i, r);
6071da177e4SLinus Torvalds if (reg == 0xff) {
60838c16e34STakashi Iwai dev_err(bus->card->dev,
60938c16e34STakashi Iwai "invalid AC97 slot %i?\n", i);
6101da177e4SLinus Torvalds continue;
6111da177e4SLinus Torvalds }
6121da177e4SLinus Torvalds if (reg_ok[cidx] & (1 << (reg - AC97_PCM_FRONT_DAC_RATE)))
6131da177e4SLinus Torvalds continue;
61438c16e34STakashi Iwai dev_dbg(bus->card->dev,
61538c16e34STakashi Iwai "setting ac97 reg 0x%x to rate %d\n",
61638c16e34STakashi Iwai reg, rate);
6171da177e4SLinus Torvalds err = snd_ac97_set_rate(pcm->r[r].codec[cidx], reg, rate);
6181da177e4SLinus Torvalds if (err < 0)
61938c16e34STakashi Iwai dev_err(bus->card->dev,
62038c16e34STakashi Iwai "error in snd_ac97_set_rate: cidx=%d, reg=0x%x, rate=%d, err=%d\n",
62138c16e34STakashi Iwai cidx, reg, rate, err);
6221da177e4SLinus Torvalds else
6231da177e4SLinus Torvalds reg_ok[cidx] |= (1 << (reg - AC97_PCM_FRONT_DAC_RATE));
6241da177e4SLinus Torvalds }
6251da177e4SLinus Torvalds }
6261da177e4SLinus Torvalds }
6271da177e4SLinus Torvalds pcm->aslots = slots;
6281da177e4SLinus Torvalds return 0;
6291da177e4SLinus Torvalds
6301da177e4SLinus Torvalds error:
6311da177e4SLinus Torvalds pcm->aslots = slots;
6321da177e4SLinus Torvalds snd_ac97_pcm_close(pcm);
6331da177e4SLinus Torvalds return err;
6341da177e4SLinus Torvalds }
6351da177e4SLinus Torvalds
6367b09679cSTakashi Iwai EXPORT_SYMBOL(snd_ac97_pcm_open);
6377b09679cSTakashi Iwai
6381da177e4SLinus Torvalds /**
6391da177e4SLinus Torvalds * snd_ac97_pcm_close - closes the given AC97 pcm
6401da177e4SLinus Torvalds * @pcm: the ac97 pcm instance
6411da177e4SLinus Torvalds *
6421da177e4SLinus Torvalds * It frees the locked AC97 slots.
643eb7c06e8SYacine Belkadi *
644eb7c06e8SYacine Belkadi * Return: Zero.
6451da177e4SLinus Torvalds */
snd_ac97_pcm_close(struct ac97_pcm * pcm)6461da177e4SLinus Torvalds int snd_ac97_pcm_close(struct ac97_pcm *pcm)
6471da177e4SLinus Torvalds {
648ee42381eSTakashi Iwai struct snd_ac97_bus *bus;
6491da177e4SLinus Torvalds unsigned short slots = pcm->aslots;
6501da177e4SLinus Torvalds int i, cidx;
6511da177e4SLinus Torvalds
6526dbe6628STakashi Iwai #ifdef CONFIG_SND_AC97_POWER_SAVE
6536dbe6628STakashi Iwai int r = pcm->cur_dbl;
6546dbe6628STakashi Iwai for (i = 3; i < 12; i++) {
6556dbe6628STakashi Iwai if (!(slots & (1 << i)))
6566dbe6628STakashi Iwai continue;
6576dbe6628STakashi Iwai for (cidx = 0; cidx < 4; cidx++) {
6586dbe6628STakashi Iwai if (pcm->r[r].rslots[cidx] & (1 << i)) {
6596dbe6628STakashi Iwai int reg = get_slot_reg(pcm, cidx, i, r);
6606dbe6628STakashi Iwai snd_ac97_update_power(pcm->r[r].codec[cidx],
6616dbe6628STakashi Iwai reg, 0);
6626dbe6628STakashi Iwai }
6636dbe6628STakashi Iwai }
6646dbe6628STakashi Iwai }
6656dbe6628STakashi Iwai #endif
6666dbe6628STakashi Iwai
6671da177e4SLinus Torvalds bus = pcm->bus;
6681da177e4SLinus Torvalds spin_lock_irq(&pcm->bus->bus_lock);
6691da177e4SLinus Torvalds for (i = 3; i < 12; i++) {
6701da177e4SLinus Torvalds if (!(slots & (1 << i)))
6711da177e4SLinus Torvalds continue;
6721da177e4SLinus Torvalds for (cidx = 0; cidx < 4; cidx++)
6731da177e4SLinus Torvalds bus->used_slots[pcm->stream][cidx] &= ~(1 << i);
6741da177e4SLinus Torvalds }
6751da177e4SLinus Torvalds pcm->aslots = 0;
6766dbe6628STakashi Iwai pcm->cur_dbl = 0;
6771da177e4SLinus Torvalds spin_unlock_irq(&pcm->bus->bus_lock);
6781da177e4SLinus Torvalds return 0;
6791da177e4SLinus Torvalds }
6801da177e4SLinus Torvalds
6817b09679cSTakashi Iwai EXPORT_SYMBOL(snd_ac97_pcm_close);
6827b09679cSTakashi Iwai
double_rate_hw_constraint_rate(struct snd_pcm_hw_params * params,struct snd_pcm_hw_rule * rule)683ee42381eSTakashi Iwai static int double_rate_hw_constraint_rate(struct snd_pcm_hw_params *params,
684ee42381eSTakashi Iwai struct snd_pcm_hw_rule *rule)
6851da177e4SLinus Torvalds {
686ee42381eSTakashi Iwai struct snd_interval *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
6871da177e4SLinus Torvalds if (channels->min > 2) {
688ee42381eSTakashi Iwai static const struct snd_interval single_rates = {
6891da177e4SLinus Torvalds .min = 1,
6901da177e4SLinus Torvalds .max = 48000,
6911da177e4SLinus Torvalds };
692ee42381eSTakashi Iwai struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
6931da177e4SLinus Torvalds return snd_interval_refine(rate, &single_rates);
6941da177e4SLinus Torvalds }
6951da177e4SLinus Torvalds return 0;
6961da177e4SLinus Torvalds }
6971da177e4SLinus Torvalds
double_rate_hw_constraint_channels(struct snd_pcm_hw_params * params,struct snd_pcm_hw_rule * rule)698ee42381eSTakashi Iwai static int double_rate_hw_constraint_channels(struct snd_pcm_hw_params *params,
699ee42381eSTakashi Iwai struct snd_pcm_hw_rule *rule)
7001da177e4SLinus Torvalds {
701ee42381eSTakashi Iwai struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
7021da177e4SLinus Torvalds if (rate->min > 48000) {
703ee42381eSTakashi Iwai static const struct snd_interval double_rate_channels = {
7041da177e4SLinus Torvalds .min = 2,
7051da177e4SLinus Torvalds .max = 2,
7061da177e4SLinus Torvalds };
707ee42381eSTakashi Iwai struct snd_interval *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
7081da177e4SLinus Torvalds return snd_interval_refine(channels, &double_rate_channels);
7091da177e4SLinus Torvalds }
7101da177e4SLinus Torvalds return 0;
7111da177e4SLinus Torvalds }
7121da177e4SLinus Torvalds
7131da177e4SLinus Torvalds /**
7141da177e4SLinus Torvalds * snd_ac97_pcm_double_rate_rules - set double rate constraints
7151da177e4SLinus Torvalds * @runtime: the runtime of the ac97 front playback pcm
7161da177e4SLinus Torvalds *
7171da177e4SLinus Torvalds * Installs the hardware constraint rules to prevent using double rates and
7181da177e4SLinus Torvalds * more than two channels at the same time.
719eb7c06e8SYacine Belkadi *
720eb7c06e8SYacine Belkadi * Return: Zero if successful, or a negative error code on failure.
7211da177e4SLinus Torvalds */
snd_ac97_pcm_double_rate_rules(struct snd_pcm_runtime * runtime)722ee42381eSTakashi Iwai int snd_ac97_pcm_double_rate_rules(struct snd_pcm_runtime *runtime)
7231da177e4SLinus Torvalds {
7241da177e4SLinus Torvalds int err;
7251da177e4SLinus Torvalds
7261da177e4SLinus Torvalds err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
7271da177e4SLinus Torvalds double_rate_hw_constraint_rate, NULL,
7281da177e4SLinus Torvalds SNDRV_PCM_HW_PARAM_CHANNELS, -1);
7291da177e4SLinus Torvalds if (err < 0)
7301da177e4SLinus Torvalds return err;
7311da177e4SLinus Torvalds err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
7321da177e4SLinus Torvalds double_rate_hw_constraint_channels, NULL,
7331da177e4SLinus Torvalds SNDRV_PCM_HW_PARAM_RATE, -1);
7341da177e4SLinus Torvalds return err;
7351da177e4SLinus Torvalds }
7367b09679cSTakashi Iwai
7377b09679cSTakashi Iwai EXPORT_SYMBOL(snd_ac97_pcm_double_rate_rules);
738