1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // Socionext UniPhier AIO Compress Audio driver. 4 // 5 // Copyright (c) 2017-2018 Socionext Inc. 6 7 #include <linux/bitfield.h> 8 #include <linux/circ_buf.h> 9 #include <linux/dma-mapping.h> 10 #include <linux/errno.h> 11 #include <linux/kernel.h> 12 #include <linux/module.h> 13 #include <sound/core.h> 14 #include <sound/pcm.h> 15 #include <sound/soc.h> 16 17 #include "aio.h" 18 19 static int uniphier_aio_compr_prepare(struct snd_compr_stream *cstream); 20 static int uniphier_aio_compr_hw_free(struct snd_compr_stream *cstream); 21 22 static int uniphier_aio_comprdma_new(struct snd_soc_pcm_runtime *rtd) 23 { 24 struct snd_compr *compr = rtd->compr; 25 struct device *dev = compr->card->dev; 26 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0)); 27 struct uniphier_aio_sub *sub = &aio->sub[compr->direction]; 28 size_t size = AUD_RING_SIZE; 29 int dma_dir = DMA_FROM_DEVICE, ret; 30 31 ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(33)); 32 if (ret) 33 return ret; 34 35 sub->compr_area = kzalloc(size, GFP_KERNEL); 36 if (!sub->compr_area) 37 return -ENOMEM; 38 39 if (sub->swm->dir == PORT_DIR_OUTPUT) 40 dma_dir = DMA_TO_DEVICE; 41 42 sub->compr_addr = dma_map_single(dev, sub->compr_area, size, dma_dir); 43 if (dma_mapping_error(dev, sub->compr_addr)) { 44 kfree(sub->compr_area); 45 sub->compr_area = NULL; 46 47 return -ENOMEM; 48 } 49 50 sub->compr_bytes = size; 51 52 return 0; 53 } 54 55 static int uniphier_aio_comprdma_free(struct snd_soc_pcm_runtime *rtd) 56 { 57 struct snd_compr *compr = rtd->compr; 58 struct device *dev = compr->card->dev; 59 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0)); 60 struct uniphier_aio_sub *sub = &aio->sub[compr->direction]; 61 int dma_dir = DMA_FROM_DEVICE; 62 63 if (sub->swm->dir == PORT_DIR_OUTPUT) 64 dma_dir = DMA_TO_DEVICE; 65 66 dma_unmap_single(dev, sub->compr_addr, sub->compr_bytes, dma_dir); 67 kfree(sub->compr_area); 68 sub->compr_area = NULL; 69 70 return 0; 71 } 72 73 static int uniphier_aio_compr_open(struct snd_compr_stream *cstream) 74 { 75 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 76 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0)); 77 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction]; 78 int ret; 79 80 if (sub->cstream) 81 return -EBUSY; 82 83 sub->cstream = cstream; 84 sub->pass_through = 1; 85 sub->use_mmap = false; 86 87 ret = uniphier_aio_comprdma_new(rtd); 88 if (ret) 89 return ret; 90 91 ret = aio_init(sub); 92 if (ret) 93 return ret; 94 95 return 0; 96 } 97 98 static int uniphier_aio_compr_free(struct snd_compr_stream *cstream) 99 { 100 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 101 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0)); 102 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction]; 103 int ret; 104 105 ret = uniphier_aio_compr_hw_free(cstream); 106 if (ret) 107 return ret; 108 ret = uniphier_aio_comprdma_free(rtd); 109 if (ret) 110 return ret; 111 112 sub->cstream = NULL; 113 114 return 0; 115 } 116 117 static int uniphier_aio_compr_get_params(struct snd_compr_stream *cstream, 118 struct snd_codec *params) 119 { 120 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 121 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0)); 122 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction]; 123 124 *params = sub->cparams.codec; 125 126 return 0; 127 } 128 129 static int uniphier_aio_compr_set_params(struct snd_compr_stream *cstream, 130 struct snd_compr_params *params) 131 { 132 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 133 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0)); 134 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction]; 135 struct device *dev = &aio->chip->pdev->dev; 136 int ret; 137 138 if (params->codec.id != SND_AUDIOCODEC_IEC61937) { 139 dev_err(dev, "Codec ID is not supported(%d)\n", 140 params->codec.id); 141 return -EINVAL; 142 } 143 if (params->codec.profile != SND_AUDIOPROFILE_IEC61937_SPDIF) { 144 dev_err(dev, "Codec profile is not supported(%d)\n", 145 params->codec.profile); 146 return -EINVAL; 147 } 148 149 /* IEC frame type will be changed after received valid data */ 150 sub->iec_pc = IEC61937_PC_AAC; 151 152 sub->cparams = *params; 153 sub->setting = 1; 154 155 aio_port_reset(sub); 156 aio_src_reset(sub); 157 158 ret = uniphier_aio_compr_prepare(cstream); 159 if (ret) 160 return ret; 161 162 return 0; 163 } 164 165 static int uniphier_aio_compr_hw_free(struct snd_compr_stream *cstream) 166 { 167 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 168 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0)); 169 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction]; 170 171 sub->setting = 0; 172 173 return 0; 174 } 175 176 static int uniphier_aio_compr_prepare(struct snd_compr_stream *cstream) 177 { 178 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 179 struct snd_compr_runtime *runtime = cstream->runtime; 180 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0)); 181 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction]; 182 int bytes = runtime->fragment_size; 183 unsigned long flags; 184 int ret; 185 186 ret = aiodma_ch_set_param(sub); 187 if (ret) 188 return ret; 189 190 spin_lock_irqsave(&sub->lock, flags); 191 ret = aiodma_rb_set_buffer(sub, sub->compr_addr, 192 sub->compr_addr + sub->compr_bytes, 193 bytes); 194 spin_unlock_irqrestore(&sub->lock, flags); 195 if (ret) 196 return ret; 197 198 ret = aio_port_set_param(sub, sub->pass_through, &sub->params); 199 if (ret) 200 return ret; 201 ret = aio_oport_set_stream_type(sub, sub->iec_pc); 202 if (ret) 203 return ret; 204 aio_port_set_enable(sub, 1); 205 206 ret = aio_if_set_param(sub, sub->pass_through); 207 if (ret) 208 return ret; 209 210 return 0; 211 } 212 213 static int uniphier_aio_compr_trigger(struct snd_compr_stream *cstream, 214 int cmd) 215 { 216 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 217 struct snd_compr_runtime *runtime = cstream->runtime; 218 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0)); 219 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction]; 220 struct device *dev = &aio->chip->pdev->dev; 221 int bytes = runtime->fragment_size, ret = 0; 222 unsigned long flags; 223 224 spin_lock_irqsave(&sub->lock, flags); 225 switch (cmd) { 226 case SNDRV_PCM_TRIGGER_START: 227 aiodma_rb_sync(sub, sub->compr_addr, sub->compr_bytes, bytes); 228 aiodma_ch_set_enable(sub, 1); 229 sub->running = 1; 230 231 break; 232 case SNDRV_PCM_TRIGGER_STOP: 233 sub->running = 0; 234 aiodma_ch_set_enable(sub, 0); 235 236 break; 237 default: 238 dev_warn(dev, "Unknown trigger(%d)\n", cmd); 239 ret = -EINVAL; 240 } 241 spin_unlock_irqrestore(&sub->lock, flags); 242 243 return ret; 244 } 245 246 static int uniphier_aio_compr_pointer(struct snd_compr_stream *cstream, 247 struct snd_compr_tstamp *tstamp) 248 { 249 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 250 struct snd_compr_runtime *runtime = cstream->runtime; 251 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0)); 252 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction]; 253 int bytes = runtime->fragment_size; 254 unsigned long flags; 255 u32 pos; 256 257 spin_lock_irqsave(&sub->lock, flags); 258 259 aiodma_rb_sync(sub, sub->compr_addr, sub->compr_bytes, bytes); 260 261 if (sub->swm->dir == PORT_DIR_OUTPUT) { 262 pos = sub->rd_offs; 263 /* Size of AIO output format is double of IEC61937 */ 264 tstamp->copied_total = sub->rd_total / 2; 265 } else { 266 pos = sub->wr_offs; 267 tstamp->copied_total = sub->rd_total; 268 } 269 tstamp->byte_offset = pos; 270 271 spin_unlock_irqrestore(&sub->lock, flags); 272 273 return 0; 274 } 275 276 static int aio_compr_send_to_hw(struct uniphier_aio_sub *sub, 277 char __user *buf, size_t dstsize) 278 { 279 u32 __user *srcbuf = (u32 __user *)buf; 280 u32 *dstbuf = (u32 *)(sub->compr_area + sub->wr_offs); 281 int src = 0, dst = 0, ret; 282 u32 frm, frm_a, frm_b; 283 284 while (dstsize > 0) { 285 ret = get_user(frm, srcbuf + src); 286 if (ret) 287 return ret; 288 src++; 289 290 frm_a = frm & 0xffff; 291 frm_b = (frm >> 16) & 0xffff; 292 293 if (frm == IEC61937_HEADER_SIGN) { 294 frm_a |= 0x01000000; 295 296 /* Next data is Pc and Pd */ 297 sub->iec_header = true; 298 } else { 299 u16 pc = be16_to_cpu((__be16)frm_a); 300 301 if (sub->iec_header && sub->iec_pc != pc) { 302 /* Force overwrite IEC frame type */ 303 sub->iec_pc = pc; 304 ret = aio_oport_set_stream_type(sub, pc); 305 if (ret) 306 return ret; 307 } 308 sub->iec_header = false; 309 } 310 dstbuf[dst++] = frm_a; 311 dstbuf[dst++] = frm_b; 312 313 dstsize -= sizeof(u32) * 2; 314 } 315 316 return 0; 317 } 318 319 static int uniphier_aio_compr_copy(struct snd_compr_stream *cstream, 320 char __user *buf, size_t count) 321 { 322 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 323 struct snd_compr_runtime *runtime = cstream->runtime; 324 struct device *carddev = rtd->compr->card->dev; 325 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0)); 326 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction]; 327 size_t cnt = min_t(size_t, count, aio_rb_space_to_end(sub) / 2); 328 int bytes = runtime->fragment_size; 329 unsigned long flags; 330 size_t s; 331 int ret; 332 333 if (cnt < sizeof(u32)) 334 return 0; 335 336 if (sub->swm->dir == PORT_DIR_OUTPUT) { 337 dma_addr_t dmapos = sub->compr_addr + sub->wr_offs; 338 339 /* Size of AIO output format is double of IEC61937 */ 340 s = cnt * 2; 341 342 dma_sync_single_for_cpu(carddev, dmapos, s, DMA_TO_DEVICE); 343 ret = aio_compr_send_to_hw(sub, buf, s); 344 dma_sync_single_for_device(carddev, dmapos, s, DMA_TO_DEVICE); 345 } else { 346 dma_addr_t dmapos = sub->compr_addr + sub->rd_offs; 347 348 s = cnt; 349 350 dma_sync_single_for_cpu(carddev, dmapos, s, DMA_FROM_DEVICE); 351 ret = copy_to_user(buf, sub->compr_area + sub->rd_offs, s); 352 dma_sync_single_for_device(carddev, dmapos, s, DMA_FROM_DEVICE); 353 } 354 if (ret) 355 return -EFAULT; 356 357 spin_lock_irqsave(&sub->lock, flags); 358 359 sub->threshold = 2 * bytes; 360 aiodma_rb_set_threshold(sub, sub->compr_bytes, 2 * bytes); 361 362 if (sub->swm->dir == PORT_DIR_OUTPUT) { 363 sub->wr_offs += s; 364 if (sub->wr_offs >= sub->compr_bytes) 365 sub->wr_offs -= sub->compr_bytes; 366 } else { 367 sub->rd_offs += s; 368 if (sub->rd_offs >= sub->compr_bytes) 369 sub->rd_offs -= sub->compr_bytes; 370 } 371 aiodma_rb_sync(sub, sub->compr_addr, sub->compr_bytes, bytes); 372 373 spin_unlock_irqrestore(&sub->lock, flags); 374 375 return cnt; 376 } 377 378 static int uniphier_aio_compr_get_caps(struct snd_compr_stream *cstream, 379 struct snd_compr_caps *caps) 380 { 381 caps->num_codecs = 1; 382 caps->min_fragment_size = AUD_MIN_FRAGMENT_SIZE; 383 caps->max_fragment_size = AUD_MAX_FRAGMENT_SIZE; 384 caps->min_fragments = AUD_MIN_FRAGMENT; 385 caps->max_fragments = AUD_MAX_FRAGMENT; 386 caps->codecs[0] = SND_AUDIOCODEC_IEC61937; 387 388 return 0; 389 } 390 391 static const struct snd_compr_codec_caps caps_iec = { 392 .num_descriptors = 1, 393 .descriptor[0].max_ch = 8, 394 .descriptor[0].num_sample_rates = 0, 395 .descriptor[0].num_bitrates = 0, 396 .descriptor[0].profiles = SND_AUDIOPROFILE_IEC61937_SPDIF, 397 .descriptor[0].modes = SND_AUDIOMODE_IEC_AC3 | 398 SND_AUDIOMODE_IEC_MPEG1 | 399 SND_AUDIOMODE_IEC_MP3 | 400 SND_AUDIOMODE_IEC_DTS, 401 .descriptor[0].formats = 0, 402 }; 403 404 static int uniphier_aio_compr_get_codec_caps(struct snd_compr_stream *stream, 405 struct snd_compr_codec_caps *codec) 406 { 407 if (codec->codec == SND_AUDIOCODEC_IEC61937) 408 *codec = caps_iec; 409 else 410 return -EINVAL; 411 412 return 0; 413 } 414 415 const struct snd_compr_ops uniphier_aio_compr_ops = { 416 .open = uniphier_aio_compr_open, 417 .free = uniphier_aio_compr_free, 418 .get_params = uniphier_aio_compr_get_params, 419 .set_params = uniphier_aio_compr_set_params, 420 .trigger = uniphier_aio_compr_trigger, 421 .pointer = uniphier_aio_compr_pointer, 422 .copy = uniphier_aio_compr_copy, 423 .get_caps = uniphier_aio_compr_get_caps, 424 .get_codec_caps = uniphier_aio_compr_get_codec_caps, 425 }; 426