ef91a9633569a717c9d0e03861a86313fa7f7aaf
[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
68 /* begin binary data: */
69 char n1d2_data[] = {/* 2380 */
70 0x03, 0x00, 0x70, 0x00, 0x01, 0xFB, 0x00, 0x71, 0x40
71 , 0x00, 0x38, 0x08, 0x0A, 0x6F, 0x9B, 0xA6, 0x7D, 0x04, 0xB0, 0xB6, 0x62, 0x88, 0x69, 0x7E
72 , 0xC4, 0x08, 0x6A, 0xBF, 0x54, 0xFC, 0xB5, 0x00, 0x58, 0x7F, 0x3B, 0x80, 0x01, 0x25, 0x30
73 , 0x50, 0x00, 0x80, 0x69, 0x5E, 0xD4, 0x3C, 0x3A, 0x90, 0x00, 0x0D, 0x72, 0x02, 0xC4, 0x80
74 , 0x6A, 0xBE, 0xD4, 0x3E, 0x30, 0x40, 0x00, 0x80, 0x3B, 0x80, 0x01, 0x00, 0xB0, 0xB2, 0xF6
75 , 0x48, 0x6A, 0x5E, 0x54, 0x3E, 0x3A, 0x80, 0x00, 0x80, 0x3B, 0x80, 0x01, 0x00, 0x9B, 0xA6
76 , 0xF8, 0x49, 0x39, 0x84, 0x80, 0x80, 0x92, 0x19, 0xFE, 0x9C, 0x3B, 0x62, 0x40, 0x1C, 0x9B
77 , 0x84, 0x54, 0x3D, 0x61, 0x40, 0x7E, 0x9C, 0x3B, 0x80, 0x07, 0xF1, 0xA6, 0xB6, 0x7E, 0x9C
78 , 0x3B, 0x00, 0x40, 0x21, 0xB5, 0x00, 0x58, 0x3F, 0x3B, 0x80, 0x08, 0x00, 0x9B, 0xA4, 0x7E
79 , 0x9C, 0x9B, 0xA4, 0x54, 0x3D, 0xA5, 0xB2, 0xD8, 0x3F, 0xB5, 0x00, 0x42, 0xC0, 0x3C, 0xD8
80 , 0x03, 0x00, 0x8B, 0x80, 0x7D, 0x7C, 0xB5, 0x00, 0x7E, 0x9C, 0x9B, 0x86, 0x7D, 0x04, 0x38
81 , 0x0A, 0x0A, 0x6F, 0xB0, 0xB2, 0xD4, 0x7E, 0x6A, 0x7E, 0x52, 0xFD, 0x71, 0x04, 0xD8, 0x7F
82 , 0x3B, 0x80, 0x01, 0x25, 0x30, 0x50, 0x00, 0x80, 0x69, 0x5E, 0xD5, 0x3E, 0x72, 0x02, 0xC4
83 , 0x11, 0x6A, 0xBE, 0xD4, 0xBC, 0x30, 0x40, 0x00, 0x80, 0x3B, 0x80, 0x01, 0x00, 0xB0, 0xB2
84 , 0xF6, 0x00, 0xB5, 0x00, 0x54, 0x3C, 0x3A, 0x88, 0x00, 0x80, 0xB5, 0x00, 0x54, 0x3D, 0x3B
85 , 0x80, 0x01, 0x00, 0x9B, 0xA6, 0xFE, 0x9C, 0xB5, 0x00, 0x58, 0x3F, 0x3C, 0xD8, 0x03, 0x00
86 , 0x8B, 0x80, 0x7D, 0x7C, 0xB5, 0x00, 0x7E, 0x9C, 0x3A, 0x88, 0x00, 0x0A, 0x9B, 0x8C, 0x42
87 , 0x88, 0xA6, 0x56, 0x7D, 0x05, 0x39, 0x02, 0x22, 0x20, 0xFB, 0x00, 0x71, 0x40, 0x3E, 0xAA
88 , 0x08, 0xC4, 0x00, 0x3A, 0x89, 0x00, 0xA6, 0xBA, 0x41, 0x58, 0x7B, 0xB5, 0x00, 0x5C, 0x7D
89 , 0x3B, 0x80, 0x13, 0x20, 0xBA, 0x20, 0xDA, 0x7C, 0x6D, 0x5E, 0x50, 0xBD, 0x3A, 0x91, 0x00
90 , 0x18, 0x82, 0x04, 0x7E, 0x50, 0x3A, 0x80, 0x00, 0x29, 0x3A, 0x9A, 0xFF, 0xFA, 0x38, 0x08
91 , 0x0B, 0x68, 0x38, 0x0C, 0x0B, 0x6D, 0xBF, 0x10, 0x42, 0x40, 0x38, 0x0D, 0x0B, 0x6A, 0xBB
92 , 0x00, 0x4C, 0x98, 0x6A, 0x3E, 0xD5, 0xFC, 0x31, 0x80, 0x20, 0xAF, 0x3B, 0x80, 0x01, 0x07
93 , 0x9B, 0xA2, 0xCA, 0x48, 0x7F, 0x4E, 0x54, 0xBC, 0xB5, 0x00, 0x4C, 0x88, 0x3A, 0x91, 0xFF
94 , 0x43, 0xB5, 0x00, 0x42, 0x90, 0x96, 0xF4, 0xD5, 0x3D, 0x3A, 0x81, 0xFF, 0x41, 0x61, 0x48
95 , 0xFD, 0xA9, 0x3A, 0x88, 0x00, 0xAF, 0x61, 0x8A, 0x72, 0xE8, 0x6A, 0x7E, 0xC4, 0x00, 0x30
96 , 0x40, 0x00, 0x80, 0x30, 0x70, 0x02, 0xBC, 0x3B, 0x80, 0x1C, 0x5A, 0xB5, 0x00, 0x55, 0x7C
97 , 0xB5, 0x00, 0x54, 0x3D, 0x3A, 0x88, 0x00, 0x0F, 0x62, 0x24, 0x44, 0x0A, 0x3A, 0x91, 0xFF
98 , 0x4F, 0x30, 0x50, 0x00, 0x80, 0x3B, 0x80, 0x01, 0x25, 0xB5, 0x00, 0x55, 0x7D, 0x6A, 0xDE
99 , 0x54, 0xBD, 0x3A, 0x81, 0xFF, 0xF3, 0x72, 0x22, 0xC2, 0x84, 0x30, 0xA0, 0x0A, 0x70, 0x61
100 , 0x04, 0x42, 0x98, 0x7F, 0x2C, 0x76, 0x91, 0x38, 0x0C, 0x22, 0x08, 0x60, 0x08, 0x43, 0x48
101 , 0x69, 0x3F, 0x54, 0x7D, 0xB5, 0x00, 0x52, 0xFF, 0x3B, 0x80, 0x1B, 0x5B, 0x38, 0x01, 0x0A
102 , 0x6F, 0x30, 0x00, 0x00, 0x20, 0xB9, 0x00, 0x54, 0x3D, 0x9B, 0x2B, 0x55, 0x3C, 0xB0, 0x04
103 , 0x52, 0xBE, 0x38, 0x08, 0x22, 0x01, 0xA6, 0xD0, 0x52, 0x3F, 0x3A, 0x80, 0x00, 0x0F, 0x8B
104 , 0x80, 0x42, 0x50, 0x9B, 0xA2, 0x42, 0xC0, 0xFB, 0x00, 0x71, 0x40, 0x7C, 0x3A, 0x88, 0x00
105 , 0xB4, 0xB5, 0x00, 0x53, 0x7C, 0x31, 0x1F, 0xFF, 0xE9, 0x69, 0x3F, 0x44, 0x0D, 0x3B, 0x80
106 , 0x01, 0x25, 0xB5, 0x00, 0x54, 0xFD, 0x7F, 0x4E, 0x54, 0x3D, 0xB5, 0x00, 0x44, 0x00, 0x3B
107 , 0x80, 0x01, 0x25, 0x9B, 0xA7, 0x7E, 0x9C, 0x7D, 0x8C, 0x54, 0x3D, 0x7C, 0x24, 0xC4, 0x85
108 , 0x6A, 0x3E, 0xD2, 0xBC, 0x61, 0x64, 0x44, 0x00, 0x3B, 0x80, 0x02, 0xE4, 0x30, 0x50, 0x00
109 , 0x80, 0x9B, 0xA2, 0x52, 0x3E, 0x90, 0x90, 0xD4, 0xBD, 0xA2, 0x12, 0xFB, 0x24, 0xB5, 0x00
110 , 0x4C, 0x8D, 0x3B, 0x44, 0x40, 0x7E, 0x31, 0x10, 0x00, 0x1C, 0xB5, 0x00, 0x4C, 0xCD, 0xB5
111 , 0x00, 0x58, 0x3B, 0x3C, 0xD8, 0x03, 0x00, 0x8B, 0x80, 0x7D, 0x7B, 0xB5, 0x00, 0x7E, 0x9C
112 , 0x6C, 0x3F, 0xFD, 0x02, 0x3B, 0x80, 0x10, 0xA5, 0xB5, 0x00, 0x54, 0x7E, 0xB5, 0x00, 0x54
113 , 0x3E, 0x3A, 0x90, 0x00, 0x5C, 0x30, 0x40, 0x00, 0x82, 0x7F, 0x28, 0xC2, 0x51, 0x3A, 0x9A
114 , 0xFF, 0xDE, 0x3A, 0xA3, 0x00, 0x14, 0x30, 0x41, 0x00, 0x00, 0x38, 0x10, 0x26, 0x91, 0x61
115 , 0x2C, 0x7E, 0x50, 0x3A, 0x8C, 0xFF, 0xB3, 0x30, 0x05, 0x00, 0x00, 0x3B, 0x80, 0x0A, 0x71
116 , 0xB5, 0x00, 0x40, 0x60, 0xB5, 0x00, 0x58, 0x3F, 0x3C, 0xD8, 0x03, 0x00, 0x8B, 0x80, 0x7D
117 , 0x7E, 0xB5, 0x00, 0x7E, 0x9C, 0x3C, 0xD0, 0x00, 0x8E, 0x3C, 0xCB, 0xFF, 0xB4, 0x82, 0x14
118 , 0x52, 0xF6, 0x6C, 0x3C, 0xD4, 0x78, 0xB5, 0x00, 0x55, 0xFA, 0x3B, 0x46, 0x40, 0xB8, 0x95
119 , 0xD4, 0xF9, 0x1A, 0xB5, 0x00, 0x53, 0x77, 0xB5, 0x00, 0x52, 0xB6, 0x3C, 0xC5, 0x40, 0xB7
120 , 0x6A, 0x5C, 0x62, 0x0C, 0x61, 0x84, 0xFE, 0x9C, 0x7F, 0x20, 0xC3, 0x41, 0x3C, 0xC9, 0xFF
121 , 0x72, 0x30, 0xA0, 0x02, 0x17, 0xFB, 0x00, 0x71, 0x40, 0xBA, 0x9B, 0xA0, 0xE2, 0x0B, 0x9B
122 , 0xC0, 0xD6, 0x7B, 0x9B, 0x00, 0xD4, 0xFC, 0x8B, 0x80, 0x55, 0x7D, 0x30, 0xB0, 0x21, 0x2C
123 , 0x73, 0x05, 0xD3, 0xB7, 0xB5, 0x00, 0x52, 0x7F, 0x3B, 0x80, 0x01, 0xDA, 0x3A, 0x31, 0xFF
124 , 0xFE, 0x6A, 0x1E, 0x54, 0xBA, 0x7C, 0x01, 0x78, 0x4A, 0x6A, 0x7E, 0x52, 0xB7, 0x3B, 0x80
125 , 0x01, 0x00, 0xB5, 0x00, 0x54, 0x7A, 0x9B, 0xC0, 0xD2, 0xBF, 0x90, 0x94, 0xD5, 0x3D, 0x3A
126 , 0x92, 0x00, 0x04, 0x92, 0x11, 0xD5, 0xBE, 0x6A, 0x1E, 0x54, 0xBA, 0x3A, 0x9B, 0x00, 0x05
127 , 0x7C, 0x27, 0x78, 0x06, 0xB5, 0x00, 0x55, 0x7D, 0x3B, 0x44, 0x40, 0xBF, 0x80, 0x18, 0x54
128 , 0x7A, 0x80, 0xB8, 0x54, 0xFC, 0xB5, 0x00, 0x52, 0xB6, 0x82, 0x14, 0x7E, 0x9C, 0x3B, 0x46
129 , 0x40, 0xDE, 0x6A, 0x5D, 0xD4, 0x38, 0x3C, 0xC5, 0x40, 0xDB, 0xB5, 0x00, 0x43, 0x0B, 0x94
130 , 0x18, 0xFE, 0x9C, 0xB5, 0x00, 0x43, 0x0B, 0x94, 0x18, 0xC0, 0x41, 0x3B, 0x00, 0x40, 0xDF
131 , 0xB5, 0x00, 0x58, 0x39, 0xB5, 0x00, 0x58, 0x39, 0x3C, 0xD8, 0x03, 0x00, 0x8B, 0x80, 0x7E
132 , 0x9C, 0x3C, 0xD0, 0xFF, 0x72, 0x71, 0x65, 0x7D, 0x2B, 0x6A, 0x7B, 0x42, 0x91, 0x6A, 0xBB
133 , 0xE2, 0x4B, 0x6A, 0x3D, 0x52, 0xF8, 0xB5, 0x00, 0x58, 0x7B, 0x3B, 0x80, 0x16, 0x94, 0xB5
134 , 0x00, 0x54, 0xF9, 0x7C, 0x44, 0xD4, 0xB8, 0x6A, 0x1B, 0xC2, 0x91, 0x61, 0xC0, 0x7E, 0x9C
135 , 0x6A, 0xBE, 0x54, 0xB6, 0x3B, 0x80, 0x00, 0xA9, 0x9B, 0xC3, 0x62, 0x09, 0x6A, 0xDB, 0xD4
136 , 0x3C, 0x3A, 0x90, 0x00, 0x25, 0x61, 0xCC, 0x42, 0x80, 0x6A, 0xBE, 0x54, 0xBA, 0x3B, 0x80
137 , 0x00, 0xA9, 0x9B, 0xC3, 0x62, 0x09, 0x9B, 0xA0, 0xD4, 0x37, 0x3A, 0x88, 0x00, 0x96, 0x66
138 , 0x04, 0x45, 0x0A, 0xFB, 0x00, 0x71, 0x40, 0xF8, 0x3A, 0x99, 0xFF, 0x6B, 0xB5, 0x00, 0x72
139 , 0x81, 0x80, 0x18, 0x43, 0x80, 0x6A, 0xFE, 0xD4, 0xBA, 0x3B, 0x80, 0x02, 0x8F, 0x80, 0xD4
140 , 0x62, 0x09, 0x7F, 0x4E, 0x54, 0xBD, 0xB5, 0x00, 0x43, 0x08, 0x38, 0x10, 0x00, 0xCF, 0x3B
141 , 0x80, 0x01, 0x33, 0x9B, 0xA2, 0x74, 0x56, 0x7F, 0x4E, 0x55, 0x3D, 0xB5, 0x00, 0x43, 0x10
142 , 0x3A, 0x82, 0x00, 0xC7, 0x7A, 0x2B, 0x54, 0x7D, 0x30, 0xA0, 0x12, 0x00, 0x30, 0xB0, 0x0B
143 , 0x66, 0x30, 0x50, 0x00, 0x80, 0x3B, 0x80, 0x02, 0xBE, 0xB5, 0x00, 0x62, 0x09, 0x7F, 0x4E
144 , 0x55, 0x3C, 0xB5, 0x00, 0x43, 0x10, 0x90, 0xDB, 0x54, 0xBD, 0x61, 0x44, 0x7E, 0x9C, 0xA2
145 , 0x17, 0x55, 0x39, 0x3A, 0x92, 0x00, 0xC8, 0x3A, 0x89, 0xFF, 0xBE, 0x3B, 0x43, 0x41, 0x49
146 , 0x6A, 0xBF, 0x54, 0xFD, 0x38, 0x12, 0x0B, 0x66, 0x30, 0x60, 0x00, 0x80, 0x30, 0x80, 0x12
147 , 0x00, 0x30, 0xA0, 0x01, 0x80, 0x3B, 0x80, 0x01, 0x1C, 0xB5, 0x00, 0x61, 0x46, 0xB5, 0x00
148 , 0x54, 0xB9, 0x30, 0x80, 0x01, 0x00, 0x30, 0x50, 0x01, 0x00, 0x30, 0x70, 0x00, 0x80, 0x3B
149 , 0x80, 0x1C, 0x3E, 0x38, 0x0C, 0x0B, 0x6B, 0x30, 0x90, 0x01, 0x80, 0x38, 0x0A, 0x22, 0x01
150 , 0x20, 0x80, 0x41, 0x28, 0x30, 0xA0, 0x01, 0x00, 0xB5, 0x00, 0x42, 0x11, 0xB5, 0x00, 0x43
151 , 0x08, 0xD4, 0xC8, 0x42, 0x11, 0x60, 0x24, 0xFE, 0x9C, 0x30, 0x90, 0x01, 0x00, 0x30, 0x50
152 , 0x00, 0x80, 0x30, 0xA0, 0x22, 0x29, 0x3B, 0x80, 0x02, 0x60, 0x30, 0x80, 0x01, 0x80, 0x30
153 , 0x80, 0x01, 0x00, 0x30, 0x50, 0x00, 0x80, 0x3B, 0x80, 0x00, 0xC1, 0x30, 0x90, 0x01, 0x00
154 , 0x30, 0x90, 0x01, 0x00, 0xB5, 0x00, 0x78, 0x09, 0x30, 0x50, 0x00, 0x3F, 0x3B, 0x80, 0x00
155 , 0x51, 0xFB, 0x00, 0x71, 0x41, 0x36, 0xB5, 0x00, 0x54, 0x7F, 0x38, 0x0A, 0x0B, 0x60, 0xD0
156 , 0x0C, 0x54, 0x3F, 0x30, 0x60, 0x00, 0x3F, 0x3B, 0x80, 0x00, 0x7A, 0xB5, 0x00, 0x61, 0x40
157 , 0x9B, 0xA8, 0x74, 0x55, 0xA5, 0xF2, 0xE2, 0x09, 0x38, 0x09, 0x0B, 0x69, 0x38, 0x0A, 0x0B
158 , 0x61, 0x38, 0x0C, 0x0A, 0x7C, 0x30, 0xA0, 0x0B, 0x67, 0x3B, 0x80, 0x00, 0x89, 0x9B, 0xE0
159 , 0xD3, 0xD5, 0x38, 0x0C, 0x0B, 0x67, 0x9B, 0xA8, 0x54, 0xBD, 0xA6, 0x1A, 0xFE, 0x9C, 0x3B
160 , 0x00, 0x41, 0x4A, 0x38, 0x01, 0x0B, 0x69, 0x9B, 0xA8, 0x54, 0xBD, 0x61, 0x84, 0x7E, 0x9C
161 , 0x92, 0x1B, 0xFE, 0x9C, 0x3B, 0x63, 0x41, 0x52, 0x38, 0x08, 0x0B, 0x6C, 0x9B, 0xDF, 0xD4
162 , 0xBE, 0xA5, 0xB2, 0xC3, 0x48, 0x38, 0x0B, 0x0B, 0x67, 0x38, 0x09, 0x0B, 0x69, 0x3B, 0x80
163 , 0x41, 0xD0, 0xB5, 0x00, 0x7E, 0x9C, 0x7F, 0x4E, 0x54, 0xBD, 0xB5, 0x00, 0x42, 0x88, 0x3A
164 , 0x91, 0xFF, 0x7A, 0x31, 0x20, 0x00, 0xC8, 0x82, 0x14, 0x44, 0x95, 0x3B, 0x44, 0x41, 0x60
165 , 0x38, 0x0A, 0x0B, 0x6A, 0x3A, 0x81, 0x00, 0x29, 0x38, 0x0C, 0x0B, 0x69, 0x38, 0x0E, 0x0B
166 , 0x62, 0xA2, 0x1B, 0xFE, 0x9C, 0x3B, 0x66, 0x41, 0x6F, 0x38, 0x0C, 0x0A, 0x7A, 0xA2, 0x13
167 , 0x7E, 0x9C, 0x3B, 0x64, 0x41, 0x6F, 0x38, 0x0C, 0x0A, 0x79, 0xA2, 0x13, 0x7E, 0x9C, 0x3B
168 , 0x67, 0x41, 0x6F, 0x38, 0x0C, 0x0B, 0x63, 0xD0, 0x35, 0x54, 0xB9, 0x3A, 0x89, 0x00, 0x50
169 , 0xB5, 0x00, 0x1A, 0x61, 0x38, 0x00, 0x0B, 0x68, 0x95, 0xD8, 0xC0, 0x40, 0xB3, 0xB7, 0x7E
170 , 0x9C, 0x3B, 0x00, 0x41, 0x76, 0x38, 0x0B, 0x0B, 0x6A, 0x38, 0x0C, 0x0B, 0x64, 0xD0, 0x34
171 , 0x54, 0xBE, 0x38, 0x0A, 0x0B, 0x65, 0x9B, 0x1F, 0xE1, 0x80, 0x95, 0xD8, 0xFE, 0x40, 0xFB
172 , 0x00, 0x71, 0x41, 0x74, 0xB2, 0xB7, 0x40, 0x48, 0x38, 0x0B, 0x0B, 0x6A, 0x61, 0x08, 0x54
173 , 0xBC, 0xB5, 0x00, 0x43, 0x08, 0xA2, 0x13, 0x54, 0x3E, 0x3A, 0x92, 0xFF, 0x94, 0x3B, 0x46
174 , 0x41, 0x7E, 0x3A, 0x89, 0xFF, 0xEB, 0x9B, 0xBF, 0xD4, 0xFC, 0xB5, 0x00, 0x42, 0xC0, 0xB5
175 , 0x00, 0x42, 0x90, 0x3A, 0x8A, 0xFF, 0xA5, 0x82, 0x14, 0x7E, 0x9C, 0x3B, 0x43, 0x41, 0x91
176 , 0x6A, 0x7B, 0xD5, 0x37, 0x3A, 0x8A, 0x00, 0x95, 0x31, 0x1F, 0xFF, 0x6A, 0x9B, 0xA0, 0xCC
177 , 0x0D, 0x6A, 0x7E, 0xC3, 0x90, 0x6A, 0x1B, 0x72, 0x81, 0xB5, 0x00, 0x74, 0x56, 0x30, 0xA0
178 , 0x0E, 0xBA, 0x3B, 0x80, 0x02, 0x8F, 0x80, 0x18, 0x61, 0x85, 0x6A, 0x5D, 0x55, 0x3D, 0x3B
179 , 0x80, 0x1A, 0x0A, 0x3C, 0xC8, 0xFF, 0xD6, 0x3B, 0x00, 0x41, 0x92, 0xB5, 0x00, 0x54, 0xBC
180 , 0xB5, 0x00, 0x54, 0xBC, 0x61, 0x44, 0x7E, 0x9C, 0x98, 0xB5, 0x7E, 0x9C, 0x82, 0x14, 0x7E
181 , 0x9C, 0x3B, 0x62, 0x41, 0xA3, 0x6A, 0x9C, 0x54, 0xB9, 0x3A, 0x81, 0x00, 0x14, 0x3A, 0x8A
182 , 0x00, 0x22, 0x61, 0x40, 0x43, 0x08, 0x3A, 0x90, 0xFF, 0xED, 0xD0, 0x4C, 0x43, 0x10, 0xB5
183 , 0x00, 0x54, 0xB6, 0x94, 0x03, 0xE2, 0x09, 0x30, 0xA0, 0x07, 0xA1, 0x3B, 0x80, 0x00, 0x14
184 , 0xB5, 0x00, 0x61, 0x40, 0x3B, 0x00, 0x41, 0xA4, 0xB5, 0x00, 0x55, 0xB7, 0xB5, 0x00, 0x55
185 , 0xB7, 0x3A, 0x83, 0x00, 0x97, 0x9B, 0xA0, 0xC5, 0x04, 0x31, 0x0F, 0xFF, 0x6A, 0x7F, 0x4E
186 , 0x4C, 0x05, 0xB5, 0x00, 0x72, 0x81, 0x80, 0x18, 0x43, 0x98, 0x6A, 0x3B, 0xD4, 0xB6, 0x3B
187 , 0x80, 0x02, 0x8F, 0x80, 0xD4, 0x62, 0x09, 0x6A, 0x5D, 0x55, 0x37, 0xB5, 0x00, 0x54, 0x36
188 , 0x3B, 0x80, 0x17, 0x99, 0xB5, 0x00, 0x7E, 0x9C, 0x8B, 0x80, 0x54, 0xB7, 0xFB, 0x00, 0x71
189 , 0x41, 0xB2, 0x3A, 0x89, 0x00, 0x5C, 0x3A, 0x91, 0xFF, 0xF2, 0x60, 0x00, 0x78, 0x11, 0x38
190 , 0x0A, 0x0B, 0x6A, 0xB5, 0x00, 0x4A, 0x10, 0xB3, 0x02, 0xC3, 0x08, 0x90, 0xDB, 0xCA, 0x50
191 , 0x3A, 0x98, 0x00, 0x10, 0xB2, 0xD3, 0x42, 0x98, 0x92, 0x17, 0xC3, 0x48, 0xB5, 0x00, 0x48
192 , 0x40, 0x3B, 0x42, 0x41, 0xCD, 0xB5, 0x00, 0x55, 0x39, 0x3A, 0x9A, 0x00, 0x5D, 0xB5, 0x00
193 , 0x43, 0x18, 0x82, 0x18, 0x7E, 0x9C, 0x3B, 0x66, 0x41, 0xCD, 0x3A, 0x8A, 0x00, 0x5E, 0xB5
194 , 0x00, 0x43, 0x08, 0x90, 0xD8, 0xFE, 0x9C, 0xA2, 0x1A, 0xC3, 0x48, 0x3B, 0x66, 0x41, 0xCB
195 , 0x6C, 0x1D, 0xFE, 0x4A, 0x3B, 0x00, 0x41, 0xCE, 0xB5, 0x00, 0x7E, 0x48, 0x3B, 0x00, 0x41
196 , 0xCE, 0xB5, 0x00, 0x58, 0x3B, 0xB5, 0x00, 0x58, 0x3B, 0x3C, 0xD8, 0x03, 0x00, 0x7F, 0x4E
197 , 0x7D, 0x55, 0x39, 0x84, 0x80, 0x02, 0x39, 0x86, 0x80, 0x02, 0x30, 0x40, 0x01, 0x00, 0xA8
198 , 0x1E, 0x7E, 0x9C, 0xA2, 0x02, 0x7E, 0x9C, 0x3B, 0x43, 0x41, 0xDA, 0x30, 0x10, 0x01, 0xFF
199 , 0xA8, 0x38, 0xFE, 0x9C, 0x30, 0x4F, 0xFE, 0x00, 0xA9, 0x26, 0x7E, 0x9C, 0x3C, 0xD8, 0x03
200 , 0x00, 0x9B, 0x99, 0x7E, 0x9C, 0xA0, 0x86, 0x7E, 0x9C, 0x3A, 0x89, 0x00, 0xC7, 0x7E, 0x81
201 , 0xC2, 0x88, 0x3A, 0x89, 0xFF, 0xE9, 0x6A, 0x3F, 0x54, 0xFD, 0xB5, 0x00, 0x58, 0x7F, 0x30
202 , 0x60, 0x00, 0x80, 0x3B, 0x80, 0x00, 0xB6, 0xB8, 0xA2, 0xE2, 0x48, 0xB5, 0x00, 0x54, 0xBE
203 , 0x38, 0x20, 0x0A, 0x6F, 0xB5, 0x00, 0x76, 0x88, 0x30, 0x62, 0x00, 0x00, 0xB5, 0x00, 0x42
204 , 0x90, 0xA0, 0xB7, 0x55, 0xBD, 0xB5, 0x00, 0x42, 0xD0, 0x38, 0x0C, 0x22, 0x13, 0xB5, 0x00
205 , 0x42, 0x98, 0xD0, 0x35, 0x7E, 0x9C, 0x3A, 0x83, 0xFF, 0x57, 0x3F, 0x00, 0x71, 0x41, 0xF0
206 , 0xB5, 0x00, 0x18, 0x61, 0x3A, 0x90, 0x00, 0x9B, 0xD0, 0x4C, 0x62, 0x09, 0x30, 0x70, 0x00
207 , 0x80, 0xB5, 0x00, 0x55, 0x7D, 0x3B, 0x80, 0x00, 0xA9, 0x9B, 0xC6, 0x61, 0x40, 0x7F, 0x4E
208 , 0x54, 0xBD, 0x6A, 0x1F, 0x4C, 0x08, 0x3B, 0x80, 0x01, 0x0E, 0x30, 0x50, 0x00, 0x80, 0xB5
209 , 0x00, 0x58, 0x3F, 0x3C, 0xD8, 0x03, 0x00, 0x8B, 0x80, 0x7D, 0x7D, 0xB5, 0x00, 0x7E, 0x9C
210 , 0x03, 0x00, 0x70, 0x00, 0x03, 0x21, 0x00, 0x71, 0x0A, 0x6F, 0x00, 0x00, 0x01, 0x00, 0x00
211 , 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00
212 , 0x02, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x2D, 0x00, 0x71, 0x0B, 0x60
213 , 0x00, 0xB8, 0x45, 0x7F, 0xEA, 0x29, 0x00, 0x00, 0x07, 0x40, 0x0F, 0x26, 0x3F, 0xFF, 0x9F
214 , 0x02, 0xCC, 0xCD, 0x00, 0x12, 0x00, 0x40, 0x00, 0x00, 0x01, 0x47, 0xAE, 0x00, 0x00, 0x00
215 , 0x02, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x08, 0x04, 0x00, 0x00, 0x0F, 0x00, 0x71
216 , 0x0A, 0x79, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x7E, 0x4D, 0xFE, 0x03
217 , 0x00, 0x70, 0x00, 0x05, 0x03, 0x00, 0x70, 0x00, 0x07, 0x7B, 0x00, 0x71, 0x03, 0x00, 0x00
218 , 0x00, 0x01, 0x00, 0x0B, 0x23, 0x00, 0x40, 0x00, 0x00, 0x3B, 0x80, 0x00, 0x00, 0x01, 0x00
219 , 0x0B, 0xAB, 0x00, 0x40, 0x24, 0x00, 0x3B, 0x80, 0x00, 0x00, 0x01, 0x00, 0x0D, 0xF5, 0x00
220 , 0x40, 0x3A, 0x00, 0x3B, 0x80, 0x00, 0x00, 0x01, 0x00, 0x0A, 0x6B, 0x00, 0x40, 0x97, 0x00
221 , 0x3B, 0x80, 0x00, 0x00, 0x01, 0x00, 0x05, 0xC6, 0x00, 0x40, 0xAB, 0x00, 0x3B, 0x80, 0x00
222 , 0x00, 0x01, 0x00, 0x0D, 0x24, 0x00, 0x40, 0xE2, 0x00, 0x3B, 0x80, 0x00, 0x00, 0x01, 0x00
223 , 0x12, 0x3A, 0x00, 0x7E, 0x9C, 0x00, 0xB5, 0x00, 0x00, 0x00, 0x01, 0x00, 0x05, 0x7B, 0x00
224 , 0x41, 0xD0, 0x00, 0x3B, 0x80, 0x00, 0x00, 0x01, 0x00, 0x1B, 0xA7, 0x00, 0x41, 0xDD, 0x00
225 , 0x3B, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03
226 , 0x00, 0x70, 0x00, 0x00, 0x23, 0x00, 0x70, 0x00, 0x02, 0x00, 0x01, 0x00, 0x80, 0x03, 0xFF
227 , 0xFF, 0xF9, 0xFF, 0xFF, 0xF7, 0xFF, 0xFF, 0xF6, 0x00, 0x00, 0x1D, 0x00, 0x00, 0x1B, 0x00
228 , 0x00, 0x1B, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x1C, 0x03, 0x00, 0x70, 0x01
229 , 0x12
230 };
231 /* end binary data. size = 2380bytes */
232
233 /* begin binary data: */
234 char speaker_data[] = {/* 423 */
235 0x00, 0x00, 0xD1, 0xFF, 0xFE, 0x06, 0xFF, 0xFE, 0x55, 0x00, 0x03, 0x2F, 0xFF, 0xFA, 0xF9
236 , 0x00, 0x05, 0x77, 0xFF, 0xFC, 0x89, 0xFF, 0xFC, 0x9A, 0x00, 0x00, 0x0B, 0xFF, 0xFA, 0x84
237 , 0x00, 0x02, 0x39, 0xFF, 0xFA, 0xD6, 0x00, 0x02, 0x98, 0xFF, 0xFC, 0xF7, 0x00, 0x00, 0xFE
238 , 0xFF, 0xFB, 0xD6, 0xFF, 0xFF, 0x47, 0x00, 0x02, 0x0A, 0xFF, 0xFD, 0x0F, 0x00, 0x01, 0x40
239 , 0xFF, 0xFD, 0xE5, 0xFF, 0xFE, 0x9D, 0xFF, 0xFE, 0xD6, 0xFF, 0xFE, 0x68, 0xFF, 0xFD, 0x59
240 , 0xFF, 0xFE, 0xAB, 0xFF, 0xFE, 0x65, 0x00, 0x00, 0x2E, 0xFF, 0xFB, 0x78, 0xFF, 0xFF, 0x2C
241 , 0x00, 0x00, 0x28, 0xFF, 0xFA, 0x9D, 0x00, 0x01, 0x7D, 0xFF, 0xFC, 0x9E, 0xFF, 0xFC, 0x0C
242 , 0x00, 0x01, 0x97, 0xFF, 0xF9, 0x25, 0x00, 0x00, 0xA5, 0xFF, 0xFC, 0x5B, 0xFF, 0xFF, 0x1B
243 , 0x00, 0x01, 0xCE, 0xFF, 0xF9, 0xE0, 0x00, 0x03, 0x9B, 0x00, 0x00, 0x98, 0xFF, 0xFC, 0x5D
244 , 0x00, 0x01, 0x7A, 0xFF, 0xFA, 0x43, 0xFF, 0xFF, 0x82, 0xFF, 0xFF, 0x66, 0xFF, 0xF8, 0xD6
245 , 0xFF, 0xFD, 0xE7, 0x00, 0x01, 0x04, 0xFF, 0xF7, 0xF3, 0xFF, 0xFE, 0x79, 0xFF, 0xFD, 0x5B
246 , 0xFF, 0xFB, 0xC4, 0xFF, 0xFE, 0xF5, 0xFF, 0xFA, 0x9B, 0xFF, 0xFF, 0x87, 0xFF, 0xFB, 0xC1
247 , 0xFF, 0xFD, 0xF3, 0x00, 0x00, 0x12, 0x00, 0x01, 0x8C, 0xFF, 0xF6, 0x37, 0x00, 0x05, 0x49
248 , 0xFF, 0xFA, 0x1F, 0xFF, 0xFC, 0x9E, 0x00, 0x00, 0xD8, 0xFF, 0xF7, 0x74, 0xFF, 0xFE, 0x29
249 , 0xFF, 0xFD, 0x42, 0xFF, 0xF3, 0x14, 0x00, 0x02, 0x1B, 0xFF, 0xF5, 0x86, 0xFF, 0xF7, 0x64
250 , 0xFF, 0xF6, 0x6D, 0xFF, 0xF3, 0x81, 0x00, 0x00, 0x2F, 0xFF, 0xF0, 0x35, 0xFF, 0xFC, 0xFA
251 , 0x00, 0x03, 0x5E, 0xFF, 0xF9, 0xA2, 0x00, 0x09, 0x46, 0xFF, 0xFE, 0x88, 0x00, 0x09, 0x61
252 , 0x00, 0x04, 0x3E, 0x00, 0x07, 0x57, 0x00, 0x09, 0xA2, 0xFF, 0xFD, 0x53, 0x00, 0x10, 0xD6
253 , 0xFF, 0xF7, 0xEE, 0xFF, 0xFC, 0xDC, 0x00, 0x04, 0x42, 0xFF, 0xF4, 0x9B, 0xFF, 0xF4, 0xA3
254 , 0xFF, 0xF0, 0x54, 0xFF, 0xF0, 0x30, 0xFF, 0xFB, 0x3B, 0xFF, 0xF2, 0x47, 0x00, 0x0E, 0xBA
255 , 0xFF, 0xF7, 0x96, 0x00, 0x22, 0x85, 0x00, 0x13, 0xA9, 0x00, 0x57, 0x54, 0x00, 0x13, 0x9B
256 , 0x00, 0x69, 0xD8, 0x00, 0x2B, 0xD5, 0x00, 0x73, 0x6B, 0x00, 0x40, 0x09, 0x00, 0x40, 0x8E
257 , 0xFF, 0xD6, 0x1D, 0xFF, 0xEA, 0x06, 0xFF, 0xB0, 0xD7, 0xFF, 0x5F, 0x5B, 0xFF, 0xA0, 0xAA
258 , 0x07, 0x36, 0x2D, 0xFF, 0xAA, 0xA7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
259 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
260 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6C, 0xCC, 0xCD
261 , 0x66, 0x66, 0x66, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x19, 0x99, 0x9A
262 , 0x00, 0x01, 0x76, 0x00, 0x01, 0x77, 0x04, 0x00, 0x00, 0x00, 0x67, 0xAE, 0x1C, 0xC0, 0x00
263 , 0x00, 0x6F, 0x69
264 };
265 /* end binary data. size = 423 bytes */
266
267 /* begin binary data: */
268 char config_data[] = {/* 165 */
269 0x09, 0xF3, 0x33, 0x01, 0x3E, 0x66, 0x00, 0x54, 0xCD, 0x00, 0x00, 0x14, 0x00, 0x00, 0x02
270 , 0x1A, 0xE6, 0x40, 0x1B, 0x40, 0xD4, 0x1C, 0x59, 0xDA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
271 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x4B, 0x00, 0x01, 0x4B
272 , 0x00, 0x00, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01
273 , 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x80, 0x00, 0x20, 0x00, 0x00, 0x00, 0x03, 0x47
274 , 0x01, 0x47, 0xAE, 0x00, 0x19, 0x9A, 0x00, 0x00, 0x00, 0x00, 0x0C, 0xCD, 0x02, 0x80, 0x00
275 , 0x00, 0x00, 0x01, 0x05, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0x50, 0x00, 0x00
276 , 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x19, 0x9A, 0x00, 0x00, 0x80, 0x00, 0x00, 0x02
277 , 0x00, 0x00, 0x01, 0x01, 0x47, 0xAE, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x19, 0x99, 0x9A
278 , 0x00, 0x80, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x30, 0x00, 0x00, 0x02, 0x00, 0x00, 0x18
279 , 0xEC, 0x00, 0x00, 0x00, 0x03, 0xD7, 0x01, 0x00, 0x00, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00
280 };
281 /* end binary data. size = 165 bytes */
282
283 /* begin binary data: */
284 char eq_data_hand[] = {/* 180 */
285 0x00, 0x00, 0x01, 0xC2, 0x90, 0xA8, 0x7D, 0x5E, 0x28, 0x3E, 0xB3, 0x60, 0x82, 0x99, 0x40
286 , 0x3E, 0xB3, 0x60, 0x00, 0x00, 0x01, 0xC2, 0x90, 0xA8, 0x7D, 0x5E, 0x28, 0x3E, 0xB3, 0x60
287 , 0x82, 0x99, 0x40, 0x3E, 0xB3, 0x60, 0x00, 0x00, 0x01, 0xC8, 0xCF, 0x48, 0x76, 0x89, 0x90
288 , 0x34, 0xDC, 0x58, 0x89, 0xF4, 0xCC, 0x42, 0xD2, 0xBC, 0x00, 0x00, 0x01, 0xEE, 0x00, 0x24
289 , 0x31, 0xEB, 0x08, 0x29, 0x55, 0x8C, 0x8C, 0x6F, 0x80, 0x6A, 0x4F, 0xC8, 0x00, 0x00, 0x01
290 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00
291 , 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
292 , 0x40, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
293 , 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
294 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
295 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x01
296 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00
297 };
298 /* end binary data. size = 180 bytes */
299
300 /* begin binary data: */
301 char eq_data_table[] = {/* 180 */
302 0x00, 0x00, 0x01, 0xC2, 0x90, 0xA8, 0x7D, 0x5E, 0x28, 0x3E, 0xB3, 0x60, 0x82, 0x99, 0x40
303 , 0x3E, 0xB3, 0x60, 0x00, 0x00, 0x01, 0xC2, 0x90, 0xA8, 0x7D, 0x5E, 0x28, 0x3E, 0xB3, 0x60
304 , 0x82, 0x99, 0x40, 0x3E, 0xB3, 0x60, 0x00, 0x00, 0x01, 0xC8, 0xCF, 0x48, 0x76, 0x89, 0x90
305 , 0x36, 0x25, 0x30, 0x89, 0xA7, 0x50, 0x41, 0x3C, 0x6C, 0x00, 0x00, 0x01, 0xEE, 0x00, 0x24
306 , 0x31, 0xEB, 0x08, 0x29, 0x55, 0x8C, 0x8C, 0x6F, 0x80, 0x6A, 0x4F, 0xC8, 0x00, 0x00, 0x01
307 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00
308 , 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
309 , 0x40, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
310 , 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
311 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
312 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x01
313 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00
314 };
315
316 /* end binary data. size = 180 bytes */
317
318 /* begin binary data: */
319 char preset_data0[] = {/* 87 */
320 0x00, 0x00, 0x07, 0x00, 0x01, 0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x40
321 , 0x00, 0x00, 0x00, 0x00, 0x01, 0x2C, 0x01, 0x47, 0xAE, 0x00, 0x2B, 0xB1, 0x00, 0x00, 0x9D
322 , 0x00, 0x0D, 0x1B, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x08, 0x00, 0x00
323 , 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x40, 0x00
324 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x48, 0x00, 0x01, 0x48
325 , 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x00, 0x03
326 };
327 /* end binary data. size = 87 bytes */
328
329 /* begin binary data: */
330 char preset_data1[] = {/* 87 */
331 0x00, 0x00, 0x07, 0x00, 0x01, 0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x40
332 , 0x00, 0x00, 0x00, 0x00, 0x01, 0x2C, 0x01, 0x47, 0xAE, 0x00, 0x2B, 0xB1, 0x00, 0x00, 0x9D
333 , 0x00, 0x0D, 0x1B, 0x01, 0x00, 0x00, 0x05, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00
334 , 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x40, 0x00
335 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x48, 0x00, 0x01, 0x48
336 , 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x00, 0x03
337 };
338 /* end binary data. size = 87 bytes */
339
340 char preset_data2[] = {/* 87 */
341 0x00, 0x00, 0x07, 0x00, 0x01, 0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x40
342 , 0x00, 0x00, 0x00, 0x00, 0x01, 0x2C, 0x01, 0x47, 0xAE, 0x00, 0x2B, 0xB1, 0x00, 0x00, 0x9D
343 , 0x00, 0x0D, 0x1B, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x05, 0x00, 0x00, 0x08, 0x00, 0x00
344 , 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x40, 0x00
345 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x48, 0x00, 0x01, 0x48
346 , 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x00, 0x03
347 };
348 /* end binary data. size = 87 bytes */
349
350 /* begin binary data: */
351 char preset_data3[] = {/* 87 */
352 0x00, 0x00, 0x07, 0x00, 0x01, 0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x40
353 , 0x00, 0x00, 0x00, 0x00, 0x01, 0x2C, 0x01, 0x47, 0xAE, 0x00, 0x2B, 0xB1, 0x00, 0x00, 0x9D
354 , 0x00, 0x0D, 0x1B, 0x01, 0x00, 0x00, 0x01, 0x80, 0x00, 0x04, 0x00, 0x00, 0x08, 0x00, 0x00
355 , 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x40, 0x00
356 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x48, 0x00, 0x01, 0x48
357 , 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x00, 0x03
358 };
359 /* end binary data. size = 87 bytes */
360
361 /* begin binary data: */
362 char preset_data4[] = {/* 87 */
363 0x00, 0x00, 0x07, 0x00, 0x01, 0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x40
364 , 0x00, 0x00, 0x00, 0x00, 0x01, 0x2C, 0x01, 0x47, 0xAE, 0x00, 0x2B, 0xB1, 0x00, 0x00, 0x9D
365 , 0x00, 0x0D, 0x1B, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x08, 0x00, 0x00
366 , 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x40, 0x00
367 , 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x48, 0x00, 0x01, 0x48
368 , 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0C, 0xCD, 0x00, 0x00, 0x03
369 };
370 /* end binary data. size = 87 bytes */
371
372 void convertBytes2Data(int num_bytes, const unsigned char bytes[], int data[])
373 {
374         int i; /* index for data */
375         int k; /* index for bytes */
376         int d;
377         int num_data = num_bytes/3;
378
379         for (i = 0, k = 0; i < num_data; ++i, k += 3) {
380                 d = (bytes[k] << 16) | (bytes[k+1] << 8) | (bytes[k+2]);
381                 if (bytes[k] & 0x80) {/* sign bit was set*/
382                         d = - ((1<<24)-d);
383                 }
384                 data[i] = d;
385         }
386 }
387
388 int ProcessPatchFile(struct tfa9887_priv *tfa9887, struct tfa9887_priv *tfa9887_byte, int length, const unsigned char* bytes)
389 {
390         unsigned int size;
391         int index = 0;
392         unsigned char buffer[MAX_I2C_LENGTH];
393         int error;
394         int value = 0;
395         unsigned int status;
396         error = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &status);
397         if (error == Tfa9887_Error_Ok) {
398                 if ( (status & 0x0043) != 0x0043) {
399                         /* one of Vddd, PLL and clocks not ok */
400                         error = -1;
401                 }
402         }
403         //pr_info("tfa status %u\n",status);
404         error = DspReadMem(tfa9887, tfa9887_byte, 0x2210, 1, &value);
405         //pr_info("tfa Version  %x\n",value);
406         while (index < length) {
407                 /* extract little endian length */
408                 size = bytes[index] + bytes[index+1] * 256;
409                 index += 2;
410                 if ( (index + size) > length) {
411                         /* too big, outside the buffer, error in the input data */
412                         return -1;
413                 }
414                 memcpy(buffer, bytes + index, size);
415                 error = regmap_raw_write(tfa9887_byte->regmap, buffer[0], &buffer[1] , (size -1));
416                 //pr_info("%d %d\n",buffer[0],size -1);
417                 if (error != Tfa9887_Error_Ok) {
418                         pr_info("ProcessPatchFile error\n");
419                         break;
420                 }
421                 index += size;
422         }
423         return error;
424 }
425
426 int DspReadMem(struct tfa9887_priv *tfa9887,  struct tfa9887_priv *tfa9887_byte, unsigned short start_offset, int num_words, int *pValues)
427 {
428         unsigned int cf_ctrl; /* the value to sent to the CF_CONTROLS register */
429         unsigned char bytes[MAX_I2C_LENGTH];
430         int burst_size; /* number of words per burst size */
431         int bytes_per_word=3;
432         int num_bytes;
433         int* p;
434         int error;
435         /* first set DMEM and AIF, leaving other bits intact */
436         error = Tfa9887_ReadRegister(tfa9887, TFA9887_CF_CONTROLS, &cf_ctrl);
437         if (error != Tfa9887_Error_Ok) {
438                 return error;
439         }
440         cf_ctrl &= ~0x000E; /* clear AIF & DMEM */
441         cf_ctrl |= (Tfa9887_DMEM_XMEM<<1); /* set DMEM, leave AIF cleared for autoincrement */
442         error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS, cf_ctrl);
443         if (error != Tfa9887_Error_Ok) {
444                 return error;
445         }
446         error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_MAD, start_offset);
447         if (error != Tfa9887_Error_Ok) {
448                 return error;
449         }
450         num_bytes = num_words*bytes_per_word;
451         p=pValues;
452         for (; num_bytes > 0; ) {
453                 burst_size = ROUND_DOWN(MAX_I2C_LENGTH, bytes_per_word);
454                 if (num_bytes < burst_size) {
455                         burst_size = num_bytes;
456                 }
457
458                 error = regmap_raw_read(tfa9887_byte->regmap, TFA9887_CF_MEM, bytes,burst_size);
459                 if (error != Tfa9887_Error_Ok) {
460                         return error;
461                 }
462                 convertBytes2Data(burst_size, bytes, p);
463                 num_bytes -= burst_size;
464                 p += burst_size/bytes_per_word;
465         }
466         return Tfa9887_Error_Ok;
467 }
468
469 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)
470 {
471
472         int error;
473         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 */
474         unsigned int cf_mad = 0x0001; /* memory address to be accessed (0 : Status, 1 : ID, 2 : parameters) */
475         unsigned int cf_status; /* the contents of the CF_STATUS register */
476         unsigned char mem[3];
477         int rpcStatus = STATUS_OK;
478         int tries = 0;
479
480 #if 1
481     {
482         /* minimize the number of I2C transactions by making use of the autoincrement in I2C */
483         unsigned char buffer[7];
484         /* first the data for CF_CONTROLS */
485         buffer[0] = (unsigned char)((cf_ctrl >> 8) & 0xFF);
486         buffer[1] = (unsigned char)(cf_ctrl & 0xFF);
487         /* write the contents of CF_MAD which is the subaddress following CF_CONTROLS */
488         buffer[2] = (unsigned char)((cf_mad >> 8) & 0xFF);
489         buffer[3] = (unsigned char)(cf_mad & 0xFF);
490         /* write the module and RPC id into CF_MEM, which follows CF_MAD */
491         buffer[4] = 0;
492         buffer[5] = module_id + 128;
493         buffer[6] = param_id;
494         error =
495             regmap_raw_write(tfa9887_byte->regmap, TFA9887_CF_CONTROLS,
496                              buffer, sizeof(buffer));
497     }
498 #else
499         error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS, cf_ctrl);
500         if (error == Tfa9887_Error_Ok) {
501                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_MAD, cf_mad);
502         }
503         if (error == Tfa9887_Error_Ok) {
504                 unsigned char id[3];
505                 id[0] = 0;
506                 id[1] = module_id+128;
507                 id[2] = param_id;
508                 error = regmap_raw_write(tfa9887_byte->regmap, TFA9887_CF_MEM,&id, 3);
509         }
510 #endif
511
512         error = regmap_raw_write(tfa9887_byte->regmap, TFA9887_CF_MEM, data, num_bytes);
513
514         if (error == Tfa9887_Error_Ok) {
515                 cf_ctrl |= (1<<8) | (1<<4); /* set the cf_req1 and cf_int bit */
516                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS, cf_ctrl);
517
518                 do {
519                         error = Tfa9887_ReadRegister(tfa9887, TFA9887_CF_STATUS, &cf_status);
520                         tries++;
521                         udelay(100);
522                 } while ( (error==Tfa9887_Error_Ok) && ((cf_status & 0x0100) == 0) && (tries < 10) ); /* don't wait forever, DSP is pretty quick to respond (< 1ms) */
523
524                 if (tries >= 100) {
525                         /* something wrong with communication with DSP */
526                         //pr_info("Setparam failed\n");
527                         error = -1;
528                 }
529         }
530         cf_ctrl = 0x0002;
531         cf_mad = 0x0000;
532         if (error == Tfa9887_Error_Ok) {
533                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS,cf_ctrl);
534     }
535     if (error == Tfa9887_Error_Ok) {
536             error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_MAD, cf_mad);
537     }
538     if (error == Tfa9887_Error_Ok) {
539                 error = regmap_raw_read(tfa9887_byte->regmap, TFA9887_CF_MEM,&mem,3);
540                 rpcStatus = (int)((mem[0] << 16) | (mem[1] << 8) | mem[2]);
541     }
542     if (error == Tfa9887_Error_Ok) {
543                 if (rpcStatus != STATUS_OK) {
544                         error = rpcStatus+100;
545                         //pr_info("RPC rpcStatus =%d\n",error);
546                 }
547     }
548         return error;
549 }
550
551 int DspGetParam(struct tfa9887_priv *tfa9887, struct tfa9887_priv *tfa9887_byte,
552                         unsigned char module_id, unsigned char param_id, int num_bytes, unsigned char *data)
553 {
554         int error;
555         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 */
556         unsigned int cf_mad = 0x0001; /* memory address to be accessed (0 : Status, 1 : ID, 2 : parameters) */
557         unsigned int cf_status;       /* the contents of the CF_STATUS register */
558                 unsigned char mem[3];
559                 unsigned char id[3];
560                 int tries = 0;
561         /* 1) write the id and data to the DSP XMEM */
562                 error =
563                     Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS,
564                                             cf_ctrl);
565                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_MAD, cf_mad);
566                 id[0] = 0;
567                 id[1] = module_id + 128;
568                 id[2] = param_id;
569                 /* only try MEM once, if error, need to resend mad as well */
570                 error = regmap_raw_write(tfa9887_byte->regmap, TFA9887_CF_MEM, id, 3);
571         /* 2) wake up the DSP and let it process the data */
572         if (error == 0) {
573                 cf_ctrl |= (1 << 8) | (1 << 4); /* set the cf_req1 and cf_int bit */
574                 error =
575                     Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS,
576                                             cf_ctrl);
577         }
578         /* 3) wait for the ack */
579         if (error == Tfa9887_Error_Ok) {
580                 do {
581                         error =
582                             Tfa9887_ReadRegister(tfa9887, TFA9887_CF_STATUS,
583                                                    &cf_status);
584                         tries++;
585                 }
586                 while ((error == 0) && ((cf_status & 0x0100) == 0) && (tries < 10));     /* don't wait forever, DSP is pretty quick to respond (< 1ms) */
587                 if (tries >= 10) {
588                         /* something wrong with communication with DSP */
589                         pr_info("something wrong with communication with DSP\n");
590                         return -1;
591                 }
592         }
593         /* 4) check the RPC return value */
594         cf_ctrl = 0x0002;
595         cf_mad = 0x0000;
596         if (error == Tfa9887_Error_Ok) {
597                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_CONTROLS,cf_ctrl);
598         }
599         if (error == Tfa9887_Error_Ok) {
600                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_MAD, cf_mad);
601         }
602         if (error == Tfa9887_Error_Ok) {
603                     regmap_raw_read(tfa9887_byte->regmap, TFA9887_CF_MEM,&mem,3);
604                 error = (mem[0] << 16) | (mem[1] << 8) | mem[2];
605
606         }
607         if (error != Tfa9887_Error_Ok) {
608                 pr_info("RPC error\n");
609
610         }
611
612         /* 5) read the resulting data */
613         if (error == 0) {
614                 cf_mad = 0x0002;        /* memory address to be accessed (0 : Status, 1 : ID, 2 : parameters) */
615                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_CF_MAD, cf_mad);
616         }
617         if (error == 0) {
618                         error =
619                             regmap_raw_read(tfa9887_byte->regmap, TFA9887_CF_MEM, data, num_bytes);
620                 }
621         return error;
622 }
623
624 int Tfa9887_WriteRegister(struct tfa9887_priv *tfa9887, unsigned int subaddress, unsigned int value)
625 {
626          int error = regmap_write(tfa9887->regmap,subaddress,value);
627          return error;
628 }
629
630 int Tfa9887_ReadRegister(struct tfa9887_priv *tfa9887, unsigned int subaddress, unsigned int* pValue)
631 {
632          int error = regmap_read(tfa9887->regmap,subaddress,pValue);
633          return error;
634 }
635
636 void calibrate (struct tfa9887_priv *tfa9887, struct tfa9887_priv *tfa9887_byte, char *calibdata)
637 {
638
639         int error;
640         int calibrateDone;
641         unsigned int status, value;
642         unsigned char bytes[3];
643         int data[2];
644         int tries = 0;
645
646         if(calibration_need) {
647                 SetMute(tfa9887, Tfa9887_Mute_Digital);
648                 pr_info("Inside calib\n");
649                 error = DspReadMem(tfa9887, tfa9887_byte, 231, 1, &calibrateDone);
650                 if (calibrateDone)
651                 {
652                         DspGetParam(tfa9887, tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_GET_RE0, 3, bytes);
653                         convertBytes2Data(3, bytes, &data[0]);
654                 }
655                 speaker_data[420] = 0;
656                 speaker_data[421] = 0;
657                 speaker_data[422] = 0;
658                 error = loadSettings(tfa9887, tfa9887_byte);
659         }
660
661          //SetConfigured
662         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
663
664         if(error == Tfa9887_Error_Ok)
665         {
666                 value |= TFA9887_SYSCTRL_CONFIGURED;
667                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
668         }
669
670         error = DspReadMem(tfa9887, tfa9887_byte, 231, 1, &calibrateDone);
671         while ((calibrateDone == 0) && (tries < 1000)) {
672                 error = DspReadMem(tfa9887, tfa9887_byte, 231, 1, &calibrateDone);
673                 tries++;
674         }
675         if(tries >= 1000)
676                 pr_info("Calibrate failed1\n");
677
678         tries = 0;
679         do {
680                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &status);
681                 tries++;
682         } while ( ((status & TFA9887_STATUS_MTPB) == TFA9887_STATUS_MTPB) && (tries < 100));
683         if(tries >= 100)
684                 pr_info("Calibrate failed\n");
685         DspGetParam(tfa9887, tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_GET_RE0, 3, bytes);
686         convertBytes2Data(3, bytes, &data[0]);
687         DspReadMem(tfa9887, tfa9887_byte, 232, 1, &data[1]);
688         pr_info("%d %d\n",data[0], data[1]);
689         memcpy(calibdata, (char *)data, 8);
690 }
691
692 void resetMtpEx(struct tfa9887_priv *tfa9887)
693 {
694         int err;
695         unsigned int mtp, status;
696         int tries = 0;
697         err = Tfa9887_ReadRegister(tfa9887, TFA9887_MTP, &mtp);
698
699         pr_info("%d****************1",mtp);
700         /* all settings loaded, signal the DSP to start calibration, only needed once after cold boot */
701         /* reset MTPEX bit if needed */
702         err = Tfa9887_WriteRegister(tfa9887, 0x0B, 0x5A); /* unlock key2 */
703         err = Tfa9887_WriteRegister(tfa9887, TFA9887_MTP, 1); /* MTPOTC=1, MTPEX=0 */
704
705         err = Tfa9887_WriteRegister(tfa9887, 0x62, 1<<11); /* CIMTP=1 */
706
707         do {
708                 err = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &status);
709                 tries++;
710         } while ( ((status & TFA9887_STATUS_MTPB) == TFA9887_STATUS_MTPB) && (tries < 100));
711
712 }
713
714 int checkMTPEX(struct tfa9887_priv *tfa9887)
715 {
716         unsigned int mtp;
717         int err;
718
719         err = Tfa9887_ReadRegister(tfa9887, TFA9887_MTP, &mtp);
720         if ( mtp & (1<<1))      /* check MTP bit1 (MTPEX) */
721                 return 1;                                       /* MTPEX is 1, calibration is done */
722         else
723                 return 0;                                       /* MTPEX is 0, calibration is not done yet */
724 }
725
726 int Tfa9887_Init(int sRate)
727 {
728         int error = 0;
729         srate = sRate;
730         if((tfa9887R) && (tfa9887R->deviceInit)) {
731                 coldStartup(tfa9887R, tfa9887R_byte, srate);
732                         //Tfa9887_WriteRegister(tfa9887R, 0x0B, 0x5A); /* unlock key2 */
733                         //Tfa9887_WriteRegister(tfa9887R, TFA9887_MTP, 0); /* MTPOTC=1, MTPEX=0 */
734
735                 if((checkMTPEX(tfa9887R) == 0)) {
736                         calibration_need = 1;
737                         calibrate(tfa9887R, tfa9887R_byte, &calibdata[0]);
738                 }
739                 else {
740                         error = Init(tfa9887R,tfa9887R_byte, sRate);
741
742                 }
743         }
744         if((tfa9887L) && (tfa9887L->deviceInit)) {
745                 coldStartup(tfa9887L, tfa9887L_byte, srate);
746                         //Tfa9887_WriteRegister(tfa9887L, 0x0B, 0x5A); /* unlock key2 */
747                         //Tfa9887_WriteRegister(tfa9887L, TFA9887_MTP, 0); /* MTPOTC=1, MTPEX=0 */
748                 if((checkMTPEX(tfa9887L) == 0)) {
749                         calibration_need = 1;
750                         calibrate(tfa9887L, tfa9887L_byte, &calibdata[8]);
751                 }
752                 else {
753                         error = Init(tfa9887L,tfa9887L_byte, sRate);
754
755                 }
756         }
757         if (error != 0)
758                 pr_info("Failed to Init tfa\n");
759         return error;
760 }
761
762 int Tfa9887_SetEq(void)
763 {
764         int error = 0;
765         if((tfa9887R) && (tfa9887R->deviceInit))
766                 error = SetEq(tfa9887R,tfa9887R_byte);
767         if((tfa9887L) && (tfa9887L->deviceInit))
768                 error = SetEq(tfa9887L,tfa9887L_byte);
769         return error;
770 }
771
772 int Tfa9887_SetPreset(void)
773 {
774         int error = 0;
775         unsigned short status;
776
777         if((tfa9887R) && (tfa9887R->deviceInit))
778                 error = SetPreset(tfa9887R,tfa9887R_byte);
779         if((tfa9887L) && (tfa9887L->deviceInit))
780                 error = SetPreset(tfa9887L,tfa9887L_byte);
781         return error;
782 }
783
784 int coldStartup(struct tfa9887_priv *tfa9887, struct tfa9887_priv *tfa9887_byte, int sRate)
785 {
786         int error,volume_value;
787         unsigned int value;
788         int tries = 0;
789         error = Tfa9887_WriteRegister(tfa9887, 0x09, 0x0002);
790         if (Tfa9887_Error_Ok == error) {
791                 error = Tfa9887_ReadRegister(tfa9887, 0x09, &value);
792         }
793         if (Tfa9887_Error_Ok == error) {
794                 /* DSP must be in control of the amplifier to avoid plops */
795                 value |= TFA9887_SYSCTRL_SEL_ENBL_AMP;
796                 error = Tfa9887_WriteRegister(tfa9887, 0x09, value);
797         }
798
799         /* some other registers must be set for optimal amplifier behaviour */
800         if (Tfa9887_Error_Ok == error) {
801                 error = Tfa9887_WriteRegister(tfa9887, 0x40, 0x5A6B);
802         }
803         if (Tfa9887_Error_Ok == error) {
804                 error = Tfa9887_WriteRegister(tfa9887, 0x05, 0x13AB);
805         }
806         if (Tfa9887_Error_Ok == error) {
807                 error = Tfa9887_WriteRegister(tfa9887, 0x06, 0x001F);
808         }
809         if (Tfa9887_Error_Ok == error) {
810                 error = Tfa9887_WriteRegister(tfa9887,
811                 TFA9887_SPKR_CALIBRATION, 0x3C4E); /*  adjusted to mandatory defaults */
812         }
813         if (Tfa9887_Error_Ok == error) {
814                 error = Tfa9887_WriteRegister(tfa9887, 0x09, 0x025D);
815         }
816         if (Tfa9887_Error_Ok == error) {
817                 error = Tfa9887_WriteRegister(tfa9887, 0x0A, 0x3EC3);
818         }
819         if (Tfa9887_Error_Ok == error) {
820                 error = Tfa9887_WriteRegister(tfa9887, 0x41, 0x0308);
821         }
822         if (Tfa9887_Error_Ok == error) {
823                 error = Tfa9887_WriteRegister(tfa9887, 0x48, 0x0180);
824         }
825         if (Tfa9887_Error_Ok == error) {
826                 error = Tfa9887_WriteRegister(tfa9887, 0x49, 0x0E82);
827         }
828         if (Tfa9887_Error_Ok == error) {
829                 error = Tfa9887_WriteRegister(tfa9887, 0x52, 0x0000);
830         }
831         if (Tfa9887_Error_Ok == error) {
832                 error = Tfa9887_WriteRegister(tfa9887, 0x40, 0x0000);
833         }
834         //Set Sampling Frequency
835         error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_CONTROL, &value);
836         if (error == Tfa9887_Error_Ok) {
837                 // clear the 4 bits first
838                 value &= (~(0xF<<TFA9887_I2SCTRL_RATE_SHIFT));
839                 switch (sRate) {
840                 case 48000:
841                         value |= TFA9887_I2SCTRL_RATE_48000;
842                         break;
843                 case 44100:
844                         value |= TFA9887_I2SCTRL_RATE_44100;
845                         break;
846                 case 32000:
847                         value |= TFA9887_I2SCTRL_RATE_32000;
848                         break;
849                 case 24000:
850                         value |= TFA9887_I2SCTRL_RATE_24000;
851                         break;
852                 case 22050:
853                         value |= TFA9887_I2SCTRL_RATE_22050;
854                         break;
855                 case 16000:
856                         value |= TFA9887_I2SCTRL_RATE_16000;
857                         break;
858                 case 12000:
859                         value |= TFA9887_I2SCTRL_RATE_12000;
860                         break;
861                 case 11025:
862                         value |= TFA9887_I2SCTRL_RATE_11025;
863                         break;
864                 case 8000:
865                         value |= TFA9887_I2SCTRL_RATE_08000;
866                         break;
867                 default:
868                         pr_info("unsupported samplerate\n");
869                         error = -1;
870                         return error;
871                 }
872                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_CONTROL, value);
873         }
874         volume_value = volume_step[PRESET_DEFAULT];
875         error = Tfa9887_ReadRegister(tfa9887, TFA9887_AUDIO_CONTROL, &value);
876         if(error == Tfa9887_Error_Ok) {
877                 value = (value&0x00FF) | (unsigned int)(volume_value<<8);
878                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_AUDIO_CONTROL, value);
879         }
880         //PowerUp
881         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
882         if(error == Tfa9887_Error_Ok) {
883                 value &= ~(TFA9887_SYSCTRL_POWERDOWN);
884                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
885         }
886
887                 //Waiting for IC to startup
888                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &value);
889                 do {
890                         error = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &value);
891                         tries++;
892                 } while ((error == Tfa9887_Error_Ok) && ((value & TFA9887_STATUS_PLLS) == 0) && (tries < 100));
893
894         //Firmware
895         error = ProcessPatchFile(tfa9887, tfa9887_byte, 10, coldpatch_data);
896                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &value);
897                 if(value & TFA9887_STATUS_ACS)
898                         //pr_info("TFA COLD BOOTED\n");
899         error = ProcessPatchFile(tfa9887, tfa9887_byte, sizeof(n1d2_data), n1d2_data);
900
901         return error;
902 }
903
904 int Init(struct tfa9887_priv *tfa9887,struct tfa9887_priv *tfa9887_byte, int sRate)
905 {
906         int error;
907         unsigned int value;
908
909         error = loadSettings(tfa9887, tfa9887_byte);
910         if(error != Tfa9887_Error_Ok) {
911                 pr_info("Loading Settings Failed\n");
912         }
913
914         error = stereoRouting(tfa9887);
915
916         if(error != Tfa9887_Error_Ok) {
917                 pr_info("Stereo routing Failed\n");
918         }
919
920          //SetConfigured
921         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
922         if(error == Tfa9887_Error_Ok)
923         {
924                 value |= TFA9887_SYSCTRL_CONFIGURED;
925                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
926         }
927         if (!calibration_need) {
928                 SetMute(tfa9887, Tfa9887_Mute_Amplifier);
929                 //PowerDown
930                 if(error == Tfa9887_Error_Ok)
931                 {
932                         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
933                         value |= TFA9887_SYSCTRL_POWERDOWN;
934                         error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
935                 }
936         }
937
938         return error;
939 }
940
941 int SetEq(struct tfa9887_priv *tfa9887,struct tfa9887_priv *tfa9887_byte)
942 {
943         int error = 0;
944         if (eq_mode == IN_HAND_MODE) {
945                 //pr_info("Setting hand mode\n");
946                 error = DspSetParam(tfa9887,tfa9887_byte, MODULE_BIQUADFILTERBANK,0, 180, eq_data_hand);
947         } else if (eq_mode == ON_DESK_MODE) {
948                 //pr_info("setting deskmode\n");
949                 error = DspSetParam(tfa9887,tfa9887_byte, MODULE_BIQUADFILTERBANK,0, 180, eq_data_table);
950         }
951         return error;
952 }
953
954 int SetPreset(struct tfa9887_priv *tfa9887,struct tfa9887_priv *tfa9887_byte)
955 {
956         int error = 0;
957         unsigned int value = 0;
958         unsigned int volume_value = 0;
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
1295         if (!tfa9887R || !tfa9887L ||
1296                 !tfa9887R->deviceInit || !tfa9887L->deviceInit) {
1297                 ret = -EINVAL;
1298                 goto fail;
1299         }
1300
1301         if (!buf || !count) {
1302                 ret = -EINVAL;
1303                 goto fail;
1304         }
1305         if (*buf >= DB_CUTOFF_INDEX)
1306                 preset_mode = MAX_DB_INDEX - *buf;
1307         else
1308                 preset_mode = PRESET_DEFAULT;
1309
1310         Tfa9887_SetPreset();
1311 fail:
1312         //printk("-tfa9887_vol_store: %d\n", count);
1313         return ret;
1314 }
1315
1316 static __devinit int tfa9887R_i2c_probe(struct i2c_client *i2c,
1317                                       const struct i2c_device_id *id)
1318 {
1319         unsigned int val;
1320         int ret;
1321
1322         pr_info("tfa9887R_i2c_probe\n");
1323         tfa9887R = devm_kzalloc(&i2c->dev,  sizeof(struct tfa9887_priv),
1324                               GFP_KERNEL);
1325         tfa9887R_byte = devm_kzalloc(&i2c->dev,  sizeof(struct tfa9887_priv),
1326                               GFP_KERNEL);
1327
1328         if (tfa9887R == NULL)
1329                 return -ENOMEM;
1330         tfa9887R->regmap = regmap_init_i2c(i2c, &tfa9887_regmap);
1331         tfa9887R_byte->regmap = regmap_init_i2c(i2c, &tfa9887_regmap_byte);
1332         if (IS_ERR(tfa9887R->regmap)) {
1333                 ret = PTR_ERR(tfa9887R->regmap);
1334                 dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
1335                         ret);
1336                 return ret;
1337         }
1338
1339         i2c_set_clientdata(i2c, tfa9887R);
1340         i2c_set_clientdata(i2c, tfa9887R_byte);
1341         tfa9887R->irq = i2c->irq;
1342         tfa9887R_byte->irq = i2c->irq;
1343         ret = regmap_read(tfa9887R->regmap, TFA9887_REVISIONNUMBER, &val);
1344         if (ret != 0) {
1345                 dev_err(&i2c->dev, "Failed to read chip revision: %d\n", ret);
1346                 goto err;
1347         }
1348         dev_info(&i2c->dev, "TFA9887 revision %d\n",val);
1349         tfa9887_kobj = kobject_create_and_add("tfa9887", kernel_kobj);
1350
1351         ret = sysfs_create_file(tfa9887_kobj, &tfa9887_config);
1352         printk("tfa9887_add_sysfs ret=%d",ret);
1353         if (ret != 0) {
1354                 dev_err(&i2c->dev, "Failed to add sysfs: %d\n", ret);
1355                 goto err;
1356         }
1357         ret = sysfs_create_file(tfa9887_kobj, &tfa9887_cal);
1358         printk("tfa9887_add_sysfs ret=%d",ret);
1359         if (ret != 0) {
1360                 dev_err(&i2c->dev, "Failed to add sysfs: %d\n", ret);
1361                 goto err;
1362         }
1363         ret = sysfs_create_file(tfa9887_kobj, &tfa9887_vol);
1364         printk("tfa9887_add_sysfs ret=%d",ret);
1365         if (ret != 0) {
1366                 dev_err(&i2c->dev, "Failed to add sysfs: %d\n", ret);
1367                 goto err;
1368         }
1369         tfa9887R->deviceInit = true;
1370         eq_mode = IN_HAND_MODE;
1371         preset_mode = PRESET_DEFAULT;
1372         return 0;
1373 err:
1374         regmap_exit(tfa9887R->regmap);
1375         return ret;
1376 }
1377
1378 static __devexit int tfa9887R_i2c_remove(struct i2c_client *client)
1379 {
1380         struct tfa9887_priv *tfa9887R = i2c_get_clientdata(client);
1381         regmap_exit(tfa9887R->regmap);
1382         sysfs_remove_file(tfa9887_kobj, &tfa9887_config);
1383         sysfs_remove_file(tfa9887_kobj, &tfa9887_cal);
1384         sysfs_remove_file(tfa9887_kobj, &tfa9887_vol);
1385         kobject_del(tfa9887_kobj);
1386         return 0;
1387 }
1388
1389 static const struct of_device_id tfa9887R_of_match[] = {
1390         { .compatible = "nxp,tfa9887R", },
1391         {},
1392 };
1393 MODULE_DEVICE_TABLE(of, tfa9887R_of_match);
1394
1395 static const struct i2c_device_id tfa9887R_i2c_id[] = {
1396         { "tfa9887R", 0 },
1397         { }
1398 };
1399 MODULE_DEVICE_TABLE(i2c, tfa9887R_i2c_id);
1400
1401 static struct i2c_driver tfa9887R_i2c_driver = {
1402          .driver = {
1403          .name = "tfa9887R",
1404          .owner = THIS_MODULE,
1405          .of_match_table = tfa9887R_of_match,
1406          },
1407          .probe =    tfa9887R_i2c_probe,
1408          .remove =   __devexit_p(tfa9887R_i2c_remove),
1409          .id_table = tfa9887R_i2c_id,
1410 };
1411
1412 static __devinit int tfa9887L_i2c_probe(struct i2c_client *i2c,
1413                                       const struct i2c_device_id *id)
1414 {
1415         unsigned int val;
1416         int ret;
1417
1418         pr_info("tfa9887L_i2c_probe\n");
1419         tfa9887L = devm_kzalloc(&i2c->dev,  sizeof(struct tfa9887_priv),
1420                               GFP_KERNEL);
1421         tfa9887L_byte = devm_kzalloc(&i2c->dev,  sizeof(struct tfa9887_priv),
1422                               GFP_KERNEL);
1423
1424         if (tfa9887L == NULL)
1425                 return -ENOMEM;
1426         tfa9887L->regmap = regmap_init_i2c(i2c, &tfa9887_regmap);
1427         tfa9887L_byte->regmap = regmap_init_i2c(i2c, &tfa9887_regmap_byte);
1428         if (IS_ERR(tfa9887L->regmap)) {
1429                 ret = PTR_ERR(tfa9887L->regmap);
1430                 dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
1431                         ret);
1432                 return ret;
1433         }
1434
1435         i2c_set_clientdata(i2c, tfa9887L);
1436         tfa9887L->irq = i2c->irq;
1437         ret = regmap_read(tfa9887L->regmap, TFA9887_REVISIONNUMBER, &val);
1438         if (ret != 0) {
1439                 dev_err(&i2c->dev, "Failed to read chip revision: %d\n", ret);
1440                 goto err;
1441         }
1442         dev_info(&i2c->dev, "TFA9887 revision %d\n",val);
1443         tfa9887L->deviceInit = true;
1444         return 0;
1445 err:
1446         regmap_exit(tfa9887L->regmap);
1447         return ret;
1448 }
1449
1450 static __devexit int tfa9887L_i2c_remove(struct i2c_client *client)
1451 {
1452         struct tfa9887_priv *tfa9887L = i2c_get_clientdata(client);
1453         regmap_exit(tfa9887L->regmap);
1454         return 0;
1455 }
1456
1457 static const struct of_device_id tfa9887L_of_match[] = {
1458         { .compatible = "nxp,tfa9887L", },
1459         {},
1460 };
1461 MODULE_DEVICE_TABLE(of, tfa9887L_of_match);
1462
1463 static const struct i2c_device_id tfa9887L_i2c_id[] = {
1464         { "tfa9887L", 0 },
1465         { }
1466 };
1467 MODULE_DEVICE_TABLE(i2c, tfa9887L_i2c_id);
1468
1469 static struct i2c_driver tfa9887L_i2c_driver = {
1470          .driver = {
1471          .name = "tfa9887L",
1472          .owner = THIS_MODULE,
1473          .of_match_table = tfa9887L_of_match,
1474          },
1475          .probe =    tfa9887L_i2c_probe,
1476          .remove =   __devexit_p(tfa9887L_i2c_remove),
1477          .id_table = tfa9887L_i2c_id,
1478 };
1479
1480 static int __init tfa9887_modinit(void)
1481 {
1482          int ret = 0;
1483          ret = i2c_add_driver(&tfa9887R_i2c_driver);
1484          if (ret != 0) {
1485          printk(KERN_ERR "Failed to register tfa9887 I2C driver: %d\n",
1486             ret);
1487          }
1488          ret = i2c_add_driver(&tfa9887L_i2c_driver);
1489          if (ret != 0) {
1490          printk(KERN_ERR "Failed to register tfa9887 I2C driver: %d\n",
1491             ret);
1492          }
1493          return ret;
1494 }
1495 module_init(tfa9887_modinit);
1496
1497 static void __exit tfa9887_exit(void)
1498 {
1499          i2c_del_driver(&tfa9887R_i2c_driver);
1500          i2c_del_driver(&tfa9887L_i2c_driver);
1501 }
1502 module_exit(tfa9887_exit);
1503