1 /* 2 * AM824 format in Audio and Music Data Transmission Protocol (IEC 61883-6) 3 * 4 * Copyright (c) Clemens Ladisch <clemens@ladisch.de> 5 * Copyright (c) 2015 Takashi Sakamoto <o-takashi@sakamocchi.jp> 6 * 7 * Licensed under the terms of the GNU General Public License, version 2. 8 */ 9 10 #include <linux/slab.h> 11 12 #include "amdtp-am824.h" 13 14 #define CIP_FMT_AM 0x10 15 16 /* "Clock-based rate control mode" is just supported. */ 17 #define AMDTP_FDF_AM824 0x00 18 19 /* 20 * Nominally 3125 bytes/second, but the MIDI port's clock might be 21 * 1% too slow, and the bus clock 100 ppm too fast. 22 */ 23 #define MIDI_BYTES_PER_SECOND 3093 24 25 /* 26 * Several devices look only at the first eight data blocks. 27 * In any case, this is more than enough for the MIDI data rate. 28 */ 29 #define MAX_MIDI_RX_BLOCKS 8 30 31 struct amdtp_am824 { 32 struct snd_rawmidi_substream *midi[AM824_MAX_CHANNELS_FOR_MIDI * 8]; 33 int midi_fifo_limit; 34 int midi_fifo_used[AM824_MAX_CHANNELS_FOR_MIDI * 8]; 35 unsigned int pcm_channels; 36 unsigned int midi_ports; 37 38 u8 pcm_positions[AM824_MAX_CHANNELS_FOR_PCM]; 39 u8 midi_position; 40 41 void (*transfer_samples)(struct amdtp_stream *s, 42 struct snd_pcm_substream *pcm, 43 __be32 *buffer, unsigned int frames); 44 45 unsigned int frame_multiplier; 46 }; 47 48 /** 49 * amdtp_am824_set_parameters - set stream parameters 50 * @s: the AMDTP stream to configure 51 * @rate: the sample rate 52 * @pcm_channels: the number of PCM samples in each data block, to be encoded 53 * as AM824 multi-bit linear audio 54 * @midi_ports: the number of MIDI ports (i.e., MPX-MIDI Data Channels) 55 * @double_pcm_frames: one data block transfers two PCM frames 56 * 57 * The parameters must be set before the stream is started, and must not be 58 * changed while the stream is running. 59 */ 60 int amdtp_am824_set_parameters(struct amdtp_stream *s, unsigned int rate, 61 unsigned int pcm_channels, 62 unsigned int midi_ports, 63 bool double_pcm_frames) 64 { 65 struct amdtp_am824 *p = s->protocol; 66 unsigned int midi_channels; 67 unsigned int i; 68 int err; 69 70 if (amdtp_stream_running(s)) 71 return -EINVAL; 72 73 if (pcm_channels > AM824_MAX_CHANNELS_FOR_PCM) 74 return -EINVAL; 75 76 midi_channels = DIV_ROUND_UP(midi_ports, 8); 77 if (midi_channels > AM824_MAX_CHANNELS_FOR_MIDI) 78 return -EINVAL; 79 80 if (WARN_ON(amdtp_stream_running(s)) || 81 WARN_ON(pcm_channels > AM824_MAX_CHANNELS_FOR_PCM) || 82 WARN_ON(midi_channels > AM824_MAX_CHANNELS_FOR_MIDI)) 83 return -EINVAL; 84 85 err = amdtp_stream_set_parameters(s, rate, 86 pcm_channels + midi_channels); 87 if (err < 0) 88 return err; 89 90 s->fdf = AMDTP_FDF_AM824 | s->sfc; 91 92 p->pcm_channels = pcm_channels; 93 p->midi_ports = midi_ports; 94 95 /* 96 * In IEC 61883-6, one data block represents one event. In ALSA, one 97 * event equals to one PCM frame. But Dice has a quirk at higher 98 * sampling rate to transfer two PCM frames in one data block. 99 */ 100 if (double_pcm_frames) 101 p->frame_multiplier = 2; 102 else 103 p->frame_multiplier = 1; 104 105 /* init the position map for PCM and MIDI channels */ 106 for (i = 0; i < pcm_channels; i++) 107 p->pcm_positions[i] = i; 108 p->midi_position = p->pcm_channels; 109 110 /* 111 * We do not know the actual MIDI FIFO size of most devices. Just 112 * assume two bytes, i.e., one byte can be received over the bus while 113 * the previous one is transmitted over MIDI. 114 * (The value here is adjusted for midi_ratelimit_per_packet().) 115 */ 116 p->midi_fifo_limit = rate - MIDI_BYTES_PER_SECOND * s->syt_interval + 1; 117 118 return 0; 119 } 120 EXPORT_SYMBOL_GPL(amdtp_am824_set_parameters); 121 122 /** 123 * amdtp_am824_set_pcm_position - set an index of data channel for a channel 124 * of PCM frame 125 * @s: the AMDTP stream 126 * @index: the index of data channel in an data block 127 * @position: the channel of PCM frame 128 */ 129 void amdtp_am824_set_pcm_position(struct amdtp_stream *s, unsigned int index, 130 unsigned int position) 131 { 132 struct amdtp_am824 *p = s->protocol; 133 134 if (index < p->pcm_channels) 135 p->pcm_positions[index] = position; 136 } 137 EXPORT_SYMBOL_GPL(amdtp_am824_set_pcm_position); 138 139 /** 140 * amdtp_am824_set_midi_position - set a index of data channel for MIDI 141 * conformant data channel 142 * @s: the AMDTP stream 143 * @position: the index of data channel in an data block 144 */ 145 void amdtp_am824_set_midi_position(struct amdtp_stream *s, 146 unsigned int position) 147 { 148 struct amdtp_am824 *p = s->protocol; 149 150 p->midi_position = position; 151 } 152 EXPORT_SYMBOL_GPL(amdtp_am824_set_midi_position); 153 154 static void write_pcm_s32(struct amdtp_stream *s, 155 struct snd_pcm_substream *pcm, 156 __be32 *buffer, unsigned int frames) 157 { 158 struct amdtp_am824 *p = s->protocol; 159 struct snd_pcm_runtime *runtime = pcm->runtime; 160 unsigned int channels, remaining_frames, i, c; 161 const u32 *src; 162 163 channels = p->pcm_channels; 164 src = (void *)runtime->dma_area + 165 frames_to_bytes(runtime, s->pcm_buffer_pointer); 166 remaining_frames = runtime->buffer_size - s->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 write_pcm_s16(struct amdtp_stream *s, 181 struct snd_pcm_substream *pcm, 182 __be32 *buffer, unsigned int frames) 183 { 184 struct amdtp_am824 *p = s->protocol; 185 struct snd_pcm_runtime *runtime = pcm->runtime; 186 unsigned int channels, remaining_frames, i, c; 187 const u16 *src; 188 189 channels = p->pcm_channels; 190 src = (void *)runtime->dma_area + 191 frames_to_bytes(runtime, s->pcm_buffer_pointer); 192 remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer; 193 194 for (i = 0; i < frames; ++i) { 195 for (c = 0; c < channels; ++c) { 196 buffer[p->pcm_positions[c]] = 197 cpu_to_be32((*src << 8) | 0x42000000); 198 src++; 199 } 200 buffer += s->data_block_quadlets; 201 if (--remaining_frames == 0) 202 src = (void *)runtime->dma_area; 203 } 204 } 205 206 static void read_pcm_s32(struct amdtp_stream *s, 207 struct snd_pcm_substream *pcm, 208 __be32 *buffer, unsigned int frames) 209 { 210 struct amdtp_am824 *p = s->protocol; 211 struct snd_pcm_runtime *runtime = pcm->runtime; 212 unsigned int channels, remaining_frames, i, c; 213 u32 *dst; 214 215 channels = p->pcm_channels; 216 dst = (void *)runtime->dma_area + 217 frames_to_bytes(runtime, s->pcm_buffer_pointer); 218 remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer; 219 220 for (i = 0; i < frames; ++i) { 221 for (c = 0; c < channels; ++c) { 222 *dst = be32_to_cpu(buffer[p->pcm_positions[c]]) << 8; 223 dst++; 224 } 225 buffer += s->data_block_quadlets; 226 if (--remaining_frames == 0) 227 dst = (void *)runtime->dma_area; 228 } 229 } 230 231 static void write_pcm_silence(struct amdtp_stream *s, 232 __be32 *buffer, unsigned int frames) 233 { 234 struct amdtp_am824 *p = s->protocol; 235 unsigned int i, c, channels = p->pcm_channels; 236 237 for (i = 0; i < frames; ++i) { 238 for (c = 0; c < channels; ++c) 239 buffer[p->pcm_positions[c]] = cpu_to_be32(0x40000000); 240 buffer += s->data_block_quadlets; 241 } 242 } 243 244 /** 245 * amdtp_am824_set_pcm_format - set the PCM format 246 * @s: the AMDTP stream to configure 247 * @format: the format of the ALSA PCM device 248 * 249 * The sample format must be set after the other parameters (rate/PCM channels/ 250 * MIDI) and before the stream is started, and must not be changed while the 251 * stream is running. 252 */ 253 void amdtp_am824_set_pcm_format(struct amdtp_stream *s, snd_pcm_format_t format) 254 { 255 struct amdtp_am824 *p = s->protocol; 256 257 if (WARN_ON(amdtp_stream_pcm_running(s))) 258 return; 259 260 switch (format) { 261 default: 262 WARN_ON(1); 263 /* fall through */ 264 case SNDRV_PCM_FORMAT_S16: 265 if (s->direction == AMDTP_OUT_STREAM) { 266 p->transfer_samples = write_pcm_s16; 267 break; 268 } 269 WARN_ON(1); 270 /* fall through */ 271 case SNDRV_PCM_FORMAT_S32: 272 if (s->direction == AMDTP_OUT_STREAM) 273 p->transfer_samples = write_pcm_s32; 274 else 275 p->transfer_samples = read_pcm_s32; 276 break; 277 } 278 } 279 EXPORT_SYMBOL_GPL(amdtp_am824_set_pcm_format); 280 281 /** 282 * amdtp_am824_add_pcm_hw_constraints - add hw constraints for PCM substream 283 * @s: the AMDTP stream for AM824 data block, must be initialized. 284 * @runtime: the PCM substream runtime 285 * 286 */ 287 int amdtp_am824_add_pcm_hw_constraints(struct amdtp_stream *s, 288 struct snd_pcm_runtime *runtime) 289 { 290 int err; 291 292 err = amdtp_stream_add_pcm_hw_constraints(s, runtime); 293 if (err < 0) 294 return err; 295 296 /* AM824 in IEC 61883-6 can deliver 24bit data. */ 297 return snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24); 298 } 299 EXPORT_SYMBOL_GPL(amdtp_am824_add_pcm_hw_constraints); 300 301 /** 302 * amdtp_am824_midi_trigger - start/stop playback/capture with a MIDI device 303 * @s: the AMDTP stream 304 * @port: index of MIDI port 305 * @midi: the MIDI device to be started, or %NULL to stop the current device 306 * 307 * Call this function on a running isochronous stream to enable the actual 308 * transmission of MIDI data. This function should be called from the MIDI 309 * device's .trigger callback. 310 */ 311 void amdtp_am824_midi_trigger(struct amdtp_stream *s, unsigned int port, 312 struct snd_rawmidi_substream *midi) 313 { 314 struct amdtp_am824 *p = s->protocol; 315 316 if (port < p->midi_ports) 317 ACCESS_ONCE(p->midi[port]) = midi; 318 } 319 EXPORT_SYMBOL_GPL(amdtp_am824_midi_trigger); 320 321 /* 322 * To avoid sending MIDI bytes at too high a rate, assume that the receiving 323 * device has a FIFO, and track how much it is filled. This values increases 324 * by one whenever we send one byte in a packet, but the FIFO empties at 325 * a constant rate independent of our packet rate. One packet has syt_interval 326 * samples, so the number of bytes that empty out of the FIFO, per packet(!), 327 * is MIDI_BYTES_PER_SECOND * syt_interval / sample_rate. To avoid storing 328 * fractional values, the values in midi_fifo_used[] are measured in bytes 329 * multiplied by the sample rate. 330 */ 331 static bool midi_ratelimit_per_packet(struct amdtp_stream *s, unsigned int port) 332 { 333 struct amdtp_am824 *p = s->protocol; 334 int used; 335 336 used = p->midi_fifo_used[port]; 337 if (used == 0) /* common shortcut */ 338 return true; 339 340 used -= MIDI_BYTES_PER_SECOND * s->syt_interval; 341 used = max(used, 0); 342 p->midi_fifo_used[port] = used; 343 344 return used < p->midi_fifo_limit; 345 } 346 347 static void midi_rate_use_one_byte(struct amdtp_stream *s, unsigned int port) 348 { 349 struct amdtp_am824 *p = s->protocol; 350 351 p->midi_fifo_used[port] += amdtp_rate_table[s->sfc]; 352 } 353 354 static void write_midi_messages(struct amdtp_stream *s, __be32 *buffer, 355 unsigned int frames) 356 { 357 struct amdtp_am824 *p = s->protocol; 358 unsigned int f, port; 359 u8 *b; 360 361 for (f = 0; f < frames; f++) { 362 b = (u8 *)&buffer[p->midi_position]; 363 364 port = (s->data_block_counter + f) % 8; 365 if (f < MAX_MIDI_RX_BLOCKS && 366 midi_ratelimit_per_packet(s, port) && 367 p->midi[port] != NULL && 368 snd_rawmidi_transmit(p->midi[port], &b[1], 1) == 1) { 369 midi_rate_use_one_byte(s, port); 370 b[0] = 0x81; 371 } else { 372 b[0] = 0x80; 373 b[1] = 0; 374 } 375 b[2] = 0; 376 b[3] = 0; 377 378 buffer += s->data_block_quadlets; 379 } 380 } 381 382 static void read_midi_messages(struct amdtp_stream *s, 383 __be32 *buffer, unsigned int frames) 384 { 385 struct amdtp_am824 *p = s->protocol; 386 unsigned int f, port; 387 int len; 388 u8 *b; 389 390 for (f = 0; f < frames; f++) { 391 port = (s->data_block_counter + f) % 8; 392 b = (u8 *)&buffer[p->midi_position]; 393 394 len = b[0] - 0x80; 395 if ((1 <= len) && (len <= 3) && (p->midi[port])) 396 snd_rawmidi_receive(p->midi[port], b + 1, len); 397 398 buffer += s->data_block_quadlets; 399 } 400 } 401 402 static unsigned int process_rx_data_blocks(struct amdtp_stream *s, __be32 *buffer, 403 unsigned int data_blocks, unsigned int *syt) 404 { 405 struct amdtp_am824 *p = s->protocol; 406 struct snd_pcm_substream *pcm = ACCESS_ONCE(s->pcm); 407 unsigned int pcm_frames; 408 409 if (pcm) { 410 p->transfer_samples(s, pcm, buffer, data_blocks); 411 pcm_frames = data_blocks * p->frame_multiplier; 412 } else { 413 write_pcm_silence(s, buffer, data_blocks); 414 pcm_frames = 0; 415 } 416 417 if (p->midi_ports) 418 write_midi_messages(s, buffer, data_blocks); 419 420 return pcm_frames; 421 } 422 423 static unsigned int process_tx_data_blocks(struct amdtp_stream *s, __be32 *buffer, 424 unsigned int data_blocks, unsigned int *syt) 425 { 426 struct amdtp_am824 *p = s->protocol; 427 struct snd_pcm_substream *pcm = ACCESS_ONCE(s->pcm); 428 unsigned int pcm_frames; 429 430 if (pcm) { 431 p->transfer_samples(s, pcm, buffer, data_blocks); 432 pcm_frames = data_blocks * p->frame_multiplier; 433 } else { 434 pcm_frames = 0; 435 } 436 437 if (p->midi_ports) 438 read_midi_messages(s, buffer, data_blocks); 439 440 return pcm_frames; 441 } 442 443 /** 444 * amdtp_am824_init - initialize an AMDTP stream structure to handle AM824 445 * data block 446 * @s: the AMDTP stream to initialize 447 * @unit: the target of the stream 448 * @dir: the direction of stream 449 * @flags: the packet transmission method to use 450 */ 451 int amdtp_am824_init(struct amdtp_stream *s, struct fw_unit *unit, 452 enum amdtp_stream_direction dir, enum cip_flags flags) 453 { 454 amdtp_stream_process_data_blocks_t process_data_blocks; 455 456 if (dir == AMDTP_IN_STREAM) 457 process_data_blocks = process_tx_data_blocks; 458 else 459 process_data_blocks = process_rx_data_blocks; 460 461 return amdtp_stream_init(s, unit, dir, flags, CIP_FMT_AM, 462 process_data_blocks, 463 sizeof(struct amdtp_am824)); 464 } 465 EXPORT_SYMBOL_GPL(amdtp_am824_init); 466