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->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, 150 struct snd_pcm_substream *pcm, 151 __be32 *buffer, unsigned int frames) 152 { 153 struct amdtp_am824 *p = s->protocol; 154 struct snd_pcm_runtime *runtime = pcm->runtime; 155 unsigned int channels, remaining_frames, i, c; 156 const u32 *src; 157 158 channels = p->pcm_channels; 159 src = (void *)runtime->dma_area + 160 frames_to_bytes(runtime, s->pcm_buffer_pointer); 161 remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer; 162 163 for (i = 0; i < frames; ++i) { 164 for (c = 0; c < channels; ++c) { 165 buffer[p->pcm_positions[c]] = 166 cpu_to_be32((*src >> 8) | 0x40000000); 167 src++; 168 } 169 buffer += s->data_block_quadlets; 170 if (--remaining_frames == 0) 171 src = (void *)runtime->dma_area; 172 } 173 } 174 175 static void read_pcm_s32(struct amdtp_stream *s, 176 struct snd_pcm_substream *pcm, 177 __be32 *buffer, unsigned int frames) 178 { 179 struct amdtp_am824 *p = s->protocol; 180 struct snd_pcm_runtime *runtime = pcm->runtime; 181 unsigned int channels, remaining_frames, i, c; 182 u32 *dst; 183 184 channels = p->pcm_channels; 185 dst = (void *)runtime->dma_area + 186 frames_to_bytes(runtime, s->pcm_buffer_pointer); 187 remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer; 188 189 for (i = 0; i < frames; ++i) { 190 for (c = 0; c < channels; ++c) { 191 *dst = be32_to_cpu(buffer[p->pcm_positions[c]]) << 8; 192 dst++; 193 } 194 buffer += s->data_block_quadlets; 195 if (--remaining_frames == 0) 196 dst = (void *)runtime->dma_area; 197 } 198 } 199 200 static void write_pcm_silence(struct amdtp_stream *s, 201 __be32 *buffer, unsigned int frames) 202 { 203 struct amdtp_am824 *p = s->protocol; 204 unsigned int i, c, channels = p->pcm_channels; 205 206 for (i = 0; i < frames; ++i) { 207 for (c = 0; c < channels; ++c) 208 buffer[p->pcm_positions[c]] = cpu_to_be32(0x40000000); 209 buffer += s->data_block_quadlets; 210 } 211 } 212 213 /** 214 * amdtp_am824_add_pcm_hw_constraints - add hw constraints for PCM substream 215 * @s: the AMDTP stream for AM824 data block, must be initialized. 216 * @runtime: the PCM substream runtime 217 * 218 */ 219 int amdtp_am824_add_pcm_hw_constraints(struct amdtp_stream *s, 220 struct snd_pcm_runtime *runtime) 221 { 222 int err; 223 224 err = amdtp_stream_add_pcm_hw_constraints(s, runtime); 225 if (err < 0) 226 return err; 227 228 /* AM824 in IEC 61883-6 can deliver 24bit data. */ 229 return snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24); 230 } 231 EXPORT_SYMBOL_GPL(amdtp_am824_add_pcm_hw_constraints); 232 233 /** 234 * amdtp_am824_midi_trigger - start/stop playback/capture with a MIDI device 235 * @s: the AMDTP stream 236 * @port: index of MIDI port 237 * @midi: the MIDI device to be started, or %NULL to stop the current device 238 * 239 * Call this function on a running isochronous stream to enable the actual 240 * transmission of MIDI data. This function should be called from the MIDI 241 * device's .trigger callback. 242 */ 243 void amdtp_am824_midi_trigger(struct amdtp_stream *s, unsigned int port, 244 struct snd_rawmidi_substream *midi) 245 { 246 struct amdtp_am824 *p = s->protocol; 247 248 if (port < p->midi_ports) 249 WRITE_ONCE(p->midi[port], midi); 250 } 251 EXPORT_SYMBOL_GPL(amdtp_am824_midi_trigger); 252 253 /* 254 * To avoid sending MIDI bytes at too high a rate, assume that the receiving 255 * device has a FIFO, and track how much it is filled. This values increases 256 * by one whenever we send one byte in a packet, but the FIFO empties at 257 * a constant rate independent of our packet rate. One packet has syt_interval 258 * samples, so the number of bytes that empty out of the FIFO, per packet(!), 259 * is MIDI_BYTES_PER_SECOND * syt_interval / sample_rate. To avoid storing 260 * fractional values, the values in midi_fifo_used[] are measured in bytes 261 * multiplied by the sample rate. 262 */ 263 static bool midi_ratelimit_per_packet(struct amdtp_stream *s, unsigned int port) 264 { 265 struct amdtp_am824 *p = s->protocol; 266 int used; 267 268 used = p->midi_fifo_used[port]; 269 if (used == 0) /* common shortcut */ 270 return true; 271 272 used -= MIDI_BYTES_PER_SECOND * s->syt_interval; 273 used = max(used, 0); 274 p->midi_fifo_used[port] = used; 275 276 return used < p->midi_fifo_limit; 277 } 278 279 static void midi_rate_use_one_byte(struct amdtp_stream *s, unsigned int port) 280 { 281 struct amdtp_am824 *p = s->protocol; 282 283 p->midi_fifo_used[port] += amdtp_rate_table[s->sfc]; 284 } 285 286 static void write_midi_messages(struct amdtp_stream *s, __be32 *buffer, 287 unsigned int frames) 288 { 289 struct amdtp_am824 *p = s->protocol; 290 unsigned int f, port; 291 u8 *b; 292 293 for (f = 0; f < frames; f++) { 294 b = (u8 *)&buffer[p->midi_position]; 295 296 port = (s->data_block_counter + f) % 8; 297 if (f < MAX_MIDI_RX_BLOCKS && 298 midi_ratelimit_per_packet(s, port) && 299 p->midi[port] != NULL && 300 snd_rawmidi_transmit(p->midi[port], &b[1], 1) == 1) { 301 midi_rate_use_one_byte(s, port); 302 b[0] = 0x81; 303 } else { 304 b[0] = 0x80; 305 b[1] = 0; 306 } 307 b[2] = 0; 308 b[3] = 0; 309 310 buffer += s->data_block_quadlets; 311 } 312 } 313 314 static void read_midi_messages(struct amdtp_stream *s, 315 __be32 *buffer, unsigned int frames) 316 { 317 struct amdtp_am824 *p = s->protocol; 318 unsigned int f, port; 319 int len; 320 u8 *b; 321 322 for (f = 0; f < frames; f++) { 323 port = (s->data_block_counter + f) % 8; 324 b = (u8 *)&buffer[p->midi_position]; 325 326 len = b[0] - 0x80; 327 if ((1 <= len) && (len <= 3) && (p->midi[port])) 328 snd_rawmidi_receive(p->midi[port], b + 1, len); 329 330 buffer += s->data_block_quadlets; 331 } 332 } 333 334 static unsigned int process_rx_data_blocks(struct amdtp_stream *s, __be32 *buffer, 335 unsigned int data_blocks, unsigned int *syt) 336 { 337 struct amdtp_am824 *p = s->protocol; 338 struct snd_pcm_substream *pcm = READ_ONCE(s->pcm); 339 unsigned int pcm_frames; 340 341 if (pcm) { 342 write_pcm_s32(s, pcm, buffer, data_blocks); 343 pcm_frames = data_blocks * p->frame_multiplier; 344 } else { 345 write_pcm_silence(s, buffer, data_blocks); 346 pcm_frames = 0; 347 } 348 349 if (p->midi_ports) 350 write_midi_messages(s, buffer, data_blocks); 351 352 return pcm_frames; 353 } 354 355 static unsigned int process_tx_data_blocks(struct amdtp_stream *s, __be32 *buffer, 356 unsigned int data_blocks, unsigned int *syt) 357 { 358 struct amdtp_am824 *p = s->protocol; 359 struct snd_pcm_substream *pcm = READ_ONCE(s->pcm); 360 unsigned int pcm_frames; 361 362 if (pcm) { 363 read_pcm_s32(s, pcm, buffer, data_blocks); 364 pcm_frames = data_blocks * p->frame_multiplier; 365 } else { 366 pcm_frames = 0; 367 } 368 369 if (p->midi_ports) 370 read_midi_messages(s, buffer, data_blocks); 371 372 return pcm_frames; 373 } 374 375 /** 376 * amdtp_am824_init - initialize an AMDTP stream structure to handle AM824 377 * data block 378 * @s: the AMDTP stream to initialize 379 * @unit: the target of the stream 380 * @dir: the direction of stream 381 * @flags: the packet transmission method to use 382 */ 383 int amdtp_am824_init(struct amdtp_stream *s, struct fw_unit *unit, 384 enum amdtp_stream_direction dir, enum cip_flags flags) 385 { 386 amdtp_stream_process_data_blocks_t process_data_blocks; 387 388 if (dir == AMDTP_IN_STREAM) 389 process_data_blocks = process_tx_data_blocks; 390 else 391 process_data_blocks = process_rx_data_blocks; 392 393 return amdtp_stream_init(s, unit, dir, flags, CIP_FMT_AM, 394 process_data_blocks, 395 sizeof(struct amdtp_am824)); 396 } 397 EXPORT_SYMBOL_GPL(amdtp_am824_init); 398