sound/firewire/motu/amdtp-motu.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * amdtp-motu.c - a part of driver for MOTU FireWire series
   4  *
   5  * Copyright (c) 2015-2017 Takashi Sakamoto <o-takashi@sakamocchi.jp>
   6  */
   7
   8 #include <linux/slab.h>
   9 #include <sound/pcm.h>
  10 #include "motu.h"
  11
  12 #define CREATE_TRACE_POINTS
  13 #include "amdtp-motu-trace.h"
  14
  15 #define CIP_FMT_MOTU            0x02
  16 #define CIP_FMT_MOTU_TX_V3      0x22
  17 #define MOTU_FDF_AM824          0x22
  18
  19 #define TICKS_PER_CYCLE         3072
  20 #define CYCLES_PER_SECOND       8000
  21 #define TICKS_PER_SECOND        (TICKS_PER_CYCLE * CYCLES_PER_SECOND)
  22
  23 #define IEEE1394_SEC_MODULUS    128
  24
  25 #define TRANSFER_DELAY_TICKS    0x2e00 /* 479.17 microseconds */
  26
  27 #define CIP_SPH_CYCLE_SHIFT     12
  28 #define CIP_SPH_CYCLE_MASK      0x01fff000
  29 #define CIP_SPH_OFFSET_MASK     0x00000fff
  30
  31 /*
  32  * Nominally 3125 bytes/second, but the MIDI port's clock might be
  33  * 1% too slow, and the bus clock 100 ppm too fast.
  34  */
  35 #define MIDI_BYTES_PER_SECOND   3093
  36
  37 struct amdtp_motu {
  38         /* For timestamp processing.  */
  39         unsigned int quotient_ticks_per_event;
  40         unsigned int remainder_ticks_per_event;
  41         unsigned int next_ticks;
  42         unsigned int next_accumulated;
  43         unsigned int next_cycles;
  44         unsigned int next_seconds;
  45
  46         unsigned int pcm_chunks;
  47         unsigned int pcm_byte_offset;
  48
  49         struct snd_rawmidi_substream *midi;
  50         unsigned int midi_ports;
  51         unsigned int midi_flag_offset;
  52         unsigned int midi_byte_offset;
  53
  54         int midi_db_count;
  55         unsigned int midi_db_interval;
  56
  57         struct amdtp_motu_cache *cache;
  58 };
  59
  60 int amdtp_motu_set_parameters(struct amdtp_stream *s, unsigned int rate,
  61                               unsigned int midi_ports,
  62                               struct snd_motu_packet_format *formats)
  63 {
  64         static const struct {
  65                 unsigned int quotient_ticks_per_event;
  66                 unsigned int remainder_ticks_per_event;
  67         } params[] = {
  68                 [CIP_SFC_44100]  = { 557, 123 },
  69                 [CIP_SFC_48000]  = { 512,   0 },
  70                 [CIP_SFC_88200]  = { 278, 282 },
  71                 [CIP_SFC_96000]  = { 256,   0 },
  72                 [CIP_SFC_176400] = { 139, 141 },
  73                 [CIP_SFC_192000] = { 128,   0 },
  74         };
  75         struct amdtp_motu *p = s->protocol;
  76         unsigned int pcm_chunks, data_chunks, data_block_quadlets;
  77         unsigned int delay;
  78         unsigned int mode;
  79         int i, err;
  80
  81         if (amdtp_stream_running(s))
  82                 return -EBUSY;
  83
  84         for (i = 0; i < ARRAY_SIZE(snd_motu_clock_rates); ++i) {
  85                 if (snd_motu_clock_rates[i] == rate) {
  86                         mode = i >> 1;
  87                         break;
  88                 }
  89         }
  90         if (i == ARRAY_SIZE(snd_motu_clock_rates))
  91                 return -EINVAL;
  92
  93         // Each data block includes SPH in its head. Data chunks follow with
  94         // 3 byte alignment. Padding follows with zero to conform to quadlet
  95         // alignment.
  96         pcm_chunks = formats->pcm_chunks[mode];
  97         data_chunks = formats->msg_chunks + pcm_chunks;
  98         data_block_quadlets = 1 + DIV_ROUND_UP(data_chunks * 3, 4);
  99
 100         err = amdtp_stream_set_parameters(s, rate, data_block_quadlets);
 101         if (err < 0)
 102                 return err;
 103
 104         p->pcm_chunks = pcm_chunks;
 105         p->pcm_byte_offset = formats->pcm_byte_offset;
 106
 107         p->midi_ports = midi_ports;
 108         p->midi_flag_offset = formats->midi_flag_offset;
 109         p->midi_byte_offset = formats->midi_byte_offset;
 110
 111         p->midi_db_count = 0;
 112         p->midi_db_interval = rate / MIDI_BYTES_PER_SECOND;
 113
 114         delay = TRANSFER_DELAY_TICKS;
 115
 116         // For no-data or empty packets to adjust PCM sampling frequency.
 117         delay += TICKS_PER_SECOND * s->syt_interval / rate;
 118
 119         p->next_seconds = 0;
 120         p->next_cycles = delay / TICKS_PER_CYCLE;
 121         p->quotient_ticks_per_event = params[s->sfc].quotient_ticks_per_event;
 122         p->remainder_ticks_per_event = params[s->sfc].remainder_ticks_per_event;
 123         p->next_ticks = delay % TICKS_PER_CYCLE;
 124         p->next_accumulated = 0;
 125
 126         return 0;
 127 }
 128
 129 static void read_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
 130                          __be32 *buffer, unsigned int data_blocks,
 131                          unsigned int pcm_frames)
 132 {
 133         struct amdtp_motu *p = s->protocol;
 134         unsigned int channels = p->pcm_chunks;
 135         struct snd_pcm_runtime *runtime = pcm->runtime;
 136         unsigned int pcm_buffer_pointer;
 137         int remaining_frames;
 138         u8 *byte;
 139         u32 *dst;
 140         int i, c;
 141
 142         pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
 143         pcm_buffer_pointer %= runtime->buffer_size;
 144
 145         dst = (void *)runtime->dma_area +
 146                                 frames_to_bytes(runtime, pcm_buffer_pointer);
 147         remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
 148
 149         for (i = 0; i < data_blocks; ++i) {
 150                 byte = (u8 *)buffer + p->pcm_byte_offset;
 151
 152                 for (c = 0; c < channels; ++c) {
 153                         *dst = (byte[0] << 24) |
 154                                (byte[1] << 16) |
 155                                (byte[2] << 8);
 156                         byte += 3;
 157                         dst++;
 158                 }
 159                 buffer += s->data_block_quadlets;
 160                 if (--remaining_frames == 0)
 161                         dst = (void *)runtime->dma_area;
 162         }
 163 }
 164
 165 static void write_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
 166                           __be32 *buffer, unsigned int data_blocks,
 167                           unsigned int pcm_frames)
 168 {
 169         struct amdtp_motu *p = s->protocol;
 170         unsigned int channels = p->pcm_chunks;
 171         struct snd_pcm_runtime *runtime = pcm->runtime;
 172         unsigned int pcm_buffer_pointer;
 173         int remaining_frames;
 174         u8 *byte;
 175         const u32 *src;
 176         int i, c;
 177
 178         pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
 179         pcm_buffer_pointer %= runtime->buffer_size;
 180
 181         src = (void *)runtime->dma_area +
 182                                 frames_to_bytes(runtime, pcm_buffer_pointer);
 183         remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
 184
 185         for (i = 0; i < data_blocks; ++i) {
 186                 byte = (u8 *)buffer + p->pcm_byte_offset;
 187
 188                 for (c = 0; c < channels; ++c) {
 189                         byte[0] = (*src >> 24) & 0xff;
 190                         byte[1] = (*src >> 16) & 0xff;
 191                         byte[2] = (*src >>  8) & 0xff;
 192                         byte += 3;
 193                         src++;
 194                 }
 195
 196                 buffer += s->data_block_quadlets;
 197                 if (--remaining_frames == 0)
 198                         src = (void *)runtime->dma_area;
 199         }
 200 }
 201
 202 static void write_pcm_silence(struct amdtp_stream *s, __be32 *buffer,
 203                               unsigned int data_blocks)
 204 {
 205         struct amdtp_motu *p = s->protocol;
 206         unsigned int channels, i, c;
 207         u8 *byte;
 208
 209         channels = p->pcm_chunks;
 210
 211         for (i = 0; i < data_blocks; ++i) {
 212                 byte = (u8 *)buffer + p->pcm_byte_offset;
 213
 214                 for (c = 0; c < channels; ++c) {
 215                         byte[0] = 0;
 216                         byte[1] = 0;
 217                         byte[2] = 0;
 218                         byte += 3;
 219                 }
 220
 221                 buffer += s->data_block_quadlets;
 222         }
 223 }
 224
 225 int amdtp_motu_add_pcm_hw_constraints(struct amdtp_stream *s,
 226                                       struct snd_pcm_runtime *runtime)
 227 {
 228         int err;
 229
 230         /* TODO: how to set an constraint for exactly 24bit PCM sample? */
 231         err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
 232         if (err < 0)
 233                 return err;
 234
 235         return amdtp_stream_add_pcm_hw_constraints(s, runtime);
 236 }
 237
 238 void amdtp_motu_midi_trigger(struct amdtp_stream *s, unsigned int port,
 239                              struct snd_rawmidi_substream *midi)
 240 {
 241         struct amdtp_motu *p = s->protocol;
 242
 243         if (port < p->midi_ports)
 244                 WRITE_ONCE(p->midi, midi);
 245 }
 246
 247 static void write_midi_messages(struct amdtp_stream *s, __be32 *buffer,
 248                                 unsigned int data_blocks)
 249 {
 250         struct amdtp_motu *p = s->protocol;
 251         struct snd_rawmidi_substream *midi = READ_ONCE(p->midi);
 252         u8 *b;
 253         int i;
 254
 255         for (i = 0; i < data_blocks; i++) {
 256                 b = (u8 *)buffer;
 257
 258                 if (midi && p->midi_db_count == 0 &&
 259                     snd_rawmidi_transmit(midi, b + p->midi_byte_offset, 1) == 1) {
 260                         b[p->midi_flag_offset] = 0x01;
 261                 } else {
 262                         b[p->midi_byte_offset] = 0x00;
 263                         b[p->midi_flag_offset] = 0x00;
 264                 }
 265
 266                 buffer += s->data_block_quadlets;
 267
 268                 if (--p->midi_db_count < 0)
 269                         p->midi_db_count = p->midi_db_interval;
 270         }
 271 }
 272
 273 static void read_midi_messages(struct amdtp_stream *s, __be32 *buffer,
 274                                unsigned int data_blocks)
 275 {
 276         struct amdtp_motu *p = s->protocol;
 277         struct snd_rawmidi_substream *midi;
 278         u8 *b;
 279         int i;
 280
 281         for (i = 0; i < data_blocks; i++) {
 282                 b = (u8 *)buffer;
 283                 midi = READ_ONCE(p->midi);
 284
 285                 if (midi && (b[p->midi_flag_offset] & 0x01))
 286                         snd_rawmidi_receive(midi, b + p->midi_byte_offset, 1);
 287
 288                 buffer += s->data_block_quadlets;
 289         }
 290 }
 291
 292 /* For tracepoints. */
 293 static void __maybe_unused copy_sph(u32 *frames, __be32 *buffer,
 294                                     unsigned int data_blocks,
 295                                     unsigned int data_block_quadlets)
 296 {
 297         unsigned int i;
 298
 299         for (i = 0; i < data_blocks; ++i) {
 300                 *frames = be32_to_cpu(*buffer);
 301                 buffer += data_block_quadlets;
 302                 frames++;
 303         }
 304 }
 305
 306 /* For tracepoints. */
 307 static void __maybe_unused copy_message(u64 *frames, __be32 *buffer,
 308                                         unsigned int data_blocks,
 309                                         unsigned int data_block_quadlets)
 310 {
 311         unsigned int i;
 312
 313         /* This is just for v2/v3 protocol. */
 314         for (i = 0; i < data_blocks; ++i) {
 315                 *frames = (be32_to_cpu(buffer[1]) << 16) |
 316                           (be32_to_cpu(buffer[2]) >> 16);
 317                 buffer += data_block_quadlets;
 318                 frames++;
 319         }
 320 }
 321
 322 static void probe_tracepoints_events(struct amdtp_stream *s,
 323                                      const struct pkt_desc *descs,
 324                                      unsigned int packets)
 325 {
 326         int i;
 327
 328         for (i = 0; i < packets; ++i) {
 329                 const struct pkt_desc *desc = descs + i;
 330                 __be32 *buf = desc->ctx_payload;
 331                 unsigned int data_blocks = desc->data_blocks;
 332
 333                 trace_data_block_sph(s, data_blocks, buf);
 334                 trace_data_block_message(s, data_blocks, buf);
 335         }
 336 }
 337
 338 static void cache_event_offsets(struct amdtp_motu_cache *cache, const __be32 *buf,
 339                                 unsigned int data_blocks, unsigned int data_block_quadlets)
 340 {
 341         unsigned int *event_offsets = cache->event_offsets;
 342         const unsigned int cache_size = cache->size;
 343         unsigned int cache_tail = cache->tail;
 344         unsigned int base_tick = cache->tx_cycle_count * TICKS_PER_CYCLE;
 345         int i;
 346
 347         for (i = 0; i < data_blocks; ++i) {
 348                 u32 sph = be32_to_cpu(*buf);
 349                 unsigned int tick;
 350
 351                 tick = ((sph & CIP_SPH_CYCLE_MASK) >> CIP_SPH_CYCLE_SHIFT) * TICKS_PER_CYCLE +
 352                        (sph & CIP_SPH_OFFSET_MASK);
 353
 354                 if (tick < base_tick)
 355                         tick += TICKS_PER_SECOND;
 356                 event_offsets[cache_tail] = tick - base_tick;
 357
 358                 cache_tail = (cache_tail + 1) % cache_size;
 359                 buf += data_block_quadlets;
 360         }
 361
 362         cache->tail = cache_tail;
 363         cache->tx_cycle_count = (cache->tx_cycle_count + 1) % CYCLES_PER_SECOND;
 364 }
 365
 366 static unsigned int process_ir_ctx_payloads(struct amdtp_stream *s,
 367                                             const struct pkt_desc *descs,
 368                                             unsigned int packets,
 369                                             struct snd_pcm_substream *pcm)
 370 {
 371         struct amdtp_motu *p = s->protocol;
 372         unsigned int pcm_frames = 0;
 373         int i;
 374
 375         if (p->cache->tx_cycle_count == UINT_MAX)
 376                 p->cache->tx_cycle_count = (s->domain->processing_cycle.tx_start % CYCLES_PER_SECOND);
 377
 378         // For data block processing.
 379         for (i = 0; i < packets; ++i) {
 380                 const struct pkt_desc *desc = descs + i;
 381                 __be32 *buf = desc->ctx_payload;
 382                 unsigned int data_blocks = desc->data_blocks;
 383
 384                 cache_event_offsets(p->cache, buf, data_blocks, s->data_block_quadlets);
 385
 386                 if (pcm) {
 387                         read_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
 388                         pcm_frames += data_blocks;
 389                 }
 390
 391                 if (p->midi_ports)
 392                         read_midi_messages(s, buf, data_blocks);
 393         }
 394
 395         // For tracepoints.
 396         if (trace_data_block_sph_enabled() ||
 397             trace_data_block_message_enabled())
 398                 probe_tracepoints_events(s, descs, packets);
 399
 400         return pcm_frames;
 401 }
 402
 403 static inline void compute_next_elapse_from_start(struct amdtp_motu *p)
 404 {
 405         p->next_accumulated += p->remainder_ticks_per_event;
 406         if (p->next_accumulated >= 441) {
 407                 p->next_accumulated -= 441;
 408                 p->next_ticks++;
 409         }
 410
 411         p->next_ticks += p->quotient_ticks_per_event;
 412         if (p->next_ticks >= TICKS_PER_CYCLE) {
 413                 p->next_ticks -= TICKS_PER_CYCLE;
 414                 p->next_cycles++;
 415         }
 416
 417         if (p->next_cycles >= CYCLES_PER_SECOND) {
 418                 p->next_cycles -= CYCLES_PER_SECOND;
 419                 p->next_seconds++;
 420         }
 421
 422         if (p->next_seconds >= IEEE1394_SEC_MODULUS)
 423                 p->next_seconds -= IEEE1394_SEC_MODULUS;
 424 }
 425
 426 static void write_sph(struct amdtp_stream *s, __be32 *buffer, unsigned int data_blocks,
 427                       const unsigned int rx_start_cycle)
 428 {
 429         struct amdtp_motu *p = s->protocol;
 430         unsigned int next_cycles;
 431         unsigned int i;
 432         u32 sph;
 433
 434         for (i = 0; i < data_blocks; i++) {
 435                 next_cycles = (rx_start_cycle + p->next_cycles) % CYCLES_PER_SECOND;
 436                 sph = ((next_cycles << CIP_SPH_CYCLE_SHIFT) | p->next_ticks) &
 437                       (CIP_SPH_CYCLE_MASK | CIP_SPH_OFFSET_MASK);
 438                 *buffer = cpu_to_be32(sph);
 439
 440                 compute_next_elapse_from_start(p);
 441
 442                 buffer += s->data_block_quadlets;
 443         }
 444 }
 445
 446 static unsigned int process_it_ctx_payloads(struct amdtp_stream *s,
 447                                             const struct pkt_desc *descs,
 448                                             unsigned int packets,
 449                                             struct snd_pcm_substream *pcm)
 450 {
 451         const unsigned int rx_start_cycle = s->domain->processing_cycle.rx_start;
 452         struct amdtp_motu *p = s->protocol;
 453         unsigned int pcm_frames = 0;
 454         int i;
 455
 456         // For data block processing.
 457         for (i = 0; i < packets; ++i) {
 458                 const struct pkt_desc *desc = descs + i;
 459                 __be32 *buf = desc->ctx_payload;
 460                 unsigned int data_blocks = desc->data_blocks;
 461
 462                 if (pcm) {
 463                         write_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
 464                         pcm_frames += data_blocks;
 465                 } else {
 466                         write_pcm_silence(s, buf, data_blocks);
 467                 }
 468
 469                 if (p->midi_ports)
 470                         write_midi_messages(s, buf, data_blocks);
 471
 472                 // TODO: how to interact control messages between userspace?
 473
 474                 write_sph(s, buf, data_blocks, rx_start_cycle);
 475         }
 476
 477         // For tracepoints.
 478         if (trace_data_block_sph_enabled() ||
 479             trace_data_block_message_enabled())
 480                 probe_tracepoints_events(s, descs, packets);
 481
 482         return pcm_frames;
 483 }
 484
 485 int amdtp_motu_init(struct amdtp_stream *s, struct fw_unit *unit,
 486                     enum amdtp_stream_direction dir,
 487                     const struct snd_motu_spec *spec, struct amdtp_motu_cache *cache)
 488 {
 489         amdtp_stream_process_ctx_payloads_t process_ctx_payloads;
 490         int fmt = CIP_FMT_MOTU;
 491         unsigned int flags = CIP_BLOCKING | CIP_UNAWARE_SYT;
 492         struct amdtp_motu *p;
 493         int err;
 494
 495         if (dir == AMDTP_IN_STREAM) {
 496                 process_ctx_payloads = process_ir_ctx_payloads;
 497
 498                 /*
 499                  * Units of version 3 transmits packets with invalid CIP header
 500                  * against IEC 61883-1.
 501                  */
 502                 if (spec->protocol_version == SND_MOTU_PROTOCOL_V3) {
 503                         flags |= CIP_WRONG_DBS |
 504                                  CIP_SKIP_DBC_ZERO_CHECK |
 505                                  CIP_HEADER_WITHOUT_EOH;
 506                         fmt = CIP_FMT_MOTU_TX_V3;
 507                 }
 508
 509                 if (spec == &snd_motu_spec_8pre ||
 510                     spec == &snd_motu_spec_ultralite) {
 511                         // 8pre has some quirks.
 512                         flags |= CIP_WRONG_DBS |
 513                                  CIP_SKIP_DBC_ZERO_CHECK;
 514                 }
 515         } else {
 516                 process_ctx_payloads = process_it_ctx_payloads;
 517                 flags |= CIP_DBC_IS_END_EVENT;
 518         }
 519
 520         err = amdtp_stream_init(s, unit, dir, flags, fmt, process_ctx_payloads,
 521                                 sizeof(struct amdtp_motu));
 522         if (err < 0)
 523                 return err;
 524
 525         s->sph = 1;
 526
 527         if (dir == AMDTP_OUT_STREAM) {
 528                 // Use fixed value for FDF field.
 529                 s->ctx_data.rx.fdf = MOTU_FDF_AM824;
 530         }
 531
 532         p = s->protocol;
 533         p->cache = cache;
 534
 535         return 0;
 536 }