1/* 2 * Audio and Music Data Transmission Protocol (IEC 61883-6) streams 3 * with Common Isochronous Packet (IEC 61883-1) headers 4 * 5 * Copyright (c) Clemens Ladisch <clemens@ladisch.de> 6 * Licensed under the terms of the GNU General Public License, version 2. 7 */ 8 9#include <linux/device.h> 10#include <linux/err.h> 11#include <linux/firewire.h> 12#include <linux/module.h> 13#include <linux/slab.h> 14#include <linux/sched.h> 15#include <sound/pcm.h> 16#include <sound/pcm_params.h> 17#include <sound/rawmidi.h> 18#include "amdtp.h" 19 20#define TICKS_PER_CYCLE 3072 21#define CYCLES_PER_SECOND 8000 22#define TICKS_PER_SECOND (TICKS_PER_CYCLE * CYCLES_PER_SECOND) 23 24/* 25 * Nominally 3125 bytes/second, but the MIDI port's clock might be 26 * 1% too slow, and the bus clock 100 ppm too fast. 27 */ 28#define MIDI_BYTES_PER_SECOND 3093 29 30/* 31 * Several devices look only at the first eight data blocks. 32 * In any case, this is more than enough for the MIDI data rate. 33 */ 34#define MAX_MIDI_RX_BLOCKS 8 35 36#define TRANSFER_DELAY_TICKS 0x2e00 /* 479.17 microseconds */ 37 38/* isochronous header parameters */ 39#define ISO_DATA_LENGTH_SHIFT 16 40#define TAG_CIP 1 41 42/* common isochronous packet header parameters */ 43#define CIP_EOH (1u << 31) 44#define CIP_EOH_MASK 0x80000000 45#define CIP_FMT_AM (0x10 << 24) 46#define CIP_FMT_MASK 0x3f000000 47#define CIP_SYT_MASK 0x0000ffff 48#define CIP_SYT_NO_INFO 0xffff 49#define CIP_FDF_MASK 0x00ff0000 50#define CIP_FDF_SFC_SHIFT 16 51 52/* 53 * Audio and Music transfer protocol specific parameters 54 * only "Clock-based rate control mode" is supported 55 */ 56#define AMDTP_FDF_AM824 (0 << (CIP_FDF_SFC_SHIFT + 3)) 57#define AMDTP_FDF_NO_DATA 0xff 58#define AMDTP_DBS_MASK 0x00ff0000 59#define AMDTP_DBS_SHIFT 16 60#define AMDTP_DBC_MASK 0x000000ff 61 62/* TODO: make these configurable */ 63#define INTERRUPT_INTERVAL 16 64#define QUEUE_LENGTH 48 65 66#define IN_PACKET_HEADER_SIZE 4 67#define OUT_PACKET_HEADER_SIZE 0 68 69static void pcm_period_tasklet(unsigned long data); 70 71/** 72 * amdtp_stream_init - initialize an AMDTP stream structure 73 * @s: the AMDTP stream to initialize 74 * @unit: the target of the stream 75 * @dir: the direction of stream 76 * @flags: the packet transmission method to use 77 */ 78int amdtp_stream_init(struct amdtp_stream *s, struct fw_unit *unit, 79 enum amdtp_stream_direction dir, enum cip_flags flags) 80{ 81 s->unit = unit; 82 s->direction = dir; 83 s->flags = flags; 84 s->context = ERR_PTR(-1); 85 mutex_init(&s->mutex); 86 tasklet_init(&s->period_tasklet, pcm_period_tasklet, (unsigned long)s); 87 s->packet_index = 0; 88 89 init_waitqueue_head(&s->callback_wait); 90 s->callbacked = false; 91 s->sync_slave = NULL; 92 93 return 0; 94} 95EXPORT_SYMBOL(amdtp_stream_init); 96 97/** 98 * amdtp_stream_destroy - free stream resources 99 * @s: the AMDTP stream to destroy 100 */ 101void amdtp_stream_destroy(struct amdtp_stream *s) 102{ 103 WARN_ON(amdtp_stream_running(s)); 104 mutex_destroy(&s->mutex); 105} 106EXPORT_SYMBOL(amdtp_stream_destroy); 107 108const unsigned int amdtp_syt_intervals[CIP_SFC_COUNT] = { 109 [CIP_SFC_32000] = 8, 110 [CIP_SFC_44100] = 8, 111 [CIP_SFC_48000] = 8, 112 [CIP_SFC_88200] = 16, 113 [CIP_SFC_96000] = 16, 114 [CIP_SFC_176400] = 32, 115 [CIP_SFC_192000] = 32, 116}; 117EXPORT_SYMBOL(amdtp_syt_intervals); 118 119const unsigned int amdtp_rate_table[CIP_SFC_COUNT] = { 120 [CIP_SFC_32000] = 32000, 121 [CIP_SFC_44100] = 44100, 122 [CIP_SFC_48000] = 48000, 123 [CIP_SFC_88200] = 88200, 124 [CIP_SFC_96000] = 96000, 125 [CIP_SFC_176400] = 176400, 126 [CIP_SFC_192000] = 192000, 127}; 128EXPORT_SYMBOL(amdtp_rate_table); 129 130/** 131 * amdtp_stream_add_pcm_hw_constraints - add hw constraints for PCM substream 132 * @s: the AMDTP stream, which must be initialized. 133 * @runtime: the PCM substream runtime 134 */ 135int amdtp_stream_add_pcm_hw_constraints(struct amdtp_stream *s, 136 struct snd_pcm_runtime *runtime) 137{ 138 int err; 139 140 /* AM824 in IEC 61883-6 can deliver 24bit data */ 141 err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24); 142 if (err < 0) 143 goto end; 144 145 /* 146 * Currently firewire-lib processes 16 packets in one software 147 * interrupt callback. This equals to 2msec but actually the 148 * interval of the interrupts has a jitter. 149 * Additionally, even if adding a constraint to fit period size to 150 * 2msec, actual calculated frames per period doesn't equal to 2msec, 151 * depending on sampling rate. 152 * Anyway, the interval to call snd_pcm_period_elapsed() cannot 2msec. 153 * Here let us use 5msec for safe period interrupt. 154 */ 155 err = snd_pcm_hw_constraint_minmax(runtime, 156 SNDRV_PCM_HW_PARAM_PERIOD_TIME, 157 5000, UINT_MAX); 158 if (err < 0) 159 goto end; 160 161 /* Non-Blocking stream has no more constraints */ 162 if (!(s->flags & CIP_BLOCKING)) 163 goto end; 164 165 /* 166 * One AMDTP packet can include some frames. In blocking mode, the 167 * number equals to SYT_INTERVAL. So the number is 8, 16 or 32, 168 * depending on its sampling rate. For accurate period interrupt, it's 169 * preferrable to align period/buffer sizes to current SYT_INTERVAL. 170 * 171 * TODO: These constraints can be improved with proper rules. 172 * Currently apply LCM of SYT_INTERVALs. 173 */ 174 err = snd_pcm_hw_constraint_step(runtime, 0, 175 SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 32); 176 if (err < 0) 177 goto end; 178 err = snd_pcm_hw_constraint_step(runtime, 0, 179 SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 32); 180end: 181 return err; 182} 183EXPORT_SYMBOL(amdtp_stream_add_pcm_hw_constraints); 184 185/** 186 * amdtp_stream_set_parameters - set stream parameters 187 * @s: the AMDTP stream to configure 188 * @rate: the sample rate 189 * @pcm_channels: the number of PCM samples in each data block, to be encoded 190 * as AM824 multi-bit linear audio 191 * @midi_ports: the number of MIDI ports (i.e., MPX-MIDI Data Channels) 192 * 193 * The parameters must be set before the stream is started, and must not be 194 * changed while the stream is running. 195 */ 196void amdtp_stream_set_parameters(struct amdtp_stream *s, 197 unsigned int rate, 198 unsigned int pcm_channels, 199 unsigned int midi_ports) 200{ 201 unsigned int i, sfc, midi_channels; 202 203 midi_channels = DIV_ROUND_UP(midi_ports, 8); 204 205 if (WARN_ON(amdtp_stream_running(s)) | 206 WARN_ON(pcm_channels > AMDTP_MAX_CHANNELS_FOR_PCM) | 207 WARN_ON(midi_channels > AMDTP_MAX_CHANNELS_FOR_MIDI)) 208 return; 209 210 for (sfc = 0; sfc < ARRAY_SIZE(amdtp_rate_table); ++sfc) 211 if (amdtp_rate_table[sfc] == rate) 212 goto sfc_found; 213 WARN_ON(1); 214 return; 215 216sfc_found: 217 s->pcm_channels = pcm_channels; 218 s->sfc = sfc; 219 s->data_block_quadlets = s->pcm_channels + midi_channels; 220 s->midi_ports = midi_ports; 221 222 s->syt_interval = amdtp_syt_intervals[sfc]; 223 224 /* default buffering in the device */ 225 s->transfer_delay = TRANSFER_DELAY_TICKS - TICKS_PER_CYCLE; 226 if (s->flags & CIP_BLOCKING) 227 /* additional buffering needed to adjust for no-data packets */ 228 s->transfer_delay += TICKS_PER_SECOND * s->syt_interval / rate; 229 230 /* init the position map for PCM and MIDI channels */ 231 for (i = 0; i < pcm_channels; i++) 232 s->pcm_positions[i] = i; 233 s->midi_position = s->pcm_channels; 234 235 /* 236 * We do not know the actual MIDI FIFO size of most devices. Just 237 * assume two bytes, i.e., one byte can be received over the bus while 238 * the previous one is transmitted over MIDI. 239 * (The value here is adjusted for midi_ratelimit_per_packet().) 240 */ 241 s->midi_fifo_limit = rate - MIDI_BYTES_PER_SECOND * s->syt_interval + 1; 242} 243EXPORT_SYMBOL(amdtp_stream_set_parameters); 244 245/** 246 * amdtp_stream_get_max_payload - get the stream's packet size 247 * @s: the AMDTP stream 248 * 249 * This function must not be called before the stream has been configured 250 * with amdtp_stream_set_parameters(). 251 */ 252unsigned int amdtp_stream_get_max_payload(struct amdtp_stream *s) 253{ 254 return 8 + s->syt_interval * s->data_block_quadlets * 4; 255} 256EXPORT_SYMBOL(amdtp_stream_get_max_payload); 257 258static void amdtp_write_s16(struct amdtp_stream *s, 259 struct snd_pcm_substream *pcm, 260 __be32 *buffer, unsigned int frames); 261static void amdtp_write_s32(struct amdtp_stream *s, 262 struct snd_pcm_substream *pcm, 263 __be32 *buffer, unsigned int frames); 264static void amdtp_read_s32(struct amdtp_stream *s, 265 struct snd_pcm_substream *pcm, 266 __be32 *buffer, unsigned int frames); 267 268/** 269 * amdtp_stream_set_pcm_format - set the PCM format 270 * @s: the AMDTP stream to configure 271 * @format: the format of the ALSA PCM device 272 * 273 * The sample format must be set after the other parameters (rate/PCM channels/ 274 * MIDI) and before the stream is started, and must not be changed while the 275 * stream is running. 276 */ 277void amdtp_stream_set_pcm_format(struct amdtp_stream *s, 278 snd_pcm_format_t format) 279{ 280 if (WARN_ON(amdtp_stream_pcm_running(s))) 281 return; 282 283 switch (format) { 284 default: 285 WARN_ON(1); 286 /* fall through */ 287 case SNDRV_PCM_FORMAT_S16: 288 if (s->direction == AMDTP_OUT_STREAM) { 289 s->transfer_samples = amdtp_write_s16; 290 break; 291 } 292 WARN_ON(1); 293 /* fall through */ 294 case SNDRV_PCM_FORMAT_S32: 295 if (s->direction == AMDTP_OUT_STREAM) 296 s->transfer_samples = amdtp_write_s32; 297 else 298 s->transfer_samples = amdtp_read_s32; 299 break; 300 } 301} 302EXPORT_SYMBOL(amdtp_stream_set_pcm_format); 303 304/** 305 * amdtp_stream_pcm_prepare - prepare PCM device for running 306 * @s: the AMDTP stream 307 * 308 * This function should be called from the PCM device's .prepare callback. 309 */ 310void amdtp_stream_pcm_prepare(struct amdtp_stream *s) 311{ 312 tasklet_kill(&s->period_tasklet); 313 s->pcm_buffer_pointer = 0; 314 s->pcm_period_pointer = 0; 315 s->pointer_flush = true; 316} 317EXPORT_SYMBOL(amdtp_stream_pcm_prepare); 318 319static unsigned int calculate_data_blocks(struct amdtp_stream *s) 320{ 321 unsigned int phase, data_blocks; 322 323 if (s->flags & CIP_BLOCKING) 324 data_blocks = s->syt_interval; 325 else if (!cip_sfc_is_base_44100(s->sfc)) { 326 /* Sample_rate / 8000 is an integer, and precomputed. */ 327 data_blocks = s->data_block_state; 328 } else { 329 phase = s->data_block_state; 330 331 /* 332 * This calculates the number of data blocks per packet so that 333 * 1) the overall rate is correct and exactly synchronized to 334 * the bus clock, and 335 * 2) packets with a rounded-up number of blocks occur as early 336 * as possible in the sequence (to prevent underruns of the 337 * device's buffer). 338 */ 339 if (s->sfc == CIP_SFC_44100) 340 /* 6 6 5 6 5 6 5 ... */ 341 data_blocks = 5 + ((phase & 1) ^ 342 (phase == 0 || phase >= 40)); 343 else 344 /* 12 11 11 11 11 ... or 23 22 22 22 22 ... */ 345 data_blocks = 11 * (s->sfc >> 1) + (phase == 0); 346 if (++phase >= (80 >> (s->sfc >> 1))) 347 phase = 0; 348 s->data_block_state = phase; 349 } 350 351 return data_blocks; 352} 353 354static unsigned int calculate_syt(struct amdtp_stream *s, 355 unsigned int cycle) 356{ 357 unsigned int syt_offset, phase, index, syt; 358 359 if (s->last_syt_offset < TICKS_PER_CYCLE) { 360 if (!cip_sfc_is_base_44100(s->sfc)) 361 syt_offset = s->last_syt_offset + s->syt_offset_state; 362 else { 363 /* 364 * The time, in ticks, of the n'th SYT_INTERVAL sample is: 365 * n * SYT_INTERVAL * 24576000 / sample_rate 366 * Modulo TICKS_PER_CYCLE, the difference between successive 367 * elements is about 1386.23. Rounding the results of this 368 * formula to the SYT precision results in a sequence of 369 * differences that begins with: 370 * 1386 1386 1387 1386 1386 1386 1387 1386 1386 1386 1387 ... 371 * This code generates _exactly_ the same sequence. 372 */ 373 phase = s->syt_offset_state; 374 index = phase % 13; 375 syt_offset = s->last_syt_offset; 376 syt_offset += 1386 + ((index && !(index & 3)) || 377 phase == 146); 378 if (++phase >= 147) 379 phase = 0; 380 s->syt_offset_state = phase; 381 } 382 } else 383 syt_offset = s->last_syt_offset - TICKS_PER_CYCLE; 384 s->last_syt_offset = syt_offset; 385 386 if (syt_offset < TICKS_PER_CYCLE) { 387 syt_offset += s->transfer_delay; 388 syt = (cycle + syt_offset / TICKS_PER_CYCLE) << 12; 389 syt += syt_offset % TICKS_PER_CYCLE; 390 391 return syt & CIP_SYT_MASK; 392 } else { 393 return CIP_SYT_NO_INFO; 394 } 395} 396 397static void amdtp_write_s32(struct amdtp_stream *s, 398 struct snd_pcm_substream *pcm, 399 __be32 *buffer, unsigned int frames) 400{ 401 struct snd_pcm_runtime *runtime = pcm->runtime; 402 unsigned int channels, remaining_frames, i, c; 403 const u32 *src; 404 405 channels = s->pcm_channels; 406 src = (void *)runtime->dma_area + 407 frames_to_bytes(runtime, s->pcm_buffer_pointer); 408 remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer; 409 410 for (i = 0; i < frames; ++i) { 411 for (c = 0; c < channels; ++c) { 412 buffer[s->pcm_positions[c]] = 413 cpu_to_be32((*src >> 8) | 0x40000000); 414 src++; 415 } 416 buffer += s->data_block_quadlets; 417 if (--remaining_frames == 0) 418 src = (void *)runtime->dma_area; 419 } 420} 421 422static void amdtp_write_s16(struct amdtp_stream *s, 423 struct snd_pcm_substream *pcm, 424 __be32 *buffer, unsigned int frames) 425{ 426 struct snd_pcm_runtime *runtime = pcm->runtime; 427 unsigned int channels, remaining_frames, i, c; 428 const u16 *src; 429 430 channels = s->pcm_channels; 431 src = (void *)runtime->dma_area + 432 frames_to_bytes(runtime, s->pcm_buffer_pointer); 433 remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer; 434 435 for (i = 0; i < frames; ++i) { 436 for (c = 0; c < channels; ++c) { 437 buffer[s->pcm_positions[c]] = 438 cpu_to_be32((*src << 8) | 0x42000000); 439 src++; 440 } 441 buffer += s->data_block_quadlets; 442 if (--remaining_frames == 0) 443 src = (void *)runtime->dma_area; 444 } 445} 446 447static void amdtp_read_s32(struct amdtp_stream *s, 448 struct snd_pcm_substream *pcm, 449 __be32 *buffer, unsigned int frames) 450{ 451 struct snd_pcm_runtime *runtime = pcm->runtime; 452 unsigned int channels, remaining_frames, i, c; 453 u32 *dst; 454 455 channels = s->pcm_channels; 456 dst = (void *)runtime->dma_area + 457 frames_to_bytes(runtime, s->pcm_buffer_pointer); 458 remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer; 459 460 for (i = 0; i < frames; ++i) { 461 for (c = 0; c < channels; ++c) { 462 *dst = be32_to_cpu(buffer[s->pcm_positions[c]]) << 8; 463 dst++; 464 } 465 buffer += s->data_block_quadlets; 466 if (--remaining_frames == 0) 467 dst = (void *)runtime->dma_area; 468 } 469} 470 471static void amdtp_fill_pcm_silence(struct amdtp_stream *s, 472 __be32 *buffer, unsigned int frames) 473{ 474 unsigned int i, c; 475 476 for (i = 0; i < frames; ++i) { 477 for (c = 0; c < s->pcm_channels; ++c) 478 buffer[s->pcm_positions[c]] = cpu_to_be32(0x40000000); 479 buffer += s->data_block_quadlets; 480 } 481} 482 483/* 484 * To avoid sending MIDI bytes at too high a rate, assume that the receiving 485 * device has a FIFO, and track how much it is filled. This values increases 486 * by one whenever we send one byte in a packet, but the FIFO empties at 487 * a constant rate independent of our packet rate. One packet has syt_interval 488 * samples, so the number of bytes that empty out of the FIFO, per packet(!), 489 * is MIDI_BYTES_PER_SECOND * syt_interval / sample_rate. To avoid storing 490 * fractional values, the values in midi_fifo_used[] are measured in bytes 491 * multiplied by the sample rate. 492 */ 493static bool midi_ratelimit_per_packet(struct amdtp_stream *s, unsigned int port) 494{ 495 int used; 496 497 used = s->midi_fifo_used[port]; 498 if (used == 0) /* common shortcut */ 499 return true; 500 501 used -= MIDI_BYTES_PER_SECOND * s->syt_interval; 502 used = max(used, 0); 503 s->midi_fifo_used[port] = used; 504 505 return used < s->midi_fifo_limit; 506} 507 508static void midi_rate_use_one_byte(struct amdtp_stream *s, unsigned int port) 509{ 510 s->midi_fifo_used[port] += amdtp_rate_table[s->sfc]; 511} 512 513static void amdtp_fill_midi(struct amdtp_stream *s, 514 __be32 *buffer, unsigned int frames) 515{ 516 unsigned int f, port; 517 u8 *b; 518 519 for (f = 0; f < frames; f++) { 520 b = (u8 *)&buffer[s->midi_position]; 521 522 port = (s->data_block_counter + f) % 8; 523 if (f < MAX_MIDI_RX_BLOCKS && 524 midi_ratelimit_per_packet(s, port) && 525 s->midi[port] != NULL && 526 snd_rawmidi_transmit(s->midi[port], &b[1], 1) == 1) { 527 midi_rate_use_one_byte(s, port); 528 b[0] = 0x81; 529 } else { 530 b[0] = 0x80; 531 b[1] = 0; 532 } 533 b[2] = 0; 534 b[3] = 0; 535 536 buffer += s->data_block_quadlets; 537 } 538} 539 540static void amdtp_pull_midi(struct amdtp_stream *s, 541 __be32 *buffer, unsigned int frames) 542{ 543 unsigned int f, port; 544 int len; 545 u8 *b; 546 547 for (f = 0; f < frames; f++) { 548 port = (s->data_block_counter + f) % 8; 549 b = (u8 *)&buffer[s->midi_position]; 550 551 len = b[0] - 0x80; 552 if ((1 <= len) && (len <= 3) && (s->midi[port])) 553 snd_rawmidi_receive(s->midi[port], b + 1, len); 554 555 buffer += s->data_block_quadlets; 556 } 557} 558 559static void update_pcm_pointers(struct amdtp_stream *s, 560 struct snd_pcm_substream *pcm, 561 unsigned int frames) 562{ 563 unsigned int ptr; 564 565 /* 566 * In IEC 61883-6, one data block represents one event. In ALSA, one 567 * event equals to one PCM frame. But Dice has a quirk to transfer 568 * two PCM frames in one data block. 569 */ 570 if (s->double_pcm_frames) 571 frames *= 2; 572 573 ptr = s->pcm_buffer_pointer + frames; 574 if (ptr >= pcm->runtime->buffer_size) 575 ptr -= pcm->runtime->buffer_size; 576 ACCESS_ONCE(s->pcm_buffer_pointer) = ptr; 577 578 s->pcm_period_pointer += frames; 579 if (s->pcm_period_pointer >= pcm->runtime->period_size) { 580 s->pcm_period_pointer -= pcm->runtime->period_size; 581 s->pointer_flush = false; 582 tasklet_hi_schedule(&s->period_tasklet); 583 } 584} 585 586static void pcm_period_tasklet(unsigned long data) 587{ 588 struct amdtp_stream *s = (void *)data; 589 struct snd_pcm_substream *pcm = ACCESS_ONCE(s->pcm); 590 591 if (pcm) 592 snd_pcm_period_elapsed(pcm); 593} 594 595static int queue_packet(struct amdtp_stream *s, 596 unsigned int header_length, 597 unsigned int payload_length, bool skip) 598{ 599 struct fw_iso_packet p = {0}; 600 int err = 0; 601 602 if (IS_ERR(s->context)) 603 goto end; 604 605 p.interrupt = IS_ALIGNED(s->packet_index + 1, INTERRUPT_INTERVAL); 606 p.tag = TAG_CIP; 607 p.header_length = header_length; 608 p.payload_length = (!skip) ? payload_length : 0; 609 p.skip = skip; 610 err = fw_iso_context_queue(s->context, &p, &s->buffer.iso_buffer, 611 s->buffer.packets[s->packet_index].offset); 612 if (err < 0) { 613 dev_err(&s->unit->device, "queueing error: %d\n", err); 614 goto end; 615 } 616 617 if (++s->packet_index >= QUEUE_LENGTH) 618 s->packet_index = 0; 619end: 620 return err; 621} 622 623static inline int queue_out_packet(struct amdtp_stream *s, 624 unsigned int payload_length, bool skip) 625{ 626 return queue_packet(s, OUT_PACKET_HEADER_SIZE, 627 payload_length, skip); 628} 629 630static inline int queue_in_packet(struct amdtp_stream *s) 631{ 632 return queue_packet(s, IN_PACKET_HEADER_SIZE, 633 amdtp_stream_get_max_payload(s), false); 634} 635 636static void handle_out_packet(struct amdtp_stream *s, unsigned int syt) 637{ 638 __be32 *buffer; 639 unsigned int data_blocks, payload_length; 640 struct snd_pcm_substream *pcm; 641 642 if (s->packet_index < 0) 643 return; 644 645 /* this module generate empty packet for 'no data' */ 646 if (!(s->flags & CIP_BLOCKING) || (syt != CIP_SYT_NO_INFO)) 647 data_blocks = calculate_data_blocks(s); 648 else 649 data_blocks = 0; 650 651 buffer = s->buffer.packets[s->packet_index].buffer; 652 buffer[0] = cpu_to_be32(ACCESS_ONCE(s->source_node_id_field) | 653 (s->data_block_quadlets << AMDTP_DBS_SHIFT) | 654 s->data_block_counter); 655 buffer[1] = cpu_to_be32(CIP_EOH | CIP_FMT_AM | AMDTP_FDF_AM824 | 656 (s->sfc << CIP_FDF_SFC_SHIFT) | syt); 657 buffer += 2; 658 659 pcm = ACCESS_ONCE(s->pcm); 660 if (pcm) 661 s->transfer_samples(s, pcm, buffer, data_blocks); 662 else 663 amdtp_fill_pcm_silence(s, buffer, data_blocks); 664 if (s->midi_ports) 665 amdtp_fill_midi(s, buffer, data_blocks); 666 667 s->data_block_counter = (s->data_block_counter + data_blocks) & 0xff; 668 669 payload_length = 8 + data_blocks * 4 * s->data_block_quadlets; 670 if (queue_out_packet(s, payload_length, false) < 0) { 671 s->packet_index = -1; 672 amdtp_stream_pcm_abort(s); 673 return; 674 } 675 676 if (pcm) 677 update_pcm_pointers(s, pcm, data_blocks); 678} 679 680static void handle_in_packet(struct amdtp_stream *s, 681 unsigned int payload_quadlets, 682 __be32 *buffer) 683{ 684 u32 cip_header[2]; 685 unsigned int data_blocks, data_block_quadlets, data_block_counter, 686 dbc_interval; 687 struct snd_pcm_substream *pcm = NULL; 688 bool lost; 689 690 cip_header[0] = be32_to_cpu(buffer[0]); 691 cip_header[1] = be32_to_cpu(buffer[1]); 692 693 /* 694 * This module supports 'Two-quadlet CIP header with SYT field'. 695 * For convenience, also check FMT field is AM824 or not. 696 */ 697 if (((cip_header[0] & CIP_EOH_MASK) == CIP_EOH) || 698 ((cip_header[1] & CIP_EOH_MASK) != CIP_EOH) || 699 ((cip_header[1] & CIP_FMT_MASK) != CIP_FMT_AM)) { 700 dev_info_ratelimited(&s->unit->device, 701 "Invalid CIP header for AMDTP: %08X:%08X\n", 702 cip_header[0], cip_header[1]); 703 goto end; 704 } 705 706 /* Calculate data blocks */ 707 if (payload_quadlets < 3 || 708 ((cip_header[1] & CIP_FDF_MASK) == 709 (AMDTP_FDF_NO_DATA << CIP_FDF_SFC_SHIFT))) { 710 data_blocks = 0; 711 } else { 712 data_block_quadlets = 713 (cip_header[0] & AMDTP_DBS_MASK) >> AMDTP_DBS_SHIFT; 714 /* avoid division by zero */ 715 if (data_block_quadlets == 0) { 716 dev_info_ratelimited(&s->unit->device, 717 "Detect invalid value in dbs field: %08X\n", 718 cip_header[0]); 719 goto err; 720 } 721 if (s->flags & CIP_WRONG_DBS) 722 data_block_quadlets = s->data_block_quadlets; 723 724 data_blocks = (payload_quadlets - 2) / data_block_quadlets; 725 } 726 727 /* Check data block counter continuity */ 728 data_block_counter = cip_header[0] & AMDTP_DBC_MASK; 729 if (data_blocks == 0 && (s->flags & CIP_EMPTY_HAS_WRONG_DBC) && 730 s->data_block_counter != UINT_MAX) 731 data_block_counter = s->data_block_counter; 732 733 if (((s->flags & CIP_SKIP_DBC_ZERO_CHECK) && 734 data_block_counter == s->tx_first_dbc) || 735 s->data_block_counter == UINT_MAX) { 736 lost = false; 737 } else if (!(s->flags & CIP_DBC_IS_END_EVENT)) { 738 lost = data_block_counter != s->data_block_counter; 739 } else { 740 if ((data_blocks > 0) && (s->tx_dbc_interval > 0)) 741 dbc_interval = s->tx_dbc_interval; 742 else 743 dbc_interval = data_blocks; 744 745 lost = data_block_counter != 746 ((s->data_block_counter + dbc_interval) & 0xff); 747 } 748 749 if (lost) { 750 dev_info(&s->unit->device, 751 "Detect discontinuity of CIP: %02X %02X\n", 752 s->data_block_counter, data_block_counter); 753 goto err; 754 } 755 756 if (data_blocks > 0) { 757 buffer += 2; 758 759 pcm = ACCESS_ONCE(s->pcm); 760 if (pcm) 761 s->transfer_samples(s, pcm, buffer, data_blocks); 762 763 if (s->midi_ports) 764 amdtp_pull_midi(s, buffer, data_blocks); 765 } 766 767 if (s->flags & CIP_DBC_IS_END_EVENT) 768 s->data_block_counter = data_block_counter; 769 else 770 s->data_block_counter = 771 (data_block_counter + data_blocks) & 0xff; 772end: 773 if (queue_in_packet(s) < 0) 774 goto err; 775 776 if (pcm) 777 update_pcm_pointers(s, pcm, data_blocks); 778 779 return; 780err: 781 s->packet_index = -1; 782 amdtp_stream_pcm_abort(s); 783} 784 785static void out_stream_callback(struct fw_iso_context *context, u32 cycle, 786 size_t header_length, void *header, 787 void *private_data) 788{ 789 struct amdtp_stream *s = private_data; 790 unsigned int i, syt, packets = header_length / 4; 791 792 /* 793 * Compute the cycle of the last queued packet. 794 * (We need only the four lowest bits for the SYT, so we can ignore 795 * that bits 0-11 must wrap around at 3072.) 796 */ 797 cycle += QUEUE_LENGTH - packets; 798 799 for (i = 0; i < packets; ++i) { 800 syt = calculate_syt(s, ++cycle); 801 handle_out_packet(s, syt); 802 } 803 fw_iso_context_queue_flush(s->context); 804} 805 806static void in_stream_callback(struct fw_iso_context *context, u32 cycle, 807 size_t header_length, void *header, 808 void *private_data) 809{ 810 struct amdtp_stream *s = private_data; 811 unsigned int p, syt, packets, payload_quadlets; 812 __be32 *buffer, *headers = header; 813 814 /* The number of packets in buffer */ 815 packets = header_length / IN_PACKET_HEADER_SIZE; 816 817 for (p = 0; p < packets; p++) { 818 if (s->packet_index < 0) 819 break; 820 821 buffer = s->buffer.packets[s->packet_index].buffer; 822 823 /* Process sync slave stream */ 824 if (s->sync_slave && s->sync_slave->callbacked) { 825 syt = be32_to_cpu(buffer[1]) & CIP_SYT_MASK; 826 handle_out_packet(s->sync_slave, syt); 827 } 828 829 /* The number of quadlets in this packet */ 830 payload_quadlets = 831 (be32_to_cpu(headers[p]) >> ISO_DATA_LENGTH_SHIFT) / 4; 832 handle_in_packet(s, payload_quadlets, buffer); 833 } 834 835 /* Queueing error or detecting discontinuity */ 836 if (s->packet_index < 0) { 837 /* Abort sync slave. */ 838 if (s->sync_slave) { 839 s->sync_slave->packet_index = -1; 840 amdtp_stream_pcm_abort(s->sync_slave); 841 } 842 return; 843 } 844 845 /* when sync to device, flush the packets for slave stream */ 846 if (s->sync_slave && s->sync_slave->callbacked) 847 fw_iso_context_queue_flush(s->sync_slave->context); 848 849 fw_iso_context_queue_flush(s->context); 850} 851 852/* processing is done by master callback */ 853static void slave_stream_callback(struct fw_iso_context *context, u32 cycle, 854 size_t header_length, void *header, 855 void *private_data) 856{ 857 return; 858} 859 860/* this is executed one time */ 861static void amdtp_stream_first_callback(struct fw_iso_context *context, 862 u32 cycle, size_t header_length, 863 void *header, void *private_data) 864{ 865 struct amdtp_stream *s = private_data; 866 867 /* 868 * For in-stream, first packet has come. 869 * For out-stream, prepared to transmit first packet 870 */ 871 s->callbacked = true; 872 wake_up(&s->callback_wait); 873 874 if (s->direction == AMDTP_IN_STREAM) 875 context->callback.sc = in_stream_callback; 876 else if ((s->flags & CIP_BLOCKING) && (s->flags & CIP_SYNC_TO_DEVICE)) 877 context->callback.sc = slave_stream_callback; 878 else 879 context->callback.sc = out_stream_callback; 880 881 context->callback.sc(context, cycle, header_length, header, s); 882} 883 884/** 885 * amdtp_stream_start - start transferring packets 886 * @s: the AMDTP stream to start 887 * @channel: the isochronous channel on the bus 888 * @speed: firewire speed code 889 * 890 * The stream cannot be started until it has been configured with 891 * amdtp_stream_set_parameters() and it must be started before any PCM or MIDI 892 * device can be started. 893 */ 894int amdtp_stream_start(struct amdtp_stream *s, int channel, int speed) 895{ 896 static const struct { 897 unsigned int data_block; 898 unsigned int syt_offset; 899 } initial_state[] = { 900 [CIP_SFC_32000] = { 4, 3072 }, 901 [CIP_SFC_48000] = { 6, 1024 }, 902 [CIP_SFC_96000] = { 12, 1024 }, 903 [CIP_SFC_192000] = { 24, 1024 }, 904 [CIP_SFC_44100] = { 0, 67 }, 905 [CIP_SFC_88200] = { 0, 67 }, 906 [CIP_SFC_176400] = { 0, 67 }, 907 }; 908 unsigned int header_size; 909 enum dma_data_direction dir; 910 int type, tag, err; 911 912 mutex_lock(&s->mutex); 913 914 if (WARN_ON(amdtp_stream_running(s) || 915 (s->data_block_quadlets < 1))) { 916 err = -EBADFD; 917 goto err_unlock; 918 } 919 920 if (s->direction == AMDTP_IN_STREAM && 921 s->flags & CIP_SKIP_INIT_DBC_CHECK) 922 s->data_block_counter = UINT_MAX; 923 else 924 s->data_block_counter = 0; 925 s->data_block_state = initial_state[s->sfc].data_block; 926 s->syt_offset_state = initial_state[s->sfc].syt_offset; 927 s->last_syt_offset = TICKS_PER_CYCLE; 928 929 /* initialize packet buffer */ 930 if (s->direction == AMDTP_IN_STREAM) { 931 dir = DMA_FROM_DEVICE; 932 type = FW_ISO_CONTEXT_RECEIVE; 933 header_size = IN_PACKET_HEADER_SIZE; 934 } else { 935 dir = DMA_TO_DEVICE; 936 type = FW_ISO_CONTEXT_TRANSMIT; 937 header_size = OUT_PACKET_HEADER_SIZE; 938 } 939 err = iso_packets_buffer_init(&s->buffer, s->unit, QUEUE_LENGTH, 940 amdtp_stream_get_max_payload(s), dir); 941 if (err < 0) 942 goto err_unlock; 943 944 s->context = fw_iso_context_create(fw_parent_device(s->unit)->card, 945 type, channel, speed, header_size, 946 amdtp_stream_first_callback, s); 947 if (IS_ERR(s->context)) { 948 err = PTR_ERR(s->context); 949 if (err == -EBUSY) 950 dev_err(&s->unit->device, 951 "no free stream on this controller\n"); 952 goto err_buffer; 953 } 954 955 amdtp_stream_update(s); 956 957 s->packet_index = 0; 958 do { 959 if (s->direction == AMDTP_IN_STREAM) 960 err = queue_in_packet(s); 961 else 962 err = queue_out_packet(s, 0, true); 963 if (err < 0) 964 goto err_context; 965 } while (s->packet_index > 0); 966 967 /* NOTE: TAG1 matches CIP. This just affects in stream. */ 968 tag = FW_ISO_CONTEXT_MATCH_TAG1; 969 if (s->flags & CIP_EMPTY_WITH_TAG0) 970 tag |= FW_ISO_CONTEXT_MATCH_TAG0; 971 972 s->callbacked = false; 973 err = fw_iso_context_start(s->context, -1, 0, tag); 974 if (err < 0) 975 goto err_context; 976 977 mutex_unlock(&s->mutex); 978 979 return 0; 980 981err_context: 982 fw_iso_context_destroy(s->context); 983 s->context = ERR_PTR(-1); 984err_buffer: 985 iso_packets_buffer_destroy(&s->buffer, s->unit); 986err_unlock: 987 mutex_unlock(&s->mutex); 988 989 return err; 990} 991EXPORT_SYMBOL(amdtp_stream_start); 992 993/** 994 * amdtp_stream_pcm_pointer - get the PCM buffer position 995 * @s: the AMDTP stream that transports the PCM data 996 * 997 * Returns the current buffer position, in frames. 998 */ 999unsigned long amdtp_stream_pcm_pointer(struct amdtp_stream *s) 1000{ 1001 /* this optimization is allowed to be racy */ 1002 if (s->pointer_flush && amdtp_stream_running(s)) 1003 fw_iso_context_flush_completions(s->context); 1004 else 1005 s->pointer_flush = true; 1006 1007 return ACCESS_ONCE(s->pcm_buffer_pointer); 1008} 1009EXPORT_SYMBOL(amdtp_stream_pcm_pointer); 1010 1011/** 1012 * amdtp_stream_update - update the stream after a bus reset 1013 * @s: the AMDTP stream 1014 */ 1015void amdtp_stream_update(struct amdtp_stream *s) 1016{ 1017 ACCESS_ONCE(s->source_node_id_field) = 1018 (fw_parent_device(s->unit)->card->node_id & 0x3f) << 24; 1019} 1020EXPORT_SYMBOL(amdtp_stream_update); 1021 1022/** 1023 * amdtp_stream_stop - stop sending packets 1024 * @s: the AMDTP stream to stop 1025 * 1026 * All PCM and MIDI devices of the stream must be stopped before the stream 1027 * itself can be stopped. 1028 */ 1029void amdtp_stream_stop(struct amdtp_stream *s) 1030{ 1031 mutex_lock(&s->mutex); 1032 1033 if (!amdtp_stream_running(s)) { 1034 mutex_unlock(&s->mutex); 1035 return; 1036 } 1037 1038 tasklet_kill(&s->period_tasklet); 1039 fw_iso_context_stop(s->context); 1040 fw_iso_context_destroy(s->context); 1041 s->context = ERR_PTR(-1); 1042 iso_packets_buffer_destroy(&s->buffer, s->unit); 1043 1044 s->callbacked = false; 1045 1046 mutex_unlock(&s->mutex); 1047} 1048EXPORT_SYMBOL(amdtp_stream_stop); 1049 1050/** 1051 * amdtp_stream_pcm_abort - abort the running PCM device 1052 * @s: the AMDTP stream about to be stopped 1053 * 1054 * If the isochronous stream needs to be stopped asynchronously, call this 1055 * function first to stop the PCM device. 1056 */ 1057void amdtp_stream_pcm_abort(struct amdtp_stream *s) 1058{ 1059 struct snd_pcm_substream *pcm; 1060 1061 pcm = ACCESS_ONCE(s->pcm); 1062 if (pcm) 1063 snd_pcm_stop_xrun(pcm); 1064} 1065EXPORT_SYMBOL(amdtp_stream_pcm_abort); 1066