ASoC: omap: rx51: Enable McBSP2 sidetone
[linux-2.6.git] / 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 unsigned int snd_soc_4_12_read(struct snd_soc_codec *codec,
24                                      unsigned int reg)
25 {
26         int ret;
27         unsigned int val;
28
29         if (reg >= codec->driver->reg_cache_size ||
30                 snd_soc_codec_volatile_register(codec, reg) ||
31                 codec->cache_bypass) {
32                         if (codec->cache_only)
33                                 return -1;
34
35                         BUG_ON(!codec->hw_read);
36                         return codec->hw_read(codec, reg);
37         }
38
39         ret = snd_soc_cache_read(codec, reg, &val);
40         if (ret < 0)
41                 return -1;
42         return val;
43 }
44
45 static int snd_soc_4_12_write(struct snd_soc_codec *codec, unsigned int reg,
46                              unsigned int value)
47 {
48         u8 data[2];
49         int ret;
50
51         data[0] = (reg << 4) | ((value >> 8) & 0x000f);
52         data[1] = value & 0x00ff;
53
54         if (!snd_soc_codec_volatile_register(codec, reg) &&
55                 reg < codec->driver->reg_cache_size &&
56                 !codec->cache_bypass) {
57                 ret = snd_soc_cache_write(codec, reg, value);
58                 if (ret < 0)
59                         return -1;
60         }
61
62         if (codec->cache_only) {
63                 codec->cache_sync = 1;
64                 return 0;
65         }
66
67         ret = codec->hw_write(codec->control_data, data, 2);
68         if (ret == 2)
69                 return 0;
70         if (ret < 0)
71                 return ret;
72         else
73                 return -EIO;
74 }
75
76 #if defined(CONFIG_SPI_MASTER)
77 static int snd_soc_4_12_spi_write(void *control_data, const char *data,
78                                  int len)
79 {
80         struct spi_device *spi = control_data;
81         struct spi_transfer t;
82         struct spi_message m;
83         u8 msg[2];
84
85         if (len <= 0)
86                 return 0;
87
88         msg[0] = data[1];
89         msg[1] = data[0];
90
91         spi_message_init(&m);
92         memset(&t, 0, sizeof t);
93
94         t.tx_buf = &msg[0];
95         t.len = len;
96
97         spi_message_add_tail(&t, &m);
98         spi_sync(spi, &m);
99
100         return len;
101 }
102 #else
103 #define snd_soc_4_12_spi_write NULL
104 #endif
105
106 static unsigned int snd_soc_7_9_read(struct snd_soc_codec *codec,
107                                      unsigned int reg)
108 {
109         int ret;
110         unsigned int val;
111
112         if (reg >= codec->driver->reg_cache_size ||
113                 snd_soc_codec_volatile_register(codec, reg) ||
114                 codec->cache_bypass) {
115                         if (codec->cache_only)
116                                 return -1;
117
118                         BUG_ON(!codec->hw_read);
119                         return codec->hw_read(codec, reg);
120         }
121
122         ret = snd_soc_cache_read(codec, reg, &val);
123         if (ret < 0)
124                 return -1;
125         return val;
126 }
127
128 static int snd_soc_7_9_write(struct snd_soc_codec *codec, unsigned int reg,
129                              unsigned int value)
130 {
131         u8 data[2];
132         int ret;
133
134         data[0] = (reg << 1) | ((value >> 8) & 0x0001);
135         data[1] = value & 0x00ff;
136
137         if (!snd_soc_codec_volatile_register(codec, reg) &&
138                 reg < codec->driver->reg_cache_size &&
139                 !codec->cache_bypass) {
140                 ret = snd_soc_cache_write(codec, reg, value);
141                 if (ret < 0)
142                         return -1;
143         }
144
145         if (codec->cache_only) {
146                 codec->cache_sync = 1;
147                 return 0;
148         }
149
150         ret = codec->hw_write(codec->control_data, data, 2);
151         if (ret == 2)
152                 return 0;
153         if (ret < 0)
154                 return ret;
155         else
156                 return -EIO;
157 }
158
159 #if defined(CONFIG_SPI_MASTER)
160 static int snd_soc_7_9_spi_write(void *control_data, const char *data,
161                                  int len)
162 {
163         struct spi_device *spi = control_data;
164         struct spi_transfer t;
165         struct spi_message m;
166         u8 msg[2];
167
168         if (len <= 0)
169                 return 0;
170
171         msg[0] = data[0];
172         msg[1] = data[1];
173
174         spi_message_init(&m);
175         memset(&t, 0, sizeof t);
176
177         t.tx_buf = &msg[0];
178         t.len = len;
179
180         spi_message_add_tail(&t, &m);
181         spi_sync(spi, &m);
182
183         return len;
184 }
185 #else
186 #define snd_soc_7_9_spi_write NULL
187 #endif
188
189 static int snd_soc_8_8_write(struct snd_soc_codec *codec, unsigned int reg,
190                              unsigned int value)
191 {
192         u8 data[2];
193         int ret;
194
195         reg &= 0xff;
196         data[0] = reg;
197         data[1] = value & 0xff;
198
199         if (!snd_soc_codec_volatile_register(codec, reg) &&
200                 reg < codec->driver->reg_cache_size &&
201                 !codec->cache_bypass) {
202                 ret = snd_soc_cache_write(codec, reg, value);
203                 if (ret < 0)
204                         return -1;
205         }
206
207         if (codec->cache_only) {
208                 codec->cache_sync = 1;
209                 return 0;
210         }
211
212         if (codec->hw_write(codec->control_data, data, 2) == 2)
213                 return 0;
214         else
215                 return -EIO;
216 }
217
218 static unsigned int snd_soc_8_8_read(struct snd_soc_codec *codec,
219                                      unsigned int reg)
220 {
221         int ret;
222         unsigned int val;
223
224         reg &= 0xff;
225         if (reg >= codec->driver->reg_cache_size ||
226                 snd_soc_codec_volatile_register(codec, reg) ||
227                 codec->cache_bypass) {
228                         if (codec->cache_only)
229                                 return -1;
230
231                         BUG_ON(!codec->hw_read);
232                         return codec->hw_read(codec, reg);
233         }
234
235         ret = snd_soc_cache_read(codec, reg, &val);
236         if (ret < 0)
237                 return -1;
238         return val;
239 }
240
241 #if defined(CONFIG_SPI_MASTER)
242 static int snd_soc_8_8_spi_write(void *control_data, const char *data,
243                                  int len)
244 {
245         struct spi_device *spi = control_data;
246         struct spi_transfer t;
247         struct spi_message m;
248         u8 msg[2];
249
250         if (len <= 0)
251                 return 0;
252
253         msg[0] = data[0];
254         msg[1] = data[1];
255
256         spi_message_init(&m);
257         memset(&t, 0, sizeof t);
258
259         t.tx_buf = &msg[0];
260         t.len = len;
261
262         spi_message_add_tail(&t, &m);
263         spi_sync(spi, &m);
264
265         return len;
266 }
267 #else
268 #define snd_soc_8_8_spi_write NULL
269 #endif
270
271 static int snd_soc_8_16_write(struct snd_soc_codec *codec, unsigned int reg,
272                               unsigned int value)
273 {
274         u8 data[3];
275         int ret;
276
277         data[0] = reg;
278         data[1] = (value >> 8) & 0xff;
279         data[2] = value & 0xff;
280
281         if (!snd_soc_codec_volatile_register(codec, reg) &&
282                 reg < codec->driver->reg_cache_size &&
283                 !codec->cache_bypass) {
284                 ret = snd_soc_cache_write(codec, reg, value);
285                 if (ret < 0)
286                         return -1;
287         }
288
289         if (codec->cache_only) {
290                 codec->cache_sync = 1;
291                 return 0;
292         }
293
294         if (codec->hw_write(codec->control_data, data, 3) == 3)
295                 return 0;
296         else
297                 return -EIO;
298 }
299
300 static unsigned int snd_soc_8_16_read(struct snd_soc_codec *codec,
301                                       unsigned int reg)
302 {
303         int ret;
304         unsigned int val;
305
306         if (reg >= codec->driver->reg_cache_size ||
307             snd_soc_codec_volatile_register(codec, reg) ||
308             codec->cache_bypass) {
309                 if (codec->cache_only)
310                         return -1;
311
312                 BUG_ON(!codec->hw_read);
313                 return codec->hw_read(codec, reg);
314         }
315
316         ret = snd_soc_cache_read(codec, reg, &val);
317         if (ret < 0)
318                 return -1;
319         return val;
320 }
321
322 #if defined(CONFIG_SPI_MASTER)
323 static int snd_soc_8_16_spi_write(void *control_data, const char *data,
324                                  int len)
325 {
326         struct spi_device *spi = control_data;
327         struct spi_transfer t;
328         struct spi_message m;
329         u8 msg[3];
330
331         if (len <= 0)
332                 return 0;
333
334         msg[0] = data[0];
335         msg[1] = data[1];
336         msg[2] = data[2];
337
338         spi_message_init(&m);
339         memset(&t, 0, sizeof t);
340
341         t.tx_buf = &msg[0];
342         t.len = len;
343
344         spi_message_add_tail(&t, &m);
345         spi_sync(spi, &m);
346
347         return len;
348 }
349 #else
350 #define snd_soc_8_16_spi_write NULL
351 #endif
352
353 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
354 static unsigned int snd_soc_8_8_read_i2c(struct snd_soc_codec *codec,
355                                           unsigned int r)
356 {
357         struct i2c_msg xfer[2];
358         u8 reg = r;
359         u8 data;
360         int ret;
361         struct i2c_client *client = codec->control_data;
362
363         /* Write register */
364         xfer[0].addr = client->addr;
365         xfer[0].flags = 0;
366         xfer[0].len = 1;
367         xfer[0].buf = &reg;
368
369         /* Read data */
370         xfer[1].addr = client->addr;
371         xfer[1].flags = I2C_M_RD;
372         xfer[1].len = 1;
373         xfer[1].buf = &data;
374
375         ret = i2c_transfer(client->adapter, xfer, 2);
376         if (ret != 2) {
377                 dev_err(&client->dev, "i2c_transfer() returned %d\n", ret);
378                 return 0;
379         }
380
381         return data;
382 }
383 #else
384 #define snd_soc_8_8_read_i2c NULL
385 #endif
386
387 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
388 static unsigned int snd_soc_8_16_read_i2c(struct snd_soc_codec *codec,
389                                           unsigned int r)
390 {
391         struct i2c_msg xfer[2];
392         u8 reg = r;
393         u16 data;
394         int ret;
395         struct i2c_client *client = codec->control_data;
396
397         /* Write register */
398         xfer[0].addr = client->addr;
399         xfer[0].flags = 0;
400         xfer[0].len = 1;
401         xfer[0].buf = &reg;
402
403         /* Read data */
404         xfer[1].addr = client->addr;
405         xfer[1].flags = I2C_M_RD;
406         xfer[1].len = 2;
407         xfer[1].buf = (u8 *)&data;
408
409         ret = i2c_transfer(client->adapter, xfer, 2);
410         if (ret != 2) {
411                 dev_err(&client->dev, "i2c_transfer() returned %d\n", ret);
412                 return 0;
413         }
414
415         return (data >> 8) | ((data & 0xff) << 8);
416 }
417 #else
418 #define snd_soc_8_16_read_i2c NULL
419 #endif
420
421 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
422 static unsigned int snd_soc_16_8_read_i2c(struct snd_soc_codec *codec,
423                                           unsigned int r)
424 {
425         struct i2c_msg xfer[2];
426         u16 reg = r;
427         u8 data;
428         int ret;
429         struct i2c_client *client = codec->control_data;
430
431         /* Write register */
432         xfer[0].addr = client->addr;
433         xfer[0].flags = 0;
434         xfer[0].len = 2;
435         xfer[0].buf = (u8 *)&reg;
436
437         /* Read data */
438         xfer[1].addr = client->addr;
439         xfer[1].flags = I2C_M_RD;
440         xfer[1].len = 1;
441         xfer[1].buf = &data;
442
443         ret = i2c_transfer(client->adapter, xfer, 2);
444         if (ret != 2) {
445                 dev_err(&client->dev, "i2c_transfer() returned %d\n", ret);
446                 return 0;
447         }
448
449         return data;
450 }
451 #else
452 #define snd_soc_16_8_read_i2c NULL
453 #endif
454
455 static unsigned int snd_soc_16_8_read(struct snd_soc_codec *codec,
456                                      unsigned int reg)
457 {
458         int ret;
459         unsigned int val;
460
461         reg &= 0xff;
462         if (reg >= codec->driver->reg_cache_size ||
463                 snd_soc_codec_volatile_register(codec, reg) ||
464                 codec->cache_bypass) {
465                         if (codec->cache_only)
466                                 return -1;
467
468                         BUG_ON(!codec->hw_read);
469                         return codec->hw_read(codec, reg);
470         }
471
472         ret = snd_soc_cache_read(codec, reg, &val);
473         if (ret < 0)
474                 return -1;
475         return val;
476 }
477
478 static int snd_soc_16_8_write(struct snd_soc_codec *codec, unsigned int reg,
479                              unsigned int value)
480 {
481         u8 data[3];
482         int ret;
483
484         data[0] = (reg >> 8) & 0xff;
485         data[1] = reg & 0xff;
486         data[2] = value;
487
488         reg &= 0xff;
489         if (!snd_soc_codec_volatile_register(codec, reg) &&
490                 reg < codec->driver->reg_cache_size &&
491                 !codec->cache_bypass) {
492                 ret = snd_soc_cache_write(codec, reg, value);
493                 if (ret < 0)
494                         return -1;
495         }
496
497         if (codec->cache_only) {
498                 codec->cache_sync = 1;
499                 return 0;
500         }
501
502         ret = codec->hw_write(codec->control_data, data, 3);
503         if (ret == 3)
504                 return 0;
505         if (ret < 0)
506                 return ret;
507         else
508                 return -EIO;
509 }
510
511 #if defined(CONFIG_SPI_MASTER)
512 static int snd_soc_16_8_spi_write(void *control_data, const char *data,
513                                  int len)
514 {
515         struct spi_device *spi = control_data;
516         struct spi_transfer t;
517         struct spi_message m;
518         u8 msg[3];
519
520         if (len <= 0)
521                 return 0;
522
523         msg[0] = data[0];
524         msg[1] = data[1];
525         msg[2] = data[2];
526
527         spi_message_init(&m);
528         memset(&t, 0, sizeof t);
529
530         t.tx_buf = &msg[0];
531         t.len = len;
532
533         spi_message_add_tail(&t, &m);
534         spi_sync(spi, &m);
535
536         return len;
537 }
538 #else
539 #define snd_soc_16_8_spi_write NULL
540 #endif
541
542 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
543 static unsigned int snd_soc_16_16_read_i2c(struct snd_soc_codec *codec,
544                                            unsigned int r)
545 {
546         struct i2c_msg xfer[2];
547         u16 reg = cpu_to_be16(r);
548         u16 data;
549         int ret;
550         struct i2c_client *client = codec->control_data;
551
552         /* Write register */
553         xfer[0].addr = client->addr;
554         xfer[0].flags = 0;
555         xfer[0].len = 2;
556         xfer[0].buf = (u8 *)&reg;
557
558         /* Read data */
559         xfer[1].addr = client->addr;
560         xfer[1].flags = I2C_M_RD;
561         xfer[1].len = 2;
562         xfer[1].buf = (u8 *)&data;
563
564         ret = i2c_transfer(client->adapter, xfer, 2);
565         if (ret != 2) {
566                 dev_err(&client->dev, "i2c_transfer() returned %d\n", ret);
567                 return 0;
568         }
569
570         return be16_to_cpu(data);
571 }
572 #else
573 #define snd_soc_16_16_read_i2c NULL
574 #endif
575
576 static unsigned int snd_soc_16_16_read(struct snd_soc_codec *codec,
577                                        unsigned int reg)
578 {
579         int ret;
580         unsigned int val;
581
582         if (reg >= codec->driver->reg_cache_size ||
583             snd_soc_codec_volatile_register(codec, reg) ||
584             codec->cache_bypass) {
585                 if (codec->cache_only)
586                         return -1;
587
588                 BUG_ON(!codec->hw_read);
589                 return codec->hw_read(codec, reg);
590         }
591
592         ret = snd_soc_cache_read(codec, reg, &val);
593         if (ret < 0)
594                 return -1;
595
596         return val;
597 }
598
599 static int snd_soc_16_16_write(struct snd_soc_codec *codec, unsigned int reg,
600                                unsigned int value)
601 {
602         u8 data[4];
603         int ret;
604
605         data[0] = (reg >> 8) & 0xff;
606         data[1] = reg & 0xff;
607         data[2] = (value >> 8) & 0xff;
608         data[3] = value & 0xff;
609
610         if (!snd_soc_codec_volatile_register(codec, reg) &&
611                 reg < codec->driver->reg_cache_size &&
612                 !codec->cache_bypass) {
613                 ret = snd_soc_cache_write(codec, reg, value);
614                 if (ret < 0)
615                         return -1;
616         }
617
618         if (codec->cache_only) {
619                 codec->cache_sync = 1;
620                 return 0;
621         }
622
623         ret = codec->hw_write(codec->control_data, data, 4);
624         if (ret == 4)
625                 return 0;
626         if (ret < 0)
627                 return ret;
628         else
629                 return -EIO;
630 }
631
632 #if defined(CONFIG_SPI_MASTER)
633 static int snd_soc_16_16_spi_write(void *control_data, const char *data,
634                                  int len)
635 {
636         struct spi_device *spi = control_data;
637         struct spi_transfer t;
638         struct spi_message m;
639         u8 msg[4];
640
641         if (len <= 0)
642                 return 0;
643
644         msg[0] = data[0];
645         msg[1] = data[1];
646         msg[2] = data[2];
647         msg[3] = data[3];
648
649         spi_message_init(&m);
650         memset(&t, 0, sizeof t);
651
652         t.tx_buf = &msg[0];
653         t.len = len;
654
655         spi_message_add_tail(&t, &m);
656         spi_sync(spi, &m);
657
658         return len;
659 }
660 #else
661 #define snd_soc_16_16_spi_write NULL
662 #endif
663
664 static struct {
665         int addr_bits;
666         int data_bits;
667         int (*write)(struct snd_soc_codec *codec, unsigned int, unsigned int);
668         int (*spi_write)(void *, const char *, int);
669         unsigned int (*read)(struct snd_soc_codec *, unsigned int);
670         unsigned int (*i2c_read)(struct snd_soc_codec *, unsigned int);
671 } io_types[] = {
672         {
673                 .addr_bits = 4, .data_bits = 12,
674                 .write = snd_soc_4_12_write, .read = snd_soc_4_12_read,
675                 .spi_write = snd_soc_4_12_spi_write,
676         },
677         {
678                 .addr_bits = 7, .data_bits = 9,
679                 .write = snd_soc_7_9_write, .read = snd_soc_7_9_read,
680                 .spi_write = snd_soc_7_9_spi_write,
681         },
682         {
683                 .addr_bits = 8, .data_bits = 8,
684                 .write = snd_soc_8_8_write, .read = snd_soc_8_8_read,
685                 .i2c_read = snd_soc_8_8_read_i2c,
686                 .spi_write = snd_soc_8_8_spi_write,
687         },
688         {
689                 .addr_bits = 8, .data_bits = 16,
690                 .write = snd_soc_8_16_write, .read = snd_soc_8_16_read,
691                 .i2c_read = snd_soc_8_16_read_i2c,
692                 .spi_write = snd_soc_8_16_spi_write,
693         },
694         {
695                 .addr_bits = 16, .data_bits = 8,
696                 .write = snd_soc_16_8_write, .read = snd_soc_16_8_read,
697                 .i2c_read = snd_soc_16_8_read_i2c,
698                 .spi_write = snd_soc_16_8_spi_write,
699         },
700         {
701                 .addr_bits = 16, .data_bits = 16,
702                 .write = snd_soc_16_16_write, .read = snd_soc_16_16_read,
703                 .i2c_read = snd_soc_16_16_read_i2c,
704                 .spi_write = snd_soc_16_16_spi_write,
705         },
706 };
707
708 /**
709  * snd_soc_codec_set_cache_io: Set up standard I/O functions.
710  *
711  * @codec: CODEC to configure.
712  * @type: Type of cache.
713  * @addr_bits: Number of bits of register address data.
714  * @data_bits: Number of bits of data per register.
715  * @control: Control bus used.
716  *
717  * Register formats are frequently shared between many I2C and SPI
718  * devices.  In order to promote code reuse the ASoC core provides
719  * some standard implementations of CODEC read and write operations
720  * which can be set up using this function.
721  *
722  * The caller is responsible for allocating and initialising the
723  * actual cache.
724  *
725  * Note that at present this code cannot be used by CODECs with
726  * volatile registers.
727  */
728 int snd_soc_codec_set_cache_io(struct snd_soc_codec *codec,
729                                int addr_bits, int data_bits,
730                                enum snd_soc_control_type control)
731 {
732         int i;
733
734         for (i = 0; i < ARRAY_SIZE(io_types); i++)
735                 if (io_types[i].addr_bits == addr_bits &&
736                     io_types[i].data_bits == data_bits)
737                         break;
738         if (i == ARRAY_SIZE(io_types)) {
739                 printk(KERN_ERR
740                        "No I/O functions for %d bit address %d bit data\n",
741                        addr_bits, data_bits);
742                 return -EINVAL;
743         }
744
745         codec->write = io_types[i].write;
746         codec->read = io_types[i].read;
747
748         switch (control) {
749         case SND_SOC_CUSTOM:
750                 break;
751
752         case SND_SOC_I2C:
753 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
754                 codec->hw_write = (hw_write_t)i2c_master_send;
755 #endif
756                 if (io_types[i].i2c_read)
757                         codec->hw_read = io_types[i].i2c_read;
758
759                 codec->control_data = container_of(codec->dev,
760                                                    struct i2c_client,
761                                                    dev);
762                 break;
763
764         case SND_SOC_SPI:
765                 if (io_types[i].spi_write)
766                         codec->hw_write = io_types[i].spi_write;
767
768                 codec->control_data = container_of(codec->dev,
769                                                    struct spi_device,
770                                                    dev);
771                 break;
772         }
773
774         return 0;
775 }
776 EXPORT_SYMBOL_GPL(snd_soc_codec_set_cache_io);
777
778 static bool snd_soc_set_cache_val(void *base, unsigned int idx,
779                                   unsigned int val, unsigned int word_size)
780 {
781         switch (word_size) {
782         case 1: {
783                 u8 *cache = base;
784                 if (cache[idx] == val)
785                         return true;
786                 cache[idx] = val;
787                 break;
788         }
789         case 2: {
790                 u16 *cache = base;
791                 if (cache[idx] == val)
792                         return true;
793                 cache[idx] = val;
794                 break;
795         }
796         default:
797                 BUG();
798         }
799         return false;
800 }
801
802 static unsigned int snd_soc_get_cache_val(const void *base, unsigned int idx,
803                 unsigned int word_size)
804 {
805         switch (word_size) {
806         case 1: {
807                 const u8 *cache = base;
808                 return cache[idx];
809         }
810         case 2: {
811                 const u16 *cache = base;
812                 return cache[idx];
813         }
814         default:
815                 BUG();
816         }
817         /* unreachable */
818         return -1;
819 }
820
821 struct snd_soc_rbtree_node {
822         struct rb_node node;
823         unsigned int reg;
824         unsigned int value;
825         unsigned int defval;
826 } __attribute__ ((packed));
827
828 struct snd_soc_rbtree_ctx {
829         struct rb_root root;
830 };
831
832 static struct snd_soc_rbtree_node *snd_soc_rbtree_lookup(
833         struct rb_root *root, unsigned int reg)
834 {
835         struct rb_node *node;
836         struct snd_soc_rbtree_node *rbnode;
837
838         node = root->rb_node;
839         while (node) {
840                 rbnode = container_of(node, struct snd_soc_rbtree_node, node);
841                 if (rbnode->reg < reg)
842                         node = node->rb_left;
843                 else if (rbnode->reg > reg)
844                         node = node->rb_right;
845                 else
846                         return rbnode;
847         }
848
849         return NULL;
850 }
851
852 static int snd_soc_rbtree_insert(struct rb_root *root,
853                                  struct snd_soc_rbtree_node *rbnode)
854 {
855         struct rb_node **new, *parent;
856         struct snd_soc_rbtree_node *rbnode_tmp;
857
858         parent = NULL;
859         new = &root->rb_node;
860         while (*new) {
861                 rbnode_tmp = container_of(*new, struct snd_soc_rbtree_node,
862                                           node);
863                 parent = *new;
864                 if (rbnode_tmp->reg < rbnode->reg)
865                         new = &((*new)->rb_left);
866                 else if (rbnode_tmp->reg > rbnode->reg)
867                         new = &((*new)->rb_right);
868                 else
869                         return 0;
870         }
871
872         /* insert the node into the rbtree */
873         rb_link_node(&rbnode->node, parent, new);
874         rb_insert_color(&rbnode->node, root);
875
876         return 1;
877 }
878
879 static int snd_soc_rbtree_cache_sync(struct snd_soc_codec *codec)
880 {
881         struct snd_soc_rbtree_ctx *rbtree_ctx;
882         struct rb_node *node;
883         struct snd_soc_rbtree_node *rbnode;
884         unsigned int val;
885         int ret;
886
887         rbtree_ctx = codec->reg_cache;
888         for (node = rb_first(&rbtree_ctx->root); node; node = rb_next(node)) {
889                 rbnode = rb_entry(node, struct snd_soc_rbtree_node, node);
890                 if (rbnode->value == rbnode->defval)
891                         continue;
892                 ret = snd_soc_cache_read(codec, rbnode->reg, &val);
893                 if (ret)
894                         return ret;
895                 codec->cache_bypass = 1;
896                 ret = snd_soc_write(codec, rbnode->reg, val);
897                 codec->cache_bypass = 0;
898                 if (ret)
899                         return ret;
900                 dev_dbg(codec->dev, "Synced register %#x, value = %#x\n",
901                         rbnode->reg, val);
902         }
903
904         return 0;
905 }
906
907 static int snd_soc_rbtree_cache_write(struct snd_soc_codec *codec,
908                                       unsigned int reg, unsigned int value)
909 {
910         struct snd_soc_rbtree_ctx *rbtree_ctx;
911         struct snd_soc_rbtree_node *rbnode;
912
913         rbtree_ctx = codec->reg_cache;
914         rbnode = snd_soc_rbtree_lookup(&rbtree_ctx->root, reg);
915         if (rbnode) {
916                 if (rbnode->value == value)
917                         return 0;
918                 rbnode->value = value;
919         } else {
920                 /* bail out early, no need to create the rbnode yet */
921                 if (!value)
922                         return 0;
923                 /*
924                  * for uninitialized registers whose value is changed
925                  * from the default zero, create an rbnode and insert
926                  * it into the tree.
927                  */
928                 rbnode = kzalloc(sizeof *rbnode, GFP_KERNEL);
929                 if (!rbnode)
930                         return -ENOMEM;
931                 rbnode->reg = reg;
932                 rbnode->value = value;
933                 snd_soc_rbtree_insert(&rbtree_ctx->root, rbnode);
934         }
935
936         return 0;
937 }
938
939 static int snd_soc_rbtree_cache_read(struct snd_soc_codec *codec,
940                                      unsigned int reg, unsigned int *value)
941 {
942         struct snd_soc_rbtree_ctx *rbtree_ctx;
943         struct snd_soc_rbtree_node *rbnode;
944
945         rbtree_ctx = codec->reg_cache;
946         rbnode = snd_soc_rbtree_lookup(&rbtree_ctx->root, reg);
947         if (rbnode) {
948                 *value = rbnode->value;
949         } else {
950                 /* uninitialized registers default to 0 */
951                 *value = 0;
952         }
953
954         return 0;
955 }
956
957 static int snd_soc_rbtree_cache_exit(struct snd_soc_codec *codec)
958 {
959         struct rb_node *next;
960         struct snd_soc_rbtree_ctx *rbtree_ctx;
961         struct snd_soc_rbtree_node *rbtree_node;
962
963         /* if we've already been called then just return */
964         rbtree_ctx = codec->reg_cache;
965         if (!rbtree_ctx)
966                 return 0;
967
968         /* free up the rbtree */
969         next = rb_first(&rbtree_ctx->root);
970         while (next) {
971                 rbtree_node = rb_entry(next, struct snd_soc_rbtree_node, node);
972                 next = rb_next(&rbtree_node->node);
973                 rb_erase(&rbtree_node->node, &rbtree_ctx->root);
974                 kfree(rbtree_node);
975         }
976
977         /* release the resources */
978         kfree(codec->reg_cache);
979         codec->reg_cache = NULL;
980
981         return 0;
982 }
983
984 static int snd_soc_rbtree_cache_init(struct snd_soc_codec *codec)
985 {
986         struct snd_soc_rbtree_node *rbtree_node;
987         struct snd_soc_rbtree_ctx *rbtree_ctx;
988         unsigned int val;
989         unsigned int word_size;
990         int i;
991         int ret;
992
993         codec->reg_cache = kmalloc(sizeof *rbtree_ctx, GFP_KERNEL);
994         if (!codec->reg_cache)
995                 return -ENOMEM;
996
997         rbtree_ctx = codec->reg_cache;
998         rbtree_ctx->root = RB_ROOT;
999
1000         if (!codec->reg_def_copy)
1001                 return 0;
1002
1003         /*
1004          * populate the rbtree with the initialized registers.  All other
1005          * registers will be inserted when they are first modified.
1006          */
1007         word_size = codec->driver->reg_word_size;
1008         for (i = 0; i < codec->driver->reg_cache_size; ++i) {
1009                 val = snd_soc_get_cache_val(codec->reg_def_copy, i, word_size);
1010                 if (!val)
1011                         continue;
1012                 rbtree_node = kzalloc(sizeof *rbtree_node, GFP_KERNEL);
1013                 if (!rbtree_node) {
1014                         ret = -ENOMEM;
1015                         snd_soc_cache_exit(codec);
1016                         break;
1017                 }
1018                 rbtree_node->reg = i;
1019                 rbtree_node->value = val;
1020                 rbtree_node->defval = val;
1021                 snd_soc_rbtree_insert(&rbtree_ctx->root, rbtree_node);
1022         }
1023
1024         return 0;
1025 }
1026
1027 #ifdef CONFIG_SND_SOC_CACHE_LZO
1028 struct snd_soc_lzo_ctx {
1029         void *wmem;
1030         void *dst;
1031         const void *src;
1032         size_t src_len;
1033         size_t dst_len;
1034         size_t decompressed_size;
1035         unsigned long *sync_bmp;
1036         int sync_bmp_nbits;
1037 };
1038
1039 #define LZO_BLOCK_NUM 8
1040 static int snd_soc_lzo_block_count(void)
1041 {
1042         return LZO_BLOCK_NUM;
1043 }
1044
1045 static int snd_soc_lzo_prepare(struct snd_soc_lzo_ctx *lzo_ctx)
1046 {
1047         lzo_ctx->wmem = kmalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL);
1048         if (!lzo_ctx->wmem)
1049                 return -ENOMEM;
1050         return 0;
1051 }
1052
1053 static int snd_soc_lzo_compress(struct snd_soc_lzo_ctx *lzo_ctx)
1054 {
1055         size_t compress_size;
1056         int ret;
1057
1058         ret = lzo1x_1_compress(lzo_ctx->src, lzo_ctx->src_len,
1059                                lzo_ctx->dst, &compress_size, lzo_ctx->wmem);
1060         if (ret != LZO_E_OK || compress_size > lzo_ctx->dst_len)
1061                 return -EINVAL;
1062         lzo_ctx->dst_len = compress_size;
1063         return 0;
1064 }
1065
1066 static int snd_soc_lzo_decompress(struct snd_soc_lzo_ctx *lzo_ctx)
1067 {
1068         size_t dst_len;
1069         int ret;
1070
1071         dst_len = lzo_ctx->dst_len;
1072         ret = lzo1x_decompress_safe(lzo_ctx->src, lzo_ctx->src_len,
1073                                     lzo_ctx->dst, &dst_len);
1074         if (ret != LZO_E_OK || dst_len != lzo_ctx->dst_len)
1075                 return -EINVAL;
1076         return 0;
1077 }
1078
1079 static int snd_soc_lzo_compress_cache_block(struct snd_soc_codec *codec,
1080                 struct snd_soc_lzo_ctx *lzo_ctx)
1081 {
1082         int ret;
1083
1084         lzo_ctx->dst_len = lzo1x_worst_compress(PAGE_SIZE);
1085         lzo_ctx->dst = kmalloc(lzo_ctx->dst_len, GFP_KERNEL);
1086         if (!lzo_ctx->dst) {
1087                 lzo_ctx->dst_len = 0;
1088                 return -ENOMEM;
1089         }
1090
1091         ret = snd_soc_lzo_compress(lzo_ctx);
1092         if (ret < 0)
1093                 return ret;
1094         return 0;
1095 }
1096
1097 static int snd_soc_lzo_decompress_cache_block(struct snd_soc_codec *codec,
1098                 struct snd_soc_lzo_ctx *lzo_ctx)
1099 {
1100         int ret;
1101
1102         lzo_ctx->dst_len = lzo_ctx->decompressed_size;
1103         lzo_ctx->dst = kmalloc(lzo_ctx->dst_len, GFP_KERNEL);
1104         if (!lzo_ctx->dst) {
1105                 lzo_ctx->dst_len = 0;
1106                 return -ENOMEM;
1107         }
1108
1109         ret = snd_soc_lzo_decompress(lzo_ctx);
1110         if (ret < 0)
1111                 return ret;
1112         return 0;
1113 }
1114
1115 static inline int snd_soc_lzo_get_blkindex(struct snd_soc_codec *codec,
1116                 unsigned int reg)
1117 {
1118         const struct snd_soc_codec_driver *codec_drv;
1119
1120         codec_drv = codec->driver;
1121         return (reg * codec_drv->reg_word_size) /
1122                DIV_ROUND_UP(codec->reg_size, snd_soc_lzo_block_count());
1123 }
1124
1125 static inline int snd_soc_lzo_get_blkpos(struct snd_soc_codec *codec,
1126                 unsigned int reg)
1127 {
1128         const struct snd_soc_codec_driver *codec_drv;
1129
1130         codec_drv = codec->driver;
1131         return reg % (DIV_ROUND_UP(codec->reg_size, snd_soc_lzo_block_count()) /
1132                       codec_drv->reg_word_size);
1133 }
1134
1135 static inline int snd_soc_lzo_get_blksize(struct snd_soc_codec *codec)
1136 {
1137         const struct snd_soc_codec_driver *codec_drv;
1138
1139         codec_drv = codec->driver;
1140         return DIV_ROUND_UP(codec->reg_size, snd_soc_lzo_block_count());
1141 }
1142
1143 static int snd_soc_lzo_cache_sync(struct snd_soc_codec *codec)
1144 {
1145         struct snd_soc_lzo_ctx **lzo_blocks;
1146         unsigned int val;
1147         int i;
1148         int ret;
1149
1150         lzo_blocks = codec->reg_cache;
1151         for_each_set_bit(i, lzo_blocks[0]->sync_bmp, lzo_blocks[0]->sync_bmp_nbits) {
1152                 ret = snd_soc_cache_read(codec, i, &val);
1153                 if (ret)
1154                         return ret;
1155                 codec->cache_bypass = 1;
1156                 ret = snd_soc_write(codec, i, val);
1157                 codec->cache_bypass = 0;
1158                 if (ret)
1159                         return ret;
1160                 dev_dbg(codec->dev, "Synced register %#x, value = %#x\n",
1161                         i, val);
1162         }
1163
1164         return 0;
1165 }
1166
1167 static int snd_soc_lzo_cache_write(struct snd_soc_codec *codec,
1168                                    unsigned int reg, unsigned int value)
1169 {
1170         struct snd_soc_lzo_ctx *lzo_block, **lzo_blocks;
1171         int ret, blkindex, blkpos;
1172         size_t blksize, tmp_dst_len;
1173         void *tmp_dst;
1174
1175         /* index of the compressed lzo block */
1176         blkindex = snd_soc_lzo_get_blkindex(codec, reg);
1177         /* register index within the decompressed block */
1178         blkpos = snd_soc_lzo_get_blkpos(codec, reg);
1179         /* size of the compressed block */
1180         blksize = snd_soc_lzo_get_blksize(codec);
1181         lzo_blocks = codec->reg_cache;
1182         lzo_block = lzo_blocks[blkindex];
1183
1184         /* save the pointer and length of the compressed block */
1185         tmp_dst = lzo_block->dst;
1186         tmp_dst_len = lzo_block->dst_len;
1187
1188         /* prepare the source to be the compressed block */
1189         lzo_block->src = lzo_block->dst;
1190         lzo_block->src_len = lzo_block->dst_len;
1191
1192         /* decompress the block */
1193         ret = snd_soc_lzo_decompress_cache_block(codec, lzo_block);
1194         if (ret < 0) {
1195                 kfree(lzo_block->dst);
1196                 goto out;
1197         }
1198
1199         /* write the new value to the cache */
1200         if (snd_soc_set_cache_val(lzo_block->dst, blkpos, value,
1201                                   codec->driver->reg_word_size)) {
1202                 kfree(lzo_block->dst);
1203                 goto out;
1204         }
1205
1206         /* prepare the source to be the decompressed block */
1207         lzo_block->src = lzo_block->dst;
1208         lzo_block->src_len = lzo_block->dst_len;
1209
1210         /* compress the block */
1211         ret = snd_soc_lzo_compress_cache_block(codec, lzo_block);
1212         if (ret < 0) {
1213                 kfree(lzo_block->dst);
1214                 kfree(lzo_block->src);
1215                 goto out;
1216         }
1217
1218         /* set the bit so we know we have to sync this register */
1219         set_bit(reg, lzo_block->sync_bmp);
1220         kfree(tmp_dst);
1221         kfree(lzo_block->src);
1222         return 0;
1223 out:
1224         lzo_block->dst = tmp_dst;
1225         lzo_block->dst_len = tmp_dst_len;
1226         return ret;
1227 }
1228
1229 static int snd_soc_lzo_cache_read(struct snd_soc_codec *codec,
1230                                   unsigned int reg, unsigned int *value)
1231 {
1232         struct snd_soc_lzo_ctx *lzo_block, **lzo_blocks;
1233         int ret, blkindex, blkpos;
1234         size_t blksize, tmp_dst_len;
1235         void *tmp_dst;
1236
1237         *value = 0;
1238         /* index of the compressed lzo block */
1239         blkindex = snd_soc_lzo_get_blkindex(codec, reg);
1240         /* register index within the decompressed block */
1241         blkpos = snd_soc_lzo_get_blkpos(codec, reg);
1242         /* size of the compressed block */
1243         blksize = snd_soc_lzo_get_blksize(codec);
1244         lzo_blocks = codec->reg_cache;
1245         lzo_block = lzo_blocks[blkindex];
1246
1247         /* save the pointer and length of the compressed block */
1248         tmp_dst = lzo_block->dst;
1249         tmp_dst_len = lzo_block->dst_len;
1250
1251         /* prepare the source to be the compressed block */
1252         lzo_block->src = lzo_block->dst;
1253         lzo_block->src_len = lzo_block->dst_len;
1254
1255         /* decompress the block */
1256         ret = snd_soc_lzo_decompress_cache_block(codec, lzo_block);
1257         if (ret >= 0)
1258                 /* fetch the value from the cache */
1259                 *value = snd_soc_get_cache_val(lzo_block->dst, blkpos,
1260                                                codec->driver->reg_word_size);
1261
1262         kfree(lzo_block->dst);
1263         /* restore the pointer and length of the compressed block */
1264         lzo_block->dst = tmp_dst;
1265         lzo_block->dst_len = tmp_dst_len;
1266         return 0;
1267 }
1268
1269 static int snd_soc_lzo_cache_exit(struct snd_soc_codec *codec)
1270 {
1271         struct snd_soc_lzo_ctx **lzo_blocks;
1272         int i, blkcount;
1273
1274         lzo_blocks = codec->reg_cache;
1275         if (!lzo_blocks)
1276                 return 0;
1277
1278         blkcount = snd_soc_lzo_block_count();
1279         /*
1280          * the pointer to the bitmap used for syncing the cache
1281          * is shared amongst all lzo_blocks.  Ensure it is freed
1282          * only once.
1283          */
1284         if (lzo_blocks[0])
1285                 kfree(lzo_blocks[0]->sync_bmp);
1286         for (i = 0; i < blkcount; ++i) {
1287                 if (lzo_blocks[i]) {
1288                         kfree(lzo_blocks[i]->wmem);
1289                         kfree(lzo_blocks[i]->dst);
1290                 }
1291                 /* each lzo_block is a pointer returned by kmalloc or NULL */
1292                 kfree(lzo_blocks[i]);
1293         }
1294         kfree(lzo_blocks);
1295         codec->reg_cache = NULL;
1296         return 0;
1297 }
1298
1299 static int snd_soc_lzo_cache_init(struct snd_soc_codec *codec)
1300 {
1301         struct snd_soc_lzo_ctx **lzo_blocks;
1302         size_t bmp_size;
1303         const struct snd_soc_codec_driver *codec_drv;
1304         int ret, tofree, i, blksize, blkcount;
1305         const char *p, *end;
1306         unsigned long *sync_bmp;
1307
1308         ret = 0;
1309         codec_drv = codec->driver;
1310
1311         /*
1312          * If we have not been given a default register cache
1313          * then allocate a dummy zero-ed out region, compress it
1314          * and remember to free it afterwards.
1315          */
1316         tofree = 0;
1317         if (!codec->reg_def_copy)
1318                 tofree = 1;
1319
1320         if (!codec->reg_def_copy) {
1321                 codec->reg_def_copy = kzalloc(codec->reg_size, GFP_KERNEL);
1322                 if (!codec->reg_def_copy)
1323                         return -ENOMEM;
1324         }
1325
1326         blkcount = snd_soc_lzo_block_count();
1327         codec->reg_cache = kzalloc(blkcount * sizeof *lzo_blocks,
1328                                    GFP_KERNEL);
1329         if (!codec->reg_cache) {
1330                 ret = -ENOMEM;
1331                 goto err_tofree;
1332         }
1333         lzo_blocks = codec->reg_cache;
1334
1335         /*
1336          * allocate a bitmap to be used when syncing the cache with
1337          * the hardware.  Each time a register is modified, the corresponding
1338          * bit is set in the bitmap, so we know that we have to sync
1339          * that register.
1340          */
1341         bmp_size = codec_drv->reg_cache_size;
1342         sync_bmp = kmalloc(BITS_TO_LONGS(bmp_size) * sizeof(long),
1343                            GFP_KERNEL);
1344         if (!sync_bmp) {
1345                 ret = -ENOMEM;
1346                 goto err;
1347         }
1348         bitmap_zero(sync_bmp, bmp_size);
1349
1350         /* allocate the lzo blocks and initialize them */
1351         for (i = 0; i < blkcount; ++i) {
1352                 lzo_blocks[i] = kzalloc(sizeof **lzo_blocks,
1353                                         GFP_KERNEL);
1354                 if (!lzo_blocks[i]) {
1355                         kfree(sync_bmp);
1356                         ret = -ENOMEM;
1357                         goto err;
1358                 }
1359                 lzo_blocks[i]->sync_bmp = sync_bmp;
1360                 lzo_blocks[i]->sync_bmp_nbits = bmp_size;
1361                 /* alloc the working space for the compressed block */
1362                 ret = snd_soc_lzo_prepare(lzo_blocks[i]);
1363                 if (ret < 0)
1364                         goto err;
1365         }
1366
1367         blksize = snd_soc_lzo_get_blksize(codec);
1368         p = codec->reg_def_copy;
1369         end = codec->reg_def_copy + codec->reg_size;
1370         /* compress the register map and fill the lzo blocks */
1371         for (i = 0; i < blkcount; ++i, p += blksize) {
1372                 lzo_blocks[i]->src = p;
1373                 if (p + blksize > end)
1374                         lzo_blocks[i]->src_len = end - p;
1375                 else
1376                         lzo_blocks[i]->src_len = blksize;
1377                 ret = snd_soc_lzo_compress_cache_block(codec,
1378                                                        lzo_blocks[i]);
1379                 if (ret < 0)
1380                         goto err;
1381                 lzo_blocks[i]->decompressed_size =
1382                         lzo_blocks[i]->src_len;
1383         }
1384
1385         if (tofree) {
1386                 kfree(codec->reg_def_copy);
1387                 codec->reg_def_copy = NULL;
1388         }
1389         return 0;
1390 err:
1391         snd_soc_cache_exit(codec);
1392 err_tofree:
1393         if (tofree) {
1394                 kfree(codec->reg_def_copy);
1395                 codec->reg_def_copy = NULL;
1396         }
1397         return ret;
1398 }
1399 #endif
1400
1401 static int snd_soc_flat_cache_sync(struct snd_soc_codec *codec)
1402 {
1403         int i;
1404         int ret;
1405         const struct snd_soc_codec_driver *codec_drv;
1406         unsigned int val;
1407
1408         codec_drv = codec->driver;
1409         for (i = 0; i < codec_drv->reg_cache_size; ++i) {
1410                 ret = snd_soc_cache_read(codec, i, &val);
1411                 if (ret)
1412                         return ret;
1413                 if (codec->reg_def_copy)
1414                         if (snd_soc_get_cache_val(codec->reg_def_copy,
1415                                                   i, codec_drv->reg_word_size) == val)
1416                                 continue;
1417                 ret = snd_soc_write(codec, i, val);
1418                 if (ret)
1419                         return ret;
1420                 dev_dbg(codec->dev, "Synced register %#x, value = %#x\n",
1421                         i, val);
1422         }
1423         return 0;
1424 }
1425
1426 static int snd_soc_flat_cache_write(struct snd_soc_codec *codec,
1427                                     unsigned int reg, unsigned int value)
1428 {
1429         snd_soc_set_cache_val(codec->reg_cache, reg, value,
1430                               codec->driver->reg_word_size);
1431         return 0;
1432 }
1433
1434 static int snd_soc_flat_cache_read(struct snd_soc_codec *codec,
1435                                    unsigned int reg, unsigned int *value)
1436 {
1437         *value = snd_soc_get_cache_val(codec->reg_cache, reg,
1438                                        codec->driver->reg_word_size);
1439         return 0;
1440 }
1441
1442 static int snd_soc_flat_cache_exit(struct snd_soc_codec *codec)
1443 {
1444         if (!codec->reg_cache)
1445                 return 0;
1446         kfree(codec->reg_cache);
1447         codec->reg_cache = NULL;
1448         return 0;
1449 }
1450
1451 static int snd_soc_flat_cache_init(struct snd_soc_codec *codec)
1452 {
1453         const struct snd_soc_codec_driver *codec_drv;
1454
1455         codec_drv = codec->driver;
1456
1457         if (codec->reg_def_copy)
1458                 codec->reg_cache = kmemdup(codec->reg_def_copy,
1459                                            codec->reg_size, GFP_KERNEL);
1460         else
1461                 codec->reg_cache = kzalloc(codec->reg_size, GFP_KERNEL);
1462         if (!codec->reg_cache)
1463                 return -ENOMEM;
1464
1465         return 0;
1466 }
1467
1468 /* an array of all supported compression types */
1469 static const struct snd_soc_cache_ops cache_types[] = {
1470         /* Flat *must* be the first entry for fallback */
1471         {
1472                 .id = SND_SOC_FLAT_COMPRESSION,
1473                 .name = "flat",
1474                 .init = snd_soc_flat_cache_init,
1475                 .exit = snd_soc_flat_cache_exit,
1476                 .read = snd_soc_flat_cache_read,
1477                 .write = snd_soc_flat_cache_write,
1478                 .sync = snd_soc_flat_cache_sync
1479         },
1480 #ifdef CONFIG_SND_SOC_CACHE_LZO
1481         {
1482                 .id = SND_SOC_LZO_COMPRESSION,
1483                 .name = "LZO",
1484                 .init = snd_soc_lzo_cache_init,
1485                 .exit = snd_soc_lzo_cache_exit,
1486                 .read = snd_soc_lzo_cache_read,
1487                 .write = snd_soc_lzo_cache_write,
1488                 .sync = snd_soc_lzo_cache_sync
1489         },
1490 #endif
1491         {
1492                 .id = SND_SOC_RBTREE_COMPRESSION,
1493                 .name = "rbtree",
1494                 .init = snd_soc_rbtree_cache_init,
1495                 .exit = snd_soc_rbtree_cache_exit,
1496                 .read = snd_soc_rbtree_cache_read,
1497                 .write = snd_soc_rbtree_cache_write,
1498                 .sync = snd_soc_rbtree_cache_sync
1499         }
1500 };
1501
1502 int snd_soc_cache_init(struct snd_soc_codec *codec)
1503 {
1504         int i;
1505
1506         for (i = 0; i < ARRAY_SIZE(cache_types); ++i)
1507                 if (cache_types[i].id == codec->compress_type)
1508                         break;
1509
1510         /* Fall back to flat compression */
1511         if (i == ARRAY_SIZE(cache_types)) {
1512                 dev_warn(codec->dev, "Could not match compress type: %d\n",
1513                          codec->compress_type);
1514                 i = 0;
1515         }
1516
1517         mutex_init(&codec->cache_rw_mutex);
1518         codec->cache_ops = &cache_types[i];
1519
1520         if (codec->cache_ops->init) {
1521                 if (codec->cache_ops->name)
1522                         dev_dbg(codec->dev, "Initializing %s cache for %s codec\n",
1523                                 codec->cache_ops->name, codec->name);
1524                 return codec->cache_ops->init(codec);
1525         }
1526         return -EINVAL;
1527 }
1528
1529 /*
1530  * NOTE: keep in mind that this function might be called
1531  * multiple times.
1532  */
1533 int snd_soc_cache_exit(struct snd_soc_codec *codec)
1534 {
1535         if (codec->cache_ops && codec->cache_ops->exit) {
1536                 if (codec->cache_ops->name)
1537                         dev_dbg(codec->dev, "Destroying %s cache for %s codec\n",
1538                                 codec->cache_ops->name, codec->name);
1539                 return codec->cache_ops->exit(codec);
1540         }
1541         return -EINVAL;
1542 }
1543
1544 /**
1545  * snd_soc_cache_read: Fetch the value of a given register from the cache.
1546  *
1547  * @codec: CODEC to configure.
1548  * @reg: The register index.
1549  * @value: The value to be returned.
1550  */
1551 int snd_soc_cache_read(struct snd_soc_codec *codec,
1552                        unsigned int reg, unsigned int *value)
1553 {
1554         int ret;
1555
1556         mutex_lock(&codec->cache_rw_mutex);
1557
1558         if (value && codec->cache_ops && codec->cache_ops->read) {
1559                 ret = codec->cache_ops->read(codec, reg, value);
1560                 mutex_unlock(&codec->cache_rw_mutex);
1561                 return ret;
1562         }
1563
1564         mutex_unlock(&codec->cache_rw_mutex);
1565         return -EINVAL;
1566 }
1567 EXPORT_SYMBOL_GPL(snd_soc_cache_read);
1568
1569 /**
1570  * snd_soc_cache_write: Set the value of a given register in the cache.
1571  *
1572  * @codec: CODEC to configure.
1573  * @reg: The register index.
1574  * @value: The new register value.
1575  */
1576 int snd_soc_cache_write(struct snd_soc_codec *codec,
1577                         unsigned int reg, unsigned int value)
1578 {
1579         int ret;
1580
1581         mutex_lock(&codec->cache_rw_mutex);
1582
1583         if (codec->cache_ops && codec->cache_ops->write) {
1584                 ret = codec->cache_ops->write(codec, reg, value);
1585                 mutex_unlock(&codec->cache_rw_mutex);
1586                 return ret;
1587         }
1588
1589         mutex_unlock(&codec->cache_rw_mutex);
1590         return -EINVAL;
1591 }
1592 EXPORT_SYMBOL_GPL(snd_soc_cache_write);
1593
1594 /**
1595  * snd_soc_cache_sync: Sync the register cache with the hardware.
1596  *
1597  * @codec: CODEC to configure.
1598  *
1599  * Any registers that should not be synced should be marked as
1600  * volatile.  In general drivers can choose not to use the provided
1601  * syncing functionality if they so require.
1602  */
1603 int snd_soc_cache_sync(struct snd_soc_codec *codec)
1604 {
1605         int ret;
1606         const char *name;
1607
1608         if (!codec->cache_sync) {
1609                 return 0;
1610         }
1611
1612         if (codec->cache_ops->name)
1613                 name = codec->cache_ops->name;
1614         else
1615                 name = "unknown";
1616
1617         if (codec->cache_ops && codec->cache_ops->sync) {
1618                 if (codec->cache_ops->name)
1619                         dev_dbg(codec->dev, "Syncing %s cache for %s codec\n",
1620                                 codec->cache_ops->name, codec->name);
1621                 trace_snd_soc_cache_sync(codec, name, "start");
1622                 ret = codec->cache_ops->sync(codec);
1623                 if (!ret)
1624                         codec->cache_sync = 0;
1625                 trace_snd_soc_cache_sync(codec, name, "end");
1626                 return ret;
1627         }
1628
1629         return -EINVAL;
1630 }
1631 EXPORT_SYMBOL_GPL(snd_soc_cache_sync);
1632
1633 static int snd_soc_get_reg_access_index(struct snd_soc_codec *codec,
1634                                         unsigned int reg)
1635 {
1636         const struct snd_soc_codec_driver *codec_drv;
1637         unsigned int min, max, index;
1638
1639         codec_drv = codec->driver;
1640         min = 0;
1641         max = codec_drv->reg_access_size - 1;
1642         do {
1643                 index = (min + max) / 2;
1644                 if (codec_drv->reg_access_default[index].reg == reg)
1645                         return index;
1646                 if (codec_drv->reg_access_default[index].reg < reg)
1647                         min = index + 1;
1648                 else
1649                         max = index;
1650         } while (min <= max);
1651         return -1;
1652 }
1653
1654 int snd_soc_default_volatile_register(struct snd_soc_codec *codec,
1655                                       unsigned int reg)
1656 {
1657         int index;
1658
1659         if (reg >= codec->driver->reg_cache_size)
1660                 return 1;
1661         index = snd_soc_get_reg_access_index(codec, reg);
1662         if (index < 0)
1663                 return 0;
1664         return codec->driver->reg_access_default[index].vol;
1665 }
1666 EXPORT_SYMBOL_GPL(snd_soc_default_volatile_register);
1667
1668 int snd_soc_default_readable_register(struct snd_soc_codec *codec,
1669                                       unsigned int reg)
1670 {
1671         int index;
1672
1673         if (reg >= codec->driver->reg_cache_size)
1674                 return 1;
1675         index = snd_soc_get_reg_access_index(codec, reg);
1676         if (index < 0)
1677                 return 0;
1678         return codec->driver->reg_access_default[index].read;
1679 }
1680 EXPORT_SYMBOL_GPL(snd_soc_default_readable_register);