Merge branch 'topic/hda-regmap' into for-next

This merges the support of regmap in HD-audio infrastructure.
Many in-house cache codes in HD-audio driver are relaced with the
more standard regmap base now.

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

5 files changed, 574 insertions, 7 deletions

diff --git a/sound/hda/Kconfig b/sound/hda/Kconfig
index 4f428ccf64ad..001c6588a5ff 100644
--- a/sound/hda/Kconfig
+++ b/sound/hda/Kconfig
@@ -1,2 +1,3 @@
 config SND_HDA_CORE
         tristate
+        select REGMAP
diff --git a/sound/hda/Makefile b/sound/hda/Makefile
index eec5da03b41f..7a359f5b7e25 100644
--- a/sound/hda/Makefile
+++ b/sound/hda/Makefile
@@ -1,4 +1,5 @@
-snd-hda-core-objs := hda_bus_type.o hdac_bus.o hdac_device.o hdac_sysfs.o
+snd-hda-core-objs := hda_bus_type.o hdac_bus.o hdac_device.o hdac_sysfs.o \
+        hdac_regmap.o array.o
 
 snd-hda-core-objs += trace.o
 CFLAGS_trace.o := -I$(src)
diff --git a/sound/hda/array.c b/sound/hda/array.c
new file mode 100644
index 000000000000..516795baa7db
--- /dev/null
+++ b/sound/hda/array.c
@@ -0,0 +1,49 @@
+/*
+ * generic arrays
+ */
+
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/hdaudio.h>
+
+/**
+ * snd_array_new - get a new element from the given array
+ * @array: the array object
+ *
+ * Get a new element from the given array.  If it exceeds the
+ * pre-allocated array size, re-allocate the array.
+ *
+ * Returns NULL if allocation failed.
+ */
+void *snd_array_new(struct snd_array *array)
+{
+        if (snd_BUG_ON(!array->elem_size))
+                return NULL;
+        if (array->used >= array->alloced) {
+                int num = array->alloced + array->alloc_align;
+                int size = (num + 1) * array->elem_size;
+                void *nlist;
+                if (snd_BUG_ON(num >= 4096))
+                        return NULL;
+                nlist = krealloc(array->list, size, GFP_KERNEL | __GFP_ZERO);
+                if (!nlist)
+                        return NULL;
+                array->list = nlist;
+                array->alloced = num;
+        }
+        return snd_array_elem(array, array->used++);
+}
+EXPORT_SYMBOL_GPL(snd_array_new);
+
+/**
+ * snd_array_free - free the given array elements
+ * @array: the array object
+ */
+void snd_array_free(struct snd_array *array)
+{
+        kfree(array->list);
+        array->used = 0;
+        array->alloced = 0;
+        array->list = NULL;
+}
+EXPORT_SYMBOL_GPL(snd_array_free);
diff --git a/sound/hda/hdac_device.c b/sound/hda/hdac_device.c
index 53b6b95ff8cd..d4a0e723af2c 100644
--- a/sound/hda/hdac_device.c
+++ b/sound/hda/hdac_device.c
@@ -9,6 +9,7 @@
 #include <linux/export.h>
 #include <linux/pm_runtime.h>
 #include <sound/hdaudio.h>
+#include <sound/hda_regmap.h>
 #include "local.h"
 
 static void setup_fg_nodes(struct hdac_device *codec);
