Commit | Line | Data |
---|---|---|
e149ca29 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
303681f4 PLB |
2 | // Copyright (c) 2015-2019 Intel Corporation |
3 | ||
4 | #include <linux/acpi.h> | |
5 | #include <sound/intel-nhlt.h> | |
6 | ||
303681f4 PLB |
7 | struct nhlt_acpi_table *intel_nhlt_init(struct device *dev) |
8 | { | |
0d283287 CR |
9 | struct nhlt_acpi_table *nhlt; |
10 | acpi_status status; | |
303681f4 | 11 | |
0d283287 CR |
12 | status = acpi_get_table(ACPI_SIG_NHLT, 0, |
13 | (struct acpi_table_header **)&nhlt); | |
14 | if (ACPI_FAILURE(status)) { | |
15 | dev_warn(dev, "NHLT table not found\n"); | |
303681f4 PLB |
16 | return NULL; |
17 | } | |
18 | ||
0d283287 | 19 | return nhlt; |
303681f4 PLB |
20 | } |
21 | EXPORT_SYMBOL_GPL(intel_nhlt_init); | |
22 | ||
23 | void intel_nhlt_free(struct nhlt_acpi_table *nhlt) | |
24 | { | |
0d283287 | 25 | acpi_put_table((struct acpi_table_header *)nhlt); |
303681f4 PLB |
26 | } |
27 | EXPORT_SYMBOL_GPL(intel_nhlt_free); | |
28 | ||
29 | int intel_nhlt_get_dmic_geo(struct device *dev, struct nhlt_acpi_table *nhlt) | |
30 | { | |
31 | struct nhlt_endpoint *epnt; | |
32 | struct nhlt_dmic_array_config *cfg; | |
7a33ea70 | 33 | struct nhlt_vendor_dmic_array_config *cfg_vendor; |
a864e8f1 | 34 | struct nhlt_fmt *fmt_configs; |
303681f4 | 35 | unsigned int dmic_geo = 0; |
a864e8f1 PLB |
36 | u16 max_ch = 0; |
37 | u8 i, j; | |
303681f4 PLB |
38 | |
39 | if (!nhlt) | |
40 | return 0; | |
41 | ||
a14a6219 MP |
42 | if (nhlt->header.length <= sizeof(struct acpi_table_header)) { |
43 | dev_warn(dev, "Invalid DMIC description table\n"); | |
44 | return 0; | |
45 | } | |
46 | ||
a864e8f1 PLB |
47 | for (j = 0, epnt = nhlt->desc; j < nhlt->endpoint_count; j++, |
48 | epnt = (struct nhlt_endpoint *)((u8 *)epnt + epnt->length)) { | |
303681f4 | 49 | |
a864e8f1 PLB |
50 | if (epnt->linktype != NHLT_LINK_DMIC) |
51 | continue; | |
52 | ||
53 | cfg = (struct nhlt_dmic_array_config *)(epnt->config.caps); | |
54 | fmt_configs = (struct nhlt_fmt *)(epnt->config.caps + epnt->config.size); | |
55 | ||
56 | /* find max number of channels based on format_configuration */ | |
57 | if (fmt_configs->fmt_count) { | |
2e6481a3 PU |
58 | struct nhlt_fmt_cfg *fmt_cfg = fmt_configs->fmt_config; |
59 | ||
6376ab02 PLB |
60 | dev_dbg(dev, "found %d format definitions\n", |
61 | fmt_configs->fmt_count); | |
a864e8f1 PLB |
62 | |
63 | for (i = 0; i < fmt_configs->fmt_count; i++) { | |
64 | struct wav_fmt_ext *fmt_ext; | |
65 | ||
2e6481a3 | 66 | fmt_ext = &fmt_cfg->fmt_ext; |
a864e8f1 PLB |
67 | |
68 | if (fmt_ext->fmt.channels > max_ch) | |
69 | max_ch = fmt_ext->fmt.channels; | |
2e6481a3 PU |
70 | |
71 | /* Move to the next nhlt_fmt_cfg */ | |
72 | fmt_cfg = (struct nhlt_fmt_cfg *)(fmt_cfg->config.caps + | |
73 | fmt_cfg->config.size); | |
a864e8f1 | 74 | } |
6376ab02 | 75 | dev_dbg(dev, "max channels found %d\n", max_ch); |
a864e8f1 | 76 | } else { |
6376ab02 | 77 | dev_dbg(dev, "No format information found\n"); |
a864e8f1 PLB |
78 | } |
79 | ||
80 | if (cfg->device_config.config_type != NHLT_CONFIG_TYPE_MIC_ARRAY) { | |
81 | dmic_geo = max_ch; | |
82 | } else { | |
303681f4 PLB |
83 | switch (cfg->array_type) { |
84 | case NHLT_MIC_ARRAY_2CH_SMALL: | |
85 | case NHLT_MIC_ARRAY_2CH_BIG: | |
86 | dmic_geo = MIC_ARRAY_2CH; | |
87 | break; | |
88 | ||
89 | case NHLT_MIC_ARRAY_4CH_1ST_GEOM: | |
90 | case NHLT_MIC_ARRAY_4CH_L_SHAPED: | |
91 | case NHLT_MIC_ARRAY_4CH_2ND_GEOM: | |
92 | dmic_geo = MIC_ARRAY_4CH; | |
93 | break; | |
7a33ea70 PLB |
94 | case NHLT_MIC_ARRAY_VENDOR_DEFINED: |
95 | cfg_vendor = (struct nhlt_vendor_dmic_array_config *)cfg; | |
96 | dmic_geo = cfg_vendor->nb_mics; | |
97 | break; | |
303681f4 | 98 | default: |
a864e8f1 PLB |
99 | dev_warn(dev, "%s: undefined DMIC array_type 0x%0x\n", |
100 | __func__, cfg->array_type); | |
101 | } | |
102 | ||
103 | if (dmic_geo > 0) { | |
6376ab02 | 104 | dev_dbg(dev, "Array with %d dmics\n", dmic_geo); |
a864e8f1 PLB |
105 | } |
106 | if (max_ch > dmic_geo) { | |
6376ab02 PLB |
107 | dev_dbg(dev, "max channels %d exceed dmic number %d\n", |
108 | max_ch, dmic_geo); | |
303681f4 PLB |
109 | } |
110 | } | |
303681f4 PLB |
111 | } |
112 | ||
6376ab02 | 113 | dev_dbg(dev, "dmic number %d max_ch %d\n", dmic_geo, max_ch); |
a864e8f1 | 114 | |
303681f4 PLB |
115 | return dmic_geo; |
116 | } | |
117 | EXPORT_SYMBOL_GPL(intel_nhlt_get_dmic_geo); | |
15fa179f AS |
118 | |
119 | bool intel_nhlt_has_endpoint_type(struct nhlt_acpi_table *nhlt, u8 link_type) | |
120 | { | |
121 | struct nhlt_endpoint *epnt; | |
122 | int i; | |
123 | ||
124 | if (!nhlt) | |
125 | return false; | |
126 | ||
127 | epnt = (struct nhlt_endpoint *)nhlt->desc; | |
128 | for (i = 0; i < nhlt->endpoint_count; i++) { | |
129 | if (epnt->linktype == link_type) | |
130 | return true; | |
131 | ||
132 | epnt = (struct nhlt_endpoint *)((u8 *)epnt + epnt->length); | |
133 | } | |
134 | return false; | |
135 | } | |
136 | EXPORT_SYMBOL(intel_nhlt_has_endpoint_type); | |
137 | ||
0c470db0 PLB |
138 | int intel_nhlt_ssp_endpoint_mask(struct nhlt_acpi_table *nhlt, u8 device_type) |
139 | { | |
140 | struct nhlt_endpoint *epnt; | |
141 | int ssp_mask = 0; | |
142 | int i; | |
143 | ||
144 | if (!nhlt || (device_type != NHLT_DEVICE_BT && device_type != NHLT_DEVICE_I2S)) | |
145 | return 0; | |
146 | ||
147 | epnt = (struct nhlt_endpoint *)nhlt->desc; | |
148 | for (i = 0; i < nhlt->endpoint_count; i++) { | |
149 | if (epnt->linktype == NHLT_LINK_SSP && epnt->device_type == device_type) { | |
150 | /* for SSP the virtual bus id is the SSP port */ | |
151 | ssp_mask |= BIT(epnt->virtual_bus_id); | |
152 | } | |
153 | epnt = (struct nhlt_endpoint *)((u8 *)epnt + epnt->length); | |
154 | } | |
155 | ||
156 | return ssp_mask; | |
157 | } | |
158 | EXPORT_SYMBOL(intel_nhlt_ssp_endpoint_mask); | |
159 | ||
72176fcc PLB |
160 | #define SSP_BLOB_V1_0_SIZE 84 |
161 | #define SSP_BLOB_V1_0_MDIVC_OFFSET 19 /* offset in u32 */ | |
162 | ||
163 | #define SSP_BLOB_V1_5_SIZE 96 | |
164 | #define SSP_BLOB_V1_5_MDIVC_OFFSET 21 /* offset in u32 */ | |
165 | #define SSP_BLOB_VER_1_5 0xEE000105 | |
166 | ||
167 | #define SSP_BLOB_V2_0_SIZE 88 | |
168 | #define SSP_BLOB_V2_0_MDIVC_OFFSET 20 /* offset in u32 */ | |
169 | #define SSP_BLOB_VER_2_0 0xEE000200 | |
170 | ||
171 | int intel_nhlt_ssp_mclk_mask(struct nhlt_acpi_table *nhlt, int ssp_num) | |
172 | { | |
173 | struct nhlt_endpoint *epnt; | |
174 | struct nhlt_fmt *fmt; | |
175 | struct nhlt_fmt_cfg *cfg; | |
176 | int mclk_mask = 0; | |
177 | int i, j; | |
178 | ||
179 | if (!nhlt) | |
180 | return 0; | |
181 | ||
182 | epnt = (struct nhlt_endpoint *)nhlt->desc; | |
183 | for (i = 0; i < nhlt->endpoint_count; i++) { | |
184 | ||
185 | /* we only care about endpoints connected to an audio codec over SSP */ | |
186 | if (epnt->linktype == NHLT_LINK_SSP && | |
187 | epnt->device_type == NHLT_DEVICE_I2S && | |
188 | epnt->virtual_bus_id == ssp_num) { | |
189 | ||
190 | fmt = (struct nhlt_fmt *)(epnt->config.caps + epnt->config.size); | |
191 | cfg = fmt->fmt_config; | |
192 | ||
193 | /* | |
194 | * In theory all formats should use the same MCLK but it doesn't hurt to | |
195 | * double-check that the configuration is consistent | |
196 | */ | |
197 | for (j = 0; j < fmt->fmt_count; j++) { | |
198 | u32 *blob; | |
199 | int mdivc_offset; | |
200 | int size; | |
201 | ||
202 | /* first check we have enough data to read the blob type */ | |
203 | if (cfg->config.size < 8) | |
204 | return -EINVAL; | |
205 | ||
206 | blob = (u32 *)cfg->config.caps; | |
207 | ||
208 | if (blob[1] == SSP_BLOB_VER_2_0) { | |
209 | mdivc_offset = SSP_BLOB_V2_0_MDIVC_OFFSET; | |
210 | size = SSP_BLOB_V2_0_SIZE; | |
211 | } else if (blob[1] == SSP_BLOB_VER_1_5) { | |
212 | mdivc_offset = SSP_BLOB_V1_5_MDIVC_OFFSET; | |
213 | size = SSP_BLOB_V1_5_SIZE; | |
214 | } else { | |
215 | mdivc_offset = SSP_BLOB_V1_0_MDIVC_OFFSET; | |
216 | size = SSP_BLOB_V1_0_SIZE; | |
217 | } | |
218 | ||
219 | /* make sure we have enough data for the fixed part of the blob */ | |
220 | if (cfg->config.size < size) | |
221 | return -EINVAL; | |
222 | ||
223 | mclk_mask |= blob[mdivc_offset] & GENMASK(1, 0); | |
224 | ||
225 | cfg = (struct nhlt_fmt_cfg *)(cfg->config.caps + cfg->config.size); | |
226 | } | |
227 | } | |
228 | epnt = (struct nhlt_endpoint *)((u8 *)epnt + epnt->length); | |
229 | } | |
230 | ||
231 | /* make sure only one MCLK is used */ | |
232 | if (hweight_long(mclk_mask) != 1) | |
233 | return -EINVAL; | |
234 | ||
235 | return mclk_mask; | |
236 | } | |
237 | EXPORT_SYMBOL(intel_nhlt_ssp_mclk_mask); | |
238 | ||
15fa179f AS |
239 | static struct nhlt_specific_cfg * |
240 | nhlt_get_specific_cfg(struct device *dev, struct nhlt_fmt *fmt, u8 num_ch, | |
7b4c93a5 | 241 | u32 rate, u8 vbps, u8 bps, bool ignore_vbps) |
15fa179f AS |
242 | { |
243 | struct nhlt_fmt_cfg *cfg = fmt->fmt_config; | |
244 | struct wav_fmt *wfmt; | |
245 | u16 _bps, _vbps; | |
246 | int i; | |
247 | ||
248 | dev_dbg(dev, "Endpoint format count=%d\n", fmt->fmt_count); | |
249 | ||
250 | for (i = 0; i < fmt->fmt_count; i++) { | |
251 | wfmt = &cfg->fmt_ext.fmt; | |
252 | _bps = wfmt->bits_per_sample; | |
253 | _vbps = cfg->fmt_ext.sample.valid_bits_per_sample; | |
254 | ||
255 | dev_dbg(dev, "Endpoint format: ch=%d fmt=%d/%d rate=%d\n", | |
256 | wfmt->channels, _vbps, _bps, wfmt->samples_per_sec); | |
257 | ||
7b4c93a5 PU |
258 | /* |
259 | * When looking for exact match of configuration ignore the vbps | |
260 | * from NHLT table when ignore_vbps is true | |
261 | */ | |
15fa179f | 262 | if (wfmt->channels == num_ch && wfmt->samples_per_sec == rate && |
7b4c93a5 | 263 | (ignore_vbps || vbps == _vbps) && bps == _bps) |
15fa179f AS |
264 | return &cfg->config; |
265 | ||
266 | cfg = (struct nhlt_fmt_cfg *)(cfg->config.caps + cfg->config.size); | |
267 | } | |
268 | ||
269 | return NULL; | |
270 | } | |
271 | ||
272 | static bool nhlt_check_ep_match(struct device *dev, struct nhlt_endpoint *epnt, | |
273 | u32 bus_id, u8 link_type, u8 dir, u8 dev_type) | |
274 | { | |
275 | dev_dbg(dev, "Endpoint: vbus_id=%d link_type=%d dir=%d dev_type = %d\n", | |
276 | epnt->virtual_bus_id, epnt->linktype, | |
277 | epnt->direction, epnt->device_type); | |
278 | ||
279 | if ((epnt->virtual_bus_id != bus_id) || | |
280 | (epnt->linktype != link_type) || | |
281 | (epnt->direction != dir)) | |
282 | return false; | |
283 | ||
284 | /* link of type DMIC bypasses device_type check */ | |
285 | return epnt->linktype == NHLT_LINK_DMIC || | |
286 | epnt->device_type == dev_type; | |
287 | } | |
288 | ||
289 | struct nhlt_specific_cfg * | |
290 | intel_nhlt_get_endpoint_blob(struct device *dev, struct nhlt_acpi_table *nhlt, | |
291 | u32 bus_id, u8 link_type, u8 vbps, u8 bps, | |
292 | u8 num_ch, u32 rate, u8 dir, u8 dev_type) | |
293 | { | |
294 | struct nhlt_specific_cfg *cfg; | |
295 | struct nhlt_endpoint *epnt; | |
7b4c93a5 | 296 | bool ignore_vbps = false; |
15fa179f AS |
297 | struct nhlt_fmt *fmt; |
298 | int i; | |
299 | ||
300 | if (!nhlt) | |
301 | return NULL; | |
302 | ||
303 | dev_dbg(dev, "Looking for configuration:\n"); | |
304 | dev_dbg(dev, " vbus_id=%d link_type=%d dir=%d, dev_type=%d\n", | |
305 | bus_id, link_type, dir, dev_type); | |
7b4c93a5 PU |
306 | if (link_type == NHLT_LINK_DMIC && bps == 32 && (vbps == 24 || vbps == 32)) { |
307 | /* | |
308 | * The DMIC hardware supports only one type of 32 bits sample | |
309 | * size, which is 24 bit sampling on the MSB side and bits[1:0] | |
310 | * are used for indicating the channel number. | |
311 | * It has been observed that some NHLT tables have the vbps | |
312 | * specified as 32 while some uses 24. | |
313 | * The format these variations describe are identical, the | |
314 | * hardware is configured and behaves the same way. | |
315 | * Note: when the samples assumed to be vbps=32 then the 'noise' | |
316 | * introduced by the lower two bits (channel number) have no | |
317 | * real life implication on audio quality. | |
318 | */ | |
319 | dev_dbg(dev, | |
320 | " ch=%d fmt=%d rate=%d (vbps is ignored for DMIC 32bit format)\n", | |
321 | num_ch, bps, rate); | |
322 | ignore_vbps = true; | |
323 | } else { | |
324 | dev_dbg(dev, " ch=%d fmt=%d/%d rate=%d\n", num_ch, vbps, bps, rate); | |
325 | } | |
15fa179f AS |
326 | dev_dbg(dev, "Endpoint count=%d\n", nhlt->endpoint_count); |
327 | ||
328 | epnt = (struct nhlt_endpoint *)nhlt->desc; | |
329 | ||
330 | for (i = 0; i < nhlt->endpoint_count; i++) { | |
331 | if (nhlt_check_ep_match(dev, epnt, bus_id, link_type, dir, dev_type)) { | |
332 | fmt = (struct nhlt_fmt *)(epnt->config.caps + epnt->config.size); | |
333 | ||
7b4c93a5 PU |
334 | cfg = nhlt_get_specific_cfg(dev, fmt, num_ch, rate, |
335 | vbps, bps, ignore_vbps); | |
15fa179f AS |
336 | if (cfg) |
337 | return cfg; | |
338 | } | |
339 | ||
340 | epnt = (struct nhlt_endpoint *)((u8 *)epnt + epnt->length); | |
341 | } | |
342 | ||
343 | return NULL; | |
344 | } | |
345 | EXPORT_SYMBOL(intel_nhlt_get_endpoint_blob); | |
02545bc5 BL |
346 | |
347 | int intel_nhlt_ssp_device_type(struct device *dev, struct nhlt_acpi_table *nhlt, | |
348 | u8 virtual_bus_id) | |
349 | { | |
350 | struct nhlt_endpoint *epnt; | |
351 | int i; | |
352 | ||
353 | if (!nhlt) | |
354 | return -EINVAL; | |
355 | ||
356 | epnt = (struct nhlt_endpoint *)nhlt->desc; | |
357 | for (i = 0; i < nhlt->endpoint_count; i++) { | |
358 | /* for SSP link the virtual bus id is the SSP port number */ | |
359 | if (epnt->linktype == NHLT_LINK_SSP && | |
360 | epnt->virtual_bus_id == virtual_bus_id) { | |
361 | dev_dbg(dev, "SSP%d: dev_type=%d\n", virtual_bus_id, | |
362 | epnt->device_type); | |
363 | return epnt->device_type; | |
364 | } | |
365 | ||
366 | epnt = (struct nhlt_endpoint *)((u8 *)epnt + epnt->length); | |
367 | } | |
368 | ||
369 | return -EINVAL; | |
370 | } | |
371 | EXPORT_SYMBOL(intel_nhlt_ssp_device_type); |