1 /*
2  * dice_stream.c - a part of driver for DICE based devices
3  *
4  * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
5  * Copyright (c) 2014 Takashi Sakamoto <o-takashi@sakamocchi.jp>
6  *
7  * Licensed under the terms of the GNU General Public License, version 2.
8  */
9 
10 #include "dice.h"
11 
12 #define	CALLBACK_TIMEOUT	200
13 
14 const unsigned int snd_dice_rates[SND_DICE_RATES_COUNT] = {
15 	/* mode 0 */
16 	[0] =  32000,
17 	[1] =  44100,
18 	[2] =  48000,
19 	/* mode 1 */
20 	[3] =  88200,
21 	[4] =  96000,
22 	/* mode 2 */
23 	[5] = 176400,
24 	[6] = 192000,
25 };
26 
27 int snd_dice_stream_get_rate_mode(struct snd_dice *dice, unsigned int rate,
28 				  unsigned int *mode)
29 {
30 	int i;
31 
32 	for (i = 0; i < ARRAY_SIZE(snd_dice_rates); i++) {
33 		if (!(dice->clock_caps & BIT(i)))
34 			continue;
35 		if (snd_dice_rates[i] != rate)
36 			continue;
37 
38 		*mode = (i - 1) / 2;
39 		return 0;
40 	}
41 	return -EINVAL;
42 }
43 
44 static void release_resources(struct snd_dice *dice,
45 			      struct fw_iso_resources *resources)
46 {
47 	__be32 channel;
48 
49 	/* Reset channel number */
50 	channel = cpu_to_be32((u32)-1);
51 	if (resources == &dice->tx_resources)
52 		snd_dice_transaction_write_tx(dice, TX_ISOCHRONOUS,
53 					      &channel, sizeof(channel));
54 	else
55 		snd_dice_transaction_write_rx(dice, RX_ISOCHRONOUS,
56 					      &channel, sizeof(channel));
57 
58 	fw_iso_resources_free(resources);
59 }
60 
61 static int keep_resources(struct snd_dice *dice,
62 			  struct fw_iso_resources *resources,
63 			  unsigned int max_payload_bytes)
64 {
65 	__be32 channel;
66 	int err;
67 
68 	err = fw_iso_resources_allocate(resources, max_payload_bytes,
69 				fw_parent_device(dice->unit)->max_speed);
70 	if (err < 0)
71 		goto end;
72 
73 	/* Set channel number */
74 	channel = cpu_to_be32(resources->channel);
75 	if (resources == &dice->tx_resources)
76 		err = snd_dice_transaction_write_tx(dice, TX_ISOCHRONOUS,
77 						    &channel, sizeof(channel));
78 	else
79 		err = snd_dice_transaction_write_rx(dice, RX_ISOCHRONOUS,
80 						    &channel, sizeof(channel));
81 	if (err < 0)
82 		release_resources(dice, resources);
83 end:
84 	return err;
85 }
86 
87 static void stop_stream(struct snd_dice *dice, struct amdtp_stream *stream)
88 {
89 	amdtp_stream_pcm_abort(stream);
90 	amdtp_stream_stop(stream);
91 
92 	if (stream == &dice->tx_stream)
93 		release_resources(dice, &dice->tx_resources);
94 	else
95 		release_resources(dice, &dice->rx_resources);
96 }
97 
98 static int start_stream(struct snd_dice *dice, struct amdtp_stream *stream,
99 			unsigned int rate)
100 {
101 	struct fw_iso_resources *resources;
102 	unsigned int i, mode, pcm_chs, midi_ports;
103 	bool double_pcm_frames;
104 	int err;
105 
106 	err = snd_dice_stream_get_rate_mode(dice, rate, &mode);
107 	if (err < 0)
108 		goto end;
109 	if (stream == &dice->tx_stream) {
110 		resources = &dice->tx_resources;
111 		pcm_chs = dice->tx_channels[mode];
112 		midi_ports = dice->tx_midi_ports[mode];
113 	} else {
114 		resources = &dice->rx_resources;
115 		pcm_chs = dice->rx_channels[mode];
116 		midi_ports = dice->rx_midi_ports[mode];
117 	}
118 
119 	/*
120 	 * At 176.4/192.0 kHz, Dice has a quirk to transfer two PCM frames in
121 	 * one data block of AMDTP packet. Thus sampling transfer frequency is
122 	 * a half of PCM sampling frequency, i.e. PCM frames at 192.0 kHz are
123 	 * transferred on AMDTP packets at 96 kHz. Two successive samples of a
124 	 * channel are stored consecutively in the packet. This quirk is called
125 	 * as 'Dual Wire'.
126 	 * For this quirk, blocking mode is required and PCM buffer size should
127 	 * be aligned to SYT_INTERVAL.
128 	 */
129 	double_pcm_frames = mode > 1;
130 	if (double_pcm_frames) {
131 		rate /= 2;
132 		pcm_chs *= 2;
133 	}
134 
135 	err = amdtp_am824_set_parameters(stream, rate, pcm_chs, midi_ports,
136 					 double_pcm_frames);
137 	if (err < 0)
138 		goto end;
139 
140 	if (double_pcm_frames) {
141 		pcm_chs /= 2;
142 
143 		for (i = 0; i < pcm_chs; i++) {
144 			amdtp_am824_set_pcm_position(stream, i, i * 2);
145 			amdtp_am824_set_pcm_position(stream, i + pcm_chs,
146 						     i * 2 + 1);
147 		}
148 	}
149 
150 	err = keep_resources(dice, resources,
151 			     amdtp_stream_get_max_payload(stream));
152 	if (err < 0) {
153 		dev_err(&dice->unit->device,
154 			"fail to keep isochronous resources\n");
155 		goto end;
156 	}
157 
158 	err = amdtp_stream_start(stream, resources->channel,
159 				 fw_parent_device(dice->unit)->max_speed);
160 	if (err < 0)
161 		release_resources(dice, resources);
162 end:
163 	return err;
164 }
165 
166 static int get_sync_mode(struct snd_dice *dice, enum cip_flags *sync_mode)
167 {
168 	u32 source;
169 	int err;
170 
171 	err = snd_dice_transaction_get_clock_source(dice, &source);
172 	if (err < 0)
173 		goto end;
174 
175 	switch (source) {
176 	/* So-called 'SYT Match' modes, sync_to_syt value of packets received */
177 	case CLOCK_SOURCE_ARX4:	/* in 4th stream */
178 	case CLOCK_SOURCE_ARX3:	/* in 3rd stream */
179 	case CLOCK_SOURCE_ARX2:	/* in 2nd stream */
180 		err = -ENOSYS;
181 		break;
182 	case CLOCK_SOURCE_ARX1:	/* in 1st stream, which this driver uses */
183 		*sync_mode = 0;
184 		break;
185 	default:
186 		*sync_mode = CIP_SYNC_TO_DEVICE;
187 		break;
188 	}
189 end:
190 	return err;
191 }
192 
193 int snd_dice_stream_start_duplex(struct snd_dice *dice, unsigned int rate)
194 {
195 	struct amdtp_stream *master, *slave;
196 	unsigned int curr_rate;
197 	enum cip_flags sync_mode;
198 	int err = 0;
199 
200 	if (dice->substreams_counter == 0)
201 		goto end;
202 
203 	err = get_sync_mode(dice, &sync_mode);
204 	if (err < 0)
205 		goto end;
206 	if (sync_mode == CIP_SYNC_TO_DEVICE) {
207 		master = &dice->tx_stream;
208 		slave  = &dice->rx_stream;
209 	} else {
210 		master = &dice->rx_stream;
211 		slave  = &dice->tx_stream;
212 	}
213 
214 	/* Some packet queueing errors. */
215 	if (amdtp_streaming_error(master) || amdtp_streaming_error(slave))
216 		stop_stream(dice, master);
217 
218 	/* Stop stream if rate is different. */
219 	err = snd_dice_transaction_get_rate(dice, &curr_rate);
220 	if (err < 0) {
221 		dev_err(&dice->unit->device,
222 			"fail to get sampling rate\n");
223 		goto end;
224 	}
225 	if (rate == 0)
226 		rate = curr_rate;
227 	if (rate != curr_rate)
228 		stop_stream(dice, master);
229 
230 	if (!amdtp_stream_running(master)) {
231 		stop_stream(dice, slave);
232 		snd_dice_transaction_clear_enable(dice);
233 
234 		amdtp_stream_set_sync(sync_mode, master, slave);
235 
236 		err = snd_dice_transaction_set_rate(dice, rate);
237 		if (err < 0) {
238 			dev_err(&dice->unit->device,
239 				"fail to set sampling rate\n");
240 			goto end;
241 		}
242 
243 		/* Start both streams. */
244 		err = start_stream(dice, master, rate);
245 		if (err < 0) {
246 			dev_err(&dice->unit->device,
247 				"fail to start AMDTP master stream\n");
248 			goto end;
249 		}
250 		err = start_stream(dice, slave, rate);
251 		if (err < 0) {
252 			dev_err(&dice->unit->device,
253 				"fail to start AMDTP slave stream\n");
254 			stop_stream(dice, master);
255 			goto end;
256 		}
257 		err = snd_dice_transaction_set_enable(dice);
258 		if (err < 0) {
259 			dev_err(&dice->unit->device,
260 				"fail to enable interface\n");
261 			stop_stream(dice, master);
262 			stop_stream(dice, slave);
263 			goto end;
264 		}
265 
266 		/* Wait first callbacks */
267 		if (!amdtp_stream_wait_callback(master, CALLBACK_TIMEOUT) ||
268 		    !amdtp_stream_wait_callback(slave, CALLBACK_TIMEOUT)) {
269 			snd_dice_transaction_clear_enable(dice);
270 			stop_stream(dice, master);
271 			stop_stream(dice, slave);
272 			err = -ETIMEDOUT;
273 		}
274 	}
275 end:
276 	return err;
277 }
278 
279 void snd_dice_stream_stop_duplex(struct snd_dice *dice)
280 {
281 	if (dice->substreams_counter > 0)
282 		return;
283 
284 	snd_dice_transaction_clear_enable(dice);
285 
286 	stop_stream(dice, &dice->tx_stream);
287 	stop_stream(dice, &dice->rx_stream);
288 }
289 
290 static int init_stream(struct snd_dice *dice, struct amdtp_stream *stream)
291 {
292 	int err;
293 	struct fw_iso_resources *resources;
294 	enum amdtp_stream_direction dir;
295 
296 	if (stream == &dice->tx_stream) {
297 		resources = &dice->tx_resources;
298 		dir = AMDTP_IN_STREAM;
299 	} else {
300 		resources = &dice->rx_resources;
301 		dir = AMDTP_OUT_STREAM;
302 	}
303 
304 	err = fw_iso_resources_init(resources, dice->unit);
305 	if (err < 0)
306 		goto end;
307 	resources->channels_mask = 0x00000000ffffffffuLL;
308 
309 	err = amdtp_am824_init(stream, dice->unit, dir, CIP_BLOCKING);
310 	if (err < 0) {
311 		amdtp_stream_destroy(stream);
312 		fw_iso_resources_destroy(resources);
313 	}
314 end:
315 	return err;
316 }
317 
318 /*
319  * This function should be called before starting streams or after stopping
320  * streams.
321  */
322 static void destroy_stream(struct snd_dice *dice, struct amdtp_stream *stream)
323 {
324 	struct fw_iso_resources *resources;
325 
326 	if (stream == &dice->tx_stream)
327 		resources = &dice->tx_resources;
328 	else
329 		resources = &dice->rx_resources;
330 
331 	amdtp_stream_destroy(stream);
332 	fw_iso_resources_destroy(resources);
333 }
334 
335 int snd_dice_stream_init_duplex(struct snd_dice *dice)
336 {
337 	int err;
338 
339 	dice->substreams_counter = 0;
340 
341 	err = init_stream(dice, &dice->tx_stream);
342 	if (err < 0)
343 		goto end;
344 
345 	err = init_stream(dice, &dice->rx_stream);
346 	if (err < 0)
347 		destroy_stream(dice, &dice->tx_stream);
348 end:
349 	return err;
350 }
351 
352 void snd_dice_stream_destroy_duplex(struct snd_dice *dice)
353 {
354 	snd_dice_transaction_clear_enable(dice);
355 
356 	destroy_stream(dice, &dice->tx_stream);
357 	destroy_stream(dice, &dice->rx_stream);
358 
359 	dice->substreams_counter = 0;
360 }
361 
362 void snd_dice_stream_update_duplex(struct snd_dice *dice)
363 {
364 	/*
365 	 * On a bus reset, the DICE firmware disables streaming and then goes
366 	 * off contemplating its own navel for hundreds of milliseconds before
367 	 * it can react to any of our attempts to reenable streaming.  This
368 	 * means that we lose synchronization anyway, so we force our streams
369 	 * to stop so that the application can restart them in an orderly
370 	 * manner.
371 	 */
372 	dice->global_enabled = false;
373 
374 	stop_stream(dice, &dice->rx_stream);
375 	stop_stream(dice, &dice->tx_stream);
376 
377 	fw_iso_resources_update(&dice->rx_resources);
378 	fw_iso_resources_update(&dice->tx_resources);
379 }
380 
381 static void dice_lock_changed(struct snd_dice *dice)
382 {
383 	dice->dev_lock_changed = true;
384 	wake_up(&dice->hwdep_wait);
385 }
386 
387 int snd_dice_stream_lock_try(struct snd_dice *dice)
388 {
389 	int err;
390 
391 	spin_lock_irq(&dice->lock);
392 
393 	if (dice->dev_lock_count < 0) {
394 		err = -EBUSY;
395 		goto out;
396 	}
397 
398 	if (dice->dev_lock_count++ == 0)
399 		dice_lock_changed(dice);
400 	err = 0;
401 out:
402 	spin_unlock_irq(&dice->lock);
403 	return err;
404 }
405 
406 void snd_dice_stream_lock_release(struct snd_dice *dice)
407 {
408 	spin_lock_irq(&dice->lock);
409 
410 	if (WARN_ON(dice->dev_lock_count <= 0))
411 		goto out;
412 
413 	if (--dice->dev_lock_count == 0)
414 		dice_lock_changed(dice);
415 out:
416 	spin_unlock_irq(&dice->lock);
417 }
418