2 * soc-cache.c -- ASoC register cache helpers
4 * Copyright 2009 Wolfson Microelectronics PLC.
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
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.
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>
21 static unsigned int snd_soc_4_12_read(struct snd_soc_codec *codec,
27 if (reg >= codec->driver->reg_cache_size ||
28 snd_soc_codec_volatile_register(codec, reg)) {
29 if (codec->cache_only)
32 BUG_ON(!codec->hw_read);
33 return codec->hw_read(codec, reg);
36 ret = snd_soc_cache_read(codec, reg, &val);
42 static int snd_soc_4_12_write(struct snd_soc_codec *codec, unsigned int reg,
48 data[0] = (reg << 4) | ((value >> 8) & 0x000f);
49 data[1] = value & 0x00ff;
51 if (!snd_soc_codec_volatile_register(codec, reg) &&
52 reg < codec->driver->reg_cache_size) {
53 ret = snd_soc_cache_write(codec, reg, value);
58 if (codec->cache_only) {
59 codec->cache_sync = 1;
63 ret = codec->hw_write(codec->control_data, data, 2);
72 #if defined(CONFIG_SPI_MASTER)
73 static int snd_soc_4_12_spi_write(void *control_data, const char *data,
76 struct spi_device *spi = control_data;
77 struct spi_transfer t;
88 memset(&t, 0, sizeof t);
93 spi_message_add_tail(&t, &m);
99 #define snd_soc_4_12_spi_write NULL
102 static unsigned int snd_soc_7_9_read(struct snd_soc_codec *codec,
108 if (reg >= codec->driver->reg_cache_size ||
109 snd_soc_codec_volatile_register(codec, reg)) {
110 if (codec->cache_only)
113 BUG_ON(!codec->hw_read);
114 return codec->hw_read(codec, reg);
117 ret = snd_soc_cache_read(codec, reg, &val);
123 static int snd_soc_7_9_write(struct snd_soc_codec *codec, unsigned int reg,
129 data[0] = (reg << 1) | ((value >> 8) & 0x0001);
130 data[1] = value & 0x00ff;
132 if (!snd_soc_codec_volatile_register(codec, reg) &&
133 reg < codec->driver->reg_cache_size) {
134 ret = snd_soc_cache_write(codec, reg, value);
139 if (codec->cache_only) {
140 codec->cache_sync = 1;
144 ret = codec->hw_write(codec->control_data, data, 2);
153 #if defined(CONFIG_SPI_MASTER)
154 static int snd_soc_7_9_spi_write(void *control_data, const char *data,
157 struct spi_device *spi = control_data;
158 struct spi_transfer t;
159 struct spi_message m;
168 spi_message_init(&m);
169 memset(&t, 0, sizeof t);
174 spi_message_add_tail(&t, &m);
180 #define snd_soc_7_9_spi_write NULL
183 static int snd_soc_8_8_write(struct snd_soc_codec *codec, unsigned int reg,
191 data[1] = value & 0xff;
193 if (!snd_soc_codec_volatile_register(codec, reg) &&
194 reg < codec->driver->reg_cache_size) {
195 ret = snd_soc_cache_write(codec, reg, value);
200 if (codec->cache_only) {
201 codec->cache_sync = 1;
205 if (codec->hw_write(codec->control_data, data, 2) == 2)
211 static unsigned int snd_soc_8_8_read(struct snd_soc_codec *codec,
218 if (reg >= codec->driver->reg_cache_size ||
219 snd_soc_codec_volatile_register(codec, reg)) {
220 if (codec->cache_only)
223 BUG_ON(!codec->hw_read);
224 return codec->hw_read(codec, reg);
227 ret = snd_soc_cache_read(codec, reg, &val);
233 #if defined(CONFIG_SPI_MASTER)
234 static int snd_soc_8_8_spi_write(void *control_data, const char *data,
237 struct spi_device *spi = control_data;
238 struct spi_transfer t;
239 struct spi_message m;
248 spi_message_init(&m);
249 memset(&t, 0, sizeof t);
254 spi_message_add_tail(&t, &m);
260 #define snd_soc_8_8_spi_write NULL
263 static int snd_soc_8_16_write(struct snd_soc_codec *codec, unsigned int reg,
270 data[1] = (value >> 8) & 0xff;
271 data[2] = value & 0xff;
273 if (!snd_soc_codec_volatile_register(codec, reg) &&
274 reg < codec->driver->reg_cache_size) {
275 ret = snd_soc_cache_write(codec, reg, value);
280 if (codec->cache_only) {
281 codec->cache_sync = 1;
285 if (codec->hw_write(codec->control_data, data, 3) == 3)
291 static unsigned int snd_soc_8_16_read(struct snd_soc_codec *codec,
297 if (reg >= codec->driver->reg_cache_size ||
298 snd_soc_codec_volatile_register(codec, reg)) {
299 if (codec->cache_only)
302 BUG_ON(!codec->hw_read);
303 return codec->hw_read(codec, reg);
306 ret = snd_soc_cache_read(codec, reg, &val);
312 #if defined(CONFIG_SPI_MASTER)
313 static int snd_soc_8_16_spi_write(void *control_data, const char *data,
316 struct spi_device *spi = control_data;
317 struct spi_transfer t;
318 struct spi_message m;
328 spi_message_init(&m);
329 memset(&t, 0, sizeof t);
334 spi_message_add_tail(&t, &m);
340 #define snd_soc_8_16_spi_write NULL
343 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
344 static unsigned int snd_soc_8_8_read_i2c(struct snd_soc_codec *codec,
347 struct i2c_msg xfer[2];
351 struct i2c_client *client = codec->control_data;
354 xfer[0].addr = client->addr;
360 xfer[1].addr = client->addr;
361 xfer[1].flags = I2C_M_RD;
365 ret = i2c_transfer(client->adapter, xfer, 2);
367 dev_err(&client->dev, "i2c_transfer() returned %d\n", ret);
374 #define snd_soc_8_8_read_i2c NULL
377 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
378 static unsigned int snd_soc_8_16_read_i2c(struct snd_soc_codec *codec,
381 struct i2c_msg xfer[2];
385 struct i2c_client *client = codec->control_data;
388 xfer[0].addr = client->addr;
394 xfer[1].addr = client->addr;
395 xfer[1].flags = I2C_M_RD;
397 xfer[1].buf = (u8 *)&data;
399 ret = i2c_transfer(client->adapter, xfer, 2);
401 dev_err(&client->dev, "i2c_transfer() returned %d\n", ret);
405 return (data >> 8) | ((data & 0xff) << 8);
408 #define snd_soc_8_16_read_i2c NULL
411 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
412 static unsigned int snd_soc_16_8_read_i2c(struct snd_soc_codec *codec,
415 struct i2c_msg xfer[2];
419 struct i2c_client *client = codec->control_data;
422 xfer[0].addr = client->addr;
425 xfer[0].buf = (u8 *)®
428 xfer[1].addr = client->addr;
429 xfer[1].flags = I2C_M_RD;
433 ret = i2c_transfer(client->adapter, xfer, 2);
435 dev_err(&client->dev, "i2c_transfer() returned %d\n", ret);
442 #define snd_soc_16_8_read_i2c NULL
445 static unsigned int snd_soc_16_8_read(struct snd_soc_codec *codec,
452 if (reg >= codec->driver->reg_cache_size ||
453 snd_soc_codec_volatile_register(codec, reg)) {
454 if (codec->cache_only)
457 BUG_ON(!codec->hw_read);
458 return codec->hw_read(codec, reg);
461 ret = snd_soc_cache_read(codec, reg, &val);
467 static int snd_soc_16_8_write(struct snd_soc_codec *codec, unsigned int reg,
473 data[0] = (reg >> 8) & 0xff;
474 data[1] = reg & 0xff;
478 if (!snd_soc_codec_volatile_register(codec, reg) &&
479 reg < codec->driver->reg_cache_size) {
480 ret = snd_soc_cache_write(codec, reg, value);
485 if (codec->cache_only) {
486 codec->cache_sync = 1;
490 ret = codec->hw_write(codec->control_data, data, 3);
499 #if defined(CONFIG_SPI_MASTER)
500 static int snd_soc_16_8_spi_write(void *control_data, const char *data,
503 struct spi_device *spi = control_data;
504 struct spi_transfer t;
505 struct spi_message m;
515 spi_message_init(&m);
516 memset(&t, 0, sizeof t);
521 spi_message_add_tail(&t, &m);
527 #define snd_soc_16_8_spi_write NULL
530 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
531 static unsigned int snd_soc_16_16_read_i2c(struct snd_soc_codec *codec,
534 struct i2c_msg xfer[2];
535 u16 reg = cpu_to_be16(r);
538 struct i2c_client *client = codec->control_data;
541 xfer[0].addr = client->addr;
544 xfer[0].buf = (u8 *)®
547 xfer[1].addr = client->addr;
548 xfer[1].flags = I2C_M_RD;
550 xfer[1].buf = (u8 *)&data;
552 ret = i2c_transfer(client->adapter, xfer, 2);
554 dev_err(&client->dev, "i2c_transfer() returned %d\n", ret);
558 return be16_to_cpu(data);
561 #define snd_soc_16_16_read_i2c NULL
564 static unsigned int snd_soc_16_16_read(struct snd_soc_codec *codec,
570 if (reg >= codec->driver->reg_cache_size ||
571 snd_soc_codec_volatile_register(codec, reg)) {
572 if (codec->cache_only)
575 BUG_ON(!codec->hw_read);
576 return codec->hw_read(codec, reg);
579 ret = snd_soc_cache_read(codec, reg, &val);
586 static int snd_soc_16_16_write(struct snd_soc_codec *codec, unsigned int reg,
592 data[0] = (reg >> 8) & 0xff;
593 data[1] = reg & 0xff;
594 data[2] = (value >> 8) & 0xff;
595 data[3] = value & 0xff;
597 if (!snd_soc_codec_volatile_register(codec, reg) &&
598 reg < codec->driver->reg_cache_size) {
599 ret = snd_soc_cache_write(codec, reg, value);
604 if (codec->cache_only) {
605 codec->cache_sync = 1;
609 ret = codec->hw_write(codec->control_data, data, 4);
618 #if defined(CONFIG_SPI_MASTER)
619 static int snd_soc_16_16_spi_write(void *control_data, const char *data,
622 struct spi_device *spi = control_data;
623 struct spi_transfer t;
624 struct spi_message m;
635 spi_message_init(&m);
636 memset(&t, 0, sizeof t);
641 spi_message_add_tail(&t, &m);
647 #define snd_soc_16_16_spi_write NULL
653 int (*write)(struct snd_soc_codec *codec, unsigned int, unsigned int);
654 int (*spi_write)(void *, const char *, int);
655 unsigned int (*read)(struct snd_soc_codec *, unsigned int);
656 unsigned int (*i2c_read)(struct snd_soc_codec *, unsigned int);
659 .addr_bits = 4, .data_bits = 12,
660 .write = snd_soc_4_12_write, .read = snd_soc_4_12_read,
661 .spi_write = snd_soc_4_12_spi_write,
664 .addr_bits = 7, .data_bits = 9,
665 .write = snd_soc_7_9_write, .read = snd_soc_7_9_read,
666 .spi_write = snd_soc_7_9_spi_write,
669 .addr_bits = 8, .data_bits = 8,
670 .write = snd_soc_8_8_write, .read = snd_soc_8_8_read,
671 .i2c_read = snd_soc_8_8_read_i2c,
672 .spi_write = snd_soc_8_8_spi_write,
675 .addr_bits = 8, .data_bits = 16,
676 .write = snd_soc_8_16_write, .read = snd_soc_8_16_read,
677 .i2c_read = snd_soc_8_16_read_i2c,
678 .spi_write = snd_soc_8_16_spi_write,
681 .addr_bits = 16, .data_bits = 8,
682 .write = snd_soc_16_8_write, .read = snd_soc_16_8_read,
683 .i2c_read = snd_soc_16_8_read_i2c,
684 .spi_write = snd_soc_16_8_spi_write,
687 .addr_bits = 16, .data_bits = 16,
688 .write = snd_soc_16_16_write, .read = snd_soc_16_16_read,
689 .i2c_read = snd_soc_16_16_read_i2c,
690 .spi_write = snd_soc_16_16_spi_write,
695 * snd_soc_codec_set_cache_io: Set up standard I/O functions.
697 * @codec: CODEC to configure.
698 * @type: Type of cache.
699 * @addr_bits: Number of bits of register address data.
700 * @data_bits: Number of bits of data per register.
701 * @control: Control bus used.
703 * Register formats are frequently shared between many I2C and SPI
704 * devices. In order to promote code reuse the ASoC core provides
705 * some standard implementations of CODEC read and write operations
706 * which can be set up using this function.
708 * The caller is responsible for allocating and initialising the
711 * Note that at present this code cannot be used by CODECs with
712 * volatile registers.
714 int snd_soc_codec_set_cache_io(struct snd_soc_codec *codec,
715 int addr_bits, int data_bits,
716 enum snd_soc_control_type control)
720 for (i = 0; i < ARRAY_SIZE(io_types); i++)
721 if (io_types[i].addr_bits == addr_bits &&
722 io_types[i].data_bits == data_bits)
724 if (i == ARRAY_SIZE(io_types)) {
726 "No I/O functions for %d bit address %d bit data\n",
727 addr_bits, data_bits);
731 codec->write = io_types[i].write;
732 codec->read = io_types[i].read;
739 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
740 codec->hw_write = (hw_write_t)i2c_master_send;
742 if (io_types[i].i2c_read)
743 codec->hw_read = io_types[i].i2c_read;
745 codec->control_data = container_of(codec->dev,
751 if (io_types[i].spi_write)
752 codec->hw_write = io_types[i].spi_write;
754 codec->control_data = container_of(codec->dev,
762 EXPORT_SYMBOL_GPL(snd_soc_codec_set_cache_io);
764 struct snd_soc_rbtree_node {
769 } __attribute__ ((packed));
771 struct snd_soc_rbtree_ctx {
775 static struct snd_soc_rbtree_node *snd_soc_rbtree_lookup(
776 struct rb_root *root, unsigned int reg)
778 struct rb_node *node;
779 struct snd_soc_rbtree_node *rbnode;
781 node = root->rb_node;
783 rbnode = container_of(node, struct snd_soc_rbtree_node, node);
784 if (rbnode->reg < reg)
785 node = node->rb_left;
786 else if (rbnode->reg > reg)
787 node = node->rb_right;
795 static int snd_soc_rbtree_insert(struct rb_root *root,
796 struct snd_soc_rbtree_node *rbnode)
798 struct rb_node **new, *parent;
799 struct snd_soc_rbtree_node *rbnode_tmp;
802 new = &root->rb_node;
804 rbnode_tmp = container_of(*new, struct snd_soc_rbtree_node,
807 if (rbnode_tmp->reg < rbnode->reg)
808 new = &((*new)->rb_left);
809 else if (rbnode_tmp->reg > rbnode->reg)
810 new = &((*new)->rb_right);
815 /* insert the node into the rbtree */
816 rb_link_node(&rbnode->node, parent, new);
817 rb_insert_color(&rbnode->node, root);
822 static int snd_soc_rbtree_cache_sync(struct snd_soc_codec *codec)
824 struct snd_soc_rbtree_ctx *rbtree_ctx;
825 struct rb_node *node;
826 struct snd_soc_rbtree_node *rbnode;
830 rbtree_ctx = codec->reg_cache;
831 for (node = rb_first(&rbtree_ctx->root); node; node = rb_next(node)) {
832 rbnode = rb_entry(node, struct snd_soc_rbtree_node, node);
833 if (rbnode->value == rbnode->defval)
835 ret = snd_soc_cache_read(codec, rbnode->reg, &val);
838 ret = snd_soc_write(codec, rbnode->reg, val);
841 dev_dbg(codec->dev, "Synced register %#x, value = %#x\n",
848 static int snd_soc_rbtree_cache_write(struct snd_soc_codec *codec,
849 unsigned int reg, unsigned int value)
851 struct snd_soc_rbtree_ctx *rbtree_ctx;
852 struct snd_soc_rbtree_node *rbnode;
854 rbtree_ctx = codec->reg_cache;
855 rbnode = snd_soc_rbtree_lookup(&rbtree_ctx->root, reg);
857 if (rbnode->value == value)
859 rbnode->value = value;
861 /* bail out early, no need to create the rbnode yet */
865 * for uninitialized registers whose value is changed
866 * from the default zero, create an rbnode and insert
869 rbnode = kzalloc(sizeof *rbnode, GFP_KERNEL);
873 rbnode->value = value;
874 snd_soc_rbtree_insert(&rbtree_ctx->root, rbnode);
880 static int snd_soc_rbtree_cache_read(struct snd_soc_codec *codec,
881 unsigned int reg, unsigned int *value)
883 struct snd_soc_rbtree_ctx *rbtree_ctx;
884 struct snd_soc_rbtree_node *rbnode;
886 rbtree_ctx = codec->reg_cache;
887 rbnode = snd_soc_rbtree_lookup(&rbtree_ctx->root, reg);
889 *value = rbnode->value;
891 /* uninitialized registers default to 0 */
898 static int snd_soc_rbtree_cache_exit(struct snd_soc_codec *codec)
900 struct rb_node *next;
901 struct snd_soc_rbtree_ctx *rbtree_ctx;
902 struct snd_soc_rbtree_node *rbtree_node;
904 /* if we've already been called then just return */
905 rbtree_ctx = codec->reg_cache;
909 /* free up the rbtree */
910 next = rb_first(&rbtree_ctx->root);
912 rbtree_node = rb_entry(next, struct snd_soc_rbtree_node, node);
913 next = rb_next(&rbtree_node->node);
914 rb_erase(&rbtree_node->node, &rbtree_ctx->root);
918 /* release the resources */
919 kfree(codec->reg_cache);
920 codec->reg_cache = NULL;
925 static int snd_soc_rbtree_cache_init(struct snd_soc_codec *codec)
927 struct snd_soc_rbtree_ctx *rbtree_ctx;
929 codec->reg_cache = kmalloc(sizeof *rbtree_ctx, GFP_KERNEL);
930 if (!codec->reg_cache)
933 rbtree_ctx = codec->reg_cache;
934 rbtree_ctx->root = RB_ROOT;
936 if (!codec->reg_def_copy)
940 * populate the rbtree with the initialized registers. All other
941 * registers will be inserted into the tree when they are first written.
943 * The reasoning behind this, is that we need to step through and
944 * dereference the cache in u8/u16 increments without sacrificing
945 * portability. This could also be done using memcpy() but that would
946 * be slightly more cryptic.
948 #define snd_soc_rbtree_populate(cache) \
951 struct snd_soc_rbtree_node *rbtree_node; \
954 cache = codec->reg_def_copy; \
955 for (i = 0; i < codec->driver->reg_cache_size; ++i) { \
958 rbtree_node = kzalloc(sizeof *rbtree_node, GFP_KERNEL); \
959 if (!rbtree_node) { \
961 snd_soc_cache_exit(codec); \
964 rbtree_node->reg = i; \
965 rbtree_node->value = cache[i]; \
966 rbtree_node->defval = cache[i]; \
967 snd_soc_rbtree_insert(&rbtree_ctx->root, \
973 switch (codec->driver->reg_word_size) {
977 return snd_soc_rbtree_populate(cache);
982 return snd_soc_rbtree_populate(cache);
991 #ifdef CONFIG_SND_SOC_CACHE_LZO
992 struct snd_soc_lzo_ctx {
998 size_t decompressed_size;
999 unsigned long *sync_bmp;
1003 #define LZO_BLOCK_NUM 8
1004 static int snd_soc_lzo_block_count(void)
1006 return LZO_BLOCK_NUM;
1009 static int snd_soc_lzo_prepare(struct snd_soc_lzo_ctx *lzo_ctx)
1011 lzo_ctx->wmem = kmalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL);
1017 static int snd_soc_lzo_compress(struct snd_soc_lzo_ctx *lzo_ctx)
1019 size_t compress_size;
1022 ret = lzo1x_1_compress(lzo_ctx->src, lzo_ctx->src_len,
1023 lzo_ctx->dst, &compress_size, lzo_ctx->wmem);
1024 if (ret != LZO_E_OK || compress_size > lzo_ctx->dst_len)
1026 lzo_ctx->dst_len = compress_size;
1030 static int snd_soc_lzo_decompress(struct snd_soc_lzo_ctx *lzo_ctx)
1035 dst_len = lzo_ctx->dst_len;
1036 ret = lzo1x_decompress_safe(lzo_ctx->src, lzo_ctx->src_len,
1037 lzo_ctx->dst, &dst_len);
1038 if (ret != LZO_E_OK || dst_len != lzo_ctx->dst_len)
1043 static int snd_soc_lzo_compress_cache_block(struct snd_soc_codec *codec,
1044 struct snd_soc_lzo_ctx *lzo_ctx)
1048 lzo_ctx->dst_len = lzo1x_worst_compress(PAGE_SIZE);
1049 lzo_ctx->dst = kmalloc(lzo_ctx->dst_len, GFP_KERNEL);
1050 if (!lzo_ctx->dst) {
1051 lzo_ctx->dst_len = 0;
1055 ret = snd_soc_lzo_compress(lzo_ctx);
1061 static int snd_soc_lzo_decompress_cache_block(struct snd_soc_codec *codec,
1062 struct snd_soc_lzo_ctx *lzo_ctx)
1066 lzo_ctx->dst_len = lzo_ctx->decompressed_size;
1067 lzo_ctx->dst = kmalloc(lzo_ctx->dst_len, GFP_KERNEL);
1068 if (!lzo_ctx->dst) {
1069 lzo_ctx->dst_len = 0;
1073 ret = snd_soc_lzo_decompress(lzo_ctx);
1079 static inline int snd_soc_lzo_get_blkindex(struct snd_soc_codec *codec,
1082 const struct snd_soc_codec_driver *codec_drv;
1085 codec_drv = codec->driver;
1086 reg_size = codec_drv->reg_cache_size * codec_drv->reg_word_size;
1087 return (reg * codec_drv->reg_word_size) /
1088 DIV_ROUND_UP(reg_size, snd_soc_lzo_block_count());
1091 static inline int snd_soc_lzo_get_blkpos(struct snd_soc_codec *codec,
1094 const struct snd_soc_codec_driver *codec_drv;
1097 codec_drv = codec->driver;
1098 reg_size = codec_drv->reg_cache_size * codec_drv->reg_word_size;
1099 return reg % (DIV_ROUND_UP(reg_size, snd_soc_lzo_block_count()) /
1100 codec_drv->reg_word_size);
1103 static inline int snd_soc_lzo_get_blksize(struct snd_soc_codec *codec)
1105 const struct snd_soc_codec_driver *codec_drv;
1108 codec_drv = codec->driver;
1109 reg_size = codec_drv->reg_cache_size * codec_drv->reg_word_size;
1110 return DIV_ROUND_UP(reg_size, snd_soc_lzo_block_count());
1113 static int snd_soc_lzo_cache_sync(struct snd_soc_codec *codec)
1115 struct snd_soc_lzo_ctx **lzo_blocks;
1120 lzo_blocks = codec->reg_cache;
1121 for_each_set_bit(i, lzo_blocks[0]->sync_bmp, lzo_blocks[0]->sync_bmp_nbits) {
1122 ret = snd_soc_cache_read(codec, i, &val);
1125 ret = snd_soc_write(codec, i, val);
1128 dev_dbg(codec->dev, "Synced register %#x, value = %#x\n",
1135 static int snd_soc_lzo_cache_write(struct snd_soc_codec *codec,
1136 unsigned int reg, unsigned int value)
1138 struct snd_soc_lzo_ctx *lzo_block, **lzo_blocks;
1139 int ret, blkindex, blkpos;
1140 size_t blksize, tmp_dst_len;
1143 /* index of the compressed lzo block */
1144 blkindex = snd_soc_lzo_get_blkindex(codec, reg);
1145 /* register index within the decompressed block */
1146 blkpos = snd_soc_lzo_get_blkpos(codec, reg);
1147 /* size of the compressed block */
1148 blksize = snd_soc_lzo_get_blksize(codec);
1149 lzo_blocks = codec->reg_cache;
1150 lzo_block = lzo_blocks[blkindex];
1152 /* save the pointer and length of the compressed block */
1153 tmp_dst = lzo_block->dst;
1154 tmp_dst_len = lzo_block->dst_len;
1156 /* prepare the source to be the compressed block */
1157 lzo_block->src = lzo_block->dst;
1158 lzo_block->src_len = lzo_block->dst_len;
1160 /* decompress the block */
1161 ret = snd_soc_lzo_decompress_cache_block(codec, lzo_block);
1163 kfree(lzo_block->dst);
1167 /* write the new value to the cache */
1168 switch (codec->driver->reg_word_size) {
1171 cache = lzo_block->dst;
1172 if (cache[blkpos] == value) {
1173 kfree(lzo_block->dst);
1176 cache[blkpos] = value;
1181 cache = lzo_block->dst;
1182 if (cache[blkpos] == value) {
1183 kfree(lzo_block->dst);
1186 cache[blkpos] = value;
1193 /* prepare the source to be the decompressed block */
1194 lzo_block->src = lzo_block->dst;
1195 lzo_block->src_len = lzo_block->dst_len;
1197 /* compress the block */
1198 ret = snd_soc_lzo_compress_cache_block(codec, lzo_block);
1200 kfree(lzo_block->dst);
1201 kfree(lzo_block->src);
1205 /* set the bit so we know we have to sync this register */
1206 set_bit(reg, lzo_block->sync_bmp);
1208 kfree(lzo_block->src);
1211 lzo_block->dst = tmp_dst;
1212 lzo_block->dst_len = tmp_dst_len;
1216 static int snd_soc_lzo_cache_read(struct snd_soc_codec *codec,
1217 unsigned int reg, unsigned int *value)
1219 struct snd_soc_lzo_ctx *lzo_block, **lzo_blocks;
1220 int ret, blkindex, blkpos;
1221 size_t blksize, tmp_dst_len;
1225 /* index of the compressed lzo block */
1226 blkindex = snd_soc_lzo_get_blkindex(codec, reg);
1227 /* register index within the decompressed block */
1228 blkpos = snd_soc_lzo_get_blkpos(codec, reg);
1229 /* size of the compressed block */
1230 blksize = snd_soc_lzo_get_blksize(codec);
1231 lzo_blocks = codec->reg_cache;
1232 lzo_block = lzo_blocks[blkindex];
1234 /* save the pointer and length of the compressed block */
1235 tmp_dst = lzo_block->dst;
1236 tmp_dst_len = lzo_block->dst_len;
1238 /* prepare the source to be the compressed block */
1239 lzo_block->src = lzo_block->dst;
1240 lzo_block->src_len = lzo_block->dst_len;
1242 /* decompress the block */
1243 ret = snd_soc_lzo_decompress_cache_block(codec, lzo_block);
1245 /* fetch the value from the cache */
1246 switch (codec->driver->reg_word_size) {
1249 cache = lzo_block->dst;
1250 *value = cache[blkpos];
1255 cache = lzo_block->dst;
1256 *value = cache[blkpos];
1264 kfree(lzo_block->dst);
1265 /* restore the pointer and length of the compressed block */
1266 lzo_block->dst = tmp_dst;
1267 lzo_block->dst_len = tmp_dst_len;
1271 static int snd_soc_lzo_cache_exit(struct snd_soc_codec *codec)
1273 struct snd_soc_lzo_ctx **lzo_blocks;
1276 lzo_blocks = codec->reg_cache;
1280 blkcount = snd_soc_lzo_block_count();
1282 * the pointer to the bitmap used for syncing the cache
1283 * is shared amongst all lzo_blocks. Ensure it is freed
1287 kfree(lzo_blocks[0]->sync_bmp);
1288 for (i = 0; i < blkcount; ++i) {
1289 if (lzo_blocks[i]) {
1290 kfree(lzo_blocks[i]->wmem);
1291 kfree(lzo_blocks[i]->dst);
1293 /* each lzo_block is a pointer returned by kmalloc or NULL */
1294 kfree(lzo_blocks[i]);
1297 codec->reg_cache = NULL;
1301 static int snd_soc_lzo_cache_init(struct snd_soc_codec *codec)
1303 struct snd_soc_lzo_ctx **lzo_blocks;
1304 size_t reg_size, bmp_size;
1305 const struct snd_soc_codec_driver *codec_drv;
1306 int ret, tofree, i, blksize, blkcount;
1307 const char *p, *end;
1308 unsigned long *sync_bmp;
1311 codec_drv = codec->driver;
1312 reg_size = codec_drv->reg_cache_size * codec_drv->reg_word_size;
1315 * If we have not been given a default register cache
1316 * then allocate a dummy zero-ed out region, compress it
1317 * and remember to free it afterwards.
1320 if (!codec->reg_def_copy)
1323 if (!codec->reg_def_copy) {
1324 codec->reg_def_copy = kzalloc(reg_size,
1326 if (!codec->reg_def_copy)
1330 blkcount = snd_soc_lzo_block_count();
1331 codec->reg_cache = kzalloc(blkcount * sizeof *lzo_blocks,
1333 if (!codec->reg_cache) {
1337 lzo_blocks = codec->reg_cache;
1340 * allocate a bitmap to be used when syncing the cache with
1341 * the hardware. Each time a register is modified, the corresponding
1342 * bit is set in the bitmap, so we know that we have to sync
1345 bmp_size = codec_drv->reg_cache_size;
1346 sync_bmp = kmalloc(BITS_TO_LONGS(bmp_size) * sizeof(long),
1352 bitmap_zero(sync_bmp, bmp_size);
1354 /* allocate the lzo blocks and initialize them */
1355 for (i = 0; i < blkcount; ++i) {
1356 lzo_blocks[i] = kzalloc(sizeof **lzo_blocks,
1358 if (!lzo_blocks[i]) {
1363 lzo_blocks[i]->sync_bmp = sync_bmp;
1364 lzo_blocks[i]->sync_bmp_nbits = bmp_size;
1365 /* alloc the working space for the compressed block */
1366 ret = snd_soc_lzo_prepare(lzo_blocks[i]);
1371 blksize = snd_soc_lzo_get_blksize(codec);
1372 p = codec->reg_def_copy;
1373 end = codec->reg_def_copy + reg_size;
1374 /* compress the register map and fill the lzo blocks */
1375 for (i = 0; i < blkcount; ++i, p += blksize) {
1376 lzo_blocks[i]->src = p;
1377 if (p + blksize > end)
1378 lzo_blocks[i]->src_len = end - p;
1380 lzo_blocks[i]->src_len = blksize;
1381 ret = snd_soc_lzo_compress_cache_block(codec,
1385 lzo_blocks[i]->decompressed_size =
1386 lzo_blocks[i]->src_len;
1390 kfree(codec->reg_def_copy);
1391 codec->reg_def_copy = NULL;
1395 snd_soc_cache_exit(codec);
1398 kfree(codec->reg_def_copy);
1399 codec->reg_def_copy = NULL;
1405 static int snd_soc_flat_cache_sync(struct snd_soc_codec *codec)
1409 const struct snd_soc_codec_driver *codec_drv;
1412 codec_drv = codec->driver;
1413 for (i = 0; i < codec_drv->reg_cache_size; ++i) {
1414 ret = snd_soc_cache_read(codec, i, &val);
1417 if (codec_drv->reg_cache_default) {
1418 switch (codec_drv->reg_word_size) {
1422 cache = codec_drv->reg_cache_default;
1423 if (cache[i] == val)
1430 cache = codec_drv->reg_cache_default;
1431 if (cache[i] == val)
1439 ret = snd_soc_write(codec, i, val);
1442 dev_dbg(codec->dev, "Synced register %#x, value = %#x\n",
1448 static int snd_soc_flat_cache_write(struct snd_soc_codec *codec,
1449 unsigned int reg, unsigned int value)
1451 switch (codec->driver->reg_word_size) {
1455 cache = codec->reg_cache;
1462 cache = codec->reg_cache;
1473 static int snd_soc_flat_cache_read(struct snd_soc_codec *codec,
1474 unsigned int reg, unsigned int *value)
1476 switch (codec->driver->reg_word_size) {
1480 cache = codec->reg_cache;
1481 *value = cache[reg];
1487 cache = codec->reg_cache;
1488 *value = cache[reg];
1498 static int snd_soc_flat_cache_exit(struct snd_soc_codec *codec)
1500 if (!codec->reg_cache)
1502 kfree(codec->reg_cache);
1503 codec->reg_cache = NULL;
1507 static int snd_soc_flat_cache_init(struct snd_soc_codec *codec)
1509 const struct snd_soc_codec_driver *codec_drv;
1512 codec_drv = codec->driver;
1513 reg_size = codec_drv->reg_cache_size * codec_drv->reg_word_size;
1516 * for flat compression, we don't need to keep a copy of the
1517 * original defaults register cache as it will definitely not
1518 * be marked as __devinitconst
1520 kfree(codec->reg_def_copy);
1521 codec->reg_def_copy = NULL;
1523 if (codec_drv->reg_cache_default)
1524 codec->reg_cache = kmemdup(codec_drv->reg_cache_default,
1525 reg_size, GFP_KERNEL);
1527 codec->reg_cache = kzalloc(reg_size, GFP_KERNEL);
1528 if (!codec->reg_cache)
1534 /* an array of all supported compression types */
1535 static const struct snd_soc_cache_ops cache_types[] = {
1536 /* Flat *must* be the first entry for fallback */
1538 .id = SND_SOC_FLAT_COMPRESSION,
1540 .init = snd_soc_flat_cache_init,
1541 .exit = snd_soc_flat_cache_exit,
1542 .read = snd_soc_flat_cache_read,
1543 .write = snd_soc_flat_cache_write,
1544 .sync = snd_soc_flat_cache_sync
1546 #ifdef CONFIG_SND_SOC_CACHE_LZO
1548 .id = SND_SOC_LZO_COMPRESSION,
1550 .init = snd_soc_lzo_cache_init,
1551 .exit = snd_soc_lzo_cache_exit,
1552 .read = snd_soc_lzo_cache_read,
1553 .write = snd_soc_lzo_cache_write,
1554 .sync = snd_soc_lzo_cache_sync
1558 .id = SND_SOC_RBTREE_COMPRESSION,
1560 .init = snd_soc_rbtree_cache_init,
1561 .exit = snd_soc_rbtree_cache_exit,
1562 .read = snd_soc_rbtree_cache_read,
1563 .write = snd_soc_rbtree_cache_write,
1564 .sync = snd_soc_rbtree_cache_sync
1568 int snd_soc_cache_init(struct snd_soc_codec *codec)
1572 for (i = 0; i < ARRAY_SIZE(cache_types); ++i)
1573 if (cache_types[i].id == codec->compress_type)
1576 /* Fall back to flat compression */
1577 if (i == ARRAY_SIZE(cache_types)) {
1578 dev_warn(codec->dev, "Could not match compress type: %d\n",
1579 codec->compress_type);
1583 mutex_init(&codec->cache_rw_mutex);
1584 codec->cache_ops = &cache_types[i];
1586 if (codec->cache_ops->init) {
1587 if (codec->cache_ops->name)
1588 dev_dbg(codec->dev, "Initializing %s cache for %s codec\n",
1589 codec->cache_ops->name, codec->name);
1590 return codec->cache_ops->init(codec);
1596 * NOTE: keep in mind that this function might be called
1599 int snd_soc_cache_exit(struct snd_soc_codec *codec)
1601 if (codec->cache_ops && codec->cache_ops->exit) {
1602 if (codec->cache_ops->name)
1603 dev_dbg(codec->dev, "Destroying %s cache for %s codec\n",
1604 codec->cache_ops->name, codec->name);
1605 return codec->cache_ops->exit(codec);
1611 * snd_soc_cache_read: Fetch the value of a given register from the cache.
1613 * @codec: CODEC to configure.
1614 * @reg: The register index.
1615 * @value: The value to be returned.
1617 int snd_soc_cache_read(struct snd_soc_codec *codec,
1618 unsigned int reg, unsigned int *value)
1622 mutex_lock(&codec->cache_rw_mutex);
1624 if (value && codec->cache_ops && codec->cache_ops->read) {
1625 ret = codec->cache_ops->read(codec, reg, value);
1626 mutex_unlock(&codec->cache_rw_mutex);
1630 mutex_unlock(&codec->cache_rw_mutex);
1633 EXPORT_SYMBOL_GPL(snd_soc_cache_read);
1636 * snd_soc_cache_write: Set the value of a given register in the cache.
1638 * @codec: CODEC to configure.
1639 * @reg: The register index.
1640 * @value: The new register value.
1642 int snd_soc_cache_write(struct snd_soc_codec *codec,
1643 unsigned int reg, unsigned int value)
1647 mutex_lock(&codec->cache_rw_mutex);
1649 if (codec->cache_ops && codec->cache_ops->write) {
1650 ret = codec->cache_ops->write(codec, reg, value);
1651 mutex_unlock(&codec->cache_rw_mutex);
1655 mutex_unlock(&codec->cache_rw_mutex);
1658 EXPORT_SYMBOL_GPL(snd_soc_cache_write);
1661 * snd_soc_cache_sync: Sync the register cache with the hardware.
1663 * @codec: CODEC to configure.
1665 * Any registers that should not be synced should be marked as
1666 * volatile. In general drivers can choose not to use the provided
1667 * syncing functionality if they so require.
1669 int snd_soc_cache_sync(struct snd_soc_codec *codec)
1673 if (!codec->cache_sync) {
1677 if (codec->cache_ops && codec->cache_ops->sync) {
1678 if (codec->cache_ops->name)
1679 dev_dbg(codec->dev, "Syncing %s cache for %s codec\n",
1680 codec->cache_ops->name, codec->name);
1681 ret = codec->cache_ops->sync(codec);
1683 codec->cache_sync = 0;
1689 EXPORT_SYMBOL_GPL(snd_soc_cache_sync);