sound/firewire/tascam/amdtp-tascam.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * amdtp-tascam.c - a part of driver for TASCAM FireWire series
   4  *
   5  * Copyright (c) 2015 Takashi Sakamoto
   6  */
   7
   8 #include <sound/pcm.h>
   9 #include "tascam.h"
  10
  11 #define AMDTP_FMT_TSCM_TX       0x1e
  12 #define AMDTP_FMT_TSCM_RX       0x3e
  13
  14 struct amdtp_tscm {
  15         unsigned int pcm_channels;
  16 };
  17
  18 int amdtp_tscm_set_parameters(struct amdtp_stream *s, unsigned int rate)
  19 {
  20         struct amdtp_tscm *p = s->protocol;
  21         unsigned int data_channels;
  22
  23         if (amdtp_stream_running(s))
  24                 return -EBUSY;
  25
  26         data_channels = p->pcm_channels;
  27
  28         /* Packets in in-stream have extra 2 data channels. */
  29         if (s->direction == AMDTP_IN_STREAM)
  30                 data_channels += 2;
  31
  32         return amdtp_stream_set_parameters(s, rate, data_channels);
  33 }
  34
  35 static void write_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
  36                           __be32 *buffer, unsigned int frames,
  37                           unsigned int pcm_frames)
  38 {
  39         struct amdtp_tscm *p = s->protocol;
  40         unsigned int channels = p->pcm_channels;
  41         struct snd_pcm_runtime *runtime = pcm->runtime;
  42         unsigned int pcm_buffer_pointer;
  43         int remaining_frames;
  44         const u32 *src;
  45         int i, c;
  46
  47         pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
  48         pcm_buffer_pointer %= runtime->buffer_size;
  49
  50         src = (void *)runtime->dma_area +
  51                                 frames_to_bytes(runtime, pcm_buffer_pointer);
  52         remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
  53
  54         for (i = 0; i < frames; ++i) {
  55                 for (c = 0; c < channels; ++c) {
  56                         buffer[c] = cpu_to_be32(*src);
  57                         src++;
  58                 }
  59                 buffer += s->data_block_quadlets;
  60                 if (--remaining_frames == 0)
  61                         src = (void *)runtime->dma_area;
  62         }
  63 }
  64
  65 static void read_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
  66                          __be32 *buffer, unsigned int frames,
  67                          unsigned int pcm_frames)
  68 {
  69         struct amdtp_tscm *p = s->protocol;
  70         unsigned int channels = p->pcm_channels;
  71         struct snd_pcm_runtime *runtime = pcm->runtime;
  72         unsigned int pcm_buffer_pointer;
  73         int remaining_frames;
  74         u32 *dst;
  75         int i, c;
  76
  77         pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
  78         pcm_buffer_pointer %= runtime->buffer_size;
  79
  80         dst  = (void *)runtime->dma_area +
  81                                 frames_to_bytes(runtime, pcm_buffer_pointer);
  82         remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
  83
  84         /* The first data channel is for event counter. */
  85         buffer += 1;
  86
  87         for (i = 0; i < frames; ++i) {
  88                 for (c = 0; c < channels; ++c) {
  89                         *dst = be32_to_cpu(buffer[c]);
  90                         dst++;
  91                 }
  92                 buffer += s->data_block_quadlets;
  93                 if (--remaining_frames == 0)
  94                         dst = (void *)runtime->dma_area;
  95         }
  96 }
  97
  98 static void write_pcm_silence(struct amdtp_stream *s, __be32 *buffer,
  99                               unsigned int data_blocks)
 100 {
 101         struct amdtp_tscm *p = s->protocol;
 102         unsigned int channels, i, c;
 103
 104         channels = p->pcm_channels;
 105
 106         for (i = 0; i < data_blocks; ++i) {
 107                 for (c = 0; c < channels; ++c)
 108                         buffer[c] = 0x00000000;
 109                 buffer += s->data_block_quadlets;
 110         }
 111 }
 112
 113 int amdtp_tscm_add_pcm_hw_constraints(struct amdtp_stream *s,
 114                                       struct snd_pcm_runtime *runtime)
 115 {
 116         int err;
 117
 118         /*
 119          * Our implementation allows this protocol to deliver 24 bit sample in
 120          * 32bit data channel.
 121          */
 122         err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
 123         if (err < 0)
 124                 return err;
 125
 126         return amdtp_stream_add_pcm_hw_constraints(s, runtime);
 127 }
 128
 129 static void read_status_messages(struct amdtp_stream *s,
 130                                  __be32 *buffer, unsigned int data_blocks)
 131 {
 132         struct snd_tscm *tscm = container_of(s, struct snd_tscm, tx_stream);
 133         bool used = READ_ONCE(tscm->hwdep->used);
 134         int i;
 135
 136         for (i = 0; i < data_blocks; i++) {
 137                 unsigned int index;
 138                 __be32 before;
 139                 __be32 after;
 140
 141                 index = be32_to_cpu(buffer[0]) % SNDRV_FIREWIRE_TASCAM_STATE_COUNT;
 142                 before = tscm->state[index];
 143                 after = buffer[s->data_block_quadlets - 1];
 144
 145                 if (used && index > 4 && index < 16) {
 146                         __be32 mask;
 147
 148                         if (index == 5)
 149                                 mask = cpu_to_be32(~0x0000ffff);
 150                         else if (index == 6)
 151                                 mask = cpu_to_be32(~0x0000ffff);
 152                         else if (index == 8)
 153                                 mask = cpu_to_be32(~0x000f0f00);
 154                         else
 155                                 mask = cpu_to_be32(~0x00000000);
 156
 157                         if ((before ^ after) & mask) {
 158                                 struct snd_firewire_tascam_change *entry =
 159                                                 &tscm->queue[tscm->push_pos];
 160
 161                                 spin_lock_irq(&tscm->lock);
 162                                 entry->index = index;
 163                                 entry->before = before;
 164                                 entry->after = after;
 165                                 if (++tscm->push_pos >= SND_TSCM_QUEUE_COUNT)
 166                                         tscm->push_pos = 0;
 167                                 spin_unlock_irq(&tscm->lock);
 168
 169                                 wake_up(&tscm->hwdep_wait);
 170                         }
 171                 }
 172
 173                 tscm->state[index] = after;
 174                 buffer += s->data_block_quadlets;
 175         }
 176 }
 177
 178 static unsigned int process_ir_ctx_payloads(struct amdtp_stream *s,
 179                                             const struct pkt_desc *descs,
 180                                             unsigned int packets,
 181                                             struct snd_pcm_substream *pcm)
 182 {
 183         unsigned int pcm_frames = 0;
 184         int i;
 185
 186         for (i = 0; i < packets; ++i) {
 187                 const struct pkt_desc *desc = descs + i;
 188                 __be32 *buf = desc->ctx_payload;
 189                 unsigned int data_blocks = desc->data_blocks;
 190
 191                 if (pcm) {
 192                         read_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
 193                         pcm_frames += data_blocks;
 194                 }
 195
 196                 read_status_messages(s, buf, data_blocks);
 197         }
 198
 199         return pcm_frames;
 200 }
 201
 202 static unsigned int process_it_ctx_payloads(struct amdtp_stream *s,
 203                                             const struct pkt_desc *descs,
 204                                             unsigned int packets,
 205                                             struct snd_pcm_substream *pcm)
 206 {
 207         unsigned int pcm_frames = 0;
 208         int i;
 209
 210         for (i = 0; i < packets; ++i) {
 211                 const struct pkt_desc *desc = descs + i;
 212                 __be32 *buf = desc->ctx_payload;
 213                 unsigned int data_blocks = desc->data_blocks;
 214
 215                 if (pcm) {
 216                         write_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
 217                         pcm_frames += data_blocks;
 218                 } else {
 219                         write_pcm_silence(s, buf, data_blocks);
 220                 }
 221         }
 222
 223         return pcm_frames;
 224 }
 225
 226 int amdtp_tscm_init(struct amdtp_stream *s, struct fw_unit *unit,
 227                     enum amdtp_stream_direction dir, unsigned int pcm_channels)
 228 {
 229         amdtp_stream_process_ctx_payloads_t process_ctx_payloads;
 230         struct amdtp_tscm *p;
 231         unsigned int fmt;
 232         int err;
 233
 234         if (dir == AMDTP_IN_STREAM) {
 235                 fmt = AMDTP_FMT_TSCM_TX;
 236                 process_ctx_payloads = process_ir_ctx_payloads;
 237         } else {
 238                 fmt = AMDTP_FMT_TSCM_RX;
 239                 process_ctx_payloads = process_it_ctx_payloads;
 240         }
 241
 242         err = amdtp_stream_init(s, unit, dir,
 243                         CIP_NONBLOCKING | CIP_SKIP_DBC_ZERO_CHECK, fmt,
 244                         process_ctx_payloads, sizeof(struct amdtp_tscm));
 245         if (err < 0)
 246                 return 0;
 247
 248         if (dir == AMDTP_OUT_STREAM) {
 249                 // Use fixed value for FDF field.
 250                 s->ctx_data.rx.fdf = 0x00;
 251                 // Not used.
 252                 s->ctx_data.rx.syt_override = 0x0000;
 253         }
 254
 255         /* This protocol uses fixed number of data channels for PCM samples. */
 256         p = s->protocol;
 257         p->pcm_channels = pcm_channels;
 258
 259         return 0;
 260 }