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