1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * oxfw_stream.c - a part of driver for OXFW970/971 based devices
4  *
5  * Copyright (c) 2014 Takashi Sakamoto
6  */
7 
8 #include "oxfw.h"
9 #include <linux/delay.h>
10 
11 #define AVC_GENERIC_FRAME_MAXIMUM_BYTES	512
12 #define CALLBACK_TIMEOUT	200
13 
14 /*
15  * According to datasheet of Oxford Semiconductor:
16  *  OXFW970: 32.0/44.1/48.0/96.0 Khz, 8 audio channels I/O
17  *  OXFW971: 32.0/44.1/48.0/88.2/96.0/192.0 kHz, 16 audio channels I/O, MIDI I/O
18  */
19 static const unsigned int oxfw_rate_table[] = {
20 	[0] = 32000,
21 	[1] = 44100,
22 	[2] = 48000,
23 	[3] = 88200,
24 	[4] = 96000,
25 	[5] = 192000,
26 };
27 
28 /*
29  * See Table 5.7 – Sampling frequency for Multi-bit Audio
30  * in AV/C Stream Format Information Specification 1.1 (Apr 2005, 1394TA)
31  */
32 static const unsigned int avc_stream_rate_table[] = {
33 	[0] = 0x02,
34 	[1] = 0x03,
35 	[2] = 0x04,
36 	[3] = 0x0a,
37 	[4] = 0x05,
38 	[5] = 0x07,
39 };
40 
41 static int set_rate(struct snd_oxfw *oxfw, unsigned int rate)
42 {
43 	int err;
44 
45 	err = avc_general_set_sig_fmt(oxfw->unit, rate,
46 				      AVC_GENERAL_PLUG_DIR_IN, 0);
47 	if (err < 0)
48 		goto end;
49 
50 	if (oxfw->has_output)
51 		err = avc_general_set_sig_fmt(oxfw->unit, rate,
52 					      AVC_GENERAL_PLUG_DIR_OUT, 0);
53 end:
54 	return err;
55 }
56 
57 static int set_stream_format(struct snd_oxfw *oxfw, struct amdtp_stream *s,
58 			     unsigned int rate, unsigned int pcm_channels)
59 {
60 	u8 **formats;
61 	struct snd_oxfw_stream_formation formation;
62 	enum avc_general_plug_dir dir;
63 	unsigned int len;
64 	int i, err;
65 
66 	if (s == &oxfw->tx_stream) {
67 		formats = oxfw->tx_stream_formats;
68 		dir = AVC_GENERAL_PLUG_DIR_OUT;
69 	} else {
70 		formats = oxfw->rx_stream_formats;
71 		dir = AVC_GENERAL_PLUG_DIR_IN;
72 	}
73 
74 	/* Seek stream format for requirements. */
75 	for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
76 		err = snd_oxfw_stream_parse_format(formats[i], &formation);
77 		if (err < 0)
78 			return err;
79 
80 		if ((formation.rate == rate) && (formation.pcm == pcm_channels))
81 			break;
82 	}
83 	if (i == SND_OXFW_STREAM_FORMAT_ENTRIES)
84 		return -EINVAL;
85 
86 	/* If assumed, just change rate. */
87 	if (oxfw->assumed)
88 		return set_rate(oxfw, rate);
89 
90 	/* Calculate format length. */
91 	len = 5 + formats[i][4] * 2;
92 
93 	err = avc_stream_set_format(oxfw->unit, dir, 0, formats[i], len);
94 	if (err < 0)
95 		return err;
96 
97 	/* Some requests just after changing format causes freezing. */
98 	msleep(100);
99 
100 	return 0;
101 }
102 
103 static void stop_stream(struct snd_oxfw *oxfw, struct amdtp_stream *stream)
104 {
105 	amdtp_stream_pcm_abort(stream);
106 	amdtp_stream_stop(stream);
107 
108 	if (stream == &oxfw->tx_stream)
109 		cmp_connection_break(&oxfw->out_conn);
110 	else
111 		cmp_connection_break(&oxfw->in_conn);
112 }
113 
114 static int start_stream(struct snd_oxfw *oxfw, struct amdtp_stream *stream,
115 			unsigned int rate, unsigned int pcm_channels)
116 {
117 	u8 **formats;
118 	struct cmp_connection *conn;
119 	struct snd_oxfw_stream_formation formation;
120 	unsigned int i, midi_ports;
121 	int err;
122 
123 	if (stream == &oxfw->rx_stream) {
124 		formats = oxfw->rx_stream_formats;
125 		conn = &oxfw->in_conn;
126 	} else {
127 		formats = oxfw->tx_stream_formats;
128 		conn = &oxfw->out_conn;
129 	}
130 
131 	/* Get stream format */
132 	for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
133 		if (formats[i] == NULL)
134 			break;
135 
136 		err = snd_oxfw_stream_parse_format(formats[i], &formation);
137 		if (err < 0)
138 			goto end;
139 		if (rate != formation.rate)
140 			continue;
141 		if (pcm_channels == 0 ||  pcm_channels == formation.pcm)
142 			break;
143 	}
144 	if (i == SND_OXFW_STREAM_FORMAT_ENTRIES) {
145 		err = -EINVAL;
146 		goto end;
147 	}
148 
149 	pcm_channels = formation.pcm;
150 	midi_ports = formation.midi * 8;
151 
152 	/* The stream should have one pcm channels at least */
153 	if (pcm_channels == 0) {
154 		err = -EINVAL;
155 		goto end;
156 	}
157 	err = amdtp_am824_set_parameters(stream, rate, pcm_channels, midi_ports,
158 					 false);
159 	if (err < 0)
160 		goto end;
161 
162 	err = cmp_connection_establish(conn,
163 				       amdtp_stream_get_max_payload(stream));
164 	if (err < 0)
165 		goto end;
166 
167 	err = amdtp_stream_start(stream,
168 				 conn->resources.channel,
169 				 conn->speed);
170 	if (err < 0) {
171 		cmp_connection_break(conn);
172 		goto end;
173 	}
174 
175 	/* Wait first packet */
176 	if (!amdtp_stream_wait_callback(stream, CALLBACK_TIMEOUT)) {
177 		stop_stream(oxfw, stream);
178 		err = -ETIMEDOUT;
179 	}
180 end:
181 	return err;
182 }
183 
184 static int check_connection_used_by_others(struct snd_oxfw *oxfw,
185 					   struct amdtp_stream *stream)
186 {
187 	struct cmp_connection *conn;
188 	bool used;
189 	int err;
190 
191 	if (stream == &oxfw->tx_stream)
192 		conn = &oxfw->out_conn;
193 	else
194 		conn = &oxfw->in_conn;
195 
196 	err = cmp_connection_check_used(conn, &used);
197 	if ((err >= 0) && used && !amdtp_stream_running(stream)) {
198 		dev_err(&oxfw->unit->device,
199 			"Connection established by others: %cPCR[%d]\n",
200 			(conn->direction == CMP_OUTPUT) ? 'o' : 'i',
201 			conn->pcr_index);
202 		err = -EBUSY;
203 	}
204 
205 	return err;
206 }
207 
208 int snd_oxfw_stream_init_simplex(struct snd_oxfw *oxfw,
209 				 struct amdtp_stream *stream)
210 {
211 	struct cmp_connection *conn;
212 	enum cmp_direction c_dir;
213 	enum amdtp_stream_direction s_dir;
214 	int err;
215 
216 	if (stream == &oxfw->tx_stream) {
217 		conn = &oxfw->out_conn;
218 		c_dir = CMP_OUTPUT;
219 		s_dir = AMDTP_IN_STREAM;
220 	} else {
221 		conn = &oxfw->in_conn;
222 		c_dir = CMP_INPUT;
223 		s_dir = AMDTP_OUT_STREAM;
224 	}
225 
226 	err = cmp_connection_init(conn, oxfw->unit, c_dir, 0);
227 	if (err < 0)
228 		goto end;
229 
230 	err = amdtp_am824_init(stream, oxfw->unit, s_dir, CIP_NONBLOCKING);
231 	if (err < 0) {
232 		amdtp_stream_destroy(stream);
233 		cmp_connection_destroy(conn);
234 		goto end;
235 	}
236 
237 	/*
238 	 * OXFW starts to transmit packets with non-zero dbc.
239 	 * OXFW postpone transferring packets till handling any asynchronous
240 	 * packets. As a result, next isochronous packet includes more data
241 	 * blocks than IEC 61883-6 defines.
242 	 */
243 	if (stream == &oxfw->tx_stream) {
244 		oxfw->tx_stream.flags |= CIP_JUMBO_PAYLOAD;
245 		if (oxfw->wrong_dbs)
246 			oxfw->tx_stream.flags |= CIP_WRONG_DBS;
247 	}
248 end:
249 	return err;
250 }
251 
252 int snd_oxfw_stream_start_simplex(struct snd_oxfw *oxfw,
253 				  struct amdtp_stream *stream,
254 				  unsigned int rate, unsigned int pcm_channels)
255 {
256 	struct amdtp_stream *opposite;
257 	struct snd_oxfw_stream_formation formation;
258 	enum avc_general_plug_dir dir;
259 	unsigned int substreams, opposite_substreams;
260 	int err = 0;
261 
262 	if (stream == &oxfw->tx_stream) {
263 		substreams = oxfw->capture_substreams;
264 		opposite = &oxfw->rx_stream;
265 		opposite_substreams = oxfw->playback_substreams;
266 		dir = AVC_GENERAL_PLUG_DIR_OUT;
267 	} else {
268 		substreams = oxfw->playback_substreams;
269 		opposite_substreams = oxfw->capture_substreams;
270 
271 		if (oxfw->has_output)
272 			opposite = &oxfw->rx_stream;
273 		else
274 			opposite = NULL;
275 
276 		dir = AVC_GENERAL_PLUG_DIR_IN;
277 	}
278 
279 	if (substreams == 0)
280 		goto end;
281 
282 	/*
283 	 * Considering JACK/FFADO streaming:
284 	 * TODO: This can be removed hwdep functionality becomes popular.
285 	 */
286 	err = check_connection_used_by_others(oxfw, stream);
287 	if (err < 0)
288 		goto end;
289 
290 	/* packet queueing error */
291 	if (amdtp_streaming_error(stream))
292 		stop_stream(oxfw, stream);
293 
294 	err = snd_oxfw_stream_get_current_formation(oxfw, dir, &formation);
295 	if (err < 0)
296 		goto end;
297 	if (rate == 0)
298 		rate = formation.rate;
299 	if (pcm_channels == 0)
300 		pcm_channels = formation.pcm;
301 
302 	if ((formation.rate != rate) || (formation.pcm != pcm_channels)) {
303 		if (opposite != NULL) {
304 			err = check_connection_used_by_others(oxfw, opposite);
305 			if (err < 0)
306 				goto end;
307 			stop_stream(oxfw, opposite);
308 		}
309 		stop_stream(oxfw, stream);
310 
311 		err = set_stream_format(oxfw, stream, rate, pcm_channels);
312 		if (err < 0) {
313 			dev_err(&oxfw->unit->device,
314 				"fail to set stream format: %d\n", err);
315 			goto end;
316 		}
317 
318 		/* Start opposite stream if needed. */
319 		if (opposite && !amdtp_stream_running(opposite) &&
320 		    (opposite_substreams > 0)) {
321 			err = start_stream(oxfw, opposite, rate, 0);
322 			if (err < 0) {
323 				dev_err(&oxfw->unit->device,
324 					"fail to restart stream: %d\n", err);
325 				goto end;
326 			}
327 		}
328 	}
329 
330 	/* Start requested stream. */
331 	if (!amdtp_stream_running(stream)) {
332 		err = start_stream(oxfw, stream, rate, pcm_channels);
333 		if (err < 0)
334 			dev_err(&oxfw->unit->device,
335 				"fail to start stream: %d\n", err);
336 	}
337 end:
338 	return err;
339 }
340 
341 void snd_oxfw_stream_stop_simplex(struct snd_oxfw *oxfw,
342 				  struct amdtp_stream *stream)
343 {
344 	if (((stream == &oxfw->tx_stream) && (oxfw->capture_substreams > 0)) ||
345 	    ((stream == &oxfw->rx_stream) && (oxfw->playback_substreams > 0)))
346 		return;
347 
348 	stop_stream(oxfw, stream);
349 }
350 
351 /*
352  * This function should be called before starting the stream or after stopping
353  * the streams.
354  */
355 void snd_oxfw_stream_destroy_simplex(struct snd_oxfw *oxfw,
356 				     struct amdtp_stream *stream)
357 {
358 	struct cmp_connection *conn;
359 
360 	if (stream == &oxfw->tx_stream)
361 		conn = &oxfw->out_conn;
362 	else
363 		conn = &oxfw->in_conn;
364 
365 	amdtp_stream_destroy(stream);
366 	cmp_connection_destroy(conn);
367 }
368 
369 void snd_oxfw_stream_update_simplex(struct snd_oxfw *oxfw,
370 				    struct amdtp_stream *stream)
371 {
372 	struct cmp_connection *conn;
373 
374 	if (stream == &oxfw->tx_stream)
375 		conn = &oxfw->out_conn;
376 	else
377 		conn = &oxfw->in_conn;
378 
379 	if (cmp_connection_update(conn) < 0)
380 		stop_stream(oxfw, stream);
381 	else
382 		amdtp_stream_update(stream);
383 }
384 
385 int snd_oxfw_stream_get_current_formation(struct snd_oxfw *oxfw,
386 				enum avc_general_plug_dir dir,
387 				struct snd_oxfw_stream_formation *formation)
388 {
389 	u8 *format;
390 	unsigned int len;
391 	int err;
392 
393 	len = AVC_GENERIC_FRAME_MAXIMUM_BYTES;
394 	format = kmalloc(len, GFP_KERNEL);
395 	if (format == NULL)
396 		return -ENOMEM;
397 
398 	err = avc_stream_get_format_single(oxfw->unit, dir, 0, format, &len);
399 	if (err < 0)
400 		goto end;
401 	if (len < 3) {
402 		err = -EIO;
403 		goto end;
404 	}
405 
406 	err = snd_oxfw_stream_parse_format(format, formation);
407 end:
408 	kfree(format);
409 	return err;
410 }
411 
412 /*
413  * See Table 6.16 - AM824 Stream Format
414  *     Figure 6.19 - format_information field for AM824 Compound
415  * in AV/C Stream Format Information Specification 1.1 (Apr 2005, 1394TA)
416  * Also 'Clause 12 AM824 sequence adaption layers' in IEC 61883-6:2005
417  */
418 int snd_oxfw_stream_parse_format(u8 *format,
419 				 struct snd_oxfw_stream_formation *formation)
420 {
421 	unsigned int i, e, channels, type;
422 
423 	memset(formation, 0, sizeof(struct snd_oxfw_stream_formation));
424 
425 	/*
426 	 * this module can support a hierarchy combination that:
427 	 *  Root:	Audio and Music (0x90)
428 	 *  Level 1:	AM824 Compound  (0x40)
429 	 */
430 	if ((format[0] != 0x90) || (format[1] != 0x40))
431 		return -ENOSYS;
432 
433 	/* check the sampling rate */
434 	for (i = 0; i < ARRAY_SIZE(avc_stream_rate_table); i++) {
435 		if (format[2] == avc_stream_rate_table[i])
436 			break;
437 	}
438 	if (i == ARRAY_SIZE(avc_stream_rate_table))
439 		return -ENOSYS;
440 
441 	formation->rate = oxfw_rate_table[i];
442 
443 	for (e = 0; e < format[4]; e++) {
444 		channels = format[5 + e * 2];
445 		type = format[6 + e * 2];
446 
447 		switch (type) {
448 		/* IEC 60958 Conformant, currently handled as MBLA */
449 		case 0x00:
450 		/* Multi Bit Linear Audio (Raw) */
451 		case 0x06:
452 			formation->pcm += channels;
453 			break;
454 		/* MIDI Conformant */
455 		case 0x0d:
456 			formation->midi = channels;
457 			break;
458 		/* IEC 61937-3 to 7 */
459 		case 0x01:
460 		case 0x02:
461 		case 0x03:
462 		case 0x04:
463 		case 0x05:
464 		/* Multi Bit Linear Audio */
465 		case 0x07:	/* DVD-Audio */
466 		case 0x0c:	/* High Precision */
467 		/* One Bit Audio */
468 		case 0x08:	/* (Plain) Raw */
469 		case 0x09:	/* (Plain) SACD */
470 		case 0x0a:	/* (Encoded) Raw */
471 		case 0x0b:	/* (Encoded) SACD */
472 		/* SMPTE Time-Code conformant */
473 		case 0x0e:
474 		/* Sample Count */
475 		case 0x0f:
476 		/* Anciliary Data */
477 		case 0x10:
478 		/* Synchronization Stream (Stereo Raw audio) */
479 		case 0x40:
480 		/* Don't care */
481 		case 0xff:
482 		default:
483 			return -ENOSYS;	/* not supported */
484 		}
485 	}
486 
487 	if (formation->pcm  > AM824_MAX_CHANNELS_FOR_PCM ||
488 	    formation->midi > AM824_MAX_CHANNELS_FOR_MIDI)
489 		return -ENOSYS;
490 
491 	return 0;
492 }
493 
494 static int
495 assume_stream_formats(struct snd_oxfw *oxfw, enum avc_general_plug_dir dir,
496 		      unsigned int pid, u8 *buf, unsigned int *len,
497 		      u8 **formats)
498 {
499 	struct snd_oxfw_stream_formation formation;
500 	unsigned int i, eid;
501 	int err;
502 
503 	/* get format at current sampling rate */
504 	err = avc_stream_get_format_single(oxfw->unit, dir, pid, buf, len);
505 	if (err < 0) {
506 		dev_err(&oxfw->unit->device,
507 		"fail to get current stream format for isoc %s plug %d:%d\n",
508 			(dir == AVC_GENERAL_PLUG_DIR_IN) ? "in" : "out",
509 			pid, err);
510 		goto end;
511 	}
512 
513 	/* parse and set stream format */
514 	eid = 0;
515 	err = snd_oxfw_stream_parse_format(buf, &formation);
516 	if (err < 0)
517 		goto end;
518 
519 	formats[eid] = devm_kmemdup(&oxfw->card->card_dev, buf, *len,
520 				    GFP_KERNEL);
521 	if (!formats[eid]) {
522 		err = -ENOMEM;
523 		goto end;
524 	}
525 
526 	/* apply the format for each available sampling rate */
527 	for (i = 0; i < ARRAY_SIZE(oxfw_rate_table); i++) {
528 		if (formation.rate == oxfw_rate_table[i])
529 			continue;
530 
531 		err = avc_general_inquiry_sig_fmt(oxfw->unit,
532 						  oxfw_rate_table[i],
533 						  dir, pid);
534 		if (err < 0)
535 			continue;
536 
537 		eid++;
538 		formats[eid] = devm_kmemdup(&oxfw->card->card_dev, buf, *len,
539 					    GFP_KERNEL);
540 		if (formats[eid] == NULL) {
541 			err = -ENOMEM;
542 			goto end;
543 		}
544 		formats[eid][2] = avc_stream_rate_table[i];
545 	}
546 
547 	err = 0;
548 	oxfw->assumed = true;
549 end:
550 	return err;
551 }
552 
553 static int fill_stream_formats(struct snd_oxfw *oxfw,
554 			       enum avc_general_plug_dir dir,
555 			       unsigned short pid)
556 {
557 	u8 *buf, **formats;
558 	unsigned int len, eid = 0;
559 	struct snd_oxfw_stream_formation dummy;
560 	int err;
561 
562 	buf = kmalloc(AVC_GENERIC_FRAME_MAXIMUM_BYTES, GFP_KERNEL);
563 	if (buf == NULL)
564 		return -ENOMEM;
565 
566 	if (dir == AVC_GENERAL_PLUG_DIR_OUT)
567 		formats = oxfw->tx_stream_formats;
568 	else
569 		formats = oxfw->rx_stream_formats;
570 
571 	/* get first entry */
572 	len = AVC_GENERIC_FRAME_MAXIMUM_BYTES;
573 	err = avc_stream_get_format_list(oxfw->unit, dir, 0, buf, &len, 0);
574 	if (err == -ENOSYS) {
575 		/* LIST subfunction is not implemented */
576 		len = AVC_GENERIC_FRAME_MAXIMUM_BYTES;
577 		err = assume_stream_formats(oxfw, dir, pid, buf, &len,
578 					    formats);
579 		goto end;
580 	} else if (err < 0) {
581 		dev_err(&oxfw->unit->device,
582 			"fail to get stream format %d for isoc %s plug %d:%d\n",
583 			eid, (dir == AVC_GENERAL_PLUG_DIR_IN) ? "in" : "out",
584 			pid, err);
585 		goto end;
586 	}
587 
588 	/* LIST subfunction is implemented */
589 	while (eid < SND_OXFW_STREAM_FORMAT_ENTRIES) {
590 		/* The format is too short. */
591 		if (len < 3) {
592 			err = -EIO;
593 			break;
594 		}
595 
596 		/* parse and set stream format */
597 		err = snd_oxfw_stream_parse_format(buf, &dummy);
598 		if (err < 0)
599 			break;
600 
601 		formats[eid] = devm_kmemdup(&oxfw->card->card_dev, buf, len,
602 					    GFP_KERNEL);
603 		if (!formats[eid]) {
604 			err = -ENOMEM;
605 			break;
606 		}
607 
608 		/* get next entry */
609 		len = AVC_GENERIC_FRAME_MAXIMUM_BYTES;
610 		err = avc_stream_get_format_list(oxfw->unit, dir, 0,
611 						 buf, &len, ++eid);
612 		/* No entries remained. */
613 		if (err == -EINVAL) {
614 			err = 0;
615 			break;
616 		} else if (err < 0) {
617 			dev_err(&oxfw->unit->device,
618 			"fail to get stream format %d for isoc %s plug %d:%d\n",
619 				eid, (dir == AVC_GENERAL_PLUG_DIR_IN) ? "in" :
620 									"out",
621 				pid, err);
622 			break;
623 		}
624 	}
625 end:
626 	kfree(buf);
627 	return err;
628 }
629 
630 int snd_oxfw_stream_discover(struct snd_oxfw *oxfw)
631 {
632 	u8 plugs[AVC_PLUG_INFO_BUF_BYTES];
633 	struct snd_oxfw_stream_formation formation;
634 	u8 *format;
635 	unsigned int i;
636 	int err;
637 
638 	/* the number of plugs for isoc in/out, ext in/out  */
639 	err = avc_general_get_plug_info(oxfw->unit, 0x1f, 0x07, 0x00, plugs);
640 	if (err < 0) {
641 		dev_err(&oxfw->unit->device,
642 		"fail to get info for isoc/external in/out plugs: %d\n",
643 			err);
644 		goto end;
645 	} else if ((plugs[0] == 0) && (plugs[1] == 0)) {
646 		err = -ENOSYS;
647 		goto end;
648 	}
649 
650 	/* use oPCR[0] if exists */
651 	if (plugs[1] > 0) {
652 		err = fill_stream_formats(oxfw, AVC_GENERAL_PLUG_DIR_OUT, 0);
653 		if (err < 0)
654 			goto end;
655 
656 		for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
657 			format = oxfw->tx_stream_formats[i];
658 			if (format == NULL)
659 				continue;
660 			err = snd_oxfw_stream_parse_format(format, &formation);
661 			if (err < 0)
662 				continue;
663 
664 			/* Add one MIDI port. */
665 			if (formation.midi > 0)
666 				oxfw->midi_input_ports = 1;
667 		}
668 
669 		oxfw->has_output = true;
670 	}
671 
672 	/* use iPCR[0] if exists */
673 	if (plugs[0] > 0) {
674 		err = fill_stream_formats(oxfw, AVC_GENERAL_PLUG_DIR_IN, 0);
675 		if (err < 0)
676 			goto end;
677 
678 		for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
679 			format = oxfw->rx_stream_formats[i];
680 			if (format == NULL)
681 				continue;
682 			err = snd_oxfw_stream_parse_format(format, &formation);
683 			if (err < 0)
684 				continue;
685 
686 			/* Add one MIDI port. */
687 			if (formation.midi > 0)
688 				oxfw->midi_output_ports = 1;
689 		}
690 	}
691 end:
692 	return err;
693 }
694 
695 void snd_oxfw_stream_lock_changed(struct snd_oxfw *oxfw)
696 {
697 	oxfw->dev_lock_changed = true;
698 	wake_up(&oxfw->hwdep_wait);
699 }
700 
701 int snd_oxfw_stream_lock_try(struct snd_oxfw *oxfw)
702 {
703 	int err;
704 
705 	spin_lock_irq(&oxfw->lock);
706 
707 	/* user land lock this */
708 	if (oxfw->dev_lock_count < 0) {
709 		err = -EBUSY;
710 		goto end;
711 	}
712 
713 	/* this is the first time */
714 	if (oxfw->dev_lock_count++ == 0)
715 		snd_oxfw_stream_lock_changed(oxfw);
716 	err = 0;
717 end:
718 	spin_unlock_irq(&oxfw->lock);
719 	return err;
720 }
721 
722 void snd_oxfw_stream_lock_release(struct snd_oxfw *oxfw)
723 {
724 	spin_lock_irq(&oxfw->lock);
725 
726 	if (WARN_ON(oxfw->dev_lock_count <= 0))
727 		goto end;
728 	if (--oxfw->dev_lock_count == 0)
729 		snd_oxfw_stream_lock_changed(oxfw);
730 end:
731 	spin_unlock_irq(&oxfw->lock);
732 }
733