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/cleanup.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/of_reserved_mem.h> 23 #include <linux/platform_data/cros_ec_commands.h> 24 #include <linux/platform_data/cros_ec_proto.h> 25 #include <linux/platform_device.h> 26 #include <linux/string_choices.h> 27 #include <sound/pcm.h> 28 #include <sound/pcm_params.h> 29 #include <sound/soc.h> 30 #include <sound/tlv.h> 31 32 struct cros_ec_codec_priv { 33 struct device *dev; 34 struct cros_ec_device *ec_device; 35 36 /* common */ 37 uint32_t ec_capabilities; 38 39 uint64_t ec_shm_addr; 40 uint32_t ec_shm_len; 41 42 uint64_t ap_shm_phys_addr; 43 uint32_t ap_shm_len; 44 uint64_t ap_shm_addr; 45 uint64_t ap_shm_last_alloc; 46 47 /* DMIC */ 48 atomic_t dmic_probed; 49 50 /* I2S_RX */ 51 uint32_t i2s_rx_bclk_ratio; 52 53 /* WoV */ 54 bool wov_enabled; 55 uint8_t *wov_audio_shm_p; 56 uint32_t wov_audio_shm_len; 57 uint8_t wov_audio_shm_type; 58 uint8_t *wov_lang_shm_p; 59 uint32_t wov_lang_shm_len; 60 uint8_t wov_lang_shm_type; 61 62 struct mutex wov_dma_lock; 63 uint8_t wov_buf[64000]; 64 uint32_t wov_rp, wov_wp; 65 size_t wov_dma_offset; 66 bool wov_burst_read; 67 struct snd_pcm_substream *wov_substream; 68 struct delayed_work wov_copy_work; 69 struct notifier_block wov_notifier; 70 }; 71 72 static int ec_codec_capable(struct cros_ec_codec_priv *priv, uint8_t cap) 73 { 74 return priv->ec_capabilities & BIT(cap); 75 } 76 77 static int send_ec_host_command(struct cros_ec_device *ec_dev, uint32_t cmd, 78 uint8_t *out, size_t outsize, 79 uint8_t *in, size_t insize) 80 { 81 int ret; 82 struct cros_ec_command *msg; 83 84 msg = kmalloc(sizeof(*msg) + max(outsize, insize), GFP_KERNEL); 85 if (!msg) 86 return -ENOMEM; 87 88 msg->version = 0; 89 msg->command = cmd; 90 msg->outsize = outsize; 91 msg->insize = insize; 92 93 if (outsize) 94 memcpy(msg->data, out, outsize); 95 96 ret = cros_ec_cmd_xfer_status(ec_dev, msg); 97 if (ret < 0) 98 goto error; 99 100 if (in && insize) 101 memcpy(in, msg->data, insize); 102 103 ret = 0; 104 error: 105 kfree(msg); 106 return ret; 107 } 108 109 static int dmic_get_gain(struct snd_kcontrol *kcontrol, 110 struct snd_ctl_elem_value *ucontrol) 111 { 112 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 113 struct cros_ec_codec_priv *priv = 114 snd_soc_component_get_drvdata(component); 115 struct ec_param_ec_codec_dmic p; 116 struct ec_response_ec_codec_dmic_get_gain_idx r; 117 int ret; 118 119 p.cmd = EC_CODEC_DMIC_GET_GAIN_IDX; 120 p.get_gain_idx_param.channel = EC_CODEC_DMIC_CHANNEL_0; 121 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_DMIC, 122 (uint8_t *)&p, sizeof(p), 123 (uint8_t *)&r, sizeof(r)); 124 if (ret < 0) 125 return ret; 126 ucontrol->value.integer.value[0] = r.gain; 127 128 p.cmd = EC_CODEC_DMIC_GET_GAIN_IDX; 129 p.get_gain_idx_param.channel = EC_CODEC_DMIC_CHANNEL_1; 130 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_DMIC, 131 (uint8_t *)&p, sizeof(p), 132 (uint8_t *)&r, sizeof(r)); 133 if (ret < 0) 134 return ret; 135 ucontrol->value.integer.value[1] = r.gain; 136 137 return 0; 138 } 139 140 static int dmic_put_gain(struct snd_kcontrol *kcontrol, 141 struct snd_ctl_elem_value *ucontrol) 142 { 143 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 144 struct cros_ec_codec_priv *priv = 145 snd_soc_component_get_drvdata(component); 146 struct soc_mixer_control *control = 147 (struct soc_mixer_control *)kcontrol->private_value; 148 int max_dmic_gain = control->max; 149 int left = ucontrol->value.integer.value[0]; 150 int right = ucontrol->value.integer.value[1]; 151 struct ec_param_ec_codec_dmic p; 152 int ret; 153 154 if (left > max_dmic_gain || right > max_dmic_gain) 155 return -EINVAL; 156 157 dev_dbg(component->dev, "set mic gain to %u, %u\n", left, right); 158 159 p.cmd = EC_CODEC_DMIC_SET_GAIN_IDX; 160 p.set_gain_idx_param.channel = EC_CODEC_DMIC_CHANNEL_0; 161 p.set_gain_idx_param.gain = left; 162 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_DMIC, 163 (uint8_t *)&p, sizeof(p), NULL, 0); 164 if (ret < 0) 165 return ret; 166 167 p.cmd = EC_CODEC_DMIC_SET_GAIN_IDX; 168 p.set_gain_idx_param.channel = EC_CODEC_DMIC_CHANNEL_1; 169 p.set_gain_idx_param.gain = right; 170 return send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_DMIC, 171 (uint8_t *)&p, sizeof(p), NULL, 0); 172 } 173 174 static const DECLARE_TLV_DB_SCALE(dmic_gain_tlv, 0, 100, 0); 175 176 enum { 177 DMIC_CTL_GAIN = 0, 178 }; 179 180 static struct snd_kcontrol_new dmic_controls[] = { 181 [DMIC_CTL_GAIN] = 182 SOC_DOUBLE_EXT_TLV("EC Mic Gain", SND_SOC_NOPM, SND_SOC_NOPM, 183 0, 0, 0, dmic_get_gain, dmic_put_gain, 184 dmic_gain_tlv), 185 }; 186 187 static int dmic_probe(struct snd_soc_component *component) 188 { 189 struct cros_ec_codec_priv *priv = 190 snd_soc_component_get_drvdata(component); 191 struct device *dev = priv->dev; 192 struct soc_mixer_control *control; 193 struct ec_param_ec_codec_dmic p; 194 struct ec_response_ec_codec_dmic_get_max_gain r; 195 int ret; 196 197 if (!atomic_add_unless(&priv->dmic_probed, 1, 1)) 198 return 0; 199 200 p.cmd = EC_CODEC_DMIC_GET_MAX_GAIN; 201 202 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_DMIC, 203 (uint8_t *)&p, sizeof(p), 204 (uint8_t *)&r, sizeof(r)); 205 if (ret < 0) { 206 dev_warn(dev, "get_max_gain() unsupported\n"); 207 return 0; 208 } 209 210 dev_dbg(dev, "max gain = %d\n", r.max_gain); 211 212 control = (struct soc_mixer_control *) 213 dmic_controls[DMIC_CTL_GAIN].private_value; 214 control->max = r.max_gain; 215 control->platform_max = r.max_gain; 216 217 return snd_soc_add_component_controls(component, 218 &dmic_controls[DMIC_CTL_GAIN], 1); 219 } 220 221 static int i2s_rx_hw_params(struct snd_pcm_substream *substream, 222 struct snd_pcm_hw_params *params, 223 struct snd_soc_dai *dai) 224 { 225 struct snd_soc_component *component = dai->component; 226 struct cros_ec_codec_priv *priv = 227 snd_soc_component_get_drvdata(component); 228 struct ec_param_ec_codec_i2s_rx p; 229 enum ec_codec_i2s_rx_sample_depth depth; 230 uint32_t bclk; 231 int ret; 232 233 if (params_rate(params) != 48000) 234 return -EINVAL; 235 236 switch (params_width(params)) { 237 case 16: 238 depth = EC_CODEC_I2S_RX_SAMPLE_DEPTH_16; 239 break; 240 case 24: 241 depth = EC_CODEC_I2S_RX_SAMPLE_DEPTH_24; 242 break; 243 default: 244 return -EINVAL; 245 } 246 247 dev_dbg(component->dev, "set depth to %u\n", depth); 248 249 p.cmd = EC_CODEC_I2S_RX_SET_SAMPLE_DEPTH; 250 p.set_sample_depth_param.depth = depth; 251 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_I2S_RX, 252 (uint8_t *)&p, sizeof(p), NULL, 0); 253 if (ret < 0) 254 return ret; 255 256 if (priv->i2s_rx_bclk_ratio) 257 bclk = params_rate(params) * priv->i2s_rx_bclk_ratio; 258 else 259 bclk = snd_soc_params_to_bclk(params); 260 261 dev_dbg(component->dev, "set bclk to %u\n", bclk); 262 263 p.cmd = EC_CODEC_I2S_RX_SET_BCLK; 264 p.set_bclk_param.bclk = bclk; 265 return send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_I2S_RX, 266 (uint8_t *)&p, sizeof(p), NULL, 0); 267 } 268 269 static int i2s_rx_set_bclk_ratio(struct snd_soc_dai *dai, unsigned int ratio) 270 { 271 struct snd_soc_component *component = dai->component; 272 struct cros_ec_codec_priv *priv = 273 snd_soc_component_get_drvdata(component); 274 275 priv->i2s_rx_bclk_ratio = ratio; 276 return 0; 277 } 278 279 static int i2s_rx_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) 280 { 281 struct snd_soc_component *component = dai->component; 282 struct cros_ec_codec_priv *priv = 283 snd_soc_component_get_drvdata(component); 284 struct ec_param_ec_codec_i2s_rx p; 285 enum ec_codec_i2s_rx_daifmt daifmt; 286 287 switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) { 288 case SND_SOC_DAIFMT_CBC_CFC: 289 break; 290 default: 291 return -EINVAL; 292 } 293 294 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 295 case SND_SOC_DAIFMT_NB_NF: 296 break; 297 default: 298 return -EINVAL; 299 } 300 301 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 302 case SND_SOC_DAIFMT_I2S: 303 daifmt = EC_CODEC_I2S_RX_DAIFMT_I2S; 304 break; 305 case SND_SOC_DAIFMT_RIGHT_J: 306 daifmt = EC_CODEC_I2S_RX_DAIFMT_RIGHT_J; 307 break; 308 case SND_SOC_DAIFMT_LEFT_J: 309 daifmt = EC_CODEC_I2S_RX_DAIFMT_LEFT_J; 310 break; 311 default: 312 return -EINVAL; 313 } 314 315 dev_dbg(component->dev, "set format to %u\n", daifmt); 316 317 p.cmd = EC_CODEC_I2S_RX_SET_DAIFMT; 318 p.set_daifmt_param.daifmt = daifmt; 319 return send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_I2S_RX, 320 (uint8_t *)&p, sizeof(p), NULL, 0); 321 } 322 323 static const struct snd_soc_dai_ops i2s_rx_dai_ops = { 324 .hw_params = i2s_rx_hw_params, 325 .set_fmt = i2s_rx_set_fmt, 326 .set_bclk_ratio = i2s_rx_set_bclk_ratio, 327 }; 328 329 static int i2s_rx_event(struct snd_soc_dapm_widget *w, 330 struct snd_kcontrol *kcontrol, int event) 331 { 332 struct snd_soc_component *component = 333 snd_soc_dapm_to_component(w->dapm); 334 struct cros_ec_codec_priv *priv = 335 snd_soc_component_get_drvdata(component); 336 struct ec_param_ec_codec_i2s_rx p = {}; 337 338 switch (event) { 339 case SND_SOC_DAPM_PRE_PMU: 340 dev_dbg(component->dev, "enable I2S RX\n"); 341 p.cmd = EC_CODEC_I2S_RX_ENABLE; 342 break; 343 case SND_SOC_DAPM_PRE_PMD: 344 dev_dbg(component->dev, "disable I2S RX\n"); 345 p.cmd = EC_CODEC_I2S_RX_DISABLE; 346 break; 347 default: 348 return 0; 349 } 350 351 return send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_I2S_RX, 352 (uint8_t *)&p, sizeof(p), NULL, 0); 353 } 354 355 static struct snd_soc_dapm_widget i2s_rx_dapm_widgets[] = { 356 SND_SOC_DAPM_INPUT("DMIC"), 357 SND_SOC_DAPM_SUPPLY("I2S RX Enable", SND_SOC_NOPM, 0, 0, i2s_rx_event, 358 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_PRE_PMD), 359 SND_SOC_DAPM_AIF_OUT("I2S RX", "I2S Capture", 0, SND_SOC_NOPM, 0, 0), 360 }; 361 362 static struct snd_soc_dapm_route i2s_rx_dapm_routes[] = { 363 {"I2S RX", NULL, "DMIC"}, 364 {"I2S RX", NULL, "I2S RX Enable"}, 365 }; 366 367 static struct snd_soc_dai_driver i2s_rx_dai_driver = { 368 .name = "EC Codec I2S RX", 369 .capture = { 370 .stream_name = "I2S Capture", 371 .channels_min = 2, 372 .channels_max = 2, 373 .rates = SNDRV_PCM_RATE_48000, 374 .formats = SNDRV_PCM_FMTBIT_S16_LE | 375 SNDRV_PCM_FMTBIT_S24_LE, 376 }, 377 .ops = &i2s_rx_dai_ops, 378 }; 379 380 static int i2s_rx_probe(struct snd_soc_component *component) 381 { 382 return dmic_probe(component); 383 } 384 385 static const struct snd_soc_component_driver i2s_rx_component_driver = { 386 .probe = i2s_rx_probe, 387 .dapm_widgets = i2s_rx_dapm_widgets, 388 .num_dapm_widgets = ARRAY_SIZE(i2s_rx_dapm_widgets), 389 .dapm_routes = i2s_rx_dapm_routes, 390 .num_dapm_routes = ARRAY_SIZE(i2s_rx_dapm_routes), 391 .endianness = 1, 392 }; 393 394 static void *wov_map_shm(struct cros_ec_codec_priv *priv, 395 uint8_t shm_id, uint32_t *len, uint8_t *type) 396 { 397 struct ec_param_ec_codec p; 398 struct ec_response_ec_codec_get_shm_addr r; 399 uint32_t req, offset; 400 401 p.cmd = EC_CODEC_GET_SHM_ADDR; 402 p.get_shm_addr_param.shm_id = shm_id; 403 if (send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC, 404 (uint8_t *)&p, sizeof(p), 405 (uint8_t *)&r, sizeof(r)) < 0) { 406 dev_err(priv->dev, "failed to EC_CODEC_GET_SHM_ADDR\n"); 407 return NULL; 408 } 409 410 dev_dbg(priv->dev, "phys_addr=%#llx, len=%#x\n", r.phys_addr, r.len); 411 412 *len = r.len; 413 *type = r.type; 414 415 switch (r.type) { 416 case EC_CODEC_SHM_TYPE_EC_RAM: 417 return (void __force *)devm_ioremap_wc(priv->dev, 418 r.phys_addr + priv->ec_shm_addr, r.len); 419 case EC_CODEC_SHM_TYPE_SYSTEM_RAM: 420 if (r.phys_addr) { 421 dev_err(priv->dev, "unknown status\n"); 422 return NULL; 423 } 424 425 req = round_up(r.len, PAGE_SIZE); 426 dev_dbg(priv->dev, "round up from %u to %u\n", r.len, req); 427 428 if (priv->ap_shm_last_alloc + req > 429 priv->ap_shm_phys_addr + priv->ap_shm_len) { 430 dev_err(priv->dev, "insufficient space for AP SHM\n"); 431 return NULL; 432 } 433 434 dev_dbg(priv->dev, "alloc AP SHM addr=%#llx, len=%#x\n", 435 priv->ap_shm_last_alloc, req); 436 437 p.cmd = EC_CODEC_SET_SHM_ADDR; 438 p.set_shm_addr_param.phys_addr = priv->ap_shm_last_alloc; 439 p.set_shm_addr_param.len = req; 440 p.set_shm_addr_param.shm_id = shm_id; 441 if (send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC, 442 (uint8_t *)&p, sizeof(p), 443 NULL, 0) < 0) { 444 dev_err(priv->dev, "failed to EC_CODEC_SET_SHM_ADDR\n"); 445 return NULL; 446 } 447 448 /* 449 * Note: EC codec only requests for `r.len' but we allocate 450 * round up PAGE_SIZE `req'. 451 */ 452 offset = priv->ap_shm_last_alloc - priv->ap_shm_phys_addr; 453 priv->ap_shm_last_alloc += req; 454 455 return (void *)(uintptr_t)(priv->ap_shm_addr + offset); 456 default: 457 return NULL; 458 } 459 } 460 461 static bool wov_queue_full(struct cros_ec_codec_priv *priv) 462 { 463 return ((priv->wov_wp + 1) % sizeof(priv->wov_buf)) == priv->wov_rp; 464 } 465 466 static size_t wov_queue_size(struct cros_ec_codec_priv *priv) 467 { 468 if (priv->wov_wp >= priv->wov_rp) 469 return priv->wov_wp - priv->wov_rp; 470 else 471 return sizeof(priv->wov_buf) - priv->wov_rp + priv->wov_wp; 472 } 473 474 static void wov_queue_dequeue(struct cros_ec_codec_priv *priv, size_t len) 475 { 476 struct snd_pcm_runtime *runtime = priv->wov_substream->runtime; 477 size_t req; 478 479 while (len) { 480 req = min(len, runtime->dma_bytes - priv->wov_dma_offset); 481 if (priv->wov_wp >= priv->wov_rp) 482 req = min(req, (size_t)priv->wov_wp - priv->wov_rp); 483 else 484 req = min(req, sizeof(priv->wov_buf) - priv->wov_rp); 485 486 memcpy(runtime->dma_area + priv->wov_dma_offset, 487 priv->wov_buf + priv->wov_rp, req); 488 489 priv->wov_dma_offset += req; 490 if (priv->wov_dma_offset == runtime->dma_bytes) 491 priv->wov_dma_offset = 0; 492 493 priv->wov_rp += req; 494 if (priv->wov_rp == sizeof(priv->wov_buf)) 495 priv->wov_rp = 0; 496 497 len -= req; 498 } 499 500 snd_pcm_period_elapsed(priv->wov_substream); 501 } 502 503 static void wov_queue_try_dequeue(struct cros_ec_codec_priv *priv) 504 { 505 size_t period_bytes = snd_pcm_lib_period_bytes(priv->wov_substream); 506 507 while (period_bytes && wov_queue_size(priv) >= period_bytes) { 508 wov_queue_dequeue(priv, period_bytes); 509 period_bytes = snd_pcm_lib_period_bytes(priv->wov_substream); 510 } 511 } 512 513 static void wov_queue_enqueue(struct cros_ec_codec_priv *priv, 514 uint8_t *addr, size_t len, bool iomem) 515 { 516 size_t req; 517 518 while (len) { 519 if (wov_queue_full(priv)) { 520 wov_queue_try_dequeue(priv); 521 522 if (wov_queue_full(priv)) { 523 dev_err(priv->dev, "overrun detected\n"); 524 return; 525 } 526 } 527 528 if (priv->wov_wp >= priv->wov_rp) 529 req = sizeof(priv->wov_buf) - priv->wov_wp; 530 else 531 /* Note: waste 1-byte to differentiate full and empty */ 532 req = priv->wov_rp - priv->wov_wp - 1; 533 req = min(req, len); 534 535 if (iomem) 536 memcpy_fromio(priv->wov_buf + priv->wov_wp, 537 (void __force __iomem *)addr, req); 538 else 539 memcpy(priv->wov_buf + priv->wov_wp, addr, req); 540 541 priv->wov_wp += req; 542 if (priv->wov_wp == sizeof(priv->wov_buf)) 543 priv->wov_wp = 0; 544 545 addr += req; 546 len -= req; 547 } 548 549 wov_queue_try_dequeue(priv); 550 } 551 552 static int wov_read_audio_shm(struct cros_ec_codec_priv *priv) 553 { 554 struct ec_param_ec_codec_wov p; 555 struct ec_response_ec_codec_wov_read_audio_shm r; 556 int ret; 557 558 p.cmd = EC_CODEC_WOV_READ_AUDIO_SHM; 559 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV, 560 (uint8_t *)&p, sizeof(p), 561 (uint8_t *)&r, sizeof(r)); 562 if (ret) { 563 dev_err(priv->dev, "failed to EC_CODEC_WOV_READ_AUDIO_SHM\n"); 564 return ret; 565 } 566 567 if (!r.len) 568 dev_dbg(priv->dev, "no data, sleep\n"); 569 else 570 wov_queue_enqueue(priv, priv->wov_audio_shm_p + r.offset, r.len, 571 priv->wov_audio_shm_type == EC_CODEC_SHM_TYPE_EC_RAM); 572 return -EAGAIN; 573 } 574 575 static int wov_read_audio(struct cros_ec_codec_priv *priv) 576 { 577 struct ec_param_ec_codec_wov p; 578 struct ec_response_ec_codec_wov_read_audio r; 579 int remain = priv->wov_burst_read ? 16000 : 320; 580 int ret; 581 582 while (remain >= 0) { 583 p.cmd = EC_CODEC_WOV_READ_AUDIO; 584 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV, 585 (uint8_t *)&p, sizeof(p), 586 (uint8_t *)&r, sizeof(r)); 587 if (ret) { 588 dev_err(priv->dev, 589 "failed to EC_CODEC_WOV_READ_AUDIO\n"); 590 return ret; 591 } 592 593 if (!r.len) { 594 dev_dbg(priv->dev, "no data, sleep\n"); 595 priv->wov_burst_read = false; 596 break; 597 } 598 599 wov_queue_enqueue(priv, r.buf, r.len, false); 600 remain -= r.len; 601 } 602 603 return -EAGAIN; 604 } 605 606 static void wov_copy_work(struct work_struct *w) 607 { 608 struct cros_ec_codec_priv *priv = 609 container_of(w, struct cros_ec_codec_priv, wov_copy_work.work); 610 int ret; 611 612 guard(mutex)(&priv->wov_dma_lock); 613 if (!priv->wov_substream) { 614 dev_warn(priv->dev, "no pcm substream\n"); 615 return; 616 } 617 618 if (ec_codec_capable(priv, EC_CODEC_CAP_WOV_AUDIO_SHM)) 619 ret = wov_read_audio_shm(priv); 620 else 621 ret = wov_read_audio(priv); 622 623 if (ret == -EAGAIN) 624 schedule_delayed_work(&priv->wov_copy_work, 625 msecs_to_jiffies(10)); 626 else if (ret) 627 dev_err(priv->dev, "failed to read audio data\n"); 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_kcontrol_chip(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_kcontrol_chip(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 str_enable_disable(enabled)); 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 guard(mutex)(&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 903 return 0; 904 } 905 906 static int wov_pcm_hw_free(struct snd_soc_component *component, 907 struct snd_pcm_substream *substream) 908 { 909 struct cros_ec_codec_priv *priv = 910 snd_soc_component_get_drvdata(component); 911 912 scoped_guard(mutex, &priv->wov_dma_lock) { 913 wov_queue_dequeue(priv, wov_queue_size(priv)); 914 priv->wov_substream = NULL; 915 } 916 917 cancel_delayed_work_sync(&priv->wov_copy_work); 918 919 return 0; 920 } 921 922 static snd_pcm_uframes_t wov_pcm_pointer(struct snd_soc_component *component, 923 struct snd_pcm_substream *substream) 924 { 925 struct snd_pcm_runtime *runtime = substream->runtime; 926 struct cros_ec_codec_priv *priv = 927 snd_soc_component_get_drvdata(component); 928 929 return bytes_to_frames(runtime, priv->wov_dma_offset); 930 } 931 932 static int wov_pcm_new(struct snd_soc_component *component, 933 struct snd_soc_pcm_runtime *rtd) 934 { 935 snd_pcm_set_managed_buffer_all(rtd->pcm, SNDRV_DMA_TYPE_VMALLOC, 936 NULL, 0, 0); 937 return 0; 938 } 939 940 static const struct snd_soc_component_driver wov_component_driver = { 941 .probe = wov_probe, 942 .remove = wov_remove, 943 .controls = wov_controls, 944 .num_controls = ARRAY_SIZE(wov_controls), 945 .open = wov_pcm_open, 946 .hw_params = wov_pcm_hw_params, 947 .hw_free = wov_pcm_hw_free, 948 .pointer = wov_pcm_pointer, 949 .pcm_new = wov_pcm_new, 950 }; 951 952 static int cros_ec_codec_platform_probe(struct platform_device *pdev) 953 { 954 struct device *dev = &pdev->dev; 955 struct cros_ec_device *ec_device = dev_get_drvdata(pdev->dev.parent); 956 struct cros_ec_codec_priv *priv; 957 struct ec_param_ec_codec p; 958 struct ec_response_ec_codec_get_capabilities r; 959 int ret; 960 #ifdef CONFIG_OF 961 struct resource res; 962 u64 ec_shm_size; 963 const __be32 *regaddr_p; 964 #endif 965 966 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 967 if (!priv) 968 return -ENOMEM; 969 970 #ifdef CONFIG_OF 971 regaddr_p = of_get_address(dev->of_node, 0, &ec_shm_size, NULL); 972 if (regaddr_p) { 973 priv->ec_shm_addr = of_read_number(regaddr_p, 2); 974 priv->ec_shm_len = ec_shm_size; 975 976 dev_dbg(dev, "ec_shm_addr=%#llx len=%#x\n", 977 priv->ec_shm_addr, priv->ec_shm_len); 978 } 979 980 ret = of_reserved_mem_region_to_resource(dev->of_node, 0, &res); 981 if (!ret) { 982 priv->ap_shm_phys_addr = res.start; 983 priv->ap_shm_len = resource_size(&res); 984 priv->ap_shm_addr = 985 (uint64_t)(uintptr_t)devm_ioremap_wc( 986 dev, priv->ap_shm_phys_addr, 987 priv->ap_shm_len); 988 priv->ap_shm_last_alloc = priv->ap_shm_phys_addr; 989 990 dev_dbg(dev, "ap_shm_phys_addr=%#llx len=%#x\n", 991 priv->ap_shm_phys_addr, priv->ap_shm_len); 992 } 993 #endif 994 995 priv->dev = dev; 996 priv->ec_device = ec_device; 997 atomic_set(&priv->dmic_probed, 0); 998 999 p.cmd = EC_CODEC_GET_CAPABILITIES; 1000 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC, 1001 (uint8_t *)&p, sizeof(p), 1002 (uint8_t *)&r, sizeof(r)); 1003 if (ret) { 1004 dev_err(dev, "failed to EC_CODEC_GET_CAPABILITIES\n"); 1005 return ret; 1006 } 1007 priv->ec_capabilities = r.capabilities; 1008 1009 /* Reset EC codec i2s rx. */ 1010 p.cmd = EC_CODEC_I2S_RX_RESET; 1011 ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_I2S_RX, 1012 (uint8_t *)&p, sizeof(p), NULL, 0); 1013 if (ret == -ENOPROTOOPT) { 1014 dev_info(dev, 1015 "Missing reset command. Please update EC firmware.\n"); 1016 } else if (ret) { 1017 dev_err(dev, "failed to EC_CODEC_I2S_RESET: %d\n", ret); 1018 return ret; 1019 } 1020 1021 platform_set_drvdata(pdev, priv); 1022 1023 ret = devm_snd_soc_register_component(dev, &i2s_rx_component_driver, 1024 &i2s_rx_dai_driver, 1); 1025 if (ret) 1026 return ret; 1027 1028 return devm_snd_soc_register_component(dev, &wov_component_driver, 1029 &wov_dai_driver, 1); 1030 } 1031 1032 #ifdef CONFIG_OF 1033 static const struct of_device_id cros_ec_codec_of_match[] = { 1034 { .compatible = "google,cros-ec-codec" }, 1035 {}, 1036 }; 1037 MODULE_DEVICE_TABLE(of, cros_ec_codec_of_match); 1038 #endif 1039 1040 #ifdef CONFIG_ACPI 1041 static const struct acpi_device_id cros_ec_codec_acpi_id[] = { 1042 { "GOOG0013", 0 }, 1043 { } 1044 }; 1045 MODULE_DEVICE_TABLE(acpi, cros_ec_codec_acpi_id); 1046 #endif 1047 1048 static struct platform_driver cros_ec_codec_platform_driver = { 1049 .driver = { 1050 .name = "cros-ec-codec", 1051 .of_match_table = of_match_ptr(cros_ec_codec_of_match), 1052 .acpi_match_table = ACPI_PTR(cros_ec_codec_acpi_id), 1053 }, 1054 .probe = cros_ec_codec_platform_probe, 1055 }; 1056 1057 module_platform_driver(cros_ec_codec_platform_driver); 1058 1059 MODULE_LICENSE("GPL v2"); 1060 MODULE_DESCRIPTION("ChromeOS EC codec driver"); 1061 MODULE_AUTHOR("Cheng-Yi Chiang <cychiang@chromium.org>"); 1062 MODULE_ALIAS("platform:cros-ec-codec"); 1063