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