[mirror_ubuntu-hirsute-kernel.git] / drivers / media / usb / cx231xx / cx231xx-audio.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  Conexant Cx231xx audio extension
 *
 *  Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
 *       Based on em28xx driver
 */

#include "cx231xx.h"
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/sound.h>
#include <linux/spinlock.h>
#include <linux/soundcard.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/info.h>
#include <sound/initval.h>
#include <sound/control.h>
#include <media/v4l2-common.h>

static int debug;
module_param(debug, int, 0644);
MODULE_PARM_DESC(debug, "activates debug info");

static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;

static int cx231xx_isoc_audio_deinit(struct cx231xx *dev)
{
	int i;

	dev_dbg(dev->dev, "Stopping isoc\n");

	for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
		if (dev->adev.urb[i]) {
			if (!irqs_disabled())
				usb_kill_urb(dev->adev.urb[i]);
			else
				usb_unlink_urb(dev->adev.urb[i]);

			usb_free_urb(dev->adev.urb[i]);
			dev->adev.urb[i] = NULL;

			kfree(dev->adev.transfer_buffer[i]);
			dev->adev.transfer_buffer[i] = NULL;
		}
	}

	return 0;
}

static int cx231xx_bulk_audio_deinit(struct cx231xx *dev)
{
	int i;

	dev_dbg(dev->dev, "Stopping bulk\n");

	for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
		if (dev->adev.urb[i]) {
			if (!irqs_disabled())
				usb_kill_urb(dev->adev.urb[i]);
			else
				usb_unlink_urb(dev->adev.urb[i]);

			usb_free_urb(dev->adev.urb[i]);
			dev->adev.urb[i] = NULL;

			kfree(dev->adev.transfer_buffer[i]);
			dev->adev.transfer_buffer[i] = NULL;
		}
	}

	return 0;
}

static void cx231xx_audio_isocirq(struct urb *urb)
{
	struct cx231xx *dev = urb->context;
	int i;
	unsigned int oldptr;
	int period_elapsed = 0;
	int status;
	unsigned char *cp;
	unsigned int stride;
	struct snd_pcm_substream *substream;
	struct snd_pcm_runtime *runtime;

	if (dev->state & DEV_DISCONNECTED)
		return;

	switch (urb->status) {
	case 0:		/* success */
	case -ETIMEDOUT:	/* NAK */
		break;
	case -ECONNRESET:	/* kill */
	case -ENOENT:
	case -ESHUTDOWN:
		return;
	default:		/* error */
		dev_dbg(dev->dev, "urb completion error %d.\n",
			urb->status);
		break;
	}

	if (atomic_read(&dev->stream_started) == 0)
		return;

	if (dev->adev.capture_pcm_substream) {
		substream = dev->adev.capture_pcm_substream;
		runtime = substream->runtime;
		stride = runtime->frame_bits >> 3;

		for (i = 0; i < urb->number_of_packets; i++) {
			unsigned long flags;
			int length = urb->iso_frame_desc[i].actual_length /
				     stride;
			cp = (unsigned char *)urb->transfer_buffer +
					      urb->iso_frame_desc[i].offset;

			if (!length)
				continue;

			oldptr = dev->adev.hwptr_done_capture;
			if (oldptr + length >= runtime->buffer_size) {
				unsigned int cnt;

				cnt = runtime->buffer_size - oldptr;
				memcpy(runtime->dma_area + oldptr * stride, cp,
				       cnt * stride);
				memcpy(runtime->dma_area, cp + cnt * stride,
				       length * stride - cnt * stride);
			} else {
				memcpy(runtime->dma_area + oldptr * stride, cp,
				       length * stride);
			}

			snd_pcm_stream_lock_irqsave(substream, flags);

			dev->adev.hwptr_done_capture += length;
			if (dev->adev.hwptr_done_capture >=
						runtime->buffer_size)
				dev->adev.hwptr_done_capture -=
						runtime->buffer_size;

			dev->adev.capture_transfer_done += length;
			if (dev->adev.capture_transfer_done >=
				runtime->period_size) {
				dev->adev.capture_transfer_done -=
						runtime->period_size;
				period_elapsed = 1;
			}
			snd_pcm_stream_unlock_irqrestore(substream, flags);
		}
		if (period_elapsed)
			snd_pcm_period_elapsed(substream);
	}
	urb->status = 0;

	status = usb_submit_urb(urb, GFP_ATOMIC);
	if (status < 0) {
		dev_err(dev->dev,
			"resubmit of audio urb failed (error=%i)\n",
			status);
	}
	return;
}

static void cx231xx_audio_bulkirq(struct urb *urb)
{
	struct cx231xx *dev = urb->context;
	unsigned int oldptr;
	int period_elapsed = 0;
	int status;
	unsigned char *cp;
	unsigned int stride;
	struct snd_pcm_substream *substream;
	struct snd_pcm_runtime *runtime;

	if (dev->state & DEV_DISCONNECTED)
		return;

	switch (urb->status) {
	case 0:		/* success */
	case -ETIMEDOUT:	/* NAK */
		break;
	case -ECONNRESET:	/* kill */
	case -ENOENT:
	case -ESHUTDOWN:
		return;
	default:		/* error */
		dev_dbg(dev->dev, "urb completion error %d.\n",
			urb->status);
		break;
	}

	if (atomic_read(&dev->stream_started) == 0)
		return;

	if (dev->adev.capture_pcm_substream) {
		substream = dev->adev.capture_pcm_substream;
		runtime = substream->runtime;
		stride = runtime->frame_bits >> 3;

		if (1) {
			unsigned long flags;
			int length = urb->actual_length /
				     stride;
			cp = (unsigned char *)urb->transfer_buffer;

			oldptr = dev->adev.hwptr_done_capture;
			if (oldptr + length >= runtime->buffer_size) {
				unsigned int cnt;

				cnt = runtime->buffer_size - oldptr;
				memcpy(runtime->dma_area + oldptr * stride, cp,
				       cnt * stride);
				memcpy(runtime->dma_area, cp + cnt * stride,
				       length * stride - cnt * stride);
			} else {
				memcpy(runtime->dma_area + oldptr * stride, cp,
				       length * stride);
			}

			snd_pcm_stream_lock_irqsave(substream, flags);

			dev->adev.hwptr_done_capture += length;
			if (dev->adev.hwptr_done_capture >=
						runtime->buffer_size)
				dev->adev.hwptr_done_capture -=
						runtime->buffer_size;

			dev->adev.capture_transfer_done += length;
			if (dev->adev.capture_transfer_done >=
				runtime->period_size) {
				dev->adev.capture_transfer_done -=
						runtime->period_size;
				period_elapsed = 1;
			}
			snd_pcm_stream_unlock_irqrestore(substream, flags);
		}
		if (period_elapsed)
			snd_pcm_period_elapsed(substream);
	}
	urb->status = 0;

	status = usb_submit_urb(urb, GFP_ATOMIC);
	if (status < 0) {
		dev_err(dev->dev,
			"resubmit of audio urb failed (error=%i)\n",
			status);
	}
	return;
}

