[linux-2.6-block.git] / drivers / staging / line6 / pcm.c

/*
 * Line6 Linux USB driver - 0.8.0
 *
 * Copyright (C) 2004-2009 Markus Grabner (grabner@icg.tugraz.at)
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License as
 *	published by the Free Software Foundation, version 2.
 *
 */

#include "driver.h"

#include <sound/core.h>
#include <sound/control.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>

#include "audio.h"
#include "capture.h"
#include "playback.h"
#include "pod.h"


/* trigger callback */
int snd_line6_trigger(struct snd_pcm_substream *substream, int cmd)
{
	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
	struct snd_pcm_substream *s;
	int err;
	unsigned long flags;

	spin_lock_irqsave(&line6pcm->lock_trigger, flags);
	clear_bit(BIT_PREPARED, &line6pcm->flags);

	snd_pcm_group_for_each_entry(s, substream) {
		switch (s->stream) {
		case SNDRV_PCM_STREAM_PLAYBACK:
			err = snd_line6_playback_trigger(s, cmd);

			if (err < 0) {
				spin_unlock_irqrestore(&line6pcm->lock_trigger,
						       flags);
				return err;
			}

			break;

		case SNDRV_PCM_STREAM_CAPTURE:
			err = snd_line6_capture_trigger(s, cmd);

			if (err < 0) {
				spin_unlock_irqrestore(&line6pcm->lock_trigger,
						       flags);
				return err;
			}

			break;

		default:
			dev_err(s2m(substream), "Unknown stream direction %d\n",
				s->stream);
		}
	}

	spin_unlock_irqrestore(&line6pcm->lock_trigger, flags);
	return 0;
}

/* control info callback */
static int snd_line6_control_info(struct snd_kcontrol *kcontrol,
				  struct snd_ctl_elem_info *uinfo)
{
	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	uinfo->count = 2;
	uinfo->value.integer.min = 0;
	uinfo->value.integer.max = 256;
	return 0;
}

/* control get callback */
static int snd_line6_control_get(struct snd_kcontrol *kcontrol,
				 struct snd_ctl_elem_value *ucontrol)
{
	int i;
	struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);

	for (i = 2; i--;)
		ucontrol->value.integer.value[i] = line6pcm->volume[i];

	return 0;
}

/* control put callback */
static int snd_line6_control_put(struct snd_kcontrol *kcontrol,
				 struct snd_ctl_elem_value *ucontrol)
{
	int i, changed = 0;
	struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);

	for (i = 2; i--;)
		if (line6pcm->volume[i] != ucontrol->value.integer.value[i]) {
			line6pcm->volume[i] = ucontrol->value.integer.value[i];
			changed = 1;
		}

	return changed;
}

/* control definition */
static struct snd_kcontrol_new line6_control = {
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.name = "PCM Playback Volume",
	.index = 0,
	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
	.info = snd_line6_control_info,
	.get = snd_line6_control_get,
	.put = snd_line6_control_put
};

/*
	Cleanup the PCM device.
*/
static void line6_cleanup_pcm(struct snd_pcm *pcm)
{
	int i;
	struct snd_line6_pcm *line6pcm = snd_pcm_chip(pcm);

	for (i = LINE6_ISO_BUFFERS; i--;) {
		if (line6pcm->urb_audio_out[i]) {
			usb_kill_urb(line6pcm->urb_audio_out[i]);
			usb_free_urb(line6pcm->urb_audio_out[i]);
		}
		if (line6pcm->urb_audio_in[i]) {
			usb_kill_urb(line6pcm->urb_audio_in[i]);
			usb_free_urb(line6pcm->urb_audio_in[i]);
		}
	}
}

