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