ALSA: hda - Move PCM format and rate handling code to core library

Signed-off-by: Takashi Iwai <tiwai@suse.de>

1 files changed, 300 insertions, 0 deletions

diff --git a/sound/hda/hdac_device.c b/sound/hda/hdac_device.c
index f75bf5622687..55c7d086b9dd 100644
--- a/sound/hda/hdac_device.c
+++ b/sound/hda/hdac_device.c
@@ -10,6 +10,7 @@
 #include <linux/pm_runtime.h>
 #include <sound/hdaudio.h>
 #include <sound/hda_regmap.h>
+#include <sound/pcm.h>
 #include "local.h"
 
 static void setup_fg_nodes(struct hdac_device *codec);
@@ -597,3 +598,302 @@ static int get_codec_vendor_name(struct hdac_device *codec)
         codec->vendor_name = kasprintf(GFP_KERNEL, "Generic %04x", vendor_id);
         return codec->vendor_name ? 0 : -ENOMEM;
 }
+
+/*
+ * stream formats
+ */
+struct hda_rate_tbl {
+        unsigned int hz;
+        unsigned int alsa_bits;
+        unsigned int hda_fmt;
+};
+
+/* rate = base * mult / div */
+#define HDA_RATE(base, mult, div) \
+        (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
+         (((div) - 1) << AC_FMT_DIV_SHIFT))
+
+static struct hda_rate_tbl rate_bits[] = {
+        /* rate in Hz, ALSA rate bitmask, HDA format value */
+
+        /* autodetected value used in snd_hda_query_supported_pcm */
+        { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
+        { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
+        { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
+        { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
+        { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
+        { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
+        { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
+        { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
+        { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
+        { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
+        { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
+#define AC_PAR_PCM_RATE_BITS    11
+        /* up to bits 10, 384kHZ isn't supported properly */
+
+        /* not autodetected value */
+        { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
+
+        { 0 } /* terminator */
+};
+
+/**
+ * snd_hdac_calc_stream_format - calculate the format bitset
+ * @rate: the sample rate
+ * @channels: the number of channels
+ * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
+ * @maxbps: the max. bps
+ * @spdif_ctls: HD-audio SPDIF status bits (0 if irrelevant)
+ *
+ * Calculate the format bitset from the given rate, channels and th PCM format.
+ *
+ * Return zero if invalid.
+ */
+unsigned int snd_hdac_calc_stream_format(unsigned int rate,
+                                         unsigned int channels,
+                                         unsigned int format,
+                                         unsigned int maxbps,
+                                         unsigned short spdif_ctls)
+{
+        int i;
+        unsigned int val = 0;
+
+        for (i = 0; rate_bits[i].hz; i++)
+                if (rate_bits[i].hz == rate) {
+                        val = rate_bits[i].hda_fmt;
+                        break;
+                }
+        if (!rate_bits[i].hz)
+                return 0;
+
+        if (channels == 0 || channels > 8)
+                return 0;
+        val |= channels - 1;
+
+        switch (snd_pcm_format_width(format)) {
+        case 8:
+                val |= AC_FMT_BITS_8;
+                break;
+        case 16:
+                val |= AC_FMT_BITS_16;
+                break;
+        case 20:
+        case 24:
+        case 32:
+                if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
+                        val |= AC_FMT_BITS_32;
+                else if (maxbps >= 24)
+                        val |= AC_FMT_BITS_24;
+                else
+                        val |= AC_FMT_BITS_20;
+                break;
+        default:
+                return 0;
+        }
+
+        if (spdif_ctls & AC_DIG1_NONAUDIO)
+                val |= AC_FMT_TYPE_NON_PCM;
+
+        return val;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_calc_stream_format);
+
+static unsigned int query_pcm_param(struct hdac_device *codec, hda_nid_t nid)
+{
+        unsigned int val = 0;
+
+        if (nid != codec->afg &&
+            (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
+                val = snd_hdac_read_parm(codec, nid, AC_PAR_PCM);
+        if (!val || val == -1)
+                val = snd_hdac_read_parm(codec, codec->afg, AC_PAR_PCM);
+        if (!val || val == -1)
+                return 0;
+        return val;
+}
+
+static unsigned int query_stream_param(struct hdac_device *codec, hda_nid_t nid)
+{
+        unsigned int streams = snd_hdac_read_parm(codec, nid, AC_PAR_STREAM);
+
+        if (!streams || streams == -1)
+                streams = snd_hdac_read_parm(codec, codec->afg, AC_PAR_STREAM);
+        if (!streams || streams == -1)
+                return 0;
+        return streams;
+}
+
+/**
+ * snd_hdac_query_supported_pcm - query the supported PCM rates and formats
+ * @codec: the codec object
+ * @nid: NID to query
+ * @ratesp: the pointer to store the detected rate bitflags
+ * @formatsp: the pointer to store the detected formats
+ * @bpsp: the pointer to store the detected format widths
+ *
+ * Queries the supported PCM rates and formats.  The NULL @ratesp, @formatsp
+ * or @bsps argument is ignored.
+ *
+ * Returns 0 if successful, otherwise a negative error code.
+ */
+int snd_hdac_query_supported_pcm(struct hdac_device *codec, hda_nid_t nid,
+                                 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
+{
+        unsigned int i, val, wcaps;
+
+        wcaps = get_wcaps(codec, nid);
+        val = query_pcm_param(codec, nid);
+
+        if (ratesp) {
+                u32 rates = 0;
+                for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
+                        if (val & (1 << i))
+                                rates |= rate_bits[i].alsa_bits;
+                }
+                if (rates == 0) {
+                        dev_err(&codec->dev,
+                                "rates == 0 (nid=0x%x, val=0x%x, ovrd=%i)\n",
+                                nid, val,
+                                (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
+                        return -EIO;
+                }
+                *ratesp = rates;
+        }
+
+        if (formatsp || bpsp) {
+                u64 formats = 0;
+                unsigned int streams, bps;
+
+                streams = query_stream_param(codec, nid);
+                if (!streams)
+                        return -EIO;
+
+                bps = 0;
+                if (streams & AC_SUPFMT_PCM) {
+                        if (val & AC_SUPPCM_BITS_8) {
+                                formats |= SNDRV_PCM_FMTBIT_U8;
+                                bps = 8;
+                        }
+                        if (val & AC_SUPPCM_BITS_16) {
+                                formats |= SNDRV_PCM_FMTBIT_S16_LE;
+                                bps = 16;
+                        }
+                        if (wcaps & AC_WCAP_DIGITAL) {
+                                if (val & AC_SUPPCM_BITS_32)
+                                        formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
+                                if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
+                                        formats |= SNDRV_PCM_FMTBIT_S32_LE;
+                                if (val & AC_SUPPCM_BITS_24)
+                                        bps = 24;
+                                else if (val & AC_SUPPCM_BITS_20)
+                                        bps = 20;
+                        } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
+                                          AC_SUPPCM_BITS_32)) {
+                                formats |= SNDRV_PCM_FMTBIT_S32_LE;
+                                if (val & AC_SUPPCM_BITS_32)
+                                        bps = 32;
+                                else if (val & AC_SUPPCM_BITS_24)
+                                        bps = 24;
+                                else if (val & AC_SUPPCM_BITS_20)
+                                        bps = 20;
+                        }
+                }
+#if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
+                if (streams & AC_SUPFMT_FLOAT32) {
+                        formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
+                        if (!bps)
+                                bps = 32;
+                }
+#endif
+                if (streams == AC_SUPFMT_AC3) {
+                        /* should be exclusive */
+                        /* temporary hack: we have still no proper support
+                         * for the direct AC3 stream...
+                         */
+                        formats |= SNDRV_PCM_FMTBIT_U8;
+                        bps = 8;
+                }
+                if (formats == 0) {
+                        dev_err(&codec->dev,
+                                "formats == 0 (nid=0x%x, val=0x%x, ovrd=%i, streams=0x%x)\n",
+                                nid, val,
+                                (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
+                                streams);
+                        return -EIO;
+                }
+                if (formatsp)
+                        *formatsp = formats;
+                if (bpsp)
+                        *bpsp = bps;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_query_supported_pcm);
+
+/**
+ * snd_hdac_is_supported_format - Check the validity of the format
+ * @codec: the codec object
+ * @nid: NID to check
+ * @format: the HD-audio format value to check
+ *
+ * Check whether the given node supports the format value.
+ *
+ * Returns true if supported, false if not.
+ */
+bool snd_hdac_is_supported_format(struct hdac_device *codec, hda_nid_t nid,
+                                  unsigned int format)
+{
+        int i;
+        unsigned int val = 0, rate, stream;
+
+        val = query_pcm_param(codec, nid);
+        if (!val)
+                return false;
+
+        rate = format & 0xff00;
+        for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
+                if (rate_bits[i].hda_fmt == rate) {
+                        if (val & (1 << i))
+                                break;
+                        return false;
+                }
+        if (i >= AC_PAR_PCM_RATE_BITS)
+                return false;
+
+        stream = query_stream_param(codec, nid);
+        if (!stream)
+                return false;
+
+        if (stream & AC_SUPFMT_PCM) {
+                switch (format & 0xf0) {
+                case 0x00:
+                        if (!(val & AC_SUPPCM_BITS_8))
+                                return false;
+                        break;
+                case 0x10:
+                        if (!(val & AC_SUPPCM_BITS_16))
+                                return false;
+                        break;
+                case 0x20:
+                        if (!(val & AC_SUPPCM_BITS_20))
+                                return false;
+                        break;
+                case 0x30:
+                        if (!(val & AC_SUPPCM_BITS_24))
+                                return false;
+                        break;
+                case 0x40:
+                        if (!(val & AC_SUPPCM_BITS_32))
+                                return false;
+                        break;
+                default:
+                        return false;
+                }
+        } else {
+                /* FIXME: check for float32 and AC3? */
+        }
+
+        return true;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_is_supported_format);