1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | // Copyright (c) 2015-2019 Intel Corporation |
3 | |
4 | #include <linux/acpi.h> |
5 | #include <sound/intel-nhlt.h> |
6 | |
7 | struct nhlt_acpi_table *intel_nhlt_init(struct device *dev) |
8 | { |
9 | struct nhlt_acpi_table *nhlt; |
10 | acpi_status status; |
11 | |
12 | status = acpi_get_table(ACPI_SIG_NHLT, instance: 0, |
13 | out_table: (struct acpi_table_header **)&nhlt); |
14 | if (ACPI_FAILURE(status)) { |
15 | dev_warn(dev, "NHLT table not found\n" ); |
16 | return NULL; |
17 | } |
18 | |
19 | return nhlt; |
20 | } |
21 | EXPORT_SYMBOL_GPL(intel_nhlt_init); |
22 | |
23 | void intel_nhlt_free(struct nhlt_acpi_table *nhlt) |
24 | { |
25 | acpi_put_table(table: (struct acpi_table_header *)nhlt); |
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; |
33 | struct nhlt_vendor_dmic_array_config *cfg_vendor; |
34 | struct nhlt_fmt *fmt_configs; |
35 | unsigned int dmic_geo = 0; |
36 | u16 max_ch = 0; |
37 | u8 i, j; |
38 | |
39 | if (!nhlt) |
40 | return 0; |
41 | |
42 | if (nhlt->header.length <= sizeof(struct acpi_table_header)) { |
43 | dev_warn(dev, "Invalid DMIC description table\n" ); |
44 | return 0; |
45 | } |
46 | |
47 | for (j = 0, epnt = nhlt->desc; j < nhlt->endpoint_count; j++, |
48 | epnt = (struct nhlt_endpoint *)((u8 *)epnt + epnt->length)) { |
49 | |
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) { |
58 | struct nhlt_fmt_cfg *fmt_cfg = fmt_configs->fmt_config; |
59 | |
60 | dev_dbg(dev, "found %d format definitions\n" , |
61 | fmt_configs->fmt_count); |
62 | |
63 | for (i = 0; i < fmt_configs->fmt_count; i++) { |
64 | struct wav_fmt_ext *fmt_ext; |
65 | |
66 | fmt_ext = &fmt_cfg->fmt_ext; |
67 | |
68 | if (fmt_ext->fmt.channels > max_ch) |
69 | max_ch = fmt_ext->fmt.channels; |
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); |
74 | } |
75 | dev_dbg(dev, "max channels found %d\n" , max_ch); |
76 | } else { |
77 | dev_dbg(dev, "No format information found\n" ); |
78 | } |
79 | |
80 | if (cfg->device_config.config_type != NHLT_CONFIG_TYPE_MIC_ARRAY) { |
81 | dmic_geo = max_ch; |
82 | } else { |
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; |
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; |
98 | default: |
99 | dev_warn(dev, "%s: undefined DMIC array_type 0x%0x\n" , |
100 | __func__, cfg->array_type); |
101 | } |
102 | |
103 | if (dmic_geo > 0) { |
104 | dev_dbg(dev, "Array with %d dmics\n" , dmic_geo); |
105 | } |
106 | if (max_ch > dmic_geo) { |
107 | dev_dbg(dev, "max channels %d exceed dmic number %d\n" , |
108 | max_ch, dmic_geo); |
109 | } |
110 | } |
111 | } |
112 | |
113 | dev_dbg(dev, "dmic number %d max_ch %d\n" , dmic_geo, max_ch); |
114 | |
115 | return dmic_geo; |
116 | } |
117 | EXPORT_SYMBOL_GPL(intel_nhlt_get_dmic_geo); |
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 | |
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 | |
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(w: mclk_mask) != 1) |
233 | return -EINVAL; |
234 | |
235 | return mclk_mask; |
236 | } |
237 | EXPORT_SYMBOL(intel_nhlt_ssp_mclk_mask); |
238 | |
239 | static struct nhlt_specific_cfg * |
240 | nhlt_get_specific_cfg(struct device *dev, struct nhlt_fmt *fmt, u8 num_ch, |
241 | u32 rate, u8 vbps, u8 bps, bool ignore_vbps) |
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 | |
258 | /* |
259 | * When looking for exact match of configuration ignore the vbps |
260 | * from NHLT table when ignore_vbps is true |
261 | */ |
262 | if (wfmt->channels == num_ch && wfmt->samples_per_sec == rate && |
263 | (ignore_vbps || vbps == _vbps) && bps == _bps) |
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; |
296 | bool ignore_vbps = false; |
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); |
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 | } |
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 | |
334 | cfg = nhlt_get_specific_cfg(dev, fmt, num_ch, rate, |
335 | vbps, bps, ignore_vbps); |
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); |
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); |
372 | |