This source file includes following definitions.
- keep_resources
- begin_session
- finish_session
- snd_motu_stream_cache_packet_formats
- snd_motu_stream_reserve_duplex
- ensure_packet_formats
- snd_motu_stream_start_duplex
- snd_motu_stream_stop_duplex
- init_stream
- destroy_stream
- snd_motu_stream_init_duplex
- snd_motu_stream_destroy_duplex
- motu_lock_changed
- snd_motu_stream_lock_try
- snd_motu_stream_lock_release
1
2
3
4
5
6
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
28 static 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
62 static int begin_session(struct snd_motu *motu)
63 {
64 __be32 reg;
65 u32 data;
66 int err;
67
68
69 err = snd_motu_transaction_read(motu, ISOC_COMM_CONTROL_OFFSET, ®,
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, ®,
82 sizeof(reg));
83 }
84
85 static void finish_session(struct snd_motu *motu)
86 {
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
95 err = snd_motu_transaction_read(motu, ISOC_COMM_CONTROL_OFFSET, ®,
96 sizeof(reg));
97 if (err < 0)
98 return;
99 data = be32_to_cpu(reg);
100
101 data &= ~(RX_ISOC_COMM_IS_ACTIVATED | TX_ISOC_COMM_IS_ACTIVATED);
102 data |= CHANGE_RX_ISOC_COMM_STATE | CHANGE_TX_ISOC_COMM_STATE;
103
104 reg = cpu_to_be32(data);
105 snd_motu_transaction_write(motu, ISOC_COMM_CONTROL_OFFSET, ®,
106 sizeof(reg));
107 }
108
109 int snd_motu_stream_cache_packet_formats(struct snd_motu *motu)
110 {
111 int err;
112
113 err = motu->spec->protocol->cache_packet_formats(motu);
114 if (err < 0)
115 return err;
116
117 if (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_2ND_Q) {
118 motu->tx_packet_formats.midi_flag_offset = 4;
119 motu->tx_packet_formats.midi_byte_offset = 6;
120 } else if (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_3RD_Q) {
121 motu->tx_packet_formats.midi_flag_offset = 8;
122 motu->tx_packet_formats.midi_byte_offset = 7;
123 }
124
125 if (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_2ND_Q) {
126 motu->rx_packet_formats.midi_flag_offset = 4;
127 motu->rx_packet_formats.midi_byte_offset = 6;
128 } else if (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_3RD_Q) {
129 motu->rx_packet_formats.midi_flag_offset = 8;
130 motu->rx_packet_formats.midi_byte_offset = 7;
131 }
132
133 return 0;
134 }
135
136 int snd_motu_stream_reserve_duplex(struct snd_motu *motu, unsigned int rate)
137 {
138 unsigned int curr_rate;
139 int err;
140
141 err = motu->spec->protocol->get_clock_rate(motu, &curr_rate);
142 if (err < 0)
143 return err;
144 if (rate == 0)
145 rate = curr_rate;
146
147 if (motu->substreams_counter == 0 || curr_rate != rate) {
148 amdtp_domain_stop(&motu->domain);
149 finish_session(motu);
150
151 fw_iso_resources_free(&motu->tx_resources);
152 fw_iso_resources_free(&motu->rx_resources);
153
154 err = motu->spec->protocol->set_clock_rate(motu, rate);
155 if (err < 0) {
156 dev_err(&motu->unit->device,
157 "fail to set sampling rate: %d\n", err);
158 return err;
159 }
160
161 err = snd_motu_stream_cache_packet_formats(motu);
162 if (err < 0)
163 return err;
164
165 err = keep_resources(motu, rate, &motu->tx_stream);
166 if (err < 0)
167 return err;
168
169 err = keep_resources(motu, rate, &motu->rx_stream);
170 if (err < 0) {
171 fw_iso_resources_free(&motu->tx_resources);
172 return err;
173 }
174 }
175
176 return 0;
177 }
178
179 static int ensure_packet_formats(struct snd_motu *motu)
180 {
181 __be32 reg;
182 u32 data;
183 int err;
184
185 err = snd_motu_transaction_read(motu, PACKET_FORMAT_OFFSET, ®,
186 sizeof(reg));
187 if (err < 0)
188 return err;
189 data = be32_to_cpu(reg);
190
191 data &= ~(TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS |
192 RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS|
193 TX_PACKET_TRANSMISSION_SPEED_MASK);
194 if (motu->tx_packet_formats.differed_part_pcm_chunks[0] == 0)
195 data |= TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS;
196 if (motu->rx_packet_formats.differed_part_pcm_chunks[0] == 0)
197 data |= RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS;
198 data |= fw_parent_device(motu->unit)->max_speed;
199
200 reg = cpu_to_be32(data);
201 return snd_motu_transaction_write(motu, PACKET_FORMAT_OFFSET, ®,
202 sizeof(reg));
203 }
204
205 int snd_motu_stream_start_duplex(struct snd_motu *motu)
206 {
207 unsigned int generation = motu->rx_resources.generation;
208 int err = 0;
209
210 if (motu->substreams_counter == 0)
211 return 0;
212
213 if (amdtp_streaming_error(&motu->rx_stream) ||
214 amdtp_streaming_error(&motu->tx_stream)) {
215 amdtp_domain_stop(&motu->domain);
216 finish_session(motu);
217 }
218
219 if (generation != fw_parent_device(motu->unit)->card->generation) {
220 err = fw_iso_resources_update(&motu->rx_resources);
221 if (err < 0)
222 return err;
223
224 err = fw_iso_resources_update(&motu->tx_resources);
225 if (err < 0)
226 return err;
227 }
228
229 if (!amdtp_stream_running(&motu->rx_stream)) {
230 int spd = fw_parent_device(motu->unit)->max_speed;
231
232 err = ensure_packet_formats(motu);
233 if (err < 0)
234 return err;
235
236 err = begin_session(motu);
237 if (err < 0) {
238 dev_err(&motu->unit->device,
239 "fail to start isochronous comm: %d\n", err);
240 goto stop_streams;
241 }
242
243 err = amdtp_domain_add_stream(&motu->domain, &motu->tx_stream,
244 motu->tx_resources.channel, spd);
245 if (err < 0)
246 goto stop_streams;
247
248 err = amdtp_domain_add_stream(&motu->domain, &motu->rx_stream,
249 motu->rx_resources.channel, spd);
250 if (err < 0)
251 goto stop_streams;
252
253 err = amdtp_domain_start(&motu->domain);
254 if (err < 0)
255 goto stop_streams;
256
257 if (!amdtp_stream_wait_callback(&motu->tx_stream,
258 CALLBACK_TIMEOUT) ||
259 !amdtp_stream_wait_callback(&motu->rx_stream,
260 CALLBACK_TIMEOUT)) {
261 err = -ETIMEDOUT;
262 goto stop_streams;
263 }
264
265 err = motu->spec->protocol->switch_fetching_mode(motu, true);
266 if (err < 0) {
267 dev_err(&motu->unit->device,
268 "fail to enable frame fetching: %d\n", err);
269 goto stop_streams;
270 }
271 }
272
273 return 0;
274
275 stop_streams:
276 amdtp_domain_stop(&motu->domain);
277 finish_session(motu);
278 return err;
279 }
280
281 void snd_motu_stream_stop_duplex(struct snd_motu *motu)
282 {
283 if (motu->substreams_counter == 0) {
284 amdtp_domain_stop(&motu->domain);
285 finish_session(motu);
286
287 fw_iso_resources_free(&motu->tx_resources);
288 fw_iso_resources_free(&motu->rx_resources);
289 }
290 }
291
292 static int init_stream(struct snd_motu *motu, struct amdtp_stream *s)
293 {
294 struct fw_iso_resources *resources;
295 enum amdtp_stream_direction dir;
296 int err;
297
298 if (s == &motu->tx_stream) {
299 resources = &motu->tx_resources;
300 dir = AMDTP_IN_STREAM;
301 } else {
302 resources = &motu->rx_resources;
303 dir = AMDTP_OUT_STREAM;
304 }
305
306 err = fw_iso_resources_init(resources, motu->unit);
307 if (err < 0)
308 return err;
309
310 err = amdtp_motu_init(s, motu->unit, dir, motu->spec->protocol);
311 if (err < 0)
312 fw_iso_resources_destroy(resources);
313
314 return err;
315 }
316
317 static void destroy_stream(struct snd_motu *motu, struct amdtp_stream *s)
318 {
319 amdtp_stream_destroy(s);
320
321 if (s == &motu->tx_stream)
322 fw_iso_resources_destroy(&motu->tx_resources);
323 else
324 fw_iso_resources_destroy(&motu->rx_resources);
325 }
326
327 int snd_motu_stream_init_duplex(struct snd_motu *motu)
328 {
329 int err;
330
331 err = init_stream(motu, &motu->tx_stream);
332 if (err < 0)
333 return err;
334
335 err = init_stream(motu, &motu->rx_stream);
336 if (err < 0) {
337 destroy_stream(motu, &motu->tx_stream);
338 return err;
339 }
340
341 err = amdtp_domain_init(&motu->domain);
342 if (err < 0) {
343 destroy_stream(motu, &motu->tx_stream);
344 destroy_stream(motu, &motu->rx_stream);
345 }
346
347 return err;
348 }
349
350
351
352 void snd_motu_stream_destroy_duplex(struct snd_motu *motu)
353 {
354 amdtp_domain_destroy(&motu->domain);
355
356 destroy_stream(motu, &motu->rx_stream);
357 destroy_stream(motu, &motu->tx_stream);
358
359 motu->substreams_counter = 0;
360 }
361
362 static void motu_lock_changed(struct snd_motu *motu)
363 {
364 motu->dev_lock_changed = true;
365 wake_up(&motu->hwdep_wait);
366 }
367
368 int snd_motu_stream_lock_try(struct snd_motu *motu)
369 {
370 int err;
371
372 spin_lock_irq(&motu->lock);
373
374 if (motu->dev_lock_count < 0) {
375 err = -EBUSY;
376 goto out;
377 }
378
379 if (motu->dev_lock_count++ == 0)
380 motu_lock_changed(motu);
381 err = 0;
382 out:
383 spin_unlock_irq(&motu->lock);
384 return err;
385 }
386
387 void snd_motu_stream_lock_release(struct snd_motu *motu)
388 {
389 spin_lock_irq(&motu->lock);
390
391 if (WARN_ON(motu->dev_lock_count <= 0))
392 goto out;
393
394 if (--motu->dev_lock_count == 0)
395 motu_lock_changed(motu);
396 out:
397 spin_unlock_irq(&motu->lock);
398 }