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