static int cx231xx_init_audio_isoc(struct cx231xx *dev)
{
	int i, errCode;
	int sb_size;

	dev_dbg(dev->dev,
		"%s: Starting ISO AUDIO transfers\n", __func__);

	if (dev->state & DEV_DISCONNECTED)
		return -ENODEV;

	sb_size = CX231XX_ISO_NUM_AUDIO_PACKETS * dev->adev.max_pkt_size;

	for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
		struct urb *urb;
		int j, k;

		dev->adev.transfer_buffer[i] = kmalloc(sb_size, GFP_ATOMIC);
		if (!dev->adev.transfer_buffer[i])
			return -ENOMEM;

		memset(dev->adev.transfer_buffer[i], 0x80, sb_size);
		urb = usb_alloc_urb(CX231XX_ISO_NUM_AUDIO_PACKETS, GFP_ATOMIC);
		if (!urb) {
			for (j = 0; j < i; j++) {
				usb_free_urb(dev->adev.urb[j]);
				kfree(dev->adev.transfer_buffer[j]);
			}
			return -ENOMEM;
		}

		urb->dev = dev->udev;
		urb->context = dev;
		urb->pipe = usb_rcvisocpipe(dev->udev,
						dev->adev.end_point_addr);
		urb->transfer_flags = URB_ISO_ASAP;
		urb->transfer_buffer = dev->adev.transfer_buffer[i];
		urb->interval = 1;
		urb->complete = cx231xx_audio_isocirq;
		urb->number_of_packets = CX231XX_ISO_NUM_AUDIO_PACKETS;
		urb->transfer_buffer_length = sb_size;

		for (j = k = 0; j < CX231XX_ISO_NUM_AUDIO_PACKETS;
			j++, k += dev->adev.max_pkt_size) {
			urb->iso_frame_desc[j].offset = k;
			urb->iso_frame_desc[j].length = dev->adev.max_pkt_size;
		}
		dev->adev.urb[i] = urb;
	}

	for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
		errCode = usb_submit_urb(dev->adev.urb[i], GFP_ATOMIC);
		if (errCode < 0) {
			cx231xx_isoc_audio_deinit(dev);
			return errCode;
		}
	}

	return errCode;
}

static int cx231xx_init_audio_bulk(struct cx231xx *dev)
{
	int i, errCode;
	int sb_size;

	dev_dbg(dev->dev,
		"%s: Starting BULK AUDIO transfers\n", __func__);

	if (dev->state & DEV_DISCONNECTED)
		return -ENODEV;

	sb_size = CX231XX_NUM_AUDIO_PACKETS * dev->adev.max_pkt_size;

	for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
		struct urb *urb;
		int j;

		dev->adev.transfer_buffer[i] = kmalloc(sb_size, GFP_ATOMIC);
		if (!dev->adev.transfer_buffer[i])
			return -ENOMEM;

		memset(dev->adev.transfer_buffer[i], 0x80, sb_size);
		urb = usb_alloc_urb(CX231XX_NUM_AUDIO_PACKETS, GFP_ATOMIC);
		if (!urb) {
			for (j = 0; j < i; j++) {
				usb_free_urb(dev->adev.urb[j]);
				kfree(dev->adev.transfer_buffer[j]);
			}
			return -ENOMEM;
		}

		urb->dev = dev->udev;
		urb->context = dev;
		urb->pipe = usb_rcvbulkpipe(dev->udev,
						dev->adev.end_point_addr);
		urb->transfer_flags = 0;
		urb->transfer_buffer = dev->adev.transfer_buffer[i];
		urb->complete = cx231xx_audio_bulkirq;
		urb->transfer_buffer_length = sb_size;

		dev->adev.urb[i] = urb;

	}

	for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
		errCode = usb_submit_urb(dev->adev.urb[i], GFP_ATOMIC);
		if (errCode < 0) {
			cx231xx_bulk_audio_deinit(dev);
			return errCode;
		}
	}

	return errCode;
}

static const struct snd_pcm_hardware snd_cx231xx_hw_capture = {
	.info = SNDRV_PCM_INFO_BLOCK_TRANSFER	|
	    SNDRV_PCM_INFO_MMAP			|
	    SNDRV_PCM_INFO_INTERLEAVED		|
	    SNDRV_PCM_INFO_MMAP_VALID,

	.formats = SNDRV_PCM_FMTBIT_S16_LE,

	.rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_KNOT,

	.rate_min = 48000,
	.rate_max = 48000,
	.channels_min = 2,
	.channels_max = 2,
	.buffer_bytes_max = 62720 * 8,	/* just about the value in usbaudio.c */
	.period_bytes_min = 64,		/* 12544/2, */
	.period_bytes_max = 12544,
	.periods_min = 2,
	.periods_max = 98,		/* 12544, */
};

static int snd_cx231xx_capture_open(struct snd_pcm_substream *substream)
{
	struct cx231xx *dev = snd_pcm_substream_chip(substream);
	struct snd_pcm_runtime *runtime = substream->runtime;
	int ret = 0;

	dev_dbg(dev->dev,
		"opening device and trying to acquire exclusive lock\n");

	if (dev->state & DEV_DISCONNECTED) {
		dev_err(dev->dev,
			"Can't open. the device was removed.\n");
		return -ENODEV;
	}

	/* set alternate setting for audio interface */
	/* 1 - 48000 samples per sec */
	mutex_lock(&dev->lock);
	if (dev->USE_ISO)
		ret = cx231xx_set_alt_setting(dev, INDEX_AUDIO, 1);
	else
		ret = cx231xx_set_alt_setting(dev, INDEX_AUDIO, 0);
	mutex_unlock(&dev->lock);
	if (ret < 0) {
		dev_err(dev->dev,
			"failed to set alternate setting !\n");

		return ret;
	}

	runtime->hw = snd_cx231xx_hw_capture;

	mutex_lock(&dev->lock);
	/* inform hardware to start streaming */
	ret = cx231xx_capture_start(dev, 1, Audio);

	dev->adev.users++;
	mutex_unlock(&dev->lock);

	snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
	dev->adev.capture_pcm_substream = substream;
	runtime->private_data = dev;

	return 0;
}

