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