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         if (s->direction == AMDTP_OUT_STREAM)
  86                 s->ctx_data.rx.fdf = AMDTP_FDF_AM824 | s->sfc;
  87
  88         p->pcm_channels = pcm_channels;
  89         p->midi_ports = midi_ports;
  90
  91         /*
  92          * In IEC 61883-6, one data block represents one event. In ALSA, one
  93          * event equals to one PCM frame. But Dice has a quirk at higher
  94          * sampling rate to transfer two PCM frames in one data block.
  95          */
  96         if (double_pcm_frames)
  97                 p->frame_multiplier = 2;
  98         else
  99                 p->frame_multiplier = 1;
 100
 101         /* init the position map for PCM and MIDI channels */
 102         for (i = 0; i < pcm_channels; i++)
 103                 p->pcm_positions[i] = i;
 104         p->midi_position = p->pcm_channels;
 105
 106         /*
 107          * We do not know the actual MIDI FIFO size of most devices.  Just
 108          * assume two bytes, i.e., one byte can be received over the bus while
 109          * the previous one is transmitted over MIDI.
 110          * (The value here is adjusted for midi_ratelimit_per_packet().)
 111          */
 112         p->midi_fifo_limit = rate - MIDI_BYTES_PER_SECOND * s->syt_interval + 1;
 113
 114         return 0;
 115 }
 116 EXPORT_SYMBOL_GPL(amdtp_am824_set_parameters);
 117
 118 /**
 119  * amdtp_am824_set_pcm_position - set an index of data channel for a channel
 120  *                                of PCM frame
 121  * @s: the AMDTP stream
 122  * @index: the index of data channel in an data block
 123  * @position: the channel of PCM frame
 124  */
 125 void amdtp_am824_set_pcm_position(struct amdtp_stream *s, unsigned int index,
 126                                  unsigned int position)
 127 {
 128         struct amdtp_am824 *p = s->protocol;
 129
 130         if (index < p->pcm_channels)
 131                 p->pcm_positions[index] = position;
 132 }
 133 EXPORT_SYMBOL_GPL(amdtp_am824_set_pcm_position);
 134
 135 /**
 136  * amdtp_am824_set_midi_position - set a index of data channel for MIDI
 137  *                                 conformant data channel
 138  * @s: the AMDTP stream
 139  * @position: the index of data channel in an data block
 140  */
 141 void amdtp_am824_set_midi_position(struct amdtp_stream *s,
 142                                    unsigned int position)
 143 {
 144         struct amdtp_am824 *p = s->protocol;
 145
 146         p->midi_position = position;
 147 }
 148 EXPORT_SYMBOL_GPL(amdtp_am824_set_midi_position);
 149
 150 static void write_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
 151                           __be32 *buffer, unsigned int frames,
 152                           unsigned int pcm_frames)
 153 {
 154         struct amdtp_am824 *p = s->protocol;
 155         unsigned int channels = p->pcm_channels;
 156         struct snd_pcm_runtime *runtime = pcm->runtime;
 157         unsigned int pcm_buffer_pointer;
 158         int remaining_frames;
 159         const u32 *src;
 160         int i, c;
 161
 162         pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
 163         pcm_buffer_pointer %= runtime->buffer_size;
 164
 165         src = (void *)runtime->dma_area +
 166                                 frames_to_bytes(runtime, pcm_buffer_pointer);
 167         remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
 168
 169         for (i = 0; i < frames; ++i) {
 170                 for (c = 0; c < channels; ++c) {
 171                         buffer[p->pcm_positions[c]] =
 172                                         cpu_to_be32((*src >> 8) | 0x40000000);
 173                         src++;
 174                 }
 175                 buffer += s->data_block_quadlets;
 176                 if (--remaining_frames == 0)
 177                         src = (void *)runtime->dma_area;
 178         }
 179 }
 180
 181 static void read_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
 182                          __be32 *buffer, unsigned int frames,
 183                          unsigned int pcm_frames)
 184 {
 185         struct amdtp_am824 *p = s->protocol;
 186         unsigned int channels = p->pcm_channels;
 187         struct snd_pcm_runtime *runtime = pcm->runtime;
 188         unsigned int pcm_buffer_pointer;
 189         int remaining_frames;
 190         u32 *dst;
 191         int i, c;
 192
 193         pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
 194         pcm_buffer_pointer %= runtime->buffer_size;
 195
 196         dst  = (void *)runtime->dma_area +
 197                                 frames_to_bytes(runtime, pcm_buffer_pointer);
 198         remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
 199
 200         for (i = 0; i < frames; ++i) {
 201                 for (c = 0; c < channels; ++c) {
 202                         *dst = be32_to_cpu(buffer[p->pcm_positions[c]]) << 8;
 203                         dst++;
 204                 }
 205                 buffer += s->data_block_quadlets;
 206                 if (--remaining_frames == 0)
 207                         dst = (void *)runtime->dma_area;
 208         }
 209 }
 210
 211 static void write_pcm_silence(struct amdtp_stream *s,
 212                               __be32 *buffer, unsigned int frames)
 213 {
 214         struct amdtp_am824 *p = s->protocol;
 215         unsigned int i, c, channels = p->pcm_channels;
 216
 217         for (i = 0; i < frames; ++i) {
 218                 for (c = 0; c < channels; ++c)
 219                         buffer[p->pcm_positions[c]] = cpu_to_be32(0x40000000);
 220                 buffer += s->data_block_quadlets;
 221         }
 222 }
 223
 224 /**
 225  * amdtp_am824_add_pcm_hw_constraints - add hw constraints for PCM substream
 226  * @s:          the AMDTP stream for AM824 data block, must be initialized.
 227  * @runtime:    the PCM substream runtime
 228  *
 229  */
 230 int amdtp_am824_add_pcm_hw_constraints(struct amdtp_stream *s,
 231                                        struct snd_pcm_runtime *runtime)
 232 {
 233         int err;
 234
 235         err = amdtp_stream_add_pcm_hw_constraints(s, runtime);
 236         if (err < 0)
 237                 return err;
 238
 239         /* AM824 in IEC 61883-6 can deliver 24bit data. */
 240         return snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
 241 }
 242 EXPORT_SYMBOL_GPL(amdtp_am824_add_pcm_hw_constraints);
 243
 244 /**
 245  * amdtp_am824_midi_trigger - start/stop playback/capture with a MIDI device
 246  * @s: the AMDTP stream
 247  * @port: index of MIDI port
 248  * @midi: the MIDI device to be started, or %NULL to stop the current device
 249  *
 250  * Call this function on a running isochronous stream to enable the actual
 251  * transmission of MIDI data.  This function should be called from the MIDI
 252  * device's .trigger callback.
 253  */
 254 void amdtp_am824_midi_trigger(struct amdtp_stream *s, unsigned int port,
 255                               struct snd_rawmidi_substream *midi)
 256 {
 257         struct amdtp_am824 *p = s->protocol;
 258
 259         if (port < p->midi_ports)
 260                 WRITE_ONCE(p->midi[port], midi);
 261 }
 262 EXPORT_SYMBOL_GPL(amdtp_am824_midi_trigger);
 263
 264 /*
 265  * To avoid sending MIDI bytes at too high a rate, assume that the receiving
 266  * device has a FIFO, and track how much it is filled.  This values increases
 267  * by one whenever we send one byte in a packet, but the FIFO empties at
 268  * a constant rate independent of our packet rate.  One packet has syt_interval
 269  * samples, so the number of bytes that empty out of the FIFO, per packet(!),
 270  * is MIDI_BYTES_PER_SECOND * syt_interval / sample_rate.  To avoid storing
 271  * fractional values, the values in midi_fifo_used[] are measured in bytes
 272  * multiplied by the sample rate.
 273  */
 274 static bool midi_ratelimit_per_packet(struct amdtp_stream *s, unsigned int port)
 275 {
 276         struct amdtp_am824 *p = s->protocol;
 277         int used;
 278
 279         used = p->midi_fifo_used[port];
 280         if (used == 0) /* common shortcut */
 281                 return true;
 282
 283         used -= MIDI_BYTES_PER_SECOND * s->syt_interval;
 284         used = max(used, 0);
 285         p->midi_fifo_used[port] = used;
 286
 287         return used < p->midi_fifo_limit;
 288 }
 289
 290 static void midi_rate_use_one_byte(struct amdtp_stream *s, unsigned int port)
 291 {
 292         struct amdtp_am824 *p = s->protocol;
 293
 294         p->midi_fifo_used[port] += amdtp_rate_table[s->sfc];
 295 }
 296
 297 static void write_midi_messages(struct amdtp_stream *s, __be32 *buffer,
 298                         unsigned int frames, unsigned int data_block_counter)
 299 {
 300         struct amdtp_am824 *p = s->protocol;
 301         unsigned int f, port;
 302         u8 *b;
 303
 304         for (f = 0; f < frames; f++) {
 305                 b = (u8 *)&buffer[p->midi_position];
 306
 307                 port = (data_block_counter + f) % 8;
 308                 if (f < MAX_MIDI_RX_BLOCKS &&
 309                     midi_ratelimit_per_packet(s, port) &&
 310                     p->midi[port] != NULL &&
 311                     snd_rawmidi_transmit(p->midi[port], &b[1], 1) == 1) {
 312                         midi_rate_use_one_byte(s, port);
 313                         b[0] = 0x81;
 314                 } else {
 315                         b[0] = 0x80;
 316                         b[1] = 0;
 317                 }
 318                 b[2] = 0;
 319                 b[3] = 0;
 320
 321                 buffer += s->data_block_quadlets;
 322         }
 323 }
 324
 325 static void read_midi_messages(struct amdtp_stream *s, __be32 *buffer,
 326                         unsigned int frames, unsigned int data_block_counter)
 327 {
 328         struct amdtp_am824 *p = s->protocol;
 329         int len;
 330         u8 *b;
 331         int f;
 332
 333         for (f = 0; f < frames; f++) {
 334                 unsigned int port = f;
 335
 336                 if (!(s->flags & CIP_UNALIGHED_DBC))
 337                         port += data_block_counter;
 338                 port %= 8;
 339                 b = (u8 *)&buffer[p->midi_position];
 340
 341                 len = b[0] - 0x80;
 342                 if ((1 <= len) &&  (len <= 3) && (p->midi[port]))
 343                         snd_rawmidi_receive(p->midi[port], b + 1, len);
 344
 345                 buffer += s->data_block_quadlets;
 346         }
 347 }
 348
 349 static unsigned int process_it_ctx_payloads(struct amdtp_stream *s,
 350                                             const struct pkt_desc *descs,
 351                                             unsigned int packets,
 352                                             struct snd_pcm_substream *pcm)
 353 {
 354         struct amdtp_am824 *p = s->protocol;
 355         unsigned int pcm_frames = 0;
 356         int i;
 357
 358         for (i = 0; i < packets; ++i) {
 359                 const struct pkt_desc *desc = descs + i;
 360                 __be32 *buf = desc->ctx_payload;
 361                 unsigned int data_blocks = desc->data_blocks;
 362
 363                 if (pcm) {
 364                         write_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
 365                         pcm_frames += data_blocks * p->frame_multiplier;
 366                 } else {
 367                         write_pcm_silence(s, buf, data_blocks);
 368                 }
 369
 370                 if (p->midi_ports) {
 371                         write_midi_messages(s, buf, data_blocks,
 372                                             desc->data_block_counter);
 373                 }
 374         }
 375
 376         return pcm_frames;
 377 }
 378
 379 static unsigned int process_ir_ctx_payloads(struct amdtp_stream *s,
 380                                             const struct pkt_desc *descs,
 381                                             unsigned int packets,
 382                                             struct snd_pcm_substream *pcm)
 383 {
 384         struct amdtp_am824 *p = s->protocol;
 385         unsigned int pcm_frames = 0;
 386         int i;
 387
 388         for (i = 0; i < packets; ++i) {
 389                 const struct pkt_desc *desc = descs + i;
 390                 __be32 *buf = desc->ctx_payload;
 391                 unsigned int data_blocks = desc->data_blocks;
 392
 393                 if (pcm) {
 394                         read_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
 395                         pcm_frames += data_blocks * p->frame_multiplier;
 396                 }
 397
 398                 if (p->midi_ports) {
 399                         read_midi_messages(s, buf, data_blocks,
 400                                            desc->data_block_counter);
 401                 }
 402         }
 403
 404         return pcm_frames;
 405 }
 406
 407 /**
 408  * amdtp_am824_init - initialize an AMDTP stream structure to handle AM824
 409  *                    data block
 410  * @s: the AMDTP stream to initialize
 411  * @unit: the target of the stream
 412  * @dir: the direction of stream
 413  * @flags: the packet transmission method to use
 414  */
 415 int amdtp_am824_init(struct amdtp_stream *s, struct fw_unit *unit,
 416                      enum amdtp_stream_direction dir, enum cip_flags flags)
 417 {
 418         amdtp_stream_process_ctx_payloads_t process_ctx_payloads;
 419
 420         if (dir == AMDTP_IN_STREAM)
 421                 process_ctx_payloads = process_ir_ctx_payloads;
 422         else
 423                 process_ctx_payloads = process_it_ctx_payloads;
 424
 425         return amdtp_stream_init(s, unit, dir, flags, CIP_FMT_AM,
 426                         process_ctx_payloads, sizeof(struct amdtp_am824));
 427 }
 428 EXPORT_SYMBOL_GPL(amdtp_am824_init);