?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / sound / soc / codecs / cros_ec_codec.c
blobf33a2a9654e76becb7d059b800d7c536c31749d7
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright 2019 Google, Inc.
4 *
5 * ChromeOS Embedded Controller codec driver.
6 *
7 * This driver uses the cros-ec interface to communicate with the ChromeOS
8 * EC for audio function.
9 */
10
11 #include <crypto/sha2.h>
12 #include <linux/acpi.h>
13 #include <linux/delay.h>
14 #include <linux/device.h>
15 #include <linux/io.h>
16 #include <linux/jiffies.h>
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/of.h>
20 #include <linux/of_address.h>
21 #include <linux/platform_data/cros_ec_commands.h>
22 #include <linux/platform_data/cros_ec_proto.h>
23 #include <linux/platform_device.h>
24 #include <sound/pcm.h>
25 #include <sound/pcm_params.h>
26 #include <sound/soc.h>
27 #include <sound/tlv.h>
28
29 struct cros_ec_codec_priv {
30 struct device *dev;
31 struct cros_ec_device *ec_device;
32
33 /* common */
34 uint32_t ec_capabilities;
35
36 uint64_t ec_shm_addr;
37 uint32_t ec_shm_len;
38
39 uint64_t ap_shm_phys_addr;
40 uint32_t ap_shm_len;
41 uint64_t ap_shm_addr;
42 uint64_t ap_shm_last_alloc;
43
44 /* DMIC */
45 atomic_t dmic_probed;
46
47 /* I2S_RX */
48 uint32_t i2s_rx_bclk_ratio;
49
50 /* WoV */
51 bool wov_enabled;
52 uint8_t *wov_audio_shm_p;
53 uint32_t wov_audio_shm_len;
54 uint8_t wov_audio_shm_type;
55 uint8_t *wov_lang_shm_p;
56 uint32_t wov_lang_shm_len;
57 uint8_t wov_lang_shm_type;
58
59 struct mutex wov_dma_lock;
60 uint8_t wov_buf[64000];
61 uint32_t wov_rp, wov_wp;
62 size_t wov_dma_offset;
63 bool wov_burst_read;
64 struct snd_pcm_substream *wov_substream;
65 struct delayed_work wov_copy_work;
66 struct notifier_block wov_notifier;
67 };
68
69 static int ec_codec_capable(struct cros_ec_codec_priv *priv, uint8_t cap)
70 {
71 return priv->ec_capabilities & BIT(cap);
72 }
73
74 static int send_ec_host_command(struct cros_ec_device *ec_dev, uint32_t cmd,
75 uint8_t *out, size_t outsize,
76 uint8_t *in, size_t insize)
77 {
78 int ret;
79 struct cros_ec_command *msg;
80
81 msg = kmalloc(sizeof(*msg) + max(outsize, insize), GFP_KERNEL);
82 if (!msg)
83 return -ENOMEM;
84
85 msg->version = 0;
86 msg->command = cmd;
87 msg->outsize = outsize;
88 msg->insize = insize;
89
90 if (outsize)
91 memcpy(msg->data, out, outsize);
92
93 ret = cros_ec_cmd_xfer_status(ec_dev, msg);
94 if (ret < 0)
95 goto error;
96
97 if (insize)
98 memcpy(in, msg->data, insize);
99
100 ret = 0;
101 error:
102 kfree(msg);
103 return ret;
104 }
105
106 static int dmic_get_gain(struct snd_kcontrol *kcontrol,
107 struct snd_ctl_elem_value *ucontrol)
108 {
109 struct snd_soc_component *component =
110 snd_soc_kcontrol_component(kcontrol);
111 struct cros_ec_codec_priv *priv =
112 snd_soc_component_get_drvdata(component);
113 struct ec_param_ec_codec_dmic p;
114 struct ec_response_ec_codec_dmic_get_gain_idx r;
115 int ret;
116
117 p.cmd = EC_CODEC_DMIC_GET_GAIN_IDX;
118 p.get_gain_idx_param.channel = EC_CODEC_DMIC_CHANNEL_0;
119 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_DMIC,
120 (uint8_t *)&p, sizeof(p),
121 (uint8_t *)&r, sizeof(r));
122 if (ret < 0)
123 return ret;
124 ucontrol->value.integer.value[0] = r.gain;
125
126 p.cmd = EC_CODEC_DMIC_GET_GAIN_IDX;
127 p.get_gain_idx_param.channel = EC_CODEC_DMIC_CHANNEL_1;
128 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_DMIC,
129 (uint8_t *)&p, sizeof(p),
130 (uint8_t *)&r, sizeof(r));
131 if (ret < 0)
132 return ret;
133 ucontrol->value.integer.value[1] = r.gain;
134
135 return 0;
136 }
137
138 static int dmic_put_gain(struct snd_kcontrol *kcontrol,
139 struct snd_ctl_elem_value *ucontrol)
140 {
141 struct snd_soc_component *component =
142 snd_soc_kcontrol_component(kcontrol);
143 struct cros_ec_codec_priv *priv =
144 snd_soc_component_get_drvdata(component);
145 struct soc_mixer_control *control =
146 (struct soc_mixer_control *)kcontrol->private_value;
147 int max_dmic_gain = control->max;
148 int left = ucontrol->value.integer.value[0];
149 int right = ucontrol->value.integer.value[1];
150 struct ec_param_ec_codec_dmic p;
151 int ret;
152
153 if (left > max_dmic_gain || right > max_dmic_gain)
154 return -EINVAL;
155
156 dev_dbg(component->dev, "set mic gain to %u, %u\n", left, right);
157
158 p.cmd = EC_CODEC_DMIC_SET_GAIN_IDX;
159 p.set_gain_idx_param.channel = EC_CODEC_DMIC_CHANNEL_0;
160 p.set_gain_idx_param.gain = left;
161 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_DMIC,
162 (uint8_t *)&p, sizeof(p), NULL, 0);
163 if (ret < 0)
164 return ret;
165
166 p.cmd = EC_CODEC_DMIC_SET_GAIN_IDX;
167 p.set_gain_idx_param.channel = EC_CODEC_DMIC_CHANNEL_1;
168 p.set_gain_idx_param.gain = right;
169 return send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_DMIC,
170 (uint8_t *)&p, sizeof(p), NULL, 0);
171 }
172
173 static const DECLARE_TLV_DB_SCALE(dmic_gain_tlv, 0, 100, 0);
174
175 enum {
176 DMIC_CTL_GAIN = 0,
177 };
178
179 static struct snd_kcontrol_new dmic_controls[] = {
180 [DMIC_CTL_GAIN] =
181 SOC_DOUBLE_EXT_TLV("EC Mic Gain", SND_SOC_NOPM, SND_SOC_NOPM,
182 0, 0, 0, dmic_get_gain, dmic_put_gain,
183 dmic_gain_tlv),
184 };
185
186 static int dmic_probe(struct snd_soc_component *component)
187 {
188 struct cros_ec_codec_priv *priv =
189 snd_soc_component_get_drvdata(component);
190 struct device *dev = priv->dev;
191 struct soc_mixer_control *control;
192 struct ec_param_ec_codec_dmic p;
193 struct ec_response_ec_codec_dmic_get_max_gain r;
194 int ret;
195
196 if (!atomic_add_unless(&priv->dmic_probed, 1, 1))
197 return 0;
198
199 p.cmd = EC_CODEC_DMIC_GET_MAX_GAIN;
200
201 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_DMIC,
202 (uint8_t *)&p, sizeof(p),
203 (uint8_t *)&r, sizeof(r));
204 if (ret < 0) {
205 dev_warn(dev, "get_max_gain() unsupported\n");
206 return 0;
207 }
208
209 dev_dbg(dev, "max gain = %d\n", r.max_gain);
210
211 control = (struct soc_mixer_control *)
212 dmic_controls[DMIC_CTL_GAIN].private_value;
213 control->max = r.max_gain;
214 control->platform_max = r.max_gain;
215
216 return snd_soc_add_component_controls(component,
217 &dmic_controls[DMIC_CTL_GAIN], 1);
218 }
219
220 static int i2s_rx_hw_params(struct snd_pcm_substream *substream,
221 struct snd_pcm_hw_params *params,
222 struct snd_soc_dai *dai)
223 {
224 struct snd_soc_component *component = dai->component;
225 struct cros_ec_codec_priv *priv =
226 snd_soc_component_get_drvdata(component);
227 struct ec_param_ec_codec_i2s_rx p;
228 enum ec_codec_i2s_rx_sample_depth depth;
229 uint32_t bclk;
230 int ret;
231
232 if (params_rate(params) != 48000)
233 return -EINVAL;
234
235 switch (params_format(params)) {
236 case SNDRV_PCM_FORMAT_S16_LE:
237 depth = EC_CODEC_I2S_RX_SAMPLE_DEPTH_16;
238 break;
239 case SNDRV_PCM_FORMAT_S24_LE:
240 depth = EC_CODEC_I2S_RX_SAMPLE_DEPTH_24;
241 break;
242 default:
243 return -EINVAL;
244 }
245
246 dev_dbg(component->dev, "set depth to %u\n", depth);
247
248 p.cmd = EC_CODEC_I2S_RX_SET_SAMPLE_DEPTH;
249 p.set_sample_depth_param.depth = depth;
250 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_I2S_RX,
251 (uint8_t *)&p, sizeof(p), NULL, 0);
252 if (ret < 0)
253 return ret;
254
255 if (priv->i2s_rx_bclk_ratio)
256 bclk = params_rate(params) * priv->i2s_rx_bclk_ratio;
257 else
258 bclk = snd_soc_params_to_bclk(params);
259
260 dev_dbg(component->dev, "set bclk to %u\n", bclk);
261
262 p.cmd = EC_CODEC_I2S_RX_SET_BCLK;
263 p.set_bclk_param.bclk = bclk;
264 return send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_I2S_RX,
265 (uint8_t *)&p, sizeof(p), NULL, 0);
266 }
267
268 static int i2s_rx_set_bclk_ratio(struct snd_soc_dai *dai, unsigned int ratio)
269 {
270 struct snd_soc_component *component = dai->component;
271 struct cros_ec_codec_priv *priv =
272 snd_soc_component_get_drvdata(component);
273
274 priv->i2s_rx_bclk_ratio = ratio;
275 return 0;
276 }
277
278 static int i2s_rx_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
279 {
280 struct snd_soc_component *component = dai->component;
281 struct cros_ec_codec_priv *priv =
282 snd_soc_component_get_drvdata(component);
283 struct ec_param_ec_codec_i2s_rx p;
284 enum ec_codec_i2s_rx_daifmt daifmt;
285
286 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
287 case SND_SOC_DAIFMT_CBS_CFS:
288 break;
289 default:
290 return -EINVAL;
291 }
292
293 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
294 case SND_SOC_DAIFMT_NB_NF:
295 break;
296 default:
297 return -EINVAL;
298 }
299
300 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
301 case SND_SOC_DAIFMT_I2S:
302 daifmt = EC_CODEC_I2S_RX_DAIFMT_I2S;
303 break;
304 case SND_SOC_DAIFMT_RIGHT_J:
305 daifmt = EC_CODEC_I2S_RX_DAIFMT_RIGHT_J;
306 break;
307 case SND_SOC_DAIFMT_LEFT_J:
308 daifmt = EC_CODEC_I2S_RX_DAIFMT_LEFT_J;
309 break;
310 default:
311 return -EINVAL;
312 }
313
314 dev_dbg(component->dev, "set format to %u\n", daifmt);
315
316 p.cmd = EC_CODEC_I2S_RX_SET_DAIFMT;
317 p.set_daifmt_param.daifmt = daifmt;
318 return send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_I2S_RX,
319 (uint8_t *)&p, sizeof(p), NULL, 0);
320 }
321
322 static const struct snd_soc_dai_ops i2s_rx_dai_ops = {
323 .hw_params = i2s_rx_hw_params,
324 .set_fmt = i2s_rx_set_fmt,
325 .set_bclk_ratio = i2s_rx_set_bclk_ratio,
326 };
327
328 static int i2s_rx_event(struct snd_soc_dapm_widget *w,
329 struct snd_kcontrol *kcontrol, int event)
330 {
331 struct snd_soc_component *component =
332 snd_soc_dapm_to_component(w->dapm);
333 struct cros_ec_codec_priv *priv =
334 snd_soc_component_get_drvdata(component);
335 struct ec_param_ec_codec_i2s_rx p = {};
336
337 switch (event) {
338 case SND_SOC_DAPM_PRE_PMU:
339 dev_dbg(component->dev, "enable I2S RX\n");
340 p.cmd = EC_CODEC_I2S_RX_ENABLE;
341 break;
342 case SND_SOC_DAPM_PRE_PMD:
343 dev_dbg(component->dev, "disable I2S RX\n");
344 p.cmd = EC_CODEC_I2S_RX_DISABLE;
345 break;
346 default:
347 return 0;
348 }
349
350 return send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_I2S_RX,
351 (uint8_t *)&p, sizeof(p), NULL, 0);
352 }
353
354 static struct snd_soc_dapm_widget i2s_rx_dapm_widgets[] = {
355 SND_SOC_DAPM_INPUT("DMIC"),
356 SND_SOC_DAPM_SUPPLY("I2S RX Enable", SND_SOC_NOPM, 0, 0, i2s_rx_event,
357 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_PRE_PMD),
358 SND_SOC_DAPM_AIF_OUT("I2S RX", "I2S Capture", 0, SND_SOC_NOPM, 0, 0),
359 };
360
361 static struct snd_soc_dapm_route i2s_rx_dapm_routes[] = {
362 {"I2S RX", NULL, "DMIC"},
363 {"I2S RX", NULL, "I2S RX Enable"},
364 };
365
366 static struct snd_soc_dai_driver i2s_rx_dai_driver = {
367 .name = "EC Codec I2S RX",
368 .capture = {
369 .stream_name = "I2S Capture",
370 .channels_min = 2,
371 .channels_max = 2,
372 .rates = SNDRV_PCM_RATE_48000,
373 .formats = SNDRV_PCM_FMTBIT_S16_LE |
374 SNDRV_PCM_FMTBIT_S24_LE,
375 },
376 .ops = &i2s_rx_dai_ops,
377 };
378
379 static int i2s_rx_probe(struct snd_soc_component *component)
380 {
381 return dmic_probe(component);
382 }
383
384 static const struct snd_soc_component_driver i2s_rx_component_driver = {
385 .probe = i2s_rx_probe,
386 .dapm_widgets = i2s_rx_dapm_widgets,
387 .num_dapm_widgets = ARRAY_SIZE(i2s_rx_dapm_widgets),
388 .dapm_routes = i2s_rx_dapm_routes,
389 .num_dapm_routes = ARRAY_SIZE(i2s_rx_dapm_routes),
390 };
391
392 static void *wov_map_shm(struct cros_ec_codec_priv *priv,
393 uint8_t shm_id, uint32_t *len, uint8_t *type)
394 {
395 struct ec_param_ec_codec p;
396 struct ec_response_ec_codec_get_shm_addr r;
397 uint32_t req, offset;
398
399 p.cmd = EC_CODEC_GET_SHM_ADDR;
400 p.get_shm_addr_param.shm_id = shm_id;
401 if (send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC,
402 (uint8_t *)&p, sizeof(p),
403 (uint8_t *)&r, sizeof(r)) < 0) {
404 dev_err(priv->dev, "failed to EC_CODEC_GET_SHM_ADDR\n");
405 return NULL;
406 }
407
408 dev_dbg(priv->dev, "phys_addr=%#llx, len=%#x\n", r.phys_addr, r.len);
409
410 *len = r.len;
411 *type = r.type;
412
413 switch (r.type) {
414 case EC_CODEC_SHM_TYPE_EC_RAM:
415 return (void __force *)devm_ioremap_wc(priv->dev,
416 r.phys_addr + priv->ec_shm_addr, r.len);
417 case EC_CODEC_SHM_TYPE_SYSTEM_RAM:
418 if (r.phys_addr) {
419 dev_err(priv->dev, "unknown status\n");
420 return NULL;
421 }
422
423 req = round_up(r.len, PAGE_SIZE);
424 dev_dbg(priv->dev, "round up from %u to %u\n", r.len, req);
425
426 if (priv->ap_shm_last_alloc + req >
427 priv->ap_shm_phys_addr + priv->ap_shm_len) {
428 dev_err(priv->dev, "insufficient space for AP SHM\n");
429 return NULL;
430 }
431
432 dev_dbg(priv->dev, "alloc AP SHM addr=%#llx, len=%#x\n",
433 priv->ap_shm_last_alloc, req);
434
435 p.cmd = EC_CODEC_SET_SHM_ADDR;
436 p.set_shm_addr_param.phys_addr = priv->ap_shm_last_alloc;
437 p.set_shm_addr_param.len = req;
438 p.set_shm_addr_param.shm_id = shm_id;
439 if (send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC,
440 (uint8_t *)&p, sizeof(p),
441 NULL, 0) < 0) {
442 dev_err(priv->dev, "failed to EC_CODEC_SET_SHM_ADDR\n");
443 return NULL;
444 }
445
446 /*
447 * Note: EC codec only requests for `r.len' but we allocate
448 * round up PAGE_SIZE `req'.
449 */
450 offset = priv->ap_shm_last_alloc - priv->ap_shm_phys_addr;
451 priv->ap_shm_last_alloc += req;
452
453 return (void *)(uintptr_t)(priv->ap_shm_addr + offset);
454 default:
455 return NULL;
456 }
457 }
458
459 static bool wov_queue_full(struct cros_ec_codec_priv *priv)
460 {
461 return ((priv->wov_wp + 1) % sizeof(priv->wov_buf)) == priv->wov_rp;
462 }
463
464 static size_t wov_queue_size(struct cros_ec_codec_priv *priv)
465 {
466 if (priv->wov_wp >= priv->wov_rp)
467 return priv->wov_wp - priv->wov_rp;
468 else
469 return sizeof(priv->wov_buf) - priv->wov_rp + priv->wov_wp;
470 }
471
472 static void wov_queue_dequeue(struct cros_ec_codec_priv *priv, size_t len)
473 {
474 struct snd_pcm_runtime *runtime = priv->wov_substream->runtime;
475 size_t req;
476
477 while (len) {
478 req = min(len, runtime->dma_bytes - priv->wov_dma_offset);
479 if (priv->wov_wp >= priv->wov_rp)
480 req = min(req, (size_t)priv->wov_wp - priv->wov_rp);
481 else
482 req = min(req, sizeof(priv->wov_buf) - priv->wov_rp);
483
484 memcpy(runtime->dma_area + priv->wov_dma_offset,
485 priv->wov_buf + priv->wov_rp, req);
486
487 priv->wov_dma_offset += req;
488 if (priv->wov_dma_offset == runtime->dma_bytes)
489 priv->wov_dma_offset = 0;
490
491 priv->wov_rp += req;
492 if (priv->wov_rp == sizeof(priv->wov_buf))
493 priv->wov_rp = 0;
494
495 len -= req;
496 }
497
498 snd_pcm_period_elapsed(priv->wov_substream);
499 }
500
501 static void wov_queue_try_dequeue(struct cros_ec_codec_priv *priv)
502 {
503 size_t period_bytes = snd_pcm_lib_period_bytes(priv->wov_substream);
504
505 while (period_bytes && wov_queue_size(priv) >= period_bytes) {
506 wov_queue_dequeue(priv, period_bytes);
507 period_bytes = snd_pcm_lib_period_bytes(priv->wov_substream);
508 }
509 }
510
511 static void wov_queue_enqueue(struct cros_ec_codec_priv *priv,
512 uint8_t *addr, size_t len, bool iomem)
513 {
514 size_t req;
515
516 while (len) {
517 if (wov_queue_full(priv)) {
518 wov_queue_try_dequeue(priv);
519
520 if (wov_queue_full(priv)) {
521 dev_err(priv->dev, "overrun detected\n");
522 return;
523 }
524 }
525
526 if (priv->wov_wp >= priv->wov_rp)
527 req = sizeof(priv->wov_buf) - priv->wov_wp;
528 else
529 /* Note: waste 1-byte to differentiate full and empty */
530 req = priv->wov_rp - priv->wov_wp - 1;
531 req = min(req, len);
532
533 if (iomem)
534 memcpy_fromio(priv->wov_buf + priv->wov_wp,
535 (void __force __iomem *)addr, req);
536 else
537 memcpy(priv->wov_buf + priv->wov_wp, addr, req);
538
539 priv->wov_wp += req;
540 if (priv->wov_wp == sizeof(priv->wov_buf))
541 priv->wov_wp = 0;
542
543 addr += req;
544 len -= req;
545 }
546
547 wov_queue_try_dequeue(priv);
548 }
549
550 static int wov_read_audio_shm(struct cros_ec_codec_priv *priv)
551 {
552 struct ec_param_ec_codec_wov p;
553 struct ec_response_ec_codec_wov_read_audio_shm r;
554 int ret;
555
556 p.cmd = EC_CODEC_WOV_READ_AUDIO_SHM;
557 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV,
558 (uint8_t *)&p, sizeof(p),
559 (uint8_t *)&r, sizeof(r));
560 if (ret) {
561 dev_err(priv->dev, "failed to EC_CODEC_WOV_READ_AUDIO_SHM\n");
562 return ret;
563 }
564
565 if (!r.len)
566 dev_dbg(priv->dev, "no data, sleep\n");
567 else
568 wov_queue_enqueue(priv, priv->wov_audio_shm_p + r.offset, r.len,
569 priv->wov_audio_shm_type == EC_CODEC_SHM_TYPE_EC_RAM);
570 return -EAGAIN;
571 }
572
573 static int wov_read_audio(struct cros_ec_codec_priv *priv)
574 {
575 struct ec_param_ec_codec_wov p;
576 struct ec_response_ec_codec_wov_read_audio r;
577 int remain = priv->wov_burst_read ? 16000 : 320;
578 int ret;
579
580 while (remain >= 0) {
581 p.cmd = EC_CODEC_WOV_READ_AUDIO;
582 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV,
583 (uint8_t *)&p, sizeof(p),
584 (uint8_t *)&r, sizeof(r));
585 if (ret) {
586 dev_err(priv->dev,
587 "failed to EC_CODEC_WOV_READ_AUDIO\n");
588 return ret;
589 }
590
591 if (!r.len) {
592 dev_dbg(priv->dev, "no data, sleep\n");
593 priv->wov_burst_read = false;
594 break;
595 }
596
597 wov_queue_enqueue(priv, r.buf, r.len, false);
598 remain -= r.len;
599 }
600
601 return -EAGAIN;
602 }
603
604 static void wov_copy_work(struct work_struct *w)
605 {
606 struct cros_ec_codec_priv *priv =
607 container_of(w, struct cros_ec_codec_priv, wov_copy_work.work);
608 int ret;
609
610 mutex_lock(&priv->wov_dma_lock);
611 if (!priv->wov_substream) {
612 dev_warn(priv->dev, "no pcm substream\n");
613 goto leave;
614 }
615
616 if (ec_codec_capable(priv, EC_CODEC_CAP_WOV_AUDIO_SHM))
617 ret = wov_read_audio_shm(priv);
618 else
619 ret = wov_read_audio(priv);
620
621 if (ret == -EAGAIN)
622 schedule_delayed_work(&priv->wov_copy_work,
623 msecs_to_jiffies(10));
624 else if (ret)
625 dev_err(priv->dev, "failed to read audio data\n");
626 leave:
627 mutex_unlock(&priv->wov_dma_lock);
628 }
629
630 static int wov_enable_get(struct snd_kcontrol *kcontrol,
631 struct snd_ctl_elem_value *ucontrol)
632 {
633 struct snd_soc_component *c = snd_soc_kcontrol_component(kcontrol);
634 struct cros_ec_codec_priv *priv = snd_soc_component_get_drvdata(c);
635
636 ucontrol->value.integer.value[0] = priv->wov_enabled;
637 return 0;
638 }
639
640 static int wov_enable_put(struct snd_kcontrol *kcontrol,
641 struct snd_ctl_elem_value *ucontrol)
642 {
643 struct snd_soc_component *c = snd_soc_kcontrol_component(kcontrol);
644 struct cros_ec_codec_priv *priv = snd_soc_component_get_drvdata(c);
645 int enabled = ucontrol->value.integer.value[0];
646 struct ec_param_ec_codec_wov p;
647 int ret;
648
649 if (priv->wov_enabled != enabled) {
650 if (enabled)
651 p.cmd = EC_CODEC_WOV_ENABLE;
652 else
653 p.cmd = EC_CODEC_WOV_DISABLE;
654
655 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV,
656 (uint8_t *)&p, sizeof(p), NULL, 0);
657 if (ret) {
658 dev_err(priv->dev, "failed to %s wov\n",
659 enabled ? "enable" : "disable");
660 return ret;
661 }
662
663 priv->wov_enabled = enabled;
664 }
665
666 return 0;
667 }
668
669 static int wov_set_lang_shm(struct cros_ec_codec_priv *priv,
670 uint8_t *buf, size_t size, uint8_t *digest)
671 {
672 struct ec_param_ec_codec_wov p;
673 struct ec_param_ec_codec_wov_set_lang_shm *pp = &p.set_lang_shm_param;
674 int ret;
675
676 if (size > priv->wov_lang_shm_len) {
677 dev_err(priv->dev, "no enough SHM size: %d\n",
678 priv->wov_lang_shm_len);
679 return -EIO;
680 }
681
682 switch (priv->wov_lang_shm_type) {
683 case EC_CODEC_SHM_TYPE_EC_RAM:
684 memcpy_toio((void __force __iomem *)priv->wov_lang_shm_p,
685 buf, size);
686 memset_io((void __force __iomem *)priv->wov_lang_shm_p + size,
687 0, priv->wov_lang_shm_len - size);
688 break;
689 case EC_CODEC_SHM_TYPE_SYSTEM_RAM:
690 memcpy(priv->wov_lang_shm_p, buf, size);
691 memset(priv->wov_lang_shm_p + size, 0,
692 priv->wov_lang_shm_len - size);
693
694 /* make sure write to memory before calling host command */
695 wmb();
696 break;
697 }
698
699 p.cmd = EC_CODEC_WOV_SET_LANG_SHM;
700 memcpy(pp->hash, digest, SHA256_DIGEST_SIZE);
701 pp->total_len = size;
702 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV,
703 (uint8_t *)&p, sizeof(p), NULL, 0);
704 if (ret) {
705 dev_err(priv->dev, "failed to EC_CODEC_WOV_SET_LANG_SHM\n");
706 return ret;
707 }
708
709 return 0;
710 }
711
712 static int wov_set_lang(struct cros_ec_codec_priv *priv,
713 uint8_t *buf, size_t size, uint8_t *digest)
714 {
715 struct ec_param_ec_codec_wov p;
716 struct ec_param_ec_codec_wov_set_lang *pp = &p.set_lang_param;
717 size_t i, req;
718 int ret;
719
720 for (i = 0; i < size; i += req) {
721 req = min(size - i, ARRAY_SIZE(pp->buf));
722
723 p.cmd = EC_CODEC_WOV_SET_LANG;
724 memcpy(pp->hash, digest, SHA256_DIGEST_SIZE);
725 pp->total_len = size;
726 pp->offset = i;
727 memcpy(pp->buf, buf + i, req);
728 pp->len = req;
729 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV,
730 (uint8_t *)&p, sizeof(p), NULL, 0);
731 if (ret) {
732 dev_err(priv->dev, "failed to EC_CODEC_WOV_SET_LANG\n");
733 return ret;
734 }
735 }
736
737 return 0;
738 }
739
740 static int wov_hotword_model_put(struct snd_kcontrol *kcontrol,
741 const unsigned int __user *bytes,
742 unsigned int size)
743 {
744 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
745 struct cros_ec_codec_priv *priv =
746 snd_soc_component_get_drvdata(component);
747 struct ec_param_ec_codec_wov p;
748 struct ec_response_ec_codec_wov_get_lang r;
749 uint8_t digest[SHA256_DIGEST_SIZE];
750 uint8_t *buf;
751 int ret;
752
753 /* Skips the TLV header. */
754 bytes += 2;
755 size -= 8;
756
757 dev_dbg(priv->dev, "%s: size=%d\n", __func__, size);
758
759 buf = memdup_user(bytes, size);
760 if (IS_ERR(buf))
761 return PTR_ERR(buf);
762
763 sha256(buf, size, digest);
764 dev_dbg(priv->dev, "hash=%*phN\n", SHA256_DIGEST_SIZE, digest);
765
766 p.cmd = EC_CODEC_WOV_GET_LANG;
767 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV,
768 (uint8_t *)&p, sizeof(p),
769 (uint8_t *)&r, sizeof(r));
770 if (ret)
771 goto leave;
772
773 if (memcmp(digest, r.hash, SHA256_DIGEST_SIZE) == 0) {
774 dev_dbg(priv->dev, "not updated");
775 goto leave;
776 }
777
778 if (ec_codec_capable(priv, EC_CODEC_CAP_WOV_LANG_SHM))
779 ret = wov_set_lang_shm(priv, buf, size, digest);
780 else
781 ret = wov_set_lang(priv, buf, size, digest);
782
783 leave:
784 kfree(buf);
785 return ret;
786 }
787
788 static struct snd_kcontrol_new wov_controls[] = {
789 SOC_SINGLE_BOOL_EXT("Wake-on-Voice Switch", 0,
790 wov_enable_get, wov_enable_put),
791 SND_SOC_BYTES_TLV("Hotword Model", 0x11000, NULL,
792 wov_hotword_model_put),
793 };
794
795 static struct snd_soc_dai_driver wov_dai_driver = {
796 .name = "Wake on Voice",
797 .capture = {
798 .stream_name = "WoV Capture",
799 .channels_min = 1,
800 .channels_max = 1,
801 .rates = SNDRV_PCM_RATE_16000,
802 .formats = SNDRV_PCM_FMTBIT_S16_LE,
803 },
804 };
805
806 static int wov_host_event(struct notifier_block *nb,
807 unsigned long queued_during_suspend, void *notify)
808 {
809 struct cros_ec_codec_priv *priv =
810 container_of(nb, struct cros_ec_codec_priv, wov_notifier);
811 u32 host_event;
812
813 dev_dbg(priv->dev, "%s\n", __func__);
814
815 host_event = cros_ec_get_host_event(priv->ec_device);
816 if (host_event & EC_HOST_EVENT_MASK(EC_HOST_EVENT_WOV)) {
817 schedule_delayed_work(&priv->wov_copy_work, 0);
818 return NOTIFY_OK;
819 } else {
820 return NOTIFY_DONE;
821 }
822 }
823
824 static int wov_probe(struct snd_soc_component *component)
825 {
826 struct cros_ec_codec_priv *priv =
827 snd_soc_component_get_drvdata(component);
828 int ret;
829
830 mutex_init(&priv->wov_dma_lock);
831 INIT_DELAYED_WORK(&priv->wov_copy_work, wov_copy_work);
832
833 priv->wov_notifier.notifier_call = wov_host_event;
834 ret = blocking_notifier_chain_register(
835 &priv->ec_device->event_notifier, &priv->wov_notifier);
836 if (ret)
837 return ret;
838
839 if (ec_codec_capable(priv, EC_CODEC_CAP_WOV_LANG_SHM)) {
840 priv->wov_lang_shm_p = wov_map_shm(priv,
841 EC_CODEC_SHM_ID_WOV_LANG,
842 &priv->wov_lang_shm_len,
843 &priv->wov_lang_shm_type);
844 if (!priv->wov_lang_shm_p)
845 return -EFAULT;
846 }
847
848 if (ec_codec_capable(priv, EC_CODEC_CAP_WOV_AUDIO_SHM)) {
849 priv->wov_audio_shm_p = wov_map_shm(priv,
850 EC_CODEC_SHM_ID_WOV_AUDIO,
851 &priv->wov_audio_shm_len,
852 &priv->wov_audio_shm_type);
853 if (!priv->wov_audio_shm_p)
854 return -EFAULT;
855 }
856
857 return dmic_probe(component);
858 }
859
860 static void wov_remove(struct snd_soc_component *component)
861 {
862 struct cros_ec_codec_priv *priv =
863 snd_soc_component_get_drvdata(component);
864
865 blocking_notifier_chain_unregister(
866 &priv->ec_device->event_notifier, &priv->wov_notifier);
867 }
868
869 static int wov_pcm_open(struct snd_soc_component *component,
870 struct snd_pcm_substream *substream)
871 {
872 static const struct snd_pcm_hardware hw_param = {
873 .info = SNDRV_PCM_INFO_MMAP |
874 SNDRV_PCM_INFO_INTERLEAVED |
875 SNDRV_PCM_INFO_MMAP_VALID,
876 .formats = SNDRV_PCM_FMTBIT_S16_LE,
877 .rates = SNDRV_PCM_RATE_16000,
878 .channels_min = 1,
879 .channels_max = 1,
880 .period_bytes_min = PAGE_SIZE,
881 .period_bytes_max = 0x20000 / 8,
882 .periods_min = 8,
883 .periods_max = 8,
884 .buffer_bytes_max = 0x20000,
885 };
886
887 return snd_soc_set_runtime_hwparams(substream, &hw_param);
888 }
889
890 static int wov_pcm_hw_params(struct snd_soc_component *component,
891 struct snd_pcm_substream *substream,
892 struct snd_pcm_hw_params *hw_params)
893 {
894 struct cros_ec_codec_priv *priv =
895 snd_soc_component_get_drvdata(component);
896
897 mutex_lock(&priv->wov_dma_lock);
898 priv->wov_substream = substream;
899 priv->wov_rp = priv->wov_wp = 0;
900 priv->wov_dma_offset = 0;
901 priv->wov_burst_read = true;
902 mutex_unlock(&priv->wov_dma_lock);
903
904 return 0;
905 }
906
907 static int wov_pcm_hw_free(struct snd_soc_component *component,
908 struct snd_pcm_substream *substream)
909 {
910 struct cros_ec_codec_priv *priv =
911 snd_soc_component_get_drvdata(component);
912
913 mutex_lock(&priv->wov_dma_lock);
914 wov_queue_dequeue(priv, wov_queue_size(priv));
915 priv->wov_substream = NULL;
916 mutex_unlock(&priv->wov_dma_lock);
917
918 cancel_delayed_work_sync(&priv->wov_copy_work);
919
920 return 0;
921 }
922
923 static snd_pcm_uframes_t wov_pcm_pointer(struct snd_soc_component *component,
924 struct snd_pcm_substream *substream)
925 {
926 struct snd_pcm_runtime *runtime = substream->runtime;
927 struct cros_ec_codec_priv *priv =
928 snd_soc_component_get_drvdata(component);
929
930 return bytes_to_frames(runtime, priv->wov_dma_offset);
931 }
932
933 static int wov_pcm_new(struct snd_soc_component *component,
934 struct snd_soc_pcm_runtime *rtd)
935 {
936 snd_pcm_set_managed_buffer_all(rtd->pcm, SNDRV_DMA_TYPE_VMALLOC,
937 NULL, 0, 0);
938 return 0;
939 }
940
941 static const struct snd_soc_component_driver wov_component_driver = {
942 .probe = wov_probe,
943 .remove = wov_remove,
944 .controls = wov_controls,
945 .num_controls = ARRAY_SIZE(wov_controls),
946 .open = wov_pcm_open,
947 .hw_params = wov_pcm_hw_params,
948 .hw_free = wov_pcm_hw_free,
949 .pointer = wov_pcm_pointer,
950 .pcm_construct = wov_pcm_new,
951 };
952
953 static int cros_ec_codec_platform_probe(struct platform_device *pdev)
954 {
955 struct device *dev = &pdev->dev;
956 struct cros_ec_device *ec_device = dev_get_drvdata(pdev->dev.parent);
957 struct cros_ec_codec_priv *priv;
958 struct ec_param_ec_codec p;
959 struct ec_response_ec_codec_get_capabilities r;
960 int ret;
961 #ifdef CONFIG_OF
962 struct device_node *node;
963 struct resource res;
964 u64 ec_shm_size;
965 const __be32 *regaddr_p;
966 #endif
967
968 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
969 if (!priv)
970 return -ENOMEM;
971
972 #ifdef CONFIG_OF
973 regaddr_p = of_get_address(dev->of_node, 0, &ec_shm_size, NULL);
974 if (regaddr_p) {
975 priv->ec_shm_addr = of_read_number(regaddr_p, 2);
976 priv->ec_shm_len = ec_shm_size;
977
978 dev_dbg(dev, "ec_shm_addr=%#llx len=%#x\n",
979 priv->ec_shm_addr, priv->ec_shm_len);
980 }
981
982 node = of_parse_phandle(dev->of_node, "memory-region", 0);
983 if (node) {
984 ret = of_address_to_resource(node, 0, &res);
985 if (!ret) {
986 priv->ap_shm_phys_addr = res.start;
987 priv->ap_shm_len = resource_size(&res);
988 priv->ap_shm_addr =
989 (uint64_t)(uintptr_t)devm_ioremap_wc(
990 dev, priv->ap_shm_phys_addr,
991 priv->ap_shm_len);
992 priv->ap_shm_last_alloc = priv->ap_shm_phys_addr;
993
994 dev_dbg(dev, "ap_shm_phys_addr=%#llx len=%#x\n",
995 priv->ap_shm_phys_addr, priv->ap_shm_len);
996 }
997 }
998 #endif
999
1000 priv->dev = dev;
1001 priv->ec_device = ec_device;
1002 atomic_set(&priv->dmic_probed, 0);
1003
1004 p.cmd = EC_CODEC_GET_CAPABILITIES;
1005 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC,
1006 (uint8_t *)&p, sizeof(p),
1007 (uint8_t *)&r, sizeof(r));
1008 if (ret) {
1009 dev_err(dev, "failed to EC_CODEC_GET_CAPABILITIES\n");
1010 return ret;
1011 }
1012 priv->ec_capabilities = r.capabilities;
1013
1014 platform_set_drvdata(pdev, priv);
1015
1016 ret = devm_snd_soc_register_component(dev, &i2s_rx_component_driver,
1017 &i2s_rx_dai_driver, 1);
1018 if (ret)
1019 return ret;
1020
1021 return devm_snd_soc_register_component(dev, &wov_component_driver,
1022 &wov_dai_driver, 1);
1023 }
1024
1025 #ifdef CONFIG_OF
1026 static const struct of_device_id cros_ec_codec_of_match[] = {
1027 { .compatible = "google,cros-ec-codec" },
1028 {},
1029 };
1030 MODULE_DEVICE_TABLE(of, cros_ec_codec_of_match);
1031 #endif
1032
1033 #ifdef CONFIG_ACPI
1034 static const struct acpi_device_id cros_ec_codec_acpi_id[] = {
1035 { "GOOG0013", 0 },
1036 { }
1037 };
1038 MODULE_DEVICE_TABLE(acpi, cros_ec_codec_acpi_id);
1039 #endif
1040
1041 static struct platform_driver cros_ec_codec_platform_driver = {
1042 .driver = {
1043 .name = "cros-ec-codec",
1044 .of_match_table = of_match_ptr(cros_ec_codec_of_match),
1045 .acpi_match_table = ACPI_PTR(cros_ec_codec_acpi_id),
1046 },
1047 .probe = cros_ec_codec_platform_probe,
1048 };
1049
1050 module_platform_driver(cros_ec_codec_platform_driver);
1051
1052 MODULE_LICENSE("GPL v2");
1053 MODULE_DESCRIPTION("ChromeOS EC codec driver");
1054 MODULE_AUTHOR("Cheng-Yi Chiang <cychiang@chromium.org>");
1055 MODULE_ALIAS("platform:cros-ec-codec");
Linux with added FPC-III support