sound/firewire/amdtp-am824.c

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