/* create a PCM device */
static int snd_line6_new_pcm(struct snd_line6_pcm *line6pcm)
{
	struct snd_pcm *pcm;
	int err;

	err = snd_pcm_new(line6pcm->line6->card,
			 (char *)line6pcm->line6->properties->name,
			 0, 1, 1, &pcm);
	if (err < 0)
		return err;

	pcm->private_data = line6pcm;
	pcm->private_free = line6_cleanup_pcm;
	line6pcm->pcm = pcm;
	strcpy(pcm->name, line6pcm->line6->properties->name);

	/* set operators */
	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
			&snd_line6_playback_ops);
	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_line6_capture_ops);

	/* pre-allocation of buffers */
	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
					snd_dma_continuous_data(GFP_KERNEL),
					64 * 1024, 128 * 1024);

	return 0;
}

/* PCM device destructor */
static int snd_line6_pcm_free(struct snd_device *device)
{
	return 0;
}

/*
	Create and register the PCM device and mixer entries.
	Create URBs for playback and capture.
*/
int line6_init_pcm(struct usb_line6 *line6,
		   struct line6_pcm_properties *properties)
{
	static struct snd_device_ops pcm_ops = {
		.dev_free = snd_line6_pcm_free,
	};

	int err;
	int ep_read = 0, ep_write = 0;
	struct snd_line6_pcm *line6pcm;

	if (!(line6->properties->capabilities & LINE6_BIT_PCM))
		return 0;  /* skip PCM initialization and report success */

	/* initialize PCM subsystem based on product id: */
	switch (line6->product) {
	case LINE6_DEVID_BASSPODXT:
	case LINE6_DEVID_BASSPODXTLIVE:
	case LINE6_DEVID_BASSPODXTPRO:
	case LINE6_DEVID_PODXT:
	case LINE6_DEVID_PODXTLIVE:
	case LINE6_DEVID_PODXTPRO:
		ep_read  = 0x82;
		ep_write = 0x01;
		break;

	case LINE6_DEVID_PODX3:
	case LINE6_DEVID_PODX3LIVE:
		ep_read  = 0x86;
		ep_write = 0x02;
		break;

	case LINE6_DEVID_POCKETPOD:
		ep_read  = 0x82;
		ep_write = 0x02;
		break;

	case LINE6_DEVID_GUITARPORT:
	case LINE6_DEVID_TONEPORT_GX:
		ep_read  = 0x82;
		ep_write = 0x01;
		break;

	case LINE6_DEVID_TONEPORT_UX1:
		ep_read  = 0x00;
		ep_write = 0x00;
		break;

	case LINE6_DEVID_TONEPORT_UX2:
		ep_read  = 0x87;
		ep_write = 0x00;
		break;

	default:
		MISSING_CASE;
	}

	line6pcm = kzalloc(sizeof(struct snd_line6_pcm), GFP_KERNEL);

	if (line6pcm == NULL)
		return -ENOMEM;

	line6pcm->volume[0] = line6pcm->volume[1] = 128;
	line6pcm->line6 = line6;
	line6pcm->ep_audio_read = ep_read;
	line6pcm->ep_audio_write = ep_write;
	line6pcm->max_packet_size = usb_maxpacket(line6->usbdev,
						 usb_rcvintpipe(line6->usbdev,
								ep_read),
						  0);
	line6pcm->properties = properties;
	line6->line6pcm = line6pcm;

	/* PCM device: */
	err = snd_device_new(line6->card, SNDRV_DEV_PCM, line6, &pcm_ops);
	if (err < 0)
		return err;

	snd_card_set_dev(line6->card, line6->ifcdev);

	err = snd_line6_new_pcm(line6pcm);
	if (err < 0)
		return err;

	spin_lock_init(&line6pcm->lock_audio_out);
	spin_lock_init(&line6pcm->lock_audio_in);
	spin_lock_init(&line6pcm->lock_trigger);

	err = create_audio_out_urbs(line6pcm);
	if (err < 0)
		return err;

	err = create_audio_in_urbs(line6pcm);
	if (err < 0)
		return err;

	/* mixer: */
	err = snd_ctl_add(line6->card, snd_ctl_new1(&line6_control, line6pcm));
	if (err < 0)
		return err;

	return 0;
}