static int snd_cx231xx_pcm_close(struct snd_pcm_substream *substream)
{
	int ret;
	struct cx231xx *dev = snd_pcm_substream_chip(substream);

	dev_dbg(dev->dev, "closing device\n");

	/* inform hardware to stop streaming */
	mutex_lock(&dev->lock);
	ret = cx231xx_capture_start(dev, 0, Audio);

	/* set alternate setting for audio interface */
	/* 1 - 48000 samples per sec */
	ret = cx231xx_set_alt_setting(dev, INDEX_AUDIO, 0);
	if (ret < 0) {
		dev_err(dev->dev,
			"failed to set alternate setting !\n");

		mutex_unlock(&dev->lock);
		return ret;
	}

	dev->adev.users--;
	mutex_unlock(&dev->lock);

	if (dev->adev.users == 0 && dev->adev.shutdown == 1) {
		dev_dbg(dev->dev, "audio users: %d\n", dev->adev.users);
		dev_dbg(dev->dev, "disabling audio stream!\n");
		dev->adev.shutdown = 0;
		dev_dbg(dev->dev, "released lock\n");
		if (atomic_read(&dev->stream_started) > 0) {
			atomic_set(&dev->stream_started, 0);
			schedule_work(&dev->wq_trigger);
		}
	}
	return 0;
}

static int snd_cx231xx_prepare(struct snd_pcm_substream *substream)
{
	struct cx231xx *dev = snd_pcm_substream_chip(substream);

	dev->adev.hwptr_done_capture = 0;
	dev->adev.capture_transfer_done = 0;

	return 0;
}

static void audio_trigger(struct work_struct *work)
{
	struct cx231xx *dev = container_of(work, struct cx231xx, wq_trigger);

	if (atomic_read(&dev->stream_started)) {
		dev_dbg(dev->dev, "starting capture");
		if (is_fw_load(dev) == 0)
			cx25840_call(dev, core, load_fw);
		if (dev->USE_ISO)
			cx231xx_init_audio_isoc(dev);
		else
			cx231xx_init_audio_bulk(dev);
	} else {
		dev_dbg(dev->dev, "stopping capture");
		cx231xx_isoc_audio_deinit(dev);
	}
}

static int snd_cx231xx_capture_trigger(struct snd_pcm_substream *substream,
				       int cmd)
{
	struct cx231xx *dev = snd_pcm_substream_chip(substream);
	int retval = 0;

	if (dev->state & DEV_DISCONNECTED)
		return -ENODEV;

	spin_lock(&dev->adev.slock);
	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
		atomic_set(&dev->stream_started, 1);
		break;
	case SNDRV_PCM_TRIGGER_STOP:
		atomic_set(&dev->stream_started, 0);
		break;
	default:
		retval = -EINVAL;
		break;
	}
	spin_unlock(&dev->adev.slock);

	schedule_work(&dev->wq_trigger);

	return retval;
}

static snd_pcm_uframes_t snd_cx231xx_capture_pointer(struct snd_pcm_substream
						     *substream)
{
	struct cx231xx *dev;
	unsigned long flags;
	snd_pcm_uframes_t hwptr_done;

	dev = snd_pcm_substream_chip(substream);

	spin_lock_irqsave(&dev->adev.slock, flags);
	hwptr_done = dev->adev.hwptr_done_capture;
	spin_unlock_irqrestore(&dev->adev.slock, flags);

	return hwptr_done;
}

static const struct snd_pcm_ops snd_cx231xx_pcm_capture = {
	.open = snd_cx231xx_capture_open,
	.close = snd_cx231xx_pcm_close,
	.prepare = snd_cx231xx_prepare,
	.trigger = snd_cx231xx_capture_trigger,
	.pointer = snd_cx231xx_capture_pointer,
};

static int cx231xx_audio_init(struct cx231xx *dev)
{
	struct cx231xx_audio *adev = &dev->adev;
	struct snd_pcm *pcm;
	struct snd_card *card;
	static int devnr;
	int err;
	struct usb_interface *uif;
	int i, isoc_pipe = 0;

	if (dev->has_alsa_audio != 1) {
		/* This device does not support the extension (in this case
		   the device is expecting the snd-usb-audio module or
		   doesn't have analog audio support at all) */
		return 0;
	}

	dev_dbg(dev->dev,
		"probing for cx231xx non standard usbaudio\n");

	err = snd_card_new(dev->dev, index[devnr], "Cx231xx Audio",
			   THIS_MODULE, 0, &card);
	if (err < 0)
		return err;

	spin_lock_init(&adev->slock);
	err = snd_pcm_new(card, "Cx231xx Audio", 0, 0, 1, &pcm);
	if (err < 0)
		goto err_free_card;

	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
			&snd_cx231xx_pcm_capture);
	snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0);
	pcm->info_flags = 0;
	pcm->private_data = dev;
	strscpy(pcm->name, "Conexant cx231xx Capture", sizeof(pcm->name));
	strscpy(card->driver, "Cx231xx-Audio", sizeof(card->driver));
	strscpy(card->shortname, "Cx231xx Audio", sizeof(card->shortname));
	strscpy(card->longname, "Conexant cx231xx Audio", sizeof(card->longname));

	INIT_WORK(&dev->wq_trigger, audio_trigger);

	err = snd_card_register(card);
	if (err < 0)
		goto err_free_card;

	adev->sndcard = card;
	adev->udev = dev->udev;

	/* compute alternate max packet sizes for Audio */
	uif =
	    dev->udev->actconfig->interface[dev->current_pcb_config.
					    hs_config_info[0].interface_info.
					    audio_index + 1];

	if (uif->altsetting[0].desc.bNumEndpoints < isoc_pipe + 1) {
		err = -ENODEV;
		goto err_free_card;
	}

	adev->end_point_addr =
	    uif->altsetting[0].endpoint[isoc_pipe].desc.
			bEndpointAddress;

	adev->num_alt = uif->num_altsetting;
	dev_info(dev->dev,
		"audio EndPoint Addr 0x%x, Alternate settings: %i\n",
		adev->end_point_addr, adev->num_alt);
	adev->alt_max_pkt_size = kmalloc_array(32, adev->num_alt, GFP_KERNEL);
	if (!adev->alt_max_pkt_size) {
		err = -ENOMEM;
		goto err_free_card;
	}

	for (i = 0; i < adev->num_alt; i++) {
		u16 tmp;

		if (uif->altsetting[i].desc.bNumEndpoints < isoc_pipe + 1) {
			err = -ENODEV;
			goto err_free_pkt_size;
		}

		tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].desc.
				wMaxPacketSize);
		adev->alt_max_pkt_size[i] =
		    (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
		dev_dbg(dev->dev,
			"audio alternate setting %i, max size= %i\n", i,
			adev->alt_max_pkt_size[i]);
	}

	return 0;

