1 // SPDX-License-Identifier: GPL-2.0
2 //
3 // ALSA SoC Texas Instruments TAS2783 Audio Smart Amplifier
4 //
5 // Copyright (C) 2025 Texas Instruments Incorporated
6 // https://www.ti.com
7 //
8 // The TAS2783 driver implements a flexible and configurable
9 // algo coefficient setting for single TAS2783 chips.
10 //
11 // Author: Niranjan H Y <niranjanhy@ti.com>
12 // Author: Baojun Xu <baojun.xu@ti.com>
13 // Author: Kevin Lu <kevin-lu@ti.com>
14
15 #include <linux/unaligned.h>
16 #include <linux/crc32.h>
17 #include <linux/efi.h>
18 #include <linux/err.h>
19 #include <linux/firmware.h>
20 #include <linux/init.h>
21 #include <linux/module.h>
22 #include <sound/pcm_params.h>
23 #include <linux/pm.h>
24 #include <linux/pm_runtime.h>
25 #include <linux/regmap.h>
26 #include <linux/wait.h>
27 #include <linux/soundwire/sdw.h>
28 #include <linux/soundwire/sdw_registers.h>
29 #include <linux/soundwire/sdw_type.h>
30 #include <sound/sdw.h>
31 #include <sound/soc.h>
32 #include <sound/tlv.h>
33 #include <sound/tas2781-tlv.h>
34
35 #include "tas2783.h"
36
37 #define TIMEOUT_FW_DL_MS (3000)
38 #define FW_DL_OFFSET 36
39 #define FW_FL_HDR 12
40 #define TAS2783_PROBE_TIMEOUT 5000
41 #define TAS2783_CALI_GUID EFI_GUID(0x1f52d2a1, 0xbb3a, 0x457d, 0xbc, \
42 0x09, 0x43, 0xa3, 0xf4, 0x31, 0x0a, 0x92)
43
44 static const u32 tas2783_cali_reg[] = {
45 TAS2783_CAL_R0,
46 TAS2783_CAL_INVR0,
47 TAS2783_CAL_R0LOW,
48 TAS2783_CAL_POWER,
49 TAS2783_CAL_TLIM,
50 };
51
52 struct bin_header_t {
53 u16 vendor_id;
54 u16 version;
55 u32 file_id;
56 u32 length;
57 };
58
59 struct calibration_data {
60 u32 is_valid;
61 unsigned long read_sz;
62 u8 data[TAS2783_CALIB_DATA_SZ];
63 };
64
65 struct tas2783_prv {
66 struct snd_soc_component *component;
67 struct calibration_data cali_data;
68 struct sdw_slave *sdw_peripheral;
69 enum sdw_slave_status status;
70 /* calibration */
71 struct mutex calib_lock;
72 /* pde and firmware download */
73 struct mutex pde_lock;
74 struct regmap *regmap;
75 struct device *dev;
76 struct class *class;
77 struct attribute_group *cal_attr_groups;
78 struct tm tm;
79 u8 rca_binaryname[64];
80 u8 dev_name[32];
81 bool hw_init;
82 /* wq for firmware download */
83 wait_queue_head_t fw_wait;
84 bool fw_dl_task_done;
85 bool fw_dl_success;
86 };
87
88 static const struct reg_default tas2783_reg_default[] = {
89 {TAS2783_AMP_LEVEL, 0x28},
90 {TASDEV_REG_SDW(0, 0, 0x03), 0x28},
91 {TASDEV_REG_SDW(0, 0, 0x04), 0x21},
92 {TASDEV_REG_SDW(0, 0, 0x05), 0x41},
93 {TASDEV_REG_SDW(0, 0, 0x06), 0x00},
94 {TASDEV_REG_SDW(0, 0, 0x07), 0x20},
95 {TASDEV_REG_SDW(0, 0, 0x08), 0x09},
96 {TASDEV_REG_SDW(0, 0, 0x09), 0x02},
97 {TASDEV_REG_SDW(0, 0, 0x0a), 0x0a},
98 {TASDEV_REG_SDW(0, 0, 0x0c), 0x10},
99 {TASDEV_REG_SDW(0, 0, 0x0d), 0x13},
100 {TASDEV_REG_SDW(0, 0, 0x0e), 0xc2},
101 {TASDEV_REG_SDW(0, 0, 0x0f), 0x40},
102 {TASDEV_REG_SDW(0, 0, 0x10), 0x04},
103 {TASDEV_REG_SDW(0, 0, 0x13), 0x13},
104 {TASDEV_REG_SDW(0, 0, 0x14), 0x12},
105 {TASDEV_REG_SDW(0, 0, 0x15), 0x00},
106 {TASDEV_REG_SDW(0, 0, 0x16), 0x12},
107 {TASDEV_REG_SDW(0, 0, 0x17), 0x80},
108 {TAS2783_DVC_LVL, 0x00},
109 {TASDEV_REG_SDW(0, 0, 0x1b), 0x61},
110 {TASDEV_REG_SDW(0, 0, 0x1c), 0x36},
111 {TASDEV_REG_SDW(0, 0, 0x1d), 0x00},
112 {TASDEV_REG_SDW(0, 0, 0x1f), 0x01},
113 {TASDEV_REG_SDW(0, 0, 0x20), 0x2e},
114 {TASDEV_REG_SDW(0, 0, 0x21), 0x00},
115 {TASDEV_REG_SDW(0, 0, 0x34), 0x06},
116 {TASDEV_REG_SDW(0, 0, 0x35), 0xbd},
117 {TASDEV_REG_SDW(0, 0, 0x36), 0xad},
118 {TASDEV_REG_SDW(0, 0, 0x37), 0xa8},
119 {TASDEV_REG_SDW(0, 0, 0x38), 0x00},
120 {TASDEV_REG_SDW(0, 0, 0x3b), 0xfc},
121 {TASDEV_REG_SDW(0, 0, 0x3d), 0xdd},
122 {TASDEV_REG_SDW(0, 0, 0x40), 0xf6},
123 {TASDEV_REG_SDW(0, 0, 0x41), 0x14},
124 {TASDEV_REG_SDW(0, 0, 0x5c), 0x19},
125 {TASDEV_REG_SDW(0, 0, 0x5d), 0x80},
126 {TASDEV_REG_SDW(0, 0, 0x63), 0x48},
127 {TASDEV_REG_SDW(0, 0, 0x65), 0x08},
128 {TASDEV_REG_SDW(0, 0, 0x66), 0xb2},
129 {TASDEV_REG_SDW(0, 0, 0x67), 0x00},
130 {TASDEV_REG_SDW(0, 0, 0x6a), 0x12},
131 {TASDEV_REG_SDW(0, 0, 0x6b), 0xfb},
132 {TASDEV_REG_SDW(0, 0, 0x6c), 0x00},
133 {TASDEV_REG_SDW(0, 0, 0x6d), 0x00},
134 {TASDEV_REG_SDW(0, 0, 0x6e), 0x1a},
135 {TASDEV_REG_SDW(0, 0, 0x6f), 0x00},
136 {TASDEV_REG_SDW(0, 0, 0x70), 0x96},
137 {TASDEV_REG_SDW(0, 0, 0x71), 0x02},
138 {TASDEV_REG_SDW(0, 0, 0x73), 0x08},
139 {TASDEV_REG_SDW(0, 0, 0x75), 0xe0},
140 {TASDEV_REG_SDW(0, 0, 0x7a), 0x60},
141 {TASDEV_REG_SDW(0, 0, 0x60), 0x21},
142 {TASDEV_REG_SDW(0, 1, 0x02), 0x00},
143 {TASDEV_REG_SDW(0, 1, 0x17), 0xc0},
144 {TASDEV_REG_SDW(0, 1, 0x19), 0x60},
145 {TASDEV_REG_SDW(0, 1, 0x35), 0x75},
146 {TASDEV_REG_SDW(0, 1, 0x3d), 0x00},
147 {TASDEV_REG_SDW(0, 1, 0x3e), 0x00},
148 {TASDEV_REG_SDW(0, 1, 0x3f), 0x00},
149 {TASDEV_REG_SDW(0, 1, 0x40), 0x00},
150 {TASDEV_REG_SDW(0, 1, 0x41), 0x00},
151 {TASDEV_REG_SDW(0, 1, 0x42), 0x00},
152 {TASDEV_REG_SDW(0, 1, 0x43), 0x00},
153 {TASDEV_REG_SDW(0, 1, 0x44), 0x00},
154 {TASDEV_REG_SDW(0, 1, 0x45), 0x00},
155 {TASDEV_REG_SDW(0, 1, 0x47), 0xab},
156 {TASDEV_REG_SDW(0, 0xfd, 0x0d), 0x0d},
157 {TASDEV_REG_SDW(0, 0xfd, 0x39), 0x00},
158 {TASDEV_REG_SDW(0, 0xfd, 0x3e), 0x00},
159 {TASDEV_REG_SDW(0, 0xfd, 0x45), 0x00},
160 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS21, 0x02, 0), 0x0},
161 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS21, 0x10, 0), 0x0},
162 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS24, 0x02, 0), 0x0},
163 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS24, 0x10, 0), 0x0},
164 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS26, 0x02, 0), 0x0},
165 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS26, 0x10, 0), 0x0},
166 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS28, 0x02, 0), 0x0},
167 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS28, 0x10, 0), 0x0},
168 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS127, 0x02, 0), 0x0},
169 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS127, 0x10, 0), 0x0},
170 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU21, 0x01, 1), 0x1},
171 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU21, 0x02, 1), 0x9c00},
172 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x01, 0), 0x1},
173 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x01, 1), 0x1},
174 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x0b, 1), 0x0},
175 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x10, 0), 0x0},
176 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x01, 1), 0x1},
177 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x01, 0), 0x1},
178 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x0b, 1), 0x0},
179 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x10, 0), 0x0},
180 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x01, 0), 0x1},
181 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x01, 1), 0x1},
182 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x01, 2), 0x1},
183 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x0b, 0), 0x0},
184 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x0b, 1), 0x0},
185 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x0b, 2), 0x0},
186 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x10, 0), 0x0},
187 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT21, 0x04, 0), 0x0},
188 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT21, 0x08, 0), 0x0},
189 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT21, 0x10, 0), 0x0},
190 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT21, 0x11, 0), 0x0},
191 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT26, 0x04, 0), 0x0},
192 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT26, 0x08, 0), 0x0},
193 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT26, 0x10, 0), 0x0},
194 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT26, 0x11, 0), 0x0},
195 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT28, 0x04, 0), 0x0},
196 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT28, 0x08, 0), 0x0},
197 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT28, 0x10, 0), 0x0},
198 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT28, 0x11, 0), 0x0},
199 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT29, 0x04, 0), 0x0},
200 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT29, 0x08, 0), 0x0},
201 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT29, 0x10, 0), 0x0},
202 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT29, 0x11, 0), 0x0},
203 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x01, 0), 0x0},
204 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x04, 0), 0x0},
205 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x05, 0), 0x1},
206 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x08, 0), 0x0},
207 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x10, 0), 0x0},
208 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x11, 0), 0x0},
209 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x12, 0), 0x0},
210 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x01, 0), 0x0},
211 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x04, 0), 0x0},
212 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x05, 0), 0x1},
213 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x08, 0), 0x0},
214 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x10, 0), 0x0},
215 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x11, 0), 0x0},
216 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x12, 0), 0x0},
217 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 0), 0x0},
218 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 1), 0x0},
219 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 2), 0x0},
220 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 3), 0x0},
221 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 4), 0x0},
222 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 5), 0x0},
223 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 6), 0x0},
224 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 7), 0x0},
225 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x06, 0), 0x0},
226 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT23, 0x04, 0), 0x0},
227 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT23, 0x08, 0), 0x0},
228 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT24, 0x04, 0), 0x0},
229 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT24, 0x08, 0), 0x0},
230 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT24, 0x11, 0), 0x0},
231 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT25, 0x04, 0), 0x0},
232 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT25, 0x08, 0), 0x0},
233 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT25, 0x11, 0), 0x0},
234 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT28, 0x04, 0), 0x0},
235 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT28, 0x08, 0), 0x0},
236 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT28, 0x11, 0), 0x0},
237 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x04, 0), 0x0},
238 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x08, 0), 0x0},
239 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x11, 0), 0x0},
240 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0), 0x0},
241 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 1), 0x0},
242 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 2), 0x0},
243 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 3), 0x0},
244 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 4), 0x0},
245 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 5), 0x0},
246 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 6), 0x0},
247 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 7), 0x0},
248 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 8), 0x0},
249 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 9), 0x0},
250 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xa), 0x0},
251 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xb), 0x0},
252 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xc), 0x0},
253 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xd), 0x0},
254 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xe), 0x0},
255 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xf), 0x0},
256 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PDE23, 0x1, 0), 0x3},
257 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PDE23, 0x10, 0), 0x3},
258 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x06, 0), 0x0},
259 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x10, 0), 0x0},
260 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x11, 0), 0x0},
261 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x12, 0), 0x0},
262 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x13, 0), 0x0},
263 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x06, 0), 0x0},
264 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x10, 0), 0x0},
265 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x11, 0), 0x0},
266 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x12, 0), 0x0},
267 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x13, 0), 0x0},
268 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_SAPU29, 0x05, 0), 0x0},
269 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_SAPU29, 0x10, 0), 0x1},
270 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_SAPU29, 0x11, 0), 0x0},
271 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_SAPU29, 0x12, 0), 0x0},
272 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_TG23, 0x10, 0), 0x0},
273 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x01, 0), 0x1},
274 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x06, 0), 0x0},
275 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x07, 0), 0x0},
276 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x08, 0), 0x0},
277 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x09, 0), 0x0},
278 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x0a, 0), 0x0},
279 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x10, 0), 0x1},
280 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x12, 0), 0x0},
281 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x13, 0), 0x0},
282 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x14, 0), 0x0},
283 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x15, 0), 0x0},
284 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x16, 0), 0x0},
285 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_UDMPU23, 0x10, 0), 0x0},
286 };
287
288 static const struct reg_sequence tas2783_init_seq[] = {
289 REG_SEQ0(SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x10, 0x00), 0x04),
290 REG_SEQ0(0x00800418, 0x00),
291 REG_SEQ0(0x00800419, 0x00),
292 REG_SEQ0(0x0080041a, 0x00),
293 REG_SEQ0(0x0080041b, 0x00),
294 REG_SEQ0(0x00800428, 0x40),
295 REG_SEQ0(0x00800429, 0x00),
296 REG_SEQ0(0x0080042a, 0x00),
297 REG_SEQ0(0x0080042b, 0x00),
298 REG_SEQ0(SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x1, 0x00), 0x00),
299 REG_SEQ0(0x0080005c, 0xD9),
300 REG_SEQ0(0x00800082, 0x20),
301 REG_SEQ0(0x008000a1, 0x00),
302 REG_SEQ0(0x00800097, 0xc8),
303 REG_SEQ0(0x00800099, 0x20),
304 REG_SEQ0(0x008000c7, 0xaa),
305 REG_SEQ0(0x008000b5, 0x74),
306 REG_SEQ0(0x00800082, 0x20),
307 REG_SEQ0(0x00807e8d, 0x0d),
308 REG_SEQ0(0x00807eb9, 0x53),
309 REG_SEQ0(0x00807ebe, 0x42),
310 REG_SEQ0(0x00807ec5, 0x37),
311 REG_SEQ0(0x00800066, 0x92),
312 REG_SEQ0(0x00800003, 0x28),
313 REG_SEQ0(0x00800004, 0x21),
314 REG_SEQ0(0x00800005, 0x41),
315 REG_SEQ0(0x00800006, 0x00),
316 REG_SEQ0(0x00800007, 0x20),
317 REG_SEQ0(0x0080000c, 0x10),
318 REG_SEQ0(0x00800013, 0x08),
319 REG_SEQ0(0x00800015, 0x00),
320 REG_SEQ0(0x00800017, 0x80),
321 REG_SEQ0(0x0080001a, 0x00),
322 REG_SEQ0(0x0080001b, 0x22),
323 REG_SEQ0(0x0080001c, 0x36),
324 REG_SEQ0(0x0080001d, 0x01),
325 REG_SEQ0(0x0080001f, 0x00),
326 REG_SEQ0(0x00800020, 0x2e),
327 REG_SEQ0(0x00800034, 0x06),
328 REG_SEQ0(0x00800035, 0xb9),
329 REG_SEQ0(0x00800036, 0xad),
330 REG_SEQ0(0x00800037, 0xa8),
331 REG_SEQ0(0x00800038, 0x00),
332 REG_SEQ0(0x0080003b, 0xfc),
333 REG_SEQ0(0x0080003d, 0xdd),
334 REG_SEQ0(0x00800040, 0xf6),
335 REG_SEQ0(0x00800041, 0x14),
336 REG_SEQ0(0x0080005c, 0x19),
337 REG_SEQ0(0x0080005d, 0x80),
338 REG_SEQ0(0x00800063, 0x48),
339 REG_SEQ0(0x00800065, 0x08),
340 REG_SEQ0(0x00800067, 0x00),
341 REG_SEQ0(0x0080006a, 0x12),
342 REG_SEQ0(0x0080006b, 0x7b),
343 REG_SEQ0(0x0080006c, 0x00),
344 REG_SEQ0(0x0080006d, 0x00),
345 REG_SEQ0(0x0080006e, 0x1a),
346 REG_SEQ0(0x0080006f, 0x00),
347 REG_SEQ0(0x00800070, 0x96),
348 REG_SEQ0(0x00800071, 0x02),
349 REG_SEQ0(0x00800073, 0x08),
350 REG_SEQ0(0x00800075, 0xe0),
351 REG_SEQ0(0x0080007a, 0x60),
352 REG_SEQ0(0x008000bd, 0x00),
353 REG_SEQ0(0x008000be, 0x00),
354 REG_SEQ0(0x008000bf, 0x00),
355 REG_SEQ0(0x008000c0, 0x00),
356 REG_SEQ0(0x008000c1, 0x00),
357 REG_SEQ0(0x008000c2, 0x00),
358 REG_SEQ0(0x008000c3, 0x00),
359 REG_SEQ0(0x008000c4, 0x00),
360 REG_SEQ0(0x008000c5, 0x00),
361 REG_SEQ0(0x00800008, 0x49),
362 REG_SEQ0(0x00800009, 0x02),
363 REG_SEQ0(0x0080000a, 0x1a),
364 REG_SEQ0(0x0080000d, 0x93),
365 REG_SEQ0(0x0080000e, 0x82),
366 REG_SEQ0(0x0080000f, 0x42),
367 REG_SEQ0(0x00800010, 0x84),
368 REG_SEQ0(0x00800014, 0x0a),
369 REG_SEQ0(0x00800016, 0x00),
370 REG_SEQ0(0x00800060, 0x21),
371 };
372
tas2783_sdca_mbq_size(struct device * dev,u32 reg)373 static int tas2783_sdca_mbq_size(struct device *dev, u32 reg)
374 {
375 switch (reg) {
376 case 0x000 ... 0x080: /* Data port 0. */
377 case 0x100 ... 0x140: /* Data port 1. */
378 case 0x200 ... 0x240: /* Data port 2. */
379 case 0x300 ... 0x340: /* Data port 3. */
380 case 0x400 ... 0x440: /* Data port 4. */
381 case 0x500 ... 0x540: /* Data port 5. */
382 case 0x800000 ... 0x803fff: /* Page 0 ~ 127. */
383 case 0x807e80 ... 0x807eff: /* Page 253. */
384 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_UDMPU23,
385 TAS2783_SDCA_CTL_UDMPU_CLUSTER, 0):
386 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU21, TAS2783_SDCA_CTL_FU_MUTE,
387 TAS2783_DEVICE_CHANNEL_LEFT):
388 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PDE23, 0x1, 0):
389 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PDE23, 0x10, 0):
390 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT21, 0x04, 0):
391 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_SAPU29, 0x10, 0):
392 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_SAPU29, 0x11, 0):
393 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_SAPU29, 0x12, 0):
394 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x10, 0):
395 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x11, 0):
396 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x10, 0):
397 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x11, 0):
398 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_TG23, 0x10, 0):
399 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x01, 0):
400 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x08, 0):
401 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x0a, 0):
402 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x10, 0):
403 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x14, 0):
404 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x15, 0):
405 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x16, 0):
406 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT26, 0x04, 0):
407 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT28, 0x04, 0):
408 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT29, 0x04, 0):
409 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT23, 0x04, 0):
410 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT24, 0x04, 0):
411 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT28, 0x04, 0):
412 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x04, 0):
413 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0):
414 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 1):
415 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 2):
416 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 3):
417 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 4):
418 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 5):
419 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 6):
420 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 7):
421 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 8):
422 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 9):
423 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xa):
424 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xb):
425 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xc):
426 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xd):
427 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xe):
428 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xf):
429 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS21, 0x02, 0):
430 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS21, 0x10, 0):
431 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS24, 0x02, 0):
432 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS24, 0x10, 0):
433 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS25, 0x02, 0):
434 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS25, 0x10, 0):
435 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS127, 0x02, 0):
436 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS127, 0x10, 0):
437 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS26, 0x02, 0):
438 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS26, 0x10, 0):
439 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS28, 0x02, 0):
440 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS28, 0x10, 0):
441 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x01, 0):
442 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x04, 0):
443 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x05, 0):
444 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x10, 0):
445 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x11, 0):
446 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x01, 1):
447 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x01, 2):
448 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x01, 0):
449 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x01, 1):
450 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x01, 0):
451 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x01, 0):
452 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x04, 0):
453 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x05, 0):
454 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x10, 0):
455 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x11, 0):
456 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x01, 0):
457 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x01, 1):
458 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT25, 0x04, 0):
459 return 1;
460
461 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT26, 0x10, 0):
462 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT26, 0x11, 0):
463 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT28, 0x10, 0):
464 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT28, 0x11, 0):
465 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT29, 0x10, 0):
466 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT29, 0x11, 0):
467 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT24, 0x11, 0):
468 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT25, 0x11, 0):
469 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT28, 0x11, 0):
470 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x11, 0):
471 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 0):
472 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 1):
473 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 2):
474 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 3):
475 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 4):
476 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 5):
477 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 6):
478 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 7):
479 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU21, 0x02, 1):
480 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x0b, 1):
481 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x0b, 1):
482 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x0b, 2):
483 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x0b, 0):
484 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x0b, 0):
485 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x0b, 1):
486 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x07, 0):
487 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x09, 0):
488 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x12, 0):
489 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x12, 0):
490 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x12, 0):
491 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x13, 0):
492 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x12, 0):
493 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x13, 0):
494 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT21, 0x10, 0):
495 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT21, 0x11, 0):
496 return 2;
497
498 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x10, 0):
499 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT21, 0x08, 0):
500 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT26, 0x08, 0):
501 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT28, 0x08, 0):
502 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT29, 0x08, 0):
503 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT23, 0x08, 0):
504 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT24, 0x08, 0):
505 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT25, 0x08, 0):
506 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT28, 0x08, 0):
507 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x08, 0):
508 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x06, 0):
509 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x10, 0):
510 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x10, 0):
511 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x06, 0):
512 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x12, 0):
513 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x13, 0):
514 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x08, 0):
515 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x08, 0):
516 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_SAPU29, 0x05, 0):
517 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x06, 0):
518 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x06, 0):
519 return 4;
520
521 default:
522 return 0;
523 }
524 }
525
tas2783_readable_register(struct device * dev,unsigned int reg)526 static bool tas2783_readable_register(struct device *dev, unsigned int reg)
527 {
528 return tas2783_sdca_mbq_size(dev, reg) > 0;
529 }
530
tas2783_volatile_register(struct device * dev,u32 reg)531 static bool tas2783_volatile_register(struct device *dev, u32 reg)
532 {
533 switch (reg) {
534 case 0x000 ... 0x080: /* Data port 0. */
535 case 0x100 ... 0x140: /* Data port 1. */
536 case 0x200 ... 0x240: /* Data port 2. */
537 case 0x300 ... 0x340: /* Data port 3. */
538 case 0x400 ... 0x440: /* Data port 4. */
539 case 0x500 ... 0x540: /* Data port 5. */
540 case 0x800001:
541 return true;
542
543 default:
544 return false;
545 }
546 }
547
548 static const struct regmap_config tas_regmap = {
549 .reg_bits = 32,
550 .val_bits = 8,
551 .readable_reg = tas2783_readable_register,
552 .volatile_reg = tas2783_volatile_register,
553 .reg_defaults = tas2783_reg_default,
554 .num_reg_defaults = ARRAY_SIZE(tas2783_reg_default),
555 .max_register = 0x41008000 + TASDEV_REG_SDW(0xa1, 0x60, 0x7f),
556 .cache_type = REGCACHE_MAPLE,
557 .use_single_read = true,
558 .use_single_write = true,
559 };
560
561 static const struct regmap_sdw_mbq_cfg tas2783_mbq_cfg = {
562 .mbq_size = tas2783_sdca_mbq_size,
563 };
564
tas2783_digital_getvol(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)565 static s32 tas2783_digital_getvol(struct snd_kcontrol *kcontrol,
566 struct snd_ctl_elem_value *ucontrol)
567 {
568 return snd_soc_get_volsw(kcontrol, ucontrol);
569 }
570
tas2783_digital_putvol(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)571 static s32 tas2783_digital_putvol(struct snd_kcontrol *kcontrol,
572 struct snd_ctl_elem_value *ucontrol)
573 {
574 return snd_soc_put_volsw(kcontrol, ucontrol);
575 }
576
tas2783_amp_getvol(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)577 static s32 tas2783_amp_getvol(struct snd_kcontrol *kcontrol,
578 struct snd_ctl_elem_value *ucontrol)
579 {
580 return snd_soc_get_volsw(kcontrol, ucontrol);
581 }
582
tas2783_amp_putvol(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)583 static s32 tas2783_amp_putvol(struct snd_kcontrol *kcontrol,
584 struct snd_ctl_elem_value *ucontrol)
585 {
586 return snd_soc_put_volsw(kcontrol, ucontrol);
587 }
588
589 static const struct snd_kcontrol_new tas2783_snd_controls[] = {
590 SOC_SINGLE_RANGE_EXT_TLV("Amp Volume", TAS2783_AMP_LEVEL,
591 1, 0, 20, 0, tas2783_amp_getvol,
592 tas2783_amp_putvol, tas2781_amp_tlv),
593 SOC_SINGLE_RANGE_EXT_TLV("Speaker Volume", TAS2783_DVC_LVL,
594 0, 0, 200, 1, tas2783_digital_getvol,
595 tas2783_digital_putvol, tas2781_dvc_tlv),
596 };
597
tas2783_validate_calibdata(struct tas2783_prv * tas_dev,u8 * data,u32 size)598 static s32 tas2783_validate_calibdata(struct tas2783_prv *tas_dev,
599 u8 *data, u32 size)
600 {
601 u32 ts, spk_count, size_calculated;
602 u32 crc_calculated, crc_read, i;
603 u32 *tmp_val;
604 struct tm tm;
605
606 i = 0;
607 tmp_val = (u32 *)data;
608 if (tmp_val[i++] != 2783) {
609 dev_err(tas_dev->dev, "cal data magic number mismatch");
610 return -EINVAL;
611 }
612
613 spk_count = tmp_val[i++];
614 if (spk_count > TAS2783_CALIB_MAX_SPK_COUNT) {
615 dev_err(tas_dev->dev, "cal data spk_count too large");
616 return -EINVAL;
617 }
618
619 ts = tmp_val[i++];
620 time64_to_tm(ts, 0, &tm);
621 dev_dbg(tas_dev->dev, "cal data timestamp: %ld-%d-%d %d:%d:%d",
622 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
623 tm.tm_hour, tm.tm_min, tm.tm_sec);
624
625 size_calculated =
626 (spk_count * TAS2783_CALIB_PARAMS * sizeof(u32)) +
627 TAS2783_CALIB_HDR_SZ + TAS2783_CALIB_CRC_SZ;
628 if (size_calculated > TAS2783_CALIB_DATA_SZ) {
629 dev_err(tas_dev->dev, "cali data sz too large");
630 return -EINVAL;
631 } else if (size < size_calculated) {
632 dev_err(tas_dev->dev, "cali data size mismatch calc=%u vs %d\n",
633 size, size_calculated);
634 return -EINVAL;
635 }
636
637 crc_calculated = crc32(~0, data,
638 size_calculated - TAS2783_CALIB_CRC_SZ) ^ ~0;
639 crc_read = tmp_val[(size_calculated - TAS2783_CALIB_CRC_SZ) / sizeof(u32)];
640 if (crc_calculated != crc_read) {
641 dev_err(tas_dev->dev,
642 "calib data integrity check fail, 0x%08x vs 0x%08x\n",
643 crc_calculated, crc_read);
644 return -EINVAL;
645 }
646
647 return 0;
648 }
649
tas2783_set_calib_params_to_device(struct tas2783_prv * tas_dev,u32 * cali_data)650 static void tas2783_set_calib_params_to_device(struct tas2783_prv *tas_dev, u32 *cali_data)
651 {
652 u32 dev_count, offset, i, device_num;
653 u32 reg_value;
654 u8 buf[4];
655
656 dev_count = cali_data[1];
657 offset = 3;
658
659 for (device_num = 0; device_num < dev_count; device_num++) {
660 if (cali_data[offset] != tas_dev->sdw_peripheral->id.unique_id) {
661 offset += TAS2783_CALIB_PARAMS;
662 continue;
663 }
664 offset++;
665
666 for (i = 0; i < ARRAY_SIZE(tas2783_cali_reg); i++) {
667 reg_value = cali_data[offset + i];
668 buf[0] = reg_value >> 24;
669 buf[1] = reg_value >> 16;
670 buf[2] = reg_value >> 8;
671 buf[3] = reg_value & 0xff;
672 regmap_bulk_write(tas_dev->regmap, tas2783_cali_reg[i],
673 buf, sizeof(u32));
674 }
675 break;
676 }
677
678 if (device_num == dev_count)
679 dev_err(tas_dev->dev, "device not found\n");
680 else
681 dev_dbg(tas_dev->dev, "calib data update done\n");
682 }
683
tas2783_update_calibdata(struct tas2783_prv * tas_dev)684 static s32 tas2783_update_calibdata(struct tas2783_prv *tas_dev)
685 {
686 efi_guid_t efi_guid = TAS2783_CALI_GUID;
687 u32 attr, i, *tmp_val;
688 unsigned long size;
689 s32 ret;
690 efi_status_t status;
691 static efi_char16_t efi_names[][32] = {
692 L"SmartAmpCalibrationData", L"CALI_DATA"};
693
694 tmp_val = (u32 *)tas_dev->cali_data.data;
695 attr = 0;
696 i = 0;
697
698 /*
699 * In some cases, the calibration is performed in Windows,
700 * and data was saved in UEFI. Linux can access it.
701 */
702 for (i = 0; i < ARRAY_SIZE(efi_names); i++) {
703 size = 0;
704 status = efi.get_variable(efi_names[i], &efi_guid, &attr,
705 &size, NULL);
706 if (size > TAS2783_CALIB_DATA_SZ) {
707 dev_err(tas_dev->dev, "cali data too large\n");
708 break;
709 }
710
711 tas_dev->cali_data.read_sz = size;
712 if (status == EFI_BUFFER_TOO_SMALL) {
713 status = efi.get_variable(efi_names[i], &efi_guid, &attr,
714 &tas_dev->cali_data.read_sz,
715 tas_dev->cali_data.data);
716 dev_dbg(tas_dev->dev, "cali get %lu bytes result:%ld\n",
717 tas_dev->cali_data.read_sz, status);
718 }
719 if (status == EFI_SUCCESS)
720 break;
721 }
722
723 if (status != EFI_SUCCESS) {
724 /* Failed got calibration data from EFI. */
725 dev_dbg(tas_dev->dev, "No calibration data in UEFI.");
726 return 0;
727 }
728
729 mutex_lock(&tas_dev->calib_lock);
730 ret = tas2783_validate_calibdata(tas_dev, tas_dev->cali_data.data,
731 tas_dev->cali_data.read_sz);
732 if (!ret)
733 tas2783_set_calib_params_to_device(tas_dev, tmp_val);
734 mutex_unlock(&tas_dev->calib_lock);
735
736 return ret;
737 }
738
read_header(const u8 * data,struct bin_header_t * hdr)739 static s32 read_header(const u8 *data, struct bin_header_t *hdr)
740 {
741 hdr->vendor_id = get_unaligned_le16(&data[0]);
742 hdr->file_id = get_unaligned_le32(&data[2]);
743 hdr->version = get_unaligned_le16(&data[6]);
744 hdr->length = get_unaligned_le32(&data[8]);
745 return 12;
746 }
747
tas2783_fw_ready(const struct firmware * fmw,void * context)748 static void tas2783_fw_ready(const struct firmware *fmw, void *context)
749 {
750 struct tas2783_prv *tas_dev =
751 (struct tas2783_prv *)context;
752 const u8 *buf = NULL;
753 s32 offset = 0, img_sz, file_blk_size, ret;
754 struct bin_header_t hdr;
755
756 if (!fmw || !fmw->data) {
757 /* No firmware binary, devices will work in ROM mode. */
758 dev_err(tas_dev->dev,
759 "Failed to read %s, no side-effect on driver running\n",
760 tas_dev->rca_binaryname);
761 ret = -EINVAL;
762 goto out;
763 }
764
765 img_sz = fmw->size;
766 buf = fmw->data;
767 offset += FW_DL_OFFSET;
768 if (offset >= (img_sz - FW_FL_HDR)) {
769 dev_err(tas_dev->dev,
770 "firmware is too small");
771 ret = -EINVAL;
772 goto out;
773 }
774
775 mutex_lock(&tas_dev->pde_lock);
776 while (offset < (img_sz - FW_FL_HDR)) {
777 memset(&hdr, 0, sizeof(hdr));
778 offset += read_header(&buf[offset], &hdr);
779 dev_dbg(tas_dev->dev,
780 "vndr=%d, file=%d, version=%d, len=%d, off=%d\n",
781 hdr.vendor_id, hdr.file_id, hdr.version,
782 hdr.length, offset);
783 /* size also includes the header */
784 file_blk_size = hdr.length - FW_FL_HDR;
785
786 /* make sure that enough data is there */
787 if (offset + file_blk_size > img_sz) {
788 ret = -EINVAL;
789 dev_err(tas_dev->dev,
790 "corrupt firmware file");
791 break;
792 }
793
794 switch (hdr.file_id) {
795 case 0:
796 ret = sdw_nwrite_no_pm(tas_dev->sdw_peripheral,
797 PRAM_ADDR_START, file_blk_size,
798 &buf[offset]);
799 if (ret < 0)
800 dev_err(tas_dev->dev,
801 "PRAM update failed: %d", ret);
802 break;
803
804 case 1:
805 ret = sdw_nwrite_no_pm(tas_dev->sdw_peripheral,
806 YRAM_ADDR_START, file_blk_size,
807 &buf[offset]);
808 if (ret < 0)
809 dev_err(tas_dev->dev,
810 "YRAM update failed: %d", ret);
811
812 break;
813
814 default:
815 ret = -EINVAL;
816 dev_err(tas_dev->dev, "Unsupported file");
817 break;
818 }
819
820 if (ret == 0)
821 offset += file_blk_size;
822 else
823 break;
824 }
825 mutex_unlock(&tas_dev->pde_lock);
826 if (!ret)
827 tas2783_update_calibdata(tas_dev);
828
829 out:
830 if (!ret)
831 tas_dev->fw_dl_success = true;
832 tas_dev->fw_dl_task_done = true;
833 wake_up(&tas_dev->fw_wait);
834 if (fmw)
835 release_firmware(fmw);
836 }
837
tas_clear_latch(struct tas2783_prv * priv)838 static inline s32 tas_clear_latch(struct tas2783_prv *priv)
839 {
840 return regmap_update_bits(priv->regmap,
841 TASDEV_REG_SDW(0, 0, 0x5c),
842 0x04, 0x04);
843 }
844
tas_fu21_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * k,s32 event)845 static s32 tas_fu21_event(struct snd_soc_dapm_widget *w,
846 struct snd_kcontrol *k, s32 event)
847 {
848 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
849 struct tas2783_prv *tas_dev = snd_soc_component_get_drvdata(component);
850 s32 mute;
851
852 switch (event) {
853 case SND_SOC_DAPM_POST_PMU:
854 mute = 0;
855 break;
856
857 case SND_SOC_DAPM_PRE_PMD:
858 mute = 1;
859 break;
860 }
861
862 return sdw_write_no_pm(tas_dev->sdw_peripheral,
863 SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU21,
864 TAS2783_SDCA_CTL_FU_MUTE, 1), mute);
865 }
866
tas_fu23_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * k,s32 event)867 static s32 tas_fu23_event(struct snd_soc_dapm_widget *w,
868 struct snd_kcontrol *k, s32 event)
869 {
870 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
871 struct tas2783_prv *tas_dev = snd_soc_component_get_drvdata(component);
872 s32 mute;
873
874 switch (event) {
875 case SND_SOC_DAPM_POST_PMU:
876 mute = 0;
877 break;
878
879 case SND_SOC_DAPM_PRE_PMD:
880 mute = 1;
881 break;
882 }
883
884 return sdw_write_no_pm(tas_dev->sdw_peripheral,
885 SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23,
886 TAS2783_SDCA_CTL_FU_MUTE, 1), mute);
887 }
888
889 static const struct snd_soc_dapm_widget tas_dapm_widgets[] = {
890 SND_SOC_DAPM_AIF_IN("ASI", "ASI Playback", 0, SND_SOC_NOPM, 0, 0),
891 SND_SOC_DAPM_AIF_OUT("ASI OUT", "ASI Capture", 0, SND_SOC_NOPM,
892 0, 0),
893 SND_SOC_DAPM_DAC_E("FU21", NULL, SND_SOC_NOPM, 0, 0, tas_fu21_event,
894 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
895 SND_SOC_DAPM_DAC_E("FU23", NULL, SND_SOC_NOPM, 0, 0, tas_fu23_event,
896 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
897 SND_SOC_DAPM_OUTPUT("SPK"),
898 SND_SOC_DAPM_INPUT("DMIC"),
899 };
900
901 static const struct snd_soc_dapm_route tas_audio_map[] = {
902 {"FU21", NULL, "ASI"},
903 {"SPK", NULL, "FU21"},
904 {"FU23", NULL, "ASI"},
905 {"SPK", NULL, "FU23"},
906 {"ASI OUT", NULL, "DMIC"},
907 };
908
tas_set_sdw_stream(struct snd_soc_dai * dai,void * sdw_stream,s32 direction)909 static s32 tas_set_sdw_stream(struct snd_soc_dai *dai,
910 void *sdw_stream, s32 direction)
911 {
912 if (!sdw_stream)
913 return 0;
914
915 snd_soc_dai_dma_data_set(dai, direction, sdw_stream);
916
917 return 0;
918 }
919
tas_sdw_shutdown(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)920 static void tas_sdw_shutdown(struct snd_pcm_substream *substream,
921 struct snd_soc_dai *dai)
922 {
923 snd_soc_dai_set_dma_data(dai, substream, NULL);
924 }
925
tas_sdw_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params,struct snd_soc_dai * dai)926 static s32 tas_sdw_hw_params(struct snd_pcm_substream *substream,
927 struct snd_pcm_hw_params *params,
928 struct snd_soc_dai *dai)
929 {
930 struct snd_soc_component *component = dai->component;
931 struct tas2783_prv *tas_dev =
932 snd_soc_component_get_drvdata(component);
933 struct sdw_stream_config stream_config = {0};
934 struct sdw_port_config port_config = {0};
935 struct sdw_stream_runtime *sdw_stream;
936 struct sdw_slave *sdw_peripheral = tas_dev->sdw_peripheral;
937 s32 ret, retry = 3;
938
939 if (!tas_dev->fw_dl_success) {
940 dev_err(tas_dev->dev, "error playback without fw download");
941 return -EINVAL;
942 }
943
944 sdw_stream = snd_soc_dai_get_dma_data(dai, substream);
945 if (!sdw_stream)
946 return -EINVAL;
947
948 ret = tas_clear_latch(tas_dev);
949 if (ret)
950 dev_err(tas_dev->dev,
951 "clear latch failed, err=%d", ret);
952
953 mutex_lock(&tas_dev->pde_lock);
954 /*
955 * Sometimes, there is error returned during power on.
956 * So added retry logic to ensure power on so that
957 * port prepare succeeds
958 */
959 do {
960 ret = regmap_write(tas_dev->regmap,
961 SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PDE23,
962 TAS2783_SDCA_CTL_REQ_POW_STATE, 0),
963 TAS2783_SDCA_POW_STATE_ON);
964 if (!ret)
965 break;
966 usleep_range(2000, 2200);
967 } while (retry--);
968 mutex_unlock(&tas_dev->pde_lock);
969 if (ret)
970 return ret;
971
972 /* SoundWire specific configuration */
973 snd_sdw_params_to_config(substream, params,
974 &stream_config, &port_config);
975 /* port 1 for playback */
976 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
977 port_config.num = 1;
978 else
979 port_config.num = 2;
980
981 ret = sdw_stream_add_slave(sdw_peripheral,
982 &stream_config, &port_config, 1, sdw_stream);
983 if (ret)
984 dev_err(dai->dev, "Unable to configure port\n");
985
986 return ret;
987 }
988
tas_sdw_pcm_hw_free(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)989 static s32 tas_sdw_pcm_hw_free(struct snd_pcm_substream *substream,
990 struct snd_soc_dai *dai)
991 {
992 s32 ret;
993 struct snd_soc_component *component = dai->component;
994 struct tas2783_prv *tas_dev =
995 snd_soc_component_get_drvdata(component);
996 struct sdw_stream_runtime *sdw_stream =
997 snd_soc_dai_get_dma_data(dai, substream);
998
999 sdw_stream_remove_slave(tas_dev->sdw_peripheral, sdw_stream);
1000
1001 mutex_lock(&tas_dev->pde_lock);
1002 ret = regmap_write(tas_dev->regmap,
1003 SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PDE23,
1004 TAS2783_SDCA_CTL_REQ_POW_STATE, 0),
1005 TAS2783_SDCA_POW_STATE_OFF);
1006 mutex_unlock(&tas_dev->pde_lock);
1007
1008 return ret;
1009 }
1010
1011 static const struct snd_soc_dai_ops tas_dai_ops = {
1012 .hw_params = tas_sdw_hw_params,
1013 .hw_free = tas_sdw_pcm_hw_free,
1014 .set_stream = tas_set_sdw_stream,
1015 .shutdown = tas_sdw_shutdown,
1016 };
1017
1018 static struct snd_soc_dai_driver tas_dai_driver[] = {
1019 {
1020 .name = "tas2783-codec",
1021 .id = 0,
1022 .playback = {
1023 .stream_name = "Playback",
1024 .channels_min = 1,
1025 .channels_max = 4,
1026 .rates = TAS2783_DEVICE_RATES,
1027 .formats = TAS2783_DEVICE_FORMATS,
1028 },
1029 .capture = {
1030 .stream_name = "Capture",
1031 .channels_min = 1,
1032 .channels_max = 4,
1033 .rates = TAS2783_DEVICE_RATES,
1034 .formats = TAS2783_DEVICE_FORMATS,
1035 },
1036 .ops = &tas_dai_ops,
1037 .symmetric_rate = 1,
1038 },
1039 };
1040
tas_component_probe(struct snd_soc_component * component)1041 static s32 tas_component_probe(struct snd_soc_component *component)
1042 {
1043 struct tas2783_prv *tas_dev =
1044 snd_soc_component_get_drvdata(component);
1045
1046 tas_dev->component = component;
1047 tas25xx_register_misc(tas_dev->sdw_peripheral);
1048
1049 return 0;
1050 }
1051
tas_component_remove(struct snd_soc_component * codec)1052 static void tas_component_remove(struct snd_soc_component *codec)
1053 {
1054 struct tas2783_prv *tas_dev =
1055 snd_soc_component_get_drvdata(codec);
1056 tas25xx_deregister_misc();
1057 tas_dev->component = NULL;
1058 }
1059
1060 static const struct snd_soc_component_driver soc_codec_driver_tasdevice = {
1061 .probe = tas_component_probe,
1062 .remove = tas_component_remove,
1063 .controls = tas2783_snd_controls,
1064 .num_controls = ARRAY_SIZE(tas2783_snd_controls),
1065 .dapm_widgets = tas_dapm_widgets,
1066 .num_dapm_widgets = ARRAY_SIZE(tas_dapm_widgets),
1067 .dapm_routes = tas_audio_map,
1068 .num_dapm_routes = ARRAY_SIZE(tas_audio_map),
1069 .idle_bias_on = 1,
1070 .endianness = 1,
1071 };
1072
tas_init(struct tas2783_prv * tas_dev)1073 static s32 tas_init(struct tas2783_prv *tas_dev)
1074 {
1075 s32 ret;
1076
1077 dev_set_drvdata(tas_dev->dev, tas_dev);
1078 ret = devm_snd_soc_register_component(tas_dev->dev,
1079 &soc_codec_driver_tasdevice,
1080 tas_dai_driver,
1081 ARRAY_SIZE(tas_dai_driver));
1082 if (ret) {
1083 dev_err(tas_dev->dev, "%s: codec register error:%d.\n",
1084 __func__, ret);
1085 return ret;
1086 }
1087
1088 /* set autosuspend parameters */
1089 pm_runtime_set_autosuspend_delay(tas_dev->dev, 3000);
1090 pm_runtime_use_autosuspend(tas_dev->dev);
1091 /* make sure the device does not suspend immediately */
1092 pm_runtime_mark_last_busy(tas_dev->dev);
1093 pm_runtime_enable(tas_dev->dev);
1094
1095 return ret;
1096 }
1097
tas_read_prop(struct sdw_slave * slave)1098 static s32 tas_read_prop(struct sdw_slave *slave)
1099 {
1100 struct sdw_slave_prop *prop = &slave->prop;
1101 s32 nval;
1102 s32 i, j;
1103 u32 bit;
1104 unsigned long addr;
1105 struct sdw_dpn_prop *dpn;
1106
1107 prop->scp_int1_mask =
1108 SDW_SCP_INT1_BUS_CLASH | SDW_SCP_INT1_PARITY;
1109 prop->quirks = SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY;
1110
1111 prop->paging_support = true;
1112
1113 /* first we need to allocate memory for set bits in port lists */
1114 prop->source_ports = 0x04; /* BITMAP: 00000100 */
1115 prop->sink_ports = 0x2; /* BITMAP: 00000010 */
1116
1117 nval = hweight32(prop->source_ports);
1118 prop->src_dpn_prop = devm_kcalloc(&slave->dev, nval,
1119 sizeof(*prop->src_dpn_prop), GFP_KERNEL);
1120 if (!prop->src_dpn_prop)
1121 return -ENOMEM;
1122
1123 i = 0;
1124 dpn = prop->src_dpn_prop;
1125 addr = prop->source_ports;
1126 for_each_set_bit(bit, &addr, 32) {
1127 dpn[i].num = bit;
1128 dpn[i].type = SDW_DPN_FULL;
1129 dpn[i].simple_ch_prep_sm = false;
1130 dpn[i].ch_prep_timeout = 10;
1131 i++;
1132 }
1133
1134 /* do this again for sink now */
1135 nval = hweight32(prop->sink_ports);
1136 prop->sink_dpn_prop = devm_kcalloc(&slave->dev, nval,
1137 sizeof(*prop->sink_dpn_prop), GFP_KERNEL);
1138 if (!prop->sink_dpn_prop)
1139 return -ENOMEM;
1140
1141 j = 0;
1142 dpn = prop->sink_dpn_prop;
1143 addr = prop->sink_ports;
1144 for_each_set_bit(bit, &addr, 32) {
1145 dpn[j].num = bit;
1146 dpn[j].type = SDW_DPN_FULL;
1147 dpn[j].simple_ch_prep_sm = false;
1148 dpn[j].ch_prep_timeout = 10;
1149 j++;
1150 }
1151
1152 /* set the timeout values */
1153 prop->clk_stop_timeout = 200;
1154
1155 return 0;
1156 }
1157
tas2783_sdca_dev_suspend(struct device * dev)1158 static s32 tas2783_sdca_dev_suspend(struct device *dev)
1159 {
1160 struct tas2783_prv *tas_dev = dev_get_drvdata(dev);
1161
1162 if (!tas_dev->hw_init)
1163 return 0;
1164
1165 regcache_cache_only(tas_dev->regmap, true);
1166 return 0;
1167 }
1168
tas2783_sdca_dev_system_suspend(struct device * dev)1169 static s32 tas2783_sdca_dev_system_suspend(struct device *dev)
1170 {
1171 return tas2783_sdca_dev_suspend(dev);
1172 }
1173
tas2783_sdca_dev_resume(struct device * dev)1174 static s32 tas2783_sdca_dev_resume(struct device *dev)
1175 {
1176 struct sdw_slave *slave = dev_to_sdw_dev(dev);
1177 struct tas2783_prv *tas_dev = dev_get_drvdata(dev);
1178 unsigned long t;
1179
1180 if (!slave->unattach_request)
1181 goto regmap_sync;
1182
1183 t = wait_for_completion_timeout(&slave->initialization_complete,
1184 msecs_to_jiffies(TAS2783_PROBE_TIMEOUT));
1185 if (!t) {
1186 dev_err(&slave->dev, "resume: initialization timed out\n");
1187 sdw_show_ping_status(slave->bus, true);
1188 return -ETIMEDOUT;
1189 }
1190
1191 slave->unattach_request = 0;
1192
1193 regmap_sync:
1194 regcache_cache_only(tas_dev->regmap, false);
1195 regcache_sync(tas_dev->regmap);
1196 return 0;
1197 }
1198
1199 static const struct dev_pm_ops tas2783_sdca_pm = {
1200 SYSTEM_SLEEP_PM_OPS(tas2783_sdca_dev_system_suspend, tas2783_sdca_dev_resume)
1201 RUNTIME_PM_OPS(tas2783_sdca_dev_suspend, tas2783_sdca_dev_resume, NULL)
1202 };
1203
tas_io_init(struct device * dev,struct sdw_slave * slave)1204 static s32 tas_io_init(struct device *dev, struct sdw_slave *slave)
1205 {
1206 struct tas2783_prv *tas_dev = dev_get_drvdata(dev);
1207 s32 ret;
1208 u8 unique_id = tas_dev->sdw_peripheral->id.unique_id;
1209
1210 if (tas_dev->hw_init)
1211 return 0;
1212
1213 tas_dev->fw_dl_task_done = false;
1214 tas_dev->fw_dl_success = false;
1215 scnprintf(tas_dev->rca_binaryname, sizeof(tas_dev->rca_binaryname),
1216 "tas2783-%01x.bin", unique_id);
1217
1218 ret = request_firmware_nowait(THIS_MODULE, FW_ACTION_UEVENT,
1219 tas_dev->rca_binaryname, tas_dev->dev,
1220 GFP_KERNEL, tas_dev, tas2783_fw_ready);
1221 if (ret) {
1222 dev_err(tas_dev->dev,
1223 "firmware request failed for uid=%d, ret=%d\n",
1224 unique_id, ret);
1225 return ret;
1226 }
1227
1228 ret = wait_event_timeout(tas_dev->fw_wait, tas_dev->fw_dl_task_done,
1229 msecs_to_jiffies(TIMEOUT_FW_DL_MS));
1230 if (!ret) {
1231 dev_err(tas_dev->dev, "fw request, wait_event timeout\n");
1232 ret = -EAGAIN;
1233 } else {
1234 ret = regmap_multi_reg_write(tas_dev->regmap, tas2783_init_seq,
1235 ARRAY_SIZE(tas2783_init_seq));
1236 tas_dev->hw_init = true;
1237 }
1238
1239 return ret;
1240 }
1241
tas_update_status(struct sdw_slave * slave,enum sdw_slave_status status)1242 static s32 tas_update_status(struct sdw_slave *slave,
1243 enum sdw_slave_status status)
1244 {
1245 struct tas2783_prv *tas_dev = dev_get_drvdata(&slave->dev);
1246 struct device *dev = &slave->dev;
1247
1248 dev_dbg(dev, "Peripheral status = %s",
1249 status == SDW_SLAVE_UNATTACHED ? "unattached" :
1250 status == SDW_SLAVE_ATTACHED ? "attached" : "alert");
1251
1252 tas_dev->status = status;
1253 if (status == SDW_SLAVE_UNATTACHED)
1254 tas_dev->hw_init = false;
1255
1256 /* Perform initialization only if slave status
1257 * is present and hw_init flag is false
1258 */
1259 if (tas_dev->hw_init || tas_dev->status != SDW_SLAVE_ATTACHED)
1260 return 0;
1261
1262 /* updated the cache data to device */
1263 regcache_cache_only(tas_dev->regmap, false);
1264 regcache_sync(tas_dev->regmap);
1265
1266 /* perform I/O transfers required for Slave initialization */
1267 return tas_io_init(&slave->dev, slave);
1268 }
1269
1270 static const struct sdw_slave_ops tas_sdw_ops = {
1271 .read_prop = tas_read_prop,
1272 .update_status = tas_update_status,
1273 };
1274
tas_remove(struct tas2783_prv * tas_dev)1275 static void tas_remove(struct tas2783_prv *tas_dev)
1276 {
1277 snd_soc_unregister_component(tas_dev->dev);
1278 }
1279
tas_sdw_probe(struct sdw_slave * peripheral,const struct sdw_device_id * id)1280 static s32 tas_sdw_probe(struct sdw_slave *peripheral,
1281 const struct sdw_device_id *id)
1282 {
1283 struct regmap *regmap;
1284 struct device *dev = &peripheral->dev;
1285 struct tas2783_prv *tas_dev;
1286
1287 tas_dev = devm_kzalloc(dev, sizeof(*tas_dev), GFP_KERNEL);
1288 if (!tas_dev)
1289 return dev_err_probe(dev, -ENOMEM,
1290 "Failed devm_kzalloc");
1291
1292 tas_dev->dev = dev;
1293 tas_dev->sdw_peripheral = peripheral;
1294 tas_dev->hw_init = false;
1295 mutex_init(&tas_dev->calib_lock);
1296 mutex_init(&tas_dev->pde_lock);
1297
1298 init_waitqueue_head(&tas_dev->fw_wait);
1299 dev_set_drvdata(dev, tas_dev);
1300 regmap = devm_regmap_init_sdw_mbq_cfg(peripheral,
1301 &tas_regmap,
1302 &tas2783_mbq_cfg);
1303 if (IS_ERR(regmap))
1304 return dev_err_probe(dev, PTR_ERR(regmap),
1305 "Failed devm_regmap_init_sdw.");
1306
1307 /* keep in cache until the device is fully initialized */
1308 regcache_cache_only(regmap, true);
1309 tas_dev->regmap = regmap;
1310 return tas_init(tas_dev);
1311 }
1312
tas_sdw_remove(struct sdw_slave * peripheral)1313 static s32 tas_sdw_remove(struct sdw_slave *peripheral)
1314 {
1315 struct tas2783_prv *tas_dev = dev_get_drvdata(&peripheral->dev);
1316
1317 pm_runtime_disable(tas_dev->dev);
1318 tas_remove(tas_dev);
1319 mutex_destroy(&tas_dev->calib_lock);
1320 mutex_destroy(&tas_dev->pde_lock);
1321 dev_set_drvdata(&peripheral->dev, NULL);
1322
1323 return 0;
1324 }
1325
1326 static const struct sdw_device_id tas_sdw_id[] = {
1327 /* chipid for the TAS2783 is 0x0000 */
1328 SDW_SLAVE_ENTRY(0x0102, 0x0000, 0),
1329 {},
1330 };
1331 MODULE_DEVICE_TABLE(sdw, tas_sdw_id);
1332
1333 static struct sdw_driver tas_sdw_driver = {
1334 .driver = {
1335 .name = "slave-tas2783",
1336 .pm = pm_ptr(&tas2783_sdca_pm),
1337 },
1338 .probe = tas_sdw_probe,
1339 .remove = tas_sdw_remove,
1340 .ops = &tas_sdw_ops,
1341 .id_table = tas_sdw_id,
1342 };
1343 module_sdw_driver(tas_sdw_driver);
1344
1345 MODULE_AUTHOR("Texas Instruments Inc.");
1346 MODULE_DESCRIPTION("ASoC TAS2783 SoundWire Driver");
1347 MODULE_LICENSE("GPL");
1348