/* prepare pcm callback */
int snd_line6_prepare(struct snd_pcm_substream *substream)
{
	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);

	if (!test_and_set_bit(BIT_PREPARED, &line6pcm->flags)) {
		unlink_wait_clear_audio_out_urbs(line6pcm);
		line6pcm->pos_out = 0;
		line6pcm->pos_out_done = 0;

		unlink_wait_clear_audio_in_urbs(line6pcm);
		line6pcm->bytes_out = 0;
		line6pcm->pos_in_done = 0;
		line6pcm->bytes_in = 0;
	}

	return 0;
}
Commit	Line	Data
705ececd MG	1	/*
	2	* Line6 Linux USB driver - 0.8.0
	3	*
	4	* Copyright (C) 2004-2009 Markus Grabner (grabner@icg.tugraz.at)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License as
	8	* published by the Free Software Foundation, version 2.
	9	*
	10	*/
	11
	12	#include "driver.h"
	13
	14	#include <sound/core.h>
	15	#include <sound/control.h>
	16	#include <sound/pcm.h>
	17	#include <sound/pcm_params.h>
	18
	19	#include "audio.h"
	20	#include "capture.h"
	21	#include "playback.h"
	22	#include "pod.h"
	23
	24
	25	/* trigger callback */
	26	int snd_line6_trigger(struct snd_pcm_substream *substream, int cmd)
	27	{
	28	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
705ececd MG	29	struct snd_pcm_substream *s;
	30	int err;
	31	unsigned long flags;
	32
	33	spin_lock_irqsave(&line6pcm->lock_trigger, flags);
	34	clear_bit(BIT_PREPARED, &line6pcm->flags);
	35
705ececd	36	snd_pcm_group_for_each_entry(s, substream) {
68dc3dde	37	switch (s->stream) {
705ececd MG	38	case SNDRV_PCM_STREAM_PLAYBACK:
	39	err = snd_line6_playback_trigger(s, cmd);
	40
68dc3dde GKH	41	if (err < 0) {
	42	spin_unlock_irqrestore(&line6pcm->lock_trigger,
	43	flags);
705ececd MG	44	return err;
	45	}
	46
	47	break;
	48
	49	case SNDRV_PCM_STREAM_CAPTURE:
	50	err = snd_line6_capture_trigger(s, cmd);
	51
68dc3dde GKH	52	if (err < 0) {
	53	spin_unlock_irqrestore(&line6pcm->lock_trigger,
	54	flags);
705ececd MG	55	return err;
	56	}
	57
	58	break;
	59
	60	default:
68dc3dde GKH	61	dev_err(s2m(substream), "Unknown stream direction %d\n",
68dc3dde GKH	62	s->stream);
705ececd MG	63	}
	64	}
	65
	66	spin_unlock_irqrestore(&line6pcm->lock_trigger, flags);
	67	return 0;
	68	}
	69
	70	/* control info callback */
68dc3dde GKH	71	static int snd_line6_control_info(struct snd_kcontrol *kcontrol,
	72	struct snd_ctl_elem_info *uinfo)
	73	{
705ececd MG	74	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	75	uinfo->count = 2;
	76	uinfo->value.integer.min = 0;
	77	uinfo->value.integer.max = 256;
	78	return 0;
	79	}
	80
	81	/* control get callback */
68dc3dde GKH	82	static int snd_line6_control_get(struct snd_kcontrol *kcontrol,
	83	struct snd_ctl_elem_value *ucontrol)
	84	{
705ececd MG	85	int i;
	86	struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
	87
68dc3dde	88	for (i = 2; i--;)
705ececd MG	89	ucontrol->value.integer.value[i] = line6pcm->volume[i];
	90
	91	return 0;
	92	}
	93
	94	/* control put callback */
