sound/firewire/amdtp-am824.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * AM824 format in Audio and Music Data Transmission Protocol (IEC 61883-6)
   4  *
   5  * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
   6  * Copyright (c) 2015 Takashi Sakamoto <o-takashi@sakamocchi.jp>
   7  */
   8
   9 #include <linux/slab.h>
  10
  11 #include "amdtp-am824.h"
  12
  13 #define CIP_FMT_AM              0x10
  14
  15 /* "Clock-based rate control mode" is just supported. */
  16 #define AMDTP_FDF_AM824         0x00
  17
  18 /*
  19  * Nominally 3125 bytes/second, but the MIDI port's clock might be
  20  * 1% too slow, and the bus clock 100 ppm too fast.
  21  */
  22 #define MIDI_BYTES_PER_SECOND   3093
  23
  24 /*
  25  * Several devices look only at the first eight data blocks.
  26  * In any case, this is more than enough for the MIDI data rate.
  27  */
  28 #define MAX_MIDI_RX_BLOCKS      8
  29
  30 struct amdtp_am824 {
  31         struct snd_rawmidi_substream *midi[AM824_MAX_CHANNELS_FOR_MIDI * 8];
  32         int midi_fifo_limit;
  33         int midi_fifo_used[AM824_MAX_CHANNELS_FOR_MIDI * 8];
  34         unsigned int pcm_channels;
  35         unsigned int midi_ports;
  36
  37         u8 pcm_positions[AM824_MAX_CHANNELS_FOR_PCM];
  38         u8 midi_position;
  39
  40         unsigned int frame_multiplier;
  41 };
  42
  43 /**
  44  * amdtp_am824_set_parameters - set stream parameters
  45  * @s: the AMDTP stream to configure
  46  * @rate: the sample rate
  47  * @pcm_channels: the number of PCM samples in each data block, to be encoded
  48  *                as AM824 multi-bit linear audio
  49  * @midi_ports: the number of MIDI ports (i.e., MPX-MIDI Data Channels)
  50  * @double_pcm_frames: one data block transfers two PCM frames
  51  *
  52  * The parameters must be set before the stream is started, and must not be
  53  * changed while the stream is running.
  54  */
  55 int amdtp_am824_set_parameters(struct amdtp_stream *s, unsigned int rate,
  56                                unsigned int pcm_channels,
  57                                unsigned int midi_ports,
  58                                bool double_pcm_frames)
  59 {
  60         struct amdtp_am824 *p = s->protocol;
  61         unsigned int midi_channels;
  62         unsigned int i;
  63         int err;
  64
  65         if (amdtp_stream_running(s))
  66                 return -EINVAL;
  67
  68         if (pcm_channels > AM824_MAX_CHANNELS_FOR_PCM)
  69                 return -EINVAL;
  70
  71         midi_channels = DIV_ROUND_UP(midi_ports, 8);
  72         if (midi_channels > AM824_MAX_CHANNELS_FOR_MIDI)
  73                 return -EINVAL;
  74
  75         if (WARN_ON(amdtp_stream_running(s)) ||
  76             WARN_ON(pcm_channels > AM824_MAX_CHANNELS_FOR_PCM) ||
  77             WARN_ON(midi_channels > AM824_MAX_CHANNELS_FOR_MIDI))
  78                 return -EINVAL;
  79
  80         err = amdtp_stream_set_parameters(s, rate,
  81                                           pcm_channels + midi_channels);
  82         if (err < 0)
  83                 return err;
  84
  85         s->ctx_data.rx.fdf = AMDTP_FDF_AM824 | s->sfc;
  86
  87         p->pcm_channels = pcm_channels;
  88         p->midi_ports = midi_ports;
  89
  90         /*
  91          * In IEC 61883-6, one data block represents one event. In ALSA, one
  92          * event equals to one PCM frame. But Dice has a quirk at higher
  93          * sampling rate to transfer two PCM frames in one data block.
  94          */
  95         if (double_pcm_frames)
  96                 p->frame_multiplier = 2;
  97         else
  98                 p->frame_multiplier = 1;
  99
 100         /* init the position map for PCM and MIDI channels */
 101         for (i = 0; i < pcm_channels; i++)
 102                 p->pcm_positions[i] = i;
 103         p->midi_position = p->pcm_channels;
 104
 105         /*
 106          * We do not know the actual MIDI FIFO size of most devices.  Just
 107          * assume two bytes, i.e., one byte can be received over the bus while
 108          * the previous one is transmitted over MIDI.
 109          * (The value here is adjusted for midi_ratelimit_per_packet().)
 110          */
 111         p->midi_fifo_limit = rate - MIDI_BYTES_PER_SECOND * s->syt_interval + 1;
 112
 113         return 0;
 114 }
 115 EXPORT_SYMBOL_GPL(amdtp_am824_set_parameters);
 116
 117 /**
 118  * amdtp_am824_set_pcm_position - set an index of data channel for a channel
 119  *                                of PCM frame
 120  * @s: the AMDTP stream
 121  * @index: the index of data channel in an data block
 122  * @position: the channel of PCM frame
 123  */
 124 void amdtp_am824_set_pcm_position(struct amdtp_stream *s, unsigned int index,
 125                                  unsigned int position)
 126 {
 127         struct amdtp_am824 *p = s->protocol;
 128
 129         if (index < p->pcm_channels)
 130                 p->pcm_positions[index] = position;
 131 }
 132 EXPORT_SYMBOL_GPL(amdtp_am824_set_pcm_position);
 133
 134 /**
 135  * amdtp_am824_set_midi_position - set a index of data channel for MIDI
 136  *                                 conformant data channel
 137  * @s: the AMDTP stream
 138  * @position: the index of data channel in an data block
 139  */
 140 void amdtp_am824_set_midi_position(struct amdtp_stream *s,
 141                                    unsigned int position)
 142 {
 143         struct amdtp_am824 *p = s->protocol;
 144
 145         p->midi_position = position;
 146 }
 147 EXPORT_SYMBOL_GPL(amdtp_am824_set_midi_position);
 148
 149 static void write_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
 150                           __be32 *buffer, unsigned int frames,
 151                           unsigned int pcm_frames)
 152 {
 153         struct amdtp_am824 *p = s->protocol;
 154         unsigned int channels = p->pcm_channels;
 155         struct snd_pcm_runtime *runtime = pcm->runtime;
 156         unsigned int pcm_buffer_pointer;
 157         int remaining_frames;
 158         const u32 *src;
 159         int i, c;
 160
 161         pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
 162         pcm_buffer_pointer %= runtime->buffer_size;
 163
 164         src = (void *)runtime->dma_area +
 165                                 frames_to_bytes(runtime, pcm_buffer_pointer);
 166         remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
 167
 168         for (i = 0; i < frames; ++i) {
 169                 for (c = 0; c < channels; ++c) {
 170                         buffer[p->pcm_positions[c]] =
 171                                         cpu_to_be32((*src >> 8) | 0x40000000);
 172                         src++;
 173                 }
 174                 buffer += s->data_block_quadlets;
 175                 if (--remaining_frames == 0)
 176                         src = (void *)runtime->dma_area;
 177         }
 178 }
 179
 180 static void read_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
 181                          __be32 *buffer, unsigned int frames,
 182                          unsigned int pcm_frames)
 183 {
 184         struct amdtp_am824 *p = s->protocol;
 185         unsigned int channels = p->pcm_channels;
 186         struct snd_pcm_runtime *runtime = pcm->runtime;
 187         unsigned int pcm_buffer_pointer;
 188         int remaining_frames;
 189         u32 *dst;
 190         int i, c;
 191
 192         pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
 193         pcm_buffer_pointer %= runtime->buffer_size;
 194
 195         dst  = (void *)runtime->dma_area +
 196                                 frames_to_bytes(runtime, pcm_buffer_pointer);
 197         remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
 198
 199         for (i = 0; i < frames; ++i) {
 200                 for (c = 0; c < channels; ++c) {
 201                         *dst = be32_to_cpu(buffer[p->pcm_positions[c]]) << 8;
 202                         dst++;
 203                 }
 204                 buffer += s->data_block_quadlets;
 205                 if (--remaining_frames == 0)
 206                         dst = (void *)runtime->dma_area;
 207         }
 208 }
 209
 210 static void write_pcm_silence(struct amdtp_stream *s,
 211                               __be32 *buffer, unsigned int frames)
 212 {
 213         struct amdtp_am824 *p = s->protocol;
 214         unsigned int i, c, channels = p->pcm_channels;
 215
 216         for (i = 0; i < frames; ++i) {
 217                 for (c = 0; c < channels; ++c)
 218                         buffer[p->pcm_positions[c]] = cpu_to_be32(0x40000000);
 219                 buffer += s->data_block_quadlets;
 220         }
 221 }
 222
 223 /**
 224  * amdtp_am824_add_pcm_hw_constraints - add hw constraints for PCM substream
 225  * @s:          the AMDTP stream for AM824 data block, must be initialized.
 226  * @runtime:    the PCM substream runtime
 227  *
 228  */
 229 int amdtp_am824_add_pcm_hw_constraints(struct amdtp_stream *s,
 230                                        struct snd_pcm_runtime *runtime)
 231 {
 232         int err;
 233
 234         err = amdtp_stream_add_pcm_hw_constraints(s, runtime);
 235         if (err < 0)
 236                 return err;
 237
 238         /* AM824 in IEC 61883-6 can deliver 24bit data. */
 239         return snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
 240 }
 241 EXPORT_SYMBOL_GPL(amdtp_am824_add_pcm_hw_constraints);
 242
 243 /**
 244  * amdtp_am824_midi_trigger - start/stop playback/capture with a MIDI device
 245  * @s: the AMDTP stream
 246  * @port: index of MIDI port
 247  * @midi: the MIDI device to be started, or %NULL to stop the current device
 248  *
 249  * Call this function on a running isochronous stream to enable the actual
 250  * transmission of MIDI data.  This function should be called from the MIDI
 251  * device's .trigger callback.
 252  */
 253 void amdtp_am824_midi_trigger(struct amdtp_stream *s, unsigned int port,
 254                               struct snd_rawmidi_substream *midi)
 255 {
 256         struct amdtp_am824 *p = s->protocol;
 257
 258         if (port < p->midi_ports)
 259                 WRITE_ONCE(p->midi[port], midi);
 260 }
 261 EXPORT_SYMBOL_GPL(amdtp_am824_midi_trigger);
 262
 263 /*
 264  * To avoid sending MIDI bytes at too high a rate, assume that the receiving
 265  * device has a FIFO, and track how much it is filled.  This values increases
 266  * by one whenever we send one byte in a packet, but the FIFO empties at
 267  * a constant rate independent of our packet rate.  One packet has syt_interval
 268  * samples, so the number of bytes that empty out of the FIFO, per packet(!),
 269  * is MIDI_BYTES_PER_SECOND * syt_interval / sample_rate.  To avoid storing
 270  * fractional values, the values in midi_fifo_used[] are measured in bytes
 271  * multiplied by the sample rate.
 272  */
 273 static bool midi_ratelimit_per_packet(struct amdtp_stream *s, unsigned int port)
 274 {
 275         struct amdtp_am824 *p = s->protocol;
 276         int used;
 277
 278         used = p->midi_fifo_used[port];
 279         if (used == 0) /* common shortcut */
 280                 return true;
 281
 282         used -= MIDI_BYTES_PER_SECOND * s->syt_interval;
 283         used = max(used, 0);
 284         p->midi_fifo_used[port] = used;
 285
 286         return used < p->midi_fifo_limit;
 287 }
 288
 289 static void midi_rate_use_one_byte(struct amdtp_stream *s, unsigned int port)
 290 {
 291         struct amdtp_am824 *p = s->protocol;
 292
 293         p->midi_fifo_used[port] += amdtp_rate_table[s->sfc];
 294 }
 295
 296 static void write_midi_messages(struct amdtp_stream *s, __be32 *buffer,
 297                         unsigned int frames, unsigned int data_block_counter)
 298 {
 299         struct amdtp_am824 *p = s->protocol;
 300         unsigned int f, port;
 301         u8 *b;
 302
 303         for (f = 0; f < frames; f++) {
 304                 b = (u8 *)&buffer[p->midi_position];
 305
 306                 port = (data_block_counter + f) % 8;
 307                 if (f < MAX_MIDI_RX_BLOCKS &&
 308                     midi_ratelimit_per_packet(s, port) &&
 309                     p->midi[port] != NULL &&
 310                     snd_rawmidi_transmit(p->midi[port], &b[1], 1) == 1) {
 311                         midi_rate_use_one_byte(s, port);
 312                         b[0] = 0x81;
 313                 } else {
 314                         b[0] = 0x80;
 315                         b[1] = 0;
 316                 }
 317                 b[2] = 0;
 318                 b[3] = 0;
 319
 320                 buffer += s->data_block_quadlets;
 321         }
 322 }
 323
 324 static void read_midi_messages(struct amdtp_stream *s, __be32 *buffer,
 325                         unsigned int frames, unsigned int data_block_counter)
 326 {
 327         struct amdtp_am824 *p = s->protocol;
 328         int len;
 329         u8 *b;
 330         int f;
 331
 332         for (f = 0; f < frames; f++) {
 333                 unsigned int port = f;
 334
 335                 if (!(s->flags & CIP_UNALIGHED_DBC))
 336                         port += data_block_counter;
 337                 port %= 8;
 338                 b = (u8 *)&buffer[p->midi_position];
 339
 340                 len = b[0] - 0x80;
 341                 if ((1 <= len) &&  (len <= 3) && (p->midi[port]))
 342                         snd_rawmidi_receive(p->midi[port], b + 1, len);
 343
 344                 buffer += s->data_block_quadlets;
 345         }
 346 }
 347
 348 static unsigned int process_it_ctx_payloads(struct amdtp_stream *s,
 349                                             const struct pkt_desc *descs,
 350                                             unsigned int packets,
 351                                             struct snd_pcm_substream *pcm)
 352 {
 353         struct amdtp_am824 *p = s->protocol;
 354         unsigned int pcm_frames = 0;
 355         int i;
 356
 357         for (i = 0; i < packets; ++i) {
 358                 const struct pkt_desc *desc = descs + i;
 359                 __be32 *buf = desc->ctx_payload;
 360                 unsigned int data_blocks = desc->data_blocks;
 361
 362                 if (pcm) {
 363                         write_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
 364                         pcm_frames += data_blocks * p->frame_multiplier;
 365                 } else {
 366                         write_pcm_silence(s, buf, data_blocks);
 367                 }
 368
 369                 if (p->midi_ports) {
 370                         write_midi_messages(s, buf, data_blocks,
 371                                             desc->data_block_counter);
 372                 }
 373         }
 374
 375         return pcm_frames;
 376 }
 377
 378 static unsigned int process_ir_ctx_payloads(struct amdtp_stream *s,
 379                                             const struct pkt_desc *descs,
 380                                             unsigned int packets,
 381                                             struct snd_pcm_substream *pcm)
 382 {
 383         struct amdtp_am824 *p = s->protocol;
 384         unsigned int pcm_frames = 0;
 385         int i;
 386
 387         for (i = 0; i < packets; ++i) {
 388                 const struct pkt_desc *desc = descs + i;
 389                 __be32 *buf = desc->ctx_payload;
 390                 unsigned int data_blocks = desc->data_blocks;
 391
 392                 if (pcm) {
 393                         read_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
 394                         pcm_frames += data_blocks * p->frame_multiplier;
 395                 }
 396
 397                 if (p->midi_ports) {
 398                         read_midi_messages(s, buf, data_blocks,
 399                                            desc->data_block_counter);
 400                 }
 401         }
 402
 403         return pcm_frames;
 404 }
 405
 406 /**
 407  * amdtp_am824_init - initialize an AMDTP stream structure to handle AM824
 408  *                    data block
 409  * @s: the AMDTP stream to initialize
 410  * @unit: the target of the stream
 411  * @dir: the direction of stream
 412  * @flags: the packet transmission method to use
 413  */
 414 int amdtp_am824_init(struct amdtp_stream *s, struct fw_unit *unit,
 415                      enum amdtp_stream_direction dir, enum cip_flags flags)
 416 {
 417         amdtp_stream_process_ctx_payloads_t process_ctx_payloads;
 418
 419         if (dir == AMDTP_IN_STREAM)
 420                 process_ctx_payloads = process_ir_ctx_payloads;
 421         else
 422                 process_ctx_payloads = process_it_ctx_payloads;
 423
 424         return amdtp_stream_init(s, unit, dir, flags, CIP_FMT_AM,
 425                         process_ctx_payloads, sizeof(struct amdtp_am824));
 426 }
 427 EXPORT_SYMBOL_GPL(amdtp_am824_init);