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 READY_TIMEOUT_MS	600
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 int start_stream(struct snd_oxfw *oxfw, struct amdtp_stream *stream)
104 {
105 	struct cmp_connection *conn;
106 	int err;
107 
108 	if (stream == &oxfw->rx_stream)
109 		conn = &oxfw->in_conn;
110 	else
111 		conn = &oxfw->out_conn;
112 
113 	err = cmp_connection_establish(conn);
114 	if (err < 0)
115 		return err;
116 
117 	err = amdtp_domain_add_stream(&oxfw->domain, stream,
118 				      conn->resources.channel, conn->speed);
119 	if (err < 0) {
120 		cmp_connection_break(conn);
121 		return err;
122 	}
123 
124 	return 0;
125 }
126 
127 static int check_connection_used_by_others(struct snd_oxfw *oxfw,
128 					   struct amdtp_stream *stream)
129 {
130 	struct cmp_connection *conn;
131 	bool used;
132 	int err;
133 
134 	if (stream == &oxfw->tx_stream)
135 		conn = &oxfw->out_conn;
136 	else
137 		conn = &oxfw->in_conn;
138 
139 	err = cmp_connection_check_used(conn, &used);
140 	if ((err >= 0) && used && !amdtp_stream_running(stream)) {
141 		dev_err(&oxfw->unit->device,
142 			"Connection established by others: %cPCR[%d]\n",
143 			(conn->direction == CMP_OUTPUT) ? 'o' : 'i',
144 			conn->pcr_index);
145 		err = -EBUSY;
146 	}
147 
148 	return err;
149 }
150 
151 static int init_stream(struct snd_oxfw *oxfw, struct amdtp_stream *stream)
152 {
153 	struct cmp_connection *conn;
154 	enum cmp_direction c_dir;
155 	enum amdtp_stream_direction s_dir;
156 	unsigned int flags = 0;
157 	int err;
158 
159 	if (!(oxfw->quirks & SND_OXFW_QUIRK_BLOCKING_TRANSMISSION))
160 		flags |= CIP_NONBLOCKING;
161 	else
162 		flags |= CIP_BLOCKING;
163 
164 	// OXFW 970/971 has no function to generate playback timing according to the sequence
165 	// of value in syt field, thus the packet should include NO_INFO value in the field.
166 	// However, some models just ignore data blocks in packet with NO_INFO for audio data
167 	// processing.
168 	if (!(oxfw->quirks & SND_OXFW_QUIRK_IGNORE_NO_INFO_PACKET))
169 		flags |= CIP_UNAWARE_SYT;
170 
171 	if (stream == &oxfw->tx_stream) {
172 		conn = &oxfw->out_conn;
173 		c_dir = CMP_OUTPUT;
174 		s_dir = AMDTP_IN_STREAM;
175 
176 		if (oxfw->quirks & SND_OXFW_QUIRK_JUMBO_PAYLOAD)
177 			flags |= CIP_JUMBO_PAYLOAD;
178 		if (oxfw->quirks & SND_OXFW_QUIRK_WRONG_DBS)
179 			flags |= CIP_WRONG_DBS;
180 	} else {
181 		conn = &oxfw->in_conn;
182 		c_dir = CMP_INPUT;
183 		s_dir = AMDTP_OUT_STREAM;
184 	}
185 
186 	err = cmp_connection_init(conn, oxfw->unit, c_dir, 0);
187 	if (err < 0)
188 		return err;
189 
190 	err = amdtp_am824_init(stream, oxfw->unit, s_dir, flags);
191 	if (err < 0) {
192 		cmp_connection_destroy(conn);
193 		return err;
194 	}
195 
196 	return 0;
197 }
198 
199 static int keep_resources(struct snd_oxfw *oxfw, struct amdtp_stream *stream)
200 {
201 	enum avc_general_plug_dir dir;
202 	u8 **formats;
203 	struct snd_oxfw_stream_formation formation;
204 	struct cmp_connection *conn;
205 	int i;
206 	int err;
207 
208 	if (stream == &oxfw->rx_stream) {
209 		dir = AVC_GENERAL_PLUG_DIR_IN;
210 		formats = oxfw->rx_stream_formats;
211 		conn = &oxfw->in_conn;
212 	} else {
213 		dir = AVC_GENERAL_PLUG_DIR_OUT;
214 		formats = oxfw->tx_stream_formats;
215 		conn = &oxfw->out_conn;
216 	}
217 
218 	err = snd_oxfw_stream_get_current_formation(oxfw, dir, &formation);
219 	if (err < 0)
220 		return err;
221 
222 	for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
223 		struct snd_oxfw_stream_formation fmt;
224 
225 		if (formats[i] == NULL)
226 			break;
227 
228 		err = snd_oxfw_stream_parse_format(formats[i], &fmt);
229 		if (err < 0)
230 			return err;
231 
232 		if (fmt.rate == formation.rate && fmt.pcm == formation.pcm &&
233 		    fmt.midi == formation.midi)
234 			break;
235 	}
236 	if (i == SND_OXFW_STREAM_FORMAT_ENTRIES)
237 		return -EINVAL;
238 
239 	// The stream should have one pcm channels at least.
240 	if (formation.pcm == 0)
241 		return -EINVAL;
242 
243 	err = amdtp_am824_set_parameters(stream, formation.rate, formation.pcm,
244 					 formation.midi * 8, false);
245 	if (err < 0)
246 		return err;
247 
248 	return cmp_connection_reserve(conn, amdtp_stream_get_max_payload(stream));
249 }
250 
251 int snd_oxfw_stream_reserve_duplex(struct snd_oxfw *oxfw,
252 				   struct amdtp_stream *stream,
253 				   unsigned int rate, unsigned int pcm_channels,
254 				   unsigned int frames_per_period,
255 				   unsigned int frames_per_buffer)
256 {
257 	struct snd_oxfw_stream_formation formation;
258 	enum avc_general_plug_dir dir;
259 	int err;
260 
261 	// Considering JACK/FFADO streaming:
262 	// TODO: This can be removed hwdep functionality becomes popular.
263 	err = check_connection_used_by_others(oxfw, &oxfw->rx_stream);
264 	if (err < 0)
265 		return err;
266 	if (oxfw->has_output) {
267 		err = check_connection_used_by_others(oxfw, &oxfw->tx_stream);
268 		if (err < 0)
269 			return err;
270 	}
271 
272 	if (stream == &oxfw->tx_stream)
273 		dir = AVC_GENERAL_PLUG_DIR_OUT;
274 	else
275 		dir = AVC_GENERAL_PLUG_DIR_IN;
276 
277 	err = snd_oxfw_stream_get_current_formation(oxfw, dir, &formation);
278 	if (err < 0)
279 		return err;
280 	if (rate == 0) {
281 		rate = formation.rate;
282 		pcm_channels = formation.pcm;
283 	}
284 	if (formation.rate != rate || formation.pcm != pcm_channels) {
285 		amdtp_domain_stop(&oxfw->domain);
286 
287 		cmp_connection_break(&oxfw->in_conn);
288 		cmp_connection_release(&oxfw->in_conn);
289 
290 		if (oxfw->has_output) {
291 			cmp_connection_break(&oxfw->out_conn);
292 			cmp_connection_release(&oxfw->out_conn);
293 		}
294 	}
295 
296 	if (oxfw->substreams_count == 0 ||
297 	    formation.rate != rate || formation.pcm != pcm_channels) {
298 		err = set_stream_format(oxfw, stream, rate, pcm_channels);
299 		if (err < 0) {
300 			dev_err(&oxfw->unit->device,
301 				"fail to set stream format: %d\n", err);
302 			return err;
303 		}
304 
305 		err = keep_resources(oxfw, &oxfw->rx_stream);
306 		if (err < 0)
307 			return err;
308 
309 		if (oxfw->has_output) {
310 			err = keep_resources(oxfw, &oxfw->tx_stream);
311 			if (err < 0) {
312 				cmp_connection_release(&oxfw->in_conn);
313 				return err;
314 			}
315 		}
316 
317 		err = amdtp_domain_set_events_per_period(&oxfw->domain,
318 					frames_per_period, frames_per_buffer);
319 		if (err < 0) {
320 			cmp_connection_release(&oxfw->in_conn);
321 			if (oxfw->has_output)
322 				cmp_connection_release(&oxfw->out_conn);
323 			return err;
324 		}
325 	}
326 
327 	return 0;
328 }
329 
330 int snd_oxfw_stream_start_duplex(struct snd_oxfw *oxfw)
331 {
332 	int err;
333 
334 	if (oxfw->substreams_count == 0)
335 		return -EIO;
336 
337 	if (amdtp_streaming_error(&oxfw->rx_stream) ||
338 	    amdtp_streaming_error(&oxfw->tx_stream)) {
339 		amdtp_domain_stop(&oxfw->domain);
340 
341 		cmp_connection_break(&oxfw->in_conn);
342 		if (oxfw->has_output)
343 			cmp_connection_break(&oxfw->out_conn);
344 	}
345 
346 	if (!amdtp_stream_running(&oxfw->rx_stream)) {
347 		unsigned int tx_init_skip_cycles = 0;
348 		bool replay_seq = false;
349 
350 		err = start_stream(oxfw, &oxfw->rx_stream);
351 		if (err < 0) {
352 			dev_err(&oxfw->unit->device,
353 				"fail to prepare rx stream: %d\n", err);
354 			goto error;
355 		}
356 
357 		if (oxfw->has_output &&
358 		    !amdtp_stream_running(&oxfw->tx_stream)) {
359 			err = start_stream(oxfw, &oxfw->tx_stream);
360 			if (err < 0) {
361 				dev_err(&oxfw->unit->device,
362 					"fail to prepare tx stream: %d\n", err);
363 				goto error;
364 			}
365 
366 			if (oxfw->quirks & SND_OXFW_QUIRK_JUMBO_PAYLOAD) {
367 				// Just after changing sampling transfer frequency, many cycles are
368 				// skipped for packet transmission.
369 				tx_init_skip_cycles = 400;
370 			} else if (oxfw->quirks & SND_OXFW_QUIRK_VOLUNTARY_RECOVERY) {
371 				// It takes a bit time for target device to adjust event frequency
372 				// according to nominal event frequency in isochronous packets from
373 				// ALSA oxfw driver.
374 				tx_init_skip_cycles = 4000;
375 			} else {
376 				replay_seq = true;
377 			}
378 		}
379 
380 		// NOTE: The device ignores presentation time expressed by the value of syt field
381 		// of CIP header in received packets. The sequence of the number of data blocks per
382 		// packet is important for media clock recovery.
383 		err = amdtp_domain_start(&oxfw->domain, tx_init_skip_cycles, replay_seq, false);
384 		if (err < 0)
385 			goto error;
386 
387 		if (!amdtp_domain_wait_ready(&oxfw->domain, READY_TIMEOUT_MS)) {
388 			err = -ETIMEDOUT;
389 			goto error;
390 		}
391 	}
392 
393 	return 0;
394 error:
395 	amdtp_domain_stop(&oxfw->domain);
396 
397 	cmp_connection_break(&oxfw->in_conn);
398 	if (oxfw->has_output)
399 		cmp_connection_break(&oxfw->out_conn);
400 
401 	return err;
402 }
403 
404 void snd_oxfw_stream_stop_duplex(struct snd_oxfw *oxfw)
405 {
406 	if (oxfw->substreams_count == 0) {
407 		amdtp_domain_stop(&oxfw->domain);
408 
409 		cmp_connection_break(&oxfw->in_conn);
410 		cmp_connection_release(&oxfw->in_conn);
411 
412 		if (oxfw->has_output) {
413 			cmp_connection_break(&oxfw->out_conn);
414 			cmp_connection_release(&oxfw->out_conn);
415 		}
416 	}
417 }
418 
419 static void destroy_stream(struct snd_oxfw *oxfw, struct amdtp_stream *stream)
420 {
421 	struct cmp_connection *conn;
422 
423 	if (stream == &oxfw->tx_stream)
424 		conn = &oxfw->out_conn;
425 	else
426 		conn = &oxfw->in_conn;
427 
428 	amdtp_stream_destroy(stream);
429 	cmp_connection_destroy(conn);
430 }
431 
432 int snd_oxfw_stream_init_duplex(struct snd_oxfw *oxfw)
433 {
434 	int err;
435 
436 	err = init_stream(oxfw, &oxfw->rx_stream);
437 	if (err < 0)
438 		return err;
439 
440 	if (oxfw->has_output) {
441 		err = init_stream(oxfw, &oxfw->tx_stream);
442 		if (err < 0) {
443 			destroy_stream(oxfw, &oxfw->rx_stream);
444 			return err;
445 		}
446 	}
447 
448 	err = amdtp_domain_init(&oxfw->domain);
449 	if (err < 0) {
450 		destroy_stream(oxfw, &oxfw->rx_stream);
451 		if (oxfw->has_output)
452 			destroy_stream(oxfw, &oxfw->tx_stream);
453 	}
454 
455 	return err;
456 }
457 
458 // This function should be called before starting the stream or after stopping
459 // the streams.
460 void snd_oxfw_stream_destroy_duplex(struct snd_oxfw *oxfw)
461 {
462 	amdtp_domain_destroy(&oxfw->domain);
463 
464 	destroy_stream(oxfw, &oxfw->rx_stream);
465 
466 	if (oxfw->has_output)
467 		destroy_stream(oxfw, &oxfw->tx_stream);
468 }
469 
470 void snd_oxfw_stream_update_duplex(struct snd_oxfw *oxfw)
471 {
472 	amdtp_domain_stop(&oxfw->domain);
473 
474 	cmp_connection_break(&oxfw->in_conn);
475 
476 	amdtp_stream_pcm_abort(&oxfw->rx_stream);
477 
478 	if (oxfw->has_output) {
479 		cmp_connection_break(&oxfw->out_conn);
480 
481 		amdtp_stream_pcm_abort(&oxfw->tx_stream);
482 	}
483 }
484 
485 int snd_oxfw_stream_get_current_formation(struct snd_oxfw *oxfw,
486 				enum avc_general_plug_dir dir,
487 				struct snd_oxfw_stream_formation *formation)
488 {
489 	u8 *format;
490 	unsigned int len;
491 	int err;
492 
493 	len = AVC_GENERIC_FRAME_MAXIMUM_BYTES;
494 	format = kmalloc(len, GFP_KERNEL);
495 	if (format == NULL)
496 		return -ENOMEM;
497 
498 	err = avc_stream_get_format_single(oxfw->unit, dir, 0, format, &len);
499 	if (err < 0)
500 		goto end;
501 	if (len < 3) {
502 		err = -EIO;
503 		goto end;
504 	}
505 
506 	err = snd_oxfw_stream_parse_format(format, formation);
507 end:
508 	kfree(format);
509 	return err;
510 }
511 
512 /*
513  * See Table 6.16 - AM824 Stream Format
514  *     Figure 6.19 - format_information field for AM824 Compound
515  * in AV/C Stream Format Information Specification 1.1 (Apr 2005, 1394TA)
516  * Also 'Clause 12 AM824 sequence adaption layers' in IEC 61883-6:2005
517  */
518 int snd_oxfw_stream_parse_format(u8 *format,
519 				 struct snd_oxfw_stream_formation *formation)
520 {
521 	unsigned int i, e, channels, type;
522 
523 	memset(formation, 0, sizeof(struct snd_oxfw_stream_formation));
524 
525 	/*
526 	 * this module can support a hierarchy combination that:
527 	 *  Root:	Audio and Music (0x90)
528 	 *  Level 1:	AM824 Compound  (0x40)
529 	 */
530 	if ((format[0] != 0x90) || (format[1] != 0x40))
531 		return -ENXIO;
532 
533 	/* check the sampling rate */
534 	for (i = 0; i < ARRAY_SIZE(avc_stream_rate_table); i++) {
535 		if (format[2] == avc_stream_rate_table[i])
536 			break;
537 	}
538 	if (i == ARRAY_SIZE(avc_stream_rate_table))
539 		return -ENXIO;
540 
541 	formation->rate = oxfw_rate_table[i];
542 
543 	for (e = 0; e < format[4]; e++) {
544 		channels = format[5 + e * 2];
545 		type = format[6 + e * 2];
546 
547 		switch (type) {
548 		/* IEC 60958 Conformant, currently handled as MBLA */
549 		case 0x00:
550 		/* Multi Bit Linear Audio (Raw) */
551 		case 0x06:
552 			formation->pcm += channels;
553 			break;
554 		/* MIDI Conformant */
555 		case 0x0d:
556 			formation->midi = channels;
557 			break;
558 		/* IEC 61937-3 to 7 */
559 		case 0x01:
560 		case 0x02:
561 		case 0x03:
562 		case 0x04:
563 		case 0x05:
564 		/* Multi Bit Linear Audio */
565 		case 0x07:	/* DVD-Audio */
566 		case 0x0c:	/* High Precision */
567 		/* One Bit Audio */
568 		case 0x08:	/* (Plain) Raw */
569 		case 0x09:	/* (Plain) SACD */
570 		case 0x0a:	/* (Encoded) Raw */
571 		case 0x0b:	/* (Encoded) SACD */
572 		/* SMPTE Time-Code conformant */
573 		case 0x0e:
574 		/* Sample Count */
575 		case 0x0f:
576 		/* Anciliary Data */
577 		case 0x10:
578 		/* Synchronization Stream (Stereo Raw audio) */
579 		case 0x40:
580 		/* Don't care */
581 		case 0xff:
582 		default:
583 			return -ENXIO;	/* not supported */
584 		}
585 	}
586 
587 	if (formation->pcm  > AM824_MAX_CHANNELS_FOR_PCM ||
588 	    formation->midi > AM824_MAX_CHANNELS_FOR_MIDI)
589 		return -ENXIO;
590 
591 	return 0;
592 }
593 
594 static int
595 assume_stream_formats(struct snd_oxfw *oxfw, enum avc_general_plug_dir dir,
596 		      unsigned int pid, u8 *buf, unsigned int *len,
597 		      u8 **formats)
598 {
599 	struct snd_oxfw_stream_formation formation;
600 	unsigned int i, eid;
601 	int err;
602 
603 	/* get format at current sampling rate */
604 	err = avc_stream_get_format_single(oxfw->unit, dir, pid, buf, len);
605 	if (err < 0) {
606 		dev_err(&oxfw->unit->device,
607 		"fail to get current stream format for isoc %s plug %d:%d\n",
608 			(dir == AVC_GENERAL_PLUG_DIR_IN) ? "in" : "out",
609 			pid, err);
610 		goto end;
611 	}
612 
613 	/* parse and set stream format */
614 	eid = 0;
615 	err = snd_oxfw_stream_parse_format(buf, &formation);
616 	if (err < 0)
617 		goto end;
618 
619 	formats[eid] = devm_kmemdup(&oxfw->card->card_dev, buf, *len,
620 				    GFP_KERNEL);
621 	if (!formats[eid]) {
622 		err = -ENOMEM;
623 		goto end;
624 	}
625 
626 	/* apply the format for each available sampling rate */
627 	for (i = 0; i < ARRAY_SIZE(oxfw_rate_table); i++) {
628 		if (formation.rate == oxfw_rate_table[i])
629 			continue;
630 
631 		err = avc_general_inquiry_sig_fmt(oxfw->unit,
632 						  oxfw_rate_table[i],
633 						  dir, pid);
634 		if (err < 0)
635 			continue;
636 
637 		eid++;
638 		formats[eid] = devm_kmemdup(&oxfw->card->card_dev, buf, *len,
639 					    GFP_KERNEL);
640 		if (formats[eid] == NULL) {
641 			err = -ENOMEM;
642 			goto end;
643 		}
644 		formats[eid][2] = avc_stream_rate_table[i];
645 	}
646 
647 	err = 0;
648 	oxfw->assumed = true;
649 end:
650 	return err;
651 }
652 
653 static int fill_stream_formats(struct snd_oxfw *oxfw,
654 			       enum avc_general_plug_dir dir,
655 			       unsigned short pid)
656 {
657 	u8 *buf, **formats;
658 	unsigned int len, eid = 0;
659 	struct snd_oxfw_stream_formation dummy;
660 	int err;
661 
662 	buf = kmalloc(AVC_GENERIC_FRAME_MAXIMUM_BYTES, GFP_KERNEL);
663 	if (buf == NULL)
664 		return -ENOMEM;
665 
666 	if (dir == AVC_GENERAL_PLUG_DIR_OUT)
667 		formats = oxfw->tx_stream_formats;
668 	else
669 		formats = oxfw->rx_stream_formats;
670 
671 	/* get first entry */
672 	len = AVC_GENERIC_FRAME_MAXIMUM_BYTES;
673 	err = avc_stream_get_format_list(oxfw->unit, dir, 0, buf, &len, 0);
674 	if (err == -ENXIO) {
675 		/* LIST subfunction is not implemented */
676 		len = AVC_GENERIC_FRAME_MAXIMUM_BYTES;
677 		err = assume_stream_formats(oxfw, dir, pid, buf, &len,
678 					    formats);
679 		goto end;
680 	} else if (err < 0) {
681 		dev_err(&oxfw->unit->device,
682 			"fail to get stream format %d for isoc %s plug %d:%d\n",
683 			eid, (dir == AVC_GENERAL_PLUG_DIR_IN) ? "in" : "out",
684 			pid, err);
685 		goto end;
686 	}
687 
688 	/* LIST subfunction is implemented */
689 	while (eid < SND_OXFW_STREAM_FORMAT_ENTRIES) {
690 		/* The format is too short. */
691 		if (len < 3) {
692 			err = -EIO;
693 			break;
694 		}
695 
696 		/* parse and set stream format */
697 		err = snd_oxfw_stream_parse_format(buf, &dummy);
698 		if (err < 0)
699 			break;
700 
701 		formats[eid] = devm_kmemdup(&oxfw->card->card_dev, buf, len,
702 					    GFP_KERNEL);
703 		if (!formats[eid]) {
704 			err = -ENOMEM;
705 			break;
706 		}
707 
708 		/* get next entry */
709 		len = AVC_GENERIC_FRAME_MAXIMUM_BYTES;
710 		err = avc_stream_get_format_list(oxfw->unit, dir, 0,
711 						 buf, &len, ++eid);
712 		/* No entries remained. */
713 		if (err == -EINVAL) {
714 			err = 0;
715 			break;
716 		} else if (err < 0) {
717 			dev_err(&oxfw->unit->device,
718 			"fail to get stream format %d for isoc %s plug %d:%d\n",
719 				eid, (dir == AVC_GENERAL_PLUG_DIR_IN) ? "in" :
720 									"out",
721 				pid, err);
722 			break;
723 		}
724 	}
725 end:
726 	kfree(buf);
727 	return err;
728 }
729 
730 int snd_oxfw_stream_discover(struct snd_oxfw *oxfw)
731 {
732 	u8 plugs[AVC_PLUG_INFO_BUF_BYTES];
733 	struct snd_oxfw_stream_formation formation;
734 	u8 *format;
735 	unsigned int i;
736 	int err;
737 
738 	/* the number of plugs for isoc in/out, ext in/out  */
739 	err = avc_general_get_plug_info(oxfw->unit, 0x1f, 0x07, 0x00, plugs);
740 	if (err < 0) {
741 		dev_err(&oxfw->unit->device,
742 		"fail to get info for isoc/external in/out plugs: %d\n",
743 			err);
744 		goto end;
745 	} else if ((plugs[0] == 0) && (plugs[1] == 0)) {
746 		err = -ENXIO;
747 		goto end;
748 	}
749 
750 	/* use oPCR[0] if exists */
751 	if (plugs[1] > 0) {
752 		err = fill_stream_formats(oxfw, AVC_GENERAL_PLUG_DIR_OUT, 0);
753 		if (err < 0) {
754 			if (err != -ENXIO)
755 				return err;
756 
757 			// The oPCR is not available for isoc communication.
758 			err = 0;
759 		} else {
760 			for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
761 				format = oxfw->tx_stream_formats[i];
762 				if (format == NULL)
763 					continue;
764 				err = snd_oxfw_stream_parse_format(format,
765 								   &formation);
766 				if (err < 0)
767 					continue;
768 
769 				/* Add one MIDI port. */
770 				if (formation.midi > 0)
771 					oxfw->midi_input_ports = 1;
772 			}
773 
774 			oxfw->has_output = true;
775 		}
776 	}
777 
778 	/* use iPCR[0] if exists */
779 	if (plugs[0] > 0) {
780 		err = fill_stream_formats(oxfw, AVC_GENERAL_PLUG_DIR_IN, 0);
781 		if (err < 0) {
782 			if (err != -ENXIO)
783 				return err;
784 
785 			// The iPCR is not available for isoc communication.
786 			err = 0;
787 		} else {
788 			for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
789 				format = oxfw->rx_stream_formats[i];
790 				if (format == NULL)
791 					continue;
792 				err = snd_oxfw_stream_parse_format(format,
793 								   &formation);
794 				if (err < 0)
795 					continue;
796 
797 				/* Add one MIDI port. */
798 				if (formation.midi > 0)
799 					oxfw->midi_output_ports = 1;
800 			}
801 
802 			oxfw->has_input = true;
803 		}
804 	}
805 end:
806 	return err;
807 }
808 
809 void snd_oxfw_stream_lock_changed(struct snd_oxfw *oxfw)
810 {
811 	oxfw->dev_lock_changed = true;
812 	wake_up(&oxfw->hwdep_wait);
813 }
814 
815 int snd_oxfw_stream_lock_try(struct snd_oxfw *oxfw)
816 {
817 	int err;
818 
819 	spin_lock_irq(&oxfw->lock);
820 
821 	/* user land lock this */
822 	if (oxfw->dev_lock_count < 0) {
823 		err = -EBUSY;
824 		goto end;
825 	}
826 
827 	/* this is the first time */
828 	if (oxfw->dev_lock_count++ == 0)
829 		snd_oxfw_stream_lock_changed(oxfw);
830 	err = 0;
831 end:
832 	spin_unlock_irq(&oxfw->lock);
833 	return err;
834 }
835 
836 void snd_oxfw_stream_lock_release(struct snd_oxfw *oxfw)
837 {
838 	spin_lock_irq(&oxfw->lock);
839 
840 	if (WARN_ON(oxfw->dev_lock_count <= 0))
841 		goto end;
842 	if (--oxfw->dev_lock_count == 0)
843 		snd_oxfw_stream_lock_changed(oxfw);
844 end:
845 	spin_unlock_irq(&oxfw->lock);
846 }
847