cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

audio.c (22412B)


      1// SPDX-License-Identifier: GPL-2.0-or-later
      2/*
      3 *   Copyright (c) 2006-2008 Daniel Mack, Karsten Wiese
      4*/
      5
      6#include <linux/device.h>
      7#include <linux/spinlock.h>
      8#include <linux/slab.h>
      9#include <linux/init.h>
     10#include <linux/usb.h>
     11#include <sound/core.h>
     12#include <sound/pcm.h>
     13
     14#include "device.h"
     15#include "audio.h"
     16
     17#define N_URBS			32
     18#define CLOCK_DRIFT_TOLERANCE	5
     19#define FRAMES_PER_URB		8
     20#define BYTES_PER_FRAME		512
     21#define CHANNELS_PER_STREAM	2
     22#define BYTES_PER_SAMPLE	3
     23#define BYTES_PER_SAMPLE_USB	4
     24#define MAX_BUFFER_SIZE		(128*1024)
     25#define MAX_ENDPOINT_SIZE	512
     26
     27#define ENDPOINT_CAPTURE	2
     28#define ENDPOINT_PLAYBACK	6
     29
     30#define MAKE_CHECKBYTE(cdev,stream,i) \
     31	(stream << 1) | (~(i / (cdev->n_streams * BYTES_PER_SAMPLE_USB)) & 1)
     32
     33static const struct snd_pcm_hardware snd_usb_caiaq_pcm_hardware = {
     34	.info 		= (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
     35			   SNDRV_PCM_INFO_BLOCK_TRANSFER),
     36	.formats 	= SNDRV_PCM_FMTBIT_S24_3BE,
     37	.rates 		= (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
     38			   SNDRV_PCM_RATE_96000),
     39	.rate_min	= 44100,
     40	.rate_max	= 0, /* will overwrite later */
     41	.channels_min	= CHANNELS_PER_STREAM,
     42	.channels_max	= CHANNELS_PER_STREAM,
     43	.buffer_bytes_max = MAX_BUFFER_SIZE,
     44	.period_bytes_min = 128,
     45	.period_bytes_max = MAX_BUFFER_SIZE,
     46	.periods_min	= 1,
     47	.periods_max	= 1024,
     48};
     49
     50static void
     51activate_substream(struct snd_usb_caiaqdev *cdev,
     52	           struct snd_pcm_substream *sub)
     53{
     54	spin_lock(&cdev->spinlock);
     55
     56	if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
     57		cdev->sub_playback[sub->number] = sub;
     58	else
     59		cdev->sub_capture[sub->number] = sub;
     60
     61	spin_unlock(&cdev->spinlock);
     62}
     63
     64static void
     65deactivate_substream(struct snd_usb_caiaqdev *cdev,
     66		     struct snd_pcm_substream *sub)
     67{
     68	unsigned long flags;
     69	spin_lock_irqsave(&cdev->spinlock, flags);
     70
     71	if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
     72		cdev->sub_playback[sub->number] = NULL;
     73	else
     74		cdev->sub_capture[sub->number] = NULL;
     75
     76	spin_unlock_irqrestore(&cdev->spinlock, flags);
     77}
     78
     79static int
     80all_substreams_zero(struct snd_pcm_substream **subs)
     81{
     82	int i;
     83	for (i = 0; i < MAX_STREAMS; i++)
     84		if (subs[i] != NULL)
     85			return 0;
     86	return 1;
     87}
     88
     89static int stream_start(struct snd_usb_caiaqdev *cdev)
     90{
     91	int i, ret;
     92	struct device *dev = caiaqdev_to_dev(cdev);
     93
     94	dev_dbg(dev, "%s(%p)\n", __func__, cdev);
     95
     96	if (cdev->streaming)
     97		return -EINVAL;
     98
     99	memset(cdev->sub_playback, 0, sizeof(cdev->sub_playback));
    100	memset(cdev->sub_capture, 0, sizeof(cdev->sub_capture));
    101	cdev->input_panic = 0;
    102	cdev->output_panic = 0;
    103	cdev->first_packet = 4;
    104	cdev->streaming = 1;
    105	cdev->warned = 0;
    106
    107	for (i = 0; i < N_URBS; i++) {
    108		ret = usb_submit_urb(cdev->data_urbs_in[i], GFP_ATOMIC);
    109		if (ret) {
    110			dev_err(dev, "unable to trigger read #%d! (ret %d)\n",
    111				i, ret);
    112			cdev->streaming = 0;
    113			return -EPIPE;
    114		}
    115	}
    116
    117	return 0;
    118}
    119
    120static void stream_stop(struct snd_usb_caiaqdev *cdev)
    121{
    122	int i;
    123	struct device *dev = caiaqdev_to_dev(cdev);
    124
    125	dev_dbg(dev, "%s(%p)\n", __func__, cdev);
    126	if (!cdev->streaming)
    127		return;
    128
    129	cdev->streaming = 0;
    130
    131	for (i = 0; i < N_URBS; i++) {
    132		usb_kill_urb(cdev->data_urbs_in[i]);
    133
    134		if (test_bit(i, &cdev->outurb_active_mask))
    135			usb_kill_urb(cdev->data_urbs_out[i]);
    136	}
    137
    138	cdev->outurb_active_mask = 0;
    139}
    140
    141static int snd_usb_caiaq_substream_open(struct snd_pcm_substream *substream)
    142{
    143	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(substream);
    144	struct device *dev = caiaqdev_to_dev(cdev);
    145
    146	dev_dbg(dev, "%s(%p)\n", __func__, substream);
    147	substream->runtime->hw = cdev->pcm_info;
    148	snd_pcm_limit_hw_rates(substream->runtime);
    149
    150	return 0;
    151}
    152
    153static int snd_usb_caiaq_substream_close(struct snd_pcm_substream *substream)
    154{
    155	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(substream);
    156	struct device *dev = caiaqdev_to_dev(cdev);
    157
    158	dev_dbg(dev, "%s(%p)\n", __func__, substream);
    159	if (all_substreams_zero(cdev->sub_playback) &&
    160	    all_substreams_zero(cdev->sub_capture)) {
    161		/* when the last client has stopped streaming,
    162		 * all sample rates are allowed again */
    163		stream_stop(cdev);
    164		cdev->pcm_info.rates = cdev->samplerates;
    165	}
    166
    167	return 0;
    168}
    169
    170static int snd_usb_caiaq_pcm_hw_free(struct snd_pcm_substream *sub)
    171{
    172	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(sub);
    173	deactivate_substream(cdev, sub);
    174	return 0;
    175}
    176
    177/* this should probably go upstream */
    178#if SNDRV_PCM_RATE_5512 != 1 << 0 || SNDRV_PCM_RATE_192000 != 1 << 12
    179#error "Change this table"
    180#endif
    181
    182static const unsigned int rates[] = { 5512, 8000, 11025, 16000, 22050, 32000, 44100,
    183				48000, 64000, 88200, 96000, 176400, 192000 };
    184
    185static int snd_usb_caiaq_pcm_prepare(struct snd_pcm_substream *substream)
    186{
    187	int bytes_per_sample, bpp, ret, i;
    188	int index = substream->number;
    189	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(substream);
    190	struct snd_pcm_runtime *runtime = substream->runtime;
    191	struct device *dev = caiaqdev_to_dev(cdev);
    192
    193	dev_dbg(dev, "%s(%p)\n", __func__, substream);
    194
    195	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
    196		int out_pos;
    197
    198		switch (cdev->spec.data_alignment) {
    199		case 0:
    200		case 2:
    201			out_pos = BYTES_PER_SAMPLE + 1;
    202			break;
    203		case 3:
    204		default:
    205			out_pos = 0;
    206			break;
    207		}
    208
    209		cdev->period_out_count[index] = out_pos;
    210		cdev->audio_out_buf_pos[index] = out_pos;
    211	} else {
    212		int in_pos;
    213
    214		switch (cdev->spec.data_alignment) {
    215		case 0:
    216			in_pos = BYTES_PER_SAMPLE + 2;
    217			break;
    218		case 2:
    219			in_pos = BYTES_PER_SAMPLE;
    220			break;
    221		case 3:
    222		default:
    223			in_pos = 0;
    224			break;
    225		}
    226
    227		cdev->period_in_count[index] = in_pos;
    228		cdev->audio_in_buf_pos[index] = in_pos;
    229	}
    230
    231	if (cdev->streaming)
    232		return 0;
    233
    234	/* the first client that opens a stream defines the sample rate
    235	 * setting for all subsequent calls, until the last client closed. */
    236	for (i=0; i < ARRAY_SIZE(rates); i++)
    237		if (runtime->rate == rates[i])
    238			cdev->pcm_info.rates = 1 << i;
    239
    240	snd_pcm_limit_hw_rates(runtime);
    241
    242	bytes_per_sample = BYTES_PER_SAMPLE;
    243	if (cdev->spec.data_alignment >= 2)
    244		bytes_per_sample++;
    245
    246	bpp = ((runtime->rate / 8000) + CLOCK_DRIFT_TOLERANCE)
    247		* bytes_per_sample * CHANNELS_PER_STREAM * cdev->n_streams;
    248
    249	if (bpp > MAX_ENDPOINT_SIZE)
    250		bpp = MAX_ENDPOINT_SIZE;
    251
    252	ret = snd_usb_caiaq_set_audio_params(cdev, runtime->rate,
    253					     runtime->sample_bits, bpp);
    254	if (ret)
    255		return ret;
    256
    257	ret = stream_start(cdev);
    258	if (ret)
    259		return ret;
    260
    261	cdev->output_running = 0;
    262	wait_event_timeout(cdev->prepare_wait_queue, cdev->output_running, HZ);
    263	if (!cdev->output_running) {
    264		stream_stop(cdev);
    265		return -EPIPE;
    266	}
    267
    268	return 0;
    269}
    270
    271static int snd_usb_caiaq_pcm_trigger(struct snd_pcm_substream *sub, int cmd)
    272{
    273	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(sub);
    274	struct device *dev = caiaqdev_to_dev(cdev);
    275
    276	dev_dbg(dev, "%s(%p) cmd %d\n", __func__, sub, cmd);
    277
    278	switch (cmd) {
    279	case SNDRV_PCM_TRIGGER_START:
    280	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
    281		activate_substream(cdev, sub);
    282		break;
    283	case SNDRV_PCM_TRIGGER_STOP:
    284	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
    285		deactivate_substream(cdev, sub);
    286		break;
    287	default:
    288		return -EINVAL;
    289	}
    290
    291	return 0;
    292}
    293
    294static snd_pcm_uframes_t
    295snd_usb_caiaq_pcm_pointer(struct snd_pcm_substream *sub)
    296{
    297	int index = sub->number;
    298	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(sub);
    299	snd_pcm_uframes_t ptr;
    300
    301	spin_lock(&cdev->spinlock);
    302
    303	if (cdev->input_panic || cdev->output_panic) {
    304		ptr = SNDRV_PCM_POS_XRUN;
    305		goto unlock;
    306	}
    307
    308	if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
    309		ptr = bytes_to_frames(sub->runtime,
    310					cdev->audio_out_buf_pos[index]);
    311	else
    312		ptr = bytes_to_frames(sub->runtime,
    313					cdev->audio_in_buf_pos[index]);
    314
    315unlock:
    316	spin_unlock(&cdev->spinlock);
    317	return ptr;
    318}
    319
    320/* operators for both playback and capture */
    321static const struct snd_pcm_ops snd_usb_caiaq_ops = {
    322	.open =		snd_usb_caiaq_substream_open,
    323	.close =	snd_usb_caiaq_substream_close,
    324	.hw_free =	snd_usb_caiaq_pcm_hw_free,
    325	.prepare =	snd_usb_caiaq_pcm_prepare,
    326	.trigger =	snd_usb_caiaq_pcm_trigger,
    327	.pointer =	snd_usb_caiaq_pcm_pointer,
    328};
    329
    330static void check_for_elapsed_periods(struct snd_usb_caiaqdev *cdev,
    331				      struct snd_pcm_substream **subs)
    332{
    333	int stream, pb, *cnt;
    334	struct snd_pcm_substream *sub;
    335
    336	for (stream = 0; stream < cdev->n_streams; stream++) {
    337		sub = subs[stream];
    338		if (!sub)
    339			continue;
    340
    341		pb = snd_pcm_lib_period_bytes(sub);
    342		cnt = (sub->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
    343					&cdev->period_out_count[stream] :
    344					&cdev->period_in_count[stream];
    345
    346		if (*cnt >= pb) {
    347			snd_pcm_period_elapsed(sub);
    348			*cnt %= pb;
    349		}
    350	}
    351}
    352
    353static void read_in_urb_mode0(struct snd_usb_caiaqdev *cdev,
    354			      const struct urb *urb,
    355			      const struct usb_iso_packet_descriptor *iso)
    356{
    357	unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
    358	struct snd_pcm_substream *sub;
    359	int stream, i;
    360
    361	if (all_substreams_zero(cdev->sub_capture))
    362		return;
    363
    364	for (i = 0; i < iso->actual_length;) {
    365		for (stream = 0; stream < cdev->n_streams; stream++, i++) {
    366			sub = cdev->sub_capture[stream];
    367			if (sub) {
    368				struct snd_pcm_runtime *rt = sub->runtime;
    369				char *audio_buf = rt->dma_area;
    370				int sz = frames_to_bytes(rt, rt->buffer_size);
    371				audio_buf[cdev->audio_in_buf_pos[stream]++]
    372					= usb_buf[i];
    373				cdev->period_in_count[stream]++;
    374				if (cdev->audio_in_buf_pos[stream] == sz)
    375					cdev->audio_in_buf_pos[stream] = 0;
    376			}
    377		}
    378	}
    379}
    380
    381static void read_in_urb_mode2(struct snd_usb_caiaqdev *cdev,
    382			      const struct urb *urb,
    383			      const struct usb_iso_packet_descriptor *iso)
    384{
    385	unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
    386	unsigned char check_byte;
    387	struct snd_pcm_substream *sub;
    388	int stream, i;
    389
    390	for (i = 0; i < iso->actual_length;) {
    391		if (i % (cdev->n_streams * BYTES_PER_SAMPLE_USB) == 0) {
    392			for (stream = 0;
    393			     stream < cdev->n_streams;
    394			     stream++, i++) {
    395				if (cdev->first_packet)
    396					continue;
    397
    398				check_byte = MAKE_CHECKBYTE(cdev, stream, i);
    399
    400				if ((usb_buf[i] & 0x3f) != check_byte)
    401					cdev->input_panic = 1;
    402
    403				if (usb_buf[i] & 0x80)
    404					cdev->output_panic = 1;
    405			}
    406		}
    407		cdev->first_packet = 0;
    408
    409		for (stream = 0; stream < cdev->n_streams; stream++, i++) {
    410			sub = cdev->sub_capture[stream];
    411			if (cdev->input_panic)
    412				usb_buf[i] = 0;
    413
    414			if (sub) {
    415				struct snd_pcm_runtime *rt = sub->runtime;
    416				char *audio_buf = rt->dma_area;
    417				int sz = frames_to_bytes(rt, rt->buffer_size);
    418				audio_buf[cdev->audio_in_buf_pos[stream]++] =
    419					usb_buf[i];
    420				cdev->period_in_count[stream]++;
    421				if (cdev->audio_in_buf_pos[stream] == sz)
    422					cdev->audio_in_buf_pos[stream] = 0;
    423			}
    424		}
    425	}
    426}
    427
    428static void read_in_urb_mode3(struct snd_usb_caiaqdev *cdev,
    429			      const struct urb *urb,
    430			      const struct usb_iso_packet_descriptor *iso)
    431{
    432	unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
    433	struct device *dev = caiaqdev_to_dev(cdev);
    434	int stream, i;
    435
    436	/* paranoia check */
    437	if (iso->actual_length % (BYTES_PER_SAMPLE_USB * CHANNELS_PER_STREAM))
    438		return;
    439
    440	for (i = 0; i < iso->actual_length;) {
    441		for (stream = 0; stream < cdev->n_streams; stream++) {
    442			struct snd_pcm_substream *sub = cdev->sub_capture[stream];
    443			char *audio_buf = NULL;
    444			int c, n, sz = 0;
    445
    446			if (sub && !cdev->input_panic) {
    447				struct snd_pcm_runtime *rt = sub->runtime;
    448				audio_buf = rt->dma_area;
    449				sz = frames_to_bytes(rt, rt->buffer_size);
    450			}
    451
    452			for (c = 0; c < CHANNELS_PER_STREAM; c++) {
    453				/* 3 audio data bytes, followed by 1 check byte */
    454				if (audio_buf) {
    455					for (n = 0; n < BYTES_PER_SAMPLE; n++) {
    456						audio_buf[cdev->audio_in_buf_pos[stream]++] = usb_buf[i+n];
    457
    458						if (cdev->audio_in_buf_pos[stream] == sz)
    459							cdev->audio_in_buf_pos[stream] = 0;
    460					}
    461
    462					cdev->period_in_count[stream] += BYTES_PER_SAMPLE;
    463				}
    464
    465				i += BYTES_PER_SAMPLE;
    466
    467				if (usb_buf[i] != ((stream << 1) | c) &&
    468				    !cdev->first_packet) {
    469					if (!cdev->input_panic)
    470						dev_warn(dev, " EXPECTED: %02x got %02x, c %d, stream %d, i %d\n",
    471							 ((stream << 1) | c), usb_buf[i], c, stream, i);
    472					cdev->input_panic = 1;
    473				}
    474
    475				i++;
    476			}
    477		}
    478	}
    479
    480	if (cdev->first_packet > 0)
    481		cdev->first_packet--;
    482}
    483
    484static void read_in_urb(struct snd_usb_caiaqdev *cdev,
    485			const struct urb *urb,
    486			const struct usb_iso_packet_descriptor *iso)
    487{
    488	struct device *dev = caiaqdev_to_dev(cdev);
    489
    490	if (!cdev->streaming)
    491		return;
    492
    493	if (iso->actual_length < cdev->bpp)
    494		return;
    495
    496	switch (cdev->spec.data_alignment) {
    497	case 0:
    498		read_in_urb_mode0(cdev, urb, iso);
    499		break;
    500	case 2:
    501		read_in_urb_mode2(cdev, urb, iso);
    502		break;
    503	case 3:
    504		read_in_urb_mode3(cdev, urb, iso);
    505		break;
    506	}
    507
    508	if ((cdev->input_panic || cdev->output_panic) && !cdev->warned) {
    509		dev_warn(dev, "streaming error detected %s %s\n",
    510				cdev->input_panic ? "(input)" : "",
    511				cdev->output_panic ? "(output)" : "");
    512		cdev->warned = 1;
    513	}
    514}
    515
    516static void fill_out_urb_mode_0(struct snd_usb_caiaqdev *cdev,
    517				struct urb *urb,
    518				const struct usb_iso_packet_descriptor *iso)
    519{
    520	unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
    521	struct snd_pcm_substream *sub;
    522	int stream, i;
    523
    524	for (i = 0; i < iso->length;) {
    525		for (stream = 0; stream < cdev->n_streams; stream++, i++) {
    526			sub = cdev->sub_playback[stream];
    527			if (sub) {
    528				struct snd_pcm_runtime *rt = sub->runtime;
    529				char *audio_buf = rt->dma_area;
    530				int sz = frames_to_bytes(rt, rt->buffer_size);
    531				usb_buf[i] =
    532					audio_buf[cdev->audio_out_buf_pos[stream]];
    533				cdev->period_out_count[stream]++;
    534				cdev->audio_out_buf_pos[stream]++;
    535				if (cdev->audio_out_buf_pos[stream] == sz)
    536					cdev->audio_out_buf_pos[stream] = 0;
    537			} else
    538				usb_buf[i] = 0;
    539		}
    540
    541		/* fill in the check bytes */
    542		if (cdev->spec.data_alignment == 2 &&
    543		    i % (cdev->n_streams * BYTES_PER_SAMPLE_USB) ==
    544		        (cdev->n_streams * CHANNELS_PER_STREAM))
    545			for (stream = 0; stream < cdev->n_streams; stream++, i++)
    546				usb_buf[i] = MAKE_CHECKBYTE(cdev, stream, i);
    547	}
    548}
    549
    550static void fill_out_urb_mode_3(struct snd_usb_caiaqdev *cdev,
    551				struct urb *urb,
    552				const struct usb_iso_packet_descriptor *iso)
    553{
    554	unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
    555	int stream, i;
    556
    557	for (i = 0; i < iso->length;) {
    558		for (stream = 0; stream < cdev->n_streams; stream++) {
    559			struct snd_pcm_substream *sub = cdev->sub_playback[stream];
    560			char *audio_buf = NULL;
    561			int c, n, sz = 0;
    562
    563			if (sub) {
    564				struct snd_pcm_runtime *rt = sub->runtime;
    565				audio_buf = rt->dma_area;
    566				sz = frames_to_bytes(rt, rt->buffer_size);
    567			}
    568
    569			for (c = 0; c < CHANNELS_PER_STREAM; c++) {
    570				for (n = 0; n < BYTES_PER_SAMPLE; n++) {
    571					if (audio_buf) {
    572						usb_buf[i+n] = audio_buf[cdev->audio_out_buf_pos[stream]++];
    573
    574						if (cdev->audio_out_buf_pos[stream] == sz)
    575							cdev->audio_out_buf_pos[stream] = 0;
    576					} else {
    577						usb_buf[i+n] = 0;
    578					}
    579				}
    580
    581				if (audio_buf)
    582					cdev->period_out_count[stream] += BYTES_PER_SAMPLE;
    583
    584				i += BYTES_PER_SAMPLE;
    585
    586				/* fill in the check byte pattern */
    587				usb_buf[i++] = (stream << 1) | c;
    588			}
    589		}
    590	}
    591}
    592
    593static inline void fill_out_urb(struct snd_usb_caiaqdev *cdev,
    594				struct urb *urb,
    595				const struct usb_iso_packet_descriptor *iso)
    596{
    597	switch (cdev->spec.data_alignment) {
    598	case 0:
    599	case 2:
    600		fill_out_urb_mode_0(cdev, urb, iso);
    601		break;
    602	case 3:
    603		fill_out_urb_mode_3(cdev, urb, iso);
    604		break;
    605	}
    606}
    607
    608static void read_completed(struct urb *urb)
    609{
    610	struct snd_usb_caiaq_cb_info *info = urb->context;
    611	struct snd_usb_caiaqdev *cdev;
    612	struct device *dev;
    613	struct urb *out = NULL;
    614	int i, frame, len, send_it = 0, outframe = 0;
    615	unsigned long flags;
    616	size_t offset = 0;
    617
    618	if (urb->status || !info)
    619		return;
    620
    621	cdev = info->cdev;
    622	dev = caiaqdev_to_dev(cdev);
    623
    624	if (!cdev->streaming)
    625		return;
    626
    627	/* find an unused output urb that is unused */
    628	for (i = 0; i < N_URBS; i++)
    629		if (test_and_set_bit(i, &cdev->outurb_active_mask) == 0) {
    630			out = cdev->data_urbs_out[i];
    631			break;
    632		}
    633
    634	if (!out) {
    635		dev_err(dev, "Unable to find an output urb to use\n");
    636		goto requeue;
    637	}
    638
    639	/* read the recently received packet and send back one which has
    640	 * the same layout */
    641	for (frame = 0; frame < FRAMES_PER_URB; frame++) {
    642		if (urb->iso_frame_desc[frame].status)
    643			continue;
    644
    645		len = urb->iso_frame_desc[outframe].actual_length;
    646		out->iso_frame_desc[outframe].length = len;
    647		out->iso_frame_desc[outframe].actual_length = 0;
    648		out->iso_frame_desc[outframe].offset = offset;
    649		offset += len;
    650
    651		if (len > 0) {
    652			spin_lock_irqsave(&cdev->spinlock, flags);
    653			fill_out_urb(cdev, out, &out->iso_frame_desc[outframe]);
    654			read_in_urb(cdev, urb, &urb->iso_frame_desc[frame]);
    655			spin_unlock_irqrestore(&cdev->spinlock, flags);
    656			check_for_elapsed_periods(cdev, cdev->sub_playback);
    657			check_for_elapsed_periods(cdev, cdev->sub_capture);
    658			send_it = 1;
    659		}
    660
    661		outframe++;
    662	}
    663
    664	if (send_it) {
    665		out->number_of_packets = outframe;
    666		usb_submit_urb(out, GFP_ATOMIC);
    667	} else {
    668		struct snd_usb_caiaq_cb_info *oinfo = out->context;
    669		clear_bit(oinfo->index, &cdev->outurb_active_mask);
    670	}
    671
    672requeue:
    673	/* re-submit inbound urb */
    674	for (frame = 0; frame < FRAMES_PER_URB; frame++) {
    675		urb->iso_frame_desc[frame].offset = BYTES_PER_FRAME * frame;
    676		urb->iso_frame_desc[frame].length = BYTES_PER_FRAME;
    677		urb->iso_frame_desc[frame].actual_length = 0;
    678	}
    679
    680	urb->number_of_packets = FRAMES_PER_URB;
    681	usb_submit_urb(urb, GFP_ATOMIC);
    682}
    683
    684static void write_completed(struct urb *urb)
    685{
    686	struct snd_usb_caiaq_cb_info *info = urb->context;
    687	struct snd_usb_caiaqdev *cdev = info->cdev;
    688
    689	if (!cdev->output_running) {
    690		cdev->output_running = 1;
    691		wake_up(&cdev->prepare_wait_queue);
    692	}
    693
    694	clear_bit(info->index, &cdev->outurb_active_mask);
    695}
    696
    697static struct urb **alloc_urbs(struct snd_usb_caiaqdev *cdev, int dir, int *ret)
    698{
    699	int i, frame;
    700	struct urb **urbs;
    701	struct usb_device *usb_dev = cdev->chip.dev;
    702	unsigned int pipe;
    703
    704	pipe = (dir == SNDRV_PCM_STREAM_PLAYBACK) ?
    705		usb_sndisocpipe(usb_dev, ENDPOINT_PLAYBACK) :
    706		usb_rcvisocpipe(usb_dev, ENDPOINT_CAPTURE);
    707
    708	urbs = kmalloc_array(N_URBS, sizeof(*urbs), GFP_KERNEL);
    709	if (!urbs) {
    710		*ret = -ENOMEM;
    711		return NULL;
    712	}
    713
    714	for (i = 0; i < N_URBS; i++) {
    715		urbs[i] = usb_alloc_urb(FRAMES_PER_URB, GFP_KERNEL);
    716		if (!urbs[i]) {
    717			*ret = -ENOMEM;
    718			return urbs;
    719		}
    720
    721		urbs[i]->transfer_buffer =
    722			kmalloc_array(BYTES_PER_FRAME, FRAMES_PER_URB,
    723				      GFP_KERNEL);
    724		if (!urbs[i]->transfer_buffer) {
    725			*ret = -ENOMEM;
    726			return urbs;
    727		}
    728
    729		for (frame = 0; frame < FRAMES_PER_URB; frame++) {
    730			struct usb_iso_packet_descriptor *iso =
    731				&urbs[i]->iso_frame_desc[frame];
    732
    733			iso->offset = BYTES_PER_FRAME * frame;
    734			iso->length = BYTES_PER_FRAME;
    735		}
    736
    737		urbs[i]->dev = usb_dev;
    738		urbs[i]->pipe = pipe;
    739		urbs[i]->transfer_buffer_length = FRAMES_PER_URB
    740						* BYTES_PER_FRAME;
    741		urbs[i]->context = &cdev->data_cb_info[i];
    742		urbs[i]->interval = 1;
    743		urbs[i]->number_of_packets = FRAMES_PER_URB;
    744		urbs[i]->complete = (dir == SNDRV_PCM_STREAM_CAPTURE) ?
    745					read_completed : write_completed;
    746	}
    747
    748	*ret = 0;
    749	return urbs;
    750}
    751
    752static void free_urbs(struct urb **urbs)
    753{
    754	int i;
    755
    756	if (!urbs)
    757		return;
    758
    759	for (i = 0; i < N_URBS; i++) {
    760		if (!urbs[i])
    761			continue;
    762
    763		usb_kill_urb(urbs[i]);
    764		kfree(urbs[i]->transfer_buffer);
    765		usb_free_urb(urbs[i]);
    766	}
    767
    768	kfree(urbs);
    769}
    770
    771int snd_usb_caiaq_audio_init(struct snd_usb_caiaqdev *cdev)
    772{
    773	int i, ret;
    774	struct device *dev = caiaqdev_to_dev(cdev);
    775
    776	cdev->n_audio_in  = max(cdev->spec.num_analog_audio_in,
    777			       cdev->spec.num_digital_audio_in) /
    778				CHANNELS_PER_STREAM;
    779	cdev->n_audio_out = max(cdev->spec.num_analog_audio_out,
    780			       cdev->spec.num_digital_audio_out) /
    781				CHANNELS_PER_STREAM;
    782	cdev->n_streams = max(cdev->n_audio_in, cdev->n_audio_out);
    783
    784	dev_dbg(dev, "cdev->n_audio_in = %d\n", cdev->n_audio_in);
    785	dev_dbg(dev, "cdev->n_audio_out = %d\n", cdev->n_audio_out);
    786	dev_dbg(dev, "cdev->n_streams = %d\n", cdev->n_streams);
    787
    788	if (cdev->n_streams > MAX_STREAMS) {
    789		dev_err(dev, "unable to initialize device, too many streams.\n");
    790		return -EINVAL;
    791	}
    792
    793	if (cdev->n_streams < 1) {
    794		dev_err(dev, "bogus number of streams: %d\n", cdev->n_streams);
    795		return -EINVAL;
    796	}
    797
    798	ret = snd_pcm_new(cdev->chip.card, cdev->product_name, 0,
    799			cdev->n_audio_out, cdev->n_audio_in, &cdev->pcm);
    800
    801	if (ret < 0) {
    802		dev_err(dev, "snd_pcm_new() returned %d\n", ret);
    803		return ret;
    804	}
    805
    806	cdev->pcm->private_data = cdev;
    807	strscpy(cdev->pcm->name, cdev->product_name, sizeof(cdev->pcm->name));
    808
    809	memset(cdev->sub_playback, 0, sizeof(cdev->sub_playback));
    810	memset(cdev->sub_capture, 0, sizeof(cdev->sub_capture));
    811
    812	memcpy(&cdev->pcm_info, &snd_usb_caiaq_pcm_hardware,
    813			sizeof(snd_usb_caiaq_pcm_hardware));
    814
    815	/* setup samplerates */
    816	cdev->samplerates = cdev->pcm_info.rates;
    817	switch (cdev->chip.usb_id) {
    818	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1):
    819	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3):
    820	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_SESSIONIO):
    821	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_GUITARRIGMOBILE):
    822		cdev->samplerates |= SNDRV_PCM_RATE_192000;
    823		fallthrough;
    824	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO2DJ):
    825	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ):
    826	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ):
    827	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORAUDIO2):
    828		cdev->samplerates |= SNDRV_PCM_RATE_88200;
    829		break;
    830	}
    831
    832	snd_pcm_set_ops(cdev->pcm, SNDRV_PCM_STREAM_PLAYBACK,
    833				&snd_usb_caiaq_ops);
    834	snd_pcm_set_ops(cdev->pcm, SNDRV_PCM_STREAM_CAPTURE,
    835				&snd_usb_caiaq_ops);
    836	snd_pcm_set_managed_buffer_all(cdev->pcm, SNDRV_DMA_TYPE_VMALLOC,
    837				       NULL, 0, 0);
    838
    839	cdev->data_cb_info =
    840		kmalloc_array(N_URBS, sizeof(struct snd_usb_caiaq_cb_info),
    841					GFP_KERNEL);
    842
    843	if (!cdev->data_cb_info)
    844		return -ENOMEM;
    845
    846	cdev->outurb_active_mask = 0;
    847	BUILD_BUG_ON(N_URBS > (sizeof(cdev->outurb_active_mask) * 8));
    848
    849	for (i = 0; i < N_URBS; i++) {
    850		cdev->data_cb_info[i].cdev = cdev;
    851		cdev->data_cb_info[i].index = i;
    852	}
    853
    854	cdev->data_urbs_in = alloc_urbs(cdev, SNDRV_PCM_STREAM_CAPTURE, &ret);
    855	if (ret < 0) {
    856		kfree(cdev->data_cb_info);
    857		free_urbs(cdev->data_urbs_in);
    858		return ret;
    859	}
    860
    861	cdev->data_urbs_out = alloc_urbs(cdev, SNDRV_PCM_STREAM_PLAYBACK, &ret);
    862	if (ret < 0) {
    863		kfree(cdev->data_cb_info);
    864		free_urbs(cdev->data_urbs_in);
    865		free_urbs(cdev->data_urbs_out);
    866		return ret;
    867	}
    868
    869	return 0;
    870}
    871
    872void snd_usb_caiaq_audio_free(struct snd_usb_caiaqdev *cdev)
    873{
    874	struct device *dev = caiaqdev_to_dev(cdev);
    875
    876	dev_dbg(dev, "%s(%p)\n", __func__, cdev);
    877	stream_stop(cdev);
    878	free_urbs(cdev->data_urbs_in);
    879	free_urbs(cdev->data_urbs_out);
    880	kfree(cdev->data_cb_info);
    881}
    882