err_free_pkt_size:
	kfree(adev->alt_max_pkt_size);
err_free_card:
	snd_card_free(card);

	return err;
}

static int cx231xx_audio_fini(struct cx231xx *dev)
{
	if (dev == NULL)
		return 0;

	if (dev->has_alsa_audio != 1) {
		/* This device does not support the extension (in this case
		   the device is expecting the snd-usb-audio module or
		   doesn't have analog audio support at all) */
		return 0;
	}

	if (dev->adev.sndcard) {
		snd_card_free_when_closed(dev->adev.sndcard);
		kfree(dev->adev.alt_max_pkt_size);
		dev->adev.sndcard = NULL;
	}

	return 0;
}

static struct cx231xx_ops audio_ops = {
	.id = CX231XX_AUDIO,
	.name = "Cx231xx Audio Extension",
	.init = cx231xx_audio_init,
	.fini = cx231xx_audio_fini,
};

static int __init cx231xx_alsa_register(void)
{
	return cx231xx_register_extension(&audio_ops);
}

static void __exit cx231xx_alsa_unregister(void)
{
	cx231xx_unregister_extension(&audio_ops);
}

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Srinivasa Deevi <srinivasa.deevi@conexant.com>");
MODULE_DESCRIPTION("Cx231xx Audio driver");

module_init(cx231xx_alsa_register);
module_exit(cx231xx_alsa_unregister);
Commit	Line	Data
c942fddf	1	// SPDX-License-Identifier: GPL-2.0-or-later
e0d3bafd SD	2	/*
	3	* Conexant Cx231xx audio extension
	4	*
	5	* Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
	6	* Based on em28xx driver
e0d3bafd SD	7	*/
e0d3bafd SD	8
589dadf2	9	#include "cx231xx.h"
e0d3bafd	10	#include <linux/kernel.h>
e0d3bafd SD	11	#include <linux/init.h>
	12	#include <linux/sound.h>
	13	#include <linux/spinlock.h>
	14	#include <linux/soundcard.h>
	15	#include <linux/slab.h>
e0d3bafd SD	16	#include <linux/module.h>
	17	#include <sound/core.h>
	18	#include <sound/pcm.h>
	19	#include <sound/pcm_params.h>
	20	#include <sound/info.h>
	21	#include <sound/initval.h>
	22	#include <sound/control.h>
	23	#include <media/v4l2-common.h>
e0d3bafd SD	24
	25	static int debug;
	26	module_param(debug, int, 0644);
	27	MODULE_PARM_DESC(debug, "activates debug info");
	28
e0d3bafd SD	29	static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
	30
	31	static int cx231xx_isoc_audio_deinit(struct cx231xx *dev)
	32	{
	33	int i;
	34
336fea92	35	dev_dbg(dev->dev, "Stopping isoc\n");
e0d3bafd	36
e0d3bafd	37	for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
84b5dbf3 MCC	38	if (dev->adev.urb[i]) {
	39	if (!irqs_disabled())
	40	usb_kill_urb(dev->adev.urb[i]);
	41	else
	42	usb_unlink_urb(dev->adev.urb[i]);
e0d3bafd	43
84b5dbf3 MCC	44	usb_free_urb(dev->adev.urb[i]);
84b5dbf3 MCC	45	dev->adev.urb[i] = NULL;
e0d3bafd	46
84b5dbf3 MCC	47	kfree(dev->adev.transfer_buffer[i]);
84b5dbf3 MCC	48	dev->adev.transfer_buffer[i] = NULL;
84b5dbf3	49	}
e0d3bafd SD	50	}
	51
	52	return 0;
	53	}
	54
64fbf444 PB	55	static int cx231xx_bulk_audio_deinit(struct cx231xx *dev)
	56	{
	57	int i;
	58
336fea92	59	dev_dbg(dev->dev, "Stopping bulk\n");
64fbf444 PB	60
	61	for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
	62	if (dev->adev.urb[i]) {
	63	if (!irqs_disabled())
	64	usb_kill_urb(dev->adev.urb[i]);
	65	else
	66	usb_unlink_urb(dev->adev.urb[i]);
	67
	68	usb_free_urb(dev->adev.urb[i]);
	69	dev->adev.urb[i] = NULL;
	70
	71	kfree(dev->adev.transfer_buffer[i]);
	72	dev->adev.transfer_buffer[i] = NULL;
	73	}
	74	}
	75
	76	return 0;
	77	}
	78
