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/lzo.h>
  18 #include <linux/bitmap.h>
  19 #include <linux/rbtree.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 struct snd_soc_rbtree_node {
  70         struct rb_node node; /* the actual rbtree node holding this block */
  71         unsigned int base_reg; /* base register handled by this block */
  72         unsigned int word_size; /* number of bytes needed to represent the register index */
  73         void *block; /* block of adjacent registers */
  74         unsigned int blklen; /* number of registers available in the block */
  75 } __attribute__ ((packed));
  76
  77 struct snd_soc_rbtree_ctx {
  78         struct rb_root root;
  79         struct snd_soc_rbtree_node *cached_rbnode;
  80 };
  81
  82 static inline void snd_soc_rbtree_get_base_top_reg(
  83         struct snd_soc_rbtree_node *rbnode,
  84         unsigned int *base, unsigned int *top)
  85 {
  86         *base = rbnode->base_reg;
  87         *top = rbnode->base_reg + rbnode->blklen - 1;
  88 }
  89
  90 static unsigned int snd_soc_rbtree_get_register(
  91         struct snd_soc_rbtree_node *rbnode, unsigned int idx)
  92 {
  93         unsigned int val;
  94
  95         switch (rbnode->word_size) {
  96         case 1: {
  97                 u8 *p = rbnode->block;
  98                 val = p[idx];
  99                 return val;
 100         }
 101         case 2: {
 102                 u16 *p = rbnode->block;
 103                 val = p[idx];
 104                 return val;
 105         }
 106         default:
 107                 BUG();
 108                 break;
 109         }
 110         return -1;
 111 }
 112
 113 static void snd_soc_rbtree_set_register(struct snd_soc_rbtree_node *rbnode,
 114                                         unsigned int idx, unsigned int val)
 115 {
 116         switch (rbnode->word_size) {
 117         case 1: {
 118                 u8 *p = rbnode->block;
 119                 p[idx] = val;
 120                 break;
 121         }
 122         case 2: {
 123                 u16 *p = rbnode->block;
 124                 p[idx] = val;
 125                 break;
 126         }
 127         default:
 128                 BUG();
 129                 break;
 130         }
 131 }
 132
 133 static struct snd_soc_rbtree_node *snd_soc_rbtree_lookup(
 134         struct rb_root *root, unsigned int reg)
 135 {
 136         struct rb_node *node;
 137         struct snd_soc_rbtree_node *rbnode;
 138         unsigned int base_reg, top_reg;
 139
 140         node = root->rb_node;
 141         while (node) {
 142                 rbnode = container_of(node, struct snd_soc_rbtree_node, node);
 143                 snd_soc_rbtree_get_base_top_reg(rbnode, &base_reg, &top_reg);
 144                 if (reg >= base_reg && reg <= top_reg)
 145                         return rbnode;
 146                 else if (reg > top_reg)
 147                         node = node->rb_right;
 148                 else if (reg < base_reg)
 149                         node = node->rb_left;
 150         }
 151
 152         return NULL;
 153 }
 154
 155 static int snd_soc_rbtree_insert(struct rb_root *root,
 156                                  struct snd_soc_rbtree_node *rbnode)
 157 {
 158         struct rb_node **new, *parent;
 159         struct snd_soc_rbtree_node *rbnode_tmp;
 160         unsigned int base_reg_tmp, top_reg_tmp;
 161         unsigned int base_reg;
 162
 163         parent = NULL;
 164         new = &root->rb_node;
 165         while (*new) {
 166                 rbnode_tmp = container_of(*new, struct snd_soc_rbtree_node,
 167                                           node);
 168                 /* base and top registers of the current rbnode */
 169                 snd_soc_rbtree_get_base_top_reg(rbnode_tmp, &base_reg_tmp,
 170                                                 &top_reg_tmp);
 171                 /* base register of the rbnode to be added */
 172                 base_reg = rbnode->base_reg;
 173                 parent = *new;
 174                 /* if this register has already been inserted, just return */
 175                 if (base_reg >= base_reg_tmp &&
 176                     base_reg <= top_reg_tmp)
 177                         return 0;
 178                 else if (base_reg > top_reg_tmp)
 179                         new = &((*new)->rb_right);
 180                 else if (base_reg < base_reg_tmp)
 181                         new = &((*new)->rb_left);
 182         }
 183
 184         /* insert the node into the rbtree */
 185         rb_link_node(&rbnode->node, parent, new);
 186         rb_insert_color(&rbnode->node, root);
 187
 188         return 1;
 189 }
 190
 191 static int snd_soc_rbtree_cache_sync(struct snd_soc_codec *codec)
 192 {
 193         struct snd_soc_rbtree_ctx *rbtree_ctx;
 194         struct rb_node *node;
 195         struct snd_soc_rbtree_node *rbnode;
 196         unsigned int regtmp;
 197         unsigned int val, def;
 198         int ret;
 199         int i;
 200
 201         rbtree_ctx = codec->reg_cache;
 202         for (node = rb_first(&rbtree_ctx->root); node; node = rb_next(node)) {
 203                 rbnode = rb_entry(node, struct snd_soc_rbtree_node, node);
 204                 for (i = 0; i < rbnode->blklen; ++i) {
 205                         regtmp = rbnode->base_reg + i;
 206                         WARN_ON(codec->writable_register &&
 207                                 codec->writable_register(codec, regtmp));
 208                         val = snd_soc_rbtree_get_register(rbnode, i);
 209                         def = snd_soc_get_cache_val(codec->reg_def_copy, i,
 210                                                     rbnode->word_size);
 211                         if (val == def)
 212                                 continue;
 213
 214                         codec->cache_bypass = 1;
 215                         ret = snd_soc_write(codec, regtmp, val);
 216                         codec->cache_bypass = 0;
 217                         if (ret)
 218                                 return ret;
 219                         dev_dbg(codec->dev, "Synced register %#x, value = %#x\n",
 220                                 regtmp, val);
 221                 }
 222         }
 223
 224         return 0;
 225 }
 226
 227 static int snd_soc_rbtree_insert_to_block(struct snd_soc_rbtree_node *rbnode,
 228                                           unsigned int pos, unsigned int reg,
 229                                           unsigned int value)
 230 {
 231         u8 *blk;
 232
 233         blk = krealloc(rbnode->block,
 234                        (rbnode->blklen + 1) * rbnode->word_size, GFP_KERNEL);
 235         if (!blk)
 236                 return -ENOMEM;
 237
 238         /* insert the register value in the correct place in the rbnode block */
 239         memmove(blk + (pos + 1) * rbnode->word_size,
 240                 blk + pos * rbnode->word_size,
 241                 (rbnode->blklen - pos) * rbnode->word_size);
 242
 243         /* update the rbnode block, its size and the base register */
 244         rbnode->block = blk;
 245         rbnode->blklen++;
 246         if (!pos)
 247                 rbnode->base_reg = reg;
 248
 249         snd_soc_rbtree_set_register(rbnode, pos, value);
 250         return 0;
 251 }
 252
 253 static int snd_soc_rbtree_cache_write(struct snd_soc_codec *codec,
 254                                       unsigned int reg, unsigned int value)
 255 {
 256         struct snd_soc_rbtree_ctx *rbtree_ctx;
 257         struct snd_soc_rbtree_node *rbnode, *rbnode_tmp;
 258         struct rb_node *node;
 259         unsigned int val;
 260         unsigned int reg_tmp;
 261         unsigned int base_reg, top_reg;
 262         unsigned int pos;
 263         int i;
 264         int ret;
 265
 266         rbtree_ctx = codec->reg_cache;
 267         /* look up the required register in the cached rbnode */
 268         rbnode = rbtree_ctx->cached_rbnode;
 269         if (rbnode) {
 270                 snd_soc_rbtree_get_base_top_reg(rbnode, &base_reg, &top_reg);
 271                 if (reg >= base_reg && reg <= top_reg) {
 272                         reg_tmp = reg - base_reg;
 273                         val = snd_soc_rbtree_get_register(rbnode, reg_tmp);
 274                         if (val == value)
 275                                 return 0;
 276                         snd_soc_rbtree_set_register(rbnode, reg_tmp, value);
 277                         return 0;
 278                 }
 279         }
 280         /* if we can't locate it in the cached rbnode we'll have
 281          * to traverse the rbtree looking for it.
 282          */
 283         rbnode = snd_soc_rbtree_lookup(&rbtree_ctx->root, reg);
 284         if (rbnode) {
 285                 reg_tmp = reg - rbnode->base_reg;
 286                 val = snd_soc_rbtree_get_register(rbnode, reg_tmp);
 287                 if (val == value)
 288                         return 0;
 289                 snd_soc_rbtree_set_register(rbnode, reg_tmp, value);
 290                 rbtree_ctx->cached_rbnode = rbnode;
 291         } else {
 292                 /* bail out early, no need to create the rbnode yet */
 293                 if (!value)
 294                         return 0;
 295                 /* look for an adjacent register to the one we are about to add */
 296                 for (node = rb_first(&rbtree_ctx->root); node;
 297                      node = rb_next(node)) {
 298                         rbnode_tmp = rb_entry(node, struct snd_soc_rbtree_node, node);
 299                         for (i = 0; i < rbnode_tmp->blklen; ++i) {
 300                                 reg_tmp = rbnode_tmp->base_reg + i;
 301                                 if (abs(reg_tmp - reg) != 1)
 302                                         continue;
 303                                 /* decide where in the block to place our register */
 304                                 if (reg_tmp + 1 == reg)
 305                                         pos = i + 1;
 306                                 else
 307                                         pos = i;
 308                                 ret = snd_soc_rbtree_insert_to_block(rbnode_tmp, pos,
 309                                                                      reg, value);
 310                                 if (ret)
 311                                         return ret;
 312                                 rbtree_ctx->cached_rbnode = rbnode_tmp;
 313                                 return 0;
 314                         }
 315                 }
 316                 /* we did not manage to find a place to insert it in an existing
 317                  * block so create a new rbnode with a single register in its block.
 318                  * This block will get populated further if any other adjacent
 319                  * registers get modified in the future.
 320                  */
 321                 rbnode = kzalloc(sizeof *rbnode, GFP_KERNEL);
 322                 if (!rbnode)
 323                         return -ENOMEM;
 324                 rbnode->blklen = 1;
 325                 rbnode->base_reg = reg;
 326                 rbnode->word_size = codec->driver->reg_word_size;
 327                 rbnode->block = kmalloc(rbnode->blklen * rbnode->word_size,
 328                                         GFP_KERNEL);
 329                 if (!rbnode->block) {
 330                         kfree(rbnode);
 331                         return -ENOMEM;
 332                 }
 333                 snd_soc_rbtree_set_register(rbnode, 0, value);
 334                 snd_soc_rbtree_insert(&rbtree_ctx->root, rbnode);
 335                 rbtree_ctx->cached_rbnode = rbnode;
 336         }
 337
 338         return 0;
 339 }
 340
 341 static int snd_soc_rbtree_cache_read(struct snd_soc_codec *codec,
 342                                      unsigned int reg, unsigned int *value)
 343 {
 344         struct snd_soc_rbtree_ctx *rbtree_ctx;
 345         struct snd_soc_rbtree_node *rbnode;
 346         unsigned int base_reg, top_reg;
 347         unsigned int reg_tmp;
 348
 349         rbtree_ctx = codec->reg_cache;
 350         /* look up the required register in the cached rbnode */
 351         rbnode = rbtree_ctx->cached_rbnode;
 352         if (rbnode) {
 353                 snd_soc_rbtree_get_base_top_reg(rbnode, &base_reg, &top_reg);
 354                 if (reg >= base_reg && reg <= top_reg) {
 355                         reg_tmp = reg - base_reg;
 356                         *value = snd_soc_rbtree_get_register(rbnode, reg_tmp);
 357                         return 0;
 358                 }
 359         }
 360         /* if we can't locate it in the cached rbnode we'll have
 361          * to traverse the rbtree looking for it.
 362          */
 363         rbnode = snd_soc_rbtree_lookup(&rbtree_ctx->root, reg);
 364         if (rbnode) {
 365                 reg_tmp = reg - rbnode->base_reg;
 366                 *value = snd_soc_rbtree_get_register(rbnode, reg_tmp);
 367                 rbtree_ctx->cached_rbnode = rbnode;
 368         } else {
 369                 /* uninitialized registers default to 0 */
 370                 *value = 0;
 371         }
 372
 373         return 0;
 374 }
 375
 376 static int snd_soc_rbtree_cache_exit(struct snd_soc_codec *codec)
 377 {
 378         struct rb_node *next;
 379         struct snd_soc_rbtree_ctx *rbtree_ctx;
 380         struct snd_soc_rbtree_node *rbtree_node;
 381
 382         /* if we've already been called then just return */
 383         rbtree_ctx = codec->reg_cache;
 384         if (!rbtree_ctx)
 385                 return 0;
 386
 387         /* free up the rbtree */
 388         next = rb_first(&rbtree_ctx->root);
 389         while (next) {
 390                 rbtree_node = rb_entry(next, struct snd_soc_rbtree_node, node);
 391                 next = rb_next(&rbtree_node->node);
 392                 rb_erase(&rbtree_node->node, &rbtree_ctx->root);
 393                 kfree(rbtree_node->block);
 394                 kfree(rbtree_node);
 395         }
 396
 397         /* release the resources */
 398         kfree(codec->reg_cache);
 399         codec->reg_cache = NULL;
 400
 401         return 0;
 402 }
 403
 404 static int snd_soc_rbtree_cache_init(struct snd_soc_codec *codec)
 405 {
 406         struct snd_soc_rbtree_ctx *rbtree_ctx;
 407         unsigned int word_size;
 408         unsigned int val;
 409         int i;
 410         int ret;
 411
 412         codec->reg_cache = kmalloc(sizeof *rbtree_ctx, GFP_KERNEL);
 413         if (!codec->reg_cache)
 414                 return -ENOMEM;
 415
 416         rbtree_ctx = codec->reg_cache;
 417         rbtree_ctx->root = RB_ROOT;
 418         rbtree_ctx->cached_rbnode = NULL;
 419
 420         if (!codec->reg_def_copy)
 421                 return 0;
 422
 423         word_size = codec->driver->reg_word_size;
 424         for (i = 0; i < codec->driver->reg_cache_size; ++i) {
 425                 val = snd_soc_get_cache_val(codec->reg_def_copy, i,
 426                                             word_size);
 427                 if (!val)
 428                         continue;
 429                 ret = snd_soc_rbtree_cache_write(codec, i, val);
 430                 if (ret)
 431                         goto err;
 432         }
 433
 434         return 0;
 435
 436 err:
 437         snd_soc_cache_exit(codec);
 438         return ret;
 439 }
 440
 441 #ifdef CONFIG_SND_SOC_CACHE_LZO
 442 struct snd_soc_lzo_ctx {
 443         void *wmem;
 444         void *dst;
 445         const void *src;
 446         size_t src_len;
 447         size_t dst_len;
 448         size_t decompressed_size;
 449         unsigned long *sync_bmp;
 450         int sync_bmp_nbits;
 451 };
 452
 453 #define LZO_BLOCK_NUM 8
 454 static int snd_soc_lzo_block_count(void)
 455 {
 456         return LZO_BLOCK_NUM;
 457 }
 458
 459 static int snd_soc_lzo_prepare(struct snd_soc_lzo_ctx *lzo_ctx)
 460 {
 461         lzo_ctx->wmem = kmalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL);
 462         if (!lzo_ctx->wmem)
 463                 return -ENOMEM;
 464         return 0;
 465 }
 466
 467 static int snd_soc_lzo_compress(struct snd_soc_lzo_ctx *lzo_ctx)
 468 {
 469         size_t compress_size;
 470         int ret;
 471
 472         ret = lzo1x_1_compress(lzo_ctx->src, lzo_ctx->src_len,
 473                                lzo_ctx->dst, &compress_size, lzo_ctx->wmem);
 474         if (ret != LZO_E_OK || compress_size > lzo_ctx->dst_len)
 475                 return -EINVAL;
 476         lzo_ctx->dst_len = compress_size;
 477         return 0;
 478 }
 479
 480 static int snd_soc_lzo_decompress(struct snd_soc_lzo_ctx *lzo_ctx)
 481 {
 482         size_t dst_len;
 483         int ret;
 484
 485         dst_len = lzo_ctx->dst_len;
 486         ret = lzo1x_decompress_safe(lzo_ctx->src, lzo_ctx->src_len,
 487                                     lzo_ctx->dst, &dst_len);
 488         if (ret != LZO_E_OK || dst_len != lzo_ctx->dst_len)
 489                 return -EINVAL;
 490         return 0;
 491 }
 492
 493 static int snd_soc_lzo_compress_cache_block(struct snd_soc_codec *codec,
 494                 struct snd_soc_lzo_ctx *lzo_ctx)
 495 {
 496         int ret;
 497
 498         lzo_ctx->dst_len = lzo1x_worst_compress(PAGE_SIZE);
 499         lzo_ctx->dst = kmalloc(lzo_ctx->dst_len, GFP_KERNEL);
 500         if (!lzo_ctx->dst) {
 501                 lzo_ctx->dst_len = 0;
 502                 return -ENOMEM;
 503         }
 504
 505         ret = snd_soc_lzo_compress(lzo_ctx);
 506         if (ret < 0)
 507                 return ret;
 508         return 0;
 509 }
 510
 511 static int snd_soc_lzo_decompress_cache_block(struct snd_soc_codec *codec,
 512                 struct snd_soc_lzo_ctx *lzo_ctx)
 513 {
 514         int ret;
 515
 516         lzo_ctx->dst_len = lzo_ctx->decompressed_size;
 517         lzo_ctx->dst = kmalloc(lzo_ctx->dst_len, GFP_KERNEL);
 518         if (!lzo_ctx->dst) {
 519                 lzo_ctx->dst_len = 0;
 520                 return -ENOMEM;
 521         }
 522
 523         ret = snd_soc_lzo_decompress(lzo_ctx);
 524         if (ret < 0)
 525                 return ret;
 526         return 0;
 527 }
 528
 529 static inline int snd_soc_lzo_get_blkindex(struct snd_soc_codec *codec,
 530                 unsigned int reg)
 531 {
 532         const struct snd_soc_codec_driver *codec_drv;
 533
 534         codec_drv = codec->driver;
 535         return (reg * codec_drv->reg_word_size) /
 536                DIV_ROUND_UP(codec->reg_size, snd_soc_lzo_block_count());
 537 }
 538
 539 static inline int snd_soc_lzo_get_blkpos(struct snd_soc_codec *codec,
 540                 unsigned int reg)
 541 {
 542         const struct snd_soc_codec_driver *codec_drv;
 543
 544         codec_drv = codec->driver;
 545         return reg % (DIV_ROUND_UP(codec->reg_size, snd_soc_lzo_block_count()) /
 546                       codec_drv->reg_word_size);
 547 }
 548
 549 static inline int snd_soc_lzo_get_blksize(struct snd_soc_codec *codec)
 550 {
 551         const struct snd_soc_codec_driver *codec_drv;
 552
 553         codec_drv = codec->driver;
 554         return DIV_ROUND_UP(codec->reg_size, snd_soc_lzo_block_count());
 555 }
 556
 557 static int snd_soc_lzo_cache_sync(struct snd_soc_codec *codec)
 558 {
 559         struct snd_soc_lzo_ctx **lzo_blocks;
 560         unsigned int val;
 561         int i;
 562         int ret;
 563
 564         lzo_blocks = codec->reg_cache;
 565         for_each_set_bit(i, lzo_blocks[0]->sync_bmp, lzo_blocks[0]->sync_bmp_nbits) {
 566                 WARN_ON(codec->writable_register &&
 567                         codec->writable_register(codec, i));
 568                 ret = snd_soc_cache_read(codec, i, &val);
 569                 if (ret)
 570                         return ret;
 571                 codec->cache_bypass = 1;
 572                 ret = snd_soc_write(codec, i, val);
 573                 codec->cache_bypass = 0;
 574                 if (ret)
 575                         return ret;
 576                 dev_dbg(codec->dev, "Synced register %#x, value = %#x\n",
 577                         i, val);
 578         }
 579
 580         return 0;
 581 }
 582
 583 static int snd_soc_lzo_cache_write(struct snd_soc_codec *codec,
 584                                    unsigned int reg, unsigned int value)
 585 {
 586         struct snd_soc_lzo_ctx *lzo_block, **lzo_blocks;
 587         int ret, blkindex, blkpos;
 588         size_t blksize, tmp_dst_len;
 589         void *tmp_dst;
 590
 591         /* index of the compressed lzo block */
 592         blkindex = snd_soc_lzo_get_blkindex(codec, reg);
 593         /* register index within the decompressed block */
 594         blkpos = snd_soc_lzo_get_blkpos(codec, reg);
 595         /* size of the compressed block */
 596         blksize = snd_soc_lzo_get_blksize(codec);
 597         lzo_blocks = codec->reg_cache;
 598         lzo_block = lzo_blocks[blkindex];
 599
 600         /* save the pointer and length of the compressed block */
 601         tmp_dst = lzo_block->dst;
 602         tmp_dst_len = lzo_block->dst_len;
 603
 604         /* prepare the source to be the compressed block */
 605         lzo_block->src = lzo_block->dst;
 606         lzo_block->src_len = lzo_block->dst_len;
 607
 608         /* decompress the block */
 609         ret = snd_soc_lzo_decompress_cache_block(codec, lzo_block);
 610         if (ret < 0) {
 611                 kfree(lzo_block->dst);
 612                 goto out;
 613         }
 614
 615         /* write the new value to the cache */
 616         if (snd_soc_set_cache_val(lzo_block->dst, blkpos, value,
 617                                   codec->driver->reg_word_size)) {
 618                 kfree(lzo_block->dst);
 619                 goto out;
 620         }
 621
 622         /* prepare the source to be the decompressed block */
 623         lzo_block->src = lzo_block->dst;
 624         lzo_block->src_len = lzo_block->dst_len;
 625
 626         /* compress the block */
 627         ret = snd_soc_lzo_compress_cache_block(codec, lzo_block);
 628         if (ret < 0) {
 629                 kfree(lzo_block->dst);
 630                 kfree(lzo_block->src);
 631                 goto out;
 632         }
 633
 634         /* set the bit so we know we have to sync this register */
 635         set_bit(reg, lzo_block->sync_bmp);
 636         kfree(tmp_dst);
 637         kfree(lzo_block->src);
 638         return 0;
 639 out:
 640         lzo_block->dst = tmp_dst;
 641         lzo_block->dst_len = tmp_dst_len;
 642         return ret;
 643 }
 644
 645 static int snd_soc_lzo_cache_read(struct snd_soc_codec *codec,
 646                                   unsigned int reg, unsigned int *value)
 647 {
 648         struct snd_soc_lzo_ctx *lzo_block, **lzo_blocks;
 649         int ret, blkindex, blkpos;
 650         size_t blksize, tmp_dst_len;
 651         void *tmp_dst;
 652
 653         *value = 0;
 654         /* index of the compressed lzo block */
 655         blkindex = snd_soc_lzo_get_blkindex(codec, reg);
 656         /* register index within the decompressed block */
 657         blkpos = snd_soc_lzo_get_blkpos(codec, reg);
 658         /* size of the compressed block */
 659         blksize = snd_soc_lzo_get_blksize(codec);
 660         lzo_blocks = codec->reg_cache;
 661         lzo_block = lzo_blocks[blkindex];
 662
 663         /* save the pointer and length of the compressed block */
 664         tmp_dst = lzo_block->dst;
 665         tmp_dst_len = lzo_block->dst_len;
 666
 667         /* prepare the source to be the compressed block */
 668         lzo_block->src = lzo_block->dst;
 669         lzo_block->src_len = lzo_block->dst_len;
 670
 671         /* decompress the block */
 672         ret = snd_soc_lzo_decompress_cache_block(codec, lzo_block);
 673         if (ret >= 0)
 674                 /* fetch the value from the cache */
 675                 *value = snd_soc_get_cache_val(lzo_block->dst, blkpos,
 676                                                codec->driver->reg_word_size);
 677
 678         kfree(lzo_block->dst);
 679         /* restore the pointer and length of the compressed block */
 680         lzo_block->dst = tmp_dst;
 681         lzo_block->dst_len = tmp_dst_len;
 682         return 0;
 683 }
 684
 685 static int snd_soc_lzo_cache_exit(struct snd_soc_codec *codec)
 686 {
 687         struct snd_soc_lzo_ctx **lzo_blocks;
 688         int i, blkcount;
 689
 690         lzo_blocks = codec->reg_cache;
 691         if (!lzo_blocks)
 692                 return 0;
 693
 694         blkcount = snd_soc_lzo_block_count();
 695         /*
 696          * the pointer to the bitmap used for syncing the cache
 697          * is shared amongst all lzo_blocks.  Ensure it is freed
 698          * only once.
 699          */
 700         if (lzo_blocks[0])
 701                 kfree(lzo_blocks[0]->sync_bmp);
 702         for (i = 0; i < blkcount; ++i) {
 703                 if (lzo_blocks[i]) {
 704                         kfree(lzo_blocks[i]->wmem);
 705                         kfree(lzo_blocks[i]->dst);
 706                 }
 707                 /* each lzo_block is a pointer returned by kmalloc or NULL */
 708                 kfree(lzo_blocks[i]);
 709         }
 710         kfree(lzo_blocks);
 711         codec->reg_cache = NULL;
 712         return 0;
 713 }
 714
 715 static int snd_soc_lzo_cache_init(struct snd_soc_codec *codec)
 716 {
 717         struct snd_soc_lzo_ctx **lzo_blocks;
 718         size_t bmp_size;
 719         const struct snd_soc_codec_driver *codec_drv;
 720         int ret, tofree, i, blksize, blkcount;
 721         const char *p, *end;
 722         unsigned long *sync_bmp;
 723
 724         ret = 0;
 725         codec_drv = codec->driver;
 726
 727         /*
 728          * If we have not been given a default register cache
 729          * then allocate a dummy zero-ed out region, compress it
 730          * and remember to free it afterwards.
 731          */
 732         tofree = 0;
 733         if (!codec->reg_def_copy)
 734                 tofree = 1;
 735
 736         if (!codec->reg_def_copy) {
 737                 codec->reg_def_copy = kzalloc(codec->reg_size, GFP_KERNEL);
 738                 if (!codec->reg_def_copy)
 739                         return -ENOMEM;
 740         }
 741
 742         blkcount = snd_soc_lzo_block_count();
 743         codec->reg_cache = kzalloc(blkcount * sizeof *lzo_blocks,
 744                                    GFP_KERNEL);
 745         if (!codec->reg_cache) {
 746                 ret = -ENOMEM;
 747                 goto err_tofree;
 748         }
 749         lzo_blocks = codec->reg_cache;
 750
 751         /*
 752          * allocate a bitmap to be used when syncing the cache with
 753          * the hardware.  Each time a register is modified, the corresponding
 754          * bit is set in the bitmap, so we know that we have to sync
 755          * that register.
 756          */
 757         bmp_size = codec_drv->reg_cache_size;
 758         sync_bmp = kmalloc(BITS_TO_LONGS(bmp_size) * sizeof(long),
 759                            GFP_KERNEL);
 760         if (!sync_bmp) {
 761                 ret = -ENOMEM;
 762                 goto err;
 763         }
 764         bitmap_zero(sync_bmp, bmp_size);
 765
 766         /* allocate the lzo blocks and initialize them */
 767         for (i = 0; i < blkcount; ++i) {
 768                 lzo_blocks[i] = kzalloc(sizeof **lzo_blocks,
 769                                         GFP_KERNEL);
 770                 if (!lzo_blocks[i]) {
 771                         kfree(sync_bmp);
 772                         ret = -ENOMEM;
 773                         goto err;
 774                 }
 775                 lzo_blocks[i]->sync_bmp = sync_bmp;
 776                 lzo_blocks[i]->sync_bmp_nbits = bmp_size;
 777                 /* alloc the working space for the compressed block */
 778                 ret = snd_soc_lzo_prepare(lzo_blocks[i]);
 779                 if (ret < 0)
 780                         goto err;
 781         }
 782
 783         blksize = snd_soc_lzo_get_blksize(codec);
 784         p = codec->reg_def_copy;
 785         end = codec->reg_def_copy + codec->reg_size;
 786         /* compress the register map and fill the lzo blocks */
 787         for (i = 0; i < blkcount; ++i, p += blksize) {
 788                 lzo_blocks[i]->src = p;
 789                 if (p + blksize > end)
 790                         lzo_blocks[i]->src_len = end - p;
 791                 else
 792                         lzo_blocks[i]->src_len = blksize;
 793                 ret = snd_soc_lzo_compress_cache_block(codec,
 794                                                        lzo_blocks[i]);
 795                 if (ret < 0)
 796                         goto err;
 797                 lzo_blocks[i]->decompressed_size =
 798                         lzo_blocks[i]->src_len;
 799         }
 800
 801         if (tofree) {
 802                 kfree(codec->reg_def_copy);
 803                 codec->reg_def_copy = NULL;
 804         }
 805         return 0;
 806 err:
 807         snd_soc_cache_exit(codec);
 808 err_tofree:
 809         if (tofree) {
 810                 kfree(codec->reg_def_copy);
 811                 codec->reg_def_copy = NULL;
 812         }
 813         return ret;
 814 }
 815 #endif
 816
 817 static int snd_soc_flat_cache_sync(struct snd_soc_codec *codec)
 818 {
 819         int i;
 820         int ret;
 821         const struct snd_soc_codec_driver *codec_drv;
 822         unsigned int val;
 823
 824         codec_drv = codec->driver;
 825         for (i = 0; i < codec_drv->reg_cache_size; ++i) {
 826                 WARN_ON(codec->writable_register &&
 827                         codec->writable_register(codec, i));
 828                 ret = snd_soc_cache_read(codec, i, &val);
 829                 if (ret)
 830                         return ret;
 831                 if (codec->reg_def_copy)
 832                         if (snd_soc_get_cache_val(codec->reg_def_copy,
 833                                                   i, codec_drv->reg_word_size) == val)
 834                                 continue;
 835                 ret = snd_soc_write(codec, i, val);
 836                 if (ret)
 837                         return ret;
 838                 dev_dbg(codec->dev, "Synced register %#x, value = %#x\n",
 839                         i, val);
 840         }
 841         return 0;
 842 }
 843
 844 static int snd_soc_flat_cache_write(struct snd_soc_codec *codec,
 845                                     unsigned int reg, unsigned int value)
 846 {
 847         snd_soc_set_cache_val(codec->reg_cache, reg, value,
 848                               codec->driver->reg_word_size);
 849         return 0;
 850 }
 851
 852 static int snd_soc_flat_cache_read(struct snd_soc_codec *codec,
 853                                    unsigned int reg, unsigned int *value)
 854 {
 855         *value = snd_soc_get_cache_val(codec->reg_cache, reg,
 856                                        codec->driver->reg_word_size);
 857         return 0;
 858 }
 859
 860 static int snd_soc_flat_cache_exit(struct snd_soc_codec *codec)
 861 {
 862         if (!codec->reg_cache)
 863                 return 0;
 864         kfree(codec->reg_cache);
 865         codec->reg_cache = NULL;
 866         return 0;
 867 }
 868
 869 static int snd_soc_flat_cache_init(struct snd_soc_codec *codec)
 870 {
 871         const struct snd_soc_codec_driver *codec_drv;
 872
 873         codec_drv = codec->driver;
 874
 875         if (codec->reg_def_copy)
 876                 codec->reg_cache = kmemdup(codec->reg_def_copy,
 877                                            codec->reg_size, GFP_KERNEL);
 878         else
 879                 codec->reg_cache = kzalloc(codec->reg_size, GFP_KERNEL);
 880         if (!codec->reg_cache)
 881                 return -ENOMEM;
 882
 883         return 0;
 884 }
 885
 886 /* an array of all supported compression types */
 887 static const struct snd_soc_cache_ops cache_types[] = {
 888         /* Flat *must* be the first entry for fallback */
 889         {
 890                 .id = SND_SOC_FLAT_COMPRESSION,
 891                 .name = "flat",
 892                 .init = snd_soc_flat_cache_init,
 893                 .exit = snd_soc_flat_cache_exit,
 894                 .read = snd_soc_flat_cache_read,
 895                 .write = snd_soc_flat_cache_write,
 896                 .sync = snd_soc_flat_cache_sync
 897         },
 898 #ifdef CONFIG_SND_SOC_CACHE_LZO
 899         {
 900                 .id = SND_SOC_LZO_COMPRESSION,
 901                 .name = "LZO",
 902                 .init = snd_soc_lzo_cache_init,
 903                 .exit = snd_soc_lzo_cache_exit,
 904                 .read = snd_soc_lzo_cache_read,
 905                 .write = snd_soc_lzo_cache_write,
 906                 .sync = snd_soc_lzo_cache_sync
 907         },
 908 #endif
 909         {
 910                 .id = SND_SOC_RBTREE_COMPRESSION,
 911                 .name = "rbtree",
 912                 .init = snd_soc_rbtree_cache_init,
 913                 .exit = snd_soc_rbtree_cache_exit,
 914                 .read = snd_soc_rbtree_cache_read,
 915                 .write = snd_soc_rbtree_cache_write,
 916                 .sync = snd_soc_rbtree_cache_sync
 917         }
 918 };
 919
 920 int snd_soc_cache_init(struct snd_soc_codec *codec)
 921 {
 922         int i;
 923
 924         for (i = 0; i < ARRAY_SIZE(cache_types); ++i)
 925                 if (cache_types[i].id == codec->compress_type)
 926                         break;
 927
 928         /* Fall back to flat compression */
 929         if (i == ARRAY_SIZE(cache_types)) {
 930                 dev_warn(codec->dev, "Could not match compress type: %d\n",
 931                          codec->compress_type);
 932                 i = 0;
 933         }
 934
 935         mutex_init(&codec->cache_rw_mutex);
 936         codec->cache_ops = &cache_types[i];
 937
 938         if (codec->cache_ops->init) {
 939                 if (codec->cache_ops->name)
 940                         dev_dbg(codec->dev, "Initializing %s cache for %s codec\n",
 941                                 codec->cache_ops->name, codec->name);
 942                 return codec->cache_ops->init(codec);
 943         }
 944         return -ENOSYS;
 945 }
 946
 947 /*
 948  * NOTE: keep in mind that this function might be called
 949  * multiple times.
 950  */
 951 int snd_soc_cache_exit(struct snd_soc_codec *codec)
 952 {
 953         if (codec->cache_ops && codec->cache_ops->exit) {
 954                 if (codec->cache_ops->name)
 955                         dev_dbg(codec->dev, "Destroying %s cache for %s codec\n",
 956                                 codec->cache_ops->name, codec->name);
 957                 return codec->cache_ops->exit(codec);
 958         }
 959         return -ENOSYS;
 960 }
 961
 962 /**
 963  * snd_soc_cache_read: Fetch the value of a given register from the cache.
 964  *
 965  * @codec: CODEC to configure.
 966  * @reg: The register index.
 967  * @value: The value to be returned.
 968  */
 969 int snd_soc_cache_read(struct snd_soc_codec *codec,
 970                        unsigned int reg, unsigned int *value)
 971 {
 972         int ret;
 973
 974         mutex_lock(&codec->cache_rw_mutex);
 975
 976         if (value && codec->cache_ops && codec->cache_ops->read) {
 977                 ret = codec->cache_ops->read(codec, reg, value);
 978                 mutex_unlock(&codec->cache_rw_mutex);
 979                 return ret;
 980         }
 981
 982         mutex_unlock(&codec->cache_rw_mutex);
 983         return -ENOSYS;
 984 }
 985 EXPORT_SYMBOL_GPL(snd_soc_cache_read);
 986
 987 /**
 988  * snd_soc_cache_write: Set the value of a given register in the cache.
 989  *
 990  * @codec: CODEC to configure.
 991  * @reg: The register index.
 992  * @value: The new register value.
 993  */
 994 int snd_soc_cache_write(struct snd_soc_codec *codec,
 995                         unsigned int reg, unsigned int value)
 996 {
 997         int ret;
 998
 999         mutex_lock(&codec->cache_rw_mutex);
1000
1001         if (codec->cache_ops && codec->cache_ops->write) {
1002                 ret = codec->cache_ops->write(codec, reg, value);
1003                 mutex_unlock(&codec->cache_rw_mutex);
1004                 return ret;
1005         }
1006
1007         mutex_unlock(&codec->cache_rw_mutex);
1008         return -ENOSYS;
1009 }
1010 EXPORT_SYMBOL_GPL(snd_soc_cache_write);
1011
1012 /**
1013  * snd_soc_cache_sync: Sync the register cache with the hardware.
1014  *
1015  * @codec: CODEC to configure.
1016  *
1017  * Any registers that should not be synced should be marked as
1018  * volatile.  In general drivers can choose not to use the provided
1019  * syncing functionality if they so require.
1020  */
1021 int snd_soc_cache_sync(struct snd_soc_codec *codec)
1022 {
1023         int ret;
1024         const char *name;
1025
1026         if (!codec->cache_sync) {
1027                 return 0;
1028         }
1029
1030         if (!codec->cache_ops || !codec->cache_ops->sync)
1031                 return -ENOSYS;
1032
1033         if (codec->cache_ops->name)
1034                 name = codec->cache_ops->name;
1035         else
1036                 name = "unknown";
1037
1038         if (codec->cache_ops->name)
1039                 dev_dbg(codec->dev, "Syncing %s cache for %s codec\n",
1040                         codec->cache_ops->name, codec->name);
1041         trace_snd_soc_cache_sync(codec, name, "start");
1042         ret = codec->cache_ops->sync(codec);
1043         if (!ret)
1044                 codec->cache_sync = 0;
1045         trace_snd_soc_cache_sync(codec, name, "end");
1046         return ret;
1047 }
1048 EXPORT_SYMBOL_GPL(snd_soc_cache_sync);
1049
1050 static int snd_soc_get_reg_access_index(struct snd_soc_codec *codec,
1051                                         unsigned int reg)
1052 {
1053         const struct snd_soc_codec_driver *codec_drv;
1054         unsigned int min, max, index;
1055
1056         codec_drv = codec->driver;
1057         min = 0;
1058         max = codec_drv->reg_access_size - 1;
1059         do {
1060                 index = (min + max) / 2;
1061                 if (codec_drv->reg_access_default[index].reg == reg)
1062                         return index;
1063                 if (codec_drv->reg_access_default[index].reg < reg)
1064                         min = index + 1;
1065                 else
1066                         max = index;
1067         } while (min <= max);
1068         return -1;
1069 }
1070
1071 int snd_soc_default_volatile_register(struct snd_soc_codec *codec,
1072                                       unsigned int reg)
1073 {
1074         int index;
1075
1076         if (reg >= codec->driver->reg_cache_size)
1077                 return 1;
1078         index = snd_soc_get_reg_access_index(codec, reg);
1079         if (index < 0)
1080                 return 0;
1081         return codec->driver->reg_access_default[index].vol;
1082 }
1083 EXPORT_SYMBOL_GPL(snd_soc_default_volatile_register);
1084
1085 int snd_soc_default_readable_register(struct snd_soc_codec *codec,
1086                                       unsigned int reg)
1087 {
1088         int index;
1089
1090         if (reg >= codec->driver->reg_cache_size)
1091                 return 1;
1092         index = snd_soc_get_reg_access_index(codec, reg);
1093         if (index < 0)
1094                 return 0;
1095         return codec->driver->reg_access_default[index].read;
1096 }
1097 EXPORT_SYMBOL_GPL(snd_soc_default_readable_register);
1098
1099 int snd_soc_default_writable_register(struct snd_soc_codec *codec,
1100                                       unsigned int reg)
1101 {
1102         int index;
1103
1104         if (reg >= codec->driver->reg_cache_size)
1105                 return 1;
1106         index = snd_soc_get_reg_access_index(codec, reg);
1107         if (index < 0)
1108                 return 0;
1109         return codec->driver->reg_access_default[index].write;
1110 }
1111 EXPORT_SYMBOL_GPL(snd_soc_default_writable_register);