Release 4.7 sound/usb/line6/pod.c

/*
 * Line 6 Linux USB driver
 *
 * Copyright (C) 2004-2010 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 <linux/slab.h>
#include <linux/wait.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/usb.h>

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

#include "capture.h"
#include "driver.h"
#include "playback.h"

/*
        Locate name in binary program dump
*/

#define	POD_NAME_OFFSET 0

#define	POD_NAME_LENGTH 16

/*
        Other constants
*/

#define POD_CONTROL_SIZE 0x80

#define POD_BUFSIZE_DUMPREQ 7

#define POD_STARTUP_DELAY 1000

/*
        Stages of POD startup procedure
*/
enum {
	
POD_STARTUP_INIT = 1,
	
POD_STARTUP_VERSIONREQ,
	
POD_STARTUP_WORKQUEUE,
	
POD_STARTUP_SETUP,
	
POD_STARTUP_LAST = POD_STARTUP_SETUP - 1
};

enum {
	
LINE6_BASSPODXT,
	
LINE6_BASSPODXTLIVE,
	
LINE6_BASSPODXTPRO,
	
LINE6_POCKETPOD,
	
LINE6_PODXT,
	
LINE6_PODXTLIVE_POD,
	
LINE6_PODXTPRO,
};


struct usb_line6_pod {
	/* Generic Line 6 USB data */
	
struct usb_line6 line6;

	/* Instrument monitor level */
	
int monitor_level;

	/* Timer for device initialization */
	
struct timer_list startup_timer;

	/* Work handler for device initialization */
	
struct work_struct startup_work;

	/* Current progress in startup procedure */
	
int startup_progress;

	/* Serial number of device */
	
u32 serial_number;

	/* Firmware version (x 100) */
	
int firmware_version;

	/* Device ID */
	
int device_id;
};


#define POD_SYSEX_CODE 3

#define POD_BYTES_PER_FRAME 6	
/* 24bit audio (stereo) */

/* *INDENT-OFF* */

enum {
	
POD_SYSEX_SAVE      = 0x24,
	
POD_SYSEX_SYSTEM    = 0x56,
	
POD_SYSEX_SYSTEMREQ = 0x57,
	/* POD_SYSEX_UPDATE    = 0x6c, */  /* software update! */
	
POD_SYSEX_STORE     = 0x71,
	
POD_SYSEX_FINISH    = 0x72,
	
POD_SYSEX_DUMPMEM   = 0x73,
	
POD_SYSEX_DUMP      = 0x74,
	
POD_SYSEX_DUMPREQ   = 0x75

	/* dumps entire internal memory of PODxt Pro */
	/* POD_SYSEX_DUMPMEM2  = 0x76 */
};

enum {
	
POD_MONITOR_LEVEL  = 0x04,
	
POD_SYSTEM_INVALID = 0x10000
};

/* *INDENT-ON* */

enum {
	
POD_DUMP_MEMORY = 2
};

enum {
	
POD_BUSY_READ,
	
POD_BUSY_WRITE,
	
POD_CHANNEL_DIRTY,
	
POD_SAVE_PRESSED,
	
POD_BUSY_MIDISEND
};


static struct snd_ratden pod_ratden = {
	.num_min = 78125,
	.num_max = 78125,
	.num_step = 1,
	.den = 2
};


static struct line6_pcm_properties pod_pcm_properties = {
	.playback_hw = {
				  .info = (SNDRV_PCM_INFO_MMAP |
					   SNDRV_PCM_INFO_INTERLEAVED |
					   SNDRV_PCM_INFO_BLOCK_TRANSFER |
					   SNDRV_PCM_INFO_MMAP_VALID |
					   SNDRV_PCM_INFO_PAUSE |
					   SNDRV_PCM_INFO_SYNC_START),
				  .formats = SNDRV_PCM_FMTBIT_S24_3LE,
				  .rates = SNDRV_PCM_RATE_KNOT,
				  .rate_min = 39062,
				  .rate_max = 39063,
				  .channels_min = 2,
				  .channels_max = 2,
				  .buffer_bytes_max = 60000,
				  .period_bytes_min = 64,
				  .period_bytes_max = 8192,
				  .periods_min = 1,
				  .periods_max = 1024},
	.capture_hw = {
				 .info = (SNDRV_PCM_INFO_MMAP |
					  SNDRV_PCM_INFO_INTERLEAVED |
					  SNDRV_PCM_INFO_BLOCK_TRANSFER |
					  SNDRV_PCM_INFO_MMAP_VALID |
					  SNDRV_PCM_INFO_SYNC_START),
				 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
				 .rates = SNDRV_PCM_RATE_KNOT,
				 .rate_min = 39062,
				 .rate_max = 39063,
				 .channels_min = 2,
				 .channels_max = 2,
				 .buffer_bytes_max = 60000,
				 .period_bytes_min = 64,
				 .period_bytes_max = 8192,
				 .periods_min = 1,
				 .periods_max = 1024},
	.rates = {
			    .nrats = 1,
			    .rats = &pod_ratden},
	.bytes_per_frame = POD_BYTES_PER_FRAME
};