e0d3bafd SD	79	static void cx231xx_audio_isocirq(struct urb *urb)
e0d3bafd SD	80	{
84b5dbf3 MCC	81	struct cx231xx *dev = urb->context;
	82	int i;
	83	unsigned int oldptr;
	84	int period_elapsed = 0;
	85	int status;
	86	unsigned char *cp;
	87	unsigned int stride;
e0d3bafd	88	struct snd_pcm_substream *substream;
84b5dbf3 MCC	89	struct snd_pcm_runtime *runtime;
84b5dbf3 MCC	90
990862a2 MCC	91	if (dev->state & DEV_DISCONNECTED)
	92	return;
	93
84b5dbf3 MCC	94	switch (urb->status) {
	95	case 0: /* success */
	96	case -ETIMEDOUT: /* NAK */
	97	break;
	98	case -ECONNRESET: /* kill */
	99	case -ENOENT:
	100	case -ESHUTDOWN:
	101	return;
	102	default: /* error */
854bb4ec	103	dev_dbg(dev->dev, "urb completion error %d.\n",
56d8a3b0	104	urb->status);
84b5dbf3	105	break;
e0d3bafd SD	106	}
e0d3bafd SD	107
61b04cb2 MCC	108	if (atomic_read(&dev->stream_started) == 0)
	109	return;
	110
e0d3bafd SD	111	if (dev->adev.capture_pcm_substream) {
	112	substream = dev->adev.capture_pcm_substream;
	113	runtime = substream->runtime;
	114	stride = runtime->frame_bits >> 3;
	115
	116	for (i = 0; i < urb->number_of_packets; i++) {
aa53bf0b	117	unsigned long flags;
cde4362f MCC	118	int length = urb->iso_frame_desc[i].actual_length /
cde4362f MCC	119	stride;
e0d3bafd	120	cp = (unsigned char *)urb->transfer_buffer +
cde4362f	121	urb->iso_frame_desc[i].offset;
e0d3bafd SD	122
	123	if (!length)
	124	continue;
	125
	126	oldptr = dev->adev.hwptr_done_capture;
	127	if (oldptr + length >= runtime->buffer_size) {
cde4362f MCC	128	unsigned int cnt;
	129
	130	cnt = runtime->buffer_size - oldptr;
e0d3bafd SD	131	memcpy(runtime->dma_area + oldptr * stride, cp,
	132	cnt * stride);
	133	memcpy(runtime->dma_area, cp + cnt * stride,
	134	length * stride - cnt * stride);
	135	} else {
	136	memcpy(runtime->dma_area + oldptr * stride, cp,
	137	length * stride);
	138	}
	139
aa53bf0b	140	snd_pcm_stream_lock_irqsave(substream, flags);
e0d3bafd SD	141
e0d3bafd SD	142	dev->adev.hwptr_done_capture += length;
b9255176 SD	143	if (dev->adev.hwptr_done_capture >=
	144	runtime->buffer_size)
	145	dev->adev.hwptr_done_capture -=
	146	runtime->buffer_size;
e0d3bafd SD	147
e0d3bafd SD	148	dev->adev.capture_transfer_done += length;
b9255176 SD	149	if (dev->adev.capture_transfer_done >=
	150	runtime->period_size) {
	151	dev->adev.capture_transfer_done -=
	152	runtime->period_size;
e0d3bafd SD	153	period_elapsed = 1;
e0d3bafd SD	154	}
aa53bf0b	155	snd_pcm_stream_unlock_irqrestore(substream, flags);
e0d3bafd SD	156	}
	157	if (period_elapsed)
	158	snd_pcm_period_elapsed(substream);
	159	}
	160	urb->status = 0;
	161
	162	status = usb_submit_urb(urb, GFP_ATOMIC);
	163	if (status < 0) {
336fea92	164	dev_err(dev->dev,
b7085c08 MCC	165	"resubmit of audio urb failed (error=%i)\n",
b7085c08 MCC	166	status);
e0d3bafd SD	167	}
	168	return;
	169	}
	170
64fbf444 PB	171	static void cx231xx_audio_bulkirq(struct urb *urb)
	172	{
	173	struct cx231xx *dev = urb->context;
	174	unsigned int oldptr;
	175	int period_elapsed = 0;
	176	int status;
	177	unsigned char *cp;
	178	unsigned int stride;
	179	struct snd_pcm_substream *substream;
	180	struct snd_pcm_runtime *runtime;
	181
990862a2 MCC	182	if (dev->state & DEV_DISCONNECTED)
	183	return;
	184
64fbf444 PB	185	switch (urb->status) {
	186	case 0: /* success */
	187	case -ETIMEDOUT: /* NAK */
	188	break;
	189	case -ECONNRESET: /* kill */
	190	case -ENOENT:
	191	case -ESHUTDOWN:
	192	return;
	193	default: /* error */
854bb4ec	194	dev_dbg(dev->dev, "urb completion error %d.\n",
56d8a3b0	195	urb->status);
64fbf444 PB	196	break;
	197	}
	198
61b04cb2 MCC	199	if (atomic_read(&dev->stream_started) == 0)
	200	return;
	201
64fbf444 PB	202	if (dev->adev.capture_pcm_substream) {
	203	substream = dev->adev.capture_pcm_substream;
	204	runtime = substream->runtime;
	205	stride = runtime->frame_bits >> 3;
	206
	207	if (1) {
aa53bf0b	208	unsigned long flags;
64fbf444 PB	209	int length = urb->actual_length /
	210	stride;
	211	cp = (unsigned char *)urb->transfer_buffer;
	212
	213	oldptr = dev->adev.hwptr_done_capture;
	214	if (oldptr + length >= runtime->buffer_size) {
	215	unsigned int cnt;
	216
	217	cnt = runtime->buffer_size - oldptr;
	218	memcpy(runtime->dma_area + oldptr * stride, cp,
	219	cnt * stride);
	220	memcpy(runtime->dma_area, cp + cnt * stride,
	221	length * stride - cnt * stride);
	222	} else {
	223	memcpy(runtime->dma_area + oldptr * stride, cp,
	224	length * stride);
	225	}
	226
aa53bf0b	227	snd_pcm_stream_lock_irqsave(substream, flags);
64fbf444 PB	228
	229	dev->adev.hwptr_done_capture += length;
	230	if (dev->adev.hwptr_done_capture >=
	231	runtime->buffer_size)
	232	dev->adev.hwptr_done_capture -=
	233	runtime->buffer_size;
	234
	235	dev->adev.capture_transfer_done += length;
	236	if (dev->adev.capture_transfer_done >=
	237	runtime->period_size) {
	238	dev->adev.capture_transfer_done -=
	239	runtime->period_size;
	240	period_elapsed = 1;
	241	}
aa53bf0b	242	snd_pcm_stream_unlock_irqrestore(substream, flags);
64fbf444 PB	243	}
	244	if (period_elapsed)
	245	snd_pcm_period_elapsed(substream);
	246	}
	247	urb->status = 0;
	248
	249	status = usb_submit_urb(urb, GFP_ATOMIC);
	250	if (status < 0) {
336fea92	251	dev_err(dev->dev,
b7085c08 MCC	252	"resubmit of audio urb failed (error=%i)\n",
b7085c08 MCC	253	status);
64fbf444 PB	254	}
	255	return;
	256	}
	257
