arm: tegra: roth: Reduce volume change clicks
[linux-2.6.git] / drivers / misc / tfa9887.c
1 #include <linux/kernel.h>
2 #include <linux/init.h>
3 #include <linux/err.h>
4 #include <linux/module.h>
5 #include <linux/interrupt.h>
6 #include <linux/i2c.h>
7 #include <linux/regmap.h>
8 #include <linux/tfa9887.h>
9 #include <sound/initval.h>
10 #include <linux/sysfs.h>
11 #include <linux/miscdevice.h>
12 #include <linux/delay.h>
13
14 #define STATUS_OK 0
15
16 void tegra_asoc_enable_clocks(void);
17 void tegra_asoc_disable_clocks(void);
18
19 static ssize_t tfa9887_cal_show(struct kobject *kobj,
20                 struct kobj_attribute *attr, char *buf);
21
22 static ssize_t tfa9887_cal_store(struct kobject *kobj,
23                 struct kobj_attribute *attr, const char *buf, size_t count);
24
25 static ssize_t tfa9887_config_show(struct kobject *kobj,
26                 struct kobj_attribute *attr, char *buf);
27
28 static ssize_t tfa9887_config_store(struct kobject *kobj,
29                 struct kobj_attribute *attr, const char *buf, size_t count);
30
31 static ssize_t tfa9887_vol_show(struct kobject *kobj,
32                 struct kobj_attribute *attr, char *buf);
33
34 static ssize_t tfa9887_vol_store(struct kobject *kobj,
35                 struct kobj_attribute *attr, const char *buf, size_t count);
36
37
38 static struct kobj_attribute tfa9887_config =
39                 __ATTR(config, 0640, tfa9887_config_show, tfa9887_config_store);
40
41 static struct kobj_attribute tfa9887_cal =
42                 __ATTR(cal, 0640, tfa9887_cal_show, tfa9887_cal_store);
43
44 static struct kobj_attribute tfa9887_vol =
45                 __ATTR(vol, 0640, tfa9887_vol_show, tfa9887_vol_store);
46
47 static struct kobject *tfa9887_kobj;
48
49 static struct tfa9887_priv *tfa9887R, *tfa9887L, *tfa9887R_byte, *tfa9887L_byte;
50
51 static int eq_mode, preset_mode, srate;
52
53 static char calibdata[16];
54
55 static int calibration_need = 0;
56
57 unsigned int volume_step[5] = {0,2,4,6,12};
58
59 /* begin binary data: */
60 unsigned char coldpatch_data[] = {/* 10 */
61 0x08, 0x00, 0x70, 0x00, 0x07, 0x81, 0x00, 0x00, 0x00, 0x01
62 };
63 /* end binary data. size = 10 bytes */
64
65 /* begin binary data: */
66
67 /* begin binary data: */
68 char n1d2_data[] = {/* 2380 */
69 0x03, 0x00, 0x70, 0x00, 0x01, 0xFB, 0x00, 0x71, 0x40
70 , 0x00, 0x38, 0x08, 0x0A, 0x6F, 0x9B, 0xA6, 0x7D, 0x04, 0xB0, 0xB6, 0x62, 0x88, 0x69, 0x7E
71 , 0xC4, 0x08, 0x6A, 0xBF, 0x54, 0xFC, 0xB5, 0x00, 0x58, 0x7F, 0x3B, 0x80, 0x01, 0x25, 0x30
72 , 0x50, 0x00, 0x80, 0x69, 0x5E, 0xD4, 0x3C, 0x3A, 0x90, 0x00, 0x0D, 0x72, 0x02, 0xC4, 0x80
73 , 0x6A, 0xBE, 0xD4, 0x3E, 0x30, 0x40, 0x00, 0x80, 0x3B, 0x80, 0x01, 0x00, 0xB0, 0xB2, 0xF6
74 , 0x48, 0x6A, 0x5E, 0x54, 0x3E, 0x3A, 0x80, 0x00, 0x80, 0x3B, 0x80, 0x01, 0x00, 0x9B, 0xA6
75 , 0xF8, 0x49, 0x39, 0x84, 0x80, 0x80, 0x92, 0x19, 0xFE, 0x9C, 0x3B, 0x62, 0x40, 0x1C, 0x9B
76 , 0x84, 0x54, 0x3D, 0x61, 0x40, 0x7E, 0x9C, 0x3B, 0x80, 0x07, 0xF1, 0xA6, 0xB6, 0x7E, 0x9C
77 , 0x3B, 0x00, 0x40, 0x21, 0xB5, 0x00, 0x58, 0x3F, 0x3B, 0x80, 0x08, 0x00, 0x9B, 0xA4, 0x7E
78 , 0x9C, 0x9B, 0xA4, 0x54, 0x3D, 0xA5, 0xB2, 0xD8, 0x3F, 0xB5, 0x00, 0x42, 0xC0, 0x3C, 0xD8
79 , 0x03, 0x00, 0x8B, 0x80, 0x7D, 0x7C, 0xB5, 0x00, 0x7E, 0x9C, 0x9B, 0x86, 0x7D, 0x04, 0x38
80 , 0x0A, 0x0A, 0x6F, 0xB0, 0xB2, 0xD4, 0x7E, 0x6A, 0x7E, 0x52, 0xFD, 0x71, 0x04, 0xD8, 0x7F
81 , 0x3B, 0x80, 0x01, 0x25, 0x30, 0x50, 0x00, 0x80, 0x69, 0x5E, 0xD5, 0x3E, 0x72, 0x02, 0xC4
82 , 0x11, 0x6A, 0xBE, 0xD4, 0xBC, 0x30, 0x40, 0x00, 0x80, 0x3B, 0x80, 0x01, 0x00, 0xB0, 0xB2
83 , 0xF6, 0x00, 0xB5, 0x00, 0x54, 0x3C, 0x3A, 0x88, 0x00, 0x80, 0xB5, 0x00, 0x54, 0x3D, 0x3B
84 , 0x80, 0x01, 0x00, 0x9B, 0xA6, 0xFE, 0x9C, 0xB5, 0x00, 0x58, 0x3F, 0x3C, 0xD8, 0x03, 0x00
85 , 0x8B, 0x80, 0x7D, 0x7C, 0xB5, 0x00, 0x7E, 0x9C, 0x3A, 0x88, 0x00, 0x0A, 0x9B, 0x8C, 0x42
86 , 0x88, 0xA6, 0x56, 0x7D, 0x05, 0x39, 0x02, 0x22, 0x20, 0xFB, 0x00, 0x71, 0x40, 0x3E, 0xAA
87 , 0x08, 0xC4, 0x00, 0x3A, 0x89, 0x00, 0xA6, 0xBA, 0x41, 0x58, 0x7B, 0xB5, 0x00, 0x5C, 0x7D
88 , 0x3B, 0x80, 0x13, 0x20, 0xBA, 0x20, 0xDA, 0x7C, 0x6D, 0x5E, 0x50, 0xBD, 0x3A, 0x91, 0x00
89 , 0x18, 0x82, 0x04, 0x7E, 0x50, 0x3A, 0x80, 0x00, 0x29, 0x3A, 0x9A, 0xFF, 0xFA, 0x38, 0x08
90 , 0x0B, 0x68, 0x38, 0x0C, 0x0B, 0x6D, 0xBF, 0x10, 0x42, 0x40, 0x38, 0x0D, 0x0B, 0x6A, 0xBB
91 , 0x00, 0x4C, 0x98, 0x6A, 0x3E, 0xD5, 0xFC, 0x31, 0x80, 0x20, 0xAF, 0x3B, 0x80, 0x01, 0x07
92 , 0x9B, 0xA2, 0xCA, 0x48, 0x7F, 0x4E, 0x54, 0xBC, 0xB5, 0x00, 0x4C, 0x88, 0x3A, 0x91, 0xFF
93 , 0x43, 0xB5, 0x00, 0x42, 0x90, 0x96, 0xF4, 0xD5, 0x3D, 0x3A, 0x81, 0xFF, 0x41, 0x61, 0x48
94 , 0xFD, 0xA9, 0x3A, 0x88, 0x00, 0xAF, 0x61, 0x8A, 0x72, 0xE8, 0x6A, 0x7E, 0xC4, 0x00, 0x30
95 , 0x40, 0x00, 0x80, 0x30, 0x70, 0x02, 0xBC, 0x3B, 0x80, 0x1C, 0x5A, 0xB5, 0x00, 0x55, 0x7C
96 , 0xB5, 0x00, 0x54, 0x3D, 0x3A, 0x88, 0x00, 0x0F, 0x62, 0x24, 0x44, 0x0A, 0x3A, 0x91, 0xFF
97 , 0x4F, 0x30, 0x50, 0x00, 0x80, 0x3B, 0x80, 0x01, 0x25, 0xB5, 0x00, 0x55, 0x7D, 0x6A, 0xDE
98 , 0x54, 0xBD, 0x3A, 0x81, 0xFF, 0xF3, 0x72, 0x22, 0xC2, 0x84, 0x30, 0xA0, 0x0A, 0x70, 0x61
99 , 0x04, 0x42, 0x98, 0x7F, 0x2C, 0x76, 0x91, 0x38, 0x0C, 0x22, 0x08, 0x60, 0x08, 0x43, 0x48
100 , 0x69, 0x3F, 0x54, 0x7D, 0xB5, 0x00, 0x52, 0xFF, 0x3B, 0x80, 0x1B, 0x5B, 0x38, 0x01, 0x0A
101 , 0x6F, 0x30, 0x00, 0x00, 0x20, 0xB9, 0x00, 0x54, 0x3D, 0x9B, 0x2B, 0x55, 0x3C, 0xB0, 0x04
102 , 0x52, 0xBE, 0x38, 0x08, 0x22, 0x01, 0xA6, 0xD0, 0x52, 0x3F, 0x3A, 0x80, 0x00, 0x0F, 0x8B
103 , 0x80, 0x42, 0x50, 0x9B, 0xA2, 0x42, 0xC0, 0xFB, 0x00, 0x71, 0x40, 0x7C, 0x3A, 0x88, 0x00
104 , 0xB4, 0xB5, 0x00, 0x53, 0x7C, 0x31, 0x1F, 0xFF, 0xE9, 0x69, 0x3F, 0x44, 0x0D, 0x3B, 0x80
105 , 0x01, 0x25, 0xB5, 0x00, 0x54, 0xFD, 0x7F, 0x4E, 0x54, 0x3D, 0xB5, 0x00, 0x44, 0x00, 0x3B
106 , 0x80, 0x01, 0x25, 0x9B, 0xA7, 0x7E, 0x9C, 0x7D, 0x8C, 0x54, 0x3D, 0x7C, 0x24, 0xC4, 0x85
107 , 0x6A, 0x3E, 0xD2, 0xBC, 0x61, 0x64, 0x44, 0x00, 0x3B, 0x80, 0x02, 0xE4, 0x30, 0x50, 0x00
108 , 0x80, 0x9B, 0xA2, 0x52, 0x3E, 0x90, 0x90, 0xD4, 0xBD, 0xA2, 0x12, 0xFB, 0x24, 0xB5, 0x00
109 , 0x4C, 0x8D, 0x3B, 0x44, 0x40, 0x7E, 0x31, 0x10, 0x00, 0x1C, 0xB5, 0x00, 0x4C, 0xCD, 0xB5
110 , 0x00, 0x58, 0x3B, 0x3C, 0xD8, 0x03, 0x00, 0x8B, 0x80, 0x7D, 0x7B, 0xB5, 0x00, 0x7E, 0x9C
111 , 0x6C, 0x3F, 0xFD, 0x02, 0x3B, 0x80, 0x10, 0xA5, 0xB5, 0x00, 0x54, 0x7E, 0xB5, 0x00, 0x54
112 , 0x3E, 0x3A, 0x90, 0x00, 0x5C, 0x30, 0x40, 0x00, 0x82, 0x7F, 0x28, 0xC2, 0x51, 0x3A, 0x9A
113 , 0xFF, 0xDE, 0x3A, 0xA3, 0x00, 0x14, 0x30, 0x41, 0x00, 0x00, 0x38, 0x10, 0x26, 0x91, 0x61
114 , 0x2C, 0x7E, 0x50, 0x3A, 0x8C, 0xFF, 0xB3, 0x30, 0x05, 0x00, 0x00, 0x3B, 0x80, 0x0A, 0x71
115 , 0xB5, 0x00, 0x40, 0x60, 0xB5, 0x00, 0x58, 0x3F, 0x3C, 0xD8, 0x03, 0x00, 0x8B, 0x80, 0x7D
116 , 0x7E, 0xB5, 0x00, 0x7E, 0x9C, 0x3C, 0xD0, 0x00, 0x8E, 0x3C, 0xCB, 0xFF, 0xB4, 0x82, 0x14
117 , 0x52, 0xF6, 0x6C, 0x3C, 0xD4, 0x78, 0xB5, 0x00, 0x55, 0xFA, 0x3B, 0x46, 0x40, 0xB8, 0x95
118 , 0xD4, 0xF9, 0x1A, 0xB5, 0x00, 0x53, 0x77, 0xB5, 0x00, 0x52, 0xB6, 0x3C, 0xC5, 0x40, 0xB7
119 , 0x6A, 0x5C, 0x62, 0x0C, 0x61, 0x84, 0xFE, 0x9C, 0x7F, 0x20, 0xC3, 0x41, 0x3C, 0xC9, 0xFF
120 , 0x72, 0x30, 0xA0, 0x02, 0x17, 0xFB, 0x00, 0x71, 0x40, 0xBA, 0x9B, 0xA0, 0xE2, 0x0B, 0x9B
121 , 0xC0, 0xD6, 0x7B, 0x9B, 0x00, 0xD4, 0xFC, 0x8B, 0x80, 0x55, 0x7D, 0x30, 0xB0, 0x21, 0x2C
122 , 0x73, 0x05, 0xD3, 0xB7, 0xB5, 0x00, 0x52, 0x7F, 0x3B, 0x80, 0x01, 0xDA, 0x3A, 0x31, 0xFF
123 , 0xFE, 0x6A, 0x1E, 0x54, 0xBA, 0x7C, 0x01, 0x78, 0x4A, 0x6A, 0x7E, 0x52, 0xB7, 0x3B, 0x80
124 , 0x01, 0x00, 0xB5, 0x00, 0x54, 0x7A, 0x9B, 0xC0, 0xD2, 0xBF, 0x90, 0x94, 0xD5, 0x3D, 0x3A
125 , 0x92, 0x00, 0x04, 0x92, 0x11, 0xD5, 0xBE, 0x6A, 0x1E, 0x54, 0xBA, 0x3A, 0x9B, 0x00, 0x05
126 , 0x7C, 0x27, 0x78, 0x06, 0xB5, 0x00, 0x55, 0x7D, 0x3B, 0x44, 0x40, 0xBF, 0x80, 0x18, 0x54
127 , 0x7A, 0x80, 0xB8, 0x54, 0xFC, 0xB5, 0x00, 0x52, 0xB6, 0x82, 0x14, 0x7E, 0x9C, 0x3B, 0x46
128 , 0x40, 0xDE, 0x6A, 0x5D, 0xD4, 0x38, 0x3C, 0xC5, 0x40, 0xDB, 0xB5, 0x00, 0x43, 0x0B, 0x94
129 , 0x18, 0xFE, 0x9C, 0xB5, 0x00, 0x43, 0x0B, 0x94, 0x18, 0xC0, 0x41, 0x3B, 0x00, 0x40, 0xDF
130 , 0xB5, 0x00, 0x58, 0x39, 0xB5, 0x00, 0x58, 0x39, 0x3C, 0xD8, 0x03, 0x00, 0x8B, 0x80, 0x7E
131 , 0x9C, 0x3C, 0xD0, 0xFF, 0x72, 0x71, 0x65, 0x7D, 0x2B, 0x6A, 0x7B, 0x42, 0x91, 0x6A, 0xBB
132 , 0xE2, 0x4B, 0x6A, 0x3D, 0x52, 0xF8, 0xB5, 0x00, 0x58, 0x7B, 0x3B, 0x80, 0x16, 0x94, 0xB5
133 , 0x00, 0x54, 0xF9, 0x7C, 0x44, 0xD4, 0xB8, 0x6A, 0x1B, 0xC2, 0x91, 0x61, 0xC0, 0x7E, 0x9C
134 , 0x6A, 0xBE, 0x54, 0xB6, 0x3B, 0x80, 0x00, 0xA9, 0x9B, 0xC3, 0x62, 0x09, 0x6A, 0xDB, 0xD4
135 , 0x3C, 0x3A, 0x90, 0x00, 0x25, 0x61, 0xCC, 0x42, 0x80, 0x6A, 0xBE, 0x54, 0xBA, 0x3B, 0x80
136 , 0x00, 0xA9, 0x9B, 0xC3, 0x62, 0x09, 0x9B, 0xA0, 0xD4, 0x37, 0x3A, 0x88, 0x00, 0x96, 0x66
137 , 0x04, 0x45, 0x0A, 0xFB, 0x00, 0x71, 0x40, 0xF8, 0x3A, 0x99, 0xFF, 0x6B, 0xB5, 0x00, 0x72
138 , 0x81, 0x80, 0x18, 0x43, 0x80, 0x6A, 0xFE, 0xD4, 0xBA, 0x3B, 0x80, 0x02, 0x8F, 0x80, 0xD4
139 , 0x62, 0x09, 0x7F, 0x4E, 0x54, 0xBD, 0xB5, 0x00, 0x43, 0x08, 0x38, 0x10, 0x00, 0xCF, 0x3B
140 , 0x80, 0x01, 0x33, 0x9B, 0xA2, 0x74, 0x56, 0x7F, 0x4E, 0x55, 0x3D, 0xB5, 0x00, 0x43, 0x10
141 , 0x3A, 0x82, 0x00, 0xC7, 0x7A, 0x2B, 0x54, 0x7D, 0x30, 0xA0, 0x12, 0x00, 0x30, 0xB0, 0x0B
142 , 0x66, 0x30, 0x50, 0x00, 0x80, 0x3B, 0x80, 0x02, 0xBE, 0xB5, 0x00, 0x62, 0x09, 0x7F, 0x4E
143 , 0x55, 0x3C, 0xB5, 0x00, 0x43, 0x10, 0x90, 0xDB, 0x54, 0xBD, 0x61, 0x44, 0x7E, 0x9C, 0xA2
144 , 0x17, 0x55, 0x39, 0x3A, 0x92, 0x00, 0xC8, 0x3A, 0x89, 0xFF, 0xBE, 0x3B, 0x43, 0x41, 0x49
145 , 0x6A, 0xBF, 0x54, 0xFD, 0x38, 0x12, 0x0B, 0x66, 0x30, 0x60, 0x00, 0x80, 0x30, 0x80, 0x12
146 , 0x00, 0x30, 0xA0, 0x01, 0x80, 0x3B, 0x80, 0x01, 0x1C, 0xB5, 0x00, 0x61, 0x46, 0xB5, 0x00
147 , 0x54, 0xB9, 0x30, 0x80, 0x01, 0x00, 0x30, 0x50, 0x01, 0x00, 0x30, 0x70, 0x00, 0x80, 0x3B
148 , 0x80, 0x1C, 0x3E, 0x38, 0x0C, 0x0B, 0x6B, 0x30, 0x90, 0x01, 0x80, 0x38, 0x0A, 0x22, 0x01
149 , 0x20, 0x80, 0x41, 0x28, 0x30, 0xA0, 0x01, 0x00, 0xB5, 0x00, 0x42, 0x11, 0xB5, 0x00, 0x43
150 , 0x08, 0xD4, 0xC8, 0x42, 0x11, 0x60, 0x24, 0xFE, 0x9C, 0x30, 0x90, 0x01, 0x00, 0x30, 0x50
151 , 0x00, 0x80, 0x30, 0xA0, 0x22, 0x29, 0x3B, 0x80, 0x02, 0x60, 0x30, 0x80, 0x01, 0x80, 0x30
152 , 0x80, 0x01, 0x00, 0x30, 0x50, 0x00, 0x80, 0x3B, 0x80, 0x00, 0xC1, 0x30, 0x90, 0x01, 0x00
153 , 0x30, 0x90, 0x01, 0x00, 0xB5, 0x00, 0x78, 0x09, 0x30, 0x50, 0x00, 0x3F, 0x3B, 0x80, 0x00
154 , 0x51, 0xFB, 0x00, 0x71, 0x41, 0x36, 0xB5, 0x00, 0x54, 0x7F, 0x38, 0x0A, 0x0B, 0x60, 0xD0
155 , 0x0C, 0x54, 0x3F, 0x30, 0x60, 0x00, 0x3F, 0x3B, 0x80, 0x00, 0x7A, 0xB5, 0x00, 0x61, 0x40
156 , 0x9B, 0xA8, 0x74, 0x55, 0xA5, 0xF2, 0xE2, 0x09, 0x38, 0x09, 0x0B, 0x69, 0x38, 0x0A, 0x0B
157 , 0x61, 0x38, 0x0C, 0x0A, 0x7C, 0x30, 0xA0, 0x0B, 0x67, 0x3B, 0x80, 0x00, 0x89, 0x9B, 0xE0
158 , 0xD3, 0xD5, 0x38, 0x0C, 0x0B, 0x67, 0x9B, 0xA8, 0x54, 0xBD, 0xA6, 0x1A, 0xFE, 0x9C, 0x3B
159 , 0x00, 0x41, 0x4A, 0x38, 0x01, 0x0B, 0x69, 0x9B, 0xA8, 0x54, 0xBD, 0x61, 0x84, 0x7E, 0x9C
160 , 0x92, 0x1B, 0xFE, 0x9C, 0x3B, 0x63, 0x41, 0x52, 0x38, 0x08, 0x0B, 0x6C, 0x9B, 0xDF, 0xD4
161 , 0xBE, 0xA5, 0xB2, 0xC3, 0x48, 0x38, 0x0B, 0x0B, 0x67, 0x38, 0x09, 0x0B, 0x69, 0x3B, 0x80
162 , 0x41, 0xD0, 0xB5, 0x00, 0x7E, 0x9C, 0x7F, 0x4E, 0x54, 0xBD, 0xB5, 0x00, 0x42, 0x88, 0x3A
163 , 0x91, 0xFF, 0x7A, 0x31, 0x20, 0x00, 0xC8, 0x82, 0x14, 0x44, 0x95, 0x3B, 0x44, 0x41, 0x60
164 , 0x38, 0x0A, 0x0B, 0x6A, 0x3A, 0x81, 0x00, 0x29, 0x38, 0x0C, 0x0B, 0x69, 0x38, 0x0E, 0x0B
165 , 0x62, 0xA2, 0x1B, 0xFE, 0x9C, 0x3B, 0x66, 0x41, 0x6F, 0x38, 0x0C, 0x0A, 0x7A, 0xA2, 0x13
166 , 0x7E, 0x9C, 0x3B, 0x64, 0x41, 0x6F, 0x38, 0x0C, 0x0A, 0x79, 0xA2, 0x13, 0x7E, 0x9C, 0x3B
167 , 0x67, 0x41, 0x6F, 0x38, 0x0C, 0x0B, 0x63, 0xD0, 0x35, 0x54, 0xB9, 0x3A, 0x89, 0x00, 0x50
168 , 0xB5, 0x00, 0x1A, 0x61, 0x38, 0x00, 0x0B, 0x68, 0x95, 0xD8, 0xC0, 0x40, 0xB3, 0xB7, 0x7E
169 , 0x9C, 0x3B, 0x00, 0x41, 0x76, 0x38, 0x0B, 0x0B, 0x6A, 0x38, 0x0C, 0x0B, 0x64, 0xD0, 0x34
170 , 0x54, 0xBE, 0x38, 0x0A, 0x0B, 0x65, 0x9B, 0x1F, 0xE1, 0x80, 0x95, 0xD8, 0xFE, 0x40, 0xFB
171 , 0x00, 0x71, 0x41, 0x74, 0xB2, 0xB7, 0x40, 0x48, 0x38, 0x0B, 0x0B, 0x6A, 0x61, 0x08, 0x54
172 , 0xBC, 0xB5, 0x00, 0x43, 0x08, 0xA2, 0x13, 0x54, 0x3E, 0x3A, 0x92, 0xFF, 0x94, 0x3B, 0x46
173 , 0x41, 0x7E, 0x3A, 0x89, 0xFF, 0xEB, 0x9B, 0xBF, 0xD4, 0xFC, 0xB5, 0x00, 0x42, 0xC0, 0xB5
174 , 0x00, 0x42, 0x90, 0x3A, 0x8A, 0xFF, 0xA5, 0x82, 0x14, 0x7E, 0x9C, 0x3B, 0x43, 0x41, 0x91
175 , 0x6A, 0x7B, 0xD5, 0x37, 0x3A, 0x8A, 0x00, 0x95, 0x31, 0x1F, 0xFF, 0x6A, 0x9B, 0xA0, 0xCC
176 , 0x0D, 0x6A, 0x7E, 0xC3, 0x90, 0x6A, 0x1B, 0x72, 0x81, 0xB5, 0x00, 0x74, 0x56, 0x30, 0xA0
177 , 0x0E, 0xBA, 0x3B, 0x80, 0x02, 0x8F, 0x80, 0x18, 0x61, 0x85, 0x6A, 0x5D, 0x55, 0x3D, 0x3B
178 , 0x80, 0x1A, 0x0A, 0x3C, 0xC8, 0xFF, 0xD6, 0x3B, 0x00, 0x41, 0x92, 0xB5, 0x00, 0x54, 0xBC
179 , 0xB5, 0x00, 0x54, 0xBC, 0x61, 0x44, 0x7E, 0x9C, 0x98, 0xB5, 0x7E, 0x9C, 0x82, 0x14, 0x7E
180 , 0x9C, 0x3B, 0x62, 0x41, 0xA3, 0x6A, 0x9C, 0x54, 0xB9, 0x3A, 0x81, 0x00, 0x14, 0x3A, 0x8A
181 , 0x00, 0x22, 0x61, 0x40, 0x43, 0x08, 0x3A, 0x90, 0xFF, 0xED, 0xD0, 0x4C, 0x43, 0x10, 0xB5
182 , 0x00, 0x54, 0xB6, 0x94, 0x03, 0xE2, 0x09, 0x30, 0xA0, 0x07, 0xA1, 0x3B, 0x80, 0x00, 0x14
183 , 0xB5, 0x00, 0x61, 0x40, 0x3B, 0x00, 0x41, 0xA4, 0xB5, 0x00, 0x55, 0xB7, 0xB5, 0x00, 0x55
184 , 0xB7, 0x3A, 0x83, 0x00, 0x97, 0x9B, 0xA0, 0xC5, 0x04, 0x31, 0x0F, 0xFF, 0x6A, 0x7F, 0x4E
185 , 0x4C, 0x05, 0xB5, 0x00, 0x72, 0x81, 0x80, 0x18, 0x43, 0x98, 0x6A, 0x3B, 0xD4, 0xB6, 0x3B
186 , 0x80, 0x02, 0x8F, 0x80, 0xD4, 0x62, 0x09, 0x6A, 0x5D, 0x55, 0x37, 0xB5, 0x00, 0x54, 0x36
187 , 0x3B, 0x80, 0x17, 0x99, 0xB5, 0x00, 0x7E, 0x9C, 0x8B, 0x80, 0x54, 0xB7, 0xFB, 0x00, 0x71
188 , 0x41, 0xB2, 0x3A, 0x89, 0x00, 0x5C, 0x3A, 0x91, 0xFF, 0xF2, 0x60, 0x00, 0x78, 0x11, 0x38
189 , 0x0A, 0x0B, 0x6A, 0xB5, 0x00, 0x4A, 0x10, 0xB3, 0x02, 0xC3, 0x08, 0x90, 0xDB, 0xCA, 0x50
190 , 0x3A, 0x98, 0x00, 0x10, 0xB2, 0xD3, 0x42, 0x98, 0x92, 0x17, 0xC3, 0x48, 0xB5, 0x00, 0x48
191 , 0x40, 0x3B, 0x42, 0x41, 0xCD, 0xB5, 0x00, 0x55, 0x39, 0x3A, 0x9A, 0x00, 0x5D, 0xB5, 0x00
192 , 0x43, 0x18, 0x82, 0x18, 0x7E, 0x9C, 0x3B, 0x66, 0x41, 0xCD, 0x3A, 0x8A, 0x00, 0x5E, 0xB5
193 , 0x00, 0x43, 0x08, 0x90, 0xD8, 0xFE, 0x9C, 0xA2, 0x1A, 0xC3, 0x48, 0x3B, 0x66, 0x41, 0xCB
194 , 0x6C, 0x1D, 0xFE, 0x4A, 0x3B, 0x00, 0x41, 0xCE, 0xB5, 0x00, 0x7E, 0x48, 0x3B, 0x00, 0x41
195 , 0xCE, 0xB5, 0x00, 0x58, 0x3B, 0xB5, 0x00, 0x58, 0x3B, 0x3C, 0xD8, 0x03, 0x00, 0x7F, 0x4E
196 , 0x7D, 0x55, 0x39, 0x84, 0x80, 0x02, 0x39, 0x86, 0x80, 0x02, 0x30, 0x40, 0x01, 0x00, 0xA8
197 , 0x1E, 0x7E, 0x9C, 0xA2, 0x02, 0x7E, 0x9C, 0x3B, 0x43, 0x41, 0xDA, 0x30, 0x10, 0x01, 0xFF
198 , 0xA8, 0x38, 0xFE, 0x9C, 0x30, 0x4F, 0xFE, 0x00, 0xA9, 0x26, 0x7E, 0x9C, 0x3C, 0xD8, 0x03
199 , 0x00, 0x9B, 0x99, 0x7E, 0x9C, 0xA0, 0x86, 0x7E, 0x9C, 0x3A, 0x89, 0x00, 0xC7, 0x7E, 0x81
200 , 0xC2, 0x88, 0x3A, 0x89, 0xFF, 0xE9, 0x6A, 0x3F, 0x54, 0xFD, 0xB5, 0x00, 0x58, 0x7F, 0x30
201 , 0x60, 0x00, 0x80, 0x3B, 0x80, 0x00, 0xB6, 0xB8, 0xA2, 0xE2, 0x48, 0xB5, 0x00, 0x54, 0xBE
202 , 0x38, 0x20, 0x0A, 0x6F, 0xB5, 0x00, 0x76, 0x88, 0x30, 0x62, 0x00, 0x00, 0xB5, 0x00, 0x42
203 , 0x90, 0xA0, 0xB7, 0x55, 0xBD, 0xB5, 0x00, 0x42, 0xD0, 0x38, 0x0C, 0x22, 0x13, 0xB5, 0x00
204 , 0x42, 0x98, 0xD0, 0x35, 0x7E, 0x9C, 0x3A, 0x83, 0xFF, 0x57, 0x3F, 0x00, 0x71, 0x41, 0xF0
205 , 0xB5, 0x00, 0x18, 0x61, 0x3A, 0x90, 0x00, 0x9B, 0xD0, 0x4C, 0x62, 0x09, 0x30, 0x70, 0x00
206 , 0x80, 0xB5, 0x00, 0x55, 0x7D, 0x3B, 0x80, 0x00, 0xA9, 0x9B, 0xC6, 0x61, 0x40, 0x7F, 0x4E
207 , 0x54, 0xBD, 0x6A, 0x1F, 0x4C, 0x08, 0x3B, 0x80, 0x01, 0x0E, 0x30, 0x50, 0x00, 0x80, 0xB5
208 , 0x00, 0x58, 0x3F, 0x3C, 0xD8, 0x03, 0x00, 0x8B, 0x80, 0x7D, 0x7D, 0xB5, 0x00, 0x7E, 0x9C
209 , 0x03, 0x00, 0x70, 0x00, 0x03, 0x21, 0x00, 0x71, 0x0A, 0x6F, 0x00, 0x00, 0x01, 0x00, 0x00
210 , 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00
211 , 0x02, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x2D, 0x00, 0x71, 0x0B, 0x60
212 , 0x00, 0xB8, 0x45, 0x7F, 0xEA, 0x29, 0x00, 0x00, 0x07, 0x40, 0x0F, 0x26, 0x3F, 0xFF, 0x9F
213 , 0x02, 0xCC, 0xCD, 0x00, 0x12, 0x00, 0x40, 0x00, 0x00, 0x01, 0x47, 0xAE, 0x00, 0x00, 0x00
214 , 0x02, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x08, 0x04, 0x00, 0x00, 0x0F, 0x00, 0x71
215 , 0x0A, 0x79, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x7E, 0x4D, 0xFE, 0x03
216 , 0x00, 0x70, 0x00, 0x05, 0x03, 0x00, 0x70, 0x00, 0x07, 0x7B, 0x00, 0x71, 0x03, 0x00, 0x00
217 , 0x00, 0x01, 0x00, 0x0B, 0x23, 0x00, 0x40, 0x00, 0x00, 0x3B, 0x80, 0x00, 0x00, 0x01, 0x00
218 , 0x0B, 0xAB, 0x00, 0x40, 0x24, 0x00, 0x3B, 0x80, 0x00, 0x00, 0x01, 0x00, 0x0D, 0xF5, 0x00
219 , 0x40, 0x3A, 0x00, 0x3B, 0x80, 0x00, 0x00, 0x01, 0x00, 0x0A, 0x6B, 0x00, 0x40, 0x97, 0x00
220 , 0x3B, 0x80, 0x00, 0x00, 0x01, 0x00, 0x05, 0xC6, 0x00, 0x40, 0xAB, 0x00, 0x3B, 0x80, 0x00
221 , 0x00, 0x01, 0x00, 0x0D, 0x24, 0x00, 0x40, 0xE2, 0x00, 0x3B, 0x80, 0x00, 0x00, 0x01, 0x00
222 , 0x12, 0x3A, 0x00, 0x7E, 0x9C, 0x00, 0xB5, 0x00, 0x00, 0x00, 0x01, 0x00, 0x05, 0x7B, 0x00
223 , 0x41, 0xD0, 0x00, 0x3B, 0x80, 0x00, 0x00, 0x01, 0x00, 0x1B, 0xA7, 0x00, 0x41, 0xDD, 0x00
224 , 0x3B, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03
225 , 0x00, 0x70, 0x00, 0x00, 0x23, 0x00, 0x70, 0x00, 0x02, 0x00, 0x01, 0x00, 0x80, 0x03, 0xFF
226 , 0xFF, 0xF9, 0xFF, 0xFF, 0xF7, 0xFF, 0xFF, 0xF6, 0x00, 0x00, 0x1D, 0x00, 0x00, 0x1B, 0x00
227 , 0x00, 0x1B, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x1C, 0x03, 0x00, 0x70, 0x01
228 , 0x12
229 };
230 /* end binary data. size = 2380bytes */
231
232 /* begin binary data: */
233 char speaker_data[] = {/* 423 */
234 0x00, 0x00, 0xD1, 0xFF, 0xFE, 0x06, 0xFF, 0xFE, 0x55, 0x00, 0x03, 0x2F, 0xFF, 0xFA, 0xF9
235 , 0x00, 0x05, 0x77, 0xFF, 0xFC, 0x89, 0xFF, 0xFC, 0x9A, 0x00, 0x00, 0x0B, 0xFF, 0xFA, 0x84
236 , 0x00, 0x02, 0x39, 0xFF, 0xFA, 0xD6, 0x00, 0x02, 0x98, 0xFF, 0xFC, 0xF7, 0x00, 0x00, 0xFE
237 , 0xFF, 0xFB, 0xD6, 0xFF, 0xFF, 0x47, 0x00, 0x02, 0x0A, 0xFF, 0xFD, 0x0F, 0x00, 0x01, 0x40
238 , 0xFF, 0xFD, 0xE5, 0xFF, 0xFE, 0x9D, 0xFF, 0xFE, 0xD6, 0xFF, 0xFE, 0x68, 0xFF, 0xFD, 0x59
239 , 0xFF, 0xFE, 0xAB, 0xFF, 0xFE, 0x65, 0x00, 0x00, 0x2E, 0xFF, 0xFB, 0x78, 0xFF, 0xFF, 0x2C
240 , 0x00, 0x00, 0x28, 0xFF, 0xFA, 0x9D, 0x00, 0x01, 0x7D, 0xFF, 0xFC, 0x9E, 0xFF, 0xFC, 0x0C
241 , 0x00, 0x01, 0x97, 0xFF, 0xF9, 0x25, 0x00, 0x00, 0xA5, 0xFF, 0xFC, 0x5B, 0xFF, 0xFF, 0x1B
242 , 0x00, 0x01, 0xCE, 0xFF, 0xF9, 0xE0, 0x00, 0x03, 0x9B, 0x00, 0x00, 0x98, 0xFF, 0xFC, 0x5D
243 , 0x00, 0x01, 0x7A, 0xFF, 0xFA, 0x43, 0xFF, 0xFF, 0x82, 0xFF, 0xFF, 0x66, 0xFF, 0xF8, 0xD6
244 , 0xFF, 0xFD, 0xE7, 0x00, 0x01, 0x04, 0xFF, 0xF7, 0xF3, 0xFF, 0xFE, 0x79, 0xFF, 0xFD, 0x5B
245 , 0xFF, 0xFB, 0xC4, 0xFF, 0xFE, 0xF5, 0xFF, 0xFA, 0x9B, 0xFF, 0xFF, 0x87, 0xFF, 0xFB, 0xC1
246 , 0xFF, 0xFD, 0xF3, 0x00, 0x00, 0x12, 0x00, 0x01, 0x8C, 0xFF, 0xF6, 0x37, 0x00, 0x05, 0x49
247 , 0xFF, 0xFA, 0x1F, 0xFF, 0xFC, 0x9E, 0x00, 0x00, 0xD8, 0xFF, 0xF7, 0x74, 0xFF, 0xFE, 0x29
248 , 0xFF, 0xFD, 0x42, 0xFF, 0xF3, 0x14, 0x00, 0x02, 0x1B, 0xFF, 0xF5, 0x86, 0xFF, 0xF7, 0x64
249 , 0xFF, 0xF6, 0x6D, 0xFF, 0xF3, 0x81, 0x00, 0x00, 0x2F, 0xFF, 0xF0, 0x35, 0xFF, 0xFC, 0xFA
250 , 0x00, 0x03, 0x5E, 0xFF, 0xF9, 0xA2, 0x00, 0x09, 0x46, 0xFF, 0xFE, 0x88, 0x00, 0x09, 0x61
251 , 0x00, 0x04, 0x3E, 0x00, 0x07, 0x57, 0x00, 0x09, 0xA2, 0xFF, 0xFD, 0x53, 0x00, 0x10, 0xD6
252 , 0xFF, 0xF7, 0xEE, 0xFF, 0xFC, 0xDC, 0x00, 0x04, 0x42, 0xFF, 0xF4, 0x9B, 0xFF, 0xF4, 0xA3
253 , 0xFF, 0xF0, 0x54, 0xFF, 0xF0, 0x30, 0xFF, 0xFB, 0x3B, 0xFF, 0xF2, 0x47, 0x00, 0x0E, 0xBA
254 , 0xFF, 0xF7, 0x96, 0x00, 0x22, 0x85, 0x00, 0x13, 0xA9, 0x00, 0x57, 0x54, 0x00, 0x13, 0x9B
255 , 0x00, 0x69, 0xD8, 0x00, 0x2B, 0xD5, 0x00, 0x73, 0x6B, 0x00, 0x40, 0x09, 0x00, 0x40, 0x8E
256 , 0xFF, 0xD6, 0x1D, 0xFF, 0xEA, 0x06, 0xFF, 0xB0, 0xD7, 0xFF, 0x5F, 0x5B, 0xFF, 0xA0, 0xAA
257 , 0x07, 0x36, 0x2D, 0xFF, 0xAA, 0xA7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
258 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
259 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6C, 0xCC, 0xCD
260 , 0x66, 0x66, 0x66, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x19, 0x99, 0x9A
261 , 0x00, 0x01, 0x76, 0x00, 0x01, 0x77, 0x04, 0x00, 0x00, 0x00, 0x67, 0xAE, 0x1C, 0xC0, 0x00
262 , 0x00, 0x6F, 0x69
263 };
264 /* end binary data. size = 423 bytes */
265
266 /* begin binary data: */
267 char config_data[] = {/* 165 */
268 0x09, 0xF3, 0x33, 0x01, 0x3E, 0x66, 0x00, 0x54, 0xCD, 0x00, 0x00, 0x14, 0x00, 0x00, 0x02
269 , 0x1A, 0xE6, 0x40, 0x1B, 0x40, 0xD4, 0x1C, 0x59, 0xDA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
270 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x4B, 0x00, 0x01, 0x4B
271 , 0x00, 0x00, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01
272 , 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x80, 0x00, 0x20, 0x00, 0x00, 0x00, 0x03, 0x47
273 , 0x01, 0x47, 0xAE, 0x00, 0x19, 0x9A, 0x00, 0x00, 0x00, 0x00, 0x0C, 0xCD, 0x02, 0x80, 0x00
274 , 0x00, 0x00, 0x01, 0x05, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0x50, 0x00, 0x00
275 , 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x19, 0x9A, 0x00, 0x00, 0x80, 0x00, 0x00, 0x02
276 , 0x00, 0x00, 0x01, 0x01, 0x47, 0xAE, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x19, 0x99, 0x9A
277 , 0x00, 0x80, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x30, 0x00, 0x00, 0x02, 0x00, 0x00, 0x18
278 , 0xEC, 0x00, 0x00, 0x00, 0x03, 0xD7, 0x01, 0x00, 0x00, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00
279 };
280 /* end binary data. size = 165 bytes */
281
282 /* begin binary data: */
283 char eq_data_hand[] = {/* 180 */
284 0x00, 0x00, 0x01, 0xC2, 0x90, 0xA8, 0x7D, 0x5E, 0x28, 0x3E, 0xB3, 0x60, 0x82, 0x99, 0x40
285 , 0x3E, 0xB3, 0x60, 0x00, 0x00, 0x01, 0xC2, 0x90, 0xA8, 0x7D, 0x5E, 0x28, 0x3E, 0xB3, 0x60
286 , 0x82, 0x99, 0x40, 0x3E, 0xB3, 0x60, 0x00, 0x00, 0x01, 0xC8, 0xCF, 0x48, 0x76, 0x89, 0x90
287 , 0x34, 0xDC, 0x58, 0x89, 0xF4, 0xCC, 0x42, 0xD2, 0xBC, 0x00, 0x00, 0x01, 0xEE, 0x00, 0x24
288 , 0x31, 0xEB, 0x08, 0x29, 0x55, 0x8C, 0x8C, 0x6F, 0x80, 0x6A, 0x4F, 0xC8, 0x00, 0x00, 0x01
289 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00
290 , 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
291 , 0x40, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
292 , 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
293 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
294 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x01
295 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00
296 };
297 /* end binary data. size = 180 bytes */
298
299 /* begin binary data: */
300 char eq_data_table[] = {/* 180 */
301 0x00, 0x00, 0x01, 0xC2, 0x90, 0xA8, 0x7D, 0x5E, 0x28, 0x3E, 0xB3, 0x60, 0x82, 0x99, 0x40
302 , 0x3E, 0xB3, 0x60, 0x00, 0x00, 0x01, 0xC2, 0x90, 0xA8, 0x7D, 0x5E, 0x28, 0x3E, 0xB3, 0x60
303 , 0x82, 0x99, 0x40, 0x3E, 0xB3, 0x60, 0x00, 0x00, 0x01, 0xC8, 0xCF, 0x48, 0x76, 0x89, 0x90
304 , 0x36, 0x25, 0x30, 0x89, 0xA7, 0x50, 0x41, 0x3C, 0x6C, 0x00, 0x00, 0x01, 0xEE, 0x00, 0x24
305 , 0x31, 0xEB, 0x08, 0x29, 0x55, 0x8C, 0x8C, 0x6F, 0x80, 0x6A, 0x4F, 0xC8, 0x00, 0x00, 0x01
306 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00
307 , 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
308 , 0x40, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
309 , 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
310 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
311 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x01
312 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00
313 };
314
315 /* end binary data. size = 180 bytes */
316
317 /* begin binary data: */
318 char preset_data0[] = {/* 87 */
319 0x00, 0x00, 0x07, 0x00, 0x01, 0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x40
320 , 0x00, 0x00, 0x00, 0x00, 0x01, 0x2C, 0x01, 0x47, 0xAE, 0x00, 0x2B, 0xB1, 0x00, 0x00, 0x9D
321 , 0x00, 0x0D, 0x1B, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x08, 0x00, 0x00
322 , 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x40, 0x00
323 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x48, 0x00, 0x01, 0x48
324 , 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x00, 0x03
325 };
326 /* end binary data. size = 87 bytes */
327
328 /* begin binary data: */
329 char preset_data1[] = {/* 87 */
330 0x00, 0x00, 0x07, 0x00, 0x01, 0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x40
331 , 0x00, 0x00, 0x00, 0x00, 0x01, 0x2C, 0x01, 0x47, 0xAE, 0x00, 0x2B, 0xB1, 0x00, 0x00, 0x9D
332 , 0x00, 0x0D, 0x1B, 0x01, 0x00, 0x00, 0x05, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00
333 , 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x40, 0x00
334 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x48, 0x00, 0x01, 0x48
335 , 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x00, 0x03
336 };
337 /* end binary data. size = 87 bytes */
338
339 char preset_data2[] = {/* 87 */
340 0x00, 0x00, 0x07, 0x00, 0x01, 0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x40
341 , 0x00, 0x00, 0x00, 0x00, 0x01, 0x2C, 0x01, 0x47, 0xAE, 0x00, 0x2B, 0xB1, 0x00, 0x00, 0x9D
342 , 0x00, 0x0D, 0x1B, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x05, 0x00, 0x00, 0x08, 0x00, 0x00
343 , 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x40, 0x00
344 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x48, 0x00, 0x01, 0x48
345 , 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x00, 0x03
346 };
347 /* end binary data. size = 87 bytes */
348
349 /* begin binary data: */
350 char preset_data3[] = {/* 87 */
351 0x00, 0x00, 0x07, 0x00, 0x01, 0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x40
352 , 0x00, 0x00, 0x00, 0x00, 0x01, 0x2C, 0x01, 0x47, 0xAE, 0x00, 0x2B, 0xB1, 0x00, 0x00, 0x9D
353 , 0x00, 0x0D, 0x1B, 0x01, 0x00, 0x00, 0x01, 0x80, 0x00, 0x04, 0x00, 0x00, 0x08, 0x00, 0x00
354 , 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x40, 0x00
355 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x48, 0x00, 0x01, 0x48
356 , 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x00, 0x03
357 };
358 /* end binary data. size = 87 bytes */
359
360 /* begin binary data: */
361 char preset_data4[] = {/* 87 */
362 0x00, 0x00, 0x07, 0x00, 0x01, 0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x40
363 , 0x00, 0x00, 0x00, 0x00, 0x01, 0x2C, 0x01, 0x47, 0xAE, 0x00, 0x2B, 0xB1, 0x00, 0x00, 0x9D
364 , 0x00, 0x0D, 0x1B, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x08, 0x00, 0x00
365 , 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x40, 0x00
366 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x48, 0x00, 0x01, 0x48
367 , 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x00, 0x03
368 };
369 /* end binary data. size = 87 bytes */
370
371 void convertBytes2Data(int num_bytes, const unsigned char bytes[], int data[])
372 {
373         int i; /* index for data */
374         int k; /* index for bytes */
375         int d;
376         int num_data = num_bytes/3;
377
378         for (i = 0, k = 0; i < num_data; ++i, k += 3) {
379                 d = (bytes[k] << 16) | (bytes[k+1] << 8) | (bytes[k+2]);
380                 if (bytes[k] & 0x80) {/* sign bit was set*/
381                         d = - ((1<<24)-d);
382                 }
383                 data[i] = d;
384         }
385 }
386
387 int ProcessPatchFile(struct tfa9887_priv *tfa9887, struct tfa9887_priv *tfa9887_byte, int length, const unsigned char* bytes)
388 {
389         unsigned int size;
390         int index = 0;
391         unsigned char buffer[MAX_I2C_LENGTH];
392         int error;
393         int value = 0;
394         unsigned int status;
395         error = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &status);
396         if (error == Tfa9887_Error_Ok) {
397                 if ( (status & 0x0043) != 0x0043) {
398                         /* one of Vddd, PLL and clocks not ok */
399                         error = -1;
400                 }
401         }
402         //pr_info("tfa status %u\n",status);
403         error = DspReadMem(tfa9887, tfa9887_byte, 0x2210, 1, &value);
404         //pr_info("tfa Version  %x\n",value);
405         while (index < length) {
406                 /* extract little endian length */
407                 size = bytes[index] + bytes[index+1] * 256;
408                 index += 2;
409                 if ( (index + size) > length) {
410                         /* too big, outside the buffer, error in the input data */
411                         return -1;
412                 }
413                 memcpy(buffer, bytes + index, size);
414                 error = regmap_raw_write(tfa9887_byte->regmap, buffer[0], &buffer[1] , (size -1));
415                 //pr_info("%d %d\n",buffer[0],size -1);
416                 if (error != Tfa9887_Error_Ok) {
417                         pr_info("ProcessPatchFile error\n");
418                         break;
419                 }
420                 index += size;
421         }
422         return error;
423 }
424
425 int DspReadMem(struct tfa9887_priv *tfa9887,  struct tfa9887_priv *tfa9887_byte, unsigned short start_offset, int num_words, int *pValues)
426 {
427         unsigned int cf_ctrl; /* the value to sent to the CF_CONTROLS register */
428         unsigned char bytes[MAX_I2C_LENGTH];
429         int burst_size; /* number of words per burst size */
430         int bytes_per_word=3;
431         int num_bytes;
432         int* p;
433         int error;
434         /* first set DMEM and AIF, leaving other bits intact */
435         error = Tfa9887_ReadRegister(tfa9887, TFA9887_CF_CONTROLS, &cf_ctrl);
436         if (error != Tfa9887_Error_Ok) {
437                 return error;
438         }
439         cf_ctrl &= ~0x000E; /* clear AIF & DMEM */
440         cf_ctrl |= (Tfa9887_DMEM_XMEM<<1); /* set DMEM, leave AIF cleared for autoincrement */
441         error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS, cf_ctrl);
442         if (error != Tfa9887_Error_Ok) {
443                 return error;
444         }
445         error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_MAD, start_offset);
446         if (error != Tfa9887_Error_Ok) {
447                 return error;
448         }
449         num_bytes = num_words*bytes_per_word;
450         p=pValues;
451         for (; num_bytes > 0; ) {
452                 burst_size = ROUND_DOWN(MAX_I2C_LENGTH, bytes_per_word);
453                 if (num_bytes < burst_size) {
454                         burst_size = num_bytes;
455                 }
456
457                 error = regmap_raw_read(tfa9887_byte->regmap, TFA9887_CF_MEM, bytes,burst_size);
458                 if (error != Tfa9887_Error_Ok) {
459                         return error;
460                 }
461                 convertBytes2Data(burst_size, bytes, p);
462                 num_bytes -= burst_size;
463                 p += burst_size/bytes_per_word;
464         }
465         return Tfa9887_Error_Ok;
466 }
467
468 int DspSetParam(struct tfa9887_priv *tfa9887, struct tfa9887_priv *tfa9887_byte, unsigned char module_id, unsigned char param_id, int num_bytes, const unsigned char *data)
469 {
470
471         int error;
472         unsigned int cf_ctrl = 0x0002; /* the value to be sent to the CF_CONTROLS register: cf_req=00000000, cf_int=0, cf_aif=0, cf_dmem=XMEM=01, cf_rst_dsp=0 */
473         unsigned int cf_mad = 0x0001; /* memory address to be accessed (0 : Status, 1 : ID, 2 : parameters) */
474         unsigned int cf_status; /* the contents of the CF_STATUS register */
475         unsigned char mem[3];
476         int rpcStatus = STATUS_OK;
477         int tries = 0;
478
479         error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS, cf_ctrl);
480         if (error == Tfa9887_Error_Ok) {
481                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_MAD, cf_mad);
482         }
483         if (error == Tfa9887_Error_Ok) {
484                 unsigned char id[3];
485                 id[0] = 0;
486                 id[1] = module_id+128;
487                 id[2] = param_id;
488                 error = regmap_raw_write(tfa9887_byte->regmap, TFA9887_CF_MEM,&id, 3);
489         }
490
491         error = regmap_raw_write(tfa9887_byte->regmap, TFA9887_CF_MEM, data, num_bytes);
492
493         if (error == Tfa9887_Error_Ok) {
494                 cf_ctrl |= (1<<8) | (1<<4); /* set the cf_req1 and cf_int bit */
495                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS, cf_ctrl);
496
497                 do {
498                         error = Tfa9887_ReadRegister(tfa9887, TFA9887_CF_STATUS, &cf_status);
499                         tries++;
500                         usleep_range(100, 200);
501                 } while ( (error==Tfa9887_Error_Ok) && ((cf_status & 0x0100) == 0) && (tries < 10) ); /* don't wait forever, DSP is pretty quick to respond (< 1ms) */
502
503                 if (tries >= 100) {
504                         /* something wrong with communication with DSP */
505                         pr_info("Setparam failed\n");
506                         error = -1;
507                 }
508         }
509         cf_ctrl = 0x0002;
510         cf_mad = 0x0000;
511         if (error == Tfa9887_Error_Ok) {
512                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS,cf_ctrl);
513     }
514
515     if (error == Tfa9887_Error_Ok) {
516             error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_MAD, cf_mad);
517     }
518     if (error == Tfa9887_Error_Ok) {
519                 error = regmap_raw_read(tfa9887_byte->regmap, TFA9887_CF_MEM,&mem,3);
520                 rpcStatus = (int)((mem[0] << 16) | (mem[1] << 8) | mem[2]);
521     }
522     if (error == Tfa9887_Error_Ok) {
523                 if (rpcStatus != STATUS_OK) {
524                         error = rpcStatus+100;
525                         //pr_info("RPC rpcStatus =%d\n",error);
526                 }
527     }
528         return error;
529 }
530
531 int DspGetParam(struct tfa9887_priv *tfa9887, struct tfa9887_priv *tfa9887_byte,
532                         unsigned char module_id, unsigned char param_id, int num_bytes, unsigned char *data)
533 {
534         int error;
535         unsigned int cf_ctrl = 0x0002;        /* the value to be sent to the CF_CONTROLS register: cf_req=00000000, cf_int=0, cf_aif=0, cf_dmem=XMEM=01, cf_rst_dsp=0 */
536         unsigned int cf_mad = 0x0001; /* memory address to be accessed (0 : Status, 1 : ID, 2 : parameters) */
537         unsigned int cf_status;       /* the contents of the CF_STATUS register */
538                 unsigned char mem[3];
539                 unsigned char id[3];
540                 int tries = 0;
541         /* 1) write the id and data to the DSP XMEM */
542                 error =
543                     Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS,
544                                             cf_ctrl);
545                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_MAD, cf_mad);
546                 id[0] = 0;
547                 id[1] = module_id + 128;
548                 id[2] = param_id;
549                 /* only try MEM once, if error, need to resend mad as well */
550                 error = regmap_raw_write(tfa9887_byte->regmap, TFA9887_CF_MEM, id, 3);
551         /* 2) wake up the DSP and let it process the data */
552         if (error == 0) {
553                 cf_ctrl |= (1 << 8) | (1 << 4); /* set the cf_req1 and cf_int bit */
554                 error =
555                     Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS,
556                                             cf_ctrl);
557         }
558         /* 3) wait for the ack */
559         if (error == Tfa9887_Error_Ok) {
560                 do {
561                         error =
562                             Tfa9887_ReadRegister(tfa9887, TFA9887_CF_STATUS,
563                                                    &cf_status);
564                         tries++;
565                 }
566                 while ((error == 0) && ((cf_status & 0x0100) == 0) && (tries < 10));     /* don't wait forever, DSP is pretty quick to respond (< 1ms) */
567                 if (tries >= 10) {
568                         /* something wrong with communication with DSP */
569                         pr_info("something wrong with communication with DSP\n");
570                         return -1;
571                 }
572         }
573         /* 4) check the RPC return value */
574         cf_ctrl = 0x0002;
575         cf_mad = 0x0000;
576         if (error == Tfa9887_Error_Ok) {
577                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS,cf_ctrl);
578         }
579         if (error == Tfa9887_Error_Ok) {
580                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_MAD, cf_mad);
581         }
582         if (error == Tfa9887_Error_Ok) {
583                     regmap_raw_read(tfa9887_byte->regmap, TFA9887_CF_MEM,&mem,3);
584                 error = (mem[0] << 16) | (mem[1] << 8) | mem[2];
585
586         }
587         if (error != Tfa9887_Error_Ok) {
588                 pr_info("RPC error\n");
589
590         }
591
592         /* 5) read the resulting data */
593         if (error == 0) {
594                 cf_mad = 0x0002;        /* memory address to be accessed (0 : Status, 1 : ID, 2 : parameters) */
595                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_MAD, cf_mad);
596         }
597         if (error == 0) {
598                         error =
599                             regmap_raw_read(tfa9887_byte->regmap, TFA9887_CF_MEM, data, num_bytes);
600                 }
601         return error;
602 }
603
604 int Tfa9887_WriteRegister(struct tfa9887_priv *tfa9887, unsigned int subaddress, unsigned int value)
605 {
606          int error = regmap_write(tfa9887->regmap,subaddress,value);
607          return error;
608 }
609
610 int Tfa9887_ReadRegister(struct tfa9887_priv *tfa9887, unsigned int subaddress, unsigned int* pValue)
611 {
612          int error = regmap_read(tfa9887->regmap,subaddress,pValue);
613          return error;
614 }
615
616 void calibrate (struct tfa9887_priv *tfa9887, struct tfa9887_priv *tfa9887_byte, char *calibdata)
617 {
618
619         int error;
620         int calibrateDone;
621         unsigned int status, value;
622         unsigned char bytes[3];
623         int data[2];
624         int tries = 0;
625
626         if(calibration_need) {
627                 SetMute(tfa9887, Tfa9887_Mute_Digital);
628                 pr_info("Inside calib\n");
629                 error = DspReadMem(tfa9887, tfa9887_byte, 231, 1, &calibrateDone);
630                 if (calibrateDone)
631                 {
632                         DspGetParam(tfa9887, tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_GET_RE0, 3, bytes);
633                         convertBytes2Data(3, bytes, &data[0]);
634                 }
635                 speaker_data[420] = 0;
636                 speaker_data[421] = 0;
637                 speaker_data[422] = 0;
638                 error = loadSettings(tfa9887, tfa9887_byte);
639         }
640
641          //SetConfigured
642         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
643
644         if(error == Tfa9887_Error_Ok)
645         {
646                 value |= TFA9887_SYSCTRL_CONFIGURED;
647                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
648         }
649
650         error = DspReadMem(tfa9887, tfa9887_byte, 231, 1, &calibrateDone);
651         while ((calibrateDone == 0) && (tries < 1000)) {
652                 error = DspReadMem(tfa9887, tfa9887_byte, 231, 1, &calibrateDone);
653                 tries++;
654         }
655         if(tries >= 1000)
656                 pr_info("Calibrate failed1\n");
657
658         tries = 0;
659         do {
660                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &status);
661                 tries++;
662         } while ( ((status & TFA9887_STATUS_MTPB) == TFA9887_STATUS_MTPB) && (tries < 100));
663         if(tries >= 100)
664                 pr_info("Calibrate failed\n");
665         DspGetParam(tfa9887, tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_GET_RE0, 3, bytes);
666         convertBytes2Data(3, bytes, &data[0]);
667         DspReadMem(tfa9887, tfa9887_byte, 232, 1, &data[1]);
668         pr_info("%d %d\n",data[0], data[1]);
669         memcpy(calibdata, (char *)data, 8);
670 }
671
672 void resetMtpEx(struct tfa9887_priv *tfa9887)
673 {
674         int err;
675         unsigned int mtp, status;
676         int tries = 0;
677         err = Tfa9887_ReadRegister(tfa9887, TFA9887_MTP, &mtp);
678
679         pr_info("%d****************1",mtp);
680         /* all settings loaded, signal the DSP to start calibration, only needed once after cold boot */
681         /* reset MTPEX bit if needed */
682         err = Tfa9887_WriteRegister(tfa9887, 0x0B, 0x5A); /* unlock key2 */
683         err = Tfa9887_WriteRegister(tfa9887, TFA9887_MTP, 1); /* MTPOTC=1, MTPEX=0 */
684
685         err = Tfa9887_WriteRegister(tfa9887, 0x62, 1<<11); /* CIMTP=1 */
686
687         do {
688                 err = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &status);
689                 tries++;
690         } while ( ((status & TFA9887_STATUS_MTPB) == TFA9887_STATUS_MTPB) && (tries < 100));
691
692 }
693
694 int checkMTPEX(struct tfa9887_priv *tfa9887)
695 {
696         unsigned int mtp;
697         int err;
698
699         err = Tfa9887_ReadRegister(tfa9887, TFA9887_MTP, &mtp);
700         if ( mtp & (1<<1))      /* check MTP bit1 (MTPEX) */
701                 return 1;                                       /* MTPEX is 1, calibration is done */
702         else
703                 return 0;                                       /* MTPEX is 0, calibration is not done yet */
704 }
705
706 int Tfa9887_Init(int sRate)
707 {
708         int error = 0;
709         srate = sRate;
710         if ((tfa9887R) && (tfa9887R->deviceInit)) {
711                 coldStartup(tfa9887R, tfa9887R_byte, srate);
712                         //Tfa9887_WriteRegister(tfa9887R, 0x0B, 0x5A); /* unlock key2 */
713                         //Tfa9887_WriteRegister(tfa9887R, TFA9887_MTP, 0); /* MTPOTC=1, MTPEX=0 */
714
715                 if((checkMTPEX(tfa9887R) == 0)) {
716                         calibration_need = 1;
717                         calibrate(tfa9887R, tfa9887R_byte, &calibdata[0]);
718                 }
719                 else {
720                         error = Init(tfa9887R,tfa9887R_byte, sRate);
721
722                 }
723         }
724         if ((tfa9887L) && (tfa9887L->deviceInit)) {
725                 coldStartup(tfa9887L, tfa9887L_byte, srate);
726                         //Tfa9887_WriteRegister(tfa9887L, 0x0B, 0x5A); /* unlock key2 */
727                         //Tfa9887_WriteRegister(tfa9887L, TFA9887_MTP, 0); /* MTPOTC=1, MTPEX=0 */
728                 if((checkMTPEX(tfa9887L) == 0)) {
729                         calibration_need = 1;
730                         calibrate(tfa9887L, tfa9887L_byte, &calibdata[8]);
731                 }
732                 else {
733                         error = Init(tfa9887L,tfa9887L_byte, sRate);
734
735                 }
736         }
737         if (error != 0)
738                 pr_info("Failed to Init tfa\n");
739         return error;
740 }
741
742 int Tfa9887_SetEq(void)
743 {
744         int error = 0;
745         if ((tfa9887R) && (tfa9887R->deviceInit))
746                 error = SetEq(tfa9887R, tfa9887R_byte);
747         if ((tfa9887L) && (tfa9887L->deviceInit))
748                 error = SetEq(tfa9887L, tfa9887L_byte);
749         return error;
750 }
751
752 int Tfa9887_SetPreset(unsigned int preset)
753 {
754         int error = 0;
755         unsigned short status;
756         if (preset != preset_mode) {
757                 preset_mode = preset;
758                 if ((tfa9887R) && (tfa9887R->deviceInit))
759                         error = SetPreset(tfa9887R, tfa9887R_byte);
760                 if ((tfa9887L) && (tfa9887L->deviceInit))
761                         error = SetPreset(tfa9887L, tfa9887L_byte);
762         }
763         return error;
764 }
765
766 int coldStartup(struct tfa9887_priv *tfa9887, struct tfa9887_priv *tfa9887_byte, int sRate)
767 {
768         int error,volume_value;
769         unsigned int value;
770         int tries = 0;
771         error = Tfa9887_WriteRegister(tfa9887, 0x09, 0x0002);
772         if (Tfa9887_Error_Ok == error) {
773                 error = Tfa9887_ReadRegister(tfa9887, 0x09, &value);
774         }
775         if (Tfa9887_Error_Ok == error) {
776                 /* DSP must be in control of the amplifier to avoid plops */
777                 value |= TFA9887_SYSCTRL_SEL_ENBL_AMP;
778                 error = Tfa9887_WriteRegister(tfa9887, 0x09, value);
779         }
780
781         /* some other registers must be set for optimal amplifier behaviour */
782         if (Tfa9887_Error_Ok == error) {
783                 error = Tfa9887_WriteRegister(tfa9887, 0x40, 0x5A6B);
784         }
785         if (Tfa9887_Error_Ok == error) {
786                 error = Tfa9887_WriteRegister(tfa9887, 0x05, 0x13AB);
787         }
788         if (Tfa9887_Error_Ok == error) {
789                 error = Tfa9887_WriteRegister(tfa9887, 0x06, 0x001F);
790         }
791         if (Tfa9887_Error_Ok == error) {
792                 error = Tfa9887_WriteRegister(tfa9887,
793                 TFA9887_SPKR_CALIBRATION, 0x3C4E); /*  adjusted to mandatory defaults */
794         }
795         if (Tfa9887_Error_Ok == error) {
796                 error = Tfa9887_WriteRegister(tfa9887, 0x09, 0x025D);
797         }
798         if (Tfa9887_Error_Ok == error) {
799                 error = Tfa9887_WriteRegister(tfa9887, 0x0A, 0x3EC3);
800         }
801         if (Tfa9887_Error_Ok == error) {
802                 error = Tfa9887_WriteRegister(tfa9887, 0x41, 0x0308);
803         }
804         if (Tfa9887_Error_Ok == error) {
805                 error = Tfa9887_WriteRegister(tfa9887, 0x48, 0x0180);
806         }
807         if (Tfa9887_Error_Ok == error) {
808                 error = Tfa9887_WriteRegister(tfa9887, 0x49, 0x0E82);
809         }
810         if (Tfa9887_Error_Ok == error) {
811                 error = Tfa9887_WriteRegister(tfa9887, 0x52, 0x0000);
812         }
813         if (Tfa9887_Error_Ok == error) {
814                 error = Tfa9887_WriteRegister(tfa9887, 0x40, 0x0000);
815         }
816         //Set Sampling Frequency
817         error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_CONTROL, &value);
818         if (error == Tfa9887_Error_Ok) {
819                 // clear the 4 bits first
820                 value &= (~(0xF<<TFA9887_I2SCTRL_RATE_SHIFT));
821                 switch (sRate) {
822                 case 48000:
823                         value |= TFA9887_I2SCTRL_RATE_48000;
824                         break;
825                 case 44100:
826                         value |= TFA9887_I2SCTRL_RATE_44100;
827                         break;
828                 case 32000:
829                         value |= TFA9887_I2SCTRL_RATE_32000;
830                         break;
831                 case 24000:
832                         value |= TFA9887_I2SCTRL_RATE_24000;
833                         break;
834                 case 22050:
835                         value |= TFA9887_I2SCTRL_RATE_22050;
836                         break;
837                 case 16000:
838                         value |= TFA9887_I2SCTRL_RATE_16000;
839                         break;
840                 case 12000:
841                         value |= TFA9887_I2SCTRL_RATE_12000;
842                         break;
843                 case 11025:
844                         value |= TFA9887_I2SCTRL_RATE_11025;
845                         break;
846                 case 8000:
847                         value |= TFA9887_I2SCTRL_RATE_08000;
848                         break;
849                 default:
850                         pr_info("unsupported samplerate\n");
851                         error = -1;
852                         return error;
853                 }
854                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_CONTROL, value);
855         }
856         volume_value = volume_step[PRESET_DEFAULT];
857         error = Tfa9887_ReadRegister(tfa9887, TFA9887_AUDIO_CONTROL, &value);
858         if(error == Tfa9887_Error_Ok) {
859                 value = (value&0x00FF) | (unsigned int)(volume_value<<8);
860                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_AUDIO_CONTROL, value);
861         }
862         //PowerUp
863         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
864         if(error == Tfa9887_Error_Ok) {
865                 value &= ~(TFA9887_SYSCTRL_POWERDOWN);
866                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
867         }
868
869                 //Waiting for IC to startup
870                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &value);
871                 do {
872                         error = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &value);
873                         tries++;
874                 } while ((error == Tfa9887_Error_Ok) && ((value & TFA9887_STATUS_PLLS) == 0) && (tries < 100));
875
876         //Firmware
877         error = ProcessPatchFile(tfa9887, tfa9887_byte, 10, coldpatch_data);
878                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &value);
879                 if(value & TFA9887_STATUS_ACS)
880                         //pr_info("TFA COLD BOOTED\n");
881         error = ProcessPatchFile(tfa9887, tfa9887_byte, sizeof(n1d2_data), n1d2_data);
882
883         return error;
884 }
885
886 int Init(struct tfa9887_priv *tfa9887,struct tfa9887_priv *tfa9887_byte, int sRate)
887 {
888         int error;
889         unsigned int value;
890
891         error = loadSettings(tfa9887, tfa9887_byte);
892         if(error != Tfa9887_Error_Ok) {
893                 pr_info("Loading Settings Failed\n");
894         }
895
896         error = stereoRouting(tfa9887);
897
898         if(error != Tfa9887_Error_Ok) {
899                 pr_info("Stereo routing Failed\n");
900         }
901
902          //SetConfigured
903         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
904         if(error == Tfa9887_Error_Ok)
905         {
906                 value |= TFA9887_SYSCTRL_CONFIGURED;
907                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
908         }
909         if (!calibration_need) {
910                 SetMute(tfa9887, Tfa9887_Mute_Amplifier);
911                 //PowerDown
912                 if(error == Tfa9887_Error_Ok)
913                 {
914                         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
915                         value |= TFA9887_SYSCTRL_POWERDOWN;
916                         error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
917                 }
918         }
919
920         return error;
921 }
922
923 int SetEq(struct tfa9887_priv *tfa9887,struct tfa9887_priv *tfa9887_byte)
924 {
925         int error = 0;
926         if (eq_mode == IN_HAND_MODE) {
927                 //pr_info("Setting hand mode\n");
928                 error = DspSetParam(tfa9887,tfa9887_byte, MODULE_BIQUADFILTERBANK,0, 180, eq_data_hand);
929         } else if (eq_mode == ON_DESK_MODE) {
930                 //pr_info("setting deskmode\n");
931                 error = DspSetParam(tfa9887,tfa9887_byte, MODULE_BIQUADFILTERBANK,0, 180, eq_data_table);
932         }
933         return error;
934 }
935
936 int SetPreset(struct tfa9887_priv *tfa9887,struct tfa9887_priv *tfa9887_byte)
937 {
938         int error = 0;
939         unsigned int value = 0;
940         unsigned int volume_value = 0;
941
942     switch(preset_mode) {
943             case 0:
944                                         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_PRESET, 87, preset_data0);
945                     break;
946             case 1:
947                                         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_PRESET, 87, preset_data1);
948                     break;
949             case 2:
950                                         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_PRESET, 87, preset_data2);
951                     break;
952             case 3:
953                                         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_PRESET, 87, preset_data3);
954                     break;
955             case 4:
956                                         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_PRESET, 87, preset_data4);
957                     break;
958             default:
959             return -1;
960     }
961         volume_value = volume_step[preset_mode];
962         //volume_value = volume_step[PRESET_DEFAULT];
963         //pr_info("%u %u\n",preset_mode,volume_value);
964         error = Tfa9887_ReadRegister(tfa9887, TFA9887_AUDIO_CONTROL, &value);
965     if(error == Tfa9887_Error_Ok) {
966             value = (value&0x00FF) | (unsigned int)(volume_value<<8);
967             error = Tfa9887_WriteRegister(tfa9887, TFA9887_AUDIO_CONTROL, value);
968     }
969         return error;
970 }
971
972 int loadSettings(struct tfa9887_priv *tfa9887,struct tfa9887_priv *tfa9887_byte)
973 {
974         int error;
975         //Load settings
976         error = DspSetParam(tfa9887,tfa9887_byte,MODULE_SPEAKERBOOST, PARAM_SET_LSMODEL, 423, speaker_data);
977         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_CONFIG, 165, config_data);
978                 SetPreset(tfa9887,tfa9887_byte);
979                 SetEq(tfa9887,tfa9887_byte);
980         return error;
981 }
982
983 int stereoRouting(struct tfa9887_priv *tfa9887)
984 {
985         int error;
986         unsigned int value;
987         if(tfa9887 == tfa9887L) {
988                 //select channel
989                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_CONTROL, &value);
990                 // clear the 2 bits first
991                 value &= ~(0x3<<TFA9887_I2SCTRL_CHANSEL_SHIFT);
992
993                 value |=(1<<TFA9887_I2SCTRL_CHANSEL_SHIFT);
994                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_CONTROL, value);
995
996                 //select ouput left for gain
997                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_SEL, &value);
998                 value &= ~(0x7<<TFA9887_I2SSEL_I2SOUT_LEFT_SHIFT);
999                 value |=(1<<TFA9887_I2SSEL_I2SOUT_LEFT_SHIFT);
1000                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_SEL, value);
1001                 //Select stereo gain
1002                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_CONTROL, &value);
1003                 value &= ~(0x1<<TFA9887_I2SCTRL_DATAI2_SHIFT);
1004                 value |=(1<<TFA9887_I2SCTRL_DATAI2_SHIFT);
1005                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_CONTROL, value);
1006
1007                 //select output right for current sense
1008                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_SEL, &value);
1009                 value &= ~(0x7<<TFA9887_I2SSEL_I2SOUT_RIGHT_SHIFT);
1010                 value |=(0<<TFA9887_I2SSEL_I2SOUT_RIGHT_SHIFT);
1011                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_SEL, value);
1012                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_SEL, value);
1013                 //pr_info("Tfa inside left\n");
1014
1015          }
1016          else if (tfa9887 == tfa9887R) {
1017                 // clear the 2 bits first
1018                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_CONTROL, &value);
1019                 value &= ~(0x3<<TFA9887_I2SCTRL_CHANSEL_SHIFT);
1020
1021                 value |=(2<<TFA9887_I2SCTRL_CHANSEL_SHIFT);
1022                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_CONTROL, value);
1023
1024                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_SEL, &value);
1025                 value &= ~(0x7<<TFA9887_I2SSEL_I2SOUT_RIGHT_SHIFT);
1026                 value |=(1<<TFA9887_I2SSEL_I2SOUT_RIGHT_SHIFT);
1027                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_SEL, value);
1028
1029                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_CONTROL, &value);
1030                 value &= ~(0x1<<TFA9887_I2SCTRL_DATAI2_SHIFT);
1031                 value |=(0<<TFA9887_I2SCTRL_DATAI2_SHIFT);
1032                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_CONTROL, value);
1033
1034                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_SEL, &value);
1035                 value &= ~(0x7<<TFA9887_I2SSEL_I2SOUT_LEFT_SHIFT);
1036                 value |=(0<<TFA9887_I2SSEL_I2SOUT_LEFT_SHIFT);
1037                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_SEL, value);
1038                 //pr_info("tfa inside right\n");
1039
1040         }
1041         else
1042         {
1043                 error = -1;
1044         }
1045         return error;
1046 }
1047
1048 int Tfa9887_Powerdown(int powerdown)
1049 {
1050         int error = 0;
1051         if ((tfa9887R) && (tfa9887R->deviceInit))
1052                 error = Powerdown(tfa9887R, tfa9887R_byte, powerdown);
1053         if ((tfa9887L) && (tfa9887L->deviceInit))
1054                 error = Powerdown(tfa9887L, tfa9887L_byte, powerdown);
1055         return error;
1056 }
1057
1058 EXPORT_SYMBOL(Tfa9887_Powerdown);
1059
1060 int Powerdown(struct tfa9887_priv *tfa9887, struct tfa9887_priv *tfa9887_byte, int powerdown)
1061 {
1062         int error;
1063         unsigned int value;
1064
1065         /* read the SystemControl register, modify the bit and write again */
1066         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
1067         if (error != Tfa9887_Error_Ok) {
1068                 return error;
1069         }
1070
1071         switch(powerdown) {
1072                 case 1:
1073                         value |= TFA9887_SYSCTRL_POWERDOWN;
1074                         SetMute(tfa9887,Tfa9887_Mute_Amplifier);
1075                         break;
1076                 case 0:
1077                         value &= ~(TFA9887_SYSCTRL_POWERDOWN);
1078                         break;
1079                 default:
1080                 return -1;
1081         }
1082         error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
1083         if(!powerdown) {
1084                 SetMute(tfa9887,Tfa9887_Mute_Off);
1085                 SetPreset(tfa9887,tfa9887_byte);
1086                 SetEq(tfa9887,tfa9887_byte);
1087         }
1088
1089
1090         return error;
1091 }
1092
1093 int SetMute(struct tfa9887_priv *tfa9887, Tfa9887_Mute_t mute)
1094 {
1095         int error;
1096         unsigned int audioctrl_value;
1097         unsigned int sysctrl_value;
1098         error =
1099             Tfa9887_ReadRegister(tfa9887, TFA9887_AUDIO_CONTROL,
1100                                    &audioctrl_value);
1101         if (error != Tfa9887_Error_Ok)
1102                 return error;
1103         error =
1104             Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL,
1105                                    &sysctrl_value);
1106         if (error != Tfa9887_Error_Ok)
1107                 return error;
1108         switch (mute) {
1109         case Tfa9887_Mute_Off:
1110                 /* previous state can be digital or amplifier mute,
1111                  * clear the cf_mute and set the enbl_amplifier bits
1112                  */
1113                 audioctrl_value &= ~(TFA9887_AUDIOCTRL_MUTE);
1114                 sysctrl_value |= TFA9887_SYSCTRL_ENBL_AMP;
1115                 break;
1116         case Tfa9887_Mute_Digital:
1117                 /* expect the amplifier to run */
1118                 /* set the cf_mute bit */
1119                 audioctrl_value |= TFA9887_AUDIOCTRL_MUTE;
1120                 /* set the enbl_amplifier bit */
1121                 sysctrl_value |= TFA9887_SYSCTRL_ENBL_AMP;
1122                 break;
1123         case Tfa9887_Mute_Amplifier:
1124                 /* clear the cf_mute bit */
1125                 audioctrl_value &= ~TFA9887_AUDIOCTRL_MUTE;
1126                 /* clear the enbl_amplifier bit */
1127                 sysctrl_value &= ~TFA9887_SYSCTRL_ENBL_AMP;
1128                 break;
1129         default:
1130                 error = -1;
1131         }
1132         if (error != Tfa9887_Error_Ok)
1133                 return error;
1134         error =
1135             Tfa9887_WriteRegister(tfa9887, TFA9887_AUDIO_CONTROL,
1136                                     audioctrl_value);
1137         if (error != Tfa9887_Error_Ok)
1138                 return error;
1139         error =
1140             Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL,
1141                                     sysctrl_value);
1142         return error;
1143 }
1144 bool tfa9887_readable_register(struct device *dev, unsigned int reg)
1145 {
1146          return true;
1147 }
1148
1149 bool tfa9887_volatile_register(struct device *dev, unsigned int reg)
1150 {
1151          return true;
1152 }
1153
1154 static const struct regmap_config tfa9887_regmap = {
1155         .reg_bits = 8,
1156         .val_bits = 16,
1157         .volatile_reg = tfa9887_volatile_register,
1158         .readable_reg = tfa9887_readable_register,
1159         .cache_type = REGCACHE_NONE,
1160 };
1161
1162 static const struct regmap_config tfa9887_regmap_byte = {
1163         .reg_bits = 8,
1164         .val_bits = 8,
1165         .volatile_reg = tfa9887_volatile_register,
1166         .readable_reg = tfa9887_readable_register,
1167         .cache_type = REGCACHE_NONE,
1168 };
1169 static ssize_t tfa9887_cal_show(struct kobject *kobj,
1170                 struct kobj_attribute *attr, char *buf)
1171 {
1172         //printk("!tfa9887_cal_show\n");
1173         if(calibration_need) {
1174                 memcpy(buf, calibdata, 16);
1175                 //pr_info("copying data\n");
1176         }
1177         return 16;
1178 }
1179
1180 static ssize_t tfa9887_cal_store(struct kobject *kobj,
1181         struct kobj_attribute *attr, const char *buf, size_t count)
1182 {
1183         ssize_t ret = count;
1184         unsigned int value;
1185         //printk("+tfa9887_cal_store: %p, %d\n", buf, count);
1186
1187         if (!buf || !count) {
1188                 ret = -EINVAL;
1189                 goto fail;
1190         }
1191         if (count == 6) {
1192                 if(calibration_need) {
1193                         memcpy(&speaker_data[420],buf,3);
1194                         memcpy(&speaker_data[420],buf+3,3);
1195                         tegra_asoc_enable_clocks();
1196                         resetMtpEx(tfa9887R);
1197                         resetMtpEx(tfa9887L);
1198                         SetMute(tfa9887R, Tfa9887_Mute_Amplifier);
1199                         SetMute(tfa9887L, Tfa9887_Mute_Amplifier);
1200                         coldStartup(tfa9887R, tfa9887R_byte, srate);
1201                         Init(tfa9887R,tfa9887R_byte, srate);
1202                         coldStartup(tfa9887L, tfa9887L_byte, srate);
1203                         Init(tfa9887L,tfa9887L_byte, srate);
1204                         calibration_need = 0;
1205                         calibrate(tfa9887R, tfa9887R_byte, &calibdata[0]);
1206                         calibrate(tfa9887L, tfa9887L_byte, &calibdata[0]);
1207                         Tfa9887_ReadRegister(tfa9887R, TFA9887_SYSTEM_CONTROL, &value);
1208                         value |= TFA9887_SYSCTRL_POWERDOWN;
1209                         Tfa9887_WriteRegister(tfa9887R, TFA9887_SYSTEM_CONTROL, value);
1210                         Tfa9887_ReadRegister(tfa9887L, TFA9887_SYSTEM_CONTROL, &value);
1211                         value |= TFA9887_SYSCTRL_POWERDOWN;
1212                         Tfa9887_WriteRegister(tfa9887L, TFA9887_SYSTEM_CONTROL, value);
1213                         tegra_asoc_disable_clocks();
1214                 }
1215         }
1216
1217 fail:
1218         //printk("-tfa9887_cal_store: %d\n", count);
1219         return ret;
1220 }
1221
1222
1223 static ssize_t tfa9887_config_show(struct kobject *kobj,
1224                 struct kobj_attribute *attr, char *buf)
1225 {
1226         printk("!tfa9887_config_show\n");
1227
1228         if (buf) {
1229                 if (eq_mode == 1)
1230                         memcpy(buf, '1', 1);
1231                 else if (eq_mode == 2)
1232                         memcpy(buf, '2', 1);
1233                 else
1234                         return -EINVAL;
1235         }
1236         return 1;
1237 }
1238
1239 static ssize_t tfa9887_config_store(struct kobject *kobj,
1240         struct kobj_attribute *attr, const char *buf, size_t count)
1241 {
1242         ssize_t ret = count;
1243
1244         //printk("+tfa9887_config_store: %p, %d\n", buf, count);
1245
1246         if (!buf || !count) {
1247                 ret = -EINVAL;
1248                 goto fail;
1249         }
1250         if (*buf == '2') {
1251                 pr_info("IN HAND MODE\n");
1252                 eq_mode = 2;
1253         }
1254         else if (*buf == '1'){
1255                 pr_info("IN DESK MODE\n");
1256                 eq_mode = 1;
1257         }
1258         Tfa9887_SetEq();
1259 fail:
1260         //printk("-tfa9887_config_store: %d\n", count);
1261         return ret;
1262 }
1263
1264 static ssize_t tfa9887_vol_show(struct kobject *kobj,
1265                 struct kobj_attribute *attr, char *buf)
1266 {
1267         printk("!tfa9887_vol_show\n");
1268         return 0;
1269 }
1270
1271 static ssize_t tfa9887_vol_store(struct kobject *kobj,
1272         struct kobj_attribute *attr, const char *buf, size_t count)
1273 {
1274         ssize_t ret = count;
1275         unsigned int preset;
1276
1277         //printk("+tfa9887_vol_store: %d, %d\n", *buf, count);
1278         if (!tfa9887R || !tfa9887L ||
1279                 !tfa9887R->deviceInit || !tfa9887L->deviceInit) {
1280                 ret = -EINVAL;
1281                 goto fail;
1282         }
1283
1284         if (!buf || !count) {
1285                 ret = -EINVAL;
1286                 goto fail;
1287         }
1288         if (*buf >= DB_CUTOFF_INDEX)
1289                 preset = MAX_DB_INDEX - *buf;
1290         else
1291                 preset = PRESET_DEFAULT;
1292
1293         Tfa9887_SetPreset(preset);
1294 fail:
1295         //printk("-tfa9887_vol_store: %d\n", count);
1296         return ret;
1297 }
1298
1299 static __devinit int tfa9887R_i2c_probe(struct i2c_client *i2c,
1300                                       const struct i2c_device_id *id)
1301 {
1302         unsigned int val;
1303         int ret;
1304
1305         pr_info("tfa9887R_i2c_probe\n");
1306         tfa9887R = devm_kzalloc(&i2c->dev,  sizeof(struct tfa9887_priv),
1307                               GFP_KERNEL);
1308         tfa9887R_byte = devm_kzalloc(&i2c->dev,  sizeof(struct tfa9887_priv),
1309                               GFP_KERNEL);
1310
1311         if (tfa9887R == NULL)
1312                 return -ENOMEM;
1313         tfa9887R->regmap = regmap_init_i2c(i2c, &tfa9887_regmap);
1314         tfa9887R_byte->regmap = regmap_init_i2c(i2c, &tfa9887_regmap_byte);
1315         if (IS_ERR(tfa9887R->regmap)) {
1316                 ret = PTR_ERR(tfa9887R->regmap);
1317                 dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
1318                         ret);
1319                 return ret;
1320         }
1321
1322         i2c_set_clientdata(i2c, tfa9887R);
1323         i2c_set_clientdata(i2c, tfa9887R_byte);
1324         tfa9887R->irq = i2c->irq;
1325         tfa9887R_byte->irq = i2c->irq;
1326         ret = regmap_read(tfa9887R->regmap, TFA9887_REVISIONNUMBER, &val);
1327         if (ret != 0) {
1328                 dev_err(&i2c->dev, "Failed to read chip revision: %d\n", ret);
1329                 goto err;
1330         }
1331         dev_info(&i2c->dev, "TFA9887 revision %d\n",val);
1332         tfa9887_kobj = kobject_create_and_add("tfa9887", kernel_kobj);
1333
1334         ret = sysfs_create_file(tfa9887_kobj, &tfa9887_config);
1335         printk("tfa9887_add_sysfs ret=%d",ret);
1336         if (ret != 0) {
1337                 dev_err(&i2c->dev, "Failed to add sysfs: %d\n", ret);
1338                 goto err;
1339         }
1340         ret = sysfs_create_file(tfa9887_kobj, &tfa9887_cal);
1341         printk("tfa9887_add_sysfs ret=%d",ret);
1342         if (ret != 0) {
1343                 dev_err(&i2c->dev, "Failed to add sysfs: %d\n", ret);
1344                 goto err;
1345         }
1346         ret = sysfs_create_file(tfa9887_kobj, &tfa9887_vol);
1347         printk("tfa9887_add_sysfs ret=%d",ret);
1348         if (ret != 0) {
1349                 dev_err(&i2c->dev, "Failed to add sysfs: %d\n", ret);
1350                 goto err;
1351         }
1352         tfa9887R->deviceInit = true;
1353         eq_mode = IN_HAND_MODE;
1354         preset_mode = PRESET_DEFAULT;
1355         return 0;
1356 err:
1357         regmap_exit(tfa9887R->regmap);
1358         return ret;
1359 }
1360
1361 static __devexit int tfa9887R_i2c_remove(struct i2c_client *client)
1362 {
1363         struct tfa9887_priv *tfa9887R = i2c_get_clientdata(client);
1364         regmap_exit(tfa9887R->regmap);
1365         sysfs_remove_file(tfa9887_kobj, &tfa9887_config);
1366         sysfs_remove_file(tfa9887_kobj, &tfa9887_cal);
1367         sysfs_remove_file(tfa9887_kobj, &tfa9887_vol);
1368         kobject_del(tfa9887_kobj);
1369         return 0;
1370 }
1371
1372 static const struct of_device_id tfa9887R_of_match[] = {
1373         { .compatible = "nxp,tfa9887R", },
1374         {},
1375 };
1376 MODULE_DEVICE_TABLE(of, tfa9887R_of_match);
1377
1378 static const struct i2c_device_id tfa9887R_i2c_id[] = {
1379         { "tfa9887R", 0 },
1380         { }
1381 };
1382 MODULE_DEVICE_TABLE(i2c, tfa9887R_i2c_id);
1383
1384 static struct i2c_driver tfa9887R_i2c_driver = {
1385          .driver = {
1386          .name = "tfa9887R",
1387          .owner = THIS_MODULE,
1388          .of_match_table = tfa9887R_of_match,
1389          },
1390          .probe =    tfa9887R_i2c_probe,
1391          .remove =   __devexit_p(tfa9887R_i2c_remove),
1392          .id_table = tfa9887R_i2c_id,
1393 };
1394
1395 static __devinit int tfa9887L_i2c_probe(struct i2c_client *i2c,
1396                                       const struct i2c_device_id *id)
1397 {
1398         unsigned int val;
1399         int ret;
1400
1401         pr_info("tfa9887L_i2c_probe\n");
1402         tfa9887L = devm_kzalloc(&i2c->dev,  sizeof(struct tfa9887_priv),
1403                               GFP_KERNEL);
1404         tfa9887L_byte = devm_kzalloc(&i2c->dev,  sizeof(struct tfa9887_priv),
1405                               GFP_KERNEL);
1406
1407         if (tfa9887L == NULL)
1408                 return -ENOMEM;
1409         tfa9887L->regmap = regmap_init_i2c(i2c, &tfa9887_regmap);
1410         tfa9887L_byte->regmap = regmap_init_i2c(i2c, &tfa9887_regmap_byte);
1411         if (IS_ERR(tfa9887L->regmap)) {
1412                 ret = PTR_ERR(tfa9887L->regmap);
1413                 dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
1414                         ret);
1415                 return ret;
1416         }
1417
1418         i2c_set_clientdata(i2c, tfa9887L);
1419         tfa9887L->irq = i2c->irq;
1420         ret = regmap_read(tfa9887L->regmap, TFA9887_REVISIONNUMBER, &val);
1421         if (ret != 0) {
1422                 dev_err(&i2c->dev, "Failed to read chip revision: %d\n", ret);
1423                 goto err;
1424         }
1425         dev_info(&i2c->dev, "TFA9887 revision %d\n",val);
1426         tfa9887L->deviceInit = true;
1427         return 0;
1428 err:
1429         regmap_exit(tfa9887L->regmap);
1430         return ret;
1431 }
1432
1433 static __devexit int tfa9887L_i2c_remove(struct i2c_client *client)
1434 {
1435         struct tfa9887_priv *tfa9887L = i2c_get_clientdata(client);
1436         regmap_exit(tfa9887L->regmap);
1437         return 0;
1438 }
1439
1440 static const struct of_device_id tfa9887L_of_match[] = {
1441         { .compatible = "nxp,tfa9887L", },
1442         {},
1443 };
1444 MODULE_DEVICE_TABLE(of, tfa9887L_of_match);
1445
1446 static const struct i2c_device_id tfa9887L_i2c_id[] = {
1447         { "tfa9887L", 0 },
1448         { }
1449 };
1450 MODULE_DEVICE_TABLE(i2c, tfa9887L_i2c_id);
1451
1452 static struct i2c_driver tfa9887L_i2c_driver = {
1453          .driver = {
1454          .name = "tfa9887L",
1455          .owner = THIS_MODULE,
1456          .of_match_table = tfa9887L_of_match,
1457          },
1458          .probe =    tfa9887L_i2c_probe,
1459          .remove =   __devexit_p(tfa9887L_i2c_remove),
1460          .id_table = tfa9887L_i2c_id,
1461 };
1462
1463 static int __init tfa9887_modinit(void)
1464 {
1465          int ret = 0;
1466          ret = i2c_add_driver(&tfa9887R_i2c_driver);
1467          if (ret != 0) {
1468          printk(KERN_ERR "Failed to register tfa9887 I2C driver: %d\n",
1469             ret);
1470          }
1471          ret = i2c_add_driver(&tfa9887L_i2c_driver);
1472          if (ret != 0) {
1473          printk(KERN_ERR "Failed to register tfa9887 I2C driver: %d\n",
1474             ret);
1475          }
1476          return ret;
1477 }
1478 module_init(tfa9887_modinit);
1479
1480 static void __exit tfa9887_exit(void)
1481 {
1482          i2c_del_driver(&tfa9887R_i2c_driver);
1483          i2c_del_driver(&tfa9887L_i2c_driver);
1484 }
1485 module_exit(tfa9887_exit);
1486