1 /* 2 * amdtp-tascam.c - a part of driver for TASCAM FireWire series 3 * 4 * Copyright (c) 2015 Takashi Sakamoto 5 * 6 * Licensed under the terms of the GNU General Public License, version 2. 7 */ 8 9 #include <sound/pcm.h> 10 #include "tascam.h" 11 12 #define AMDTP_FMT_TSCM_TX 0x1e 13 #define AMDTP_FMT_TSCM_RX 0x3e 14 15 struct amdtp_tscm { 16 unsigned int pcm_channels; 17 18 void (*transfer_samples)(struct amdtp_stream *s, 19 struct snd_pcm_substream *pcm, 20 __be32 *buffer, unsigned int frames); 21 }; 22 23 int amdtp_tscm_set_parameters(struct amdtp_stream *s, unsigned int rate) 24 { 25 struct amdtp_tscm *p = s->protocol; 26 unsigned int data_channels; 27 28 if (amdtp_stream_running(s)) 29 return -EBUSY; 30 31 data_channels = p->pcm_channels; 32 33 /* Packets in in-stream have extra 2 data channels. */ 34 if (s->direction == AMDTP_IN_STREAM) 35 data_channels += 2; 36 37 return amdtp_stream_set_parameters(s, rate, data_channels); 38 } 39 40 static void write_pcm_s32(struct amdtp_stream *s, 41 struct snd_pcm_substream *pcm, 42 __be32 *buffer, unsigned int frames) 43 { 44 struct amdtp_tscm *p = s->protocol; 45 struct snd_pcm_runtime *runtime = pcm->runtime; 46 unsigned int channels, remaining_frames, i, c; 47 const u32 *src; 48 49 channels = p->pcm_channels; 50 src = (void *)runtime->dma_area + 51 frames_to_bytes(runtime, s->pcm_buffer_pointer); 52 remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer; 53 54 for (i = 0; i < frames; ++i) { 55 for (c = 0; c < channels; ++c) { 56 buffer[c] = cpu_to_be32(*src); 57 src++; 58 } 59 buffer += s->data_block_quadlets; 60 if (--remaining_frames == 0) 61 src = (void *)runtime->dma_area; 62 } 63 } 64 65 static void write_pcm_s16(struct amdtp_stream *s, 66 struct snd_pcm_substream *pcm, 67 __be32 *buffer, unsigned int frames) 68 { 69 struct amdtp_tscm *p = s->protocol; 70 struct snd_pcm_runtime *runtime = pcm->runtime; 71 unsigned int channels, remaining_frames, i, c; 72 const u16 *src; 73 74 channels = p->pcm_channels; 75 src = (void *)runtime->dma_area + 76 frames_to_bytes(runtime, s->pcm_buffer_pointer); 77 remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer; 78 79 for (i = 0; i < frames; ++i) { 80 for (c = 0; c < channels; ++c) { 81 buffer[c] = cpu_to_be32(*src << 16); 82 src++; 83 } 84 buffer += s->data_block_quadlets; 85 if (--remaining_frames == 0) 86 src = (void *)runtime->dma_area; 87 } 88 } 89 90 static void read_pcm_s32(struct amdtp_stream *s, 91 struct snd_pcm_substream *pcm, 92 __be32 *buffer, unsigned int frames) 93 { 94 struct amdtp_tscm *p = s->protocol; 95 struct snd_pcm_runtime *runtime = pcm->runtime; 96 unsigned int channels, remaining_frames, i, c; 97 u32 *dst; 98 99 channels = p->pcm_channels; 100 dst = (void *)runtime->dma_area + 101 frames_to_bytes(runtime, s->pcm_buffer_pointer); 102 remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer; 103 104 /* The first data channel is for event counter. */ 105 buffer += 1; 106 107 for (i = 0; i < frames; ++i) { 108 for (c = 0; c < channels; ++c) { 109 *dst = be32_to_cpu(buffer[c]); 110 dst++; 111 } 112 buffer += s->data_block_quadlets; 113 if (--remaining_frames == 0) 114 dst = (void *)runtime->dma_area; 115 } 116 } 117 118 static void write_pcm_silence(struct amdtp_stream *s, __be32 *buffer, 119 unsigned int data_blocks) 120 { 121 struct amdtp_tscm *p = s->protocol; 122 unsigned int channels, i, c; 123 124 channels = p->pcm_channels; 125 126 for (i = 0; i < data_blocks; ++i) { 127 for (c = 0; c < channels; ++c) 128 buffer[c] = 0x00000000; 129 buffer += s->data_block_quadlets; 130 } 131 } 132 133 int amdtp_tscm_add_pcm_hw_constraints(struct amdtp_stream *s, 134 struct snd_pcm_runtime *runtime) 135 { 136 int err; 137 138 /* 139 * Our implementation allows this protocol to deliver 24 bit sample in 140 * 32bit data channel. 141 */ 142 err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24); 143 if (err < 0) 144 return err; 145 146 return amdtp_stream_add_pcm_hw_constraints(s, runtime); 147 } 148 149 void amdtp_tscm_set_pcm_format(struct amdtp_stream *s, snd_pcm_format_t format) 150 { 151 struct amdtp_tscm *p = s->protocol; 152 153 if (WARN_ON(amdtp_stream_pcm_running(s))) 154 return; 155 156 switch (format) { 157 default: 158 WARN_ON(1); 159 /* fall through */ 160 case SNDRV_PCM_FORMAT_S16: 161 if (s->direction == AMDTP_OUT_STREAM) { 162 p->transfer_samples = write_pcm_s16; 163 break; 164 } 165 WARN_ON(1); 166 /* fall through */ 167 case SNDRV_PCM_FORMAT_S32: 168 if (s->direction == AMDTP_OUT_STREAM) 169 p->transfer_samples = write_pcm_s32; 170 else 171 p->transfer_samples = read_pcm_s32; 172 break; 173 } 174 } 175 176 static unsigned int process_tx_data_blocks(struct amdtp_stream *s, 177 __be32 *buffer, 178 unsigned int data_blocks, 179 unsigned int *syt) 180 { 181 struct amdtp_tscm *p = (struct amdtp_tscm *)s->protocol; 182 struct snd_pcm_substream *pcm; 183 184 pcm = ACCESS_ONCE(s->pcm); 185 if (data_blocks > 0 && pcm) 186 p->transfer_samples(s, pcm, buffer, data_blocks); 187 188 /* A place holder for control messages. */ 189 190 return data_blocks; 191 } 192 193 static unsigned int process_rx_data_blocks(struct amdtp_stream *s, 194 __be32 *buffer, 195 unsigned int data_blocks, 196 unsigned int *syt) 197 { 198 struct amdtp_tscm *p = (struct amdtp_tscm *)s->protocol; 199 struct snd_pcm_substream *pcm; 200 201 /* This field is not used. */ 202 *syt = 0x0000; 203 204 pcm = ACCESS_ONCE(s->pcm); 205 if (pcm) 206 p->transfer_samples(s, pcm, buffer, data_blocks); 207 else 208 write_pcm_silence(s, buffer, data_blocks); 209 210 return data_blocks; 211 } 212 213 int amdtp_tscm_init(struct amdtp_stream *s, struct fw_unit *unit, 214 enum amdtp_stream_direction dir, unsigned int pcm_channels) 215 { 216 amdtp_stream_process_data_blocks_t process_data_blocks; 217 struct amdtp_tscm *p; 218 unsigned int fmt; 219 int err; 220 221 if (dir == AMDTP_IN_STREAM) { 222 fmt = AMDTP_FMT_TSCM_TX; 223 process_data_blocks = process_tx_data_blocks; 224 } else { 225 fmt = AMDTP_FMT_TSCM_RX; 226 process_data_blocks = process_rx_data_blocks; 227 } 228 229 err = amdtp_stream_init(s, unit, dir, 230 CIP_NONBLOCKING | CIP_SKIP_DBC_ZERO_CHECK, fmt, 231 process_data_blocks, sizeof(struct amdtp_tscm)); 232 if (err < 0) 233 return 0; 234 235 /* Use fixed value for FDF field. */ 236 s->fdf = 0x00; 237 238 /* This protocol uses fixed number of data channels for PCM samples. */ 239 p = s->protocol; 240 p->pcm_channels = pcm_channels; 241 242 return 0; 243 } 244