e0d3bafd SD	258	static int cx231xx_init_audio_isoc(struct cx231xx *dev)
e0d3bafd SD	259	{
84b5dbf3 MCC	260	int i, errCode;
84b5dbf3 MCC	261	int sb_size;
e0d3bafd	262
336fea92	263	dev_dbg(dev->dev,
b7085c08	264	"%s: Starting ISO AUDIO transfers\n", __func__);
e0d3bafd	265
990862a2 MCC	266	if (dev->state & DEV_DISCONNECTED)
	267	return -ENODEV;
	268
64fbf444	269	sb_size = CX231XX_ISO_NUM_AUDIO_PACKETS * dev->adev.max_pkt_size;
e0d3bafd SD	270
	271	for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
	272	struct urb *urb;
	273	int j, k;
	274
	275	dev->adev.transfer_buffer[i] = kmalloc(sb_size, GFP_ATOMIC);
	276	if (!dev->adev.transfer_buffer[i])
	277	return -ENOMEM;
	278
	279	memset(dev->adev.transfer_buffer[i], 0x80, sb_size);
64fbf444	280	urb = usb_alloc_urb(CX231XX_ISO_NUM_AUDIO_PACKETS, GFP_ATOMIC);
e0d3bafd	281	if (!urb) {
e0d3bafd SD	282	for (j = 0; j < i; j++) {
	283	usb_free_urb(dev->adev.urb[j]);
	284	kfree(dev->adev.transfer_buffer[j]);
	285	}
	286	return -ENOMEM;
	287	}
	288
	289	urb->dev = dev->udev;
	290	urb->context = dev;
b9255176 SD	291	urb->pipe = usb_rcvisocpipe(dev->udev,
b9255176 SD	292	dev->adev.end_point_addr);
cd5534be	293	urb->transfer_flags = URB_ISO_ASAP;
e0d3bafd SD	294	urb->transfer_buffer = dev->adev.transfer_buffer[i];
	295	urb->interval = 1;
	296	urb->complete = cx231xx_audio_isocirq;
64fbf444	297	urb->number_of_packets = CX231XX_ISO_NUM_AUDIO_PACKETS;
e0d3bafd SD	298	urb->transfer_buffer_length = sb_size;
e0d3bafd SD	299
64fbf444	300	for (j = k = 0; j < CX231XX_ISO_NUM_AUDIO_PACKETS;
b9255176	301	j++, k += dev->adev.max_pkt_size) {
e0d3bafd	302	urb->iso_frame_desc[j].offset = k;
84b5dbf3	303	urb->iso_frame_desc[j].length = dev->adev.max_pkt_size;
e0d3bafd SD	304	}
	305	dev->adev.urb[i] = urb;
	306	}
	307
	308	for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
	309	errCode = usb_submit_urb(dev->adev.urb[i], GFP_ATOMIC);
	310	if (errCode < 0) {
	311	cx231xx_isoc_audio_deinit(dev);
	312	return errCode;
	313	}
	314	}
	315
	316	return errCode;
	317	}
	318
64fbf444 PB	319	static int cx231xx_init_audio_bulk(struct cx231xx *dev)
	320	{
	321	int i, errCode;
	322	int sb_size;
	323
336fea92	324	dev_dbg(dev->dev,
b7085c08	325	"%s: Starting BULK AUDIO transfers\n", __func__);
64fbf444	326
990862a2 MCC	327	if (dev->state & DEV_DISCONNECTED)
	328	return -ENODEV;
	329
64fbf444 PB	330	sb_size = CX231XX_NUM_AUDIO_PACKETS * dev->adev.max_pkt_size;
	331
	332	for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
	333	struct urb *urb;
	334	int j;
	335
	336	dev->adev.transfer_buffer[i] = kmalloc(sb_size, GFP_ATOMIC);
	337	if (!dev->adev.transfer_buffer[i])
	338	return -ENOMEM;
	339
	340	memset(dev->adev.transfer_buffer[i], 0x80, sb_size);
	341	urb = usb_alloc_urb(CX231XX_NUM_AUDIO_PACKETS, GFP_ATOMIC);
	342	if (!urb) {
64fbf444 PB	343	for (j = 0; j < i; j++) {
	344	usb_free_urb(dev->adev.urb[j]);
	345	kfree(dev->adev.transfer_buffer[j]);
	346	}
	347	return -ENOMEM;
	348	}
	349
	350	urb->dev = dev->udev;
	351	urb->context = dev;
	352	urb->pipe = usb_rcvbulkpipe(dev->udev,
	353	dev->adev.end_point_addr);
cd5534be	354	urb->transfer_flags = 0;
64fbf444 PB	355	urb->transfer_buffer = dev->adev.transfer_buffer[i];
	356	urb->complete = cx231xx_audio_bulkirq;
	357	urb->transfer_buffer_length = sb_size;
	358
	359	dev->adev.urb[i] = urb;
	360
	361	}
	362
	363	for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
	364	errCode = usb_submit_urb(dev->adev.urb[i], GFP_ATOMIC);
	365	if (errCode < 0) {
	366	cx231xx_bulk_audio_deinit(dev);
	367	return errCode;
	368	}
	369	}
	370
	371	return errCode;
	372	}
	373
