Re: [alsa-devel] [PATCH v5 1/4] ASoC: cros_ec_codec: support WoV

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Hi,

On 19/10/19 9:02, Tzung-Bi Shih wrote:
> 1. Get EC codec's capabilities.
> 2. Get and set SHM address if any.
> 3. Transmit language model to EC codec if needed.
> 4. Start to read audio data from EC codec if receives host event.
> 
> Signed-off-by: Tzung-Bi Shih <tzungbi@xxxxxxxxxx>
> ---
>  drivers/platform/chrome/cros_ec_trace.c       |   1 +
>  .../linux/platform_data/cros_ec_commands.h    |  69 ++

For the chrome/platform side.

Acked-by: Enric Balletbo i Serra <enric.balletbo@xxxxxxxxxxxxx>

Mark, once applied, could we get an immutable branch from you containing the
following already applied patches + this series? We need as we have patches that
could conflict on platform/chrome.

3fe5a963c631 ASoC: dt-bindings: cros_ec_codec: add SHM bindings
f3e82ad43ca5 ASoC: cros_ec_codec: read max DMIC gain from EC codec
104c6f8f7ff8 platform/chrome: cros_ec: add common commands for EC codec
8f731d4c92c2 ASoC: cros_ec_codec: extract DMIC EC command from I2S RX
727f1c71c780 ASoC: cros_ec_codec: refactor I2S RX
036beb0e85f8 platform/chrome: cros_ec: remove unused EC feature

Thanks,
 Enric.

