drivers/media/pci/cobalt/cobalt-alsa-pcm.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  ALSA PCM device for the
   4  *  ALSA interface to cobalt PCM capture streams
   5  *
   6  *  Copyright 2014-2015 Cisco Systems, Inc. and/or its affiliates.
   7  *  All rights reserved.
   8  */
   9
  10 #include <linux/init.h>
  11 #include <linux/kernel.h>
  12 #include <linux/vmalloc.h>
  13 #include <linux/delay.h>
  14
  15 #include <media/v4l2-device.h>
  16
  17 #include <sound/core.h>
  18 #include <sound/pcm.h>
  19
  20 #include "cobalt-driver.h"
  21 #include "cobalt-alsa.h"
  22 #include "cobalt-alsa-pcm.h"
  23
  24 static unsigned int pcm_debug;
  25 module_param(pcm_debug, int, 0644);
  26 MODULE_PARM_DESC(pcm_debug, "enable debug messages for pcm");
  27
  28 #define dprintk(fmt, arg...) \
  29         do { \
  30                 if (pcm_debug) \
  31                         pr_info("cobalt-alsa-pcm %s: " fmt, __func__, ##arg); \
  32         } while (0)
  33
  34 static const struct snd_pcm_hardware snd_cobalt_hdmi_capture = {
  35         .info = SNDRV_PCM_INFO_BLOCK_TRANSFER |
  36                 SNDRV_PCM_INFO_MMAP           |
  37                 SNDRV_PCM_INFO_INTERLEAVED    |
  38                 SNDRV_PCM_INFO_MMAP_VALID,
  39
  40         .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE,
  41
  42         .rates = SNDRV_PCM_RATE_48000,
  43
  44         .rate_min = 48000,
  45         .rate_max = 48000,
  46         .channels_min = 1,
  47         .channels_max = 8,
  48         .buffer_bytes_max = 4 * 240 * 8 * 4,    /* 5 ms of data */
  49         .period_bytes_min = 1920,               /* 1 sample = 8 * 4 bytes */
  50         .period_bytes_max = 240 * 8 * 4,        /* 5 ms of 8 channel data */
  51         .periods_min = 1,
  52         .periods_max = 4,
  53 };
  54
  55 static const struct snd_pcm_hardware snd_cobalt_playback = {
  56         .info = SNDRV_PCM_INFO_BLOCK_TRANSFER |
  57                 SNDRV_PCM_INFO_MMAP           |
  58                 SNDRV_PCM_INFO_INTERLEAVED    |
  59                 SNDRV_PCM_INFO_MMAP_VALID,
  60
  61         .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE,
  62
  63         .rates = SNDRV_PCM_RATE_48000,
  64
  65         .rate_min = 48000,
  66         .rate_max = 48000,
  67         .channels_min = 1,
  68         .channels_max = 8,
  69         .buffer_bytes_max = 4 * 240 * 8 * 4,    /* 5 ms of data */
  70         .period_bytes_min = 1920,               /* 1 sample = 8 * 4 bytes */
  71         .period_bytes_max = 240 * 8 * 4,        /* 5 ms of 8 channel data */
  72         .periods_min = 1,
  73         .periods_max = 4,
  74 };
  75
  76 static void sample_cpy(u8 *dst, const u8 *src, u32 len, bool is_s32)
  77 {
  78         static const unsigned map[8] = { 0, 1, 5, 4, 2, 3, 6, 7 };
  79         unsigned idx = 0;
  80
  81         while (len >= (is_s32 ? 4 : 2)) {
  82                 unsigned offset = map[idx] * 4;
  83                 u32 val = src[offset + 1] + (src[offset + 2] << 8) +
  84                          (src[offset + 3] << 16);
  85
  86                 if (is_s32) {
  87                         *dst++ = 0;
  88                         *dst++ = val & 0xff;
  89                 }
  90                 *dst++ = (val >> 8) & 0xff;
  91                 *dst++ = (val >> 16) & 0xff;
  92                 len -= is_s32 ? 4 : 2;
  93                 idx++;
  94         }
  95 }
  96
  97 static void cobalt_alsa_announce_pcm_data(struct snd_cobalt_card *cobsc,
  98                                         u8 *pcm_data,
  99                                         size_t skip,
 100                                         size_t samples)
 101 {
 102         struct snd_pcm_substream *substream;
 103         struct snd_pcm_runtime *runtime;
 104         unsigned long flags;
 105         unsigned int oldptr;
 106         unsigned int stride;
 107         int length = samples;
 108         int period_elapsed = 0;
 109         bool is_s32;
 110
 111         dprintk("cobalt alsa announce ptr=%p data=%p num_bytes=%zd\n", cobsc,
 112                 pcm_data, samples);
 113
 114         substream = cobsc->capture_pcm_substream;
 115         if (substream == NULL) {
 116                 dprintk("substream was NULL\n");
 117                 return;
 118         }
 119
 120         runtime = substream->runtime;
 121         if (runtime == NULL) {
 122                 dprintk("runtime was NULL\n");
 123                 return;
 124         }
 125         is_s32 = runtime->format == SNDRV_PCM_FORMAT_S32_LE;
 126
 127         stride = runtime->frame_bits >> 3;
 128         if (stride == 0) {
 129                 dprintk("stride is zero\n");
 130                 return;
 131         }
 132
 133         if (length == 0) {
 134                 dprintk("%s: length was zero\n", __func__);
 135                 return;
 136         }
 137
 138         if (runtime->dma_area == NULL) {
 139                 dprintk("dma area was NULL - ignoring\n");
 140                 return;
 141         }
 142
 143         oldptr = cobsc->hwptr_done_capture;
 144         if (oldptr + length >= runtime->buffer_size) {
 145                 unsigned int cnt = runtime->buffer_size - oldptr;
 146                 unsigned i;
 147
 148                 for (i = 0; i < cnt; i++)
 149                         sample_cpy(runtime->dma_area + (oldptr + i) * stride,
 150                                         pcm_data + i * skip,
 151                                         stride, is_s32);
 152                 for (i = cnt; i < length; i++)
 153                         sample_cpy(runtime->dma_area + (i - cnt) * stride,
 154                                         pcm_data + i * skip, stride, is_s32);
 155         } else {
 156                 unsigned i;
 157
 158                 for (i = 0; i < length; i++)
 159                         sample_cpy(runtime->dma_area + (oldptr + i) * stride,
 160                                         pcm_data + i * skip,
 161                                         stride, is_s32);
 162         }
 163         snd_pcm_stream_lock_irqsave(substream, flags);
 164
 165         cobsc->hwptr_done_capture += length;
 166         if (cobsc->hwptr_done_capture >=
 167             runtime->buffer_size)
 168                 cobsc->hwptr_done_capture -=
 169                         runtime->buffer_size;
 170
 171         cobsc->capture_transfer_done += length;
 172         if (cobsc->capture_transfer_done >=
 173             runtime->period_size) {
 174                 cobsc->capture_transfer_done -=
 175                         runtime->period_size;
 176                 period_elapsed = 1;
 177         }
 178
 179         snd_pcm_stream_unlock_irqrestore(substream, flags);
 180
 181         if (period_elapsed)
 182                 snd_pcm_period_elapsed(substream);
 183 }
 184
 185 static int alsa_fnc(struct vb2_buffer *vb, void *priv)
 186 {
 187         struct cobalt_stream *s = priv;
 188         unsigned char *p = vb2_plane_vaddr(vb, 0);
 189         int i;
 190
 191         if (pcm_debug) {
 192                 pr_info("alsa: ");
 193                 for (i = 0; i < 8 * 4; i++) {
 194                         if (!(i & 3))
 195                                 pr_cont(" ");
 196                         pr_cont("%02x", p[i]);
 197                 }
 198                 pr_cont("\n");
 199         }
 200         cobalt_alsa_announce_pcm_data(s->alsa,
 201                         vb2_plane_vaddr(vb, 0),
 202                         8 * 4,
 203                         vb2_get_plane_payload(vb, 0) / (8 * 4));
 204         return 0;
 205 }
 206
 207 static int snd_cobalt_pcm_capture_open(struct snd_pcm_substream *substream)
 208 {
 209         struct snd_pcm_runtime *runtime = substream->runtime;
 210         struct snd_cobalt_card *cobsc = snd_pcm_substream_chip(substream);
 211         struct cobalt_stream *s = cobsc->s;
 212
 213         runtime->hw = snd_cobalt_hdmi_capture;
 214         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
 215         cobsc->capture_pcm_substream = substream;
 216         runtime->private_data = s;
 217         cobsc->alsa_record_cnt++;
 218         if (cobsc->alsa_record_cnt == 1) {
 219                 int rc;
 220
 221                 rc = vb2_thread_start(&s->q, alsa_fnc, s, s->vdev.name);
 222                 if (rc) {
 223                         cobsc->alsa_record_cnt--;
 224                         return rc;
 225                 }
 226         }
 227         return 0;
 228 }
 229
 230 static int snd_cobalt_pcm_capture_close(struct snd_pcm_substream *substream)
 231 {
 232         struct snd_cobalt_card *cobsc = snd_pcm_substream_chip(substream);
 233         struct cobalt_stream *s = cobsc->s;
 234
 235         cobsc->alsa_record_cnt--;
 236         if (cobsc->alsa_record_cnt == 0)
 237                 vb2_thread_stop(&s->q);
 238         return 0;
 239 }
 240
 241 static int snd_cobalt_pcm_ioctl(struct snd_pcm_substream *substream,
 242                      unsigned int cmd, void *arg)
 243 {
 244         return snd_pcm_lib_ioctl(substream, cmd, arg);
 245 }
 246
 247
 248 static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs,
 249                                         size_t size)
 250 {
 251         struct snd_pcm_runtime *runtime = subs->runtime;
 252
 253         dprintk("Allocating vbuffer\n");
 254         if (runtime->dma_area) {
 255                 if (runtime->dma_bytes > size)
 256                         return 0;
 257
 258                 vfree(runtime->dma_area);
 259         }
 260         runtime->dma_area = vmalloc(size);
 261         if (!runtime->dma_area)
 262                 return -ENOMEM;
 263
 264         runtime->dma_bytes = size;
 265
 266         return 0;
 267 }
 268
 269 static int snd_cobalt_pcm_hw_params(struct snd_pcm_substream *substream,
 270                          struct snd_pcm_hw_params *params)
 271 {
 272         dprintk("%s called\n", __func__);
 273
 274         return snd_pcm_alloc_vmalloc_buffer(substream,
 275                                            params_buffer_bytes(params));
 276 }
 277
 278 static int snd_cobalt_pcm_hw_free(struct snd_pcm_substream *substream)
 279 {
 280         if (substream->runtime->dma_area) {
 281                 dprintk("freeing pcm capture region\n");
 282                 vfree(substream->runtime->dma_area);
 283                 substream->runtime->dma_area = NULL;
 284         }
 285
 286         return 0;
 287 }
 288
 289 static int snd_cobalt_pcm_prepare(struct snd_pcm_substream *substream)
 290 {
 291         struct snd_cobalt_card *cobsc = snd_pcm_substream_chip(substream);
 292
 293         cobsc->hwptr_done_capture = 0;
 294         cobsc->capture_transfer_done = 0;
 295
 296         return 0;
 297 }
 298
 299 static int snd_cobalt_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 300 {
 301         switch (cmd) {
 302         case SNDRV_PCM_TRIGGER_START:
 303         case SNDRV_PCM_TRIGGER_STOP:
 304                 return 0;
 305         default:
 306                 return -EINVAL;
 307         }
 308         return 0;
 309 }
 310
 311 static
 312 snd_pcm_uframes_t snd_cobalt_pcm_pointer(struct snd_pcm_substream *substream)
 313 {
 314         snd_pcm_uframes_t hwptr_done;
 315         struct snd_cobalt_card *cobsc = snd_pcm_substream_chip(substream);
 316
 317         hwptr_done = cobsc->hwptr_done_capture;
 318
 319         return hwptr_done;
 320 }
 321
 322 static void pb_sample_cpy(u8 *dst, const u8 *src, u32 len, bool is_s32)
 323 {
 324         static const unsigned map[8] = { 0, 1, 5, 4, 2, 3, 6, 7 };
 325         unsigned idx = 0;
 326
 327         while (len >= (is_s32 ? 4 : 2)) {
 328                 unsigned offset = map[idx] * 4;
 329                 u8 *out = dst + offset;
 330
 331                 *out++ = 0;
 332                 if (is_s32) {
 333                         src++;
 334                         *out++ = *src++;
 335                 } else {
 336                         *out++ = 0;
 337                 }
 338                 *out++ = *src++;
 339                 *out = *src++;
 340                 len -= is_s32 ? 4 : 2;
 341                 idx++;
 342         }
 343 }
 344
 345 static void cobalt_alsa_pb_pcm_data(struct snd_cobalt_card *cobsc,
 346                                         u8 *pcm_data,
 347                                         size_t skip,
 348                                         size_t samples)
 349 {
 350         struct snd_pcm_substream *substream;
 351         struct snd_pcm_runtime *runtime;
 352         unsigned long flags;
 353         unsigned int pos;
 354         unsigned int stride;
 355         bool is_s32;
 356         unsigned i;
 357
 358         dprintk("cobalt alsa pb ptr=%p data=%p samples=%zd\n", cobsc,
 359                 pcm_data, samples);
 360
 361         substream = cobsc->playback_pcm_substream;
 362         if (substream == NULL) {
 363                 dprintk("substream was NULL\n");
 364                 return;
 365         }
 366
 367         runtime = substream->runtime;
 368         if (runtime == NULL) {
 369                 dprintk("runtime was NULL\n");
 370                 return;
 371         }
 372
 373         is_s32 = runtime->format == SNDRV_PCM_FORMAT_S32_LE;
 374         stride = runtime->frame_bits >> 3;
 375         if (stride == 0) {
 376                 dprintk("stride is zero\n");
 377                 return;
 378         }
 379
 380         if (samples == 0) {
 381                 dprintk("%s: samples was zero\n", __func__);
 382                 return;
 383         }
 384
 385         if (runtime->dma_area == NULL) {
 386                 dprintk("dma area was NULL - ignoring\n");
 387                 return;
 388         }
 389
 390         pos = cobsc->pb_pos % cobsc->pb_size;
 391         for (i = 0; i < cobsc->pb_count / (8 * 4); i++)
 392                 pb_sample_cpy(pcm_data + i * skip,
 393                                 runtime->dma_area + pos + i * stride,
 394                                 stride, is_s32);
 395         snd_pcm_stream_lock_irqsave(substream, flags);
 396
 397         cobsc->pb_pos += i * stride;
 398
 399         snd_pcm_stream_unlock_irqrestore(substream, flags);
 400         if (cobsc->pb_pos % cobsc->pb_count == 0)
 401                 snd_pcm_period_elapsed(substream);
 402 }
 403
 404 static int alsa_pb_fnc(struct vb2_buffer *vb, void *priv)
 405 {
 406         struct cobalt_stream *s = priv;
 407
 408         if (s->alsa->alsa_pb_channel)
 409                 cobalt_alsa_pb_pcm_data(s->alsa,
 410                                 vb2_plane_vaddr(vb, 0),
 411                                 8 * 4,
 412                                 vb2_get_plane_payload(vb, 0) / (8 * 4));
 413         return 0;
 414 }
 415
 416 static int snd_cobalt_pcm_playback_open(struct snd_pcm_substream *substream)
 417 {
 418         struct snd_cobalt_card *cobsc = snd_pcm_substream_chip(substream);
 419         struct snd_pcm_runtime *runtime = substream->runtime;
 420         struct cobalt_stream *s = cobsc->s;
 421
 422         runtime->hw = snd_cobalt_playback;
 423         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
 424         cobsc->playback_pcm_substream = substream;
 425         runtime->private_data = s;
 426         cobsc->alsa_playback_cnt++;
 427         if (cobsc->alsa_playback_cnt == 1) {
 428                 int rc;
 429
 430                 rc = vb2_thread_start(&s->q, alsa_pb_fnc, s, s->vdev.name);
 431                 if (rc) {
 432                         cobsc->alsa_playback_cnt--;
 433                         return rc;
 434                 }
 435         }
 436
 437         return 0;
 438 }
 439
 440 static int snd_cobalt_pcm_playback_close(struct snd_pcm_substream *substream)
 441 {
 442         struct snd_cobalt_card *cobsc = snd_pcm_substream_chip(substream);
 443         struct cobalt_stream *s = cobsc->s;
 444
 445         cobsc->alsa_playback_cnt--;
 446         if (cobsc->alsa_playback_cnt == 0)
 447                 vb2_thread_stop(&s->q);
 448         return 0;
 449 }
 450
 451 static int snd_cobalt_pcm_pb_prepare(struct snd_pcm_substream *substream)
 452 {
 453         struct snd_cobalt_card *cobsc = snd_pcm_substream_chip(substream);
 454
 455         cobsc->pb_size = snd_pcm_lib_buffer_bytes(substream);
 456         cobsc->pb_count = snd_pcm_lib_period_bytes(substream);
 457         cobsc->pb_pos = 0;
 458
 459         return 0;
 460 }
 461
 462 static int snd_cobalt_pcm_pb_trigger(struct snd_pcm_substream *substream,
 463                                      int cmd)
 464 {
 465         struct snd_cobalt_card *cobsc = snd_pcm_substream_chip(substream);
 466
 467         switch (cmd) {
 468         case SNDRV_PCM_TRIGGER_START:
 469                 if (cobsc->alsa_pb_channel)
 470                         return -EBUSY;
 471                 cobsc->alsa_pb_channel = true;
 472                 return 0;
 473         case SNDRV_PCM_TRIGGER_STOP:
 474                 cobsc->alsa_pb_channel = false;
 475                 return 0;
 476         default:
 477                 return -EINVAL;
 478         }
 479 }
 480
 481 static
 482 snd_pcm_uframes_t snd_cobalt_pcm_pb_pointer(struct snd_pcm_substream *substream)
 483 {
 484         struct snd_cobalt_card *cobsc = snd_pcm_substream_chip(substream);
 485         size_t ptr;
 486
 487         ptr = cobsc->pb_pos;
 488
 489         return bytes_to_frames(substream->runtime, ptr) %
 490                substream->runtime->buffer_size;
 491 }
 492
 493 static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
 494                                              unsigned long offset)
 495 {
 496         void *pageptr = subs->runtime->dma_area + offset;
 497
 498         return vmalloc_to_page(pageptr);
 499 }
 500
 501 static const struct snd_pcm_ops snd_cobalt_pcm_capture_ops = {
 502         .open           = snd_cobalt_pcm_capture_open,
 503         .close          = snd_cobalt_pcm_capture_close,
 504         .ioctl          = snd_cobalt_pcm_ioctl,
 505         .hw_params      = snd_cobalt_pcm_hw_params,
 506         .hw_free        = snd_cobalt_pcm_hw_free,
 507         .prepare        = snd_cobalt_pcm_prepare,
 508         .trigger        = snd_cobalt_pcm_trigger,
 509         .pointer        = snd_cobalt_pcm_pointer,
 510         .page           = snd_pcm_get_vmalloc_page,
 511 };
 512
 513 static const struct snd_pcm_ops snd_cobalt_pcm_playback_ops = {
 514         .open           = snd_cobalt_pcm_playback_open,
 515         .close          = snd_cobalt_pcm_playback_close,
 516         .ioctl          = snd_cobalt_pcm_ioctl,
 517         .hw_params      = snd_cobalt_pcm_hw_params,
 518         .hw_free        = snd_cobalt_pcm_hw_free,
 519         .prepare        = snd_cobalt_pcm_pb_prepare,
 520         .trigger        = snd_cobalt_pcm_pb_trigger,
 521         .pointer        = snd_cobalt_pcm_pb_pointer,
 522         .page           = snd_pcm_get_vmalloc_page,
 523 };
 524
 525 int snd_cobalt_pcm_create(struct snd_cobalt_card *cobsc)
 526 {
 527         struct snd_pcm *sp;
 528         struct snd_card *sc = cobsc->sc;
 529         struct cobalt_stream *s = cobsc->s;
 530         struct cobalt *cobalt = s->cobalt;
 531         int ret;
 532
 533         s->q.gfp_flags |= __GFP_ZERO;
 534
 535         if (!s->is_output) {
 536                 cobalt_s_bit_sysctrl(cobalt,
 537                         COBALT_SYS_CTRL_AUDIO_IPP_RESETN_BIT(s->video_channel),
 538                         0);
 539                 mdelay(2);
 540                 cobalt_s_bit_sysctrl(cobalt,
 541                         COBALT_SYS_CTRL_AUDIO_IPP_RESETN_BIT(s->video_channel),
 542                         1);
 543                 mdelay(1);
 544
 545                 ret = snd_pcm_new(sc, "Cobalt PCM-In HDMI",
 546                         0, /* PCM device 0, the only one for this card */
 547                         0, /* 0 playback substreams */
 548                         1, /* 1 capture substream */
 549                         &sp);
 550                 if (ret) {
 551                         cobalt_err("snd_cobalt_pcm_create() failed for input with err %d\n",
 552                                    ret);
 553                         goto err_exit;
 554                 }
 555
 556                 snd_pcm_set_ops(sp, SNDRV_PCM_STREAM_CAPTURE,
 557                                 &snd_cobalt_pcm_capture_ops);
 558                 sp->info_flags = 0;
 559                 sp->private_data = cobsc;
 560                 strlcpy(sp->name, "cobalt", sizeof(sp->name));
 561         } else {
 562                 cobalt_s_bit_sysctrl(cobalt,
 563                         COBALT_SYS_CTRL_AUDIO_OPP_RESETN_BIT, 0);
 564                 mdelay(2);
 565                 cobalt_s_bit_sysctrl(cobalt,
 566                         COBALT_SYS_CTRL_AUDIO_OPP_RESETN_BIT, 1);
 567                 mdelay(1);
 568
 569                 ret = snd_pcm_new(sc, "Cobalt PCM-Out HDMI",
 570                         0, /* PCM device 0, the only one for this card */
 571                         1, /* 0 playback substreams */
 572                         0, /* 1 capture substream */
 573                         &sp);
 574                 if (ret) {
 575                         cobalt_err("snd_cobalt_pcm_create() failed for output with err %d\n",
 576                                    ret);
 577                         goto err_exit;
 578                 }
 579
 580                 snd_pcm_set_ops(sp, SNDRV_PCM_STREAM_PLAYBACK,
 581                                 &snd_cobalt_pcm_playback_ops);
 582                 sp->info_flags = 0;
 583                 sp->private_data = cobsc;
 584                 strlcpy(sp->name, "cobalt", sizeof(sp->name));
 585         }
 586
 587         return 0;
 588
 589 err_exit:
 590         return ret;
 591 }