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