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