68dc3dde GKH	95	static int snd_line6_control_put(struct snd_kcontrol *kcontrol,
	96	struct snd_ctl_elem_value *ucontrol)
	97	{
705ececd MG	98	int i, changed = 0;
	99	struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
	100
68dc3dde GKH	101	for (i = 2; i--;)
68dc3dde GKH	102	if (line6pcm->volume[i] != ucontrol->value.integer.value[i]) {
705ececd MG	103	line6pcm->volume[i] = ucontrol->value.integer.value[i];
	104	changed = 1;
	105	}
	106
	107	return changed;
	108	}
	109
	110	/* control definition */
	111	static struct snd_kcontrol_new line6_control = {
	112	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	113	.name = "PCM Playback Volume",
	114	.index = 0,
	115	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
	116	.info = snd_line6_control_info,
	117	.get = snd_line6_control_get,
	118	.put = snd_line6_control_put
	119	};
	120
	121	/*
	122	Cleanup the PCM device.
	123	*/
	124	static void line6_cleanup_pcm(struct snd_pcm *pcm)
	125	{
	126	int i;
	127	struct snd_line6_pcm *line6pcm = snd_pcm_chip(pcm);
	128
68dc3dde GKH	129	for (i = LINE6_ISO_BUFFERS; i--;) {
68dc3dde GKH	130	if (line6pcm->urb_audio_out[i]) {
705ececd MG	131	usb_kill_urb(line6pcm->urb_audio_out[i]);
	132	usb_free_urb(line6pcm->urb_audio_out[i]);
	133	}
68dc3dde	134	if (line6pcm->urb_audio_in[i]) {
705ececd MG	135	usb_kill_urb(line6pcm->urb_audio_in[i]);
	136	usb_free_urb(line6pcm->urb_audio_in[i]);
	137	}
	138	}
	139	}
	140
	141	/* create a PCM device */
	142	static int snd_line6_new_pcm(struct snd_line6_pcm *line6pcm)
	143	{
	144	struct snd_pcm *pcm;
	145	int err;
	146
68dc3dde GKH	147	err = snd_pcm_new(line6pcm->line6->card,
	148	(char *)line6pcm->line6->properties->name,
	149	0, 1, 1, &pcm);
	150	if (err < 0)
705ececd MG	151	return err;
	152
	153	pcm->private_data = line6pcm;
	154	pcm->private_free = line6_cleanup_pcm;
	155	line6pcm->pcm = pcm;
	156	strcpy(pcm->name, line6pcm->line6->properties->name);
	157
	158	/* set operators */
afb9091d SB	159	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
afb9091d SB	160	&snd_line6_playback_ops);
705ececd MG	161	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_line6_capture_ops);
	162
	163	/* pre-allocation of buffers */
68dc3dde GKH	164	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
	165	snd_dma_continuous_data(GFP_KERNEL),
	166	64 * 1024, 128 * 1024);
705ececd MG	167
	168	return 0;
	169	}
	170
	171	/* PCM device destructor */
	172	static int snd_line6_pcm_free(struct snd_device *device)
	173	{
	174	return 0;
	175	}
	176
	177	/*
	178	Create and register the PCM device and mixer entries.
	179	Create URBs for playback and capture.
	180	*/