static const char pod_version_header[] = {
	0xf2, 0x7e, 0x7f, 0x06, 0x02
};

/* forward declarations: */
static void pod_startup2(unsigned long data);
static void pod_startup3(struct usb_line6_pod *pod);



static char *pod_alloc_sysex_buffer(struct usb_line6_pod *pod, int code,
				    int size)
{
	return line6_alloc_sysex_buffer(&pod->line6, POD_SYSEX_CODE, code,
					size);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
markus grabner
markus grabner
33
100.00%
2
100.00%
Total
33
100.00%
2
100.00%

/*
        Process a completely received message.
*/


static void line6_pod_process_message(struct usb_line6 *line6)
{
	struct usb_line6_pod *pod = (struct usb_line6_pod *) line6;
	const unsigned char *buf = pod->line6.buffer_message;

	if (memcmp(buf, pod_version_header, sizeof(pod_version_header)) == 0) {
		pod->firmware_version = buf[13] * 100 + buf[14] * 10 + buf[15];
		pod->device_id = ((int)buf[8] << 16) | ((int)buf[9] << 8) |
				 (int) buf[10];
		pod_startup3(pod);
		return;
	}

	/* Only look for sysex messages from this device */
	if (buf[0] != (LINE6_SYSEX_BEGIN | LINE6_CHANNEL_DEVICE) &&
	    buf[0] != (LINE6_SYSEX_BEGIN | LINE6_CHANNEL_UNKNOWN)) {
		return;
	}
	if (memcmp(buf + 1, line6_midi_id, sizeof(line6_midi_id)) != 0)
		return;

	if (buf[5] == POD_SYSEX_SYSTEM && buf[6] == POD_MONITOR_LEVEL) {
		short value = ((int)buf[7] << 12) | ((int)buf[8] << 8) |
			      ((int)buf[9] << 4) | (int)buf[10];
		pod->monitor_level = value;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
markus grabner
markus grabner
135
57.20%
2
40.00%
stefan hajnoczi
stefan hajnoczi
86
36.44%
1
20.00%
chris rorvick
chris rorvick
15
6.36%
2
40.00%
Total
236
100.00%
5
100.00%

/*
        Send system parameter (from integer).
*/


static int pod_set_system_param_int(struct usb_line6_pod *pod, int value,
				    int code)
{
	char *sysex;
	static const int size = 5;

	sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_SYSTEM, size);
	if (!sysex)
		return -ENOMEM;
	sysex[SYSEX_DATA_OFS] = code;
	sysex[SYSEX_DATA_OFS + 1] = (value >> 12) & 0x0f;
	sysex[SYSEX_DATA_OFS + 2] = (value >> 8) & 0x0f;
	sysex[SYSEX_DATA_OFS + 3] = (value >> 4) & 0x0f;
	sysex[SYSEX_DATA_OFS + 4] = (value) & 0x0f;
	line6_send_sysex_message(&pod->line6, sysex, size);
	kfree(sysex);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
markus grabner
markus grabner
132
99.25%
2
66.67%
shawn bohrer
shawn bohrer
1
0.75%
1
33.33%
Total
133
100.00%
3
100.00%

/*
        "read" request on "serial_number" special file.
*/


static ssize_t serial_number_show(struct device *dev,
				  struct device_attribute *attr, char *buf)
{
	struct usb_interface *interface = to_usb_interface(dev);
	struct usb_line6_pod *pod = usb_get_intfdata(interface);

	return sprintf(buf, "%u\n", pod->serial_number);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
markus grabner
markus grabner
45
86.54%
1
25.00%
greg kroah-hartman
greg kroah-hartman
6
11.54%
2
50.00%
chris rorvick
chris rorvick
1
1.92%
1
25.00%
Total
52
100.00%
4
100.00%

/*
        "read" request on "firmware_version" special file.
*/


static ssize_t firmware_version_show(struct device *dev,
				     struct device_attribute *attr, char *buf)
{
	struct usb_interface *interface = to_usb_interface(dev);
	struct usb_line6_pod *pod = usb_get_intfdata(interface);

	return sprintf(buf, "%d.%02d\n", pod->firmware_version / 100,
		       pod->firmware_version % 100);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
markus grabner
markus grabner
54
90.00%
1
33.33%
greg kroah-hartman
greg kroah-hartman
6
10.00%
2
66.67%
Total
60
100.00%
3
100.00%

/*
        "read" request on "device_id" special file.
*/


static ssize_t device_id_show(struct device *dev,
			      struct device_attribute *attr, char *buf)
{
	struct usb_interface *interface = to_usb_interface(dev);
	struct usb_line6_pod *pod = usb_get_intfdata(interface);

	return sprintf(buf, "%d\n", pod->device_id);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
markus grabner
markus grabner
46
88.46%
1
33.33%
greg kroah-hartman
greg kroah-hartman
6
11.54%
2
66.67%
Total
52
100.00%
3
100.00%

/*
        POD startup procedure.
        This is a sequence of functions with special requirements (e.g., must
        not run immediately after initialization, must not run in interrupt
        context). After the last one has finished, the device is ready to use.
*/



static void pod_startup1(struct usb_line6_pod *pod)
{
	CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_INIT);

	/* delay startup procedure: */
	line6_start_timer(&pod->startup_timer, POD_STARTUP_DELAY, pod_startup2,
			  (unsigned long)pod);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
markus grabner
markus grabner
39
100.00%
3
100.00%
Total
39
100.00%
3
100.00%



static void pod_startup2(unsigned long data)
{
	struct usb_line6_pod *pod = (struct usb_line6_pod *)data;
	struct usb_line6 *line6 = &pod->line6;

	CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_VERSIONREQ);

	/* request firmware version: */
	line6_version_request_async(line6);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
markus grabner
markus grabner
47
100.00%
2
100.00%
Total
47
100.00%
2
100.00%



static void pod_startup3(struct usb_line6_pod *pod)
{
	CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_WORKQUEUE);

	/* schedule work for global work queue: */
	schedule_work(&pod->startup_work);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
markus grabner
markus grabner
28
96.55%
2
66.67%
stefan hajnoczi
stefan hajnoczi
1
3.45%
1
33.33%
Total
29
100.00%
3
100.00%



static void pod_startup4(struct work_struct *work)
{
	struct usb_line6_pod *pod =
	    container_of(work, struct usb_line6_pod, startup_work);
	struct usb_line6 *line6 = &pod->line6;

	CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_SETUP);

	/* serial number: */
	line6_read_serial_number(&pod->line6, &pod->serial_number);

	/* ALSA audio interface: */
	snd_card_register(line6->card);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
markus grabner
markus grabner
63
94.03%
3
60.00%
takashi iwai
takashi iwai
3
4.48%
1
20.00%
stefan hajnoczi
stefan hajnoczi
1
1.49%
1
20.00%
Total
67
100.00%
5
100.00%

/* POD special files: */
static DEVICE_ATTR_RO(device_id);
static DEVICE_ATTR_RO(firmware_version);
static DEVICE_ATTR_RO(serial_number);


static struct attribute *pod_dev_attrs[] = {
	&dev_attr_device_id.attr,
	&dev_attr_firmware_version.attr,
	&dev_attr_serial_number.attr,
	NULL
};


static const struct attribute_group pod_dev_attr_group = {
	.name = "pod",
	.attrs = pod_dev_attrs,
};

/* control info callback */


static int snd_pod_control_monitor_info(struct snd_kcontrol *kcontrol,
					struct snd_ctl_elem_info *uinfo)
{
	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	uinfo->count = 1;
	uinfo->value.integer.min = 0;
	uinfo->value.integer.max = 65535;
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
markus grabner
markus grabner
51
100.00%
1
100.00%
Total
51
100.00%
1
100.00%

/* control get callback */


static int snd_pod_control_monitor_get(struct snd_kcontrol *kcontrol,
				       struct snd_ctl_elem_value *ucontrol)
{
	struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
	struct usb_line6_pod *pod = (struct usb_line6_pod *)line6pcm->line6;

	ucontrol->value.integer.value[0] = pod->monitor_level;
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
markus grabner
markus grabner
58
100.00%
1
100.00%
Total
58
100.00%
1
100.00%

/* control put callback */


static int snd_pod_control_monitor_put(struct snd_kcontrol *kcontrol,
				       struct snd_ctl_elem_value *ucontrol)
{
	struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
	struct usb_line6_pod *pod = (struct usb_line6_pod *)line6pcm->line6;

	if (ucontrol->value.integer.value[0] == pod->monitor_level)
		return 0;

	pod->monitor_level = ucontrol->value.integer.value[0];
	pod_set_system_param_int(pod, ucontrol->value.integer.value[0],
				 POD_MONITOR_LEVEL);
	return 1;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
markus grabner
markus grabner
95
98.96%
2
66.67%
stefan hajnoczi
stefan hajnoczi
1
1.04%
1
33.33%
Total
96
100.00%
3
100.00%

/* control definition */

static struct snd_kcontrol_new pod_control_monitor = {
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.name = "Monitor Playback Volume",
	.index = 0,
	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
	.info = snd_pod_control_monitor_info,
	.get = snd_pod_control_monitor_get,
	.put = snd_pod_control_monitor_put
};

/*
        POD device disconnected.
*/


static void line6_pod_disconnect(struct usb_line6 *line6)
{
	struct usb_line6_pod *pod = (struct usb_line6_pod *)line6;

	del_timer_sync(&pod->startup_timer);
	cancel_work_sync(&pod->startup_work);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
takashi iwai
takashi iwai
23
58.97%
3
75.00%
chris rorvick
chris rorvick
16
41.03%
1
25.00%
Total
39
100.00%
4
100.00%

/*
         Try to init POD device.
*/


static int pod_init(struct usb_line6 *line6,
		    const struct usb_device_id *id)
{
	int err;
	struct usb_line6_pod *pod = (struct usb_line6_pod *) line6;

	line6->process_message = line6_pod_process_message;
	line6->disconnect = line6_pod_disconnect;

	init_timer(&pod->startup_timer);
	INIT_WORK(&pod->startup_work, pod_startup4);

	/* create sysfs entries: */
	err = snd_card_add_dev_attr(line6->card, &pod_dev_attr_group);
	if (err < 0)
		return err;

	/* initialize MIDI subsystem: */
	err = line6_init_midi(line6);
	if (err < 0)
		return err;

	/* initialize PCM subsystem: */
	err = line6_init_pcm(line6, &pod_pcm_properties);
	if (err < 0)
		return err;

	/* register monitor control: */
	err = snd_ctl_add(line6->card,
			  snd_ctl_new1(&pod_control_monitor, line6->line6pcm));
	if (err < 0)
		return err;

	/*
           When the sound card is registered at this point, the PODxt Live
           displays "Invalid Code Error 07", so we do it later in the event
           handler.
         */

	if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL) {
		pod->monitor_level = POD_SYSTEM_INVALID;

		/* initiate startup procedure: */
		pod_startup1(pod);
	}

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
markus grabner
markus grabner
130
72.22%
3
23.08%
chris rorvick
chris rorvick
20
11.11%
4
30.77%
greg kroah-hartman
greg kroah-hartman
16
8.89%
1
7.69%
takashi iwai
takashi iwai
12
6.67%
3
23.08%
stefan hajnoczi
stefan hajnoczi
2
1.11%
2
15.38%
Total
180
100.00%
13
100.00%


#define LINE6_DEVICE(prod) USB_DEVICE(0x0e41, prod)

#define LINE6_IF_NUM(prod, n) USB_DEVICE_INTERFACE_NUMBER(0x0e41, prod, n)

/* table of devices that work with this driver */

static const struct usb_device_id pod_id_table[] = {
	{ LINE6_DEVICE(0x4250),    .driver_info = LINE6_BASSPODXT },
	{ LINE6_DEVICE(0x4642),    .driver_info = LINE6_BASSPODXTLIVE },
	{ LINE6_DEVICE(0x4252),    .driver_info = LINE6_BASSPODXTPRO },
	{ LINE6_IF_NUM(0x5051, 1), .driver_info = LINE6_POCKETPOD },
	{ LINE6_DEVICE(0x5044),    .driver_info = LINE6_PODXT },
	{ LINE6_IF_NUM(0x4650, 0), .driver_info = LINE6_PODXTLIVE_POD },
	{ LINE6_DEVICE(0x5050),    .driver_info = LINE6_PODXTPRO },
	{}
};

MODULE_DEVICE_TABLE(usb, pod_id_table);


static const struct line6_properties pod_properties_table[] = {
	[LINE6_BASSPODXT] = {
		.id = "BassPODxt",
		.name = "BassPODxt",
		.capabilities	= LINE6_CAP_CONTROL
				| LINE6_CAP_PCM
				| LINE6_CAP_HWMON,
		.altsetting = 5,
		.ep_ctrl_r = 0x84,
		.ep_ctrl_w = 0x03,
		.ep_audio_r = 0x82,
		.ep_audio_w = 0x01,
        },
	[LINE6_BASSPODXTLIVE] = {
		.id = "BassPODxtLive",
		.name = "BassPODxt Live",
		.capabilities	= LINE6_CAP_CONTROL
				| LINE6_CAP_PCM
				| LINE6_CAP_HWMON,
		.altsetting = 1,
		.ep_ctrl_r = 0x84,
		.ep_ctrl_w = 0x03,
		.ep_audio_r = 0x82,
		.ep_audio_w = 0x01,
        },
	[LINE6_BASSPODXTPRO] = {
		.id = "BassPODxtPro",
		.name = "BassPODxt Pro",
		.capabilities	= LINE6_CAP_CONTROL
				| LINE6_CAP_PCM
				| LINE6_CAP_HWMON,
		.altsetting = 5,
		.ep_ctrl_r = 0x84,
		.ep_ctrl_w = 0x03,
		.ep_audio_r = 0x82,
		.ep_audio_w = 0x01,
        },
	[LINE6_POCKETPOD] = {
		.id = "PocketPOD",
		.name = "Pocket POD",
		.capabilities	= LINE6_CAP_CONTROL,
		.altsetting = 0,
		.ep_ctrl_r = 0x82,
		.ep_ctrl_w = 0x02,
		/* no audio channel */
	},
	[LINE6_PODXT] = {
		.id = "PODxt",
		.name = "PODxt",
		.capabilities	= LINE6_CAP_CONTROL
				| LINE6_CAP_PCM
				| LINE6_CAP_HWMON,
		.altsetting = 5,
		.ep_ctrl_r = 0x84,
		.ep_ctrl_w = 0x03,
		.ep_audio_r = 0x82,
		.ep_audio_w = 0x01,
        },
	[LINE6_PODXTLIVE_POD] = {
		.id = "PODxtLive",
		.name = "PODxt Live",
		.capabilities	= LINE6_CAP_CONTROL
				| LINE6_CAP_PCM
				| LINE6_CAP_HWMON,
		.altsetting = 1,
		.ep_ctrl_r = 0x84,
		.ep_ctrl_w = 0x03,
		.ep_audio_r = 0x82,
		.ep_audio_w = 0x01,
        },
	[LINE6_PODXTPRO] = {
		.id = "PODxtPro",
		.name = "PODxt Pro",
		.capabilities	= LINE6_CAP_CONTROL
				| LINE6_CAP_PCM
				| LINE6_CAP_HWMON,
		.altsetting = 5,
		.ep_ctrl_r = 0x84,
		.ep_ctrl_w = 0x03,
		.ep_audio_r = 0x82,
		.ep_audio_w = 0x01,
        },
};

/*
        Probe USB device.
*/


static int pod_probe(struct usb_interface *interface,
		     const struct usb_device_id *id)
{
	return line6_probe(interface, id, "Line6-POD",
			   &pod_properties_table[id->driver_info],
			   pod_init, sizeof(struct usb_line6_pod));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
takashi iwai
takashi iwai
41
95.35%
4
80.00%
chris rorvick
chris rorvick
2
4.65%
1
20.00%
Total
43
100.00%
5
100.00%


static struct usb_driver pod_driver = {
	.name = KBUILD_MODNAME,
	.probe = pod_probe,
	.disconnect = line6_disconnect,
#ifdef CONFIG_PM
	.suspend = line6_suspend,
	.resume = line6_resume,
	.reset_resume = line6_resume,
#endif
	.id_table = pod_id_table,
};


module_usb_driver(pod_driver);

MODULE_DESCRIPTION("Line 6 POD USB driver");
MODULE_LICENSE("GPL");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
markus grabner
markus grabner
1360
58.60%
3
9.68%
takashi iwai
takashi iwai
768
33.09%
8
25.81%
stefan hajnoczi
stefan hajnoczi
95
4.09%
5
16.13%
chris rorvick
chris rorvick
58
2.50%
10
32.26%
greg kroah-hartman
greg kroah-hartman
37
1.59%
3
9.68%
tejun heo
tejun heo
2
0.09%
1
3.23%
shawn bohrer
shawn bohrer
1
0.04%
1
3.23%
Total
2321
100.00%
31
100.00%
  
Directory: sound/usb/line6

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.