1 /*
2 * fireworks_stream.c - a part of driver for Fireworks based devices
3 *
4 * Copyright (c) 2013-2014 Takashi Sakamoto
5 *
6 * Licensed under the terms of the GNU General Public License, version 2.
7 */
8 #include "./fireworks.h"
9
10 #define CALLBACK_TIMEOUT 100
11
12 static int
init_stream(struct snd_efw * efw,struct amdtp_stream * stream)13 init_stream(struct snd_efw *efw, struct amdtp_stream *stream)
14 {
15 struct cmp_connection *conn;
16 enum cmp_direction c_dir;
17 enum amdtp_stream_direction s_dir;
18 int err;
19
20 if (stream == &efw->tx_stream) {
21 conn = &efw->out_conn;
22 c_dir = CMP_OUTPUT;
23 s_dir = AMDTP_IN_STREAM;
24 } else {
25 conn = &efw->in_conn;
26 c_dir = CMP_INPUT;
27 s_dir = AMDTP_OUT_STREAM;
28 }
29
30 err = cmp_connection_init(conn, efw->unit, c_dir, 0);
31 if (err < 0)
32 goto end;
33
34 err = amdtp_stream_init(stream, efw->unit, s_dir, CIP_BLOCKING);
35 if (err < 0) {
36 amdtp_stream_destroy(stream);
37 cmp_connection_destroy(conn);
38 }
39 end:
40 return err;
41 }
42
43 static void
stop_stream(struct snd_efw * efw,struct amdtp_stream * stream)44 stop_stream(struct snd_efw *efw, struct amdtp_stream *stream)
45 {
46 amdtp_stream_pcm_abort(stream);
47 amdtp_stream_stop(stream);
48
49 if (stream == &efw->tx_stream)
50 cmp_connection_break(&efw->out_conn);
51 else
52 cmp_connection_break(&efw->in_conn);
53 }
54
55 static int
start_stream(struct snd_efw * efw,struct amdtp_stream * stream,unsigned int sampling_rate)56 start_stream(struct snd_efw *efw, struct amdtp_stream *stream,
57 unsigned int sampling_rate)
58 {
59 struct cmp_connection *conn;
60 unsigned int mode, pcm_channels, midi_ports;
61 int err;
62
63 err = snd_efw_get_multiplier_mode(sampling_rate, &mode);
64 if (err < 0)
65 goto end;
66 if (stream == &efw->tx_stream) {
67 conn = &efw->out_conn;
68 pcm_channels = efw->pcm_capture_channels[mode];
69 midi_ports = efw->midi_out_ports;
70 } else {
71 conn = &efw->in_conn;
72 pcm_channels = efw->pcm_playback_channels[mode];
73 midi_ports = efw->midi_in_ports;
74 }
75
76 amdtp_stream_set_parameters(stream, sampling_rate,
77 pcm_channels, midi_ports);
78
79 /* establish connection via CMP */
80 err = cmp_connection_establish(conn,
81 amdtp_stream_get_max_payload(stream));
82 if (err < 0)
83 goto end;
84
85 /* start amdtp stream */
86 err = amdtp_stream_start(stream,
87 conn->resources.channel,
88 conn->speed);
89 if (err < 0) {
90 stop_stream(efw, stream);
91 goto end;
92 }
93
94 /* wait first callback */
95 if (!amdtp_stream_wait_callback(stream, CALLBACK_TIMEOUT)) {
96 stop_stream(efw, stream);
97 err = -ETIMEDOUT;
98 }
99 end:
100 return err;
101 }
102
103 static void
destroy_stream(struct snd_efw * efw,struct amdtp_stream * stream)104 destroy_stream(struct snd_efw *efw, struct amdtp_stream *stream)
105 {
106 stop_stream(efw, stream);
107
108 amdtp_stream_destroy(stream);
109
110 if (stream == &efw->tx_stream)
111 cmp_connection_destroy(&efw->out_conn);
112 else
113 cmp_connection_destroy(&efw->in_conn);
114 }
115
116 static int
get_sync_mode(struct snd_efw * efw,enum cip_flags * sync_mode)117 get_sync_mode(struct snd_efw *efw, enum cip_flags *sync_mode)
118 {
119 enum snd_efw_clock_source clock_source;
120 int err;
121
122 err = snd_efw_command_get_clock_source(efw, &clock_source);
123 if (err < 0)
124 return err;
125
126 if (clock_source == SND_EFW_CLOCK_SOURCE_SYTMATCH)
127 return -ENOSYS;
128
129 *sync_mode = CIP_SYNC_TO_DEVICE;
130 return 0;
131 }
132
133 static int
check_connection_used_by_others(struct snd_efw * efw,struct amdtp_stream * s)134 check_connection_used_by_others(struct snd_efw *efw, struct amdtp_stream *s)
135 {
136 struct cmp_connection *conn;
137 bool used;
138 int err;
139
140 if (s == &efw->tx_stream)
141 conn = &efw->out_conn;
142 else
143 conn = &efw->in_conn;
144
145 err = cmp_connection_check_used(conn, &used);
146 if ((err >= 0) && used && !amdtp_stream_running(s)) {
147 dev_err(&efw->unit->device,
148 "Connection established by others: %cPCR[%d]\n",
149 (conn->direction == CMP_OUTPUT) ? 'o' : 'i',
150 conn->pcr_index);
151 err = -EBUSY;
152 }
153
154 return err;
155 }
156
snd_efw_stream_init_duplex(struct snd_efw * efw)157 int snd_efw_stream_init_duplex(struct snd_efw *efw)
158 {
159 int err;
160
161 err = init_stream(efw, &efw->tx_stream);
162 if (err < 0)
163 goto end;
164 /* Fireworks transmits NODATA packets with TAG0. */
165 efw->tx_stream.flags |= CIP_EMPTY_WITH_TAG0;
166 /* Fireworks has its own meaning for dbc. */
167 efw->tx_stream.flags |= CIP_DBC_IS_END_EVENT;
168 /* Fireworks reset dbc at bus reset. */
169 efw->tx_stream.flags |= CIP_SKIP_DBC_ZERO_CHECK;
170 /*
171 * But Recent firmwares starts packets with non-zero dbc.
172 * Driver version 5.7.6 installs firmware version 5.7.3.
173 */
174 if (efw->is_fireworks3 &&
175 (efw->firmware_version == 0x5070000 ||
176 efw->firmware_version == 0x5070300 ||
177 efw->firmware_version == 0x5080000))
178 efw->tx_stream.tx_first_dbc = 0x02;
179 /* AudioFire9 always reports wrong dbs. */
180 if (efw->is_af9)
181 efw->tx_stream.flags |= CIP_WRONG_DBS;
182 /* Firmware version 5.5 reports fixed interval for dbc. */
183 if (efw->firmware_version == 0x5050000)
184 efw->tx_stream.tx_dbc_interval = 8;
185
186 err = init_stream(efw, &efw->rx_stream);
187 if (err < 0) {
188 destroy_stream(efw, &efw->tx_stream);
189 goto end;
190 }
191 /*
192 * Fireworks ignores MIDI messages in more than first 8 data
193 * blocks of an received AMDTP packet.
194 */
195 efw->rx_stream.rx_blocks_for_midi = 8;
196
197 /* set IEC61883 compliant mode (actually not fully compliant...) */
198 err = snd_efw_command_set_tx_mode(efw, SND_EFW_TRANSPORT_MODE_IEC61883);
199 if (err < 0) {
200 destroy_stream(efw, &efw->tx_stream);
201 destroy_stream(efw, &efw->rx_stream);
202 }
203 end:
204 return err;
205 }
206
snd_efw_stream_start_duplex(struct snd_efw * efw,unsigned int rate)207 int snd_efw_stream_start_duplex(struct snd_efw *efw, unsigned int rate)
208 {
209 struct amdtp_stream *master, *slave;
210 atomic_t *slave_substreams;
211 enum cip_flags sync_mode;
212 unsigned int curr_rate;
213 int err = 0;
214
215 mutex_lock(&efw->mutex);
216
217 /* Need no substreams */
218 if ((atomic_read(&efw->playback_substreams) == 0) &&
219 (atomic_read(&efw->capture_substreams) == 0))
220 goto end;
221
222 err = get_sync_mode(efw, &sync_mode);
223 if (err < 0)
224 goto end;
225 if (sync_mode == CIP_SYNC_TO_DEVICE) {
226 master = &efw->tx_stream;
227 slave = &efw->rx_stream;
228 slave_substreams = &efw->playback_substreams;
229 } else {
230 master = &efw->rx_stream;
231 slave = &efw->tx_stream;
232 slave_substreams = &efw->capture_substreams;
233 }
234
235 /*
236 * Considering JACK/FFADO streaming:
237 * TODO: This can be removed hwdep functionality becomes popular.
238 */
239 err = check_connection_used_by_others(efw, master);
240 if (err < 0)
241 goto end;
242
243 /* packet queueing error */
244 if (amdtp_streaming_error(slave))
245 stop_stream(efw, slave);
246 if (amdtp_streaming_error(master))
247 stop_stream(efw, master);
248
249 /* stop streams if rate is different */
250 err = snd_efw_command_get_sampling_rate(efw, &curr_rate);
251 if (err < 0)
252 goto end;
253 if (rate == 0)
254 rate = curr_rate;
255 if (rate != curr_rate) {
256 stop_stream(efw, slave);
257 stop_stream(efw, master);
258 }
259
260 /* master should be always running */
261 if (!amdtp_stream_running(master)) {
262 amdtp_stream_set_sync(sync_mode, master, slave);
263 efw->master = master;
264
265 err = snd_efw_command_set_sampling_rate(efw, rate);
266 if (err < 0)
267 goto end;
268
269 err = start_stream(efw, master, rate);
270 if (err < 0) {
271 dev_err(&efw->unit->device,
272 "fail to start AMDTP master stream:%d\n", err);
273 goto end;
274 }
275 }
276
277 /* start slave if needed */
278 if (atomic_read(slave_substreams) > 0 && !amdtp_stream_running(slave)) {
279 err = start_stream(efw, slave, rate);
280 if (err < 0) {
281 dev_err(&efw->unit->device,
282 "fail to start AMDTP slave stream:%d\n", err);
283 stop_stream(efw, master);
284 }
285 }
286 end:
287 mutex_unlock(&efw->mutex);
288 return err;
289 }
290
snd_efw_stream_stop_duplex(struct snd_efw * efw)291 void snd_efw_stream_stop_duplex(struct snd_efw *efw)
292 {
293 struct amdtp_stream *master, *slave;
294 atomic_t *master_substreams, *slave_substreams;
295
296 if (efw->master == &efw->rx_stream) {
297 slave = &efw->tx_stream;
298 master = &efw->rx_stream;
299 slave_substreams = &efw->capture_substreams;
300 master_substreams = &efw->playback_substreams;
301 } else {
302 slave = &efw->rx_stream;
303 master = &efw->tx_stream;
304 slave_substreams = &efw->playback_substreams;
305 master_substreams = &efw->capture_substreams;
306 }
307
308 mutex_lock(&efw->mutex);
309
310 if (atomic_read(slave_substreams) == 0) {
311 stop_stream(efw, slave);
312
313 if (atomic_read(master_substreams) == 0)
314 stop_stream(efw, master);
315 }
316
317 mutex_unlock(&efw->mutex);
318 }
319
snd_efw_stream_update_duplex(struct snd_efw * efw)320 void snd_efw_stream_update_duplex(struct snd_efw *efw)
321 {
322 if ((cmp_connection_update(&efw->out_conn) < 0) ||
323 (cmp_connection_update(&efw->in_conn) < 0)) {
324 mutex_lock(&efw->mutex);
325 stop_stream(efw, &efw->rx_stream);
326 stop_stream(efw, &efw->tx_stream);
327 mutex_unlock(&efw->mutex);
328 } else {
329 amdtp_stream_update(&efw->rx_stream);
330 amdtp_stream_update(&efw->tx_stream);
331 }
332 }
333
snd_efw_stream_destroy_duplex(struct snd_efw * efw)334 void snd_efw_stream_destroy_duplex(struct snd_efw *efw)
335 {
336 mutex_lock(&efw->mutex);
337
338 destroy_stream(efw, &efw->rx_stream);
339 destroy_stream(efw, &efw->tx_stream);
340
341 mutex_unlock(&efw->mutex);
342 }
343
snd_efw_stream_lock_changed(struct snd_efw * efw)344 void snd_efw_stream_lock_changed(struct snd_efw *efw)
345 {
346 efw->dev_lock_changed = true;
347 wake_up(&efw->hwdep_wait);
348 }
349
snd_efw_stream_lock_try(struct snd_efw * efw)350 int snd_efw_stream_lock_try(struct snd_efw *efw)
351 {
352 int err;
353
354 spin_lock_irq(&efw->lock);
355
356 /* user land lock this */
357 if (efw->dev_lock_count < 0) {
358 err = -EBUSY;
359 goto end;
360 }
361
362 /* this is the first time */
363 if (efw->dev_lock_count++ == 0)
364 snd_efw_stream_lock_changed(efw);
365 err = 0;
366 end:
367 spin_unlock_irq(&efw->lock);
368 return err;
369 }
370
snd_efw_stream_lock_release(struct snd_efw * efw)371 void snd_efw_stream_lock_release(struct snd_efw *efw)
372 {
373 spin_lock_irq(&efw->lock);
374
375 if (WARN_ON(efw->dev_lock_count <= 0))
376 goto end;
377 if (--efw->dev_lock_count == 0)
378 snd_efw_stream_lock_changed(efw);
379 end:
380 spin_unlock_irq(&efw->lock);
381 }
382