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 (in && 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_width(params)) { 236 case 16: 237 depth = EC_CODEC_I2S_RX_SAMPLE_DEPTH_16; 238 break; 239 case 24: 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_CLOCK_PROVIDER_MASK) { 287 case SND_SOC_DAIFMT_CBC_CFC: 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 .endianness = 1, 391 }; 392 393 static void *wov_map_shm(struct cros_ec_codec_priv *priv, 394 uint8_t shm_id, uint32_t *len, uint8_t *type) 395 { 396 struct ec_param_ec_codec p; 397 struct ec_response_ec_codec_get_shm_addr r; 398 uint32_t req, offset; 399 400 p.cmd = EC_CODEC_GET_SHM_ADDR; 401 p.get_shm_addr_param.shm_id = shm_id; 402 if (send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC, 403 (uint8_t *)&p, sizeof(p), 404 (uint8_t *)&r, sizeof(r)) < 0) { 405 dev_err(priv->dev, "failed to EC_CODEC_GET_SHM_ADDR\n"); 406 return NULL; 407 } 408 409 dev_dbg(priv->dev, "phys_addr=%#llx, len=%#x\n", r.phys_addr, r.len); 410 411 *len = r.len; 412 *type = r.type; 413 414 switch (r.type) { 415 case EC_CODEC_SHM_TYPE_EC_RAM: 416 return (void __force *)devm_ioremap_wc(priv->dev, 417 r.phys_addr + priv->ec_shm_addr, r.len); 418 case EC_CODEC_SHM_TYPE_SYSTEM_RAM: 419 if (r.phys_addr) { 420 dev_err(priv->dev, "unknown status\n"); 421 return NULL; 422 } 423 424 req = round_up(r.len, PAGE_SIZE); 425 dev_dbg(priv->dev, "round up from %u to %u\n", r.len, req); 426 427 if (priv->ap_shm_last_alloc + req > 428 priv->ap_shm_phys_addr + priv->ap_shm_len) { 429 dev_err(priv->dev, "insufficient space for AP SHM\n"); 430 return NULL; 431 } 432 433 dev_dbg(priv->dev, "alloc AP SHM addr=%#llx, len=%#x\n", 434 priv->ap_shm_last_alloc, req); 435 436 p.cmd = EC_CODEC_SET_SHM_ADDR; 437 p.set_shm_addr_param.phys_addr = priv->ap_shm_last_alloc; 438 p.set_shm_addr_param.len = req; 439 p.set_shm_addr_param.shm_id = shm_id; 440 if (send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC, 441 (uint8_t *)&p, sizeof(p), 442 NULL, 0) < 0) { 443 dev_err(priv->dev, "failed to EC_CODEC_SET_SHM_ADDR\n"); 444 return NULL; 445 } 446 447 /* 448 * Note: EC codec only requests for `r.len' but we allocate 449 * round up PAGE_SIZE `req'. 450 */ 451 offset = priv->ap_shm_last_alloc - priv->ap_shm_phys_addr; 452 priv->ap_shm_last_alloc += req; 453 454 return (void *)(uintptr_t)(priv->ap_shm_addr + offset); 455 default: 456 return NULL; 457 } 458 } 459 460 static bool wov_queue_full(struct cros_ec_codec_priv *priv) 461 { 462 return ((priv->wov_wp + 1) % sizeof(priv->wov_buf)) == priv->wov_rp; 463 } 464 465 static size_t wov_queue_size(struct cros_ec_codec_priv *priv) 466 { 467 if (priv->wov_wp >= priv->wov_rp) 468 return priv->wov_wp - priv->wov_rp; 469 else 470 return sizeof(priv->wov_buf) - priv->wov_rp + priv->wov_wp; 471 } 472 473 static void wov_queue_dequeue(struct cros_ec_codec_priv *priv, size_t len) 474 { 475 struct snd_pcm_runtime *runtime = priv->wov_substream->runtime; 476 size_t req; 477 478 while (len) { 479 req = min(len, runtime->dma_bytes - priv->wov_dma_offset); 480 if (priv->wov_wp >= priv->wov_rp) 481 req = min(req, (size_t)priv->wov_wp - priv->wov_rp); 482 else 483 req = min(req, sizeof(priv->wov_buf) - priv->wov_rp); 484 485 memcpy(runtime->dma_area + priv->wov_dma_offset, 486 priv->wov_buf + priv->wov_rp, req); 487 488 priv->wov_dma_offset += req; 489 if (priv->wov_dma_offset == runtime->dma_bytes) 490 priv->wov_dma_offset = 0; 491 492 priv->wov_rp += req; 493 if (priv->wov_rp == sizeof(priv->wov_buf)) 494 priv->wov_rp = 0; 495 496 len -= req; 497 } 498 499 snd_pcm_period_elapsed(priv->wov_substream); 500 } 501 502 static void wov_queue_try_dequeue(struct cros_ec_codec_priv *priv) 503 { 504 size_t period_bytes = snd_pcm_lib_period_bytes(priv->wov_substream); 505 506 while (period_bytes && wov_queue_size(priv) >= period_bytes) { 507 wov_queue_dequeue(priv, period_bytes); 508 period_bytes = snd_pcm_lib_period_bytes(priv->wov_substream); 509 } 510 } 511 512 static void wov_queue_enqueue(struct cros_ec_codec_priv *priv, 513 uint8_t *addr, size_t len, bool iomem) 514 { 515 size_t req; 516 517 while (len) { 518 if (wov_queue_full(priv)) { 519 wov_queue_try_dequeue(priv); 520 521 if (wov_queue_full(priv)) { 522 dev_err(priv->dev, "overrun detected\n"); 523 return; 524 } 525 } 526 527 if (priv->wov_wp >= priv->wov_rp) 528 req = sizeof(priv->wov_buf) - priv->wov_wp; 529 else 530 /* Note: waste 1-byte to differentiate full and empty */ 531 req = priv->wov_rp - priv->wov_wp - 1; 532 req = min(req, len); 533 534 if (iomem) 535 memcpy_fromio(priv->wov_buf + priv->wov_wp, 536 (void __force __iomem *)addr, req); 537 else 538 memcpy(priv->wov_buf + priv->wov_wp, addr, req); 539 540 priv->wov_wp += req; 541 if (priv->wov_wp == sizeof(priv->wov_buf)) 542 priv->wov_wp = 0; 543 544 addr += req; 545 len -= req; 546 } 547 548 wov_queue_try_dequeue(priv); 549 } 550 551 static int wov_read_audio_shm(struct cros_ec_codec_priv *priv) 552 { 553 struct ec_param_ec_codec_wov p; 554 struct ec_response_ec_codec_wov_read_audio_shm r; 555 int ret; 556 557 p.cmd = EC_CODEC_WOV_READ_AUDIO_SHM; 558 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV, 559 (uint8_t *)&p, sizeof(p), 560 (uint8_t *)&r, sizeof(r)); 561 if (ret) { 562 dev_err(priv->dev, "failed to EC_CODEC_WOV_READ_AUDIO_SHM\n"); 563 return ret; 564 } 565 566 if (!r.len) 567 dev_dbg(priv->dev, "no data, sleep\n"); 568 else 569 wov_queue_enqueue(priv, priv->wov_audio_shm_p + r.offset, r.len, 570 priv->wov_audio_shm_type == EC_CODEC_SHM_TYPE_EC_RAM); 571 return -EAGAIN; 572 } 573 574 static int wov_read_audio(struct cros_ec_codec_priv *priv) 575 { 576 struct ec_param_ec_codec_wov p; 577 struct ec_response_ec_codec_wov_read_audio r; 578 int remain = priv->wov_burst_read ? 16000 : 320; 579 int ret; 580 581 while (remain >= 0) { 582 p.cmd = EC_CODEC_WOV_READ_AUDIO; 583 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV, 584 (uint8_t *)&p, sizeof(p), 585 (uint8_t *)&r, sizeof(r)); 586 if (ret) { 587 dev_err(priv->dev, 588 "failed to EC_CODEC_WOV_READ_AUDIO\n"); 589 return ret; 590 } 591 592 if (!r.len) { 593 dev_dbg(priv->dev, "no data, sleep\n"); 594 priv->wov_burst_read = false; 595 break; 596 } 597 598 wov_queue_enqueue(priv, r.buf, r.len, false); 599 remain -= r.len; 600 } 601 602 return -EAGAIN; 603 } 604 605 static void wov_copy_work(struct work_struct *w) 606 { 607 struct cros_ec_codec_priv *priv = 608 container_of(w, struct cros_ec_codec_priv, wov_copy_work.work); 609 int ret; 610 611 mutex_lock(&priv->wov_dma_lock); 612 if (!priv->wov_substream) { 613 dev_warn(priv->dev, "no pcm substream\n"); 614 goto leave; 615 } 616 617 if (ec_codec_capable(priv, EC_CODEC_CAP_WOV_AUDIO_SHM)) 618 ret = wov_read_audio_shm(priv); 619 else 620 ret = wov_read_audio(priv); 621 622 if (ret == -EAGAIN) 623 schedule_delayed_work(&priv->wov_copy_work, 624 msecs_to_jiffies(10)); 625 else if (ret) 626 dev_err(priv->dev, "failed to read audio data\n"); 627 leave: 628 mutex_unlock(&priv->wov_dma_lock); 629 } 630 631 static int wov_enable_get(struct snd_kcontrol *kcontrol, 632 struct snd_ctl_elem_value *ucontrol) 633 { 634 struct snd_soc_component *c = snd_soc_kcontrol_component(kcontrol); 635 struct cros_ec_codec_priv *priv = snd_soc_component_get_drvdata(c); 636 637 ucontrol->value.integer.value[0] = priv->wov_enabled; 638 return 0; 639 } 640 641 static int wov_enable_put(struct snd_kcontrol *kcontrol, 642 struct snd_ctl_elem_value *ucontrol) 643 { 644 struct snd_soc_component *c = snd_soc_kcontrol_component(kcontrol); 645 struct cros_ec_codec_priv *priv = snd_soc_component_get_drvdata(c); 646 int enabled = ucontrol->value.integer.value[0]; 647 struct ec_param_ec_codec_wov p; 648 int ret; 649 650 if (priv->wov_enabled != enabled) { 651 if (enabled) 652 p.cmd = EC_CODEC_WOV_ENABLE; 653 else 654 p.cmd = EC_CODEC_WOV_DISABLE; 655 656 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV, 657 (uint8_t *)&p, sizeof(p), NULL, 0); 658 if (ret) { 659 dev_err(priv->dev, "failed to %s wov\n", 660 enabled ? "enable" : "disable"); 661 return ret; 662 } 663 664 priv->wov_enabled = enabled; 665 } 666 667 return 0; 668 } 669 670 static int wov_set_lang_shm(struct cros_ec_codec_priv *priv, 671 uint8_t *buf, size_t size, uint8_t *digest) 672 { 673 struct ec_param_ec_codec_wov p; 674 struct ec_param_ec_codec_wov_set_lang_shm *pp = &p.set_lang_shm_param; 675 int ret; 676 677 if (size > priv->wov_lang_shm_len) { 678 dev_err(priv->dev, "no enough SHM size: %d\n", 679 priv->wov_lang_shm_len); 680 return -EIO; 681 } 682 683 switch (priv->wov_lang_shm_type) { 684 case EC_CODEC_SHM_TYPE_EC_RAM: 685 memcpy_toio((void __force __iomem *)priv->wov_lang_shm_p, 686 buf, size); 687 memset_io((void __force __iomem *)priv->wov_lang_shm_p + size, 688 0, priv->wov_lang_shm_len - size); 689 break; 690 case EC_CODEC_SHM_TYPE_SYSTEM_RAM: 691 memcpy(priv->wov_lang_shm_p, buf, size); 692 memset(priv->wov_lang_shm_p + size, 0, 693 priv->wov_lang_shm_len - size); 694 695 /* make sure write to memory before calling host command */ 696 wmb(); 697 break; 698 } 699 700 p.cmd = EC_CODEC_WOV_SET_LANG_SHM; 701 memcpy(pp->hash, digest, SHA256_DIGEST_SIZE); 702 pp->total_len = size; 703 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV, 704 (uint8_t *)&p, sizeof(p), NULL, 0); 705 if (ret) { 706 dev_err(priv->dev, "failed to EC_CODEC_WOV_SET_LANG_SHM\n"); 707 return ret; 708 } 709 710 return 0; 711 } 712 713 static int wov_set_lang(struct cros_ec_codec_priv *priv, 714 uint8_t *buf, size_t size, uint8_t *digest) 715 { 716 struct ec_param_ec_codec_wov p; 717 struct ec_param_ec_codec_wov_set_lang *pp = &p.set_lang_param; 718 size_t i, req; 719 int ret; 720 721 for (i = 0; i < size; i += req) { 722 req = min(size - i, ARRAY_SIZE(pp->buf)); 723 724 p.cmd = EC_CODEC_WOV_SET_LANG; 725 memcpy(pp->hash, digest, SHA256_DIGEST_SIZE); 726 pp->total_len = size; 727 pp->offset = i; 728 memcpy(pp->buf, buf + i, req); 729 pp->len = req; 730 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV, 731 (uint8_t *)&p, sizeof(p), NULL, 0); 732 if (ret) { 733 dev_err(priv->dev, "failed to EC_CODEC_WOV_SET_LANG\n"); 734 return ret; 735 } 736 } 737 738 return 0; 739 } 740 741 static int wov_hotword_model_put(struct snd_kcontrol *kcontrol, 742 const unsigned int __user *bytes, 743 unsigned int size) 744 { 745 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 746 struct cros_ec_codec_priv *priv = 747 snd_soc_component_get_drvdata(component); 748 struct ec_param_ec_codec_wov p; 749 struct ec_response_ec_codec_wov_get_lang r; 750 uint8_t digest[SHA256_DIGEST_SIZE]; 751 uint8_t *buf; 752 int ret; 753 754 /* Skips the TLV header. */ 755 bytes += 2; 756 size -= 8; 757 758 dev_dbg(priv->dev, "%s: size=%d\n", __func__, size); 759 760 buf = memdup_user(bytes, size); 761 if (IS_ERR(buf)) 762 return PTR_ERR(buf); 763 764 sha256(buf, size, digest); 765 dev_dbg(priv->dev, "hash=%*phN\n", SHA256_DIGEST_SIZE, digest); 766 767 p.cmd = EC_CODEC_WOV_GET_LANG; 768 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV, 769 (uint8_t *)&p, sizeof(p), 770 (uint8_t *)&r, sizeof(r)); 771 if (ret) 772 goto leave; 773 774 if (memcmp(digest, r.hash, SHA256_DIGEST_SIZE) == 0) { 775 dev_dbg(priv->dev, "not updated"); 776 goto leave; 777 } 778 779 if (ec_codec_capable(priv, EC_CODEC_CAP_WOV_LANG_SHM)) 780 ret = wov_set_lang_shm(priv, buf, size, digest); 781 else 782 ret = wov_set_lang(priv, buf, size, digest); 783 784 leave: 785 kfree(buf); 786 return ret; 787 } 788 789 static struct snd_kcontrol_new wov_controls[] = { 790 SOC_SINGLE_BOOL_EXT("Wake-on-Voice Switch", 0, 791 wov_enable_get, wov_enable_put), 792 SND_SOC_BYTES_TLV("Hotword Model", 0x11000, NULL, 793 wov_hotword_model_put), 794 }; 795 796 static struct snd_soc_dai_driver wov_dai_driver = { 797 .name = "Wake on Voice", 798 .capture = { 799 .stream_name = "WoV Capture", 800 .channels_min = 1, 801 .channels_max = 1, 802 .rates = SNDRV_PCM_RATE_16000, 803 .formats = SNDRV_PCM_FMTBIT_S16_LE, 804 }, 805 }; 806 807 static int wov_host_event(struct notifier_block *nb, 808 unsigned long queued_during_suspend, void *notify) 809 { 810 struct cros_ec_codec_priv *priv = 811 container_of(nb, struct cros_ec_codec_priv, wov_notifier); 812 u32 host_event; 813 814 dev_dbg(priv->dev, "%s\n", __func__); 815 816 host_event = cros_ec_get_host_event(priv->ec_device); 817 if (host_event & EC_HOST_EVENT_MASK(EC_HOST_EVENT_WOV)) { 818 schedule_delayed_work(&priv->wov_copy_work, 0); 819 return NOTIFY_OK; 820 } else { 821 return NOTIFY_DONE; 822 } 823 } 824 825 static int wov_probe(struct snd_soc_component *component) 826 { 827 struct cros_ec_codec_priv *priv = 828 snd_soc_component_get_drvdata(component); 829 int ret; 830 831 mutex_init(&priv->wov_dma_lock); 832 INIT_DELAYED_WORK(&priv->wov_copy_work, wov_copy_work); 833 834 priv->wov_notifier.notifier_call = wov_host_event; 835 ret = blocking_notifier_chain_register( 836 &priv->ec_device->event_notifier, &priv->wov_notifier); 837 if (ret) 838 return ret; 839 840 if (ec_codec_capable(priv, EC_CODEC_CAP_WOV_LANG_SHM)) { 841 priv->wov_lang_shm_p = wov_map_shm(priv, 842 EC_CODEC_SHM_ID_WOV_LANG, 843 &priv->wov_lang_shm_len, 844 &priv->wov_lang_shm_type); 845 if (!priv->wov_lang_shm_p) 846 return -EFAULT; 847 } 848 849 if (ec_codec_capable(priv, EC_CODEC_CAP_WOV_AUDIO_SHM)) { 850 priv->wov_audio_shm_p = wov_map_shm(priv, 851 EC_CODEC_SHM_ID_WOV_AUDIO, 852 &priv->wov_audio_shm_len, 853 &priv->wov_audio_shm_type); 854 if (!priv->wov_audio_shm_p) 855 return -EFAULT; 856 } 857 858 return dmic_probe(component); 859 } 860 861 static void wov_remove(struct snd_soc_component *component) 862 { 863 struct cros_ec_codec_priv *priv = 864 snd_soc_component_get_drvdata(component); 865 866 blocking_notifier_chain_unregister( 867 &priv->ec_device->event_notifier, &priv->wov_notifier); 868 } 869 870 static int wov_pcm_open(struct snd_soc_component *component, 871 struct snd_pcm_substream *substream) 872 { 873 static const struct snd_pcm_hardware hw_param = { 874 .info = SNDRV_PCM_INFO_MMAP | 875 SNDRV_PCM_INFO_INTERLEAVED | 876 SNDRV_PCM_INFO_MMAP_VALID, 877 .formats = SNDRV_PCM_FMTBIT_S16_LE, 878 .rates = SNDRV_PCM_RATE_16000, 879 .channels_min = 1, 880 .channels_max = 1, 881 .period_bytes_min = PAGE_SIZE, 882 .period_bytes_max = 0x20000 / 8, 883 .periods_min = 8, 884 .periods_max = 8, 885 .buffer_bytes_max = 0x20000, 886 }; 887 888 return snd_soc_set_runtime_hwparams(substream, &hw_param); 889 } 890 891 static int wov_pcm_hw_params(struct snd_soc_component *component, 892 struct snd_pcm_substream *substream, 893 struct snd_pcm_hw_params *hw_params) 894 { 895 struct cros_ec_codec_priv *priv = 896 snd_soc_component_get_drvdata(component); 897 898 mutex_lock(&priv->wov_dma_lock); 899 priv->wov_substream = substream; 900 priv->wov_rp = priv->wov_wp = 0; 901 priv->wov_dma_offset = 0; 902 priv->wov_burst_read = true; 903 mutex_unlock(&priv->wov_dma_lock); 904 905 return 0; 906 } 907 908 static int wov_pcm_hw_free(struct snd_soc_component *component, 909 struct snd_pcm_substream *substream) 910 { 911 struct cros_ec_codec_priv *priv = 912 snd_soc_component_get_drvdata(component); 913 914 mutex_lock(&priv->wov_dma_lock); 915 wov_queue_dequeue(priv, wov_queue_size(priv)); 916 priv->wov_substream = NULL; 917 mutex_unlock(&priv->wov_dma_lock); 918 919 cancel_delayed_work_sync(&priv->wov_copy_work); 920 921 return 0; 922 } 923 924 static snd_pcm_uframes_t wov_pcm_pointer(struct snd_soc_component *component, 925 struct snd_pcm_substream *substream) 926 { 927 struct snd_pcm_runtime *runtime = substream->runtime; 928 struct cros_ec_codec_priv *priv = 929 snd_soc_component_get_drvdata(component); 930 931 return bytes_to_frames(runtime, priv->wov_dma_offset); 932 } 933 934 static int wov_pcm_new(struct snd_soc_component *component, 935 struct snd_soc_pcm_runtime *rtd) 936 { 937 snd_pcm_set_managed_buffer_all(rtd->pcm, SNDRV_DMA_TYPE_VMALLOC, 938 NULL, 0, 0); 939 return 0; 940 } 941 942 static const struct snd_soc_component_driver wov_component_driver = { 943 .probe = wov_probe, 944 .remove = wov_remove, 945 .controls = wov_controls, 946 .num_controls = ARRAY_SIZE(wov_controls), 947 .open = wov_pcm_open, 948 .hw_params = wov_pcm_hw_params, 949 .hw_free = wov_pcm_hw_free, 950 .pointer = wov_pcm_pointer, 951 .pcm_construct = wov_pcm_new, 952 }; 953 954 static int cros_ec_codec_platform_probe(struct platform_device *pdev) 955 { 956 struct device *dev = &pdev->dev; 957 struct cros_ec_device *ec_device = dev_get_drvdata(pdev->dev.parent); 958 struct cros_ec_codec_priv *priv; 959 struct ec_param_ec_codec p; 960 struct ec_response_ec_codec_get_capabilities r; 961 int ret; 962 #ifdef CONFIG_OF 963 struct device_node *node; 964 struct resource res; 965 u64 ec_shm_size; 966 const __be32 *regaddr_p; 967 #endif 968 969 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 970 if (!priv) 971 return -ENOMEM; 972 973 #ifdef CONFIG_OF 974 regaddr_p = of_get_address(dev->of_node, 0, &ec_shm_size, NULL); 975 if (regaddr_p) { 976 priv->ec_shm_addr = of_read_number(regaddr_p, 2); 977 priv->ec_shm_len = ec_shm_size; 978 979 dev_dbg(dev, "ec_shm_addr=%#llx len=%#x\n", 980 priv->ec_shm_addr, priv->ec_shm_len); 981 } 982 983 node = of_parse_phandle(dev->of_node, "memory-region", 0); 984 if (node) { 985 ret = of_address_to_resource(node, 0, &res); 986 if (!ret) { 987 priv->ap_shm_phys_addr = res.start; 988 priv->ap_shm_len = resource_size(&res); 989 priv->ap_shm_addr = 990 (uint64_t)(uintptr_t)devm_ioremap_wc( 991 dev, priv->ap_shm_phys_addr, 992 priv->ap_shm_len); 993 priv->ap_shm_last_alloc = priv->ap_shm_phys_addr; 994 995 dev_dbg(dev, "ap_shm_phys_addr=%#llx len=%#x\n", 996 priv->ap_shm_phys_addr, priv->ap_shm_len); 997 } 998 } 999 #endif 1000 1001 priv->dev = dev; 1002 priv->ec_device = ec_device; 1003 atomic_set(&priv->dmic_probed, 0); 1004 1005 p.cmd = EC_CODEC_GET_CAPABILITIES; 1006 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC, 1007 (uint8_t *)&p, sizeof(p), 1008 (uint8_t *)&r, sizeof(r)); 1009 if (ret) { 1010 dev_err(dev, "failed to EC_CODEC_GET_CAPABILITIES\n"); 1011 return ret; 1012 } 1013 priv->ec_capabilities = r.capabilities; 1014 1015 /* Reset EC codec i2s rx. */ 1016 p.cmd = EC_CODEC_I2S_RX_RESET; 1017 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_I2S_RX, 1018 (uint8_t *)&p, sizeof(p), NULL, 0); 1019 if (ret == -ENOPROTOOPT) { 1020 dev_info(dev, 1021 "Missing reset command. Please update EC firmware.\n"); 1022 } else if (ret) { 1023 dev_err(dev, "failed to EC_CODEC_I2S_RESET: %d\n", ret); 1024 return ret; 1025 } 1026 1027 platform_set_drvdata(pdev, priv); 1028 1029 ret = devm_snd_soc_register_component(dev, &i2s_rx_component_driver, 1030 &i2s_rx_dai_driver, 1); 1031 if (ret) 1032 return ret; 1033 1034 return devm_snd_soc_register_component(dev, &wov_component_driver, 1035 &wov_dai_driver, 1); 1036 } 1037 1038 #ifdef CONFIG_OF 1039 static const struct of_device_id cros_ec_codec_of_match[] = { 1040 { .compatible = "google,cros-ec-codec" }, 1041 {}, 1042 }; 1043 MODULE_DEVICE_TABLE(of, cros_ec_codec_of_match); 1044 #endif 1045 1046 #ifdef CONFIG_ACPI 1047 static const struct acpi_device_id cros_ec_codec_acpi_id[] = { 1048 { "GOOG0013", 0 }, 1049 { } 1050 }; 1051 MODULE_DEVICE_TABLE(acpi, cros_ec_codec_acpi_id); 1052 #endif 1053 1054 static struct platform_driver cros_ec_codec_platform_driver = { 1055 .driver = { 1056 .name = "cros-ec-codec", 1057 .of_match_table = of_match_ptr(cros_ec_codec_of_match), 1058 .acpi_match_table = ACPI_PTR(cros_ec_codec_acpi_id), 1059 }, 1060 .probe = cros_ec_codec_platform_probe, 1061 }; 1062 1063 module_platform_driver(cros_ec_codec_platform_driver); 1064 1065 MODULE_LICENSE("GPL v2"); 1066 MODULE_DESCRIPTION("ChromeOS EC codec driver"); 1067 MODULE_AUTHOR("Cheng-Yi Chiang <cychiang@chromium.org>"); 1068 MODULE_ALIAS("platform:cros-ec-codec"); 1069