sound/soc/soc-cache.c

   1 /*
   2  * soc-cache.c  --  ASoC register cache helpers
   3  *
   4  * Copyright 2009 Wolfson Microelectronics PLC.
   5  *
   6  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
   7  *
   8  *  This program is free software; you can redistribute  it and/or modify it
   9  *  under  the terms of  the GNU General  Public License as published by the
  10  *  Free Software Foundation;  either version 2 of the  License, or (at your
  11  *  option) any later version.
  12  */
  13
  14 #include <linux/i2c.h>
  15 #include <linux/spi/spi.h>
  16 #include <sound/soc.h>
  17 #include <linux/bitmap.h>
  18 #include <linux/rbtree.h>
  19 #include <linux/export.h>
  20
  21 #include <trace/events/asoc.h>
  22
  23 static bool snd_soc_set_cache_val(void *base, unsigned int idx,
  24                                   unsigned int val, unsigned int word_size)
  25 {
  26         switch (word_size) {
  27         case 1: {
  28                 u8 *cache = base;
  29                 if (cache[idx] == val)
  30                         return true;
  31                 cache[idx] = val;
  32                 break;
  33         }
  34         case 2: {
  35                 u16 *cache = base;
  36                 if (cache[idx] == val)
  37                         return true;
  38                 cache[idx] = val;
  39                 break;
  40         }
  41         default:
  42                 BUG();
  43         }
  44         return false;
  45 }
  46
  47 static unsigned int snd_soc_get_cache_val(const void *base, unsigned int idx,
  48                 unsigned int word_size)
  49 {
  50         if (!base)
  51                 return -1;
  52
  53         switch (word_size) {
  54         case 1: {
  55                 const u8 *cache = base;
  56                 return cache[idx];
  57         }
  58         case 2: {
  59                 const u16 *cache = base;
  60                 return cache[idx];
  61         }
  62         default:
  63                 BUG();
  64         }
  65         /* unreachable */
  66         return -1;
  67 }
  68
  69 static int snd_soc_flat_cache_sync(struct snd_soc_codec *codec)
  70 {
  71         int i;
  72         int ret;
  73         const struct snd_soc_codec_driver *codec_drv;
  74         unsigned int val;
  75
  76         codec_drv = codec->driver;
  77         for (i = 0; i < codec_drv->reg_cache_size; ++i) {
  78                 ret = snd_soc_cache_read(codec, i, &val);
  79                 if (ret)
  80                         return ret;
  81                 if (codec->reg_def_copy)
  82                         if (snd_soc_get_cache_val(codec->reg_def_copy,
  83                                                   i, codec_drv->reg_word_size) == val)
  84                                 continue;
  85
  86                 WARN_ON(!snd_soc_codec_writable_register(codec, i));
  87
  88                 ret = snd_soc_write(codec, i, val);
  89                 if (ret)
  90                         return ret;
  91                 dev_dbg(codec->dev, "Synced register %#x, value = %#x\n",
  92                         i, val);
  93         }
  94         return 0;
  95 }
  96
  97 static int snd_soc_flat_cache_write(struct snd_soc_codec *codec,
  98                                     unsigned int reg, unsigned int value)
  99 {
 100         snd_soc_set_cache_val(codec->reg_cache, reg, value,
 101                               codec->driver->reg_word_size);
 102         return 0;
 103 }
 104
 105 static int snd_soc_flat_cache_read(struct snd_soc_codec *codec,
 106                                    unsigned int reg, unsigned int *value)
 107 {
 108         *value = snd_soc_get_cache_val(codec->reg_cache, reg,
 109                                        codec->driver->reg_word_size);
 110         return 0;
 111 }
 112
 113 static int snd_soc_flat_cache_exit(struct snd_soc_codec *codec)
 114 {
 115         if (!codec->reg_cache)
 116                 return 0;
 117         kfree(codec->reg_cache);
 118         codec->reg_cache = NULL;
 119         return 0;
 120 }
 121
 122 static int snd_soc_flat_cache_init(struct snd_soc_codec *codec)
 123 {
 124         if (codec->reg_def_copy)
 125                 codec->reg_cache = kmemdup(codec->reg_def_copy,
 126                                            codec->reg_size, GFP_KERNEL);
 127         else
 128                 codec->reg_cache = kzalloc(codec->reg_size, GFP_KERNEL);
 129         if (!codec->reg_cache)
 130                 return -ENOMEM;
 131
 132         return 0;
 133 }
 134
 135 /* an array of all supported compression types */
 136 static const struct snd_soc_cache_ops cache_types[] = {
 137         /* Flat *must* be the first entry for fallback */
 138         {
 139                 .id = SND_SOC_FLAT_COMPRESSION,
 140                 .name = "flat",
 141                 .init = snd_soc_flat_cache_init,
 142                 .exit = snd_soc_flat_cache_exit,
 143                 .read = snd_soc_flat_cache_read,
 144                 .write = snd_soc_flat_cache_write,
 145                 .sync = snd_soc_flat_cache_sync
 146         },
 147 };
 148
 149 int snd_soc_cache_init(struct snd_soc_codec *codec)
 150 {
 151         int i;
 152
 153         for (i = 0; i < ARRAY_SIZE(cache_types); ++i)
 154                 if (cache_types[i].id == codec->compress_type)
 155                         break;
 156
 157         /* Fall back to flat compression */
 158         if (i == ARRAY_SIZE(cache_types)) {
 159                 dev_warn(codec->dev, "Could not match compress type: %d\n",
 160                          codec->compress_type);
 161                 i = 0;
 162         }
 163
 164         mutex_init(&codec->cache_rw_mutex);
 165         codec->cache_ops = &cache_types[i];
 166
 167         if (codec->cache_ops->init) {
 168                 if (codec->cache_ops->name)
 169                         dev_dbg(codec->dev, "Initializing %s cache for %s codec\n",
 170                                 codec->cache_ops->name, codec->name);
 171                 return codec->cache_ops->init(codec);
 172         }
 173         return -ENOSYS;
 174 }
 175
 176 /*
 177  * NOTE: keep in mind that this function might be called
 178  * multiple times.
 179  */
 180 int snd_soc_cache_exit(struct snd_soc_codec *codec)
 181 {
 182         if (codec->cache_ops && codec->cache_ops->exit) {
 183                 if (codec->cache_ops->name)
 184                         dev_dbg(codec->dev, "Destroying %s cache for %s codec\n",
 185                                 codec->cache_ops->name, codec->name);
 186                 return codec->cache_ops->exit(codec);
 187         }
 188         return -ENOSYS;
 189 }
 190
 191 /**
 192  * snd_soc_cache_read: Fetch the value of a given register from the cache.
 193  *
 194  * @codec: CODEC to configure.
 195  * @reg: The register index.
 196  * @value: The value to be returned.
 197  */
 198 int snd_soc_cache_read(struct snd_soc_codec *codec,
 199                        unsigned int reg, unsigned int *value)
 200 {
 201         int ret;
 202
 203         mutex_lock(&codec->cache_rw_mutex);
 204
 205         if (value && codec->cache_ops && codec->cache_ops->read) {
 206                 ret = codec->cache_ops->read(codec, reg, value);
 207                 mutex_unlock(&codec->cache_rw_mutex);
 208                 return ret;
 209         }
 210
 211         mutex_unlock(&codec->cache_rw_mutex);
 212         return -ENOSYS;
 213 }
 214 EXPORT_SYMBOL_GPL(snd_soc_cache_read);
 215
 216 /**
 217  * snd_soc_cache_write: Set the value of a given register in the cache.
 218  *
 219  * @codec: CODEC to configure.
 220  * @reg: The register index.
 221  * @value: The new register value.
 222  */
 223 int snd_soc_cache_write(struct snd_soc_codec *codec,
 224                         unsigned int reg, unsigned int value)
 225 {
 226         int ret;
 227
 228         mutex_lock(&codec->cache_rw_mutex);
 229
 230         if (codec->cache_ops && codec->cache_ops->write) {
 231                 ret = codec->cache_ops->write(codec, reg, value);
 232                 mutex_unlock(&codec->cache_rw_mutex);
 233                 return ret;
 234         }
 235
 236         mutex_unlock(&codec->cache_rw_mutex);
 237         return -ENOSYS;
 238 }
 239 EXPORT_SYMBOL_GPL(snd_soc_cache_write);
 240
 241 /**
 242  * snd_soc_cache_sync: Sync the register cache with the hardware.
 243  *
 244  * @codec: CODEC to configure.
 245  *
 246  * Any registers that should not be synced should be marked as
 247  * volatile.  In general drivers can choose not to use the provided
 248  * syncing functionality if they so require.
 249  */
 250 int snd_soc_cache_sync(struct snd_soc_codec *codec)
 251 {
 252         int ret;
 253         const char *name;
 254
 255         if (!codec->cache_sync) {
 256                 return 0;
 257         }
 258
 259         if (!codec->cache_ops || !codec->cache_ops->sync)
 260                 return -ENOSYS;
 261
 262         if (codec->cache_ops->name)
 263                 name = codec->cache_ops->name;
 264         else
 265                 name = "unknown";
 266
 267         if (codec->cache_ops->name)
 268                 dev_dbg(codec->dev, "Syncing %s cache for %s codec\n",
 269                         codec->cache_ops->name, codec->name);
 270         trace_snd_soc_cache_sync(codec, name, "start");
 271         ret = codec->cache_ops->sync(codec);
 272         if (!ret)
 273                 codec->cache_sync = 0;
 274         trace_snd_soc_cache_sync(codec, name, "end");
 275         return ret;
 276 }
 277 EXPORT_SYMBOL_GPL(snd_soc_cache_sync);
 278
 279 static int snd_soc_get_reg_access_index(struct snd_soc_codec *codec,
 280                                         unsigned int reg)
 281 {
 282         const struct snd_soc_codec_driver *codec_drv;
 283         unsigned int min, max, index;
 284
 285         codec_drv = codec->driver;
 286         min = 0;
 287         max = codec_drv->reg_access_size - 1;
 288         do {
 289                 index = (min + max) / 2;
 290                 if (codec_drv->reg_access_default[index].reg == reg)
 291                         return index;
 292                 if (codec_drv->reg_access_default[index].reg < reg)
 293                         min = index + 1;
 294                 else
 295                         max = index;
 296         } while (min <= max);
 297         return -1;
 298 }
 299
 300 int snd_soc_default_volatile_register(struct snd_soc_codec *codec,
 301                                       unsigned int reg)
 302 {
 303         int index;
 304
 305         if (reg >= codec->driver->reg_cache_size)
 306                 return 1;
 307         index = snd_soc_get_reg_access_index(codec, reg);
 308         if (index < 0)
 309                 return 0;
 310         return codec->driver->reg_access_default[index].vol;
 311 }
 312 EXPORT_SYMBOL_GPL(snd_soc_default_volatile_register);
 313
 314 int snd_soc_default_readable_register(struct snd_soc_codec *codec,
 315                                       unsigned int reg)
 316 {
 317         int index;
 318
 319         if (reg >= codec->driver->reg_cache_size)
 320                 return 1;
 321         index = snd_soc_get_reg_access_index(codec, reg);
 322         if (index < 0)
 323                 return 0;
 324         return codec->driver->reg_access_default[index].read;
 325 }
 326 EXPORT_SYMBOL_GPL(snd_soc_default_readable_register);
 327
 328 int snd_soc_default_writable_register(struct snd_soc_codec *codec,
 329                                       unsigned int reg)
 330 {
 331         int index;
 332
 333         if (reg >= codec->driver->reg_cache_size)
 334                 return 1;
 335         index = snd_soc_get_reg_access_index(codec, reg);
 336         if (index < 0)
 337                 return 0;
 338         return codec->driver->reg_access_default[index].write;
 339 }
 340 EXPORT_SYMBOL_GPL(snd_soc_default_writable_register);