arm: tegra: roth: Fix TFA device patch header.
[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 #if 1
480     {
481         /* minimize the number of I2C transactions by making use of the autoincrement in I2C */
482         unsigned char buffer[7];
483         /* first the data for CF_CONTROLS */
484         buffer[0] = (unsigned char)((cf_ctrl >> 8) & 0xFF);
485         buffer[1] = (unsigned char)(cf_ctrl & 0xFF);
486         /* write the contents of CF_MAD which is the subaddress following CF_CONTROLS */
487         buffer[2] = (unsigned char)((cf_mad >> 8) & 0xFF);
488         buffer[3] = (unsigned char)(cf_mad & 0xFF);
489         /* write the module and RPC id into CF_MEM, which follows CF_MAD */
490         buffer[4] = 0;
491         buffer[5] = module_id + 128;
492         buffer[6] = param_id;
493         error =
494             regmap_raw_write(tfa9887_byte->regmap, TFA9887_CF_CONTROLS,
495                              buffer, sizeof(buffer));
496     }
497 #else
498         error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS, cf_ctrl);
499         if (error == Tfa9887_Error_Ok) {
500                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_MAD, cf_mad);
501         }
502         if (error == Tfa9887_Error_Ok) {
503                 unsigned char id[3];
504                 id[0] = 0;
505                 id[1] = module_id+128;
506                 id[2] = param_id;
507                 error = regmap_raw_write(tfa9887_byte->regmap, TFA9887_CF_MEM,&id, 3);
508         }
509 #endif
510
511         error = regmap_raw_write(tfa9887_byte->regmap, TFA9887_CF_MEM, data, num_bytes);
512
513         if (error == Tfa9887_Error_Ok) {
514                 cf_ctrl |= (1<<8) | (1<<4); /* set the cf_req1 and cf_int bit */
515                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS, cf_ctrl);
516
517                 do {
518                         error = Tfa9887_ReadRegister(tfa9887, TFA9887_CF_STATUS, &cf_status);
519                         tries++;
520                         udelay(100);
521                 } while ( (error==Tfa9887_Error_Ok) && ((cf_status & 0x0100) == 0) && (tries < 10) ); /* don't wait forever, DSP is pretty quick to respond (< 1ms) */
522
523                 if (tries >= 100) {
524                         /* something wrong with communication with DSP */
525                         //pr_info("Setparam failed\n");
526                         error = -1;
527                 }
528         }
529         cf_ctrl = 0x0002;
530         cf_mad = 0x0000;
531         if (error == Tfa9887_Error_Ok) {
532                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS,cf_ctrl);
533     }
534     if (error == Tfa9887_Error_Ok) {
535             error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_MAD, cf_mad);
536     }
537     if (error == Tfa9887_Error_Ok) {
538                 error = regmap_raw_read(tfa9887_byte->regmap, TFA9887_CF_MEM,&mem,3);
539                 rpcStatus = (int)((mem[0] << 16) | (mem[1] << 8) | mem[2]);
540     }
541     if (error == Tfa9887_Error_Ok) {
542                 if (rpcStatus != STATUS_OK) {
543                         error = rpcStatus+100;
544                         //pr_info("RPC rpcStatus =%d\n",error);
545                 }
546     }
547         return error;
548 }
549
550 int DspGetParam(struct tfa9887_priv *tfa9887, struct tfa9887_priv *tfa9887_byte,
551                         unsigned char module_id, unsigned char param_id, int num_bytes, unsigned char *data)
552 {
553         int error;
554         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 */
555         unsigned int cf_mad = 0x0001; /* memory address to be accessed (0 : Status, 1 : ID, 2 : parameters) */
556         unsigned int cf_status;       /* the contents of the CF_STATUS register */
557                 unsigned char mem[3];
558                 unsigned char id[3];
559                 int tries = 0;
560         /* 1) write the id and data to the DSP XMEM */
561                 error =
562                     Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS,
563                                             cf_ctrl);
564                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_MAD, cf_mad);
565                 id[0] = 0;
566                 id[1] = module_id + 128;
567                 id[2] = param_id;
568                 /* only try MEM once, if error, need to resend mad as well */
569                 error = regmap_raw_write(tfa9887_byte->regmap, TFA9887_CF_MEM, id, 3);
570         /* 2) wake up the DSP and let it process the data */
571         if (error == 0) {
572                 cf_ctrl |= (1 << 8) | (1 << 4); /* set the cf_req1 and cf_int bit */
573                 error =
574                     Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS,
575                                             cf_ctrl);
576         }
577         /* 3) wait for the ack */
578         if (error == Tfa9887_Error_Ok) {
579                 do {
580                         error =
581                             Tfa9887_ReadRegister(tfa9887, TFA9887_CF_STATUS,
582                                                    &cf_status);
583                         tries++;
584                 }
585                 while ((error == 0) && ((cf_status & 0x0100) == 0) && (tries < 10));     /* don't wait forever, DSP is pretty quick to respond (< 1ms) */
586                 if (tries >= 10) {
587                         /* something wrong with communication with DSP */
588                         pr_info("something wrong with communication with DSP\n");
589                         return -1;
590                 }
591         }
592         /* 4) check the RPC return value */
593         cf_ctrl = 0x0002;
594         cf_mad = 0x0000;
595         if (error == Tfa9887_Error_Ok) {
596                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS,cf_ctrl);
597         }
598         if (error == Tfa9887_Error_Ok) {
599                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_MAD, cf_mad);
600         }
601         if (error == Tfa9887_Error_Ok) {
602                     regmap_raw_read(tfa9887_byte->regmap, TFA9887_CF_MEM,&mem,3);
603                 error = (mem[0] << 16) | (mem[1] << 8) | mem[2];
604
605         }
606         if (error != Tfa9887_Error_Ok) {
607                 pr_info("RPC error\n");
608
609         }
610
611         /* 5) read the resulting data */
612         if (error == 0) {
613                 cf_mad = 0x0002;        /* memory address to be accessed (0 : Status, 1 : ID, 2 : parameters) */
614                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_MAD, cf_mad);
615         }
616         if (error == 0) {
617                         error =
618                             regmap_raw_read(tfa9887_byte->regmap, TFA9887_CF_MEM, data, num_bytes);
619                 }
620         return error;
621 }
622
623 int Tfa9887_WriteRegister(struct tfa9887_priv *tfa9887, unsigned int subaddress, unsigned int value)
624 {
625          int error = regmap_write(tfa9887->regmap,subaddress,value);
626          return error;
627 }
628
629 int Tfa9887_ReadRegister(struct tfa9887_priv *tfa9887, unsigned int subaddress, unsigned int* pValue)
630 {
631          int error = regmap_read(tfa9887->regmap,subaddress,pValue);
632          return error;
633 }
634
635 void calibrate (struct tfa9887_priv *tfa9887, struct tfa9887_priv *tfa9887_byte, char *calibdata)
636 {
637
638         int error;
639         int calibrateDone;
640         unsigned int status, value;
641         unsigned char bytes[3];
642         int data[2];
643         int tries = 0;
644
645         if(calibration_need) {
646                 SetMute(tfa9887, Tfa9887_Mute_Digital);
647                 pr_info("Inside calib\n");
648                 error = DspReadMem(tfa9887, tfa9887_byte, 231, 1, &calibrateDone);
649                 if (calibrateDone)
650                 {
651                         DspGetParam(tfa9887, tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_GET_RE0, 3, bytes);
652                         convertBytes2Data(3, bytes, &data[0]);
653                 }
654                 speaker_data[420] = 0;
655                 speaker_data[421] = 0;
656                 speaker_data[422] = 0;
657                 error = loadSettings(tfa9887, tfa9887_byte);
658         }
659
660          //SetConfigured
661         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
662
663         if(error == Tfa9887_Error_Ok)
664         {
665                 value |= TFA9887_SYSCTRL_CONFIGURED;
666                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
667         }
668
669         error = DspReadMem(tfa9887, tfa9887_byte, 231, 1, &calibrateDone);
670         while ((calibrateDone == 0) && (tries < 1000)) {
671                 error = DspReadMem(tfa9887, tfa9887_byte, 231, 1, &calibrateDone);
672                 tries++;
673         }
674         if(tries >= 1000)
675                 pr_info("Calibrate failed1\n");
676
677         tries = 0;
678         do {
679                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &status);
680                 tries++;
681         } while ( ((status & TFA9887_STATUS_MTPB) == TFA9887_STATUS_MTPB) && (tries < 100));
682         if(tries >= 100)
683                 pr_info("Calibrate failed\n");
684         DspGetParam(tfa9887, tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_GET_RE0, 3, bytes);
685         convertBytes2Data(3, bytes, &data[0]);
686         DspReadMem(tfa9887, tfa9887_byte, 232, 1, &data[1]);
687         pr_info("%d %d\n",data[0], data[1]);
688         memcpy(calibdata, (char *)data, 8);
689 }
690
691 void resetMtpEx(struct tfa9887_priv *tfa9887)
692 {
693         int err;
694         unsigned int mtp, status;
695         int tries = 0;
696         err = Tfa9887_ReadRegister(tfa9887, TFA9887_MTP, &mtp);
697
698         pr_info("%d****************1",mtp);
699         /* all settings loaded, signal the DSP to start calibration, only needed once after cold boot */
700         /* reset MTPEX bit if needed */
701         err = Tfa9887_WriteRegister(tfa9887, 0x0B, 0x5A); /* unlock key2 */
702         err = Tfa9887_WriteRegister(tfa9887, TFA9887_MTP, 1); /* MTPOTC=1, MTPEX=0 */
703
704         err = Tfa9887_WriteRegister(tfa9887, 0x62, 1<<11); /* CIMTP=1 */
705
706         do {
707                 err = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &status);
708                 tries++;
709         } while ( ((status & TFA9887_STATUS_MTPB) == TFA9887_STATUS_MTPB) && (tries < 100));
710
711 }
712
713 int checkMTPEX(struct tfa9887_priv *tfa9887)
714 {
715         unsigned int mtp;
716         int err;
717
718         err = Tfa9887_ReadRegister(tfa9887, TFA9887_MTP, &mtp);
719         if ( mtp & (1<<1))      /* check MTP bit1 (MTPEX) */
720                 return 1;                                       /* MTPEX is 1, calibration is done */
721         else
722                 return 0;                                       /* MTPEX is 0, calibration is not done yet */
723 }
724
725 int Tfa9887_Init(int sRate)
726 {
727         int error = 0;
728         srate = sRate;
729         if((tfa9887R) && (tfa9887R->deviceInit)) {
730                 coldStartup(tfa9887R, tfa9887R_byte, srate);
731                         //Tfa9887_WriteRegister(tfa9887R, 0x0B, 0x5A); /* unlock key2 */
732                         //Tfa9887_WriteRegister(tfa9887R, TFA9887_MTP, 0); /* MTPOTC=1, MTPEX=0 */
733
734                 if((checkMTPEX(tfa9887R) == 0)) {
735                         calibration_need = 1;
736                         calibrate(tfa9887R, tfa9887R_byte, &calibdata[0]);
737                 }
738                 else {
739                         error = Init(tfa9887R,tfa9887R_byte, sRate);
740
741                 }
742         }
743         if((tfa9887L) && (tfa9887L->deviceInit)) {
744                 coldStartup(tfa9887L, tfa9887L_byte, srate);
745                         //Tfa9887_WriteRegister(tfa9887L, 0x0B, 0x5A); /* unlock key2 */
746                         //Tfa9887_WriteRegister(tfa9887L, TFA9887_MTP, 0); /* MTPOTC=1, MTPEX=0 */
747                 if((checkMTPEX(tfa9887L) == 0)) {
748                         calibration_need = 1;
749                         calibrate(tfa9887L, tfa9887L_byte, &calibdata[8]);
750                 }
751                 else {
752                         error = Init(tfa9887L,tfa9887L_byte, sRate);
753
754                 }
755         }
756         if (error != 0)
757                 pr_info("Failed to Init tfa\n");
758         return error;
759 }
760
761 int Tfa9887_SetEq(void)
762 {
763         int error = 0;
764         if((tfa9887R) && (tfa9887R->deviceInit))
765                 error = SetEq(tfa9887R,tfa9887R_byte);
766         if((tfa9887L) && (tfa9887L->deviceInit))
767                 error = SetEq(tfa9887L,tfa9887L_byte);
768         return error;
769 }
770
771 int Tfa9887_SetPreset(void)
772 {
773         int error = 0;
774         unsigned short status;
775
776         if((tfa9887R) && (tfa9887R->deviceInit))
777                 error = SetPreset(tfa9887R,tfa9887R_byte);
778         if((tfa9887L) && (tfa9887L->deviceInit))
779                 error = SetPreset(tfa9887L,tfa9887L_byte);
780         return error;
781 }
782
783 int coldStartup(struct tfa9887_priv *tfa9887, struct tfa9887_priv *tfa9887_byte, int sRate)
784 {
785         int error,volume_value;
786         unsigned int value;
787         int tries = 0;
788         error = Tfa9887_WriteRegister(tfa9887, 0x09, 0x0002);
789         if (Tfa9887_Error_Ok == error) {
790                 error = Tfa9887_ReadRegister(tfa9887, 0x09, &value);
791         }
792         if (Tfa9887_Error_Ok == error) {
793                 /* DSP must be in control of the amplifier to avoid plops */
794                 value |= TFA9887_SYSCTRL_SEL_ENBL_AMP;
795                 error = Tfa9887_WriteRegister(tfa9887, 0x09, value);
796         }
797
798         /* some other registers must be set for optimal amplifier behaviour */
799         if (Tfa9887_Error_Ok == error) {
800                 error = Tfa9887_WriteRegister(tfa9887, 0x40, 0x5A6B);
801         }
802         if (Tfa9887_Error_Ok == error) {
803                 error = Tfa9887_WriteRegister(tfa9887, 0x05, 0x13AB);
804         }
805         if (Tfa9887_Error_Ok == error) {
806                 error = Tfa9887_WriteRegister(tfa9887, 0x06, 0x001F);
807         }
808         if (Tfa9887_Error_Ok == error) {
809                 error = Tfa9887_WriteRegister(tfa9887,
810                 TFA9887_SPKR_CALIBRATION, 0x3C4E); /*  adjusted to mandatory defaults */
811         }
812         if (Tfa9887_Error_Ok == error) {
813                 error = Tfa9887_WriteRegister(tfa9887, 0x09, 0x025D);
814         }
815         if (Tfa9887_Error_Ok == error) {
816                 error = Tfa9887_WriteRegister(tfa9887, 0x0A, 0x3EC3);
817         }
818         if (Tfa9887_Error_Ok == error) {
819                 error = Tfa9887_WriteRegister(tfa9887, 0x41, 0x0308);
820         }
821         if (Tfa9887_Error_Ok == error) {
822                 error = Tfa9887_WriteRegister(tfa9887, 0x48, 0x0180);
823         }
824         if (Tfa9887_Error_Ok == error) {
825                 error = Tfa9887_WriteRegister(tfa9887, 0x49, 0x0E82);
826         }
827         if (Tfa9887_Error_Ok == error) {
828                 error = Tfa9887_WriteRegister(tfa9887, 0x52, 0x0000);
829         }
830         if (Tfa9887_Error_Ok == error) {
831                 error = Tfa9887_WriteRegister(tfa9887, 0x40, 0x0000);
832         }
833         //Set Sampling Frequency
834         error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_CONTROL, &value);
835         if (error == Tfa9887_Error_Ok) {
836                 // clear the 4 bits first
837                 value &= (~(0xF<<TFA9887_I2SCTRL_RATE_SHIFT));
838                 switch (sRate) {
839                 case 48000:
840                         value |= TFA9887_I2SCTRL_RATE_48000;
841                         break;
842                 case 44100:
843                         value |= TFA9887_I2SCTRL_RATE_44100;
844                         break;
845                 case 32000:
846                         value |= TFA9887_I2SCTRL_RATE_32000;
847                         break;
848                 case 24000:
849                         value |= TFA9887_I2SCTRL_RATE_24000;
850                         break;
851                 case 22050:
852                         value |= TFA9887_I2SCTRL_RATE_22050;
853                         break;
854                 case 16000:
855                         value |= TFA9887_I2SCTRL_RATE_16000;
856                         break;
857                 case 12000:
858                         value |= TFA9887_I2SCTRL_RATE_12000;
859                         break;
860                 case 11025:
861                         value |= TFA9887_I2SCTRL_RATE_11025;
862                         break;
863                 case 8000:
864                         value |= TFA9887_I2SCTRL_RATE_08000;
865                         break;
866                 default:
867                         pr_info("unsupported samplerate\n");
868                         error = -1;
869                         return error;
870                 }
871                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_CONTROL, value);
872         }
873         volume_value = volume_step[PRESET_DEFAULT];
874         error = Tfa9887_ReadRegister(tfa9887, TFA9887_AUDIO_CONTROL, &value);
875         if(error == Tfa9887_Error_Ok) {
876                 value = (value&0x00FF) | (unsigned int)(volume_value<<8);
877                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_AUDIO_CONTROL, value);
878         }
879         //PowerUp
880         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
881         if(error == Tfa9887_Error_Ok) {
882                 value &= ~(TFA9887_SYSCTRL_POWERDOWN);
883                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
884         }
885
886                 //Waiting for IC to startup
887                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &value);
888                 do {
889                         error = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &value);
890                         tries++;
891                 } while ((error == Tfa9887_Error_Ok) && ((value & TFA9887_STATUS_PLLS) == 0) && (tries < 100));
892
893         //Firmware
894         error = ProcessPatchFile(tfa9887, tfa9887_byte, 10, coldpatch_data);
895                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &value);
896                 if(value & TFA9887_STATUS_ACS)
897                         //pr_info("TFA COLD BOOTED\n");
898         error = ProcessPatchFile(tfa9887, tfa9887_byte, sizeof(n1d2_data), n1d2_data);
899
900         return error;
901 }
902
903 int Init(struct tfa9887_priv *tfa9887,struct tfa9887_priv *tfa9887_byte, int sRate)
904 {
905         int error;
906         unsigned int value;
907
908         error = loadSettings(tfa9887, tfa9887_byte);
909         if(error != Tfa9887_Error_Ok) {
910                 pr_info("Loading Settings Failed\n");
911         }
912
913         error = stereoRouting(tfa9887);
914
915         if(error != Tfa9887_Error_Ok) {
916                 pr_info("Stereo routing Failed\n");
917         }
918
919          //SetConfigured
920         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
921         if(error == Tfa9887_Error_Ok)
922         {
923                 value |= TFA9887_SYSCTRL_CONFIGURED;
924                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
925         }
926         if (!calibration_need) {
927                 SetMute(tfa9887, Tfa9887_Mute_Amplifier);
928                 //PowerDown
929                 if(error == Tfa9887_Error_Ok)
930                 {
931                         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
932                         value |= TFA9887_SYSCTRL_POWERDOWN;
933                         error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
934                 }
935         }
936
937         return error;
938 }
939
940 int SetEq(struct tfa9887_priv *tfa9887,struct tfa9887_priv *tfa9887_byte)
941 {
942         int error = 0;
943         if (eq_mode == IN_HAND_MODE) {
944                 //pr_info("Setting hand mode\n");
945                 error = DspSetParam(tfa9887,tfa9887_byte, MODULE_BIQUADFILTERBANK,0, 180, eq_data_hand);
946         } else if (eq_mode == ON_DESK_MODE) {
947                 //pr_info("setting deskmode\n");
948                 error = DspSetParam(tfa9887,tfa9887_byte, MODULE_BIQUADFILTERBANK,0, 180, eq_data_table);
949         }
950         return error;
951 }
952
953 int SetPreset(struct tfa9887_priv *tfa9887,struct tfa9887_priv *tfa9887_byte)
954 {
955         int error = 0;
956         unsigned int value = 0;
957         unsigned int volume_value = 0;
958
959     switch(preset_mode) {
960             case 0:
961                                         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_PRESET, 87, preset_data0);
962                     break;
963             case 1:
964                                         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_PRESET, 87, preset_data1);
965                     break;
966             case 2:
967                                         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_PRESET, 87, preset_data2);
968                     break;
969             case 3:
970                                         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_PRESET, 87, preset_data3);
971                     break;
972             case 4:
973                                         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_PRESET, 87, preset_data4);
974                     break;
975             default:
976             return -1;
977     }
978         volume_value = volume_step[preset_mode];
979         //volume_value = volume_step[PRESET_DEFAULT];
980         //pr_info("%u %u\n",preset_mode,volume_value);
981         error = Tfa9887_ReadRegister(tfa9887, TFA9887_AUDIO_CONTROL, &value);
982     if(error == Tfa9887_Error_Ok) {
983             value = (value&0x00FF) | (unsigned int)(volume_value<<8);
984             error = Tfa9887_WriteRegister(tfa9887, TFA9887_AUDIO_CONTROL, value);
985     }
986         return error;
987 }
988
989 int loadSettings(struct tfa9887_priv *tfa9887,struct tfa9887_priv *tfa9887_byte)
990 {
991         int error;
992         //Load settings
993         error = DspSetParam(tfa9887,tfa9887_byte,MODULE_SPEAKERBOOST, PARAM_SET_LSMODEL, 423, speaker_data);
994         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_CONFIG, 165, config_data);
995                 SetPreset(tfa9887,tfa9887_byte);
996                 SetEq(tfa9887,tfa9887_byte);
997         return error;
998 }
999
1000 int stereoRouting(struct tfa9887_priv *tfa9887)
1001 {
1002         int error;
1003         unsigned int value;
1004         if(tfa9887 == tfa9887L) {
1005                 //select channel
1006                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_CONTROL, &value);
1007                 // clear the 2 bits first
1008                 value &= ~(0x3<<TFA9887_I2SCTRL_CHANSEL_SHIFT);
1009
1010                 value |=(1<<TFA9887_I2SCTRL_CHANSEL_SHIFT);
1011                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_CONTROL, value);
1012
1013                 //select ouput left for gain
1014                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_SEL, &value);
1015                 value &= ~(0x7<<TFA9887_I2SSEL_I2SOUT_LEFT_SHIFT);
1016                 value |=(1<<TFA9887_I2SSEL_I2SOUT_LEFT_SHIFT);
1017                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_SEL, value);
1018                 //Select stereo gain
1019                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_CONTROL, &value);
1020                 value &= ~(0x1<<TFA9887_I2SCTRL_DATAI2_SHIFT);
1021                 value |=(1<<TFA9887_I2SCTRL_DATAI2_SHIFT);
1022                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_CONTROL, value);
1023
1024                 //select output right for current sense
1025                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_SEL, &value);
1026                 value &= ~(0x7<<TFA9887_I2SSEL_I2SOUT_RIGHT_SHIFT);
1027                 value |=(0<<TFA9887_I2SSEL_I2SOUT_RIGHT_SHIFT);
1028                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_SEL, value);
1029                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_SEL, value);
1030                 //pr_info("Tfa inside left\n");
1031
1032          }
1033          else if (tfa9887 == tfa9887R) {
1034                 // clear the 2 bits first
1035                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_CONTROL, &value);
1036                 value &= ~(0x3<<TFA9887_I2SCTRL_CHANSEL_SHIFT);
1037
1038                 value |=(2<<TFA9887_I2SCTRL_CHANSEL_SHIFT);
1039                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_CONTROL, value);
1040
1041                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_SEL, &value);
1042                 value &= ~(0x7<<TFA9887_I2SSEL_I2SOUT_RIGHT_SHIFT);
1043                 value |=(1<<TFA9887_I2SSEL_I2SOUT_RIGHT_SHIFT);
1044                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_SEL, value);
1045
1046                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_CONTROL, &value);
1047                 value &= ~(0x1<<TFA9887_I2SCTRL_DATAI2_SHIFT);
1048                 value |=(0<<TFA9887_I2SCTRL_DATAI2_SHIFT);
1049                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_CONTROL, value);
1050
1051                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_SEL, &value);
1052                 value &= ~(0x7<<TFA9887_I2SSEL_I2SOUT_LEFT_SHIFT);
1053                 value |=(0<<TFA9887_I2SSEL_I2SOUT_LEFT_SHIFT);
1054                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_SEL, value);
1055                 //pr_info("tfa inside right\n");
1056
1057         }
1058         else
1059         {
1060                 error = -1;
1061         }
1062         return error;
1063 }
1064
1065 int Tfa9887_Powerdown(int powerdown)
1066 {
1067         int error = 0;
1068         if((tfa9887R) && (tfa9887R->deviceInit))
1069                 error = Powerdown(tfa9887R, tfa9887R_byte, powerdown);
1070         if((tfa9887L) && (tfa9887L->deviceInit))
1071                 error = Powerdown(tfa9887L, tfa9887L_byte, powerdown);
1072         return error;
1073 }
1074
1075 EXPORT_SYMBOL(Tfa9887_Powerdown);
1076
1077 int Powerdown(struct tfa9887_priv *tfa9887, struct tfa9887_priv *tfa9887_byte, int powerdown)
1078 {
1079         int error;
1080         unsigned int value;
1081
1082         /* read the SystemControl register, modify the bit and write again */
1083         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
1084         if (error != Tfa9887_Error_Ok) {
1085                 return error;
1086         }
1087
1088         switch(powerdown) {
1089                 case 1:
1090                         value |= TFA9887_SYSCTRL_POWERDOWN;
1091                         SetMute(tfa9887,Tfa9887_Mute_Amplifier);
1092                         break;
1093                 case 0:
1094                         value &= ~(TFA9887_SYSCTRL_POWERDOWN);
1095                         break;
1096                 default:
1097                 return -1;
1098         }
1099         error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
1100         if(!powerdown) {
1101                 SetMute(tfa9887,Tfa9887_Mute_Off);
1102                 SetPreset(tfa9887,tfa9887_byte);
1103                 SetEq(tfa9887,tfa9887_byte);
1104         }
1105
1106
1107         return error;
1108 }
1109
1110 int SetMute(struct tfa9887_priv *tfa9887, Tfa9887_Mute_t mute)
1111 {
1112         int error;
1113         unsigned int audioctrl_value;
1114         unsigned int sysctrl_value;
1115         error =
1116             Tfa9887_ReadRegister(tfa9887, TFA9887_AUDIO_CONTROL,
1117                                    &audioctrl_value);
1118         if (error != Tfa9887_Error_Ok)
1119                 return error;
1120         error =
1121             Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL,
1122                                    &sysctrl_value);
1123         if (error != Tfa9887_Error_Ok)
1124                 return error;
1125         switch (mute) {
1126         case Tfa9887_Mute_Off:
1127                 /* previous state can be digital or amplifier mute,
1128                  * clear the cf_mute and set the enbl_amplifier bits
1129                  */
1130                 audioctrl_value &= ~(TFA9887_AUDIOCTRL_MUTE);
1131                 sysctrl_value |= TFA9887_SYSCTRL_ENBL_AMP;
1132                 break;
1133         case Tfa9887_Mute_Digital:
1134                 /* expect the amplifier to run */
1135                 /* set the cf_mute bit */
1136                 audioctrl_value |= TFA9887_AUDIOCTRL_MUTE;
1137                 /* set the enbl_amplifier bit */
1138                 sysctrl_value |= TFA9887_SYSCTRL_ENBL_AMP;
1139                 break;
1140         case Tfa9887_Mute_Amplifier:
1141                 /* clear the cf_mute bit */
1142                 audioctrl_value &= ~TFA9887_AUDIOCTRL_MUTE;
1143                 /* clear the enbl_amplifier bit */
1144                 sysctrl_value &= ~TFA9887_SYSCTRL_ENBL_AMP;
1145                 break;
1146         default:
1147                 error = -1;
1148         }
1149         if (error != Tfa9887_Error_Ok)
1150                 return error;
1151         error =
1152             Tfa9887_WriteRegister(tfa9887, TFA9887_AUDIO_CONTROL,
1153                                     audioctrl_value);
1154         if (error != Tfa9887_Error_Ok)
1155                 return error;
1156         error =
1157             Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL,
1158                                     sysctrl_value);
1159         return error;
1160 }
1161 bool tfa9887_readable_register(struct device *dev, unsigned int reg)
1162 {
1163          return true;
1164 }
1165
1166 bool tfa9887_volatile_register(struct device *dev, unsigned int reg)
1167 {
1168          return true;
1169 }
1170
1171 static const struct regmap_config tfa9887_regmap = {
1172         .reg_bits = 8,
1173         .val_bits = 16,
1174         .volatile_reg = tfa9887_volatile_register,
1175         .readable_reg = tfa9887_readable_register,
1176         .cache_type = REGCACHE_NONE,
1177 };
1178
1179 static const struct regmap_config tfa9887_regmap_byte = {
1180         .reg_bits = 8,
1181         .val_bits = 8,
1182         .volatile_reg = tfa9887_volatile_register,
1183         .readable_reg = tfa9887_readable_register,
1184         .cache_type = REGCACHE_NONE,
1185 };
1186 static ssize_t tfa9887_cal_show(struct kobject *kobj,
1187                 struct kobj_attribute *attr, char *buf)
1188 {
1189         //printk("!tfa9887_cal_show\n");
1190         if(calibration_need) {
1191                 memcpy(buf, calibdata, 16);
1192                 //pr_info("copying data\n");
1193         }
1194         return 16;
1195 }
1196
1197 static ssize_t tfa9887_cal_store(struct kobject *kobj,
1198         struct kobj_attribute *attr, const char *buf, size_t count)
1199 {
1200         ssize_t ret = count;
1201         unsigned int value;
1202         //printk("+tfa9887_cal_store: %p, %d\n", buf, count);
1203
1204         if (!buf || !count) {
1205                 ret = -EINVAL;
1206                 goto fail;
1207         }
1208         if (count == 6) {
1209                 if(calibration_need) {
1210                         memcpy(&speaker_data[420],buf,3);
1211                         memcpy(&speaker_data[420],buf+3,3);
1212                         tegra_asoc_enable_clocks();
1213                         resetMtpEx(tfa9887R);
1214                         resetMtpEx(tfa9887L);
1215                         SetMute(tfa9887R, Tfa9887_Mute_Amplifier);
1216                         SetMute(tfa9887L, Tfa9887_Mute_Amplifier);
1217                         coldStartup(tfa9887R, tfa9887R_byte, srate);
1218                         Init(tfa9887R,tfa9887R_byte, srate);
1219                         coldStartup(tfa9887L, tfa9887L_byte, srate);
1220                         Init(tfa9887L,tfa9887L_byte, srate);
1221                         calibration_need = 0;
1222                         calibrate(tfa9887R, tfa9887R_byte, &calibdata[0]);
1223                         calibrate(tfa9887L, tfa9887L_byte, &calibdata[0]);
1224                         Tfa9887_ReadRegister(tfa9887R, TFA9887_SYSTEM_CONTROL, &value);
1225                         value |= TFA9887_SYSCTRL_POWERDOWN;
1226                         Tfa9887_WriteRegister(tfa9887R, TFA9887_SYSTEM_CONTROL, value);
1227                         Tfa9887_ReadRegister(tfa9887L, TFA9887_SYSTEM_CONTROL, &value);
1228                         value |= TFA9887_SYSCTRL_POWERDOWN;
1229                         Tfa9887_WriteRegister(tfa9887L, TFA9887_SYSTEM_CONTROL, value);
1230                         tegra_asoc_disable_clocks();
1231                 }
1232         }
1233
1234 fail:
1235         //printk("-tfa9887_cal_store: %d\n", count);
1236         return ret;
1237 }
1238
1239
1240 static ssize_t tfa9887_config_show(struct kobject *kobj,
1241                 struct kobj_attribute *attr, char *buf)
1242 {
1243         printk("!tfa9887_config_show\n");
1244
1245         if (buf) {
1246                 if (eq_mode == 1)
1247                         memcpy(buf, '1', 1);
1248                 else if (eq_mode == 2)
1249                         memcpy(buf, '2', 1);
1250                 else
1251                         return -EINVAL;
1252         }
1253         return 1;
1254 }
1255
1256 static ssize_t tfa9887_config_store(struct kobject *kobj,
1257         struct kobj_attribute *attr, const char *buf, size_t count)
1258 {
1259         ssize_t ret = count;
1260
1261         //printk("+tfa9887_config_store: %p, %d\n", buf, count);
1262
1263         if (!buf || !count) {
1264                 ret = -EINVAL;
1265                 goto fail;
1266         }
1267         if (*buf == '2') {
1268                 pr_info("IN HAND MODE\n");
1269                 eq_mode = 2;
1270         }
1271         else if (*buf == '1'){
1272                 pr_info("IN DESK MODE\n");
1273                 eq_mode = 1;
1274         }
1275         Tfa9887_SetEq();
1276 fail:
1277         //printk("-tfa9887_config_store: %d\n", count);
1278         return ret;
1279 }
1280
1281 static ssize_t tfa9887_vol_show(struct kobject *kobj,
1282                 struct kobj_attribute *attr, char *buf)
1283 {
1284         printk("!tfa9887_vol_show\n");
1285         return 0;
1286 }
1287
1288 static ssize_t tfa9887_vol_store(struct kobject *kobj,
1289         struct kobj_attribute *attr, const char *buf, size_t count)
1290 {
1291         ssize_t ret = count;
1292
1293         //printk("+tfa9887_vol_store: %d, %d\n", *buf, count);
1294         if (!tfa9887R || !tfa9887L ||
1295                 !tfa9887R->deviceInit || !tfa9887L->deviceInit) {
1296                 ret = -EINVAL;
1297                 goto fail;
1298         }
1299
1300         if (!buf || !count) {
1301                 ret = -EINVAL;
1302                 goto fail;
1303         }
1304         if (*buf >= DB_CUTOFF_INDEX)
1305                 preset_mode = MAX_DB_INDEX - *buf;
1306         else
1307                 preset_mode = PRESET_DEFAULT;
1308
1309         Tfa9887_SetPreset();
1310 fail:
1311         //printk("-tfa9887_vol_store: %d\n", count);
1312         return ret;
1313 }
1314
1315 static __devinit int tfa9887R_i2c_probe(struct i2c_client *i2c,
1316                                       const struct i2c_device_id *id)
1317 {
1318         unsigned int val;
1319         int ret;
1320
1321         pr_info("tfa9887R_i2c_probe\n");
1322         tfa9887R = devm_kzalloc(&i2c->dev,  sizeof(struct tfa9887_priv),
1323                               GFP_KERNEL);
1324         tfa9887R_byte = devm_kzalloc(&i2c->dev,  sizeof(struct tfa9887_priv),
1325                               GFP_KERNEL);
1326
1327         if (tfa9887R == NULL)
1328                 return -ENOMEM;
1329         tfa9887R->regmap = regmap_init_i2c(i2c, &tfa9887_regmap);
1330         tfa9887R_byte->regmap = regmap_init_i2c(i2c, &tfa9887_regmap_byte);
1331         if (IS_ERR(tfa9887R->regmap)) {
1332                 ret = PTR_ERR(tfa9887R->regmap);
1333                 dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
1334                         ret);
1335                 return ret;
1336         }
1337
1338         i2c_set_clientdata(i2c, tfa9887R);
1339         i2c_set_clientdata(i2c, tfa9887R_byte);
1340         tfa9887R->irq = i2c->irq;
1341         tfa9887R_byte->irq = i2c->irq;
1342         ret = regmap_read(tfa9887R->regmap, TFA9887_REVISIONNUMBER, &val);
1343         if (ret != 0) {
1344                 dev_err(&i2c->dev, "Failed to read chip revision: %d\n", ret);
1345                 goto err;
1346         }
1347         dev_info(&i2c->dev, "TFA9887 revision %d\n",val);
1348         tfa9887_kobj = kobject_create_and_add("tfa9887", kernel_kobj);
1349
1350         ret = sysfs_create_file(tfa9887_kobj, &tfa9887_config);
1351         printk("tfa9887_add_sysfs ret=%d",ret);
1352         if (ret != 0) {
1353                 dev_err(&i2c->dev, "Failed to add sysfs: %d\n", ret);
1354                 goto err;
1355         }
1356         ret = sysfs_create_file(tfa9887_kobj, &tfa9887_cal);
1357         printk("tfa9887_add_sysfs ret=%d",ret);
1358         if (ret != 0) {
1359                 dev_err(&i2c->dev, "Failed to add sysfs: %d\n", ret);
1360                 goto err;
1361         }
1362         ret = sysfs_create_file(tfa9887_kobj, &tfa9887_vol);
1363         printk("tfa9887_add_sysfs ret=%d",ret);
1364         if (ret != 0) {
1365                 dev_err(&i2c->dev, "Failed to add sysfs: %d\n", ret);
1366                 goto err;
1367         }
1368         tfa9887R->deviceInit = true;
1369         eq_mode = IN_HAND_MODE;
1370         preset_mode = PRESET_DEFAULT;
1371         return 0;
1372 err:
1373         regmap_exit(tfa9887R->regmap);
1374         return ret;
1375 }
1376
1377 static __devexit int tfa9887R_i2c_remove(struct i2c_client *client)
1378 {
1379         struct tfa9887_priv *tfa9887R = i2c_get_clientdata(client);
1380         regmap_exit(tfa9887R->regmap);
1381         sysfs_remove_file(tfa9887_kobj, &tfa9887_config);
1382         sysfs_remove_file(tfa9887_kobj, &tfa9887_cal);
1383         sysfs_remove_file(tfa9887_kobj, &tfa9887_vol);
1384         kobject_del(tfa9887_kobj);
1385         return 0;
1386 }
1387
1388 static const struct of_device_id tfa9887R_of_match[] = {
1389         { .compatible = "nxp,tfa9887R", },
1390         {},
1391 };
1392 MODULE_DEVICE_TABLE(of, tfa9887R_of_match);
1393
1394 static const struct i2c_device_id tfa9887R_i2c_id[] = {
1395         { "tfa9887R", 0 },
1396         { }
1397 };
1398 MODULE_DEVICE_TABLE(i2c, tfa9887R_i2c_id);
1399
1400 static struct i2c_driver tfa9887R_i2c_driver = {
1401          .driver = {
1402          .name = "tfa9887R",
1403          .owner = THIS_MODULE,
1404          .of_match_table = tfa9887R_of_match,
1405          },
1406          .probe =    tfa9887R_i2c_probe,
1407          .remove =   __devexit_p(tfa9887R_i2c_remove),
1408          .id_table = tfa9887R_i2c_id,
1409 };
1410
1411 static __devinit int tfa9887L_i2c_probe(struct i2c_client *i2c,
1412                                       const struct i2c_device_id *id)
1413 {
1414         unsigned int val;
1415         int ret;
1416
1417         pr_info("tfa9887L_i2c_probe\n");
1418         tfa9887L = devm_kzalloc(&i2c->dev,  sizeof(struct tfa9887_priv),
1419                               GFP_KERNEL);
1420         tfa9887L_byte = devm_kzalloc(&i2c->dev,  sizeof(struct tfa9887_priv),
1421                               GFP_KERNEL);
1422
1423         if (tfa9887L == NULL)
1424                 return -ENOMEM;
1425         tfa9887L->regmap = regmap_init_i2c(i2c, &tfa9887_regmap);
1426         tfa9887L_byte->regmap = regmap_init_i2c(i2c, &tfa9887_regmap_byte);
1427         if (IS_ERR(tfa9887L->regmap)) {
1428                 ret = PTR_ERR(tfa9887L->regmap);
1429                 dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
1430                         ret);
1431                 return ret;
1432         }
1433
1434         i2c_set_clientdata(i2c, tfa9887L);
1435         tfa9887L->irq = i2c->irq;
1436         ret = regmap_read(tfa9887L->regmap, TFA9887_REVISIONNUMBER, &val);
1437         if (ret != 0) {
1438                 dev_err(&i2c->dev, "Failed to read chip revision: %d\n", ret);
1439                 goto err;
1440         }
1441         dev_info(&i2c->dev, "TFA9887 revision %d\n",val);
1442         tfa9887L->deviceInit = true;
1443         return 0;
1444 err:
1445         regmap_exit(tfa9887L->regmap);
1446         return ret;
1447 }
1448
1449 static __devexit int tfa9887L_i2c_remove(struct i2c_client *client)
1450 {
1451         struct tfa9887_priv *tfa9887L = i2c_get_clientdata(client);
1452         regmap_exit(tfa9887L->regmap);
1453         return 0;
1454 }
1455
1456 static const struct of_device_id tfa9887L_of_match[] = {
1457         { .compatible = "nxp,tfa9887L", },
1458         {},
1459 };
1460 MODULE_DEVICE_TABLE(of, tfa9887L_of_match);
1461
1462 static const struct i2c_device_id tfa9887L_i2c_id[] = {
1463         { "tfa9887L", 0 },
1464         { }
1465 };
1466 MODULE_DEVICE_TABLE(i2c, tfa9887L_i2c_id);
1467
1468 static struct i2c_driver tfa9887L_i2c_driver = {
1469          .driver = {
1470          .name = "tfa9887L",
1471          .owner = THIS_MODULE,
1472          .of_match_table = tfa9887L_of_match,
1473          },
1474          .probe =    tfa9887L_i2c_probe,
1475          .remove =   __devexit_p(tfa9887L_i2c_remove),
1476          .id_table = tfa9887L_i2c_id,
1477 };
1478
1479 static int __init tfa9887_modinit(void)
1480 {
1481          int ret = 0;
1482          ret = i2c_add_driver(&tfa9887R_i2c_driver);
1483          if (ret != 0) {
1484          printk(KERN_ERR "Failed to register tfa9887 I2C driver: %d\n",
1485             ret);
1486          }
1487          ret = i2c_add_driver(&tfa9887L_i2c_driver);
1488          if (ret != 0) {
1489          printk(KERN_ERR "Failed to register tfa9887 I2C driver: %d\n",
1490             ret);
1491          }
1492          return ret;
1493 }
1494 module_init(tfa9887_modinit);
1495
1496 static void __exit tfa9887_exit(void)
1497 {
1498          i2c_del_driver(&tfa9887R_i2c_driver);
1499          i2c_del_driver(&tfa9887L_i2c_driver);
1500 }
1501 module_exit(tfa9887_exit);
1502