1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * amdtp-tascam.c - a part of driver for TASCAM FireWire series
4 *
5 * Copyright (c) 2015 Takashi Sakamoto
6 */
7
8 #include <sound/pcm.h>
9 #include "tascam.h"
10
11 #define AMDTP_FMT_TSCM_TX 0x1e
12 #define AMDTP_FMT_TSCM_RX 0x3e
13
14 struct amdtp_tscm {
15 unsigned int pcm_channels;
16 };
17
amdtp_tscm_set_parameters(struct amdtp_stream * s,unsigned int rate)18 int amdtp_tscm_set_parameters(struct amdtp_stream *s, unsigned int rate)
19 {
20 struct amdtp_tscm *p = s->protocol;
21 unsigned int data_channels;
22
23 if (amdtp_stream_running(s))
24 return -EBUSY;
25
26 data_channels = p->pcm_channels;
27
28 /* Packets in in-stream have extra 2 data channels. */
29 if (s->direction == AMDTP_IN_STREAM)
30 data_channels += 2;
31
32 return amdtp_stream_set_parameters(s, rate, data_channels);
33 }
34
write_pcm_s32(struct amdtp_stream * s,struct snd_pcm_substream * pcm,__be32 * buffer,unsigned int frames,unsigned int pcm_frames)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)
38 {
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;
43 int remaining_frames;
44 const u32 *src;
45 int i, c;
46
47 pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
48 pcm_buffer_pointer %= runtime->buffer_size;
49
50 src = (void *)runtime->dma_area +
51 frames_to_bytes(runtime, pcm_buffer_pointer);
52 remaining_frames = runtime->buffer_size - 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
read_pcm_s32(struct amdtp_stream * s,struct snd_pcm_substream * pcm,__be32 * buffer,unsigned int frames,unsigned int pcm_frames)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)
68 {
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;
73 int remaining_frames;
74 u32 *dst;
75 int i, c;
76
77 pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
78 pcm_buffer_pointer %= runtime->buffer_size;
79
80 dst = (void *)runtime->dma_area +
81 frames_to_bytes(runtime, pcm_buffer_pointer);
82 remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
83
84 /* The first data channel is for event counter. */
85 buffer += 1;
86
87 for (i = 0; i < frames; ++i) {
88 for (c = 0; c < channels; ++c) {
89 *dst = be32_to_cpu(buffer[c]);
90 dst++;
91 }
92 buffer += s->data_block_quadlets;
93 if (--remaining_frames == 0)
94 dst = (void *)runtime->dma_area;
95 }
96 }
97
write_pcm_silence(struct amdtp_stream * s,__be32 * buffer,unsigned int data_blocks)98 static void write_pcm_silence(struct amdtp_stream *s, __be32 *buffer,
99 unsigned int data_blocks)
100 {
101 struct amdtp_tscm *p = s->protocol;
102 unsigned int channels, i, c;
103
104 channels = p->pcm_channels;
105
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;
110 }
111 }
112
amdtp_tscm_add_pcm_hw_constraints(struct amdtp_stream * s,struct snd_pcm_runtime * runtime)113 int amdtp_tscm_add_pcm_hw_constraints(struct amdtp_stream *s,
114 struct snd_pcm_runtime *runtime)
115 {
116 int err;
117
118 /*
119 * Our implementation allows this protocol to deliver 24 bit sample in
120 * 32bit data channel.
121 */
122 err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
123 if (err < 0)
124 return err;
125
126 return amdtp_stream_add_pcm_hw_constraints(s, runtime);
127 }
128
read_status_messages(struct amdtp_stream * s,__be32 * buffer,unsigned int data_blocks)129 static void read_status_messages(struct amdtp_stream *s,
130 __be32 *buffer, unsigned int data_blocks)
131 {
132 struct snd_tscm *tscm = container_of(s, struct snd_tscm, tx_stream);
133 bool used = READ_ONCE(tscm->hwdep->used);
134 int i;
135
136 for (i = 0; i < data_blocks; i++) {
137 unsigned int index;
138 __be32 before;
139 __be32 after;
140
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];
144
145 if (used && index > 4 && index < 16) {
146 __be32 mask;
147
148 if (index == 5)
149 mask = cpu_to_be32(~0x0000ffff);
150 else if (index == 6)
151 mask = cpu_to_be32(~0x0000ffff);
152 else if (index == 8)
153 mask = cpu_to_be32(~0x000f0f00);
154 else
155 mask = cpu_to_be32(~0x00000000);
156
157 if ((before ^ after) & mask) {
158 struct snd_firewire_tascam_change *entry =
159 &tscm->queue[tscm->push_pos];
160 unsigned long flag;
161
162 spin_lock_irqsave(&tscm->lock, flag);
163 entry->index = index;
164 entry->before = before;
165 entry->after = after;
166 if (++tscm->push_pos >= SND_TSCM_QUEUE_COUNT)
167 tscm->push_pos = 0;
168 spin_unlock_irqrestore(&tscm->lock, flag);
169
170 wake_up(&tscm->hwdep_wait);
171 }
172 }
173
174 tscm->state[index] = after;
175 buffer += s->data_block_quadlets;
176 }
177 }
178
process_ir_ctx_payloads(struct amdtp_stream * s,const struct pkt_desc * descs,unsigned int packets,struct snd_pcm_substream * pcm)179 static unsigned int process_ir_ctx_payloads(struct amdtp_stream *s,
180 const struct pkt_desc *descs,
181 unsigned int packets,
182 struct snd_pcm_substream *pcm)
183 {
184 unsigned int pcm_frames = 0;
185 int i;
186
187 for (i = 0; i < packets; ++i) {
188 const struct pkt_desc *desc = descs + i;
189 __be32 *buf = desc->ctx_payload;
190 unsigned int data_blocks = desc->data_blocks;
191
192 if (pcm) {
193 read_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
194 pcm_frames += data_blocks;
195 }
196
197 read_status_messages(s, buf, data_blocks);
198 }
199
200 return pcm_frames;
201 }
202
process_it_ctx_payloads(struct amdtp_stream * s,const struct pkt_desc * descs,unsigned int packets,struct snd_pcm_substream * pcm)203 static unsigned int process_it_ctx_payloads(struct amdtp_stream *s,
204 const struct pkt_desc *descs,
205 unsigned int packets,
206 struct snd_pcm_substream *pcm)
207 {
208 unsigned int pcm_frames = 0;
209 int i;
210
211 for (i = 0; i < packets; ++i) {
212 const struct pkt_desc *desc = descs + i;
213 __be32 *buf = desc->ctx_payload;
214 unsigned int data_blocks = desc->data_blocks;
215
216 if (pcm) {
217 write_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
218 pcm_frames += data_blocks;
219 } else {
220 write_pcm_silence(s, buf, data_blocks);
221 }
222 }
223
224 return pcm_frames;
225 }
226
amdtp_tscm_init(struct amdtp_stream * s,struct fw_unit * unit,enum amdtp_stream_direction dir,unsigned int pcm_channels)227 int amdtp_tscm_init(struct amdtp_stream *s, struct fw_unit *unit,
228 enum amdtp_stream_direction dir, unsigned int pcm_channels)
229 {
230 amdtp_stream_process_ctx_payloads_t process_ctx_payloads;
231 struct amdtp_tscm *p;
232 unsigned int fmt;
233 int err;
234
235 if (dir == AMDTP_IN_STREAM) {
236 fmt = AMDTP_FMT_TSCM_TX;
237 process_ctx_payloads = process_ir_ctx_payloads;
238 } else {
239 fmt = AMDTP_FMT_TSCM_RX;
240 process_ctx_payloads = process_it_ctx_payloads;
241 }
242
243 err = amdtp_stream_init(s, unit, dir,
244 CIP_NONBLOCKING | CIP_SKIP_DBC_ZERO_CHECK, fmt,
245 process_ctx_payloads, sizeof(struct amdtp_tscm));
246 if (err < 0)
247 return 0;
248
249 if (dir == AMDTP_OUT_STREAM) {
250 // Use fixed value for FDF field.
251 s->ctx_data.rx.fdf = 0x00;
252 // Not used.
253 s->ctx_data.rx.syt_override = 0x0000;
254 }
255
256 /* This protocol uses fixed number of data channels for PCM samples. */
257 p = s->protocol;
258 p->pcm_channels = pcm_channels;
259
260 return 0;
261 }
262
