1 // SPDX-License-Identifier: GPL-2.0-only
3 * amdtp-tascam.c - a part of driver for TASCAM FireWire series
5 * Copyright (c) 2015 Takashi Sakamoto
11 #define AMDTP_FMT_TSCM_TX 0x1e
12 #define AMDTP_FMT_TSCM_RX 0x3e
15 unsigned int pcm_channels;
18 int amdtp_tscm_set_parameters(struct amdtp_stream *s, unsigned int rate)
20 struct amdtp_tscm *p = s->protocol;
21 unsigned int data_channels;
23 if (amdtp_stream_running(s))
26 data_channels = p->pcm_channels;
28 /* Packets in in-stream have extra 2 data channels. */
29 if (s->direction == AMDTP_IN_STREAM)
32 return amdtp_stream_set_parameters(s, rate, data_channels);
35 static void write_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
36 __be32 *buffer, unsigned int frames,
37 unsigned int pcm_frames)
39 struct amdtp_tscm *p = s->protocol;
40 unsigned int channels = p->pcm_channels;
41 struct snd_pcm_runtime *runtime = pcm->runtime;
42 unsigned int pcm_buffer_pointer;
47 pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
48 pcm_buffer_pointer %= runtime->buffer_size;
50 src = (void *)runtime->dma_area +
51 frames_to_bytes(runtime, pcm_buffer_pointer);
52 remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
54 for (i = 0; i < frames; ++i) {
55 for (c = 0; c < channels; ++c) {
56 buffer[c] = cpu_to_be32(*src);
59 buffer += s->data_block_quadlets;
60 if (--remaining_frames == 0)
61 src = (void *)runtime->dma_area;
65 static void read_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
66 __be32 *buffer, unsigned int frames,
67 unsigned int pcm_frames)
69 struct amdtp_tscm *p = s->protocol;
70 unsigned int channels = p->pcm_channels;
71 struct snd_pcm_runtime *runtime = pcm->runtime;
72 unsigned int pcm_buffer_pointer;
77 pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
78 pcm_buffer_pointer %= runtime->buffer_size;
80 dst = (void *)runtime->dma_area +
81 frames_to_bytes(runtime, pcm_buffer_pointer);
82 remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
84 /* The first data channel is for event counter. */
87 for (i = 0; i < frames; ++i) {
88 for (c = 0; c < channels; ++c) {
89 *dst = be32_to_cpu(buffer[c]);
92 buffer += s->data_block_quadlets;
93 if (--remaining_frames == 0)
94 dst = (void *)runtime->dma_area;
98 static void write_pcm_silence(struct amdtp_stream *s, __be32 *buffer,
99 unsigned int data_blocks)
101 struct amdtp_tscm *p = s->protocol;
102 unsigned int channels, i, c;
104 channels = p->pcm_channels;
106 for (i = 0; i < data_blocks; ++i) {
107 for (c = 0; c < channels; ++c)
108 buffer[c] = 0x00000000;
109 buffer += s->data_block_quadlets;
113 int amdtp_tscm_add_pcm_hw_constraints(struct amdtp_stream *s,
114 struct snd_pcm_runtime *runtime)
119 * Our implementation allows this protocol to deliver 24 bit sample in
120 * 32bit data channel.
122 err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
126 return amdtp_stream_add_pcm_hw_constraints(s, runtime);
129 static void read_status_messages(struct amdtp_stream *s,
130 __be32 *buffer, unsigned int data_blocks)
132 struct snd_tscm *tscm = container_of(s, struct snd_tscm, tx_stream);
133 bool used = READ_ONCE(tscm->hwdep->used);
136 for (i = 0; i < data_blocks; i++) {
141 index = be32_to_cpu(buffer[0]) % SNDRV_FIREWIRE_TASCAM_STATE_COUNT;
142 before = tscm->state[index];
143 after = buffer[s->data_block_quadlets - 1];
145 if (used && index > 4 && index < 16) {
149 mask = cpu_to_be32(~0x0000ffff);
151 mask = cpu_to_be32(~0x0000ffff);
153 mask = cpu_to_be32(~0x000f0f00);
155 mask = cpu_to_be32(~0x00000000);
157 if ((before ^ after) & mask) {
158 struct snd_firewire_tascam_change *entry =
159 &tscm->queue[tscm->push_pos];
161 spin_lock_irq(&tscm->lock);
162 entry->index = index;
163 entry->before = before;
164 entry->after = after;
165 if (++tscm->push_pos >= SND_TSCM_QUEUE_COUNT)
167 spin_unlock_irq(&tscm->lock);
169 wake_up(&tscm->hwdep_wait);
173 tscm->state[index] = after;
174 buffer += s->data_block_quadlets;
178 static unsigned int process_ir_ctx_payloads(struct amdtp_stream *s,
179 const struct pkt_desc *descs,
180 unsigned int packets,
181 struct snd_pcm_substream *pcm)
183 unsigned int pcm_frames = 0;
186 for (i = 0; i < packets; ++i) {
187 const struct pkt_desc *desc = descs + i;
188 __be32 *buf = desc->ctx_payload;
189 unsigned int data_blocks = desc->data_blocks;
192 read_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
193 pcm_frames += data_blocks;
196 read_status_messages(s, buf, data_blocks);
202 static unsigned int process_it_ctx_payloads(struct amdtp_stream *s,
203 const struct pkt_desc *descs,
204 unsigned int packets,
205 struct snd_pcm_substream *pcm)
207 unsigned int pcm_frames = 0;
210 for (i = 0; i < packets; ++i) {
211 const struct pkt_desc *desc = descs + i;
212 __be32 *buf = desc->ctx_payload;
213 unsigned int data_blocks = desc->data_blocks;
216 write_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
217 pcm_frames += data_blocks;
219 write_pcm_silence(s, buf, data_blocks);
226 int amdtp_tscm_init(struct amdtp_stream *s, struct fw_unit *unit,
227 enum amdtp_stream_direction dir, unsigned int pcm_channels)
229 amdtp_stream_process_ctx_payloads_t process_ctx_payloads;
230 struct amdtp_tscm *p;
234 if (dir == AMDTP_IN_STREAM) {
235 fmt = AMDTP_FMT_TSCM_TX;
236 process_ctx_payloads = process_ir_ctx_payloads;
238 fmt = AMDTP_FMT_TSCM_RX;
239 process_ctx_payloads = process_it_ctx_payloads;
242 err = amdtp_stream_init(s, unit, dir,
243 CIP_NONBLOCKING | CIP_SKIP_DBC_ZERO_CHECK, fmt,
244 process_ctx_payloads, sizeof(struct amdtp_tscm));
248 if (dir == AMDTP_OUT_STREAM) {
249 // Use fixed value for FDF field.
250 s->ctx_data.rx.fdf = 0x00;
252 s->ctx_data.rx.syt_override = 0x0000;
255 /* This protocol uses fixed number of data channels for PCM samples. */
257 p->pcm_channels = pcm_channels;