>  sound/soc/codecs/Kconfig                      |   2 +
>  sound/soc/codecs/cros_ec_codec.c              | 700 +++++++++++++++++-
>  4 files changed, 770 insertions(+), 2 deletions(-)
> 
> diff --git a/drivers/platform/chrome/cros_ec_trace.c b/drivers/platform/chrome/cros_ec_trace.c
> index 2ea0d4e0d54d..5af1d66d9eca 100644
> --- a/drivers/platform/chrome/cros_ec_trace.c
> +++ b/drivers/platform/chrome/cros_ec_trace.c
> @@ -101,6 +101,7 @@
>  	TRACE_SYMBOL(EC_CMD_EC_CODEC), \
>  	TRACE_SYMBOL(EC_CMD_EC_CODEC_DMIC), \
>  	TRACE_SYMBOL(EC_CMD_EC_CODEC_I2S_RX), \
> +	TRACE_SYMBOL(EC_CMD_EC_CODEC_WOV), \
>  	TRACE_SYMBOL(EC_CMD_REBOOT_EC), \
>  	TRACE_SYMBOL(EC_CMD_GET_PANIC_INFO), \
>  	TRACE_SYMBOL(EC_CMD_ACPI_READ), \
> diff --git a/include/linux/platform_data/cros_ec_commands.h b/include/linux/platform_data/cros_ec_commands.h
> index 21db0d4d4025..69210881ebac 100644
> --- a/include/linux/platform_data/cros_ec_commands.h
> +++ b/include/linux/platform_data/cros_ec_commands.h
> @@ -556,6 +556,9 @@ enum host_event_code {
>  	/* Keyboard recovery combo with hardware reinitialization */
>  	EC_HOST_EVENT_KEYBOARD_RECOVERY_HW_REINIT = 30,
>  
> +	/* WoV */
> +	EC_HOST_EVENT_WOV = 31,
> +
>  	/*
>  	 * The high bit of the event mask is not used as a host event code.  If
>  	 * it reads back as set, then the entire event mask should be
> @@ -4477,10 +4480,14 @@ enum ec_codec_subcmd {
>  };
>  
>  enum ec_codec_cap {
> +	EC_CODEC_CAP_WOV_AUDIO_SHM = 0,
> +	EC_CODEC_CAP_WOV_LANG_SHM = 1,
>  	EC_CODEC_CAP_LAST = 32,
>  };
>  
>  enum ec_codec_shm_id {
> +	EC_CODEC_SHM_ID_WOV_AUDIO = 0x0,
> +	EC_CODEC_SHM_ID_WOV_LANG = 0x1,
>  	EC_CODEC_SHM_ID_LAST,
>  };
>  
> @@ -4641,6 +4648,68 @@ struct __ec_align4 ec_param_ec_codec_i2s_rx {
>  	};
>  };
>  
> +/*****************************************************************************/
> +/* Commands for WoV on audio codec. */
> +
> +#define EC_CMD_EC_CODEC_WOV 0x00BF
> +
> +enum ec_codec_wov_subcmd {
> +	EC_CODEC_WOV_SET_LANG = 0x0,
> +	EC_CODEC_WOV_SET_LANG_SHM = 0x1,
> +	EC_CODEC_WOV_GET_LANG = 0x2,
> +	EC_CODEC_WOV_ENABLE = 0x3,
> +	EC_CODEC_WOV_DISABLE = 0x4,
> +	EC_CODEC_WOV_READ_AUDIO = 0x5,
> +	EC_CODEC_WOV_READ_AUDIO_SHM = 0x6,
> +	EC_CODEC_WOV_SUBCMD_COUNT,
> +};
> +
> +/*
> + * @hash is SHA256 of the whole language model.
> + * @total_len indicates the length of whole language model.
> + * @offset is the cursor from the beginning of the model.
> + * @buf is the packet buffer.
> + * @len denotes how many bytes in the buf.
> + */
> +struct __ec_align4 ec_param_ec_codec_wov_set_lang {
> +	uint8_t hash[32];
> +	uint32_t total_len;
> +	uint32_t offset;
> +	uint8_t buf[128];
> +	uint32_t len;
> +};
> +
> +struct __ec_align4 ec_param_ec_codec_wov_set_lang_shm {
> +	uint8_t hash[32];
> +	uint32_t total_len;
> +};
> +
> +struct __ec_align4 ec_param_ec_codec_wov {
> +	uint8_t cmd; /* enum ec_codec_wov_subcmd */
> +	uint8_t reserved[3];
> +
> +	union {
> +		struct ec_param_ec_codec_wov_set_lang
> +				set_lang_param;
> +		struct ec_param_ec_codec_wov_set_lang_shm
> +				set_lang_shm_param;
> +	};
> +};
> +
> +struct __ec_align4 ec_response_ec_codec_wov_get_lang {
> +	uint8_t hash[32];
> +};
> +
> +struct __ec_align4 ec_response_ec_codec_wov_read_audio {
> +	uint8_t buf[128];
> +	uint32_t len;
> +};
> +
> +struct __ec_align4 ec_response_ec_codec_wov_read_audio_shm {
> +	uint32_t offset;
> +	uint32_t len;
> +};
> +
>  /*****************************************************************************/
>  /* System commands */
>  
> diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig
> index 5a706102db04..1a4b084cc90d 100644
> --- a/sound/soc/codecs/Kconfig
> +++ b/sound/soc/codecs/Kconfig
> @@ -509,6 +509,8 @@ config SND_SOC_CQ0093VC
>  config SND_SOC_CROS_EC_CODEC
>  	tristate "codec driver for ChromeOS EC"
>  	depends on CROS_EC
> +	select CRYPTO
> +	select CRYPTO_SHA256
>  	help
>  	  If you say yes here you will get support for the
>  	  ChromeOS Embedded Controller's Audio Codec.
> diff --git a/sound/soc/codecs/cros_ec_codec.c b/sound/soc/codecs/cros_ec_codec.c
> index 3d4f9e82d6e9..dd14caf9091a 100644
> --- a/sound/soc/codecs/cros_ec_codec.c
> +++ b/sound/soc/codecs/cros_ec_codec.c
> @@ -8,10 +8,16 @@
>   * EC for audio function.
>   */
>  
> +#include <crypto/hash.h>
> +#include <crypto/sha.h>
>  #include <linux/delay.h>
>  #include <linux/device.h>
> +#include <linux/io.h>
> +#include <linux/jiffies.h>
>  #include <linux/kernel.h>
>  #include <linux/module.h>
> +#include <linux/of.h>
> +#include <linux/of_address.h>
>  #include <linux/platform_data/cros_ec_commands.h>
>  #include <linux/platform_data/cros_ec_proto.h>
>  #include <linux/platform_device.h>
> @@ -23,8 +29,45 @@
>  struct cros_ec_codec_priv {
>  	struct device *dev;
>  	struct cros_ec_device *ec_device;
> +
> +	/* common */
> +	uint32_t ec_capabilities;
> +
> +	uint64_t ec_shm_addr;
> +	uint32_t ec_shm_len;
> +
> +	uint64_t ap_shm_phys_addr;
> +	uint32_t ap_shm_len;
> +	uint64_t ap_shm_addr;
> +	uint64_t ap_shm_last_alloc;
> +
> +	/* DMIC */
> +	atomic_t dmic_probed;
> +
> +	/* WoV */
> +	bool wov_enabled;
> +	uint8_t *wov_audio_shm_p;
> +	uint32_t wov_audio_shm_len;
> +	uint8_t wov_audio_shm_type;
> +	uint8_t *wov_lang_shm_p;
> +	uint32_t wov_lang_shm_len;
> +	uint8_t wov_lang_shm_type;
> +
> +	struct mutex wov_dma_lock;
> +	uint8_t wov_buf[64000];
> +	uint32_t wov_rp, wov_wp;
> +	size_t wov_dma_offset;
> +	bool wov_burst_read;
> +	struct snd_pcm_substream *wov_substream;
> +	struct delayed_work wov_copy_work;
> +	struct notifier_block wov_notifier;
>  };
>  
> +static int ec_codec_capable(struct cros_ec_codec_priv *priv, uint8_t cap)
> +{
> +	return priv->ec_capabilities & BIT(cap);
> +}
> +
>  static int send_ec_host_command(struct cros_ec_device *ec_dev, uint32_t cmd,
>  				uint8_t *out, size_t outsize,
>  				uint8_t *in, size_t insize)
> @@ -57,6 +100,41 @@ static int send_ec_host_command(struct cros_ec_device *ec_dev, uint32_t cmd,
>  	return ret;
>  }
>  
> +static int calculate_sha256(struct cros_ec_codec_priv *priv,
> +			    uint8_t *buf, uint32_t size, uint8_t *digest)
> +{
> +	struct crypto_shash *tfm;
> +
> +	tfm = crypto_alloc_shash("sha256", CRYPTO_ALG_TYPE_SHASH, 0);
> +	if (IS_ERR(tfm)) {
> +		dev_err(priv->dev, "can't alloc shash\n");
> +		return PTR_ERR(tfm);
> +	}
> +
> +	{
> +		SHASH_DESC_ON_STACK(desc, tfm);
> +
> +		desc->tfm = tfm;
> +
> +		crypto_shash_digest(desc, buf, size, digest);
> +		shash_desc_zero(desc);
> +	}
> +
> +	crypto_free_shash(tfm);
> +
> +#ifdef DEBUG
> +	{
> +		char digest_str[65];
> +
> +		bin2hex(digest_str, digest, 32);
> +		digest_str[64] = 0;
> +		dev_dbg(priv->dev, "hash=%s\n", digest_str);
> +	}
> +#endif
> +
> +	return 0;
> +}
> +
>  static int dmic_get_gain(struct snd_kcontrol *kcontrol,
>  			 struct snd_ctl_elem_value *ucontrol)
>  {
> @@ -147,6 +225,9 @@ static int dmic_probe(struct snd_soc_component *component)
>  	struct ec_response_ec_codec_dmic_get_max_gain r;
>  	int ret;
>  
> +	if (!atomic_add_unless(&priv->dmic_probed, 1, 1))
> +		return 0;
> +
>  	p.cmd = EC_CODEC_DMIC_GET_MAX_GAIN;
>  
>  	ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_DMIC,
> @@ -324,23 +405,638 @@ static const struct snd_soc_component_driver i2s_rx_component_driver = {
>  	.num_dapm_routes	= ARRAY_SIZE(i2s_rx_dapm_routes),
>  };
>  
> +static void *wov_map_shm(struct cros_ec_codec_priv *priv,
> +			 uint8_t shm_id, uint32_t *len, uint8_t *type)
> +{
> +	struct ec_param_ec_codec p;
> +	struct ec_response_ec_codec_get_shm_addr r;
> +	uint32_t req, offset;
> +
> +	p.cmd = EC_CODEC_GET_SHM_ADDR;
> +	p.get_shm_addr_param.shm_id = shm_id;
> +	if (send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC,
> +				 (uint8_t *)&p, sizeof(p),
> +				 (uint8_t *)&r, sizeof(r)) < 0) {
> +		dev_err(priv->dev, "failed to EC_CODEC_GET_SHM_ADDR\n");
> +		return NULL;
> +	}
> +
> +	dev_dbg(priv->dev, "phys_addr=%#llx, len=%#x\n", r.phys_addr, r.len);
> +
> +	*len = r.len;
> +	*type = r.type;
> +
> +	switch (r.type) {
> +	case EC_CODEC_SHM_TYPE_EC_RAM:
> +		return (void __force *)devm_ioremap_wc(priv->dev,
> +				r.phys_addr + priv->ec_shm_addr, r.len);
> +	case EC_CODEC_SHM_TYPE_SYSTEM_RAM:
> +		if (r.phys_addr) {
> +			dev_err(priv->dev, "unknown status\n");
> +			return NULL;
> +		}
> +
> +		req = round_up(r.len, PAGE_SIZE);
> +		dev_dbg(priv->dev, "round up from %u to %u\n", r.len, req);
> +
> +		if (priv->ap_shm_last_alloc + req >
> +		    priv->ap_shm_phys_addr + priv->ap_shm_len) {
> +			dev_err(priv->dev, "insufficient space for AP SHM\n");
> +			return NULL;
> +		}
> +
> +		dev_dbg(priv->dev, "alloc AP SHM addr=%#llx, len=%#x\n",
> +			priv->ap_shm_last_alloc, req);
> +
> +		p.cmd = EC_CODEC_SET_SHM_ADDR;
> +		p.set_shm_addr_param.phys_addr = priv->ap_shm_last_alloc;
> +		p.set_shm_addr_param.len = req;
> +		p.set_shm_addr_param.shm_id = shm_id;
> +		if (send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC,
> +					 (uint8_t *)&p, sizeof(p),
> +					 NULL, 0) < 0) {
> +			dev_err(priv->dev, "failed to EC_CODEC_SET_SHM_ADDR\n");
> +			return NULL;
> +		}
> +
> +		/*
> +		 * Note: EC codec only requests for `r.len' but we allocate
> +		 * round up PAGE_SIZE `req'.
> +		 */
> +		offset = priv->ap_shm_last_alloc - priv->ap_shm_phys_addr;
> +		priv->ap_shm_last_alloc += req;
> +
> +		return (void *)(uintptr_t)(priv->ap_shm_addr + offset);
> +	default:
> +		return NULL;
> +	}
> +}
> +
> +static bool wov_queue_full(struct cros_ec_codec_priv *priv)
> +{
> +	return ((priv->wov_wp + 1) % sizeof(priv->wov_buf)) == priv->wov_rp;
> +}
> +
> +static size_t wov_queue_size(struct cros_ec_codec_priv *priv)
> +{
> +	if (priv->wov_wp >= priv->wov_rp)
> +		return priv->wov_wp - priv->wov_rp;
> +	else
> +		return sizeof(priv->wov_buf) - priv->wov_rp + priv->wov_wp;
> +}
> +
> +static void wov_queue_dequeue(struct cros_ec_codec_priv *priv, size_t len)
> +{
> +	struct snd_pcm_runtime *runtime = priv->wov_substream->runtime;
> +	size_t req;
> +
> +	while (len) {
> +		req = min(len, runtime->dma_bytes - priv->wov_dma_offset);
> +		if (priv->wov_wp >= priv->wov_rp)
> +			req = min(req, (size_t)priv->wov_wp - priv->wov_rp);
> +		else
> +			req = min(req, sizeof(priv->wov_buf) - priv->wov_rp);
> +
> +		memcpy(runtime->dma_area + priv->wov_dma_offset,
> +		       priv->wov_buf + priv->wov_rp, req);
> +
> +		priv->wov_dma_offset += req;
> +		if (priv->wov_dma_offset == runtime->dma_bytes)
> +			priv->wov_dma_offset = 0;
> +
> +		priv->wov_rp += req;
> +		if (priv->wov_rp == sizeof(priv->wov_buf))
> +			priv->wov_rp = 0;
> +
> +		len -= req;
> +	}
> +
> +	snd_pcm_period_elapsed(priv->wov_substream);
> +}
> +
> +static void wov_queue_try_dequeue(struct cros_ec_codec_priv *priv)
> +{
> +	size_t period_bytes = snd_pcm_lib_period_bytes(priv->wov_substream);
> +
> +	while (period_bytes && wov_queue_size(priv) >= period_bytes) {
> +		wov_queue_dequeue(priv, period_bytes);
> +		period_bytes = snd_pcm_lib_period_bytes(priv->wov_substream);
> +	}
> +}
> +
> +static void wov_queue_enqueue(struct cros_ec_codec_priv *priv,
> +			      uint8_t *addr, size_t len, bool iomem)
> +{
> +	size_t req;
> +
> +	while (len) {
> +		if (wov_queue_full(priv)) {
> +			wov_queue_try_dequeue(priv);
> +
> +			if (wov_queue_full(priv)) {
> +				dev_err(priv->dev, "overrun detected\n");
> +				return;
> +			}
> +		}
> +
> +		if (priv->wov_wp >= priv->wov_rp)
> +			req = sizeof(priv->wov_buf) - priv->wov_wp;
> +		else
> +			/* Note: waste 1-byte to differentiate full and empty */
> +			req = priv->wov_rp - priv->wov_wp - 1;
> +		req = min(req, len);
> +
> +		if (iomem)
> +			memcpy_fromio(priv->wov_buf + priv->wov_wp,
> +				      (void __force __iomem *)addr, req);
> +		else
> +			memcpy(priv->wov_buf + priv->wov_wp, addr, req);
> +
> +		priv->wov_wp += req;
> +		if (priv->wov_wp == sizeof(priv->wov_buf))
> +			priv->wov_wp = 0;
> +
> +		addr += req;
> +		len -= req;
> +	}
> +
> +	wov_queue_try_dequeue(priv);
> +}
> +
> +static int wov_read_audio_shm(struct cros_ec_codec_priv *priv)
> +{
> +	struct ec_param_ec_codec_wov p;
> +	struct ec_response_ec_codec_wov_read_audio_shm r;
> +	int ret;
> +
> +	p.cmd = EC_CODEC_WOV_READ_AUDIO_SHM;
> +	ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV,
> +				   (uint8_t *)&p, sizeof(p),
> +				   (uint8_t *)&r, sizeof(r));
> +	if (ret) {
> +		dev_err(priv->dev, "failed to EC_CODEC_WOV_READ_AUDIO_SHM\n");
> +		return ret;
> +	}
> +
> +	if (!r.len)
> +		dev_dbg(priv->dev, "no data, sleep\n");
> +	else
> +		wov_queue_enqueue(priv, priv->wov_audio_shm_p + r.offset, r.len,
> +			priv->wov_audio_shm_type == EC_CODEC_SHM_TYPE_EC_RAM);
> +	return -EAGAIN;
> +}
> +
> +static int wov_read_audio(struct cros_ec_codec_priv *priv)
> +{
> +	struct ec_param_ec_codec_wov p;
> +	struct ec_response_ec_codec_wov_read_audio r;
> +	int remain = priv->wov_burst_read ? 16000 : 320;
> +	int ret;
> +
> +	while (remain >= 0) {
> +		p.cmd = EC_CODEC_WOV_READ_AUDIO;
> +		ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV,
> +					   (uint8_t *)&p, sizeof(p),
> +					   (uint8_t *)&r, sizeof(r));
> +		if (ret) {
> +			dev_err(priv->dev,
> +				"failed to EC_CODEC_WOV_READ_AUDIO\n");
> +			return ret;
> +		}
> +
> +		if (!r.len) {
> +			dev_dbg(priv->dev, "no data, sleep\n");
> +			priv->wov_burst_read = false;
> +			break;
> +		}
> +
> +		wov_queue_enqueue(priv, r.buf, r.len, false);
> +		remain -= r.len;
> +	}
> +
> +	return -EAGAIN;
> +}
> +
> +static void wov_copy_work(struct work_struct *w)
> +{
> +	struct cros_ec_codec_priv *priv =
> +		container_of(w, struct cros_ec_codec_priv, wov_copy_work.work);
> +	int ret;
> +
> +	mutex_lock(&priv->wov_dma_lock);
> +	if (!priv->wov_substream) {
> +		dev_warn(priv->dev, "no pcm substream\n");
> +		goto leave;
> +	}
> +
> +	if (ec_codec_capable(priv, EC_CODEC_CAP_WOV_AUDIO_SHM))
> +		ret = wov_read_audio_shm(priv);
> +	else
> +		ret = wov_read_audio(priv);
> +
> +	if (ret == -EAGAIN)
> +		schedule_delayed_work(&priv->wov_copy_work,
> +				      msecs_to_jiffies(10));
> +	else if (ret)
> +		dev_err(priv->dev, "failed to read audio data\n");
> +leave:
> +	mutex_unlock(&priv->wov_dma_lock);
> +}
> +
> +static int wov_enable_get(struct snd_kcontrol *kcontrol,
> +			  struct snd_ctl_elem_value *ucontrol)
> +{
> +	struct snd_soc_component *c = snd_soc_kcontrol_component(kcontrol);
> +	struct cros_ec_codec_priv *priv = snd_soc_component_get_drvdata(c);
> +
> +	ucontrol->value.integer.value[0] = priv->wov_enabled;
> +	return 0;
> +}
> +
> +static int wov_enable_put(struct snd_kcontrol *kcontrol,
> +			  struct snd_ctl_elem_value *ucontrol)
> +{
> +	struct snd_soc_component *c = snd_soc_kcontrol_component(kcontrol);
> +	struct cros_ec_codec_priv *priv = snd_soc_component_get_drvdata(c);
> +	int enabled = ucontrol->value.integer.value[0];
> +	struct ec_param_ec_codec_wov p;
> +	int ret;
> +
> +	if (priv->wov_enabled != enabled) {
> +		if (enabled)
> +			p.cmd = EC_CODEC_WOV_ENABLE;
> +		else
> +			p.cmd = EC_CODEC_WOV_DISABLE;
> +
> +		ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV,
> +					   (uint8_t *)&p, sizeof(p), NULL, 0);
> +		if (ret) {
> +			dev_err(priv->dev, "failed to %s wov\n",
> +				enabled ? "enable" : "disable");
> +			return ret;
> +		}
> +
> +		priv->wov_enabled = enabled;
> +	}
> +
> +	return 0;
> +}
> +
> +static int wov_set_lang_shm(struct cros_ec_codec_priv *priv,
> +			    uint8_t *buf, size_t size, uint8_t *digest)
> +{
> +	struct ec_param_ec_codec_wov p;
> +	struct ec_param_ec_codec_wov_set_lang_shm *pp = &p.set_lang_shm_param;
> +	int ret;
> +
> +	if (size > priv->wov_lang_shm_len) {
> +		dev_err(priv->dev, "no enough SHM size: %d\n",
> +			priv->wov_lang_shm_len);
> +		return -EIO;
> +	}
> +
> +	switch (priv->wov_lang_shm_type) {
> +	case EC_CODEC_SHM_TYPE_EC_RAM:
> +		memcpy_toio((void __force __iomem *)priv->wov_lang_shm_p,
> +			    buf, size);
> +		memset_io((void __force __iomem *)priv->wov_lang_shm_p + size,
> +			  0, priv->wov_lang_shm_len - size);
> +		break;
> +	case EC_CODEC_SHM_TYPE_SYSTEM_RAM:
> +		memcpy(priv->wov_lang_shm_p, buf, size);
> +		memset(priv->wov_lang_shm_p + size, 0,
> +		       priv->wov_lang_shm_len - size);
> +
> +		/* make sure write to memory before calling host command */
> +		wmb();
> +		break;
> +	}
> +
> +	p.cmd = EC_CODEC_WOV_SET_LANG_SHM;
> +	memcpy(pp->hash, digest, SHA256_DIGEST_SIZE);
> +	pp->total_len = size;
> +	ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV,
> +				   (uint8_t *)&p, sizeof(p), NULL, 0);
> +	if (ret) {
> +		dev_err(priv->dev, "failed to EC_CODEC_WOV_SET_LANG_SHM\n");
> +		return ret;
> +	}
> +
> +	return 0;
> +}
> +
> +static int wov_set_lang(struct cros_ec_codec_priv *priv,
> +			uint8_t *buf, size_t size, uint8_t *digest)
> +{
> +	struct ec_param_ec_codec_wov p;
> +	struct ec_param_ec_codec_wov_set_lang *pp = &p.set_lang_param;
> +	size_t i, req;
> +	int ret;
> +
> +	for (i = 0; i < size; i += req) {
> +		req = min(size - i, ARRAY_SIZE(pp->buf));
> +
> +		p.cmd = EC_CODEC_WOV_SET_LANG;
> +		memcpy(pp->hash, digest, SHA256_DIGEST_SIZE);
> +		pp->total_len = size;
> +		pp->offset = i;
> +		memcpy(pp->buf, buf + i, req);
> +		pp->len = req;
> +		ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV,
> +					   (uint8_t *)&p, sizeof(p), NULL, 0);
> +		if (ret) {
> +			dev_err(priv->dev, "failed to EC_CODEC_WOV_SET_LANG\n");
> +			return ret;
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +static int wov_hotword_model_put(struct snd_kcontrol *kcontrol,
> +				 const unsigned int __user *bytes,
> +				 unsigned int size)
> +{
> +	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
> +	struct cros_ec_codec_priv *priv =
> +		snd_soc_component_get_drvdata(component);
> +	struct ec_param_ec_codec_wov p;
> +	struct ec_response_ec_codec_wov_get_lang r;
> +	uint8_t digest[SHA256_DIGEST_SIZE];
> +	uint8_t *buf;
> +	int ret;
> +
> +	/* Skips the TLV header. */
> +	bytes += 2;
> +	size -= 8;
> +
> +	dev_dbg(priv->dev, "%s: size=%d\n", __func__, size);
> +
> +	buf = memdup_user(bytes, size);
> +	if (IS_ERR(buf))
> +		return PTR_ERR(buf);
> +
> +	ret = calculate_sha256(priv, buf, size, digest);
> +	if (ret)
> +		goto leave;
> +
> +	p.cmd = EC_CODEC_WOV_GET_LANG;
> +	ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC_WOV,
> +				   (uint8_t *)&p, sizeof(p),
> +				   (uint8_t *)&r, sizeof(r));
> +	if (ret)
> +		goto leave;
> +
> +	if (memcmp(digest, r.hash, SHA256_DIGEST_SIZE) == 0) {
> +		dev_dbg(priv->dev, "not updated");
> +		goto leave;
> +	}
> +
> +	if (ec_codec_capable(priv, EC_CODEC_CAP_WOV_LANG_SHM))
> +		ret = wov_set_lang_shm(priv, buf, size, digest);
> +	else
> +		ret = wov_set_lang(priv, buf, size, digest);
> +
> +leave:
> +	kfree(buf);
> +	return ret;
> +}
> +
> +static struct snd_kcontrol_new wov_controls[] = {
> +	SOC_SINGLE_BOOL_EXT("Wake-on-Voice Switch", 0,
> +			    wov_enable_get, wov_enable_put),
> +	SND_SOC_BYTES_TLV("Hotword Model", 0x11000, NULL,
> +			  wov_hotword_model_put),
> +};
> +
> +static struct snd_soc_dai_driver wov_dai_driver = {
> +	.name = "Wake on Voice",
> +	.capture = {
> +		.stream_name = "WoV Capture",
> +		.channels_min = 1,
> +		.channels_max = 1,
> +		.rates = SNDRV_PCM_RATE_16000,
> +		.formats = SNDRV_PCM_FMTBIT_S16_LE,
> +	},
> +};
> +
> +static int wov_host_event(struct notifier_block *nb,
> +			  unsigned long queued_during_suspend, void *notify)
> +{
> +	struct cros_ec_codec_priv *priv =
> +		container_of(nb, struct cros_ec_codec_priv, wov_notifier);
> +	u32 host_event;
> +
> +	dev_dbg(priv->dev, "%s\n", __func__);
> +
> +	host_event = cros_ec_get_host_event(priv->ec_device);
> +	if (host_event & EC_HOST_EVENT_MASK(EC_HOST_EVENT_WOV)) {
> +		schedule_delayed_work(&priv->wov_copy_work, 0);
> +		return NOTIFY_OK;
> +	} else {
> +		return NOTIFY_DONE;
> +	}
> +}
> +
> +static int wov_probe(struct snd_soc_component *component)
> +{
> +	struct cros_ec_codec_priv *priv =
> +		snd_soc_component_get_drvdata(component);
> +	int ret;
> +
> +	mutex_init(&priv->wov_dma_lock);
> +	INIT_DELAYED_WORK(&priv->wov_copy_work, wov_copy_work);
> +
> +	priv->wov_notifier.notifier_call = wov_host_event;
> +	ret = blocking_notifier_chain_register(
> +			&priv->ec_device->event_notifier, &priv->wov_notifier);
> +	if (ret)
> +		return ret;
> +
> +	if (ec_codec_capable(priv, EC_CODEC_CAP_WOV_LANG_SHM)) {
> +		priv->wov_lang_shm_p = wov_map_shm(priv,
> +				EC_CODEC_SHM_ID_WOV_LANG,
> +				&priv->wov_lang_shm_len,
> +				&priv->wov_lang_shm_type);
> +		if (!priv->wov_lang_shm_p)
> +			return -EFAULT;
> +	}
> +
> +	if (ec_codec_capable(priv, EC_CODEC_CAP_WOV_AUDIO_SHM)) {
> +		priv->wov_audio_shm_p = wov_map_shm(priv,
> +				EC_CODEC_SHM_ID_WOV_AUDIO,
> +				&priv->wov_audio_shm_len,
> +				&priv->wov_audio_shm_type);
> +		if (!priv->wov_audio_shm_p)
> +			return -EFAULT;
> +	}
> +
> +	return dmic_probe(component);
> +}
> +
> +static void wov_remove(struct snd_soc_component *component)
> +{
> +	struct cros_ec_codec_priv *priv =
> +		snd_soc_component_get_drvdata(component);
> +
> +	blocking_notifier_chain_unregister(
> +			&priv->ec_device->event_notifier, &priv->wov_notifier);
> +}
> +
> +static int wov_pcm_open(struct snd_soc_component *component,
> +			struct snd_pcm_substream *substream)
> +{
> +	static const struct snd_pcm_hardware hw_param = {
> +		.info = SNDRV_PCM_INFO_MMAP |
> +			SNDRV_PCM_INFO_INTERLEAVED |
> +			SNDRV_PCM_INFO_MMAP_VALID,
> +		.formats = SNDRV_PCM_FMTBIT_S16_LE,
> +		.rates = SNDRV_PCM_RATE_16000,
> +		.channels_min = 1,
> +		.channels_max = 1,
> +		.period_bytes_min = PAGE_SIZE,
> +		.period_bytes_max = 0x20000 / 8,
> +		.periods_min = 8,
> +		.periods_max = 8,
> +		.buffer_bytes_max = 0x20000,
> +	};
> +
> +	return snd_soc_set_runtime_hwparams(substream, &hw_param);
> +}
> +
> +static int wov_pcm_hw_params(struct snd_soc_component *component,
> +			     struct snd_pcm_substream *substream,
> +			     struct snd_pcm_hw_params *hw_params)
> +{
> +	struct cros_ec_codec_priv *priv =
> +		snd_soc_component_get_drvdata(component);
> +
> +	mutex_lock(&priv->wov_dma_lock);
> +	priv->wov_substream = substream;
> +	priv->wov_rp = priv->wov_wp = 0;
> +	priv->wov_dma_offset = 0;
> +	priv->wov_burst_read = true;
> +	mutex_unlock(&priv->wov_dma_lock);
> +
> +	return snd_pcm_lib_alloc_vmalloc_buffer(substream,
> +			params_buffer_bytes(hw_params));
> +}
> +
> +static int wov_pcm_hw_free(struct snd_soc_component *component,
> +			   struct snd_pcm_substream *substream)
> +{
> +	struct cros_ec_codec_priv *priv =
> +		snd_soc_component_get_drvdata(component);
> +
> +	mutex_lock(&priv->wov_dma_lock);
> +	wov_queue_dequeue(priv, wov_queue_size(priv));
> +	priv->wov_substream = NULL;
> +	mutex_unlock(&priv->wov_dma_lock);
> +
> +	cancel_delayed_work_sync(&priv->wov_copy_work);
> +
> +	return snd_pcm_lib_free_vmalloc_buffer(substream);
> +}
> +
> +static snd_pcm_uframes_t wov_pcm_pointer(struct snd_soc_component *component,
> +					 struct snd_pcm_substream *substream)
> +{
> +	struct snd_pcm_runtime *runtime = substream->runtime;
> +	struct cros_ec_codec_priv *priv =
> +		snd_soc_component_get_drvdata(component);
> +
> +	return bytes_to_frames(runtime, priv->wov_dma_offset);
> +}
> +
> +static struct page *wov_pcm_page(struct snd_soc_component *component,
> +				 struct snd_pcm_substream *substream,
> +				 unsigned long offset)
> +{
> +	return snd_pcm_lib_get_vmalloc_page(substream, offset);
> +}
> +
> +static const struct snd_soc_component_driver wov_component_driver = {
> +	.probe		= wov_probe,
> +	.remove		= wov_remove,
> +	.controls	= wov_controls,
> +	.num_controls	= ARRAY_SIZE(wov_controls),
> +	.open		= wov_pcm_open,
> +	.hw_params	= wov_pcm_hw_params,
> +	.hw_free	= wov_pcm_hw_free,
> +	.pointer	= wov_pcm_pointer,
> +	.page		= wov_pcm_page,
> +};
> +
>  static int cros_ec_codec_platform_probe(struct platform_device *pdev)
>  {
>  	struct device *dev = &pdev->dev;
>  	struct cros_ec_device *ec_device = dev_get_drvdata(pdev->dev.parent);
>  	struct cros_ec_codec_priv *priv;
> +	struct ec_param_ec_codec p;
> +	struct ec_response_ec_codec_get_capabilities r;
> +	int ret;
> +#ifdef CONFIG_OF
> +	struct device_node *node;
> +	struct resource res;
> +	u64 ec_shm_size;
> +	const __be32 *regaddr_p;
> +#endif
>  
>  	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
>  	if (!priv)
>  		return -ENOMEM;
>  
> +#ifdef CONFIG_OF
> +	regaddr_p = of_get_address(dev->of_node, 0, &ec_shm_size, NULL);
> +	if (regaddr_p) {
> +		priv->ec_shm_addr = of_read_number(regaddr_p, 2);
> +		priv->ec_shm_len = ec_shm_size;
> +
> +		dev_dbg(dev, "ec_shm_addr=%#llx len=%#x\n",
> +			priv->ec_shm_addr, priv->ec_shm_len);
> +	}
> +
> +	node = of_parse_phandle(dev->of_node, "memory-region", 0);
> +	if (node) {
> +		ret = of_address_to_resource(node, 0, &res);
> +		if (!ret) {
> +			priv->ap_shm_phys_addr = res.start;
> +			priv->ap_shm_len = resource_size(&res);
> +			priv->ap_shm_addr =
> +				(uint64_t)(uintptr_t)devm_ioremap_wc(
> +					dev, priv->ap_shm_phys_addr,
> +					priv->ap_shm_len);
> +			priv->ap_shm_last_alloc = priv->ap_shm_phys_addr;
> +
> +			dev_dbg(dev, "ap_shm_phys_addr=%#llx len=%#x\n",
> +				priv->ap_shm_phys_addr, priv->ap_shm_len);
> +		}
> +	}
> +#endif
> +
>  	priv->dev = dev;
>  	priv->ec_device = ec_device;
> +	atomic_set(&priv->dmic_probed, 0);
> +
> +	p.cmd = EC_CODEC_GET_CAPABILITIES;
> +	ret = send_ec_host_command(priv->ec_device, EC_CMD_EC_CODEC,
> +				   (uint8_t *)&p, sizeof(p),
> +				   (uint8_t *)&r, sizeof(r));
> +	if (ret) {
> +		dev_err(dev, "failed to EC_CODEC_GET_CAPABILITIES\n");
> +		return ret;
> +	}
> +	priv->ec_capabilities = r.capabilities;
>  
>  	platform_set_drvdata(pdev, priv);
>  
> -	return devm_snd_soc_register_component(dev, &i2s_rx_component_driver,
> -					       &i2s_rx_dai_driver, 1);
> +	ret = devm_snd_soc_register_component(dev, &i2s_rx_component_driver,
> +					      &i2s_rx_dai_driver, 1);
> +	if (ret)
> +		return ret;
> +
> +	return devm_snd_soc_register_component(dev, &wov_component_driver,
> +					       &wov_dai_driver, 1);
>  }
>  
>  #ifdef CONFIG_OF
> 



[Index of Archives]     [Device Tree Compilter]     [Device Tree Spec]     [Linux Driver Backports]     [Video for Linux]     [Linux USB Devel]     [Linux PCI Devel]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [XFree86]     [Yosemite Backpacking]


  Powered by Linux