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