1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * mtk-afe-fe-dais.c -- Mediatek afe fe dai operator 4 * 5 * Copyright (c) 2016 MediaTek Inc. 6 * Author: Garlic Tseng <garlic.tseng@mediatek.com> 7 */ 8 9 #include <linux/module.h> 10 #include <linux/pm_runtime.h> 11 #include <linux/regmap.h> 12 #include <sound/soc.h> 13 #include "mtk-afe-platform-driver.h" 14 #include "mtk-afe-fe-dai.h" 15 #include "mtk-base-afe.h" 16 17 #define AFE_BASE_END_OFFSET 8 18 19 static int mtk_regmap_update_bits(struct regmap *map, int reg, 20 unsigned int mask, 21 unsigned int val) 22 { 23 if (reg < 0) 24 return 0; 25 return regmap_update_bits(map, reg, mask, val); 26 } 27 28 static int mtk_regmap_write(struct regmap *map, int reg, unsigned int val) 29 { 30 if (reg < 0) 31 return 0; 32 return regmap_write(map, reg, val); 33 } 34 35 int mtk_afe_fe_startup(struct snd_pcm_substream *substream, 36 struct snd_soc_dai *dai) 37 { 38 struct snd_soc_pcm_runtime *rtd = substream->private_data; 39 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai); 40 struct snd_pcm_runtime *runtime = substream->runtime; 41 int memif_num = rtd->cpu_dai->id; 42 struct mtk_base_afe_memif *memif = &afe->memif[memif_num]; 43 const struct snd_pcm_hardware *mtk_afe_hardware = afe->mtk_afe_hardware; 44 int ret; 45 46 memif->substream = substream; 47 48 snd_pcm_hw_constraint_step(substream->runtime, 0, 49 SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 16); 50 /* enable agent */ 51 mtk_regmap_update_bits(afe->regmap, memif->data->agent_disable_reg, 52 1 << memif->data->agent_disable_shift, 53 0 << memif->data->agent_disable_shift); 54 55 snd_soc_set_runtime_hwparams(substream, mtk_afe_hardware); 56 57 /* 58 * Capture cannot use ping-pong buffer since hw_ptr at IRQ may be 59 * smaller than period_size due to AFE's internal buffer. 60 * This easily leads to overrun when avail_min is period_size. 61 * One more period can hold the possible unread buffer. 62 */ 63 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { 64 int periods_max = mtk_afe_hardware->periods_max; 65 66 ret = snd_pcm_hw_constraint_minmax(runtime, 67 SNDRV_PCM_HW_PARAM_PERIODS, 68 3, periods_max); 69 if (ret < 0) { 70 dev_err(afe->dev, "hw_constraint_minmax failed\n"); 71 return ret; 72 } 73 } 74 75 ret = snd_pcm_hw_constraint_integer(runtime, 76 SNDRV_PCM_HW_PARAM_PERIODS); 77 if (ret < 0) 78 dev_err(afe->dev, "snd_pcm_hw_constraint_integer failed\n"); 79 80 /* dynamic allocate irq to memif */ 81 if (memif->irq_usage < 0) { 82 int irq_id = mtk_dynamic_irq_acquire(afe); 83 84 if (irq_id != afe->irqs_size) { 85 /* link */ 86 memif->irq_usage = irq_id; 87 } else { 88 dev_err(afe->dev, "%s() error: no more asys irq\n", 89 __func__); 90 ret = -EBUSY; 91 } 92 } 93 return ret; 94 } 95 EXPORT_SYMBOL_GPL(mtk_afe_fe_startup); 96 97 void mtk_afe_fe_shutdown(struct snd_pcm_substream *substream, 98 struct snd_soc_dai *dai) 99 { 100 struct snd_soc_pcm_runtime *rtd = substream->private_data; 101 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai); 102 struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id]; 103 int irq_id; 104 105 irq_id = memif->irq_usage; 106 107 mtk_regmap_update_bits(afe->regmap, memif->data->agent_disable_reg, 108 1 << memif->data->agent_disable_shift, 109 1 << memif->data->agent_disable_shift); 110 111 if (!memif->const_irq) { 112 mtk_dynamic_irq_release(afe, irq_id); 113 memif->irq_usage = -1; 114 memif->substream = NULL; 115 } 116 } 117 EXPORT_SYMBOL_GPL(mtk_afe_fe_shutdown); 118 119 int mtk_afe_fe_hw_params(struct snd_pcm_substream *substream, 120 struct snd_pcm_hw_params *params, 121 struct snd_soc_dai *dai) 122 { 123 struct snd_soc_pcm_runtime *rtd = substream->private_data; 124 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai); 125 struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id]; 126 int msb_at_bit33 = 0; 127 int ret, fs = 0; 128 129 ret = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params)); 130 if (ret < 0) 131 return ret; 132 133 msb_at_bit33 = upper_32_bits(substream->runtime->dma_addr) ? 1 : 0; 134 memif->phys_buf_addr = lower_32_bits(substream->runtime->dma_addr); 135 memif->buffer_size = substream->runtime->dma_bytes; 136 137 /* start */ 138 mtk_regmap_write(afe->regmap, memif->data->reg_ofs_base, 139 memif->phys_buf_addr); 140 /* end */ 141 mtk_regmap_write(afe->regmap, 142 memif->data->reg_ofs_base + AFE_BASE_END_OFFSET, 143 memif->phys_buf_addr + memif->buffer_size - 1); 144 145 /* set MSB to 33-bit */ 146 mtk_regmap_update_bits(afe->regmap, memif->data->msb_reg, 147 1 << memif->data->msb_shift, 148 msb_at_bit33 << memif->data->msb_shift); 149 150 /* set channel */ 151 if (memif->data->mono_shift >= 0) { 152 unsigned int mono = (params_channels(params) == 1) ? 1 : 0; 153 154 mtk_regmap_update_bits(afe->regmap, memif->data->mono_reg, 155 1 << memif->data->mono_shift, 156 mono << memif->data->mono_shift); 157 } 158 159 /* set rate */ 160 if (memif->data->fs_shift < 0) 161 return 0; 162 163 fs = afe->memif_fs(substream, params_rate(params)); 164 165 if (fs < 0) 166 return -EINVAL; 167 168 mtk_regmap_update_bits(afe->regmap, memif->data->fs_reg, 169 memif->data->fs_maskbit << memif->data->fs_shift, 170 fs << memif->data->fs_shift); 171 172 return 0; 173 } 174 EXPORT_SYMBOL_GPL(mtk_afe_fe_hw_params); 175 176 int mtk_afe_fe_hw_free(struct snd_pcm_substream *substream, 177 struct snd_soc_dai *dai) 178 { 179 return snd_pcm_lib_free_pages(substream); 180 } 181 EXPORT_SYMBOL_GPL(mtk_afe_fe_hw_free); 182 183 int mtk_afe_fe_trigger(struct snd_pcm_substream *substream, int cmd, 184 struct snd_soc_dai *dai) 185 { 186 struct snd_soc_pcm_runtime *rtd = substream->private_data; 187 struct snd_pcm_runtime * const runtime = substream->runtime; 188 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai); 189 struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id]; 190 struct mtk_base_afe_irq *irqs = &afe->irqs[memif->irq_usage]; 191 const struct mtk_base_irq_data *irq_data = irqs->irq_data; 192 unsigned int counter = runtime->period_size; 193 int fs; 194 195 dev_dbg(afe->dev, "%s %s cmd=%d\n", __func__, memif->data->name, cmd); 196 197 switch (cmd) { 198 case SNDRV_PCM_TRIGGER_START: 199 case SNDRV_PCM_TRIGGER_RESUME: 200 if (memif->data->enable_shift >= 0) 201 mtk_regmap_update_bits(afe->regmap, 202 memif->data->enable_reg, 203 1 << memif->data->enable_shift, 204 1 << memif->data->enable_shift); 205 206 /* set irq counter */ 207 mtk_regmap_update_bits(afe->regmap, irq_data->irq_cnt_reg, 208 irq_data->irq_cnt_maskbit 209 << irq_data->irq_cnt_shift, 210 counter << irq_data->irq_cnt_shift); 211 212 /* set irq fs */ 213 fs = afe->irq_fs(substream, runtime->rate); 214 215 if (fs < 0) 216 return -EINVAL; 217 218 mtk_regmap_update_bits(afe->regmap, irq_data->irq_fs_reg, 219 irq_data->irq_fs_maskbit 220 << irq_data->irq_fs_shift, 221 fs << irq_data->irq_fs_shift); 222 223 /* enable interrupt */ 224 mtk_regmap_update_bits(afe->regmap, irq_data->irq_en_reg, 225 1 << irq_data->irq_en_shift, 226 1 << irq_data->irq_en_shift); 227 228 return 0; 229 case SNDRV_PCM_TRIGGER_STOP: 230 case SNDRV_PCM_TRIGGER_SUSPEND: 231 mtk_regmap_update_bits(afe->regmap, memif->data->enable_reg, 232 1 << memif->data->enable_shift, 0); 233 /* disable interrupt */ 234 mtk_regmap_update_bits(afe->regmap, irq_data->irq_en_reg, 235 1 << irq_data->irq_en_shift, 236 0 << irq_data->irq_en_shift); 237 /* and clear pending IRQ */ 238 mtk_regmap_write(afe->regmap, irq_data->irq_clr_reg, 239 1 << irq_data->irq_clr_shift); 240 return 0; 241 default: 242 return -EINVAL; 243 } 244 } 245 EXPORT_SYMBOL_GPL(mtk_afe_fe_trigger); 246 247 int mtk_afe_fe_prepare(struct snd_pcm_substream *substream, 248 struct snd_soc_dai *dai) 249 { 250 struct snd_soc_pcm_runtime *rtd = substream->private_data; 251 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai); 252 struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id]; 253 int hd_audio = 0; 254 255 /* set hd mode */ 256 switch (substream->runtime->format) { 257 case SNDRV_PCM_FORMAT_S16_LE: 258 hd_audio = 0; 259 break; 260 case SNDRV_PCM_FORMAT_S32_LE: 261 hd_audio = 1; 262 break; 263 case SNDRV_PCM_FORMAT_S24_LE: 264 hd_audio = 1; 265 break; 266 default: 267 dev_err(afe->dev, "%s() error: unsupported format %d\n", 268 __func__, substream->runtime->format); 269 break; 270 } 271 272 mtk_regmap_update_bits(afe->regmap, memif->data->hd_reg, 273 1 << memif->data->hd_shift, 274 hd_audio << memif->data->hd_shift); 275 276 return 0; 277 } 278 EXPORT_SYMBOL_GPL(mtk_afe_fe_prepare); 279 280 const struct snd_soc_dai_ops mtk_afe_fe_ops = { 281 .startup = mtk_afe_fe_startup, 282 .shutdown = mtk_afe_fe_shutdown, 283 .hw_params = mtk_afe_fe_hw_params, 284 .hw_free = mtk_afe_fe_hw_free, 285 .prepare = mtk_afe_fe_prepare, 286 .trigger = mtk_afe_fe_trigger, 287 }; 288 EXPORT_SYMBOL_GPL(mtk_afe_fe_ops); 289 290 static DEFINE_MUTEX(irqs_lock); 291 int mtk_dynamic_irq_acquire(struct mtk_base_afe *afe) 292 { 293 int i; 294 295 mutex_lock(&afe->irq_alloc_lock); 296 for (i = 0; i < afe->irqs_size; ++i) { 297 if (afe->irqs[i].irq_occupyed == 0) { 298 afe->irqs[i].irq_occupyed = 1; 299 mutex_unlock(&afe->irq_alloc_lock); 300 return i; 301 } 302 } 303 mutex_unlock(&afe->irq_alloc_lock); 304 return afe->irqs_size; 305 } 306 EXPORT_SYMBOL_GPL(mtk_dynamic_irq_acquire); 307 308 int mtk_dynamic_irq_release(struct mtk_base_afe *afe, int irq_id) 309 { 310 mutex_lock(&afe->irq_alloc_lock); 311 if (irq_id >= 0 && irq_id < afe->irqs_size) { 312 afe->irqs[irq_id].irq_occupyed = 0; 313 mutex_unlock(&afe->irq_alloc_lock); 314 return 0; 315 } 316 mutex_unlock(&afe->irq_alloc_lock); 317 return -EINVAL; 318 } 319 EXPORT_SYMBOL_GPL(mtk_dynamic_irq_release); 320 321 int mtk_afe_dai_suspend(struct snd_soc_dai *dai) 322 { 323 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai); 324 struct device *dev = afe->dev; 325 struct regmap *regmap = afe->regmap; 326 int i; 327 328 if (pm_runtime_status_suspended(dev) || afe->suspended) 329 return 0; 330 331 if (!afe->reg_back_up) 332 afe->reg_back_up = 333 devm_kcalloc(dev, afe->reg_back_up_list_num, 334 sizeof(unsigned int), GFP_KERNEL); 335 336 for (i = 0; i < afe->reg_back_up_list_num; i++) 337 regmap_read(regmap, afe->reg_back_up_list[i], 338 &afe->reg_back_up[i]); 339 340 afe->suspended = true; 341 afe->runtime_suspend(dev); 342 return 0; 343 } 344 EXPORT_SYMBOL_GPL(mtk_afe_dai_suspend); 345 346 int mtk_afe_dai_resume(struct snd_soc_dai *dai) 347 { 348 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai); 349 struct device *dev = afe->dev; 350 struct regmap *regmap = afe->regmap; 351 int i = 0; 352 353 if (pm_runtime_status_suspended(dev) || !afe->suspended) 354 return 0; 355 356 afe->runtime_resume(dev); 357 358 if (!afe->reg_back_up) 359 dev_dbg(dev, "%s no reg_backup\n", __func__); 360 361 for (i = 0; i < afe->reg_back_up_list_num; i++) 362 mtk_regmap_write(regmap, afe->reg_back_up_list[i], 363 afe->reg_back_up[i]); 364 365 afe->suspended = false; 366 return 0; 367 } 368 EXPORT_SYMBOL_GPL(mtk_afe_dai_resume); 369 370 MODULE_DESCRIPTION("Mediatek simple fe dai operator"); 371 MODULE_AUTHOR("Garlic Tseng <garlic.tseng@mediatek.com>"); 372 MODULE_LICENSE("GPL v2"); 373