38c4f03a	374	static const struct snd_pcm_hardware snd_cx231xx_hw_capture = {
6e6a8b5a MCC	375	.info = SNDRV_PCM_INFO_BLOCK_TRANSFER \|
	376	SNDRV_PCM_INFO_MMAP \|
	377	SNDRV_PCM_INFO_INTERLEAVED \|
6e4f574b	378	SNDRV_PCM_INFO_MMAP_VALID,
e0d3bafd SD	379
	380	.formats = SNDRV_PCM_FMTBIT_S16_LE,
	381
	382	.rates = SNDRV_PCM_RATE_CONTINUOUS \| SNDRV_PCM_RATE_KNOT,
	383
	384	.rate_min = 48000,
	385	.rate_max = 48000,
	386	.channels_min = 2,
	387	.channels_max = 2,
	388	.buffer_bytes_max = 62720 * 8, /* just about the value in usbaudio.c */
cde4362f	389	.period_bytes_min = 64, /* 12544/2, */
e0d3bafd SD	390	.period_bytes_max = 12544,
e0d3bafd SD	391	.periods_min = 2,
cde4362f	392	.periods_max = 98, /* 12544, */
e0d3bafd SD	393	};
	394
	395	static int snd_cx231xx_capture_open(struct snd_pcm_substream *substream)
	396	{
	397	struct cx231xx *dev = snd_pcm_substream_chip(substream);
	398	struct snd_pcm_runtime *runtime = substream->runtime;
	399	int ret = 0;
	400
336fea92	401	dev_dbg(dev->dev,
56d8a3b0	402	"opening device and trying to acquire exclusive lock\n");
e0d3bafd	403
990862a2	404	if (dev->state & DEV_DISCONNECTED) {
336fea92	405	dev_err(dev->dev,
b7085c08	406	"Can't open. the device was removed.\n");
990862a2 MCC	407	return -ENODEV;
	408	}
	409
84b5dbf3	410	/* set alternate setting for audio interface */
b9255176	411	/* 1 - 48000 samples per sec */
61b04cb2	412	mutex_lock(&dev->lock);
64fbf444 PB	413	if (dev->USE_ISO)
	414	ret = cx231xx_set_alt_setting(dev, INDEX_AUDIO, 1);
	415	else
	416	ret = cx231xx_set_alt_setting(dev, INDEX_AUDIO, 0);
61b04cb2	417	mutex_unlock(&dev->lock);
84b5dbf3	418	if (ret < 0) {
336fea92	419	dev_err(dev->dev,
b7085c08	420	"failed to set alternate setting !\n");
e0d3bafd	421
84b5dbf3 MCC	422	return ret;
84b5dbf3 MCC	423	}
e0d3bafd	424
e0d3bafd SD	425	runtime->hw = snd_cx231xx_hw_capture;
e0d3bafd SD	426
84b5dbf3	427	mutex_lock(&dev->lock);
61b04cb2 MCC	428	/* inform hardware to start streaming */
	429	ret = cx231xx_capture_start(dev, 1, Audio);
	430
e0d3bafd	431	dev->adev.users++;
84b5dbf3	432	mutex_unlock(&dev->lock);
e0d3bafd SD	433
	434	snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
	435	dev->adev.capture_pcm_substream = substream;
	436	runtime->private_data = dev;
	437
	438	return 0;
	439	}
	440
	441	static int snd_cx231xx_pcm_close(struct snd_pcm_substream *substream)
	442	{
84b5dbf3	443	int ret;
e0d3bafd SD	444	struct cx231xx *dev = snd_pcm_substream_chip(substream);
e0d3bafd SD	445
336fea92	446	dev_dbg(dev->dev, "closing device\n");
e0d3bafd	447
61b04cb2 MCC	448	/* inform hardware to stop streaming */
61b04cb2 MCC	449	mutex_lock(&dev->lock);
64fbf444 PB	450	ret = cx231xx_capture_start(dev, 0, Audio);
64fbf444 PB	451
84b5dbf3	452	/* set alternate setting for audio interface */
b9255176 SD	453	/* 1 - 48000 samples per sec */
b9255176 SD	454	ret = cx231xx_set_alt_setting(dev, INDEX_AUDIO, 0);
84b5dbf3	455	if (ret < 0) {
336fea92	456	dev_err(dev->dev,
b7085c08	457	"failed to set alternate setting !\n");
e0d3bafd	458
61b04cb2	459	mutex_unlock(&dev->lock);
84b5dbf3 MCC	460	return ret;
84b5dbf3 MCC	461	}
e0d3bafd	462
84b5dbf3	463	dev->adev.users--;
e0d3bafd SD	464	mutex_unlock(&dev->lock);
	465
	466	if (dev->adev.users == 0 && dev->adev.shutdown == 1) {
336fea92 MCC	467	dev_dbg(dev->dev, "audio users: %d\n", dev->adev.users);
336fea92 MCC	468	dev_dbg(dev->dev, "disabling audio stream!\n");
e0d3bafd	469	dev->adev.shutdown = 0;
336fea92	470	dev_dbg(dev->dev, "released lock\n");
61b04cb2 MCC	471	if (atomic_read(&dev->stream_started) > 0) {
	472	atomic_set(&dev->stream_started, 0);
	473	schedule_work(&dev->wq_trigger);
	474	}
e0d3bafd SD	475	}
	476	return 0;
	477	}
	478
e0d3bafd SD	479	static int snd_cx231xx_prepare(struct snd_pcm_substream *substream)
e0d3bafd SD	480	{
64fbf444 PB	481	struct cx231xx *dev = snd_pcm_substream_chip(substream);
	482
	483	dev->adev.hwptr_done_capture = 0;
	484	dev->adev.capture_transfer_done = 0;
	485
e0d3bafd SD	486	return 0;
	487	}
	488
61b04cb2 MCC	489	static void audio_trigger(struct work_struct *work)
	490	{
	491	struct cx231xx *dev = container_of(work, struct cx231xx, wq_trigger);
	492
	493	if (atomic_read(&dev->stream_started)) {
336fea92	494	dev_dbg(dev->dev, "starting capture");
61b04cb2 MCC	495	if (is_fw_load(dev) == 0)
	496	cx25840_call(dev, core, load_fw);
	497	if (dev->USE_ISO)
	498	cx231xx_init_audio_isoc(dev);
	499	else
	500	cx231xx_init_audio_bulk(dev);
	501	} else {
336fea92	502	dev_dbg(dev->dev, "stopping capture");
61b04cb2 MCC	503	cx231xx_isoc_audio_deinit(dev);
	504	}
	505	}
	506
e0d3bafd	507	static int snd_cx231xx_capture_trigger(struct snd_pcm_substream *substream,
84b5dbf3	508	int cmd)
e0d3bafd SD	509	{
e0d3bafd SD	510	struct cx231xx *dev = snd_pcm_substream_chip(substream);
da983503	511	int retval = 0;
e0d3bafd	512
990862a2 MCC	513	if (dev->state & DEV_DISCONNECTED)
	514	return -ENODEV;
	515
84b5dbf3	516	spin_lock(&dev->adev.slock);
e0d3bafd SD	517	switch (cmd) {
e0d3bafd SD	518	case SNDRV_PCM_TRIGGER_START:
61b04cb2	519	atomic_set(&dev->stream_started, 1);
e0d3bafd SD	520	break;
e0d3bafd SD	521	case SNDRV_PCM_TRIGGER_STOP:
61b04cb2	522	atomic_set(&dev->stream_started, 0);
84b5dbf3	523	break;
e0d3bafd SD	524	default:
e0d3bafd SD	525	retval = -EINVAL;
da983503	526	break;
e0d3bafd	527	}
84b5dbf3	528	spin_unlock(&dev->adev.slock);
61b04cb2 MCC	529
	530	schedule_work(&dev->wq_trigger);
	531
da983503	532	return retval;
e0d3bafd SD	533	}
	534
	535	static snd_pcm_uframes_t snd_cx231xx_capture_pointer(struct snd_pcm_substream
84b5dbf3	536	*substream)
e0d3bafd SD	537	{
e0d3bafd SD	538	struct cx231xx *dev;
84b5dbf3	539	unsigned long flags;
e0d3bafd SD	540	snd_pcm_uframes_t hwptr_done;
	541
	542	dev = snd_pcm_substream_chip(substream);
	543
84b5dbf3	544	spin_lock_irqsave(&dev->adev.slock, flags);
e0d3bafd	545	hwptr_done = dev->adev.hwptr_done_capture;
84b5dbf3	546	spin_unlock_irqrestore(&dev->adev.slock, flags);
e0d3bafd SD	547
	548	return hwptr_done;
	549	}
	550
