blob: 2bbb335e8de199f3ba0ba00be859bc6ceb8a07aa [file] [log] [blame]
Thomas Gleixnerda607e12019-05-29 16:57:59 -07001// SPDX-License-Identifier: GPL-2.0-only
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +09002/*
3 * motu-stream.c - a part of driver for MOTU FireWire series
4 *
5 * Copyright (c) 2015-2017 Takashi Sakamoto <o-takashi@sakamocchi.jp>
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +09006 */
7
8#include "motu.h"
9
10#define CALLBACK_TIMEOUT 200
11
12#define ISOC_COMM_CONTROL_OFFSET 0x0b00
13#define ISOC_COMM_CONTROL_MASK 0xffff0000
14#define CHANGE_RX_ISOC_COMM_STATE 0x80000000
15#define RX_ISOC_COMM_IS_ACTIVATED 0x40000000
16#define RX_ISOC_COMM_CHANNEL_MASK 0x3f000000
17#define RX_ISOC_COMM_CHANNEL_SHIFT 24
18#define CHANGE_TX_ISOC_COMM_STATE 0x00800000
19#define TX_ISOC_COMM_IS_ACTIVATED 0x00400000
20#define TX_ISOC_COMM_CHANNEL_MASK 0x003f0000
21#define TX_ISOC_COMM_CHANNEL_SHIFT 16
22
23#define PACKET_FORMAT_OFFSET 0x0b10
24#define TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS 0x00000080
25#define RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS 0x00000040
26#define TX_PACKET_TRANSMISSION_SPEED_MASK 0x0000000f
27
Takashi Sakamoto83501322019-06-17 17:15:03 +090028static int keep_resources(struct snd_motu *motu, unsigned int rate,
29 struct amdtp_stream *stream)
30{
31 struct fw_iso_resources *resources;
32 struct snd_motu_packet_format *packet_format;
33 unsigned int midi_ports = 0;
34 int err;
35
36 if (stream == &motu->rx_stream) {
37 resources = &motu->rx_resources;
38 packet_format = &motu->rx_packet_formats;
39
40 if ((motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_2ND_Q) ||
41 (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_3RD_Q))
42 midi_ports = 1;
43 } else {
44 resources = &motu->tx_resources;
45 packet_format = &motu->tx_packet_formats;
46
47 if ((motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_2ND_Q) ||
48 (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_3RD_Q))
49 midi_ports = 1;
50 }
51
52 err = amdtp_motu_set_parameters(stream, rate, midi_ports,
53 packet_format);
54 if (err < 0)
55 return err;
56
57 return fw_iso_resources_allocate(resources,
58 amdtp_stream_get_max_payload(stream),
59 fw_parent_device(motu->unit)->max_speed);
60}
61
Takashi Sakamoto8edc56e2019-06-17 17:15:08 +090062static int begin_session(struct snd_motu *motu)
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +090063{
64 __be32 reg;
65 u32 data;
66 int err;
67
Takashi Sakamoto83501322019-06-17 17:15:03 +090068 // Configure the unit to start isochronous communication.
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +090069 err = snd_motu_transaction_read(motu, ISOC_COMM_CONTROL_OFFSET, &reg,
70 sizeof(reg));
71 if (err < 0)
72 return err;
73 data = be32_to_cpu(reg) & ~ISOC_COMM_CONTROL_MASK;
74
75 data |= CHANGE_RX_ISOC_COMM_STATE | RX_ISOC_COMM_IS_ACTIVATED |
76 (motu->rx_resources.channel << RX_ISOC_COMM_CHANNEL_SHIFT) |
77 CHANGE_TX_ISOC_COMM_STATE | TX_ISOC_COMM_IS_ACTIVATED |
78 (motu->tx_resources.channel << TX_ISOC_COMM_CHANNEL_SHIFT);
79
80 reg = cpu_to_be32(data);
81 return snd_motu_transaction_write(motu, ISOC_COMM_CONTROL_OFFSET, &reg,
82 sizeof(reg));
83}
84
Takashi Sakamotob66ab142019-06-17 17:15:05 +090085static void finish_session(struct snd_motu *motu)
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +090086{
87 __be32 reg;
88 u32 data;
89 int err;
90
91 err = motu->spec->protocol->switch_fetching_mode(motu, false);
92 if (err < 0)
93 return;
94
Takashi Sakamotoec694fb2019-06-17 17:15:07 +090095 amdtp_stream_stop(&motu->tx_stream);
96 amdtp_stream_stop(&motu->rx_stream);
97
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +090098 err = snd_motu_transaction_read(motu, ISOC_COMM_CONTROL_OFFSET, &reg,
99 sizeof(reg));
100 if (err < 0)
101 return;
102 data = be32_to_cpu(reg);
103
104 data &= ~(RX_ISOC_COMM_IS_ACTIVATED | TX_ISOC_COMM_IS_ACTIVATED);
105 data |= CHANGE_RX_ISOC_COMM_STATE | CHANGE_TX_ISOC_COMM_STATE;
106
107 reg = cpu_to_be32(data);
108 snd_motu_transaction_write(motu, ISOC_COMM_CONTROL_OFFSET, &reg,
109 sizeof(reg));
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900110}
111
112static int start_isoc_ctx(struct snd_motu *motu, struct amdtp_stream *stream)
113{
114 struct fw_iso_resources *resources;
115 int err;
116
117 if (stream == &motu->rx_stream)
118 resources = &motu->rx_resources;
119 else
120 resources = &motu->tx_resources;
121
122 err = amdtp_stream_start(stream, resources->channel,
123 fw_parent_device(motu->unit)->max_speed);
124 if (err < 0)
125 return err;
126
Takashi Sakamoto8edc56e2019-06-17 17:15:08 +0900127 if (!amdtp_stream_wait_callback(stream, CALLBACK_TIMEOUT))
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900128 return -ETIMEDOUT;
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900129
130 return 0;
131}
132
Takashi Sakamoto8b460c72017-08-20 21:25:03 +0900133int snd_motu_stream_cache_packet_formats(struct snd_motu *motu)
134{
135 int err;
136
137 err = motu->spec->protocol->cache_packet_formats(motu);
138 if (err < 0)
139 return err;
140
141 if (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_2ND_Q) {
142 motu->tx_packet_formats.midi_flag_offset = 4;
143 motu->tx_packet_formats.midi_byte_offset = 6;
144 } else if (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_3RD_Q) {
145 motu->tx_packet_formats.midi_flag_offset = 8;
146 motu->tx_packet_formats.midi_byte_offset = 7;
147 }
148
149 if (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_2ND_Q) {
150 motu->rx_packet_formats.midi_flag_offset = 4;
151 motu->rx_packet_formats.midi_byte_offset = 6;
152 } else if (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_3RD_Q) {
153 motu->rx_packet_formats.midi_flag_offset = 8;
154 motu->rx_packet_formats.midi_byte_offset = 7;
155 }
156
157 return 0;
158}
159
Takashi Sakamoto8edc56e2019-06-17 17:15:08 +0900160int snd_motu_stream_reserve_duplex(struct snd_motu *motu, unsigned int rate)
161{
162 unsigned int curr_rate;
163 int err;
164
165 err = motu->spec->protocol->get_clock_rate(motu, &curr_rate);
166 if (err < 0)
167 return err;
168 if (rate == 0)
169 rate = curr_rate;
170
171 if (motu->substreams_counter == 0 || curr_rate != rate) {
172 finish_session(motu);
173
174 fw_iso_resources_free(&motu->tx_resources);
175 fw_iso_resources_free(&motu->rx_resources);
176
177 err = motu->spec->protocol->set_clock_rate(motu, rate);
178 if (err < 0) {
179 dev_err(&motu->unit->device,
180 "fail to set sampling rate: %d\n", err);
181 return err;
182 }
183
184 err = snd_motu_stream_cache_packet_formats(motu);
185 if (err < 0)
186 return err;
187
188 err = keep_resources(motu, rate, &motu->tx_stream);
189 if (err < 0)
190 return err;
191
192 err = keep_resources(motu, rate, &motu->rx_stream);
193 if (err < 0) {
194 fw_iso_resources_free(&motu->tx_resources);
195 return err;
196 }
197 }
198
199 return 0;
200}
201
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900202static int ensure_packet_formats(struct snd_motu *motu)
203{
204 __be32 reg;
205 u32 data;
206 int err;
207
208 err = snd_motu_transaction_read(motu, PACKET_FORMAT_OFFSET, &reg,
209 sizeof(reg));
210 if (err < 0)
211 return err;
212 data = be32_to_cpu(reg);
213
214 data &= ~(TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS |
215 RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS|
216 TX_PACKET_TRANSMISSION_SPEED_MASK);
217 if (motu->tx_packet_formats.differed_part_pcm_chunks[0] == 0)
218 data |= TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS;
219 if (motu->rx_packet_formats.differed_part_pcm_chunks[0] == 0)
220 data |= RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS;
221 data |= fw_parent_device(motu->unit)->max_speed;
222
223 reg = cpu_to_be32(data);
224 return snd_motu_transaction_write(motu, PACKET_FORMAT_OFFSET, &reg,
225 sizeof(reg));
226}
227
Takashi Sakamoto8edc56e2019-06-17 17:15:08 +0900228int snd_motu_stream_start_duplex(struct snd_motu *motu)
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900229{
Takashi Sakamoto2d103422019-06-17 17:15:09 +0900230 unsigned int generation = motu->rx_resources.generation;
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900231 int err = 0;
232
Takashi Sakamoto18f26032019-06-17 17:15:01 +0900233 if (motu->substreams_counter == 0)
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900234 return 0;
235
Takashi Sakamoto8edc56e2019-06-17 17:15:08 +0900236 if (amdtp_streaming_error(&motu->rx_stream) ||
Takashi Sakamotoec694fb2019-06-17 17:15:07 +0900237 amdtp_streaming_error(&motu->tx_stream))
Takashi Sakamotob66ab142019-06-17 17:15:05 +0900238 finish_session(motu);
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900239
Takashi Sakamoto2d103422019-06-17 17:15:09 +0900240 if (generation != fw_parent_device(motu->unit)->card->generation) {
241 err = fw_iso_resources_update(&motu->rx_resources);
242 if (err < 0)
243 return err;
244
245 err = fw_iso_resources_update(&motu->tx_resources);
246 if (err < 0)
247 return err;
248 }
249
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900250 if (!amdtp_stream_running(&motu->rx_stream)) {
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900251 err = ensure_packet_formats(motu);
252 if (err < 0)
253 return err;
254
Takashi Sakamoto8edc56e2019-06-17 17:15:08 +0900255 err = begin_session(motu);
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900256 if (err < 0) {
257 dev_err(&motu->unit->device,
258 "fail to start isochronous comm: %d\n", err);
Markus Elfringf16e6662017-09-06 13:30:14 +0200259 goto stop_streams;
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900260 }
261
262 err = start_isoc_ctx(motu, &motu->rx_stream);
263 if (err < 0) {
264 dev_err(&motu->unit->device,
265 "fail to start IT context: %d\n", err);
Markus Elfringf16e6662017-09-06 13:30:14 +0200266 goto stop_streams;
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900267 }
268
Takashi Sakamoto8edc56e2019-06-17 17:15:08 +0900269 err = motu->spec->protocol->switch_fetching_mode(motu, true);
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900270 if (err < 0) {
271 dev_err(&motu->unit->device,
272 "fail to enable frame fetching: %d\n", err);
Markus Elfringf16e6662017-09-06 13:30:14 +0200273 goto stop_streams;
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900274 }
275 }
276
Takashi Sakamoto18f26032019-06-17 17:15:01 +0900277 if (!amdtp_stream_running(&motu->tx_stream)) {
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900278 err = start_isoc_ctx(motu, &motu->tx_stream);
279 if (err < 0) {
280 dev_err(&motu->unit->device,
281 "fail to start IR context: %d", err);
Markus Elfringf16e6662017-09-06 13:30:14 +0200282 goto stop_streams;
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900283 }
284 }
285
286 return 0;
Markus Elfringf16e6662017-09-06 13:30:14 +0200287
288stop_streams:
Takashi Sakamotob66ab142019-06-17 17:15:05 +0900289 finish_session(motu);
Markus Elfringf16e6662017-09-06 13:30:14 +0200290 return err;
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900291}
292
293void snd_motu_stream_stop_duplex(struct snd_motu *motu)
294{
Takashi Sakamotoeccd8952019-06-18 22:26:17 +0900295 if (motu->substreams_counter == 0) {
Takashi Sakamotoec694fb2019-06-17 17:15:07 +0900296 finish_session(motu);
Takashi Sakamotoeccd8952019-06-18 22:26:17 +0900297
298 fw_iso_resources_free(&motu->tx_resources);
299 fw_iso_resources_free(&motu->rx_resources);
300 }
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900301}
302
303static int init_stream(struct snd_motu *motu, enum amdtp_stream_direction dir)
304{
305 int err;
306 struct amdtp_stream *stream;
307 struct fw_iso_resources *resources;
308
309 if (dir == AMDTP_IN_STREAM) {
310 stream = &motu->tx_stream;
311 resources = &motu->tx_resources;
312 } else {
313 stream = &motu->rx_stream;
314 resources = &motu->rx_resources;
315 }
316
317 err = fw_iso_resources_init(resources, motu->unit);
318 if (err < 0)
319 return err;
320
321 err = amdtp_motu_init(stream, motu->unit, dir, motu->spec->protocol);
322 if (err < 0) {
323 amdtp_stream_destroy(stream);
324 fw_iso_resources_destroy(resources);
325 }
326
327 return err;
328}
329
330static void destroy_stream(struct snd_motu *motu,
331 enum amdtp_stream_direction dir)
332{
333 struct amdtp_stream *stream;
334 struct fw_iso_resources *resources;
335
336 if (dir == AMDTP_IN_STREAM) {
337 stream = &motu->tx_stream;
338 resources = &motu->tx_resources;
339 } else {
340 stream = &motu->rx_stream;
341 resources = &motu->rx_resources;
342 }
343
344 amdtp_stream_destroy(stream);
Takashi Sakamoto0e3fb692019-06-01 12:08:01 +0900345 fw_iso_resources_destroy(resources);
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900346}
347
348int snd_motu_stream_init_duplex(struct snd_motu *motu)
349{
350 int err;
351
352 err = init_stream(motu, AMDTP_IN_STREAM);
353 if (err < 0)
354 return err;
355
356 err = init_stream(motu, AMDTP_OUT_STREAM);
357 if (err < 0)
358 destroy_stream(motu, AMDTP_IN_STREAM);
359
360 return err;
361}
362
363/*
364 * This function should be called before starting streams or after stopping
365 * streams.
366 */
367void snd_motu_stream_destroy_duplex(struct snd_motu *motu)
368{
369 destroy_stream(motu, AMDTP_IN_STREAM);
370 destroy_stream(motu, AMDTP_OUT_STREAM);
371
Takashi Sakamoto18f26032019-06-17 17:15:01 +0900372 motu->substreams_counter = 0;
Takashi Sakamoto9b2bb4f2017-03-22 21:30:20 +0900373}
Takashi Sakamoto71c37972017-03-22 21:30:24 +0900374
375static void motu_lock_changed(struct snd_motu *motu)
376{
377 motu->dev_lock_changed = true;
378 wake_up(&motu->hwdep_wait);
379}
380
381int snd_motu_stream_lock_try(struct snd_motu *motu)
382{
383 int err;
384
385 spin_lock_irq(&motu->lock);
386
387 if (motu->dev_lock_count < 0) {
388 err = -EBUSY;
389 goto out;
390 }
391
392 if (motu->dev_lock_count++ == 0)
393 motu_lock_changed(motu);
394 err = 0;
395out:
396 spin_unlock_irq(&motu->lock);
397 return err;
398}
399
400void snd_motu_stream_lock_release(struct snd_motu *motu)
401{
402 spin_lock_irq(&motu->lock);
403
404 if (WARN_ON(motu->dev_lock_count <= 0))
405 goto out;
406
407 if (--motu->dev_lock_count == 0)
408 motu_lock_changed(motu);
409out:
410 spin_unlock_irq(&motu->lock);
411}