audio: Implement tfa driver shutdown.
[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) {
739                 mutex_lock(&tfa9887R->lock);
740                 if (tfa9887R->deviceInit) {
741                         coldStartup(tfa9887R, tfa9887R_byte, srate);
742                         //Tfa9887_WriteRegister(tfa9887R, 0x0B, 0x5A); /* unlock key2 */
743                         //Tfa9887_WriteRegister(tfa9887R, TFA9887_MTP, 0); /* MTPOTC=1, MTPEX=0 */
744                         setOtc(tfa9887R,1);
745
746                         if((checkMTPEX(tfa9887R) == 0)) {
747                                 calibration = 1;
748                                 calibrate(tfa9887R, tfa9887R_byte, &calibdata[0]);
749                         }
750                         else {
751                                 error = Init(tfa9887R,tfa9887R_byte, sRate);
752
753                         }
754                 }
755                 mutex_unlock(&tfa9887R->lock);
756         }
757
758         if (tfa9887L) {
759                 mutex_lock(&tfa9887L->lock);
760                 if (tfa9887L->deviceInit) {
761                         coldStartup(tfa9887L, tfa9887L_byte, srate);
762                         //Tfa9887_WriteRegister(tfa9887L, 0x0B, 0x5A); /* unlock key2 */
763                         //Tfa9887_WriteRegister(tfa9887L, TFA9887_MTP, 0); /* MTPOTC=1, MTPEX=0 */
764                         setOtc(tfa9887L,1);
765
766                         if((checkMTPEX(tfa9887L) == 0)) {
767                                 calibration = 1;
768                                 calibrate(tfa9887L, tfa9887L_byte, &calibdata[8]);
769                         }
770                         else {
771                                 error = Init(tfa9887L,tfa9887L_byte, sRate);
772
773                         }
774                 }
775                 mutex_unlock(&tfa9887L->lock);
776         }
777         if (error != 0)
778                 pr_info("Failed to Init tfa\n");
779         return error;
780 }
781
782 void setOtc(struct tfa9887_priv *tfa9887, unsigned short otcOn)
783 {
784
785         int err;
786         unsigned int mtp;
787         unsigned int status;
788         int mtpChanged = 0;
789         int tries = 0;
790
791         err = Tfa9887_ReadRegister(tfa9887, TFA9887_MTP, &mtp);
792         /* set reset MTPEX bit if needed */
793         if ( (mtp & TFA9887_MTP_MTPOTC) != otcOn) {
794         /* need to change the OTC bit, set MTPEX=0 in any case */
795                 err = Tfa9887_WriteRegister(tfa9887, 0x0B, 0x5A); /* unlock key2 */
796
797                 err = Tfa9887_WriteRegister(tfa9887, TFA9887_MTP, otcOn); /* MTPOTC=otcOn, MTPEX=0 */
798
799                 err = Tfa9887_WriteRegister(tfa9887, 0x62, 1<<11); /* CIMTP=1 */
800
801                 mtpChanged =1;
802
803         }
804         //Sleep(13*16); /* need to wait until all parameters are copied into MTP */
805         do {
806                 err = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &status);
807                 msleep(10);
808                 tries++;
809         } while ( ((status & TFA9887_STATUS_MTPB) == TFA9887_STATUS_MTPB) && (tries < 100));
810
811         if (mtpChanged) {
812                 /* ensure the DSP restarts after this to read out the new value */
813                 err = Tfa9887_WriteRegister(tfa9887, 0x70, 0x1); /* DSP reset */
814         }
815
816 }
817
818 int Tfa9887_SetEq(void)
819 {
820         int error = 0;
821
822         if (tfa9887R) {
823                 mutex_lock(&tfa9887R->lock);
824                 if (tfa9887R->deviceInit)
825                         error = SetEq(tfa9887R, tfa9887R_byte);
826                 mutex_unlock(&tfa9887R->lock);
827         }
828
829         if (tfa9887L) {
830                 mutex_lock(&tfa9887L->lock);
831                 if (tfa9887L->deviceInit)
832                         error = SetEq(tfa9887L, tfa9887L_byte);
833                 mutex_unlock(&tfa9887L->lock);
834         }
835         return error;
836 }
837
838 int Tfa9887_SetPreset(unsigned int preset)
839 {
840         int error = 0;
841         if (preset != preset_mode) {
842                 preset_mode = preset;
843
844                 if (tfa9887R) {
845                         mutex_lock(&tfa9887R->lock);
846                         if (tfa9887R->deviceInit)
847                                 error = SetPreset(tfa9887R, tfa9887R_byte);
848                         mutex_unlock(&tfa9887R->lock);
849                 }
850
851                 if (tfa9887L) {
852                         mutex_lock(&tfa9887L->lock);
853                         if (tfa9887L->deviceInit)
854                                 error = SetPreset(tfa9887L, tfa9887L_byte);
855                         mutex_unlock(&tfa9887L->lock);
856                 }
857         }
858         return error;
859 }
860
861 int coldStartup(struct tfa9887_priv *tfa9887, struct tfa9887_priv *tfa9887_byte, int sRate)
862 {
863         int error,volume_value;
864         unsigned int value;
865         int tries = 0;
866         error = Tfa9887_WriteRegister(tfa9887, 0x09, 0x0002);
867         if (Tfa9887_Error_Ok == error) {
868                 error = Tfa9887_ReadRegister(tfa9887, 0x09, &value);
869         }
870         if (Tfa9887_Error_Ok == error) {
871                 /* DSP must be in control of the amplifier to avoid plops */
872                 value |= TFA9887_SYSCTRL_SEL_ENBL_AMP;
873                 error = Tfa9887_WriteRegister(tfa9887, 0x09, value);
874         }
875
876         /* some other registers must be set for optimal amplifier behaviour */
877         if (Tfa9887_Error_Ok == error) {
878                 error = Tfa9887_WriteRegister(tfa9887, 0x40, 0x5A6B);
879         }
880         if (Tfa9887_Error_Ok == error) {
881                 error = Tfa9887_WriteRegister(tfa9887, 0x05, 0x13AB);
882         }
883         if (Tfa9887_Error_Ok == error) {
884                 error = Tfa9887_WriteRegister(tfa9887, 0x06, 0x001F);
885         }
886         if (Tfa9887_Error_Ok == error) {
887                 error = Tfa9887_WriteRegister(tfa9887,
888                 TFA9887_SPKR_CALIBRATION, 0x3C4E); /*  adjusted to mandatory defaults */
889         }
890         if (Tfa9887_Error_Ok == error) {
891                 error = Tfa9887_WriteRegister(tfa9887, 0x09, 0x025D);
892         }
893         if (Tfa9887_Error_Ok == error) {
894                 error = Tfa9887_WriteRegister(tfa9887, 0x0A, 0x3EC3);
895         }
896         if (Tfa9887_Error_Ok == error) {
897                 error = Tfa9887_WriteRegister(tfa9887, 0x41, 0x0308);
898         }
899         if (Tfa9887_Error_Ok == error) {
900                 error = Tfa9887_WriteRegister(tfa9887, 0x48, 0x0180);
901         }
902         if (Tfa9887_Error_Ok == error) {
903                 error = Tfa9887_WriteRegister(tfa9887, 0x49, 0x0E82);
904         }
905         if (Tfa9887_Error_Ok == error) {
906                 error = Tfa9887_WriteRegister(tfa9887, 0x52, 0x0000);
907         }
908         if (Tfa9887_Error_Ok == error) {
909                 error = Tfa9887_WriteRegister(tfa9887, 0x40, 0x0000);
910         }
911         //Set Sampling Frequency
912         error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_CONTROL, &value);
913         if (error == Tfa9887_Error_Ok) {
914                 // clear the 4 bits first
915                 value &= (~(0xF<<TFA9887_I2SCTRL_RATE_SHIFT));
916                 switch (sRate) {
917                 case 48000:
918                         value |= TFA9887_I2SCTRL_RATE_48000;
919                         break;
920                 case 44100:
921                         value |= TFA9887_I2SCTRL_RATE_44100;
922                         break;
923                 case 32000:
924                         value |= TFA9887_I2SCTRL_RATE_32000;
925                         break;
926                 case 24000:
927                         value |= TFA9887_I2SCTRL_RATE_24000;
928                         break;
929                 case 22050:
930                         value |= TFA9887_I2SCTRL_RATE_22050;
931                         break;
932                 case 16000:
933                         value |= TFA9887_I2SCTRL_RATE_16000;
934                         break;
935                 case 12000:
936                         value |= TFA9887_I2SCTRL_RATE_12000;
937                         break;
938                 case 11025:
939                         value |= TFA9887_I2SCTRL_RATE_11025;
940                         break;
941                 case 8000:
942                         value |= TFA9887_I2SCTRL_RATE_08000;
943                         break;
944                 default:
945                         pr_info("unsupported samplerate\n");
946                         error = -1;
947                         return error;
948                 }
949                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_CONTROL, value);
950         }
951         volume_value = volume_step[PRESET_DEFAULT];
952         error = Tfa9887_ReadRegister(tfa9887, TFA9887_AUDIO_CONTROL, &value);
953         if(error == Tfa9887_Error_Ok) {
954                 value = (value&0x00FF) | (unsigned int)(volume_value<<8);
955                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_AUDIO_CONTROL, value);
956         }
957         //PowerUp
958         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
959         if(error == Tfa9887_Error_Ok) {
960                 value &= ~(TFA9887_SYSCTRL_POWERDOWN);
961                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
962         }
963
964                 //Waiting for IC to startup
965                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &value);
966                 do {
967                         error = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &value);
968                         msleep(1);
969                         tries++;
970                 } while ((error == Tfa9887_Error_Ok) && ((value & TFA9887_STATUS_PLLS) == 0) && (tries < 100));
971
972         //Firmware
973         error = ProcessPatchFile(tfa9887, tfa9887_byte, 10, coldpatch_data);
974                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_STATUS, &value);
975                 if(value & TFA9887_STATUS_ACS)
976                         //pr_info("TFA COLD BOOTED\n");
977         error = ProcessPatchFile(tfa9887, tfa9887_byte, sizeof(n1d2_data), n1d2_data);
978
979         return error;
980 }
981
982 int Init(struct tfa9887_priv *tfa9887,struct tfa9887_priv *tfa9887_byte, int sRate)
983 {
984         int error;
985         unsigned int value;
986
987         error = loadSettings(tfa9887, tfa9887_byte);
988         if(error != Tfa9887_Error_Ok) {
989                 pr_info("Loading Settings Failed\n");
990         }
991
992         error = stereoRouting(tfa9887);
993
994         if(error != Tfa9887_Error_Ok) {
995                 pr_info("Stereo routing Failed\n");
996         }
997
998          //SetConfigured
999         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
1000         if(error == Tfa9887_Error_Ok)
1001         {
1002                 value |= TFA9887_SYSCTRL_CONFIGURED;
1003                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
1004         }
1005         if (!calibration) {
1006                 SetMute(tfa9887, Tfa9887_Mute_Amplifier);
1007                 //PowerDown
1008                 if(error == Tfa9887_Error_Ok)
1009                 {
1010                         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
1011                         value |= TFA9887_SYSCTRL_POWERDOWN;
1012                         error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
1013                 }
1014         }
1015
1016         return error;
1017 }
1018
1019 int SetEq(struct tfa9887_priv *tfa9887,struct tfa9887_priv *tfa9887_byte)
1020 {
1021         int error = 0;
1022         if (eq_mode == IN_HAND_MODE) {
1023                 //pr_info("Setting hand mode\n");
1024                 error = DspSetParam(tfa9887,tfa9887_byte, MODULE_BIQUADFILTERBANK,0, 180, eq_data_hand);
1025         } else if (eq_mode == ON_DESK_MODE) {
1026                 //pr_info("setting deskmode\n");
1027                 error = DspSetParam(tfa9887,tfa9887_byte, MODULE_BIQUADFILTERBANK,0, 180, eq_data_table);
1028         }
1029         return error;
1030 }
1031
1032 int SetPreset(struct tfa9887_priv *tfa9887,struct tfa9887_priv *tfa9887_byte)
1033 {
1034         int error = 0;
1035         unsigned int value = 0;
1036         unsigned int volume_value = 0;
1037
1038     switch(preset_mode) {
1039             case 0:
1040                                         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_PRESET, 87, preset_data0);
1041                     break;
1042             case 1:
1043                                         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_PRESET, 87, preset_data1);
1044                     break;
1045             case 2:
1046                                         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_PRESET, 87, preset_data2);
1047                     break;
1048             case 3:
1049                                         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_PRESET, 87, preset_data3);
1050                     break;
1051             case 4:
1052                                         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_PRESET, 87, preset_data4);
1053                     break;
1054             default:
1055             return -1;
1056     }
1057         volume_value = volume_step[preset_mode];
1058         //volume_value = volume_step[PRESET_DEFAULT];
1059         //pr_info("%u %u\n",preset_mode,volume_value);
1060         error = Tfa9887_ReadRegister(tfa9887, TFA9887_AUDIO_CONTROL, &value);
1061     if(error == Tfa9887_Error_Ok) {
1062             value = (value&0x00FF) | (unsigned int)(volume_value<<8);
1063             error = Tfa9887_WriteRegister(tfa9887, TFA9887_AUDIO_CONTROL, value);
1064     }
1065         return error;
1066 }
1067
1068 int loadSettings(struct tfa9887_priv *tfa9887,struct tfa9887_priv *tfa9887_byte)
1069 {
1070         int error;
1071         //Load settings
1072         error = DspSetParam(tfa9887,tfa9887_byte,MODULE_SPEAKERBOOST, PARAM_SET_LSMODEL, 423, speaker_data);
1073         error = DspSetParam(tfa9887,tfa9887_byte, MODULE_SPEAKERBOOST, PARAM_SET_CONFIG, 165, config_data);
1074                 SetPreset(tfa9887,tfa9887_byte);
1075                 SetEq(tfa9887,tfa9887_byte);
1076         return error;
1077 }
1078
1079 int stereoRouting(struct tfa9887_priv *tfa9887)
1080 {
1081         int error;
1082         unsigned int value;
1083         if(tfa9887 == tfa9887L) {
1084                 //select channel
1085                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_CONTROL, &value);
1086                 // clear the 2 bits first
1087                 value &= ~(0x3<<TFA9887_I2SCTRL_CHANSEL_SHIFT);
1088
1089                 value |=(1<<TFA9887_I2SCTRL_CHANSEL_SHIFT);
1090                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_CONTROL, value);
1091
1092                 //select ouput left for gain
1093                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_SEL, &value);
1094                 value &= ~(0x7<<TFA9887_I2SSEL_I2SOUT_LEFT_SHIFT);
1095                 value |=(1<<TFA9887_I2SSEL_I2SOUT_LEFT_SHIFT);
1096                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_SEL, value);
1097                 //Select stereo gain
1098                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_CONTROL, &value);
1099                 value &= ~(0x1<<TFA9887_I2SCTRL_DATAI2_SHIFT);
1100                 value |=(1<<TFA9887_I2SCTRL_DATAI2_SHIFT);
1101                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_CONTROL, value);
1102
1103                 //select output right for current sense
1104                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_SEL, &value);
1105                 value &= ~(0x7<<TFA9887_I2SSEL_I2SOUT_RIGHT_SHIFT);
1106                 value |=(0<<TFA9887_I2SSEL_I2SOUT_RIGHT_SHIFT);
1107                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_SEL, value);
1108                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_SEL, value);
1109                 //pr_info("Tfa inside left\n");
1110
1111          }
1112          else if (tfa9887 == tfa9887R) {
1113                 // clear the 2 bits first
1114                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_CONTROL, &value);
1115                 value &= ~(0x3<<TFA9887_I2SCTRL_CHANSEL_SHIFT);
1116
1117                 value |=(2<<TFA9887_I2SCTRL_CHANSEL_SHIFT);
1118                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_CONTROL, value);
1119
1120                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_SEL, &value);
1121                 value &= ~(0x7<<TFA9887_I2SSEL_I2SOUT_RIGHT_SHIFT);
1122                 value |=(1<<TFA9887_I2SSEL_I2SOUT_RIGHT_SHIFT);
1123                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_SEL, value);
1124
1125                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_CONTROL, &value);
1126                 value &= ~(0x1<<TFA9887_I2SCTRL_DATAI2_SHIFT);
1127                 value |=(0<<TFA9887_I2SCTRL_DATAI2_SHIFT);
1128                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_CONTROL, value);
1129
1130                 error = Tfa9887_ReadRegister(tfa9887, TFA9887_I2S_SEL, &value);
1131                 value &= ~(0x7<<TFA9887_I2SSEL_I2SOUT_LEFT_SHIFT);
1132                 value |=(0<<TFA9887_I2SSEL_I2SOUT_LEFT_SHIFT);
1133                 error = Tfa9887_WriteRegister(tfa9887, TFA9887_I2S_SEL, value);
1134                 //pr_info("tfa inside right\n");
1135
1136         }
1137         else
1138         {
1139                 error = -1;
1140         }
1141         return error;
1142 }
1143
1144 int Tfa9887_Powerdown(int powerdown)
1145 {
1146         int error = 0;
1147
1148         if (tfa9887R) {
1149                 mutex_lock(&tfa9887R->lock);
1150                 if (tfa9887R->deviceInit)
1151                         error = Powerdown(tfa9887R, tfa9887R_byte, powerdown);
1152                 mutex_unlock(&tfa9887R->lock);
1153         }
1154
1155         if (tfa9887L) {
1156                 mutex_lock(&tfa9887L->lock);
1157                 if (tfa9887L->deviceInit)
1158                         error = Powerdown(tfa9887L, tfa9887L_byte, powerdown);
1159                 mutex_unlock(&tfa9887L->lock);
1160         }
1161         return error;
1162 }
1163
1164 EXPORT_SYMBOL(Tfa9887_Powerdown);
1165
1166 int Powerdown(struct tfa9887_priv *tfa9887, struct tfa9887_priv *tfa9887_byte, int powerdown)
1167 {
1168         int error;
1169         unsigned int value;
1170
1171         /* read the SystemControl register, modify the bit and write again */
1172         error = Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
1173         if (error != Tfa9887_Error_Ok) {
1174                 return error;
1175         }
1176
1177         switch(powerdown) {
1178                 case 1:
1179                         value |= TFA9887_SYSCTRL_POWERDOWN;
1180                         SetMute(tfa9887,Tfa9887_Mute_Amplifier);
1181                         break;
1182                 case 0:
1183                         value &= ~(TFA9887_SYSCTRL_POWERDOWN);
1184                         break;
1185                 default:
1186                 return -1;
1187         }
1188         error = Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
1189         if(!powerdown) {
1190                 SetMute(tfa9887,Tfa9887_Mute_Off);
1191                 SetPreset(tfa9887,tfa9887_byte);
1192                 SetEq(tfa9887,tfa9887_byte);
1193         }
1194
1195
1196         return error;
1197 }
1198
1199 int SetMute(struct tfa9887_priv *tfa9887, Tfa9887_Mute_t mute)
1200 {
1201         int error;
1202         unsigned int audioctrl_value;
1203         unsigned int sysctrl_value;
1204         error =
1205             Tfa9887_ReadRegister(tfa9887, TFA9887_AUDIO_CONTROL,
1206                                    &audioctrl_value);
1207         if (error != Tfa9887_Error_Ok)
1208                 return error;
1209         error =
1210             Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL,
1211                                    &sysctrl_value);
1212         if (error != Tfa9887_Error_Ok)
1213                 return error;
1214         switch (mute) {
1215         case Tfa9887_Mute_Off:
1216                 /* previous state can be digital or amplifier mute,
1217                  * clear the cf_mute and set the enbl_amplifier bits
1218                  */
1219                 audioctrl_value &= ~(TFA9887_AUDIOCTRL_MUTE);
1220                 sysctrl_value |= TFA9887_SYSCTRL_ENBL_AMP;
1221                 break;
1222         case Tfa9887_Mute_Digital:
1223                 /* expect the amplifier to run */
1224                 /* set the cf_mute bit */
1225                 audioctrl_value |= TFA9887_AUDIOCTRL_MUTE;
1226                 /* set the enbl_amplifier bit */
1227                 sysctrl_value |= TFA9887_SYSCTRL_ENBL_AMP;
1228                 break;
1229         case Tfa9887_Mute_Amplifier:
1230                 /* clear the cf_mute bit */
1231                 audioctrl_value &= ~TFA9887_AUDIOCTRL_MUTE;
1232                 /* clear the enbl_amplifier bit */
1233                 sysctrl_value &= ~TFA9887_SYSCTRL_ENBL_AMP;
1234                 break;
1235         default:
1236                 error = -1;
1237         }
1238         if (error != Tfa9887_Error_Ok)
1239                 return error;
1240         error =
1241             Tfa9887_WriteRegister(tfa9887, TFA9887_AUDIO_CONTROL,
1242                                     audioctrl_value);
1243         if (error != Tfa9887_Error_Ok)
1244                 return error;
1245         error =
1246             Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL,
1247                                     sysctrl_value);
1248         return error;
1249 }
1250 bool tfa9887_readable_register(struct device *dev, unsigned int reg)
1251 {
1252          return true;
1253 }
1254
1255 bool tfa9887_volatile_register(struct device *dev, unsigned int reg)
1256 {
1257          return true;
1258 }
1259
1260 static const struct regmap_config tfa9887_regmap = {
1261         .reg_bits = 8,
1262         .val_bits = 16,
1263         .volatile_reg = tfa9887_volatile_register,
1264         .readable_reg = tfa9887_readable_register,
1265         .cache_type = REGCACHE_NONE,
1266 };
1267
1268 static const struct regmap_config tfa9887_regmap_byte = {
1269         .reg_bits = 8,
1270         .val_bits = 8,
1271         .volatile_reg = tfa9887_volatile_register,
1272         .readable_reg = tfa9887_readable_register,
1273         .cache_type = REGCACHE_NONE,
1274 };
1275 static ssize_t tfa9887_cal_show(struct kobject *kobj,
1276                 struct kobj_attribute *attr, char *buf)
1277 {
1278         //printk("!tfa9887_cal_show\n");
1279         if (calibration) {
1280                 memcpy(buf, calibdata, 16);
1281                 return 16;
1282                 //pr_info("copying data\n");
1283         }
1284         else
1285         return -1;
1286 }
1287
1288 static ssize_t tfa9887_cal_store(struct kobject *kobj,
1289         struct kobj_attribute *attr, const char *buf, size_t count)
1290 {
1291         ssize_t ret = count;
1292         //printk("+tfa9887_cal_store: %p, %d\n", buf, count);
1293
1294         if (!buf || !count) {
1295                 ret = -EINVAL;
1296                 goto fail;
1297         }
1298         if (count == 6) {
1299                 if (calibration) {
1300                         recalibration = 1;
1301                         tegra_asoc_enable_clocks();
1302                         memcpy(&speaker_data[420],buf,3);
1303                         recalibrate(tfa9887R, tfa9887R_byte);
1304                         memcpy(&speaker_data[420],buf+3,3);
1305                         recalibrate(tfa9887L, tfa9887L_byte);
1306                         recalibration = 0;
1307                         calibration = 0;
1308                         tegra_asoc_disable_clocks();
1309                 }
1310         }
1311 fail:
1312         //printk("-tfa9887_cal_store: %d\n", count);
1313         return ret;
1314 }
1315
1316 void recalibrate(struct tfa9887_priv *tfa9887, struct tfa9887_priv *tfa9887_byte) {
1317
1318         unsigned int value;
1319         if (tfa9887) {
1320                 mutex_lock(&tfa9887->lock);
1321                 if (tfa9887->deviceInit) {
1322                         resetMtpEx(tfa9887);
1323                         SetMute(tfa9887, Tfa9887_Mute_Amplifier);
1324                         coldStartup(tfa9887, tfa9887_byte, srate);
1325                         Init(tfa9887,tfa9887_byte, srate);
1326                         calibrate(tfa9887, tfa9887_byte, &calibdata[0]);
1327                         Tfa9887_ReadRegister(tfa9887, TFA9887_SYSTEM_CONTROL, &value);
1328                         value |= TFA9887_SYSCTRL_POWERDOWN;
1329                         Tfa9887_WriteRegister(tfa9887, TFA9887_SYSTEM_CONTROL, value);
1330                 }
1331                 mutex_unlock(&tfa9887->lock);
1332         }
1333 }
1334
1335 static ssize_t tfa9887_config_show(struct kobject *kobj,
1336                 struct kobj_attribute *attr, char *buf)
1337 {
1338         //printk("!tfa9887_config_show\n");
1339
1340         if (buf) {
1341                 if (eq_mode == 1)
1342                         *buf = '1';
1343                 else if (eq_mode == 2)
1344                         *buf = '2';
1345                 else
1346                         return -EINVAL;
1347         }
1348         printk("%c\n",*buf);
1349         return 1;
1350 }
1351
1352 static ssize_t tfa9887_config_store(struct kobject *kobj,
1353         struct kobj_attribute *attr, const char *buf, size_t count)
1354 {
1355         ssize_t ret = count;
1356
1357         //printk("+tfa9887_config_store: %p, %d\n", buf, count);
1358
1359         if (!buf || !count) {
1360                 ret = -EINVAL;
1361                 goto fail;
1362         }
1363         if (*buf == '2') {
1364                 pr_info("IN HAND MODE\n");
1365                 eq_mode = 2;
1366         }
1367         else if (*buf == '1'){
1368                 pr_info("IN DESK MODE\n");
1369                 eq_mode = 1;
1370         }
1371         Tfa9887_SetEq();
1372 fail:
1373         //printk("-tfa9887_config_store: %d\n", count);
1374         return ret;
1375 }
1376
1377 static ssize_t tfa9887_vol_show(struct kobject *kobj,
1378                 struct kobj_attribute *attr, char *buf)
1379 {
1380         printk("!tfa9887_vol_show\n");
1381         return 0;
1382 }
1383
1384 static ssize_t tfa9887_vol_store(struct kobject *kobj,
1385         struct kobj_attribute *attr, const char *buf, size_t count)
1386 {
1387         ssize_t ret = count;
1388         unsigned int preset;
1389
1390         //printk("+tfa9887_vol_store: %d, %d\n", *buf, count);
1391
1392         if (!buf || !count) {
1393                 ret = -EINVAL;
1394                 goto fail;
1395         }
1396         if (*buf >= DB_CUTOFF_INDEX)
1397                 preset = MAX_DB_INDEX - *buf;
1398         else
1399                 preset = PRESET_DEFAULT;
1400
1401         Tfa9887_SetPreset(preset);
1402 fail:
1403         //printk("-tfa9887_vol_store: %d\n", count);
1404         return ret;
1405 }
1406
1407 static __devinit int tfa9887R_i2c_probe(struct i2c_client *i2c,
1408                                       const struct i2c_device_id *id)
1409 {
1410         unsigned int val;
1411         int ret;
1412
1413         pr_info("tfa9887R_i2c_probe\n");
1414         tfa9887R = devm_kzalloc(&i2c->dev,  sizeof(struct tfa9887_priv),
1415                               GFP_KERNEL);
1416         tfa9887R_byte = devm_kzalloc(&i2c->dev,  sizeof(struct tfa9887_priv),
1417                               GFP_KERNEL);
1418
1419         if (tfa9887R == NULL)
1420                 return -ENOMEM;
1421         tfa9887R->regmap = regmap_init_i2c(i2c, &tfa9887_regmap);
1422         tfa9887R_byte->regmap = regmap_init_i2c(i2c, &tfa9887_regmap_byte);
1423         if (IS_ERR(tfa9887R->regmap)) {
1424                 ret = PTR_ERR(tfa9887R->regmap);
1425                 dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
1426                         ret);
1427                 return ret;
1428         }
1429
1430         i2c_set_clientdata(i2c, tfa9887R);
1431         i2c_set_clientdata(i2c, tfa9887R_byte);
1432         mutex_init(&tfa9887R->lock);
1433         tfa9887R->irq = i2c->irq;
1434         tfa9887R_byte->irq = i2c->irq;
1435         ret = regmap_read(tfa9887R->regmap, TFA9887_REVISIONNUMBER, &val);
1436         if (ret != 0) {
1437                 dev_err(&i2c->dev, "Failed to read chip revision: %d\n", ret);
1438                 goto err;
1439         }
1440         dev_info(&i2c->dev, "TFA9887 revision %d\n",val);
1441         tfa9887_kobj = kobject_create_and_add("tfa9887", kernel_kobj);
1442
1443         ret = sysfs_create_file(tfa9887_kobj, &tfa9887_config);
1444         printk("tfa9887_add_sysfs ret=%d",ret);
1445         if (ret != 0) {
1446                 dev_err(&i2c->dev, "Failed to add sysfs: %d\n", ret);
1447                 goto err;
1448         }
1449         ret = sysfs_create_file(tfa9887_kobj, &tfa9887_cal);
1450         printk("tfa9887_add_sysfs ret=%d",ret);
1451         if (ret != 0) {
1452                 dev_err(&i2c->dev, "Failed to add sysfs: %d\n", ret);
1453                 goto err;
1454         }
1455         ret = sysfs_create_file(tfa9887_kobj, &tfa9887_vol);
1456         printk("tfa9887_add_sysfs ret=%d",ret);
1457         if (ret != 0) {
1458                 dev_err(&i2c->dev, "Failed to add sysfs: %d\n", ret);
1459                 goto err;
1460         }
1461         if (tfa9887R) {
1462                 mutex_lock(&tfa9887R->lock);
1463                 tfa9887R->deviceInit = true;
1464                 mutex_unlock(&tfa9887R->lock);
1465         }
1466         eq_mode = IN_HAND_MODE;
1467         preset_mode = PRESET_DEFAULT;
1468         return 0;
1469 err:
1470         regmap_exit(tfa9887R->regmap);
1471         return ret;
1472 }
1473
1474 static __devexit int tfa9887R_i2c_remove(struct i2c_client *client)
1475 {
1476         struct tfa9887_priv *tfa9887R = i2c_get_clientdata(client);
1477         regmap_exit(tfa9887R->regmap);
1478         sysfs_remove_file(tfa9887_kobj, &tfa9887_config);
1479         sysfs_remove_file(tfa9887_kobj, &tfa9887_cal);
1480         sysfs_remove_file(tfa9887_kobj, &tfa9887_vol);
1481         kobject_del(tfa9887_kobj);
1482         return 0;
1483 }
1484
1485 static void tfa9887R_i2c_shutdown(struct i2c_client *i2c)
1486 {
1487         if (tfa9887R) {
1488                 mutex_lock(&tfa9887R->lock);
1489                 if (i2c->irq)
1490                         disable_irq(i2c->irq);
1491                 tfa9887R->deviceInit = false;
1492                 mutex_unlock(&tfa9887R->lock);
1493         }
1494 }
1495
1496 static const struct of_device_id tfa9887R_of_match[] = {
1497         { .compatible = "nxp,tfa9887R", },
1498         {},
1499 };
1500 MODULE_DEVICE_TABLE(of, tfa9887R_of_match);
1501
1502 static const struct i2c_device_id tfa9887R_i2c_id[] = {
1503         { "tfa9887R", 0 },
1504         { }
1505 };
1506 MODULE_DEVICE_TABLE(i2c, tfa9887R_i2c_id);
1507
1508 static struct i2c_driver tfa9887R_i2c_driver = {
1509          .driver = {
1510          .name = "tfa9887R",
1511          .owner = THIS_MODULE,
1512          .of_match_table = tfa9887R_of_match,
1513          },
1514          .probe =    tfa9887R_i2c_probe,
1515          .remove =   __devexit_p(tfa9887R_i2c_remove),
1516          .id_table = tfa9887R_i2c_id,
1517          .shutdown = tfa9887R_i2c_shutdown,
1518 };
1519
1520 static __devinit int tfa9887L_i2c_probe(struct i2c_client *i2c,
1521                                       const struct i2c_device_id *id)
1522 {
1523         unsigned int val;
1524         int ret;
1525
1526         pr_info("tfa9887L_i2c_probe\n");
1527         tfa9887L = devm_kzalloc(&i2c->dev,  sizeof(struct tfa9887_priv),
1528                               GFP_KERNEL);
1529         tfa9887L_byte = devm_kzalloc(&i2c->dev,  sizeof(struct tfa9887_priv),
1530                               GFP_KERNEL);
1531
1532         if (tfa9887L == NULL)
1533                 return -ENOMEM;
1534         tfa9887L->regmap = regmap_init_i2c(i2c, &tfa9887_regmap);
1535         tfa9887L_byte->regmap = regmap_init_i2c(i2c, &tfa9887_regmap_byte);
1536         if (IS_ERR(tfa9887L->regmap)) {
1537                 ret = PTR_ERR(tfa9887L->regmap);
1538                 dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
1539                         ret);
1540                 return ret;
1541         }
1542
1543         i2c_set_clientdata(i2c, tfa9887L);
1544         mutex_init(&tfa9887L->lock);
1545         tfa9887L->irq = i2c->irq;
1546         ret = regmap_read(tfa9887L->regmap, TFA9887_REVISIONNUMBER, &val);
1547         if (ret != 0) {
1548                 dev_err(&i2c->dev, "Failed to read chip revision: %d\n", ret);
1549                 goto err;
1550         }
1551         dev_info(&i2c->dev, "TFA9887 revision %d\n",val);
1552         if (tfa9887L) {
1553                 mutex_lock(&tfa9887L->lock);
1554                 tfa9887L->deviceInit = true;
1555                 mutex_unlock(&tfa9887L->lock);
1556         }
1557         return 0;
1558 err:
1559         regmap_exit(tfa9887L->regmap);
1560         return ret;
1561 }
1562
1563 static __devexit int tfa9887L_i2c_remove(struct i2c_client *client)
1564 {
1565         struct tfa9887_priv *tfa9887L = i2c_get_clientdata(client);
1566         regmap_exit(tfa9887L->regmap);
1567         return 0;
1568 }
1569
1570 static void tfa9887L_i2c_shutdown(struct i2c_client *i2c)
1571 {
1572         if (tfa9887L) {
1573                 mutex_lock(&tfa9887L->lock);
1574                 if (i2c->irq)
1575                         disable_irq(i2c->irq);
1576                 tfa9887L->deviceInit = false;
1577                 mutex_unlock(&tfa9887L->lock);
1578         }
1579 }
1580
1581 static const struct of_device_id tfa9887L_of_match[] = {
1582         { .compatible = "nxp,tfa9887L", },
1583         {},
1584 };
1585 MODULE_DEVICE_TABLE(of, tfa9887L_of_match);
1586
1587 static const struct i2c_device_id tfa9887L_i2c_id[] = {
1588         { "tfa9887L", 0 },
1589         { }
1590 };
1591 MODULE_DEVICE_TABLE(i2c, tfa9887L_i2c_id);
1592
1593 static struct i2c_driver tfa9887L_i2c_driver = {
1594          .driver = {
1595          .name = "tfa9887L",
1596          .owner = THIS_MODULE,
1597          .of_match_table = tfa9887L_of_match,
1598          },
1599          .probe =    tfa9887L_i2c_probe,
1600          .remove =   __devexit_p(tfa9887L_i2c_remove),
1601          .id_table = tfa9887L_i2c_id,
1602          .shutdown = tfa9887L_i2c_shutdown,
1603 };
1604
1605 static int __init tfa9887_modinit(void)
1606 {
1607          int ret = 0;
1608          ret = i2c_add_driver(&tfa9887R_i2c_driver);
1609          if (ret != 0) {
1610          printk(KERN_ERR "Failed to register tfa9887 I2C driver: %d\n",
1611             ret);
1612          }
1613          ret = i2c_add_driver(&tfa9887L_i2c_driver);
1614          if (ret != 0) {
1615          printk(KERN_ERR "Failed to register tfa9887 I2C driver: %d\n",
1616             ret);
1617          }
1618          return ret;
1619 }
1620 module_init(tfa9887_modinit);
1621
1622 static void __exit tfa9887_exit(void)
1623 {
1624          i2c_del_driver(&tfa9887R_i2c_driver);
1625          i2c_del_driver(&tfa9887L_i2c_driver);
1626 }
1627 module_exit(tfa9887_exit);
1628