22511cfa	551	static const struct snd_pcm_ops snd_cx231xx_pcm_capture = {
84b5dbf3 MCC	552	.open = snd_cx231xx_capture_open,
84b5dbf3 MCC	553	.close = snd_cx231xx_pcm_close,
84b5dbf3 MCC	554	.prepare = snd_cx231xx_prepare,
	555	.trigger = snd_cx231xx_capture_trigger,
	556	.pointer = snd_cx231xx_capture_pointer,
e0d3bafd SD	557	};
	558
	559	static int cx231xx_audio_init(struct cx231xx *dev)
	560	{
	561	struct cx231xx_audio *adev = &dev->adev;
84b5dbf3 MCC	562	struct snd_pcm *pcm;
	563	struct snd_card *card;
	564	static int devnr;
	565	int err;
	566	struct usb_interface *uif;
	567	int i, isoc_pipe = 0;
e0d3bafd SD	568
	569	if (dev->has_alsa_audio != 1) {
	570	/* This device does not support the extension (in this case
	571	the device is expecting the snd-usb-audio module or
	572	doesn't have analog audio support at all) */
	573	return 0;
	574	}
	575
336fea92	576	dev_dbg(dev->dev,
b7085c08	577	"probing for cx231xx non standard usbaudio\n");
e0d3bafd	578
336fea92	579	err = snd_card_new(dev->dev, index[devnr], "Cx231xx Audio",
e7356888	580	THIS_MODULE, 0, &card);
a938b8c5 MCC	581	if (err < 0)
a938b8c5 MCC	582	return err;
e0d3bafd SD	583
	584	spin_lock_init(&adev->slock);
	585	err = snd_pcm_new(card, "Cx231xx Audio", 0, 0, 1, &pcm);
fff1abc4 JH	586	if (err < 0)
fff1abc4 JH	587	goto err_free_card;
e0d3bafd	588
84b5dbf3 MCC	589	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
84b5dbf3 MCC	590	&snd_cx231xx_pcm_capture);
355b9a0c	591	snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0);
e0d3bafd SD	592	pcm->info_flags = 0;
e0d3bafd SD	593	pcm->private_data = dev;
cc1e6315 MCC	594	strscpy(pcm->name, "Conexant cx231xx Capture", sizeof(pcm->name));
	595	strscpy(card->driver, "Cx231xx-Audio", sizeof(card->driver));
	596	strscpy(card->shortname, "Cx231xx Audio", sizeof(card->shortname));
	597	strscpy(card->longname, "Conexant cx231xx Audio", sizeof(card->longname));
e0d3bafd	598
61b04cb2 MCC	599	INIT_WORK(&dev->wq_trigger, audio_trigger);
61b04cb2 MCC	600
e0d3bafd	601	err = snd_card_register(card);
fff1abc4 JH	602	if (err < 0)
	603	goto err_free_card;
	604
e0d3bafd SD	605	adev->sndcard = card;
	606	adev->udev = dev->udev;
	607
84b5dbf3 MCC	608	/* compute alternate max packet sizes for Audio */
	609	uif =
	610	dev->udev->actconfig->interface[dev->current_pcb_config.
	611	hs_config_info[0].interface_info.
	612	audio_index + 1];
e0d3bafd	613
65f92164 JH	614	if (uif->altsetting[0].desc.bNumEndpoints < isoc_pipe + 1) {
	615	err = -ENODEV;
	616	goto err_free_card;
	617	}
	618
84b5dbf3	619	adev->end_point_addr =
69a11a32 HV	620	uif->altsetting[0].endpoint[isoc_pipe].desc.
69a11a32 HV	621	bEndpointAddress;
e0d3bafd	622
84b5dbf3	623	adev->num_alt = uif->num_altsetting;
336fea92	624	dev_info(dev->dev,
b7085c08	625	"audio EndPoint Addr 0x%x, Alternate settings: %i\n",
ed0e3729	626	adev->end_point_addr, adev->num_alt);
6da2ec56	627	adev->alt_max_pkt_size = kmalloc_array(32, adev->num_alt, GFP_KERNEL);
fff1abc4 JH	628	if (!adev->alt_max_pkt_size) {
	629	err = -ENOMEM;
	630	goto err_free_card;
	631	}
e0d3bafd	632
84b5dbf3	633	for (i = 0; i < adev->num_alt; i++) {
65f92164 JH	634	u16 tmp;
	635
	636	if (uif->altsetting[i].desc.bNumEndpoints < isoc_pipe + 1) {
	637	err = -ENODEV;
	638	goto err_free_pkt_size;
	639	}
	640
	641	tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].desc.
84b5dbf3 MCC	642	wMaxPacketSize);
	643	adev->alt_max_pkt_size[i] =
	644	(tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
336fea92	645	dev_dbg(dev->dev,
b7085c08 MCC	646	"audio alternate setting %i, max size= %i\n", i,
b7085c08 MCC	647	adev->alt_max_pkt_size[i]);
84b5dbf3	648	}
e0d3bafd SD	649
e0d3bafd SD	650	return 0;
fff1abc4	651
65f92164 JH	652	err_free_pkt_size:
65f92164 JH	653	kfree(adev->alt_max_pkt_size);
fff1abc4 JH	654	err_free_card:
	655	snd_card_free(card);
	656
	657	return err;
e0d3bafd SD	658	}
	659
	660	static int cx231xx_audio_fini(struct cx231xx *dev)
	661	{
	662	if (dev == NULL)
	663	return 0;
	664
	665	if (dev->has_alsa_audio != 1) {
	666	/* This device does not support the extension (in this case
	667	the device is expecting the snd-usb-audio module or
	668	doesn't have analog audio support at all) */
	669	return 0;
	670	}
	671
	672	if (dev->adev.sndcard) {
88c66084	673	snd_card_free_when_closed(dev->adev.sndcard);
84b5dbf3	674	kfree(dev->adev.alt_max_pkt_size);
e0d3bafd SD	675	dev->adev.sndcard = NULL;
	676	}
	677
	678	return 0;
	679	}
	680
	681	static struct cx231xx_ops audio_ops = {
84b5dbf3	682	.id = CX231XX_AUDIO,
e0d3bafd SD	683	.name = "Cx231xx Audio Extension",
	684	.init = cx231xx_audio_init,
	685	.fini = cx231xx_audio_fini,
	686	};
	687
	688	static int __init cx231xx_alsa_register(void)
	689	{
	690	return cx231xx_register_extension(&audio_ops);
	691	}
	692
	693	static void __exit cx231xx_alsa_unregister(void)
	694	{
	695	cx231xx_unregister_extension(&audio_ops);
	696	}
	697
	698	MODULE_LICENSE("GPL");
	699	MODULE_AUTHOR("Srinivasa Deevi <srinivasa.deevi@conexant.com>");
	700	MODULE_DESCRIPTION("Cx231xx Audio driver");
	701
	702	module_init(cx231xx_alsa_register);
	703	module_exit(cx231xx_alsa_unregister);