@@ -234,7 +235,22 @@ int snd_hdac_read(struct hdac_device *codec, hda_nid_t nid,
 EXPORT_SYMBOL_GPL(snd_hdac_read);
 
 /**
- * snd_hdac_read_parm - read a codec parameter
+ * _snd_hdac_read_parm - read a parmeter
+ *
+ * This function returns zero or an error unlike snd_hdac_read_parm().
+ */
+int _snd_hdac_read_parm(struct hdac_device *codec, hda_nid_t nid, int parm,
+                        unsigned int *res)
+{
+        unsigned int cmd;
+
+        cmd = snd_hdac_regmap_encode_verb(nid, AC_VERB_PARAMETERS) | parm;
+        return snd_hdac_regmap_read_raw(codec, cmd, res);
+}
+EXPORT_SYMBOL_GPL(_snd_hdac_read_parm);
+
+/**
+ * snd_hdac_read_parm_uncached - read a codec parameter without caching
  * @codec: the codec object
  * @nid: NID to read a parameter
  * @parm: parameter to read
@@ -242,15 +258,42 @@ EXPORT_SYMBOL_GPL(snd_hdac_read);
  * Returns -1 for error.  If you need to distinguish the error more
  * strictly, use snd_hdac_read() directly.
  */
-int snd_hdac_read_parm(struct hdac_device *codec, hda_nid_t nid, int parm)
+int snd_hdac_read_parm_uncached(struct hdac_device *codec, hda_nid_t nid,
+                                int parm)
 {
         int val;
 
-        if (snd_hdac_read(codec, nid, AC_VERB_PARAMETERS, parm, &val))
-                return -1;
+        if (codec->regmap)
+                regcache_cache_bypass(codec->regmap, true);
+        val = snd_hdac_read_parm(codec, nid, parm);
+        if (codec->regmap)
+                regcache_cache_bypass(codec->regmap, false);
         return val;
 }
-EXPORT_SYMBOL_GPL(snd_hdac_read_parm);
+EXPORT_SYMBOL_GPL(snd_hdac_read_parm_uncached);
+
+/**
+ * snd_hdac_override_parm - override read-only parameters
+ * @codec: the codec object
+ * @nid: NID for the parameter
+ * @parm: the parameter to change
+ * @val: the parameter value to overwrite
+ */
+int snd_hdac_override_parm(struct hdac_device *codec, hda_nid_t nid,
+                           unsigned int parm, unsigned int val)
+{
+        unsigned int verb = (AC_VERB_PARAMETERS << 8) | (nid << 20) | parm;
+        int err;
+
+        if (!codec->regmap)
+                return -EINVAL;
+
+        codec->caps_overwriting = true;
+        err = snd_hdac_regmap_write_raw(codec, verb, val);
+        codec->caps_overwriting = false;
+        return err;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_override_parm);
 
 /**
  * snd_hdac_get_sub_nodes - get start NID and number of subtree nodes
@@ -259,13 +302,14 @@ EXPORT_SYMBOL_GPL(snd_hdac_read_parm);
  * @start_id: the pointer to store the starting NID
  *
  * Returns the number of subtree nodes or zero if not found.
+ * This function reads parameters always without caching.
  */
 int snd_hdac_get_sub_nodes(struct hdac_device *codec, hda_nid_t nid,
                            hda_nid_t *start_id)
 {
         unsigned int parm;
 
-        parm = snd_hdac_read_parm(codec, nid, AC_PAR_NODE_COUNT);
+        parm = snd_hdac_read_parm_uncached(codec, nid, AC_PAR_NODE_COUNT);
         if (parm == -1) {
                 *start_id = 0;
                 return 0;
diff --git a/sound/hda/hdac_regmap.c b/sound/hda/hdac_regmap.c
new file mode 100644
index 000000000000..1eb43209fe2c
--- /dev/null
+++ b/sound/hda/hdac_regmap.c
@@ -0,0 +1,472 @@
+/*
+ * Regmap support for HD-audio verbs
+ *
+ * A virtual register is translated to one or more hda verbs for write,
+ * vice versa for read.
+ *
+ * A few limitations:
+ * - Provided for not all verbs but only subset standard non-volatile verbs.
+ * - For reading, only AC_VERB_GET_* variants can be used.
+ * - For writing, mapped to the *corresponding* AC_VERB_SET_* variants,
+ *   so can't handle asymmetric verbs for read and write
+ */
+
+#include <linux/slab.h>
+#include <linux/device.h>
+#include <linux/regmap.h>
+#include <linux/export.h>
+#include <linux/pm.h>
+#include <linux/pm_runtime.h>
+#include <sound/core.h>
+#include <sound/hdaudio.h>
+#include <sound/hda_regmap.h>
+
+#ifdef CONFIG_PM
+#define codec_is_running(codec)                         \
+        (atomic_read(&(codec)->in_pm) ||                \
+         !pm_runtime_suspended(&(codec)->dev))
+#else
+#define codec_is_running(codec)         true
+#endif
+
+#define get_verb(reg)   (((reg) >> 8) & 0xfff)
+
+static bool hda_volatile_reg(struct device *dev, unsigned int reg)
+{
+        struct hdac_device *codec = dev_to_hdac_dev(dev);
+        unsigned int verb = get_verb(reg);
+
+        switch (verb) {
+        case AC_VERB_GET_PROC_COEF:
+                return !codec->cache_coef;
+        case AC_VERB_GET_COEF_INDEX:
+        case AC_VERB_GET_PROC_STATE:
+        case AC_VERB_GET_POWER_STATE:
+        case AC_VERB_GET_PIN_SENSE:
+        case AC_VERB_GET_HDMI_DIP_SIZE:
+        case AC_VERB_GET_HDMI_ELDD:
+        case AC_VERB_GET_HDMI_DIP_INDEX:
+        case AC_VERB_GET_HDMI_DIP_DATA:
+        case AC_VERB_GET_HDMI_DIP_XMIT:
+        case AC_VERB_GET_HDMI_CP_CTRL:
+        case AC_VERB_GET_HDMI_CHAN_SLOT:
+        case AC_VERB_GET_DEVICE_SEL:
+        case AC_VERB_GET_DEVICE_LIST:   /* read-only volatile */
+                return true;
+        }
+
+        return false;
+}
+
+static bool hda_writeable_reg(struct device *dev, unsigned int reg)
+{
+        struct hdac_device *codec = dev_to_hdac_dev(dev);
+        unsigned int verb = get_verb(reg);
+        int i;
+
+        for (i = 0; i < codec->vendor_verbs.used; i++) {
+                unsigned int *v = snd_array_elem(&codec->vendor_verbs, i);
+                if (verb == *v)
+                        return true;
+        }
+
+        if (codec->caps_overwriting)
+                return true;
+
+        switch (verb & 0xf00) {
+        case AC_VERB_GET_STREAM_FORMAT:
+        case AC_VERB_GET_AMP_GAIN_MUTE:
+                return true;
+        case AC_VERB_GET_PROC_COEF:
+                return codec->cache_coef;
+        case 0xf00:
+                break;
+        default:
+                return false;
+        }
+
+        switch (verb) {
+        case AC_VERB_GET_CONNECT_SEL:
+        case AC_VERB_GET_SDI_SELECT:
+        case AC_VERB_GET_PIN_WIDGET_CONTROL:
+        case AC_VERB_GET_UNSOLICITED_RESPONSE: /* only as SET_UNSOLICITED_ENABLE */
+        case AC_VERB_GET_BEEP_CONTROL:
+        case AC_VERB_GET_EAPD_BTLENABLE:
+        case AC_VERB_GET_DIGI_CONVERT_1:
+        case AC_VERB_GET_DIGI_CONVERT_2: /* only for beep control */
+        case AC_VERB_GET_VOLUME_KNOB_CONTROL:
+        case AC_VERB_GET_GPIO_MASK:
+        case AC_VERB_GET_GPIO_DIRECTION:
+        case AC_VERB_GET_GPIO_DATA: /* not for volatile read */
+        case AC_VERB_GET_GPIO_WAKE_MASK:
+        case AC_VERB_GET_GPIO_UNSOLICITED_RSP_MASK:
+        case AC_VERB_GET_GPIO_STICKY_MASK:
+                return true;
+        }
+
+        return false;
+}
+
+static bool hda_readable_reg(struct device *dev, unsigned int reg)
+{
+        struct hdac_device *codec = dev_to_hdac_dev(dev);
+        unsigned int verb = get_verb(reg);
+
+        if (codec->caps_overwriting)
+                return true;
+
+        switch (verb) {
+        case AC_VERB_PARAMETERS:
+        case AC_VERB_GET_CONNECT_LIST:
+        case AC_VERB_GET_SUBSYSTEM_ID:
+                return true;
+        /* below are basically writable, but disabled for reducing unnecessary
+         * writes at sync
+         */
+        case AC_VERB_GET_CONFIG_DEFAULT: /* usually just read */
+        case AC_VERB_GET_CONV: /* managed in PCM code */
+        case AC_VERB_GET_CVT_CHAN_COUNT: /* managed in HDMI CA code */
+                return true;
+        }
+
+        return hda_writeable_reg(dev, reg);
+}
+
+/*
+ * Stereo amp pseudo register:
+ * for making easier to handle the stereo volume control, we provide a
+ * fake register to deal both left and right channels by a single
+ * (pseudo) register access.  A verb consisting of SET_AMP_GAIN with
+ * *both* SET_LEFT and SET_RIGHT bits takes a 16bit value, the lower 8bit
+ * for the left and the upper 8bit for the right channel.
+ */
+static bool is_stereo_amp_verb(unsigned int reg)
+{
+        if (((reg >> 8) & 0x700) != AC_VERB_SET_AMP_GAIN_MUTE)
+                return false;
+        return (reg & (AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT)) ==
+                (AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT);
+}
+
+/* read a pseudo stereo amp register (16bit left+right) */
+static int hda_reg_read_stereo_amp(struct hdac_device *codec,
+                                   unsigned int reg, unsigned int *val)
+{
+        unsigned int left, right;
+        int err;
+
+        reg &= ~(AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT);
+        err = snd_hdac_exec_verb(codec, reg | AC_AMP_GET_LEFT, 0, &left);
+        if (err < 0)
+                return err;
+        err = snd_hdac_exec_verb(codec, reg | AC_AMP_GET_RIGHT, 0, &right);
+        if (err < 0)
+                return err;
+        *val = left | (right << 8);
+        return 0;
+}
+
+/* write a pseudo stereo amp register (16bit left+right) */
+static int hda_reg_write_stereo_amp(struct hdac_device *codec,
+                                    unsigned int reg, unsigned int val)
+{
+        int err;
+        unsigned int verb, left, right;
+
+        verb = AC_VERB_SET_AMP_GAIN_MUTE << 8;
+        if (reg & AC_AMP_GET_OUTPUT)
+                verb |= AC_AMP_SET_OUTPUT;
+        else
+                verb |= AC_AMP_SET_INPUT | ((reg & 0xf) << 8);
+        reg = (reg & ~0xfffff) | verb;
+
+        left = val & 0xff;
+        right = (val >> 8) & 0xff;
+        if (left == right) {
+                reg |= AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT;
+                return snd_hdac_exec_verb(codec, reg | left, 0, NULL);
+        }
+
+        err = snd_hdac_exec_verb(codec, reg | AC_AMP_SET_LEFT | left, 0, NULL);
+        if (err < 0)
+                return err;
+        err = snd_hdac_exec_verb(codec, reg | AC_AMP_SET_RIGHT | right, 0, NULL);
+        if (err < 0)
+                return err;
+        return 0;
+}
+
+/* read a pseudo coef register (16bit) */
+static int hda_reg_read_coef(struct hdac_device *codec, unsigned int reg,
+                             unsigned int *val)
+{
+        unsigned int verb;
+        int err;
+
+        if (!codec->cache_coef)
+                return -EINVAL;
+        /* LSB 8bit = coef index */
+        verb = (reg & ~0xfff00) | (AC_VERB_SET_COEF_INDEX << 8);
+        err = snd_hdac_exec_verb(codec, verb, 0, NULL);
+        if (err < 0)
+                return err;
+        verb = (reg & ~0xfffff) | (AC_VERB_GET_COEF_INDEX << 8);
+        return snd_hdac_exec_verb(codec, verb, 0, val);
+}
+
+/* write a pseudo coef register (16bit) */
+static int hda_reg_write_coef(struct hdac_device *codec, unsigned int reg,
+                              unsigned int val)
+{
+        unsigned int verb;
+        int err;
+
+        if (!codec->cache_coef)
+                return -EINVAL;
+        /* LSB 8bit = coef index */
+        verb = (reg & ~0xfff00) | (AC_VERB_SET_COEF_INDEX << 8);
+        err = snd_hdac_exec_verb(codec, verb, 0, NULL);
+        if (err < 0)
+                return err;
+        verb = (reg & ~0xfffff) | (AC_VERB_GET_COEF_INDEX << 8) |
+                (val & 0xffff);
+        return snd_hdac_exec_verb(codec, verb, 0, NULL);
+}
+
+static int hda_reg_read(void *context, unsigned int reg, unsigned int *val)
+{
+        struct hdac_device *codec = context;
+        int verb = get_verb(reg);
+        int err;
+
+        if (!codec_is_running(codec))
+                return -EAGAIN;
+        reg |= (codec->addr << 28);
+        if (is_stereo_amp_verb(reg))
+                return hda_reg_read_stereo_amp(codec, reg, val);
+        if (verb == AC_VERB_GET_PROC_COEF)
+                return hda_reg_read_coef(codec, reg, val);
+        err = snd_hdac_exec_verb(codec, reg, 0, val);
+        if (err < 0)
+                return err;
+        /* special handling for asymmetric reads */
+        if (verb == AC_VERB_GET_POWER_STATE) {
+                if (*val & AC_PWRST_ERROR)
+                        *val = -1;
+                else /* take only the actual state */
+                        *val = (*val >> 4) & 0x0f;
+        }
+        return 0;
+}
+
+static int hda_reg_write(void *context, unsigned int reg, unsigned int val)
+{
+        struct hdac_device *codec = context;
+        unsigned int verb;
+        int i, bytes, err;
+
+        if (!codec_is_running(codec))
+                return codec->lazy_cache ? 0 : -EAGAIN;
+
+        reg &= ~0x00080000U; /* drop GET bit */
+        reg |= (codec->addr << 28);
+
+        if (is_stereo_amp_verb(reg))
+                return hda_reg_write_stereo_amp(codec, reg, val);
+
+        verb = get_verb(reg);
+        if (verb == AC_VERB_SET_PROC_COEF)
+                return hda_reg_write_coef(codec, reg, val);
+
+        switch (verb & 0xf00) {
+        case AC_VERB_SET_AMP_GAIN_MUTE:
+                verb = AC_VERB_SET_AMP_GAIN_MUTE;
+                if (reg & AC_AMP_GET_LEFT)
+                        verb |= AC_AMP_SET_LEFT >> 8;
+                else
+                        verb |= AC_AMP_SET_RIGHT >> 8;
+                if (reg & AC_AMP_GET_OUTPUT) {
+                        verb |= AC_AMP_SET_OUTPUT >> 8;
+                } else {
+                        verb |= AC_AMP_SET_INPUT >> 8;
+                        verb |= reg & 0xf;
+                }
+                break;
+        }
+
+        switch (verb) {
+        case AC_VERB_SET_DIGI_CONVERT_1:
+                bytes = 2;
+                break;
+        case AC_VERB_SET_CONFIG_DEFAULT_BYTES_0:
+                bytes = 4;
+                break;
+        default:
+                bytes = 1;
+                break;
+        }
+
+        for (i = 0; i < bytes; i++) {
+                reg &= ~0xfffff;
+                reg |= (verb + i) << 8 | ((val >> (8 * i)) & 0xff);
+                err = snd_hdac_exec_verb(codec, reg, 0, NULL);
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
+}
+
+static const struct regmap_config hda_regmap_cfg = {
+        .name = "hdaudio",
+        .reg_bits = 32,
+        .val_bits = 32,
+        .max_register = 0xfffffff,
+        .writeable_reg = hda_writeable_reg,
+        .readable_reg = hda_readable_reg,
+        .volatile_reg = hda_volatile_reg,
+        .cache_type = REGCACHE_RBTREE,
+        .reg_read = hda_reg_read,
+        .reg_write = hda_reg_write,
+        .use_single_rw = true,
+};
+
+int snd_hdac_regmap_init(struct hdac_device *codec)
+{
+        struct regmap *regmap;
+
+        regmap = regmap_init(&codec->dev, NULL, codec, &hda_regmap_cfg);
+        if (IS_ERR(regmap))
+                return PTR_ERR(regmap);
+        codec->regmap = regmap;
+        snd_array_init(&codec->vendor_verbs, sizeof(unsigned int), 8);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_regmap_init);
+
+void snd_hdac_regmap_exit(struct hdac_device *codec)
+{
+        if (codec->regmap) {
+                regmap_exit(codec->regmap);
+                codec->regmap = NULL;
+                snd_array_free(&codec->vendor_verbs);
+        }
+}
+EXPORT_SYMBOL_GPL(snd_hdac_regmap_exit);
+
+/**
+ * snd_hdac_regmap_add_vendor_verb - add a vendor-specific verb to regmap
+ * @codec: the codec object
+ * @verb: verb to allow accessing via regmap
+ *
+ * Returns zero for success or a negative error code.
+ */
+int snd_hdac_regmap_add_vendor_verb(struct hdac_device *codec,
+                                    unsigned int verb)
+{
+        unsigned int *p = snd_array_new(&codec->vendor_verbs);
+
+        if (!p)
+                return -ENOMEM;
+        *p = verb;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_regmap_add_vendor_verb);
+
+/*
+ * helper functions
+ */
+
+/* write a pseudo-register value (w/o power sequence) */
+static int reg_raw_write(struct hdac_device *codec, unsigned int reg,
+                         unsigned int val)
+{
+        if (!codec->regmap)
+                return hda_reg_write(codec, reg, val);
+        else
+                return regmap_write(codec->regmap, reg, val);
+}
+
+/**
+ * snd_hdac_regmap_write_raw - write a pseudo register with power mgmt
+ * @codec: the codec object
+ * @reg: pseudo register
+ * @val: value to write
+ *
+ * Returns zero if successful or a negative error code.
+ */
+int snd_hdac_regmap_write_raw(struct hdac_device *codec, unsigned int reg,
+                              unsigned int val)
+{
+        int err;
+
+        err = reg_raw_write(codec, reg, val);
+        if (err == -EAGAIN) {
+                snd_hdac_power_up(codec);
+                err = reg_raw_write(codec, reg, val);
+                snd_hdac_power_down(codec);
+        }
+        return err;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_regmap_write_raw);
+
+static int reg_raw_read(struct hdac_device *codec, unsigned int reg,
+                        unsigned int *val)
+{
+        if (!codec->regmap)
+                return hda_reg_read(codec, reg, val);
+        else
+                return regmap_read(codec->regmap, reg, val);
+}
+
+/**
+ * snd_hdac_regmap_read_raw - read a pseudo register with power mgmt
+ * @codec: the codec object
+ * @reg: pseudo register
+ * @val: pointer to store the read value
+ *
+ * Returns zero if successful or a negative error code.
+ */
+int snd_hdac_regmap_read_raw(struct hdac_device *codec, unsigned int reg,
+                             unsigned int *val)
+{
+        int err;
+
+        err = reg_raw_read(codec, reg, val);
+        if (err == -EAGAIN) {
+                snd_hdac_power_up(codec);
+                err = reg_raw_read(codec, reg, val);
+                snd_hdac_power_down(codec);
+        }
+        return err;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_regmap_read_raw);
+
+/**
+ * snd_hdac_regmap_update_raw - update a pseudo register with power mgmt
+ * @codec: the codec object
+ * @reg: pseudo register
+ * @mask: bit mask to udpate
+ * @val: value to update
+ *
+ * Returns zero if successful or a negative error code.
+ */
+int snd_hdac_regmap_update_raw(struct hdac_device *codec, unsigned int reg,
+                               unsigned int mask, unsigned int val)
+{
+        unsigned int orig;
+        int err;
+
+        val &= mask;
+        err = snd_hdac_regmap_read_raw(codec, reg, &orig);
+        if (err < 0)
+                return err;
+        val |= orig & ~mask;
+        if (val == orig)
+                return 0;
+        err = snd_hdac_regmap_write_raw(codec, reg, val);
+        if (err < 0)
+                return err;
+        return 1;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_regmap_update_raw);