mfd: Remove custom wm8350 cache implementation

Since none of the users now reference the cache directly we can happily
remove the custom cache code and rely on the regmap cache.

For simplicity we don't bother with the register defaults tables but
instead read the defaults from the device - regmap is capable of doing
this, unlike our old cache infrastructure. This saves a lot of code and
allows us to cache the device revision information too.

Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>

3 files changed, 18 insertions, 3492 deletions

diff --git a/drivers/mfd/wm8350-core.c b/drivers/mfd/wm8350-core.c
index fadcbbe9e2ba..7c1ae24605d9 100644
--- a/drivers/mfd/wm8350-core.c
+++ b/drivers/mfd/wm8350-core.c
@@ -60,181 +60,32 @@
 /*
  * WM8350 Device IO
  */
-static DEFINE_MUTEX(io_mutex);
 static DEFINE_MUTEX(reg_lock_mutex);
 
-/* Perform a physical read from the device.
- */
-static int wm8350_phys_read(struct wm8350 *wm8350, u8 reg, int num_regs,
-                            u16 *dest)
-{
-        int i, ret;
-        int bytes = num_regs * 2;
-
-        dev_dbg(wm8350->dev, "volatile read\n");
-        ret = regmap_raw_read(wm8350->regmap, reg, dest, bytes);
-
-        for (i = reg; i < reg + num_regs; i++) {
-                /* Cache is CPU endian */
-                dest[i - reg] = be16_to_cpu(dest[i - reg]);
-
-                /* Mask out non-readable bits */
-                dest[i - reg] &= wm8350_reg_io_map[i].readable;
-        }
-
-        dump(num_regs, dest);
-
-        return ret;
-}
-
-static int wm8350_read(struct wm8350 *wm8350, u8 reg, int num_regs, u16 *dest)
-{
-        int i;
-        int end = reg + num_regs;
-        int ret = 0;
-        int bytes = num_regs * 2;
-
-        if ((reg + num_regs - 1) > WM8350_MAX_REGISTER) {
-                dev_err(wm8350->dev, "invalid reg %x\n",
-                        reg + num_regs - 1);
-                return -EINVAL;
-        }
-
-        dev_dbg(wm8350->dev,
-                "%s R%d(0x%2.2x) %d regs\n", __func__, reg, reg, num_regs);
-
-#if WM8350_BUS_DEBUG
-        /* we can _safely_ read any register, but warn if read not supported */
-        for (i = reg; i < end; i++) {
-                if (!wm8350_reg_io_map[i].readable)
-                        dev_warn(wm8350->dev,
-                                "reg R%d is not readable\n", i);
-        }
-#endif
-
-        /* if any volatile registers are required, then read back all */
-        for (i = reg; i < end; i++)
-                if (wm8350_reg_io_map[i].vol)
-                        return wm8350_phys_read(wm8350, reg, num_regs, dest);
-
-        /* no volatiles, then cache is good */
-        dev_dbg(wm8350->dev, "cache read\n");
-        memcpy(dest, &wm8350->reg_cache[reg], bytes);
-        dump(num_regs, dest);
-        return ret;
-}
-
-static inline int is_reg_locked(struct wm8350 *wm8350, u8 reg)
-{
-        if (reg == WM8350_SECURITY ||
-            wm8350->reg_cache[WM8350_SECURITY] == WM8350_UNLOCK_KEY)
-                return 0;
-
-        if ((reg >= WM8350_GPIO_FUNCTION_SELECT_1 &&
-             reg <= WM8350_GPIO_FUNCTION_SELECT_4) ||
-            (reg >= WM8350_BATTERY_CHARGER_CONTROL_1 &&
-             reg <= WM8350_BATTERY_CHARGER_CONTROL_3))
-                return 1;
-        return 0;
-}
-
-static int wm8350_write(struct wm8350 *wm8350, u8 reg, int num_regs, u16 *src)
-{
-        int i;
-        int end = reg + num_regs;
-        int bytes = num_regs * 2;
-
-        if ((reg + num_regs - 1) > WM8350_MAX_REGISTER) {
-                dev_err(wm8350->dev, "invalid reg %x\n",
-                        reg + num_regs - 1);
-                return -EINVAL;
-        }
-
-        /* it's generally not a good idea to write to RO or locked registers */
-        for (i = reg; i < end; i++) {
-                if (!wm8350_reg_io_map[i].writable) {
-                        dev_err(wm8350->dev,
-                                "attempted write to read only reg R%d\n", i);
-                        return -EINVAL;
-                }
-
-                if (is_reg_locked(wm8350, i)) {
-                        dev_err(wm8350->dev,
-                               "attempted write to locked reg R%d\n", i);
-                        return -EINVAL;
-                }
-
-                src[i - reg] &= wm8350_reg_io_map[i].writable;
-
-                wm8350->reg_cache[i] =
-                        (wm8350->reg_cache[i] & ~wm8350_reg_io_map[i].writable)
-                        | src[i - reg];
-
-                src[i - reg] = cpu_to_be16(src[i - reg]);
-        }
-
-        /* Actually write it out */
-        return regmap_raw_write(wm8350->regmap, reg, src, bytes);
-}
-
 /*
  * Safe read, modify, write methods
  */
 int wm8350_clear_bits(struct wm8350 *wm8350, u16 reg, u16 mask)
 {
-        u16 data;
-        int err;
-
-        mutex_lock(&io_mutex);
-        err = wm8350_read(wm8350, reg, 1, &data);
-        if (err) {
-                dev_err(wm8350->dev, "read from reg R%d failed\n", reg);
-                goto out;
-        }
-
-        data &= ~mask;
-        err = wm8350_write(wm8350, reg, 1, &data);
-        if (err)
-                dev_err(wm8350->dev, "write to reg R%d failed\n", reg);
-out:
-        mutex_unlock(&io_mutex);
-        return err;
+        return regmap_update_bits(wm8350->regmap, reg, mask, 0);
 }
 EXPORT_SYMBOL_GPL(wm8350_clear_bits);
 
 int wm8350_set_bits(struct wm8350 *wm8350, u16 reg, u16 mask)
 {
-        u16 data;
-        int err;
-
-        mutex_lock(&io_mutex);
-        err = wm8350_read(wm8350, reg, 1, &data);
-        if (err) {
-                dev_err(wm8350->dev, "read from reg R%d failed\n", reg);
-                goto out;
-        }
-
-        data |= mask;
-        err = wm8350_write(wm8350, reg, 1, &data);
-        if (err)
-                dev_err(wm8350->dev, "write to reg R%d failed\n", reg);
-out:
-        mutex_unlock(&io_mutex);
-        return err;
+        return regmap_update_bits(wm8350->regmap, reg, mask, mask);
 }
 EXPORT_SYMBOL_GPL(wm8350_set_bits);
 
 u16 wm8350_reg_read(struct wm8350 *wm8350, int reg)
 {
-        u16 data;
+        unsigned int data;
         int err;
 
-        mutex_lock(&io_mutex);
-        err = wm8350_read(wm8350, reg, 1, &data);
+        err = regmap_read(wm8350->regmap, reg, &data);
         if (err)
                 dev_err(wm8350->dev, "read from reg R%d failed\n", reg);
 
-        mutex_unlock(&io_mutex);