68dc3dde GKH	181	int line6_init_pcm(struct usb_line6 *line6,
68dc3dde GKH	182	struct line6_pcm_properties *properties)
705ececd MG	183	{
	184	static struct snd_device_ops pcm_ops = {
	185	.dev_free = snd_line6_pcm_free,
	186	};
	187
	188	int err;
	189	int ep_read = 0, ep_write = 0;
	190	struct snd_line6_pcm *line6pcm;
	191
68dc3dde	192	if (!(line6->properties->capabilities & LINE6_BIT_PCM))
705ececd MG	193	return 0; /* skip PCM initialization and report success */
	194
	195	/* initialize PCM subsystem based on product id: */
68dc3dde	196	switch (line6->product) {
705ececd	197	case LINE6_DEVID_BASSPODXT:
68dc3dde GKH	198	case LINE6_DEVID_BASSPODXTLIVE:
	199	case LINE6_DEVID_BASSPODXTPRO:
	200	case LINE6_DEVID_PODXT:
	201	case LINE6_DEVID_PODXTLIVE:
	202	case LINE6_DEVID_PODXTPRO:
705ececd MG	203	ep_read = 0x82;
	204	ep_write = 0x01;
	205	break;
	206
68dc3dde GKH	207	case LINE6_DEVID_PODX3:
68dc3dde GKH	208	case LINE6_DEVID_PODX3LIVE:
705ececd MG	209	ep_read = 0x86;
	210	ep_write = 0x02;
	211	break;
	212
68dc3dde	213	case LINE6_DEVID_POCKETPOD:
705ececd MG	214	ep_read = 0x82;
	215	ep_write = 0x02;
	216	break;
	217
68dc3dde	218	case LINE6_DEVID_GUITARPORT:
705ececd MG	219	case LINE6_DEVID_TONEPORT_GX:
	220	ep_read = 0x82;
	221	ep_write = 0x01;
	222	break;
	223
	224	case LINE6_DEVID_TONEPORT_UX1:
	225	ep_read = 0x00;
	226	ep_write = 0x00;
	227	break;
	228
	229	case LINE6_DEVID_TONEPORT_UX2:
	230	ep_read = 0x87;
	231	ep_write = 0x00;
	232	break;
	233
	234	default:
	235	MISSING_CASE;
	236	}
	237
	238	line6pcm = kzalloc(sizeof(struct snd_line6_pcm), GFP_KERNEL);
	239
68dc3dde	240	if (line6pcm == NULL)
705ececd MG	241	return -ENOMEM;
	242
	243	line6pcm->volume[0] = line6pcm->volume[1] = 128;
	244	line6pcm->line6 = line6;
	245	line6pcm->ep_audio_read = ep_read;
	246	line6pcm->ep_audio_write = ep_write;
68dc3dde GKH	247	line6pcm->max_packet_size = usb_maxpacket(line6->usbdev,
	248	usb_rcvintpipe(line6->usbdev,
	249	ep_read),
	250	0);
705ececd MG	251	line6pcm->properties = properties;
	252	line6->line6pcm = line6pcm;
	253
	254	/* PCM device: */
68dc3dde GKH	255	err = snd_device_new(line6->card, SNDRV_DEV_PCM, line6, &pcm_ops);
68dc3dde GKH	256	if (err < 0)
705ececd MG	257	return err;
	258
	259	snd_card_set_dev(line6->card, line6->ifcdev);
	260
68dc3dde GKH	261	err = snd_line6_new_pcm(line6pcm);
68dc3dde GKH	262	if (err < 0)
705ececd MG	263	return err;
	264
	265	spin_lock_init(&line6pcm->lock_audio_out);
	266	spin_lock_init(&line6pcm->lock_audio_in);
	267	spin_lock_init(&line6pcm->lock_trigger);
	268
68dc3dde GKH	269	err = create_audio_out_urbs(line6pcm);
68dc3dde GKH	270	if (err < 0)
705ececd MG	271	return err;
705ececd MG	272
68dc3dde GKH	273	err = create_audio_in_urbs(line6pcm);
68dc3dde GKH	274	if (err < 0)
705ececd MG	275	return err;
	276
	277	/* mixer: */
68dc3dde GKH	278	err = snd_ctl_add(line6->card, snd_ctl_new1(&line6_control, line6pcm));
68dc3dde GKH	279	if (err < 0)
705ececd MG	280	return err;
	281
	282	return 0;
	283	}
	284
	285	/* prepare pcm callback */
	286	int snd_line6_prepare(struct snd_pcm_substream *substream)
	287	{
	288	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
	289
68dc3dde	290	if (!test_and_set_bit(BIT_PREPARED, &line6pcm->flags)) {
705ececd MG	291	unlink_wait_clear_audio_out_urbs(line6pcm);
	292	line6pcm->pos_out = 0;
	293	line6pcm->pos_out_done = 0;
	294
	295	unlink_wait_clear_audio_in_urbs(line6pcm);
	296	line6pcm->bytes_out = 0;
	297	line6pcm->pos_in_done = 0;
	298	line6pcm->bytes_in = 0;
	299	}
	300
	301	return 0;
	302	}