Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * wm_adsp.c  --  Wolfson ADSP support
0004  *
0005  * Copyright 2012 Wolfson Microelectronics plc
0006  *
0007  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
0008  */
0009 
0010 #include <linux/ctype.h>
0011 #include <linux/module.h>
0012 #include <linux/moduleparam.h>
0013 #include <linux/init.h>
0014 #include <linux/delay.h>
0015 #include <linux/firmware.h>
0016 #include <linux/list.h>
0017 #include <linux/pm.h>
0018 #include <linux/pm_runtime.h>
0019 #include <linux/regmap.h>
0020 #include <linux/regulator/consumer.h>
0021 #include <linux/slab.h>
0022 #include <linux/workqueue.h>
0023 #include <linux/debugfs.h>
0024 #include <sound/core.h>
0025 #include <sound/pcm.h>
0026 #include <sound/pcm_params.h>
0027 #include <sound/soc.h>
0028 #include <sound/jack.h>
0029 #include <sound/initval.h>
0030 #include <sound/tlv.h>
0031 
0032 #include "wm_adsp.h"
0033 
0034 #define adsp_crit(_dsp, fmt, ...) \
0035     dev_crit(_dsp->cs_dsp.dev, "%s: " fmt, _dsp->cs_dsp.name, ##__VA_ARGS__)
0036 #define adsp_err(_dsp, fmt, ...) \
0037     dev_err(_dsp->cs_dsp.dev, "%s: " fmt, _dsp->cs_dsp.name, ##__VA_ARGS__)
0038 #define adsp_warn(_dsp, fmt, ...) \
0039     dev_warn(_dsp->cs_dsp.dev, "%s: " fmt, _dsp->cs_dsp.name, ##__VA_ARGS__)
0040 #define adsp_info(_dsp, fmt, ...) \
0041     dev_info(_dsp->cs_dsp.dev, "%s: " fmt, _dsp->cs_dsp.name, ##__VA_ARGS__)
0042 #define adsp_dbg(_dsp, fmt, ...) \
0043     dev_dbg(_dsp->cs_dsp.dev, "%s: " fmt, _dsp->cs_dsp.name, ##__VA_ARGS__)
0044 
0045 #define compr_err(_obj, fmt, ...) \
0046     adsp_err(_obj->dsp, "%s: " fmt, _obj->name ? _obj->name : "legacy", \
0047          ##__VA_ARGS__)
0048 #define compr_dbg(_obj, fmt, ...) \
0049     adsp_dbg(_obj->dsp, "%s: " fmt, _obj->name ? _obj->name : "legacy", \
0050          ##__VA_ARGS__)
0051 
0052 #define ADSP_MAX_STD_CTRL_SIZE               512
0053 
0054 static const struct cs_dsp_client_ops wm_adsp1_client_ops;
0055 static const struct cs_dsp_client_ops wm_adsp2_client_ops;
0056 
0057 #define WM_ADSP_FW_MBC_VSS  0
0058 #define WM_ADSP_FW_HIFI     1
0059 #define WM_ADSP_FW_TX       2
0060 #define WM_ADSP_FW_TX_SPK   3
0061 #define WM_ADSP_FW_RX       4
0062 #define WM_ADSP_FW_RX_ANC   5
0063 #define WM_ADSP_FW_CTRL     6
0064 #define WM_ADSP_FW_ASR      7
0065 #define WM_ADSP_FW_TRACE    8
0066 #define WM_ADSP_FW_SPK_PROT 9
0067 #define WM_ADSP_FW_SPK_CALI 10
0068 #define WM_ADSP_FW_SPK_DIAG 11
0069 #define WM_ADSP_FW_MISC     12
0070 
0071 #define WM_ADSP_NUM_FW      13
0072 
0073 static const char *wm_adsp_fw_text[WM_ADSP_NUM_FW] = {
0074     [WM_ADSP_FW_MBC_VSS] =  "MBC/VSS",
0075     [WM_ADSP_FW_HIFI] =     "MasterHiFi",
0076     [WM_ADSP_FW_TX] =       "Tx",
0077     [WM_ADSP_FW_TX_SPK] =   "Tx Speaker",
0078     [WM_ADSP_FW_RX] =       "Rx",
0079     [WM_ADSP_FW_RX_ANC] =   "Rx ANC",
0080     [WM_ADSP_FW_CTRL] =     "Voice Ctrl",
0081     [WM_ADSP_FW_ASR] =      "ASR Assist",
0082     [WM_ADSP_FW_TRACE] =    "Dbg Trace",
0083     [WM_ADSP_FW_SPK_PROT] = "Protection",
0084     [WM_ADSP_FW_SPK_CALI] = "Calibration",
0085     [WM_ADSP_FW_SPK_DIAG] = "Diagnostic",
0086     [WM_ADSP_FW_MISC] =     "Misc",
0087 };
0088 
0089 struct wm_adsp_system_config_xm_hdr {
0090     __be32 sys_enable;
0091     __be32 fw_id;
0092     __be32 fw_rev;
0093     __be32 boot_status;
0094     __be32 watchdog;
0095     __be32 dma_buffer_size;
0096     __be32 rdma[6];
0097     __be32 wdma[8];
0098     __be32 build_job_name[3];
0099     __be32 build_job_number;
0100 } __packed;
0101 
0102 struct wm_halo_system_config_xm_hdr {
0103     __be32 halo_heartbeat;
0104     __be32 build_job_name[3];
0105     __be32 build_job_number;
0106 } __packed;
0107 
0108 struct wm_adsp_alg_xm_struct {
0109     __be32 magic;
0110     __be32 smoothing;
0111     __be32 threshold;
0112     __be32 host_buf_ptr;
0113     __be32 start_seq;
0114     __be32 high_water_mark;
0115     __be32 low_water_mark;
0116     __be64 smoothed_power;
0117 } __packed;
0118 
0119 struct wm_adsp_host_buf_coeff_v1 {
0120     __be32 host_buf_ptr;        /* Host buffer pointer */
0121     __be32 versions;        /* Version numbers */
0122     __be32 name[4];         /* The buffer name */
0123 } __packed;
0124 
0125 struct wm_adsp_buffer {
0126     __be32 buf1_base;       /* Base addr of first buffer area */
0127     __be32 buf1_size;       /* Size of buf1 area in DSP words */
0128     __be32 buf2_base;       /* Base addr of 2nd buffer area */
0129     __be32 buf1_buf2_size;      /* Size of buf1+buf2 in DSP words */
0130     __be32 buf3_base;       /* Base addr of buf3 area */
0131     __be32 buf_total_size;      /* Size of buf1+buf2+buf3 in DSP words */
0132     __be32 high_water_mark;     /* Point at which IRQ is asserted */
0133     __be32 irq_count;       /* bits 1-31 count IRQ assertions */
0134     __be32 irq_ack;         /* acked IRQ count, bit 0 enables IRQ */
0135     __be32 next_write_index;    /* word index of next write */
0136     __be32 next_read_index;     /* word index of next read */
0137     __be32 error;           /* error if any */
0138     __be32 oldest_block_index;  /* word index of oldest surviving */
0139     __be32 requested_rewind;    /* how many blocks rewind was done */
0140     __be32 reserved_space;      /* internal */
0141     __be32 min_free;        /* min free space since stream start */
0142     __be32 blocks_written[2];   /* total blocks written (64 bit) */
0143     __be32 words_written[2];    /* total words written (64 bit) */
0144 } __packed;
0145 
0146 struct wm_adsp_compr;
0147 
0148 struct wm_adsp_compr_buf {
0149     struct list_head list;
0150     struct wm_adsp *dsp;
0151     struct wm_adsp_compr *compr;
0152 
0153     struct wm_adsp_buffer_region *regions;
0154     u32 host_buf_ptr;
0155 
0156     u32 error;
0157     u32 irq_count;
0158     int read_index;
0159     int avail;
0160     int host_buf_mem_type;
0161 
0162     char *name;
0163 };
0164 
0165 struct wm_adsp_compr {
0166     struct list_head list;
0167     struct wm_adsp *dsp;
0168     struct wm_adsp_compr_buf *buf;
0169 
0170     struct snd_compr_stream *stream;
0171     struct snd_compressed_buffer size;
0172 
0173     u32 *raw_buf;
0174     unsigned int copied_total;
0175 
0176     unsigned int sample_rate;
0177 
0178     const char *name;
0179 };
0180 
0181 #define WM_ADSP_MIN_FRAGMENTS          1
0182 #define WM_ADSP_MAX_FRAGMENTS          256
0183 #define WM_ADSP_MIN_FRAGMENT_SIZE      (16 * CS_DSP_DATA_WORD_SIZE)
0184 #define WM_ADSP_MAX_FRAGMENT_SIZE      (4096 * CS_DSP_DATA_WORD_SIZE)
0185 
0186 #define WM_ADSP_ALG_XM_STRUCT_MAGIC    0x49aec7
0187 
0188 #define HOST_BUFFER_FIELD(field) \
0189     (offsetof(struct wm_adsp_buffer, field) / sizeof(__be32))
0190 
0191 #define ALG_XM_FIELD(field) \
0192     (offsetof(struct wm_adsp_alg_xm_struct, field) / sizeof(__be32))
0193 
0194 #define HOST_BUF_COEFF_SUPPORTED_COMPAT_VER 1
0195 
0196 #define HOST_BUF_COEFF_COMPAT_VER_MASK      0xFF00
0197 #define HOST_BUF_COEFF_COMPAT_VER_SHIFT     8
0198 
0199 static int wm_adsp_buffer_init(struct wm_adsp *dsp);
0200 static int wm_adsp_buffer_free(struct wm_adsp *dsp);
0201 
0202 struct wm_adsp_buffer_region {
0203     unsigned int offset;
0204     unsigned int cumulative_size;
0205     unsigned int mem_type;
0206     unsigned int base_addr;
0207 };
0208 
0209 struct wm_adsp_buffer_region_def {
0210     unsigned int mem_type;
0211     unsigned int base_offset;
0212     unsigned int size_offset;
0213 };
0214 
0215 static const struct wm_adsp_buffer_region_def default_regions[] = {
0216     {
0217         .mem_type = WMFW_ADSP2_XM,
0218         .base_offset = HOST_BUFFER_FIELD(buf1_base),
0219         .size_offset = HOST_BUFFER_FIELD(buf1_size),
0220     },
0221     {
0222         .mem_type = WMFW_ADSP2_XM,
0223         .base_offset = HOST_BUFFER_FIELD(buf2_base),
0224         .size_offset = HOST_BUFFER_FIELD(buf1_buf2_size),
0225     },
0226     {
0227         .mem_type = WMFW_ADSP2_YM,
0228         .base_offset = HOST_BUFFER_FIELD(buf3_base),
0229         .size_offset = HOST_BUFFER_FIELD(buf_total_size),
0230     },
0231 };
0232 
0233 struct wm_adsp_fw_caps {
0234     u32 id;
0235     struct snd_codec_desc desc;
0236     int num_regions;
0237     const struct wm_adsp_buffer_region_def *region_defs;
0238 };
0239 
0240 static const struct wm_adsp_fw_caps ctrl_caps[] = {
0241     {
0242         .id = SND_AUDIOCODEC_BESPOKE,
0243         .desc = {
0244             .max_ch = 8,
0245             .sample_rates = { 16000 },
0246             .num_sample_rates = 1,
0247             .formats = SNDRV_PCM_FMTBIT_S16_LE,
0248         },
0249         .num_regions = ARRAY_SIZE(default_regions),
0250         .region_defs = default_regions,
0251     },
0252 };
0253 
0254 static const struct wm_adsp_fw_caps trace_caps[] = {
0255     {
0256         .id = SND_AUDIOCODEC_BESPOKE,
0257         .desc = {
0258             .max_ch = 8,
0259             .sample_rates = {
0260                 4000, 8000, 11025, 12000, 16000, 22050,
0261                 24000, 32000, 44100, 48000, 64000, 88200,
0262                 96000, 176400, 192000
0263             },
0264             .num_sample_rates = 15,
0265             .formats = SNDRV_PCM_FMTBIT_S16_LE,
0266         },
0267         .num_regions = ARRAY_SIZE(default_regions),
0268         .region_defs = default_regions,
0269     },
0270 };
0271 
0272 static const struct {
0273     const char *file;
0274     int compr_direction;
0275     int num_caps;
0276     const struct wm_adsp_fw_caps *caps;
0277     bool voice_trigger;
0278 } wm_adsp_fw[WM_ADSP_NUM_FW] = {
0279     [WM_ADSP_FW_MBC_VSS] =  { .file = "mbc-vss" },
0280     [WM_ADSP_FW_HIFI] =     { .file = "hifi" },
0281     [WM_ADSP_FW_TX] =       { .file = "tx" },
0282     [WM_ADSP_FW_TX_SPK] =   { .file = "tx-spk" },
0283     [WM_ADSP_FW_RX] =       { .file = "rx" },
0284     [WM_ADSP_FW_RX_ANC] =   { .file = "rx-anc" },
0285     [WM_ADSP_FW_CTRL] =     {
0286         .file = "ctrl",
0287         .compr_direction = SND_COMPRESS_CAPTURE,
0288         .num_caps = ARRAY_SIZE(ctrl_caps),
0289         .caps = ctrl_caps,
0290         .voice_trigger = true,
0291     },
0292     [WM_ADSP_FW_ASR] =      { .file = "asr" },
0293     [WM_ADSP_FW_TRACE] =    {
0294         .file = "trace",
0295         .compr_direction = SND_COMPRESS_CAPTURE,
0296         .num_caps = ARRAY_SIZE(trace_caps),
0297         .caps = trace_caps,
0298     },
0299     [WM_ADSP_FW_SPK_PROT] = {
0300         .file = "spk-prot",
0301         .compr_direction = SND_COMPRESS_CAPTURE,
0302         .num_caps = ARRAY_SIZE(trace_caps),
0303         .caps = trace_caps,
0304     },
0305     [WM_ADSP_FW_SPK_CALI] = { .file = "spk-cali" },
0306     [WM_ADSP_FW_SPK_DIAG] = { .file = "spk-diag" },
0307     [WM_ADSP_FW_MISC] =     { .file = "misc" },
0308 };
0309 
0310 struct wm_coeff_ctl {
0311     const char *name;
0312     struct cs_dsp_coeff_ctl *cs_ctl;
0313     struct soc_bytes_ext bytes_ext;
0314     struct work_struct work;
0315 };
0316 
0317 int wm_adsp_fw_get(struct snd_kcontrol *kcontrol,
0318            struct snd_ctl_elem_value *ucontrol)
0319 {
0320     struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
0321     struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
0322     struct wm_adsp *dsp = snd_soc_component_get_drvdata(component);
0323 
0324     ucontrol->value.enumerated.item[0] = dsp[e->shift_l].fw;
0325 
0326     return 0;
0327 }
0328 EXPORT_SYMBOL_GPL(wm_adsp_fw_get);
0329 
0330 int wm_adsp_fw_put(struct snd_kcontrol *kcontrol,
0331            struct snd_ctl_elem_value *ucontrol)
0332 {
0333     struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
0334     struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
0335     struct wm_adsp *dsp = snd_soc_component_get_drvdata(component);
0336     int ret = 1;
0337 
0338     if (ucontrol->value.enumerated.item[0] == dsp[e->shift_l].fw)
0339         return 0;
0340 
0341     if (ucontrol->value.enumerated.item[0] >= WM_ADSP_NUM_FW)
0342         return -EINVAL;
0343 
0344     mutex_lock(&dsp[e->shift_l].cs_dsp.pwr_lock);
0345 
0346     if (dsp[e->shift_l].cs_dsp.booted || !list_empty(&dsp[e->shift_l].compr_list))
0347         ret = -EBUSY;
0348     else
0349         dsp[e->shift_l].fw = ucontrol->value.enumerated.item[0];
0350 
0351     mutex_unlock(&dsp[e->shift_l].cs_dsp.pwr_lock);
0352 
0353     return ret;
0354 }
0355 EXPORT_SYMBOL_GPL(wm_adsp_fw_put);
0356 
0357 const struct soc_enum wm_adsp_fw_enum[] = {
0358     SOC_ENUM_SINGLE(0, 0, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
0359     SOC_ENUM_SINGLE(0, 1, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
0360     SOC_ENUM_SINGLE(0, 2, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
0361     SOC_ENUM_SINGLE(0, 3, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
0362     SOC_ENUM_SINGLE(0, 4, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
0363     SOC_ENUM_SINGLE(0, 5, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
0364     SOC_ENUM_SINGLE(0, 6, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
0365 };
0366 EXPORT_SYMBOL_GPL(wm_adsp_fw_enum);
0367 
0368 static inline struct wm_coeff_ctl *bytes_ext_to_ctl(struct soc_bytes_ext *ext)
0369 {
0370     return container_of(ext, struct wm_coeff_ctl, bytes_ext);
0371 }
0372 
0373 static int wm_coeff_info(struct snd_kcontrol *kctl,
0374              struct snd_ctl_elem_info *uinfo)
0375 {
0376     struct soc_bytes_ext *bytes_ext =
0377         (struct soc_bytes_ext *)kctl->private_value;
0378     struct wm_coeff_ctl *ctl = bytes_ext_to_ctl(bytes_ext);
0379     struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;
0380 
0381     switch (cs_ctl->type) {
0382     case WMFW_CTL_TYPE_ACKED:
0383         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
0384         uinfo->value.integer.min = CS_DSP_ACKED_CTL_MIN_VALUE;
0385         uinfo->value.integer.max = CS_DSP_ACKED_CTL_MAX_VALUE;
0386         uinfo->value.integer.step = 1;
0387         uinfo->count = 1;
0388         break;
0389     default:
0390         uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
0391         uinfo->count = cs_ctl->len;
0392         break;
0393     }
0394 
0395     return 0;
0396 }
0397 
0398 static int wm_coeff_put(struct snd_kcontrol *kctl,
0399             struct snd_ctl_elem_value *ucontrol)
0400 {
0401     struct soc_bytes_ext *bytes_ext =
0402         (struct soc_bytes_ext *)kctl->private_value;
0403     struct wm_coeff_ctl *ctl = bytes_ext_to_ctl(bytes_ext);
0404     struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;
0405     char *p = ucontrol->value.bytes.data;
0406     int ret = 0;
0407 
0408     mutex_lock(&cs_ctl->dsp->pwr_lock);
0409     ret = cs_dsp_coeff_write_ctrl(cs_ctl, 0, p, cs_ctl->len);
0410     mutex_unlock(&cs_ctl->dsp->pwr_lock);
0411 
0412     return ret;
0413 }
0414 
0415 static int wm_coeff_tlv_put(struct snd_kcontrol *kctl,
0416                 const unsigned int __user *bytes, unsigned int size)
0417 {
0418     struct soc_bytes_ext *bytes_ext =
0419         (struct soc_bytes_ext *)kctl->private_value;
0420     struct wm_coeff_ctl *ctl = bytes_ext_to_ctl(bytes_ext);
0421     struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;
0422     int ret = 0;
0423 
0424     mutex_lock(&cs_ctl->dsp->pwr_lock);
0425 
0426     if (copy_from_user(cs_ctl->cache, bytes, size))
0427         ret = -EFAULT;
0428     else
0429         ret = cs_dsp_coeff_write_ctrl(cs_ctl, 0, cs_ctl->cache, size);
0430 
0431     mutex_unlock(&cs_ctl->dsp->pwr_lock);
0432 
0433     return ret;
0434 }
0435 
0436 static int wm_coeff_put_acked(struct snd_kcontrol *kctl,
0437                   struct snd_ctl_elem_value *ucontrol)
0438 {
0439     struct soc_bytes_ext *bytes_ext =
0440         (struct soc_bytes_ext *)kctl->private_value;
0441     struct wm_coeff_ctl *ctl = bytes_ext_to_ctl(bytes_ext);
0442     struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;
0443     unsigned int val = ucontrol->value.integer.value[0];
0444     int ret;
0445 
0446     if (val == 0)
0447         return 0;   /* 0 means no event */
0448 
0449     mutex_lock(&cs_ctl->dsp->pwr_lock);
0450 
0451     if (cs_ctl->enabled)
0452         ret = cs_dsp_coeff_write_acked_control(cs_ctl, val);
0453     else
0454         ret = -EPERM;
0455 
0456     mutex_unlock(&cs_ctl->dsp->pwr_lock);
0457 
0458     return ret;
0459 }
0460 
0461 static int wm_coeff_get(struct snd_kcontrol *kctl,
0462             struct snd_ctl_elem_value *ucontrol)
0463 {
0464     struct soc_bytes_ext *bytes_ext =
0465         (struct soc_bytes_ext *)kctl->private_value;
0466     struct wm_coeff_ctl *ctl = bytes_ext_to_ctl(bytes_ext);
0467     struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;
0468     char *p = ucontrol->value.bytes.data;
0469     int ret;
0470 
0471     mutex_lock(&cs_ctl->dsp->pwr_lock);
0472     ret = cs_dsp_coeff_read_ctrl(cs_ctl, 0, p, cs_ctl->len);
0473     mutex_unlock(&cs_ctl->dsp->pwr_lock);
0474 
0475     return ret;
0476 }
0477 
0478 static int wm_coeff_tlv_get(struct snd_kcontrol *kctl,
0479                 unsigned int __user *bytes, unsigned int size)
0480 {
0481     struct soc_bytes_ext *bytes_ext =
0482         (struct soc_bytes_ext *)kctl->private_value;
0483     struct wm_coeff_ctl *ctl = bytes_ext_to_ctl(bytes_ext);
0484     struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;
0485     int ret = 0;
0486 
0487     mutex_lock(&cs_ctl->dsp->pwr_lock);
0488 
0489     ret = cs_dsp_coeff_read_ctrl(cs_ctl, 0, cs_ctl->cache, size);
0490 
0491     if (!ret && copy_to_user(bytes, cs_ctl->cache, size))
0492         ret = -EFAULT;
0493 
0494     mutex_unlock(&cs_ctl->dsp->pwr_lock);
0495 
0496     return ret;
0497 }
0498 
0499 static int wm_coeff_get_acked(struct snd_kcontrol *kcontrol,
0500                   struct snd_ctl_elem_value *ucontrol)
0501 {
0502     /*
0503      * Although it's not useful to read an acked control, we must satisfy
0504      * user-side assumptions that all controls are readable and that a
0505      * write of the same value should be filtered out (it's valid to send
0506      * the same event number again to the firmware). We therefore return 0,
0507      * meaning "no event" so valid event numbers will always be a change
0508      */
0509     ucontrol->value.integer.value[0] = 0;
0510 
0511     return 0;
0512 }
0513 
0514 static unsigned int wmfw_convert_flags(unsigned int in, unsigned int len)
0515 {
0516     unsigned int out, rd, wr, vol;
0517 
0518     if (len > ADSP_MAX_STD_CTRL_SIZE) {
0519         rd = SNDRV_CTL_ELEM_ACCESS_TLV_READ;
0520         wr = SNDRV_CTL_ELEM_ACCESS_TLV_WRITE;
0521         vol = SNDRV_CTL_ELEM_ACCESS_VOLATILE;
0522 
0523         out = SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
0524     } else {
0525         rd = SNDRV_CTL_ELEM_ACCESS_READ;
0526         wr = SNDRV_CTL_ELEM_ACCESS_WRITE;
0527         vol = SNDRV_CTL_ELEM_ACCESS_VOLATILE;
0528 
0529         out = 0;
0530     }
0531 
0532     if (in) {
0533         out |= rd;
0534         if (in & WMFW_CTL_FLAG_WRITEABLE)
0535             out |= wr;
0536         if (in & WMFW_CTL_FLAG_VOLATILE)
0537             out |= vol;
0538     } else {
0539         out |= rd | wr | vol;
0540     }
0541 
0542     return out;
0543 }
0544 
0545 static void wm_adsp_ctl_work(struct work_struct *work)
0546 {
0547     struct wm_coeff_ctl *ctl = container_of(work,
0548                         struct wm_coeff_ctl,
0549                         work);
0550     struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;
0551     struct wm_adsp *dsp = container_of(cs_ctl->dsp,
0552                        struct wm_adsp,
0553                        cs_dsp);
0554     struct snd_kcontrol_new *kcontrol;
0555 
0556     kcontrol = kzalloc(sizeof(*kcontrol), GFP_KERNEL);
0557     if (!kcontrol)
0558         return;
0559 
0560     kcontrol->name = ctl->name;
0561     kcontrol->info = wm_coeff_info;
0562     kcontrol->iface = SNDRV_CTL_ELEM_IFACE_MIXER;
0563     kcontrol->tlv.c = snd_soc_bytes_tlv_callback;
0564     kcontrol->private_value = (unsigned long)&ctl->bytes_ext;
0565     kcontrol->access = wmfw_convert_flags(cs_ctl->flags, cs_ctl->len);
0566 
0567     switch (cs_ctl->type) {
0568     case WMFW_CTL_TYPE_ACKED:
0569         kcontrol->get = wm_coeff_get_acked;
0570         kcontrol->put = wm_coeff_put_acked;
0571         break;
0572     default:
0573         if (kcontrol->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
0574             ctl->bytes_ext.max = cs_ctl->len;
0575             ctl->bytes_ext.get = wm_coeff_tlv_get;
0576             ctl->bytes_ext.put = wm_coeff_tlv_put;
0577         } else {
0578             kcontrol->get = wm_coeff_get;
0579             kcontrol->put = wm_coeff_put;
0580         }
0581         break;
0582     }
0583 
0584     snd_soc_add_component_controls(dsp->component, kcontrol, 1);
0585 
0586     kfree(kcontrol);
0587 }
0588 
0589 static int wm_adsp_control_add(struct cs_dsp_coeff_ctl *cs_ctl)
0590 {
0591     struct wm_adsp *dsp = container_of(cs_ctl->dsp, struct wm_adsp, cs_dsp);
0592     struct cs_dsp *cs_dsp = &dsp->cs_dsp;
0593     struct wm_coeff_ctl *ctl;
0594     char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
0595     const char *region_name;
0596     int ret;
0597 
0598     if (cs_ctl->flags & WMFW_CTL_FLAG_SYS)
0599         return 0;
0600 
0601     region_name = cs_dsp_mem_region_name(cs_ctl->alg_region.type);
0602     if (!region_name) {
0603         adsp_err(dsp, "Unknown region type: %d\n", cs_ctl->alg_region.type);
0604         return -EINVAL;
0605     }
0606 
0607     switch (cs_dsp->fw_ver) {
0608     case 0:
0609     case 1:
0610         ret = scnprintf(name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN,
0611                 "%s %s %x", cs_dsp->name, region_name,
0612                 cs_ctl->alg_region.alg);
0613         break;
0614     case 2:
0615         ret = scnprintf(name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN,
0616                 "%s%c %.12s %x", cs_dsp->name, *region_name,
0617                 wm_adsp_fw_text[dsp->fw], cs_ctl->alg_region.alg);
0618         break;
0619     default:
0620         ret = scnprintf(name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN,
0621                 "%s %.12s %x", cs_dsp->name,
0622                 wm_adsp_fw_text[dsp->fw], cs_ctl->alg_region.alg);
0623         break;
0624     }
0625 
0626     if (cs_ctl->subname) {
0627         int avail = SNDRV_CTL_ELEM_ID_NAME_MAXLEN - ret - 2;
0628         int skip = 0;
0629 
0630         if (dsp->component->name_prefix)
0631             avail -= strlen(dsp->component->name_prefix) + 1;
0632 
0633         /* Truncate the subname from the start if it is too long */
0634         if (cs_ctl->subname_len > avail)
0635             skip = cs_ctl->subname_len - avail;
0636 
0637         snprintf(name + ret, SNDRV_CTL_ELEM_ID_NAME_MAXLEN - ret,
0638              " %.*s", cs_ctl->subname_len - skip, cs_ctl->subname + skip);
0639     }
0640 
0641     ctl = kzalloc(sizeof(*ctl), GFP_KERNEL);
0642     if (!ctl)
0643         return -ENOMEM;
0644     ctl->cs_ctl = cs_ctl;
0645 
0646     ctl->name = kmemdup(name, strlen(name) + 1, GFP_KERNEL);
0647     if (!ctl->name) {
0648         ret = -ENOMEM;
0649         goto err_ctl;
0650     }
0651 
0652     cs_ctl->priv = ctl;
0653 
0654     INIT_WORK(&ctl->work, wm_adsp_ctl_work);
0655     schedule_work(&ctl->work);
0656 
0657     return 0;
0658 
0659 err_ctl:
0660     kfree(ctl);
0661 
0662     return ret;
0663 }
0664 
0665 static void wm_adsp_control_remove(struct cs_dsp_coeff_ctl *cs_ctl)
0666 {
0667     struct wm_coeff_ctl *ctl = cs_ctl->priv;
0668 
0669     cancel_work_sync(&ctl->work);
0670 
0671     kfree(ctl->name);
0672     kfree(ctl);
0673 }
0674 
0675 int wm_adsp_write_ctl(struct wm_adsp *dsp, const char *name, int type,
0676               unsigned int alg, void *buf, size_t len)
0677 {
0678     struct cs_dsp_coeff_ctl *cs_ctl = cs_dsp_get_ctl(&dsp->cs_dsp, name, type, alg);
0679     struct wm_coeff_ctl *ctl;
0680     struct snd_kcontrol *kcontrol;
0681     char ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
0682     int ret;
0683 
0684     ret = cs_dsp_coeff_write_ctrl(cs_ctl, 0, buf, len);
0685     if (ret)
0686         return ret;
0687 
0688     if (cs_ctl->flags & WMFW_CTL_FLAG_SYS)
0689         return 0;
0690 
0691     ctl = cs_ctl->priv;
0692 
0693     if (dsp->component->name_prefix)
0694         snprintf(ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s %s",
0695              dsp->component->name_prefix, ctl->name);
0696     else
0697         snprintf(ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s",
0698              ctl->name);
0699 
0700     kcontrol = snd_soc_card_get_kcontrol(dsp->component->card, ctl_name);
0701     if (!kcontrol) {
0702         adsp_err(dsp, "Can't find kcontrol %s\n", ctl_name);
0703         return -EINVAL;
0704     }
0705 
0706     snd_ctl_notify(dsp->component->card->snd_card,
0707                SNDRV_CTL_EVENT_MASK_VALUE, &kcontrol->id);
0708 
0709     return 0;
0710 }
0711 EXPORT_SYMBOL_GPL(wm_adsp_write_ctl);
0712 
0713 int wm_adsp_read_ctl(struct wm_adsp *dsp, const char *name, int type,
0714              unsigned int alg, void *buf, size_t len)
0715 {
0716     return cs_dsp_coeff_read_ctrl(cs_dsp_get_ctl(&dsp->cs_dsp, name, type, alg),
0717                       0, buf, len);
0718 }
0719 EXPORT_SYMBOL_GPL(wm_adsp_read_ctl);
0720 
0721 static void wm_adsp_release_firmware_files(struct wm_adsp *dsp,
0722                        const struct firmware *wmfw_firmware,
0723                        char *wmfw_filename,
0724                        const struct firmware *coeff_firmware,
0725                        char *coeff_filename)
0726 {
0727     if (wmfw_firmware)
0728         release_firmware(wmfw_firmware);
0729     kfree(wmfw_filename);
0730 
0731     if (coeff_firmware)
0732         release_firmware(coeff_firmware);
0733     kfree(coeff_filename);
0734 }
0735 
0736 static int wm_adsp_request_firmware_file(struct wm_adsp *dsp,
0737                      const struct firmware **firmware, char **filename,
0738                      const char *dir, const char *system_name,
0739                      const char *asoc_component_prefix,
0740                      const char *filetype)
0741 {
0742     struct cs_dsp *cs_dsp = &dsp->cs_dsp;
0743     char *s, c;
0744     int ret = 0;
0745 
0746     if (system_name && asoc_component_prefix)
0747         *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s-%s.%s", dir, dsp->part,
0748                       dsp->fwf_name, wm_adsp_fw[dsp->fw].file, system_name,
0749                       asoc_component_prefix, filetype);
0750     else if (system_name)
0751         *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s.%s", dir, dsp->part,
0752                       dsp->fwf_name, wm_adsp_fw[dsp->fw].file, system_name,
0753                       filetype);
0754     else
0755         *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s.%s", dir, dsp->part, dsp->fwf_name,
0756                       wm_adsp_fw[dsp->fw].file, filetype);
0757 
0758     if (*filename == NULL)
0759         return -ENOMEM;
0760 
0761     /*
0762      * Make sure that filename is lower-case and any non alpha-numeric
0763      * characters except full stop and forward slash are replaced with
0764      * hyphens.
0765      */
0766     s = *filename;
0767     while (*s) {
0768         c = *s;
0769         if (isalnum(c))
0770             *s = tolower(c);
0771         else if ((c != '.') && (c != '/'))
0772             *s = '-';
0773         s++;
0774     }
0775 
0776     ret = firmware_request_nowarn(firmware, *filename, cs_dsp->dev);
0777     if (ret != 0) {
0778         adsp_dbg(dsp, "Failed to request '%s'\n", *filename);
0779         kfree(*filename);
0780         *filename = NULL;
0781     }
0782 
0783     return ret;
0784 }
0785 
0786 static const char *cirrus_dir = "cirrus/";
0787 static int wm_adsp_request_firmware_files(struct wm_adsp *dsp,
0788                       const struct firmware **wmfw_firmware,
0789                       char **wmfw_filename,
0790                       const struct firmware **coeff_firmware,
0791                       char **coeff_filename)
0792 {
0793     const char *system_name = dsp->system_name;
0794     const char *asoc_component_prefix = dsp->component->name_prefix;
0795     int ret = 0;
0796 
0797     if (system_name && asoc_component_prefix) {
0798         if (!wm_adsp_request_firmware_file(dsp, wmfw_firmware, wmfw_filename,
0799                            cirrus_dir, system_name,
0800                            asoc_component_prefix, "wmfw")) {
0801             adsp_dbg(dsp, "Found '%s'\n", *wmfw_filename);
0802             wm_adsp_request_firmware_file(dsp, coeff_firmware, coeff_filename,
0803                               cirrus_dir, system_name,
0804                               asoc_component_prefix, "bin");
0805             return 0;
0806         }
0807     }
0808 
0809     if (system_name) {
0810         if (!wm_adsp_request_firmware_file(dsp, wmfw_firmware, wmfw_filename,
0811                            cirrus_dir, system_name,
0812                            NULL, "wmfw")) {
0813             adsp_dbg(dsp, "Found '%s'\n", *wmfw_filename);
0814             if (asoc_component_prefix)
0815                 wm_adsp_request_firmware_file(dsp, coeff_firmware, coeff_filename,
0816                                   cirrus_dir, system_name,
0817                                   asoc_component_prefix, "bin");
0818 
0819             if (!*coeff_firmware)
0820                 wm_adsp_request_firmware_file(dsp, coeff_firmware, coeff_filename,
0821                                   cirrus_dir, system_name,
0822                                   NULL, "bin");
0823             return 0;
0824         }
0825     }
0826 
0827     if (!wm_adsp_request_firmware_file(dsp, wmfw_firmware, wmfw_filename,
0828                        "", NULL, NULL, "wmfw")) {
0829         adsp_dbg(dsp, "Found '%s'\n", *wmfw_filename);
0830         wm_adsp_request_firmware_file(dsp, coeff_firmware, coeff_filename,
0831                           "", NULL, NULL, "bin");
0832         return 0;
0833     }
0834 
0835     ret = wm_adsp_request_firmware_file(dsp, wmfw_firmware, wmfw_filename,
0836                         cirrus_dir, NULL, NULL, "wmfw");
0837     if (!ret) {
0838         adsp_dbg(dsp, "Found '%s'\n", *wmfw_filename);
0839         wm_adsp_request_firmware_file(dsp, coeff_firmware, coeff_filename,
0840                           cirrus_dir, NULL, NULL, "bin");
0841         return 0;
0842     }
0843 
0844     adsp_err(dsp, "Failed to request firmware <%s>%s-%s-%s<-%s<%s>>.wmfw\n",
0845          cirrus_dir, dsp->part, dsp->fwf_name, wm_adsp_fw[dsp->fw].file,
0846          system_name, asoc_component_prefix);
0847 
0848     return -ENOENT;
0849 }
0850 
0851 static int wm_adsp_common_init(struct wm_adsp *dsp)
0852 {
0853     char *p;
0854 
0855     INIT_LIST_HEAD(&dsp->compr_list);
0856     INIT_LIST_HEAD(&dsp->buffer_list);
0857 
0858     if (!dsp->fwf_name) {
0859         p = devm_kstrdup(dsp->cs_dsp.dev, dsp->cs_dsp.name, GFP_KERNEL);
0860         if (!p)
0861             return -ENOMEM;
0862 
0863         dsp->fwf_name = p;
0864         for (; *p != 0; ++p)
0865             *p = tolower(*p);
0866     }
0867 
0868     return 0;
0869 }
0870 
0871 int wm_adsp1_init(struct wm_adsp *dsp)
0872 {
0873     int ret;
0874 
0875     dsp->cs_dsp.client_ops = &wm_adsp1_client_ops;
0876 
0877     ret = cs_dsp_adsp1_init(&dsp->cs_dsp);
0878     if (ret)
0879         return ret;
0880 
0881     return wm_adsp_common_init(dsp);
0882 }
0883 EXPORT_SYMBOL_GPL(wm_adsp1_init);
0884 
0885 int wm_adsp1_event(struct snd_soc_dapm_widget *w,
0886            struct snd_kcontrol *kcontrol,
0887            int event)
0888 {
0889     struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
0890     struct wm_adsp *dsps = snd_soc_component_get_drvdata(component);
0891     struct wm_adsp *dsp = &dsps[w->shift];
0892     int ret = 0;
0893     char *wmfw_filename = NULL;
0894     const struct firmware *wmfw_firmware = NULL;
0895     char *coeff_filename = NULL;
0896     const struct firmware *coeff_firmware = NULL;
0897 
0898     dsp->component = component;
0899 
0900     switch (event) {
0901     case SND_SOC_DAPM_POST_PMU:
0902         ret = wm_adsp_request_firmware_files(dsp,
0903                              &wmfw_firmware, &wmfw_filename,
0904                              &coeff_firmware, &coeff_filename);
0905         if (ret)
0906             break;
0907 
0908         ret = cs_dsp_adsp1_power_up(&dsp->cs_dsp,
0909                         wmfw_firmware, wmfw_filename,
0910                         coeff_firmware, coeff_filename,
0911                         wm_adsp_fw_text[dsp->fw]);
0912 
0913         wm_adsp_release_firmware_files(dsp,
0914                            wmfw_firmware, wmfw_filename,
0915                            coeff_firmware, coeff_filename);
0916         break;
0917     case SND_SOC_DAPM_PRE_PMD:
0918         cs_dsp_adsp1_power_down(&dsp->cs_dsp);
0919         break;
0920     default:
0921         break;
0922     }
0923 
0924     return ret;
0925 }
0926 EXPORT_SYMBOL_GPL(wm_adsp1_event);
0927 
0928 int wm_adsp2_set_dspclk(struct snd_soc_dapm_widget *w, unsigned int freq)
0929 {
0930     struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
0931     struct wm_adsp *dsps = snd_soc_component_get_drvdata(component);
0932     struct wm_adsp *dsp = &dsps[w->shift];
0933 
0934     return cs_dsp_set_dspclk(&dsp->cs_dsp, freq);
0935 }
0936 EXPORT_SYMBOL_GPL(wm_adsp2_set_dspclk);
0937 
0938 int wm_adsp2_preloader_get(struct snd_kcontrol *kcontrol,
0939                struct snd_ctl_elem_value *ucontrol)
0940 {
0941     struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
0942     struct wm_adsp *dsps = snd_soc_component_get_drvdata(component);
0943     struct soc_mixer_control *mc =
0944         (struct soc_mixer_control *)kcontrol->private_value;
0945     struct wm_adsp *dsp = &dsps[mc->shift - 1];
0946 
0947     ucontrol->value.integer.value[0] = dsp->preloaded;
0948 
0949     return 0;
0950 }
0951 EXPORT_SYMBOL_GPL(wm_adsp2_preloader_get);
0952 
0953 int wm_adsp2_preloader_put(struct snd_kcontrol *kcontrol,
0954                struct snd_ctl_elem_value *ucontrol)
0955 {
0956     struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
0957     struct wm_adsp *dsps = snd_soc_component_get_drvdata(component);
0958     struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
0959     struct soc_mixer_control *mc =
0960         (struct soc_mixer_control *)kcontrol->private_value;
0961     struct wm_adsp *dsp = &dsps[mc->shift - 1];
0962     char preload[32];
0963 
0964     if (dsp->preloaded == ucontrol->value.integer.value[0])
0965         return 0;
0966 
0967     snprintf(preload, ARRAY_SIZE(preload), "%s Preload", dsp->cs_dsp.name);
0968 
0969     if (ucontrol->value.integer.value[0] || dsp->toggle_preload)
0970         snd_soc_component_force_enable_pin(component, preload);
0971     else
0972         snd_soc_component_disable_pin(component, preload);
0973 
0974     snd_soc_dapm_sync(dapm);
0975 
0976     flush_work(&dsp->boot_work);
0977 
0978     dsp->preloaded = ucontrol->value.integer.value[0];
0979 
0980     if (dsp->toggle_preload) {
0981         snd_soc_component_disable_pin(component, preload);
0982         snd_soc_dapm_sync(dapm);
0983     }
0984 
0985     return 1;
0986 }
0987 EXPORT_SYMBOL_GPL(wm_adsp2_preloader_put);
0988 
0989 static void wm_adsp_boot_work(struct work_struct *work)
0990 {
0991     struct wm_adsp *dsp = container_of(work,
0992                        struct wm_adsp,
0993                        boot_work);
0994     int ret = 0;
0995     char *wmfw_filename = NULL;
0996     const struct firmware *wmfw_firmware = NULL;
0997     char *coeff_filename = NULL;
0998     const struct firmware *coeff_firmware = NULL;
0999 
1000     ret = wm_adsp_request_firmware_files(dsp,
1001                          &wmfw_firmware, &wmfw_filename,
1002                          &coeff_firmware, &coeff_filename);
1003     if (ret)
1004         return;
1005 
1006     cs_dsp_power_up(&dsp->cs_dsp,
1007             wmfw_firmware, wmfw_filename,
1008             coeff_firmware, coeff_filename,
1009             wm_adsp_fw_text[dsp->fw]);
1010 
1011     wm_adsp_release_firmware_files(dsp,
1012                        wmfw_firmware, wmfw_filename,
1013                        coeff_firmware, coeff_filename);
1014 }
1015 
1016 int wm_adsp_early_event(struct snd_soc_dapm_widget *w,
1017             struct snd_kcontrol *kcontrol, int event)
1018 {
1019     struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1020     struct wm_adsp *dsps = snd_soc_component_get_drvdata(component);
1021     struct wm_adsp *dsp = &dsps[w->shift];
1022 
1023     switch (event) {
1024     case SND_SOC_DAPM_PRE_PMU:
1025         queue_work(system_unbound_wq, &dsp->boot_work);
1026         break;
1027     case SND_SOC_DAPM_PRE_PMD:
1028         cs_dsp_power_down(&dsp->cs_dsp);
1029         break;
1030     default:
1031         break;
1032     }
1033 
1034     return 0;
1035 }
1036 EXPORT_SYMBOL_GPL(wm_adsp_early_event);
1037 
1038 static int wm_adsp_event_post_run(struct cs_dsp *cs_dsp)
1039 {
1040     struct wm_adsp *dsp = container_of(cs_dsp, struct wm_adsp, cs_dsp);
1041 
1042     if (wm_adsp_fw[dsp->fw].num_caps != 0)
1043         return wm_adsp_buffer_init(dsp);
1044 
1045     return 0;
1046 }
1047 
1048 static void wm_adsp_event_post_stop(struct cs_dsp *cs_dsp)
1049 {
1050     struct wm_adsp *dsp = container_of(cs_dsp, struct wm_adsp, cs_dsp);
1051 
1052     if (wm_adsp_fw[dsp->fw].num_caps != 0)
1053         wm_adsp_buffer_free(dsp);
1054 
1055     dsp->fatal_error = false;
1056 }
1057 
1058 int wm_adsp_event(struct snd_soc_dapm_widget *w,
1059           struct snd_kcontrol *kcontrol, int event)
1060 {
1061     struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1062     struct wm_adsp *dsps = snd_soc_component_get_drvdata(component);
1063     struct wm_adsp *dsp = &dsps[w->shift];
1064     int ret = 0;
1065 
1066     switch (event) {
1067     case SND_SOC_DAPM_POST_PMU:
1068         flush_work(&dsp->boot_work);
1069         ret = cs_dsp_run(&dsp->cs_dsp);
1070         break;
1071     case SND_SOC_DAPM_PRE_PMD:
1072         cs_dsp_stop(&dsp->cs_dsp);
1073         break;
1074     default:
1075         break;
1076     }
1077 
1078     return ret;
1079 }
1080 EXPORT_SYMBOL_GPL(wm_adsp_event);
1081 
1082 int wm_adsp2_component_probe(struct wm_adsp *dsp, struct snd_soc_component *component)
1083 {
1084     char preload[32];
1085 
1086     snprintf(preload, ARRAY_SIZE(preload), "%s Preload", dsp->cs_dsp.name);
1087     snd_soc_component_disable_pin(component, preload);
1088 
1089     cs_dsp_init_debugfs(&dsp->cs_dsp, component->debugfs_root);
1090 
1091     dsp->component = component;
1092 
1093     return 0;
1094 }
1095 EXPORT_SYMBOL_GPL(wm_adsp2_component_probe);
1096 
1097 int wm_adsp2_component_remove(struct wm_adsp *dsp, struct snd_soc_component *component)
1098 {
1099     cs_dsp_cleanup_debugfs(&dsp->cs_dsp);
1100 
1101     return 0;
1102 }
1103 EXPORT_SYMBOL_GPL(wm_adsp2_component_remove);
1104 
1105 int wm_adsp2_init(struct wm_adsp *dsp)
1106 {
1107     int ret;
1108 
1109     INIT_WORK(&dsp->boot_work, wm_adsp_boot_work);
1110 
1111     dsp->sys_config_size = sizeof(struct wm_adsp_system_config_xm_hdr);
1112     dsp->cs_dsp.client_ops = &wm_adsp2_client_ops;
1113 
1114     ret = cs_dsp_adsp2_init(&dsp->cs_dsp);
1115     if (ret)
1116         return ret;
1117 
1118     return wm_adsp_common_init(dsp);
1119 }
1120 EXPORT_SYMBOL_GPL(wm_adsp2_init);
1121 
1122 int wm_halo_init(struct wm_adsp *dsp)
1123 {
1124     int ret;
1125 
1126     INIT_WORK(&dsp->boot_work, wm_adsp_boot_work);
1127 
1128     dsp->sys_config_size = sizeof(struct wm_halo_system_config_xm_hdr);
1129     dsp->cs_dsp.client_ops = &wm_adsp2_client_ops;
1130 
1131     ret = cs_dsp_halo_init(&dsp->cs_dsp);
1132     if (ret)
1133         return ret;
1134 
1135     return wm_adsp_common_init(dsp);
1136 }
1137 EXPORT_SYMBOL_GPL(wm_halo_init);
1138 
1139 void wm_adsp2_remove(struct wm_adsp *dsp)
1140 {
1141     cs_dsp_remove(&dsp->cs_dsp);
1142 }
1143 EXPORT_SYMBOL_GPL(wm_adsp2_remove);
1144 
1145 static inline int wm_adsp_compr_attached(struct wm_adsp_compr *compr)
1146 {
1147     return compr->buf != NULL;
1148 }
1149 
1150 static int wm_adsp_compr_attach(struct wm_adsp_compr *compr)
1151 {
1152     struct wm_adsp_compr_buf *buf = NULL, *tmp;
1153 
1154     if (compr->dsp->fatal_error)
1155         return -EINVAL;
1156 
1157     list_for_each_entry(tmp, &compr->dsp->buffer_list, list) {
1158         if (!tmp->name || !strcmp(compr->name, tmp->name)) {
1159             buf = tmp;
1160             break;
1161         }
1162     }
1163 
1164     if (!buf)
1165         return -EINVAL;
1166 
1167     compr->buf = buf;
1168     buf->compr = compr;
1169 
1170     return 0;
1171 }
1172 
1173 static void wm_adsp_compr_detach(struct wm_adsp_compr *compr)
1174 {
1175     if (!compr)
1176         return;
1177 
1178     /* Wake the poll so it can see buffer is no longer attached */
1179     if (compr->stream)
1180         snd_compr_fragment_elapsed(compr->stream);
1181 
1182     if (wm_adsp_compr_attached(compr)) {
1183         compr->buf->compr = NULL;
1184         compr->buf = NULL;
1185     }
1186 }
1187 
1188 int wm_adsp_compr_open(struct wm_adsp *dsp, struct snd_compr_stream *stream)
1189 {
1190     struct wm_adsp_compr *compr, *tmp;
1191     struct snd_soc_pcm_runtime *rtd = stream->private_data;
1192     int ret = 0;
1193 
1194     mutex_lock(&dsp->cs_dsp.pwr_lock);
1195 
1196     if (wm_adsp_fw[dsp->fw].num_caps == 0) {
1197         adsp_err(dsp, "%s: Firmware does not support compressed API\n",
1198              asoc_rtd_to_codec(rtd, 0)->name);
1199         ret = -ENXIO;
1200         goto out;
1201     }
1202 
1203     if (wm_adsp_fw[dsp->fw].compr_direction != stream->direction) {
1204         adsp_err(dsp, "%s: Firmware does not support stream direction\n",
1205              asoc_rtd_to_codec(rtd, 0)->name);
1206         ret = -EINVAL;
1207         goto out;
1208     }
1209 
1210     list_for_each_entry(tmp, &dsp->compr_list, list) {
1211         if (!strcmp(tmp->name, asoc_rtd_to_codec(rtd, 0)->name)) {
1212             adsp_err(dsp, "%s: Only a single stream supported per dai\n",
1213                  asoc_rtd_to_codec(rtd, 0)->name);
1214             ret = -EBUSY;
1215             goto out;
1216         }
1217     }
1218 
1219     compr = kzalloc(sizeof(*compr), GFP_KERNEL);
1220     if (!compr) {
1221         ret = -ENOMEM;
1222         goto out;
1223     }
1224 
1225     compr->dsp = dsp;
1226     compr->stream = stream;
1227     compr->name = asoc_rtd_to_codec(rtd, 0)->name;
1228 
1229     list_add_tail(&compr->list, &dsp->compr_list);
1230 
1231     stream->runtime->private_data = compr;
1232 
1233 out:
1234     mutex_unlock(&dsp->cs_dsp.pwr_lock);
1235 
1236     return ret;
1237 }
1238 EXPORT_SYMBOL_GPL(wm_adsp_compr_open);
1239 
1240 int wm_adsp_compr_free(struct snd_soc_component *component,
1241                struct snd_compr_stream *stream)
1242 {
1243     struct wm_adsp_compr *compr = stream->runtime->private_data;
1244     struct wm_adsp *dsp = compr->dsp;
1245 
1246     mutex_lock(&dsp->cs_dsp.pwr_lock);
1247 
1248     wm_adsp_compr_detach(compr);
1249     list_del(&compr->list);
1250 
1251     kfree(compr->raw_buf);
1252     kfree(compr);
1253 
1254     mutex_unlock(&dsp->cs_dsp.pwr_lock);
1255 
1256     return 0;
1257 }
1258 EXPORT_SYMBOL_GPL(wm_adsp_compr_free);
1259 
1260 static int wm_adsp_compr_check_params(struct snd_compr_stream *stream,
1261                       struct snd_compr_params *params)
1262 {
1263     struct wm_adsp_compr *compr = stream->runtime->private_data;
1264     struct wm_adsp *dsp = compr->dsp;
1265     const struct wm_adsp_fw_caps *caps;
1266     const struct snd_codec_desc *desc;
1267     int i, j;
1268 
1269     if (params->buffer.fragment_size < WM_ADSP_MIN_FRAGMENT_SIZE ||
1270         params->buffer.fragment_size > WM_ADSP_MAX_FRAGMENT_SIZE ||
1271         params->buffer.fragments < WM_ADSP_MIN_FRAGMENTS ||
1272         params->buffer.fragments > WM_ADSP_MAX_FRAGMENTS ||
1273         params->buffer.fragment_size % CS_DSP_DATA_WORD_SIZE) {
1274         compr_err(compr, "Invalid buffer fragsize=%d fragments=%d\n",
1275               params->buffer.fragment_size,
1276               params->buffer.fragments);
1277 
1278         return -EINVAL;
1279     }
1280 
1281     for (i = 0; i < wm_adsp_fw[dsp->fw].num_caps; i++) {
1282         caps = &wm_adsp_fw[dsp->fw].caps[i];
1283         desc = &caps->desc;
1284 
1285         if (caps->id != params->codec.id)
1286             continue;
1287 
1288         if (stream->direction == SND_COMPRESS_PLAYBACK) {
1289             if (desc->max_ch < params->codec.ch_out)
1290                 continue;
1291         } else {
1292             if (desc->max_ch < params->codec.ch_in)
1293                 continue;
1294         }
1295 
1296         if (!(desc->formats & (1 << params->codec.format)))
1297             continue;
1298 
1299         for (j = 0; j < desc->num_sample_rates; ++j)
1300             if (desc->sample_rates[j] == params->codec.sample_rate)
1301                 return 0;
1302     }
1303 
1304     compr_err(compr, "Invalid params id=%u ch=%u,%u rate=%u fmt=%u\n",
1305           params->codec.id, params->codec.ch_in, params->codec.ch_out,
1306           params->codec.sample_rate, params->codec.format);
1307     return -EINVAL;
1308 }
1309 
1310 static inline unsigned int wm_adsp_compr_frag_words(struct wm_adsp_compr *compr)
1311 {
1312     return compr->size.fragment_size / CS_DSP_DATA_WORD_SIZE;
1313 }
1314 
1315 int wm_adsp_compr_set_params(struct snd_soc_component *component,
1316                  struct snd_compr_stream *stream,
1317                  struct snd_compr_params *params)
1318 {
1319     struct wm_adsp_compr *compr = stream->runtime->private_data;
1320     unsigned int size;
1321     int ret;
1322 
1323     ret = wm_adsp_compr_check_params(stream, params);
1324     if (ret)
1325         return ret;
1326 
1327     compr->size = params->buffer;
1328 
1329     compr_dbg(compr, "fragment_size=%d fragments=%d\n",
1330           compr->size.fragment_size, compr->size.fragments);
1331 
1332     size = wm_adsp_compr_frag_words(compr) * sizeof(*compr->raw_buf);
1333     compr->raw_buf = kmalloc(size, GFP_DMA | GFP_KERNEL);
1334     if (!compr->raw_buf)
1335         return -ENOMEM;
1336 
1337     compr->sample_rate = params->codec.sample_rate;
1338 
1339     return 0;
1340 }
1341 EXPORT_SYMBOL_GPL(wm_adsp_compr_set_params);
1342 
1343 int wm_adsp_compr_get_caps(struct snd_soc_component *component,
1344                struct snd_compr_stream *stream,
1345                struct snd_compr_caps *caps)
1346 {
1347     struct wm_adsp_compr *compr = stream->runtime->private_data;
1348     int fw = compr->dsp->fw;
1349     int i;
1350 
1351     if (wm_adsp_fw[fw].caps) {
1352         for (i = 0; i < wm_adsp_fw[fw].num_caps; i++)
1353             caps->codecs[i] = wm_adsp_fw[fw].caps[i].id;
1354 
1355         caps->num_codecs = i;
1356         caps->direction = wm_adsp_fw[fw].compr_direction;
1357 
1358         caps->min_fragment_size = WM_ADSP_MIN_FRAGMENT_SIZE;
1359         caps->max_fragment_size = WM_ADSP_MAX_FRAGMENT_SIZE;
1360         caps->min_fragments = WM_ADSP_MIN_FRAGMENTS;
1361         caps->max_fragments = WM_ADSP_MAX_FRAGMENTS;
1362     }
1363 
1364     return 0;
1365 }
1366 EXPORT_SYMBOL_GPL(wm_adsp_compr_get_caps);
1367 
1368 static inline int wm_adsp_buffer_read(struct wm_adsp_compr_buf *buf,
1369                       unsigned int field_offset, u32 *data)
1370 {
1371     return cs_dsp_read_data_word(&buf->dsp->cs_dsp, buf->host_buf_mem_type,
1372                      buf->host_buf_ptr + field_offset, data);
1373 }
1374 
1375 static inline int wm_adsp_buffer_write(struct wm_adsp_compr_buf *buf,
1376                        unsigned int field_offset, u32 data)
1377 {
1378     return cs_dsp_write_data_word(&buf->dsp->cs_dsp, buf->host_buf_mem_type,
1379                       buf->host_buf_ptr + field_offset,
1380                       data);
1381 }
1382 
1383 static int wm_adsp_buffer_populate(struct wm_adsp_compr_buf *buf)
1384 {
1385     const struct wm_adsp_fw_caps *caps = wm_adsp_fw[buf->dsp->fw].caps;
1386     struct wm_adsp_buffer_region *region;
1387     u32 offset = 0;
1388     int i, ret;
1389 
1390     buf->regions = kcalloc(caps->num_regions, sizeof(*buf->regions),
1391                    GFP_KERNEL);
1392     if (!buf->regions)
1393         return -ENOMEM;
1394 
1395     for (i = 0; i < caps->num_regions; ++i) {
1396         region = &buf->regions[i];
1397 
1398         region->offset = offset;
1399         region->mem_type = caps->region_defs[i].mem_type;
1400 
1401         ret = wm_adsp_buffer_read(buf, caps->region_defs[i].base_offset,
1402                       &region->base_addr);
1403         if (ret < 0)
1404             return ret;
1405 
1406         ret = wm_adsp_buffer_read(buf, caps->region_defs[i].size_offset,
1407                       &offset);
1408         if (ret < 0)
1409             return ret;
1410 
1411         region->cumulative_size = offset;
1412 
1413         compr_dbg(buf,
1414               "region=%d type=%d base=%08x off=%08x size=%08x\n",
1415               i, region->mem_type, region->base_addr,
1416               region->offset, region->cumulative_size);
1417     }
1418 
1419     return 0;
1420 }
1421 
1422 static void wm_adsp_buffer_clear(struct wm_adsp_compr_buf *buf)
1423 {
1424     buf->irq_count = 0xFFFFFFFF;
1425     buf->read_index = -1;
1426     buf->avail = 0;
1427 }
1428 
1429 static struct wm_adsp_compr_buf *wm_adsp_buffer_alloc(struct wm_adsp *dsp)
1430 {
1431     struct wm_adsp_compr_buf *buf;
1432 
1433     buf = kzalloc(sizeof(*buf), GFP_KERNEL);
1434     if (!buf)
1435         return NULL;
1436 
1437     buf->dsp = dsp;
1438 
1439     wm_adsp_buffer_clear(buf);
1440 
1441     return buf;
1442 }
1443 
1444 static int wm_adsp_buffer_parse_legacy(struct wm_adsp *dsp)
1445 {
1446     struct cs_dsp_alg_region *alg_region;
1447     struct wm_adsp_compr_buf *buf;
1448     u32 xmalg, addr, magic;
1449     int i, ret;
1450 
1451     alg_region = cs_dsp_find_alg_region(&dsp->cs_dsp, WMFW_ADSP2_XM, dsp->cs_dsp.fw_id);
1452     if (!alg_region) {
1453         adsp_err(dsp, "No algorithm region found\n");
1454         return -EINVAL;
1455     }
1456 
1457     xmalg = dsp->sys_config_size / sizeof(__be32);
1458 
1459     addr = alg_region->base + xmalg + ALG_XM_FIELD(magic);
1460     ret = cs_dsp_read_data_word(&dsp->cs_dsp, WMFW_ADSP2_XM, addr, &magic);
1461     if (ret < 0)
1462         return ret;
1463 
1464     if (magic != WM_ADSP_ALG_XM_STRUCT_MAGIC)
1465         return -ENODEV;
1466 
1467     buf = wm_adsp_buffer_alloc(dsp);
1468     if (!buf)
1469         return -ENOMEM;
1470 
1471     addr = alg_region->base + xmalg + ALG_XM_FIELD(host_buf_ptr);
1472     for (i = 0; i < 5; ++i) {
1473         ret = cs_dsp_read_data_word(&dsp->cs_dsp, WMFW_ADSP2_XM, addr,
1474                         &buf->host_buf_ptr);
1475         if (ret < 0)
1476             goto err;
1477 
1478         if (buf->host_buf_ptr)
1479             break;
1480 
1481         usleep_range(1000, 2000);
1482     }
1483 
1484     if (!buf->host_buf_ptr) {
1485         ret = -EIO;
1486         goto err;
1487     }
1488 
1489     buf->host_buf_mem_type = WMFW_ADSP2_XM;
1490 
1491     ret = wm_adsp_buffer_populate(buf);
1492     if (ret < 0)
1493         goto err;
1494 
1495     list_add_tail(&buf->list, &dsp->buffer_list);
1496 
1497     compr_dbg(buf, "legacy host_buf_ptr=%x\n", buf->host_buf_ptr);
1498 
1499     return 0;
1500 
1501 err:
1502     kfree(buf);
1503 
1504     return ret;
1505 }
1506 
1507 static int wm_adsp_buffer_parse_coeff(struct cs_dsp_coeff_ctl *cs_ctl)
1508 {
1509     struct wm_adsp_host_buf_coeff_v1 coeff_v1;
1510     struct wm_adsp_compr_buf *buf;
1511     struct wm_adsp *dsp = container_of(cs_ctl->dsp, struct wm_adsp, cs_dsp);
1512     unsigned int version = 0;
1513     int ret, i;
1514 
1515     for (i = 0; i < 5; ++i) {
1516         ret = cs_dsp_coeff_read_ctrl(cs_ctl, 0, &coeff_v1,
1517                          min(cs_ctl->len, sizeof(coeff_v1)));
1518         if (ret < 0)
1519             return ret;
1520 
1521         if (coeff_v1.host_buf_ptr)
1522             break;
1523 
1524         usleep_range(1000, 2000);
1525     }
1526 
1527     if (!coeff_v1.host_buf_ptr) {
1528         adsp_err(dsp, "Failed to acquire host buffer\n");
1529         return -EIO;
1530     }
1531 
1532     buf = wm_adsp_buffer_alloc(dsp);
1533     if (!buf)
1534         return -ENOMEM;
1535 
1536     buf->host_buf_mem_type = cs_ctl->alg_region.type;
1537     buf->host_buf_ptr = be32_to_cpu(coeff_v1.host_buf_ptr);
1538 
1539     ret = wm_adsp_buffer_populate(buf);
1540     if (ret < 0)
1541         goto err;
1542 
1543     /*
1544      * v0 host_buffer coefficients didn't have versioning, so if the
1545      * control is one word, assume version 0.
1546      */
1547     if (cs_ctl->len == 4)
1548         goto done;
1549 
1550     version = be32_to_cpu(coeff_v1.versions) & HOST_BUF_COEFF_COMPAT_VER_MASK;
1551     version >>= HOST_BUF_COEFF_COMPAT_VER_SHIFT;
1552 
1553     if (version > HOST_BUF_COEFF_SUPPORTED_COMPAT_VER) {
1554         adsp_err(dsp,
1555              "Host buffer coeff ver %u > supported version %u\n",
1556              version, HOST_BUF_COEFF_SUPPORTED_COMPAT_VER);
1557         ret = -EINVAL;
1558         goto err;
1559     }
1560 
1561     cs_dsp_remove_padding((u32 *)&coeff_v1.name, ARRAY_SIZE(coeff_v1.name));
1562 
1563     buf->name = kasprintf(GFP_KERNEL, "%s-dsp-%s", dsp->part,
1564                   (char *)&coeff_v1.name);
1565 
1566 done:
1567     list_add_tail(&buf->list, &dsp->buffer_list);
1568 
1569     compr_dbg(buf, "host_buf_ptr=%x coeff version %u\n",
1570           buf->host_buf_ptr, version);
1571 
1572     return version;
1573 
1574 err:
1575     kfree(buf);
1576 
1577     return ret;
1578 }
1579 
1580 static int wm_adsp_buffer_init(struct wm_adsp *dsp)
1581 {
1582     struct cs_dsp_coeff_ctl *cs_ctl;
1583     int ret;
1584 
1585     list_for_each_entry(cs_ctl, &dsp->cs_dsp.ctl_list, list) {
1586         if (cs_ctl->type != WMFW_CTL_TYPE_HOST_BUFFER)
1587             continue;
1588 
1589         if (!cs_ctl->enabled)
1590             continue;
1591 
1592         ret = wm_adsp_buffer_parse_coeff(cs_ctl);
1593         if (ret < 0) {
1594             adsp_err(dsp, "Failed to parse coeff: %d\n", ret);
1595             goto error;
1596         } else if (ret == 0) {
1597             /* Only one buffer supported for version 0 */
1598             return 0;
1599         }
1600     }
1601 
1602     if (list_empty(&dsp->buffer_list)) {
1603         /* Fall back to legacy support */
1604         ret = wm_adsp_buffer_parse_legacy(dsp);
1605         if (ret)
1606             adsp_warn(dsp, "Failed to parse legacy: %d\n", ret);
1607     }
1608 
1609     return 0;
1610 
1611 error:
1612     wm_adsp_buffer_free(dsp);
1613     return ret;
1614 }
1615 
1616 static int wm_adsp_buffer_free(struct wm_adsp *dsp)
1617 {
1618     struct wm_adsp_compr_buf *buf, *tmp;
1619 
1620     list_for_each_entry_safe(buf, tmp, &dsp->buffer_list, list) {
1621         wm_adsp_compr_detach(buf->compr);
1622 
1623         kfree(buf->name);
1624         kfree(buf->regions);
1625         list_del(&buf->list);
1626         kfree(buf);
1627     }
1628 
1629     return 0;
1630 }
1631 
1632 static int wm_adsp_buffer_get_error(struct wm_adsp_compr_buf *buf)
1633 {
1634     int ret;
1635 
1636     ret = wm_adsp_buffer_read(buf, HOST_BUFFER_FIELD(error), &buf->error);
1637     if (ret < 0) {
1638         compr_err(buf, "Failed to check buffer error: %d\n", ret);
1639         return ret;
1640     }
1641     if (buf->error != 0) {
1642         compr_err(buf, "Buffer error occurred: %d\n", buf->error);
1643         return -EIO;
1644     }
1645 
1646     return 0;
1647 }
1648 
1649 int wm_adsp_compr_trigger(struct snd_soc_component *component,
1650               struct snd_compr_stream *stream, int cmd)
1651 {
1652     struct wm_adsp_compr *compr = stream->runtime->private_data;
1653     struct wm_adsp *dsp = compr->dsp;
1654     int ret = 0;
1655 
1656     compr_dbg(compr, "Trigger: %d\n", cmd);
1657 
1658     mutex_lock(&dsp->cs_dsp.pwr_lock);
1659 
1660     switch (cmd) {
1661     case SNDRV_PCM_TRIGGER_START:
1662         if (!wm_adsp_compr_attached(compr)) {
1663             ret = wm_adsp_compr_attach(compr);
1664             if (ret < 0) {
1665                 compr_err(compr, "Failed to link buffer and stream: %d\n",
1666                       ret);
1667                 break;
1668             }
1669         }
1670 
1671         ret = wm_adsp_buffer_get_error(compr->buf);
1672         if (ret < 0)
1673             break;
1674 
1675         /* Trigger the IRQ at one fragment of data */
1676         ret = wm_adsp_buffer_write(compr->buf,
1677                        HOST_BUFFER_FIELD(high_water_mark),
1678                        wm_adsp_compr_frag_words(compr));
1679         if (ret < 0) {
1680             compr_err(compr, "Failed to set high water mark: %d\n",
1681                   ret);
1682             break;
1683         }
1684         break;
1685     case SNDRV_PCM_TRIGGER_STOP:
1686         if (wm_adsp_compr_attached(compr))
1687             wm_adsp_buffer_clear(compr->buf);
1688         break;
1689     default:
1690         ret = -EINVAL;
1691         break;
1692     }
1693 
1694     mutex_unlock(&dsp->cs_dsp.pwr_lock);
1695 
1696     return ret;
1697 }
1698 EXPORT_SYMBOL_GPL(wm_adsp_compr_trigger);
1699 
1700 static inline int wm_adsp_buffer_size(struct wm_adsp_compr_buf *buf)
1701 {
1702     int last_region = wm_adsp_fw[buf->dsp->fw].caps->num_regions - 1;
1703 
1704     return buf->regions[last_region].cumulative_size;
1705 }
1706 
1707 static int wm_adsp_buffer_update_avail(struct wm_adsp_compr_buf *buf)
1708 {
1709     u32 next_read_index, next_write_index;
1710     int write_index, read_index, avail;
1711     int ret;
1712 
1713     /* Only sync read index if we haven't already read a valid index */
1714     if (buf->read_index < 0) {
1715         ret = wm_adsp_buffer_read(buf,
1716                 HOST_BUFFER_FIELD(next_read_index),
1717                 &next_read_index);
1718         if (ret < 0)
1719             return ret;
1720 
1721         read_index = sign_extend32(next_read_index, 23);
1722 
1723         if (read_index < 0) {
1724             compr_dbg(buf, "Avail check on unstarted stream\n");
1725             return 0;
1726         }
1727 
1728         buf->read_index = read_index;
1729     }
1730 
1731     ret = wm_adsp_buffer_read(buf, HOST_BUFFER_FIELD(next_write_index),
1732             &next_write_index);
1733     if (ret < 0)
1734         return ret;
1735 
1736     write_index = sign_extend32(next_write_index, 23);
1737 
1738     avail = write_index - buf->read_index;
1739     if (avail < 0)
1740         avail += wm_adsp_buffer_size(buf);
1741 
1742     compr_dbg(buf, "readindex=0x%x, writeindex=0x%x, avail=%d\n",
1743           buf->read_index, write_index, avail * CS_DSP_DATA_WORD_SIZE);
1744 
1745     buf->avail = avail;
1746 
1747     return 0;
1748 }
1749 
1750 int wm_adsp_compr_handle_irq(struct wm_adsp *dsp)
1751 {
1752     struct wm_adsp_compr_buf *buf;
1753     struct wm_adsp_compr *compr;
1754     int ret = 0;
1755 
1756     mutex_lock(&dsp->cs_dsp.pwr_lock);
1757 
1758     if (list_empty(&dsp->buffer_list)) {
1759         ret = -ENODEV;
1760         goto out;
1761     }
1762 
1763     adsp_dbg(dsp, "Handling buffer IRQ\n");
1764 
1765     list_for_each_entry(buf, &dsp->buffer_list, list) {
1766         compr = buf->compr;
1767 
1768         ret = wm_adsp_buffer_get_error(buf);
1769         if (ret < 0)
1770             goto out_notify; /* Wake poll to report error */
1771 
1772         ret = wm_adsp_buffer_read(buf, HOST_BUFFER_FIELD(irq_count),
1773                       &buf->irq_count);
1774         if (ret < 0) {
1775             compr_err(buf, "Failed to get irq_count: %d\n", ret);
1776             goto out;
1777         }
1778 
1779         ret = wm_adsp_buffer_update_avail(buf);
1780         if (ret < 0) {
1781             compr_err(buf, "Error reading avail: %d\n", ret);
1782             goto out;
1783         }
1784 
1785         if (wm_adsp_fw[dsp->fw].voice_trigger && buf->irq_count == 2)
1786             ret = WM_ADSP_COMPR_VOICE_TRIGGER;
1787 
1788 out_notify:
1789         if (compr && compr->stream)
1790             snd_compr_fragment_elapsed(compr->stream);
1791     }
1792 
1793 out:
1794     mutex_unlock(&dsp->cs_dsp.pwr_lock);
1795 
1796     return ret;
1797 }
1798 EXPORT_SYMBOL_GPL(wm_adsp_compr_handle_irq);
1799 
1800 static int wm_adsp_buffer_reenable_irq(struct wm_adsp_compr_buf *buf)
1801 {
1802     if (buf->irq_count & 0x01)
1803         return 0;
1804 
1805     compr_dbg(buf, "Enable IRQ(0x%x) for next fragment\n", buf->irq_count);
1806 
1807     buf->irq_count |= 0x01;
1808 
1809     return wm_adsp_buffer_write(buf, HOST_BUFFER_FIELD(irq_ack),
1810                     buf->irq_count);
1811 }
1812 
1813 int wm_adsp_compr_pointer(struct snd_soc_component *component,
1814               struct snd_compr_stream *stream,
1815               struct snd_compr_tstamp *tstamp)
1816 {
1817     struct wm_adsp_compr *compr = stream->runtime->private_data;
1818     struct wm_adsp *dsp = compr->dsp;
1819     struct wm_adsp_compr_buf *buf;
1820     int ret = 0;
1821 
1822     compr_dbg(compr, "Pointer request\n");
1823 
1824     mutex_lock(&dsp->cs_dsp.pwr_lock);
1825 
1826     buf = compr->buf;
1827 
1828     if (dsp->fatal_error || !buf || buf->error) {
1829         snd_compr_stop_error(stream, SNDRV_PCM_STATE_XRUN);
1830         ret = -EIO;
1831         goto out;
1832     }
1833 
1834     if (buf->avail < wm_adsp_compr_frag_words(compr)) {
1835         ret = wm_adsp_buffer_update_avail(buf);
1836         if (ret < 0) {
1837             compr_err(compr, "Error reading avail: %d\n", ret);
1838             goto out;
1839         }
1840 
1841         /*
1842          * If we really have less than 1 fragment available tell the
1843          * DSP to inform us once a whole fragment is available.
1844          */
1845         if (buf->avail < wm_adsp_compr_frag_words(compr)) {
1846             ret = wm_adsp_buffer_get_error(buf);
1847             if (ret < 0) {
1848                 if (buf->error)
1849                     snd_compr_stop_error(stream,
1850                             SNDRV_PCM_STATE_XRUN);
1851                 goto out;
1852             }
1853 
1854             ret = wm_adsp_buffer_reenable_irq(buf);
1855             if (ret < 0) {
1856                 compr_err(compr, "Failed to re-enable buffer IRQ: %d\n",
1857                       ret);
1858                 goto out;
1859             }
1860         }
1861     }
1862 
1863     tstamp->copied_total = compr->copied_total;
1864     tstamp->copied_total += buf->avail * CS_DSP_DATA_WORD_SIZE;
1865     tstamp->sampling_rate = compr->sample_rate;
1866 
1867 out:
1868     mutex_unlock(&dsp->cs_dsp.pwr_lock);
1869 
1870     return ret;
1871 }
1872 EXPORT_SYMBOL_GPL(wm_adsp_compr_pointer);
1873 
1874 static int wm_adsp_buffer_capture_block(struct wm_adsp_compr *compr, int target)
1875 {
1876     struct wm_adsp_compr_buf *buf = compr->buf;
1877     unsigned int adsp_addr;
1878     int mem_type, nwords, max_read;
1879     int i, ret;
1880 
1881     /* Calculate read parameters */
1882     for (i = 0; i < wm_adsp_fw[buf->dsp->fw].caps->num_regions; ++i)
1883         if (buf->read_index < buf->regions[i].cumulative_size)
1884             break;
1885 
1886     if (i == wm_adsp_fw[buf->dsp->fw].caps->num_regions)
1887         return -EINVAL;
1888 
1889     mem_type = buf->regions[i].mem_type;
1890     adsp_addr = buf->regions[i].base_addr +
1891             (buf->read_index - buf->regions[i].offset);
1892 
1893     max_read = wm_adsp_compr_frag_words(compr);
1894     nwords = buf->regions[i].cumulative_size - buf->read_index;
1895 
1896     if (nwords > target)
1897         nwords = target;
1898     if (nwords > buf->avail)
1899         nwords = buf->avail;
1900     if (nwords > max_read)
1901         nwords = max_read;
1902     if (!nwords)
1903         return 0;
1904 
1905     /* Read data from DSP */
1906     ret = cs_dsp_read_raw_data_block(&buf->dsp->cs_dsp, mem_type, adsp_addr,
1907                      nwords, (__be32 *)compr->raw_buf);
1908     if (ret < 0)
1909         return ret;
1910 
1911     cs_dsp_remove_padding(compr->raw_buf, nwords);
1912 
1913     /* update read index to account for words read */
1914     buf->read_index += nwords;
1915     if (buf->read_index == wm_adsp_buffer_size(buf))
1916         buf->read_index = 0;
1917 
1918     ret = wm_adsp_buffer_write(buf, HOST_BUFFER_FIELD(next_read_index),
1919                    buf->read_index);
1920     if (ret < 0)
1921         return ret;
1922 
1923     /* update avail to account for words read */
1924     buf->avail -= nwords;
1925 
1926     return nwords;
1927 }
1928 
1929 static int wm_adsp_compr_read(struct wm_adsp_compr *compr,
1930                   char __user *buf, size_t count)
1931 {
1932     struct wm_adsp *dsp = compr->dsp;
1933     int ntotal = 0;
1934     int nwords, nbytes;
1935 
1936     compr_dbg(compr, "Requested read of %zu bytes\n", count);
1937 
1938     if (dsp->fatal_error || !compr->buf || compr->buf->error) {
1939         snd_compr_stop_error(compr->stream, SNDRV_PCM_STATE_XRUN);
1940         return -EIO;
1941     }
1942 
1943     count /= CS_DSP_DATA_WORD_SIZE;
1944 
1945     do {
1946         nwords = wm_adsp_buffer_capture_block(compr, count);
1947         if (nwords < 0) {
1948             compr_err(compr, "Failed to capture block: %d\n",
1949                   nwords);
1950             return nwords;
1951         }
1952 
1953         nbytes = nwords * CS_DSP_DATA_WORD_SIZE;
1954 
1955         compr_dbg(compr, "Read %d bytes\n", nbytes);
1956 
1957         if (copy_to_user(buf + ntotal, compr->raw_buf, nbytes)) {
1958             compr_err(compr, "Failed to copy data to user: %d, %d\n",
1959                   ntotal, nbytes);
1960             return -EFAULT;
1961         }
1962 
1963         count -= nwords;
1964         ntotal += nbytes;
1965     } while (nwords > 0 && count > 0);
1966 
1967     compr->copied_total += ntotal;
1968 
1969     return ntotal;
1970 }
1971 
1972 int wm_adsp_compr_copy(struct snd_soc_component *component,
1973                struct snd_compr_stream *stream, char __user *buf,
1974                size_t count)
1975 {
1976     struct wm_adsp_compr *compr = stream->runtime->private_data;
1977     struct wm_adsp *dsp = compr->dsp;
1978     int ret;
1979 
1980     mutex_lock(&dsp->cs_dsp.pwr_lock);
1981 
1982     if (stream->direction == SND_COMPRESS_CAPTURE)
1983         ret = wm_adsp_compr_read(compr, buf, count);
1984     else
1985         ret = -ENOTSUPP;
1986 
1987     mutex_unlock(&dsp->cs_dsp.pwr_lock);
1988 
1989     return ret;
1990 }
1991 EXPORT_SYMBOL_GPL(wm_adsp_compr_copy);
1992 
1993 static void wm_adsp_fatal_error(struct cs_dsp *cs_dsp)
1994 {
1995     struct wm_adsp *dsp = container_of(cs_dsp, struct wm_adsp, cs_dsp);
1996     struct wm_adsp_compr *compr;
1997 
1998     dsp->fatal_error = true;
1999 
2000     list_for_each_entry(compr, &dsp->compr_list, list) {
2001         if (compr->stream)
2002             snd_compr_fragment_elapsed(compr->stream);
2003     }
2004 }
2005 
2006 irqreturn_t wm_adsp2_bus_error(int irq, void *data)
2007 {
2008     struct wm_adsp *dsp = (struct wm_adsp *)data;
2009 
2010     cs_dsp_adsp2_bus_error(&dsp->cs_dsp);
2011 
2012     return IRQ_HANDLED;
2013 }
2014 EXPORT_SYMBOL_GPL(wm_adsp2_bus_error);
2015 
2016 irqreturn_t wm_halo_bus_error(int irq, void *data)
2017 {
2018     struct wm_adsp *dsp = (struct wm_adsp *)data;
2019 
2020     cs_dsp_halo_bus_error(&dsp->cs_dsp);
2021 
2022     return IRQ_HANDLED;
2023 }
2024 EXPORT_SYMBOL_GPL(wm_halo_bus_error);
2025 
2026 irqreturn_t wm_halo_wdt_expire(int irq, void *data)
2027 {
2028     struct wm_adsp *dsp = data;
2029 
2030     cs_dsp_halo_wdt_expire(&dsp->cs_dsp);
2031 
2032     return IRQ_HANDLED;
2033 }
2034 EXPORT_SYMBOL_GPL(wm_halo_wdt_expire);
2035 
2036 static const struct cs_dsp_client_ops wm_adsp1_client_ops = {
2037     .control_add = wm_adsp_control_add,
2038     .control_remove = wm_adsp_control_remove,
2039 };
2040 
2041 static const struct cs_dsp_client_ops wm_adsp2_client_ops = {
2042     .control_add = wm_adsp_control_add,
2043     .control_remove = wm_adsp_control_remove,
2044     .post_run = wm_adsp_event_post_run,
2045     .post_stop = wm_adsp_event_post_stop,
2046     .watchdog_expired = wm_adsp_fatal_error,
2047 };
2048 
2049 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!