Commit | Line | Data |
---|---|---|
315fd41f TS |
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 | ||
315fd41f TS |
12 | static int |
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 | |
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 | |
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 | ||
d23c2cc4 TS |
103 | /* |
104 | * This function should be called before starting the stream or after stopping | |
105 | * the streams. | |
106 | */ | |
315fd41f TS |
107 | static void |
108 | destroy_stream(struct snd_efw *efw, struct amdtp_stream *stream) | |
109 | { | |
d23c2cc4 | 110 | struct cmp_connection *conn; |
315fd41f TS |
111 | |
112 | if (stream == &efw->tx_stream) | |
d23c2cc4 | 113 | conn = &efw->out_conn; |
315fd41f | 114 | else |
d23c2cc4 TS |
115 | conn = &efw->in_conn; |
116 | ||
117 | amdtp_stream_destroy(stream); | |
118 | cmp_connection_destroy(&efw->out_conn); | |
315fd41f TS |
119 | } |
120 | ||
121 | static int | |
122 | get_sync_mode(struct snd_efw *efw, enum cip_flags *sync_mode) | |
123 | { | |
124 | enum snd_efw_clock_source clock_source; | |
125 | int err; | |
126 | ||
127 | err = snd_efw_command_get_clock_source(efw, &clock_source); | |
128 | if (err < 0) | |
129 | return err; | |
130 | ||
131 | if (clock_source == SND_EFW_CLOCK_SOURCE_SYTMATCH) | |
132 | return -ENOSYS; | |
133 | ||
134 | *sync_mode = CIP_SYNC_TO_DEVICE; | |
135 | return 0; | |
136 | } | |
137 | ||
138 | static int | |
139 | check_connection_used_by_others(struct snd_efw *efw, struct amdtp_stream *s) | |
140 | { | |
141 | struct cmp_connection *conn; | |
142 | bool used; | |
143 | int err; | |
144 | ||
145 | if (s == &efw->tx_stream) | |
146 | conn = &efw->out_conn; | |
147 | else | |
148 | conn = &efw->in_conn; | |
149 | ||
150 | err = cmp_connection_check_used(conn, &used); | |
151 | if ((err >= 0) && used && !amdtp_stream_running(s)) { | |
152 | dev_err(&efw->unit->device, | |
153 | "Connection established by others: %cPCR[%d]\n", | |
154 | (conn->direction == CMP_OUTPUT) ? 'o' : 'i', | |
155 | conn->pcr_index); | |
156 | err = -EBUSY; | |
157 | } | |
158 | ||
159 | return err; | |
160 | } | |
161 | ||
162 | int snd_efw_stream_init_duplex(struct snd_efw *efw) | |
163 | { | |
164 | int err; | |
165 | ||
166 | err = init_stream(efw, &efw->tx_stream); | |
167 | if (err < 0) | |
168 | goto end; | |
7ab56645 TS |
169 | /* Fireworks transmits NODATA packets with TAG0. */ |
170 | efw->tx_stream.flags |= CIP_EMPTY_WITH_TAG0; | |
c8bdf49b TS |
171 | /* Fireworks has its own meaning for dbc. */ |
172 | efw->tx_stream.flags |= CIP_DBC_IS_END_EVENT; | |
b84b1a27 TS |
173 | /* Fireworks reset dbc at bus reset. */ |
174 | efw->tx_stream.flags |= CIP_SKIP_DBC_ZERO_CHECK; | |
69702239 TS |
175 | /* AudioFire9 always reports wrong dbs. */ |
176 | if (efw->is_af9) | |
177 | efw->tx_stream.flags |= CIP_WRONG_DBS; | |
d9cd0065 TS |
178 | /* Firmware version 5.5 reports fixed interval for dbc. */ |
179 | if (efw->firmware_version == 0x5050000) | |
180 | efw->tx_stream.tx_dbc_interval = 8; | |
315fd41f TS |
181 | |
182 | err = init_stream(efw, &efw->rx_stream); | |
183 | if (err < 0) { | |
184 | destroy_stream(efw, &efw->tx_stream); | |
185 | goto end; | |
186 | } | |
187 | ||
188 | /* set IEC61883 compliant mode (actually not fully compliant...) */ | |
189 | err = snd_efw_command_set_tx_mode(efw, SND_EFW_TRANSPORT_MODE_IEC61883); | |
190 | if (err < 0) { | |
191 | destroy_stream(efw, &efw->tx_stream); | |
192 | destroy_stream(efw, &efw->rx_stream); | |
193 | } | |
194 | end: | |
195 | return err; | |
196 | } | |
197 | ||
4a286d55 | 198 | int snd_efw_stream_start_duplex(struct snd_efw *efw, unsigned int rate) |
315fd41f TS |
199 | { |
200 | struct amdtp_stream *master, *slave; | |
201 | atomic_t *slave_substreams; | |
202 | enum cip_flags sync_mode; | |
203 | unsigned int curr_rate; | |
204 | int err = 0; | |
205 | ||
206 | mutex_lock(&efw->mutex); | |
207 | ||
208 | /* Need no substreams */ | |
209 | if ((atomic_read(&efw->playback_substreams) == 0) && | |
210 | (atomic_read(&efw->capture_substreams) == 0)) | |
211 | goto end; | |
212 | ||
213 | err = get_sync_mode(efw, &sync_mode); | |
214 | if (err < 0) | |
215 | goto end; | |
216 | if (sync_mode == CIP_SYNC_TO_DEVICE) { | |
217 | master = &efw->tx_stream; | |
218 | slave = &efw->rx_stream; | |
219 | slave_substreams = &efw->playback_substreams; | |
220 | } else { | |
221 | master = &efw->rx_stream; | |
222 | slave = &efw->tx_stream; | |
223 | slave_substreams = &efw->capture_substreams; | |
224 | } | |
225 | ||
226 | /* | |
227 | * Considering JACK/FFADO streaming: | |
228 | * TODO: This can be removed hwdep functionality becomes popular. | |
229 | */ | |
230 | err = check_connection_used_by_others(efw, master); | |
231 | if (err < 0) | |
232 | goto end; | |
233 | ||
234 | /* packet queueing error */ | |
235 | if (amdtp_streaming_error(slave)) | |
236 | stop_stream(efw, slave); | |
237 | if (amdtp_streaming_error(master)) | |
238 | stop_stream(efw, master); | |
239 | ||
240 | /* stop streams if rate is different */ | |
241 | err = snd_efw_command_get_sampling_rate(efw, &curr_rate); | |
242 | if (err < 0) | |
243 | goto end; | |
244 | if (rate == 0) | |
245 | rate = curr_rate; | |
246 | if (rate != curr_rate) { | |
247 | stop_stream(efw, slave); | |
248 | stop_stream(efw, master); | |
249 | } | |
250 | ||
251 | /* master should be always running */ | |
252 | if (!amdtp_stream_running(master)) { | |
253 | amdtp_stream_set_sync(sync_mode, master, slave); | |
254 | efw->master = master; | |
255 | ||
256 | err = snd_efw_command_set_sampling_rate(efw, rate); | |
257 | if (err < 0) | |
258 | goto end; | |
259 | ||
260 | err = start_stream(efw, master, rate); | |
261 | if (err < 0) { | |
262 | dev_err(&efw->unit->device, | |
263 | "fail to start AMDTP master stream:%d\n", err); | |
264 | goto end; | |
265 | } | |
266 | } | |
267 | ||
268 | /* start slave if needed */ | |
269 | if (atomic_read(slave_substreams) > 0 && !amdtp_stream_running(slave)) { | |
270 | err = start_stream(efw, slave, rate); | |
271 | if (err < 0) { | |
272 | dev_err(&efw->unit->device, | |
273 | "fail to start AMDTP slave stream:%d\n", err); | |
274 | stop_stream(efw, master); | |
275 | } | |
276 | } | |
277 | end: | |
278 | mutex_unlock(&efw->mutex); | |
279 | return err; | |
280 | } | |
281 | ||
282 | void snd_efw_stream_stop_duplex(struct snd_efw *efw) | |
283 | { | |
284 | struct amdtp_stream *master, *slave; | |
285 | atomic_t *master_substreams, *slave_substreams; | |
286 | ||
315fd41f TS |
287 | if (efw->master == &efw->rx_stream) { |
288 | slave = &efw->tx_stream; | |
289 | master = &efw->rx_stream; | |
290 | slave_substreams = &efw->capture_substreams; | |
291 | master_substreams = &efw->playback_substreams; | |
292 | } else { | |
293 | slave = &efw->rx_stream; | |
294 | master = &efw->tx_stream; | |
295 | slave_substreams = &efw->playback_substreams; | |
296 | master_substreams = &efw->capture_substreams; | |
297 | } | |
298 | ||
c6e5e741 TS |
299 | mutex_lock(&efw->mutex); |
300 | ||
315fd41f TS |
301 | if (atomic_read(slave_substreams) == 0) { |
302 | stop_stream(efw, slave); | |
303 | ||
304 | if (atomic_read(master_substreams) == 0) | |
305 | stop_stream(efw, master); | |
306 | } | |
307 | ||
308 | mutex_unlock(&efw->mutex); | |
309 | } | |
310 | ||
311 | void snd_efw_stream_update_duplex(struct snd_efw *efw) | |
312 | { | |
313 | if ((cmp_connection_update(&efw->out_conn) < 0) || | |
314 | (cmp_connection_update(&efw->in_conn) < 0)) { | |
315 | mutex_lock(&efw->mutex); | |
316 | stop_stream(efw, &efw->rx_stream); | |
317 | stop_stream(efw, &efw->tx_stream); | |
318 | mutex_unlock(&efw->mutex); | |
319 | } else { | |
320 | amdtp_stream_update(&efw->rx_stream); | |
321 | amdtp_stream_update(&efw->tx_stream); | |
322 | } | |
323 | } | |
324 | ||
325 | void snd_efw_stream_destroy_duplex(struct snd_efw *efw) | |
326 | { | |
315fd41f TS |
327 | destroy_stream(efw, &efw->rx_stream); |
328 | destroy_stream(efw, &efw->tx_stream); | |
315fd41f | 329 | } |
594ddced TS |
330 | |
331 | void snd_efw_stream_lock_changed(struct snd_efw *efw) | |
332 | { | |
333 | efw->dev_lock_changed = true; | |
334 | wake_up(&efw->hwdep_wait); | |
335 | } | |
336 | ||
337 | int snd_efw_stream_lock_try(struct snd_efw *efw) | |
338 | { | |
339 | int err; | |
340 | ||
341 | spin_lock_irq(&efw->lock); | |
342 | ||
343 | /* user land lock this */ | |
344 | if (efw->dev_lock_count < 0) { | |
345 | err = -EBUSY; | |
346 | goto end; | |
347 | } | |
348 | ||
349 | /* this is the first time */ | |
350 | if (efw->dev_lock_count++ == 0) | |
351 | snd_efw_stream_lock_changed(efw); | |
352 | err = 0; | |
353 | end: | |
354 | spin_unlock_irq(&efw->lock); | |
355 | return err; | |
356 | } | |
357 | ||
358 | void snd_efw_stream_lock_release(struct snd_efw *efw) | |
359 | { | |
360 | spin_lock_irq(&efw->lock); | |
361 | ||
362 | if (WARN_ON(efw->dev_lock_count <= 0)) | |
363 | goto end; | |
364 | if (--efw->dev_lock_count == 0) | |
365 | snd_efw_stream_lock_changed(efw); | |
366 | end: | |
367 | spin_unlock_irq(&efw->lock); | |
368 | } |