ASoC: Remove rbtree register cache

All users now use regmap directly so delete the ASoC version of the code.

Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>

diff --git a/include/sound/soc.h b/include/sound/soc.h
index d9aa66be1994c5e12b3af589a11e75182e5b9238..a35cf14a8eb14ac7f867a9e13bb624e27c15463e 100644 (file)
--- a/include/sound/soc.h
+++ b/include/sound/soc.h
@@ -266,7 +266,6 @@ enum snd_soc_control_type {
 
 enum snd_soc_compress_type {
        SND_SOC_FLAT_COMPRESSION = 1,
-       SND_SOC_RBTREE_COMPRESSION
 };
 
 enum snd_soc_pcm_subclass {

diff --git a/sound/soc/soc-cache.c b/sound/soc/soc-cache.c
index 18bb6b3335e0424ad5a9830d466c930dc8560fcc..9d56f0218f41688576fec511db272e6484480bdb 100644 (file)
--- a/sound/soc/soc-cache.c
+++ b/sound/soc/soc-cache.c
@@ -66,378 +66,6 @@ static unsigned int snd_soc_get_cache_val(const void *base, unsigned int idx,
        return -1;
 }
 
-struct snd_soc_rbtree_node {
-       struct rb_node node; /* the actual rbtree node holding this block */
-       unsigned int base_reg; /* base register handled by this block */
-       unsigned int word_size; /* number of bytes needed to represent the register index */
-       void *block; /* block of adjacent registers */
-       unsigned int blklen; /* number of registers available in the block */
-} __attribute__ ((packed));
-
-struct snd_soc_rbtree_ctx {
-       struct rb_root root;
-       struct snd_soc_rbtree_node *cached_rbnode;
-};
-
-static inline void snd_soc_rbtree_get_base_top_reg(
-       struct snd_soc_rbtree_node *rbnode,
-       unsigned int *base, unsigned int *top)
-{
-       *base = rbnode->base_reg;
-       *top = rbnode->base_reg + rbnode->blklen - 1;
-}
-
-static unsigned int snd_soc_rbtree_get_register(
-       struct snd_soc_rbtree_node *rbnode, unsigned int idx)
-{
-       unsigned int val;
-
-       switch (rbnode->word_size) {
-       case 1: {
-               u8 *p = rbnode->block;
-               val = p[idx];
-               return val;
-       }
-       case 2: {
-               u16 *p = rbnode->block;
-               val = p[idx];
-               return val;
-       }
-       default:
-               BUG();
-               break;
-       }
-       return -1;
-}
-
-static void snd_soc_rbtree_set_register(struct snd_soc_rbtree_node *rbnode,
-                                       unsigned int idx, unsigned int val)
-{
-       switch (rbnode->word_size) {
-       case 1: {
-               u8 *p = rbnode->block;
-               p[idx] = val;
-               break;
-       }
-       case 2: {
-               u16 *p = rbnode->block;
-               p[idx] = val;
-               break;
-       }
-       default:
-               BUG();
-               break;
-       }
-}
-
-static struct snd_soc_rbtree_node *snd_soc_rbtree_lookup(
-       struct rb_root *root, unsigned int reg)
-{
-       struct rb_node *node;
-       struct snd_soc_rbtree_node *rbnode;
-       unsigned int base_reg, top_reg;
-
-       node = root->rb_node;
-       while (node) {
-               rbnode = container_of(node, struct snd_soc_rbtree_node, node);
-               snd_soc_rbtree_get_base_top_reg(rbnode, &base_reg, &top_reg);
-               if (reg >= base_reg && reg <= top_reg)
-                       return rbnode;
-               else if (reg > top_reg)
-                       node = node->rb_right;
-               else if (reg < base_reg)
-                       node = node->rb_left;
-       }
-
-       return NULL;
-}
-
-static int snd_soc_rbtree_insert(struct rb_root *root,
-                                struct snd_soc_rbtree_node *rbnode)
-{
-       struct rb_node **new, *parent;
-       struct snd_soc_rbtree_node *rbnode_tmp;
-       unsigned int base_reg_tmp, top_reg_tmp;
-       unsigned int base_reg;
-
-       parent = NULL;
-       new = &root->rb_node;
-       while (*new) {
-               rbnode_tmp = container_of(*new, struct snd_soc_rbtree_node,
-                                         node);
-               /* base and top registers of the current rbnode */
-               snd_soc_rbtree_get_base_top_reg(rbnode_tmp, &base_reg_tmp,
-                                               &top_reg_tmp);
-               /* base register of the rbnode to be added */
-               base_reg = rbnode->base_reg;
-               parent = *new;
-               /* if this register has already been inserted, just return */
-               if (base_reg >= base_reg_tmp &&
-                   base_reg <= top_reg_tmp)
-                       return 0;
-               else if (base_reg > top_reg_tmp)
-                       new = &((*new)->rb_right);
-               else if (base_reg < base_reg_tmp)
-                       new = &((*new)->rb_left);
-       }
-
-       /* insert the node into the rbtree */
-       rb_link_node(&rbnode->node, parent, new);
-       rb_insert_color(&rbnode->node, root);
-
-       return 1;
-}
-
-static int snd_soc_rbtree_cache_sync(struct snd_soc_codec *codec)
-{
-       struct snd_soc_rbtree_ctx *rbtree_ctx;
-       struct rb_node *node;
-       struct snd_soc_rbtree_node *rbnode;
-       unsigned int regtmp;
-       unsigned int val, def;
-       int ret;
-       int i;
-
-       rbtree_ctx = codec->reg_cache;
-       for (node = rb_first(&rbtree_ctx->root); node; node = rb_next(node)) {
-               rbnode = rb_entry(node, struct snd_soc_rbtree_node, node);
-               for (i = 0; i < rbnode->blklen; ++i) {
-                       regtmp = rbnode->base_reg + i;
-                       val = snd_soc_rbtree_get_register(rbnode, i);
-                       def = snd_soc_get_cache_val(codec->reg_def_copy, i,
-                                                   rbnode->word_size);
-                       if (val == def)
-                               continue;
-
-                       WARN_ON(!snd_soc_codec_writable_register(codec, regtmp));
-
-                       codec->cache_bypass = 1;
-                       ret = snd_soc_write(codec, regtmp, val);
-                       codec->cache_bypass = 0;
-                       if (ret)
-                               return ret;
-                       dev_dbg(codec->dev, "Synced register %#x, value = %#x\n",
-                               regtmp, val);
-               }
-       }
-
-       return 0;
-}
-
-static int snd_soc_rbtree_insert_to_block(struct snd_soc_rbtree_node *rbnode,
-                                         unsigned int pos, unsigned int reg,
-                                         unsigned int value)
-{
-       u8 *blk;
-
-       blk = krealloc(rbnode->block,
-                      (rbnode->blklen + 1) * rbnode->word_size, GFP_KERNEL);
-       if (!blk)
-               return -ENOMEM;
-
-       /* insert the register value in the correct place in the rbnode block */
-       memmove(blk + (pos + 1) * rbnode->word_size,
-               blk + pos * rbnode->word_size,
-               (rbnode->blklen - pos) * rbnode->word_size);
-
-       /* update the rbnode block, its size and the base register */
-       rbnode->block = blk;
-       rbnode->blklen++;
-       if (!pos)
-               rbnode->base_reg = reg;
-
-       snd_soc_rbtree_set_register(rbnode, pos, value);
-       return 0;
-}
-
-static int snd_soc_rbtree_cache_write(struct snd_soc_codec *codec,
-                                     unsigned int reg, unsigned int value)
-{
-       struct snd_soc_rbtree_ctx *rbtree_ctx;
-       struct snd_soc_rbtree_node *rbnode, *rbnode_tmp;
-       struct rb_node *node;
-       unsigned int val;
-       unsigned int reg_tmp;
-       unsigned int base_reg, top_reg;
-       unsigned int pos;
-       int i;
-       int ret;
-
-       rbtree_ctx = codec->reg_cache;
-       /* look up the required register in the cached rbnode */
-       rbnode = rbtree_ctx->cached_rbnode;
-       if (rbnode) {
-               snd_soc_rbtree_get_base_top_reg(rbnode, &base_reg, &top_reg);
-               if (reg >= base_reg && reg <= top_reg) {
-                       reg_tmp = reg - base_reg;
-                       val = snd_soc_rbtree_get_register(rbnode, reg_tmp);
-                       if (val == value)
-                               return 0;
-                       snd_soc_rbtree_set_register(rbnode, reg_tmp, value);
-                       return 0;
-               }
-       }
-       /* if we can't locate it in the cached rbnode we'll have
-        * to traverse the rbtree looking for it.
-        */
-       rbnode = snd_soc_rbtree_lookup(&rbtree_ctx->root, reg);
-       if (rbnode) {
-               reg_tmp = reg - rbnode->base_reg;
-               val = snd_soc_rbtree_get_register(rbnode, reg_tmp);
-               if (val == value)
-                       return 0;
-               snd_soc_rbtree_set_register(rbnode, reg_tmp, value);
-               rbtree_ctx->cached_rbnode = rbnode;
-       } else {
-               /* bail out early, no need to create the rbnode yet */
-               if (!value)
-                       return 0;
-               /* look for an adjacent register to the one we are about to add */
-               for (node = rb_first(&rbtree_ctx->root); node;
-                    node = rb_next(node)) {
-                       rbnode_tmp = rb_entry(node, struct snd_soc_rbtree_node, node);
-                       for (i = 0; i < rbnode_tmp->blklen; ++i) {
-                               reg_tmp = rbnode_tmp->base_reg + i;
-                               if (abs(reg_tmp - reg) != 1)
-                                       continue;
-                               /* decide where in the block to place our register */
-                               if (reg_tmp + 1 == reg)
-                                       pos = i + 1;
-                               else
-                                       pos = i;
-                               ret = snd_soc_rbtree_insert_to_block(rbnode_tmp, pos,
-                                                                    reg, value);
-                               if (ret)
-                                       return ret;
-                               rbtree_ctx->cached_rbnode = rbnode_tmp;
-                               return 0;
-                       }
-               }
-               /* we did not manage to find a place to insert it in an existing
-                * block so create a new rbnode with a single register in its block.
-                * This block will get populated further if any other adjacent
-                * registers get modified in the future.
-                */
-               rbnode = kzalloc(sizeof *rbnode, GFP_KERNEL);
-               if (!rbnode)
-                       return -ENOMEM;
-               rbnode->blklen = 1;
-               rbnode->base_reg = reg;
-               rbnode->word_size = codec->driver->reg_word_size;
-               rbnode->block = kmalloc(rbnode->blklen * rbnode->word_size,
-                                       GFP_KERNEL);
-               if (!rbnode->block) {
-                       kfree(rbnode);
-                       return -ENOMEM;
-               }
-               snd_soc_rbtree_set_register(rbnode, 0, value);
-               snd_soc_rbtree_insert(&rbtree_ctx->root, rbnode);
-               rbtree_ctx->cached_rbnode = rbnode;
-       }
-
-       return 0;
-}
-
-static int snd_soc_rbtree_cache_read(struct snd_soc_codec *codec,
-                                    unsigned int reg, unsigned int *value)
-{
-       struct snd_soc_rbtree_ctx *rbtree_ctx;
-       struct snd_soc_rbtree_node *rbnode;
-       unsigned int base_reg, top_reg;
-       unsigned int reg_tmp;
-
-       rbtree_ctx = codec->reg_cache;
-       /* look up the required register in the cached rbnode */
-       rbnode = rbtree_ctx->cached_rbnode;
-       if (rbnode) {
-               snd_soc_rbtree_get_base_top_reg(rbnode, &base_reg, &top_reg);
-               if (reg >= base_reg && reg <= top_reg) {
-                       reg_tmp = reg - base_reg;
-                       *value = snd_soc_rbtree_get_register(rbnode, reg_tmp);
-                       return 0;
-               }
-       }
-       /* if we can't locate it in the cached rbnode we'll have
-        * to traverse the rbtree looking for it.
-        */
-       rbnode = snd_soc_rbtree_lookup(&rbtree_ctx->root, reg);
-       if (rbnode) {
-               reg_tmp = reg - rbnode->base_reg;
-               *value = snd_soc_rbtree_get_register(rbnode, reg_tmp);
-               rbtree_ctx->cached_rbnode = rbnode;
-       } else {
-               /* uninitialized registers default to 0 */
-               *value = 0;
-       }
-
-       return 0;
-}
-
-static int snd_soc_rbtree_cache_exit(struct snd_soc_codec *codec)
-{
-       struct rb_node *next;
-       struct snd_soc_rbtree_ctx *rbtree_ctx;
-       struct snd_soc_rbtree_node *rbtree_node;
-
-       /* if we've already been called then just return */
-       rbtree_ctx = codec->reg_cache;
-       if (!rbtree_ctx)
-               return 0;
-
-       /* free up the rbtree */
-       next = rb_first(&rbtree_ctx->root);
-       while (next) {
-               rbtree_node = rb_entry(next, struct snd_soc_rbtree_node, node);
-               next = rb_next(&rbtree_node->node);
-               rb_erase(&rbtree_node->node, &rbtree_ctx->root);
-               kfree(rbtree_node->block);
-               kfree(rbtree_node);
-       }
-
-       /* release the resources */
-       kfree(codec->reg_cache);
-       codec->reg_cache = NULL;
-
-       return 0;
-}
-
-static int snd_soc_rbtree_cache_init(struct snd_soc_codec *codec)
-{
-       struct snd_soc_rbtree_ctx *rbtree_ctx;
-       unsigned int word_size;
-       unsigned int val;
-       int i;
-       int ret;
-
-       codec->reg_cache = kmalloc(sizeof *rbtree_ctx, GFP_KERNEL);
-       if (!codec->reg_cache)
-               return -ENOMEM;
-
-       rbtree_ctx = codec->reg_cache;
-       rbtree_ctx->root = RB_ROOT;
-       rbtree_ctx->cached_rbnode = NULL;
-
-       if (!codec->reg_def_copy)
-               return 0;
-
-       word_size = codec->driver->reg_word_size;
-       for (i = 0; i < codec->driver->reg_cache_size; ++i) {
-               val = snd_soc_get_cache_val(codec->reg_def_copy, i,
-                                           word_size);
-               if (!val)
-                       continue;
-               ret = snd_soc_rbtree_cache_write(codec, i, val);
-               if (ret)
-                       goto err;
-       }
-
-       return 0;
-
-err:
-       snd_soc_cache_exit(codec);
-       return ret;
-}
-
 static int snd_soc_flat_cache_sync(struct snd_soc_codec *codec)
 {
        int i;
@@ -516,15 +144,6 @@ static const struct snd_soc_cache_ops cache_types[] = {
                .write = snd_soc_flat_cache_write,
                .sync = snd_soc_flat_cache_sync
        },
-       {
-               .id = SND_SOC_RBTREE_COMPRESSION,
-               .name = "rbtree",
-               .init = snd_soc_rbtree_cache_init,
-               .exit = snd_soc_rbtree_cache_exit,
-               .read = snd_soc_rbtree_cache_read,
-               .write = snd_soc_rbtree_cache_write,
-               .sync = snd_soc_rbtree_cache_sync
-       }
 };
 
 int snd_soc_cache_init(struct snd_soc_codec *codec)