[thirdparty/linux.git] / sound / usb / line6 / podhd.c

/*
 * Line 6 Pod HD
 *
 * Copyright (C) 2011 Stefan Hajnoczi <stefanha@gmail.com>
 * Copyright (C) 2015 Andrej Krutak <dev@andree.sk>
 * Copyright (C) 2017 Hans P. Moller <hmoller@uc.cl>
 *
 *	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/usb.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <sound/core.h>
#include <sound/pcm.h>

#include "driver.h"
#include "pcm.h"

#define PODHD_STARTUP_DELAY 500

/*
 * Stages of POD startup procedure
 */
enum {
	PODHD_STARTUP_INIT = 1,
	PODHD_STARTUP_SCHEDULE_WORKQUEUE,
	PODHD_STARTUP_SETUP,
	PODHD_STARTUP_LAST = PODHD_STARTUP_SETUP - 1
};

enum {
	LINE6_PODHD300,
	LINE6_PODHD400,
	LINE6_PODHD500_0,
	LINE6_PODHD500_1,
	LINE6_PODX3,
	LINE6_PODX3LIVE,
	LINE6_PODHD500X
};

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

	/* 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 */
	int firmware_version;
};

static struct snd_ratden podhd_ratden = {
	.num_min = 48000,
	.num_max = 48000,
	.num_step = 1,
	.den = 1,
};

static struct line6_pcm_properties podhd_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_48000,
				  .rate_min = 48000,
				  .rate_max = 48000,
				  .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_48000,
				 .rate_min = 48000,
				 .rate_max = 48000,
				 .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 = &podhd_ratden},
	.bytes_per_channel = 3 /* SNDRV_PCM_FMTBIT_S24_3LE */
};

static struct line6_pcm_properties podx3_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_48000,
				  .rate_min = 48000,
				  .rate_max = 48000,
				  .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_48000,
				 .rate_min = 48000,
				 .rate_max = 48000,
				 /* 1+2: Main signal (out), 3+4: Tone 1,
				  * 5+6: Tone 2, 7+8: raw
				  */
				 .channels_min = 8,
				 .channels_max = 8,
				 .buffer_bytes_max = 60000,
				 .period_bytes_min = 64,
				 .period_bytes_max = 8192,
				 .periods_min = 1,
				 .periods_max = 1024},
	.rates = {
			    .nrats = 1,
			    .rats = &podhd_ratden},
	.bytes_per_channel = 3 /* SNDRV_PCM_FMTBIT_S24_3LE */
};
static struct usb_driver podhd_driver;

static void podhd_startup_start_workqueue(unsigned long data);
static void podhd_startup_workqueue(struct work_struct *work);
static int podhd_startup_finalize(struct usb_line6_podhd *pod);

static ssize_t serial_number_show(struct device *dev,
				  struct device_attribute *attr, char *buf)
{
	struct snd_card *card = dev_to_snd_card(dev);
	struct usb_line6_podhd *pod = card->private_data;

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

static ssize_t firmware_version_show(struct device *dev,
				     struct device_attribute *attr, char *buf)
{
	struct snd_card *card = dev_to_snd_card(dev);
	struct usb_line6_podhd *pod = card->private_data;

	return sprintf(buf, "%06x\n", pod->firmware_version);
}

static DEVICE_ATTR_RO(firmware_version);
static DEVICE_ATTR_RO(serial_number);

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

static const struct attribute_group podhd_dev_attr_group = {
	.name = "podhd",
	.attrs = podhd_dev_attrs,
};

/*
 * POD X3 startup procedure.
 *
 * May be compatible with other POD HD's, since it's also similar to the
 * previous POD setup. In any case, it doesn't seem to be required for the
 * audio nor bulk interfaces to work.
 */

static void podhd_startup(struct usb_line6_podhd *pod)
{
	CHECK_STARTUP_PROGRESS(pod->startup_progress, PODHD_STARTUP_INIT);

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

static void podhd_startup_start_workqueue(unsigned long data)
{
	struct usb_line6_podhd *pod = (struct usb_line6_podhd *)data;

	CHECK_STARTUP_PROGRESS(pod->startup_progress,
		PODHD_STARTUP_SCHEDULE_WORKQUEUE);

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

static int podhd_dev_start(struct usb_line6_podhd *pod)
{
	int ret;
	u8 init_bytes[8];
	int i;
	struct usb_device *usbdev = pod->line6.usbdev;

	ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
					0x67, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
					0x11, 0,
					NULL, 0, LINE6_TIMEOUT * HZ);
	if (ret < 0) {
		dev_err(pod->line6.ifcdev, "read request failed (error %d)\n", ret);
		return ret;
	}

	/* NOTE: looks like some kind of ping message */
	ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67,
					USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
					0x11, 0x0,
					&init_bytes, 3, LINE6_TIMEOUT * HZ);
	if (ret < 0) {
		dev_err(pod->line6.ifcdev,
			"receive length failed (error %d)\n", ret);
		return ret;
	}

	pod->firmware_version =
		(init_bytes[0] << 16) | (init_bytes[1] << 8) | (init_bytes[2] << 0);

	for (i = 0; i <= 16; i++) {
		ret = line6_read_data(&pod->line6, 0xf000 + 0x08 * i, init_bytes, 8);
		if (ret < 0)
			return ret;
	}

	ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
					USB_REQ_SET_FEATURE,
					USB_TYPE_STANDARD | USB_RECIP_DEVICE | USB_DIR_OUT,
					1, 0,
					NULL, 0, LINE6_TIMEOUT * HZ);
	if (ret < 0)
		return ret;

	return 0;
}

static void podhd_startup_workqueue(struct work_struct *work)
{
	struct usb_line6_podhd *pod =
	    container_of(work, struct usb_line6_podhd, startup_work);

	CHECK_STARTUP_PROGRESS(pod->startup_progress, PODHD_STARTUP_SETUP);

	podhd_dev_start(pod);
	line6_read_serial_number(&pod->line6, &pod->serial_number);

	podhd_startup_finalize(pod);
}

static int podhd_startup_finalize(struct usb_line6_podhd *pod)
{
	struct usb_line6 *line6 = &pod->line6;

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

static void podhd_disconnect(struct usb_line6 *line6)
{
	struct usb_line6_podhd *pod = (struct usb_line6_podhd *)line6;

	if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL) {
		struct usb_interface *intf;

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

		intf = usb_ifnum_to_if(line6->usbdev,
					pod->line6.properties->ctrl_if);
		usb_driver_release_interface(&podhd_driver, intf);
	}
}

/*
	Try to init POD HD device.
*/
static int podhd_init(struct usb_line6 *line6,
		      const struct usb_device_id *id)
{
	int err;
	struct usb_line6_podhd *pod = (struct usb_line6_podhd *) line6;
	struct usb_interface *intf;

	line6->disconnect = podhd_disconnect;

	if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL) {
		/* claim the data interface */
		intf = usb_ifnum_to_if(line6->usbdev,
					pod->line6.properties->ctrl_if);
		if (!intf) {
			dev_err(pod->line6.ifcdev, "interface %d not found\n",
				pod->line6.properties->ctrl_if);
			return -ENODEV;
		}

		err = usb_driver_claim_interface(&podhd_driver, intf, NULL);
		if (err != 0) {
			dev_err(pod->line6.ifcdev, "can't claim interface %d, error %d\n",
				pod->line6.properties->ctrl_if, err);
			return err;
		}

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

	if (pod->line6.properties->capabilities & LINE6_CAP_PCM) {
		/* initialize PCM subsystem: */
		err = line6_init_pcm(line6,
			(id->driver_info == LINE6_PODX3 ||
			id->driver_info == LINE6_PODX3LIVE) ? &podx3_pcm_properties :
			&podhd_pcm_properties);
		if (err < 0)
			return err;
	}

	if (!(pod->line6.properties->capabilities & LINE6_CAP_CONTROL)) {
		/* register USB audio system directly */
		return podhd_startup_finalize(pod);
	}

	/* init device and delay registering */
	init_timer(&pod->startup_timer);
	INIT_WORK(&pod->startup_work, podhd_startup_workqueue);
	podhd_startup(pod);
	return 0;
}

#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 podhd_id_table[] = {
	/* TODO: no need to alloc data interfaces when only audio is used */
	{ LINE6_DEVICE(0x5057),    .driver_info = LINE6_PODHD300 },
	{ LINE6_DEVICE(0x5058),    .driver_info = LINE6_PODHD400 },
	{ LINE6_IF_NUM(0x414D, 0), .driver_info = LINE6_PODHD500_0 },
	{ LINE6_IF_NUM(0x414D, 1), .driver_info = LINE6_PODHD500_1 },
	{ LINE6_IF_NUM(0x414A, 0), .driver_info = LINE6_PODX3 },
	{ LINE6_IF_NUM(0x414B, 0), .driver_info = LINE6_PODX3LIVE },
	{ LINE6_IF_NUM(0x4159, 0), .driver_info = LINE6_PODHD500X },
	{}
};

MODULE_DEVICE_TABLE(usb, podhd_id_table);

static const struct line6_properties podhd_properties_table[] = {
	[LINE6_PODHD300] = {
		.id = "PODHD300",
		.name = "POD HD300",
		.capabilities	= 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_PODHD400] = {
		.id = "PODHD400",
		.name = "POD HD400",
		.capabilities	= 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_PODHD500_0] = {
		.id = "PODHD500",
		.name = "POD HD500",
		.capabilities	= LINE6_CAP_PCM
				| LINE6_CAP_HWMON,
		.altsetting = 1,
		.ep_ctrl_r = 0x81,
		.ep_ctrl_w = 0x01,
		.ep_audio_r = 0x86,
		.ep_audio_w = 0x02,
	},
	[LINE6_PODHD500_1] = {
		.id = "PODHD500",
		.name = "POD HD500",
		.capabilities	= LINE6_CAP_PCM
				| LINE6_CAP_HWMON,
		.altsetting = 1,
		.ep_ctrl_r = 0x81,
		.ep_ctrl_w = 0x01,
		.ep_audio_r = 0x86,
		.ep_audio_w = 0x02,
	},
	[LINE6_PODX3] = {
		.id = "PODX3",
		.name = "POD X3",
		.capabilities	= LINE6_CAP_CONTROL
				| LINE6_CAP_PCM | LINE6_CAP_HWMON | LINE6_CAP_IN_NEEDS_OUT,
		.altsetting = 1,
		.ep_ctrl_r = 0x81,
		.ep_ctrl_w = 0x01,
		.ctrl_if = 1,
		.ep_audio_r = 0x86,
		.ep_audio_w = 0x02,
	},
	[LINE6_PODX3LIVE] = {
		.id = "PODX3LIVE",
		.name = "POD X3 LIVE",
		.capabilities	= LINE6_CAP_CONTROL
				| LINE6_CAP_PCM | LINE6_CAP_HWMON | LINE6_CAP_IN_NEEDS_OUT,
		.altsetting = 1,
		.ep_ctrl_r = 0x81,
		.ep_ctrl_w = 0x01,
		.ctrl_if = 1,
		.ep_audio_r = 0x86,
		.ep_audio_w = 0x02,
	},
	[LINE6_PODHD500X] = {
		.id = "PODHD500X",
		.name = "POD HD500X",
		.capabilities	= LINE6_CAP_CONTROL
				| LINE6_CAP_PCM | LINE6_CAP_HWMON,
		.altsetting = 1,
		.ep_ctrl_r = 0x81,
		.ep_ctrl_w = 0x01,
		.ctrl_if = 1,
		.ep_audio_r = 0x86,
		.ep_audio_w = 0x02,
	},
};

/*
	Probe USB device.
*/
static int podhd_probe(struct usb_interface *interface,
		       const struct usb_device_id *id)
{
	return line6_probe(interface, id, "Line6-PODHD",
			   &podhd_properties_table[id->driver_info],
			   podhd_init, sizeof(struct usb_line6_podhd));
}

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

module_usb_driver(podhd_driver);

MODULE_DESCRIPTION("Line 6 PODHD USB driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
16dc1040	1	/*
c6fffce9	2	* Line 6 Pod HD
16dc1040 SH	3	*
16dc1040 SH	4	* Copyright (C) 2011 Stefan Hajnoczi <stefanha@gmail.com>
790869da	5	* Copyright (C) 2015 Andrej Krutak <dev@andree.sk>
c1d25075	6	* Copyright (C) 2017 Hans P. Moller <hmoller@uc.cl>
16dc1040 SH	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License as
	10	* published by the Free Software Foundation, version 2.
	11	*
	12	*/
	13
ccddbe4a TI	14	#include <linux/usb.h>
	15	#include <linux/slab.h>
	16	#include <linux/module.h>
16dc1040 SH	17	#include <sound/core.h>
	18	#include <sound/pcm.h>
	19
16dc1040 SH	20	#include "driver.h"
16dc1040 SH	21	#include "pcm.h"
ccddbe4a	22
790869da AK	23	#define PODHD_STARTUP_DELAY 500
	24
	25	/*
	26	* Stages of POD startup procedure
	27	*/
	28	enum {
	29	PODHD_STARTUP_INIT = 1,
	30	PODHD_STARTUP_SCHEDULE_WORKQUEUE,
	31	PODHD_STARTUP_SETUP,
	32	PODHD_STARTUP_LAST = PODHD_STARTUP_SETUP - 1
	33	};
	34
ccddbe4a TI	35	enum {
	36	LINE6_PODHD300,
	37	LINE6_PODHD400,
	38	LINE6_PODHD500_0,
	39	LINE6_PODHD500_1,
790869da	40	LINE6_PODX3,
c1d25075 HME	41	LINE6_PODX3LIVE,
c1d25075 HME	42	LINE6_PODHD500X
790869da AK	43	};
	44
	45	struct usb_line6_podhd {
	46	/* Generic Line 6 USB data */
	47	struct usb_line6 line6;
	48
	49	/* Timer for device initialization */
	50	struct timer_list startup_timer;
	51
	52	/* Work handler for device initialization */
	53	struct work_struct startup_work;
	54
	55	/* Current progress in startup procedure */
	56	int startup_progress;
	57
	58	/* Serial number of device */
	59	u32 serial_number;
	60
	61	/* Firmware version */
	62	int firmware_version;
ccddbe4a TI	63	};
ccddbe4a TI	64
16dc1040 SH	65	static struct snd_ratden podhd_ratden = {
	66	.num_min = 48000,
	67	.num_max = 48000,
	68	.num_step = 1,
	69	.den = 1,
	70	};
	71
	72	static struct line6_pcm_properties podhd_pcm_properties = {
1263f611	73	.playback_hw = {
16dc1040 SH	74	.info = (SNDRV_PCM_INFO_MMAP \|
	75	SNDRV_PCM_INFO_INTERLEAVED \|
	76	SNDRV_PCM_INFO_BLOCK_TRANSFER \|
	77	SNDRV_PCM_INFO_MMAP_VALID \|
	78	SNDRV_PCM_INFO_PAUSE \|
16dc1040 SH	79	SNDRV_PCM_INFO_SYNC_START),
	80	.formats = SNDRV_PCM_FMTBIT_S24_3LE,
	81	.rates = SNDRV_PCM_RATE_48000,
	82	.rate_min = 48000,
	83	.rate_max = 48000,
	84	.channels_min = 2,
	85	.channels_max = 2,
	86	.buffer_bytes_max = 60000,
	87	.period_bytes_min = 64,
	88	.period_bytes_max = 8192,
	89	.periods_min = 1,
	90	.periods_max = 1024},
1263f611	91	.capture_hw = {
16dc1040 SH	92	.info = (SNDRV_PCM_INFO_MMAP \|
	93	SNDRV_PCM_INFO_INTERLEAVED \|
	94	SNDRV_PCM_INFO_BLOCK_TRANSFER \|
	95	SNDRV_PCM_INFO_MMAP_VALID \|
16dc1040 SH	96	SNDRV_PCM_INFO_SYNC_START),
	97	.formats = SNDRV_PCM_FMTBIT_S24_3LE,
	98	.rates = SNDRV_PCM_RATE_48000,
	99	.rate_min = 48000,
	100	.rate_max = 48000,
	101	.channels_min = 2,
	102	.channels_max = 2,
	103	.buffer_bytes_max = 60000,
	104	.period_bytes_min = 64,
	105	.period_bytes_max = 8192,
	106	.periods_min = 1,
	107	.periods_max = 1024},
1263f611	108	.rates = {
16dc1040 SH	109	.nrats = 1,
16dc1040 SH	110	.rats = &podhd_ratden},
790869da	111	.bytes_per_channel = 3 /* SNDRV_PCM_FMTBIT_S24_3LE */
16dc1040 SH	112	};
16dc1040 SH	113
790869da AK	114	static struct line6_pcm_properties podx3_pcm_properties = {
	115	.playback_hw = {
	116	.info = (SNDRV_PCM_INFO_MMAP \|
	117	SNDRV_PCM_INFO_INTERLEAVED \|
	118	SNDRV_PCM_INFO_BLOCK_TRANSFER \|
	119	SNDRV_PCM_INFO_MMAP_VALID \|
	120	SNDRV_PCM_INFO_PAUSE \|
	121	SNDRV_PCM_INFO_SYNC_START),
	122	.formats = SNDRV_PCM_FMTBIT_S24_3LE,
	123	.rates = SNDRV_PCM_RATE_48000,
	124	.rate_min = 48000,
	125	.rate_max = 48000,
	126	.channels_min = 2,
	127	.channels_max = 2,
	128	.buffer_bytes_max = 60000,
	129	.period_bytes_min = 64,
	130	.period_bytes_max = 8192,
	131	.periods_min = 1,
	132	.periods_max = 1024},
	133	.capture_hw = {
	134	.info = (SNDRV_PCM_INFO_MMAP \|
	135	SNDRV_PCM_INFO_INTERLEAVED \|
	136	SNDRV_PCM_INFO_BLOCK_TRANSFER \|
	137	SNDRV_PCM_INFO_MMAP_VALID \|
	138	SNDRV_PCM_INFO_SYNC_START),
	139	.formats = SNDRV_PCM_FMTBIT_S24_3LE,
	140	.rates = SNDRV_PCM_RATE_48000,
	141	.rate_min = 48000,
	142	.rate_max = 48000,
	143	/* 1+2: Main signal (out), 3+4: Tone 1,
	144	* 5+6: Tone 2, 7+8: raw
	145	*/
	146	.channels_min = 8,
	147	.channels_max = 8,
	148	.buffer_bytes_max = 60000,
	149	.period_bytes_min = 64,
	150	.period_bytes_max = 8192,
	151	.periods_min = 1,
	152	.periods_max = 1024},
	153	.rates = {
	154	.nrats = 1,
	155	.rats = &podhd_ratden},
	156	.bytes_per_channel = 3 /* SNDRV_PCM_FMTBIT_S24_3LE */
	157	};
fc90172b	158	static struct usb_driver podhd_driver;
790869da AK	159
	160	static void podhd_startup_start_workqueue(unsigned long data);
	161	static void podhd_startup_workqueue(struct work_struct *work);
	162	static int podhd_startup_finalize(struct usb_line6_podhd *pod);
	163
	164	static ssize_t serial_number_show(struct device *dev,
	165	struct device_attribute attr, char buf)
	166	{
	167	struct snd_card *card = dev_to_snd_card(dev);
	168	struct usb_line6_podhd *pod = card->private_data;
	169
	170	return sprintf(buf, "%u\n", pod->serial_number);
	171	}
	172
	173	static ssize_t firmware_version_show(struct device *dev,
	174	struct device_attribute attr, char buf)
	175	{
	176	struct snd_card *card = dev_to_snd_card(dev);
	177	struct usb_line6_podhd *pod = card->private_data;
	178
	179	return sprintf(buf, "%06x\n", pod->firmware_version);
	180	}
	181
	182	static DEVICE_ATTR_RO(firmware_version);
	183	static DEVICE_ATTR_RO(serial_number);
	184
	185	static struct attribute *podhd_dev_attrs[] = {
	186	&dev_attr_firmware_version.attr,
	187	&dev_attr_serial_number.attr,
	188	NULL
	189	};
	190
	191	static const struct attribute_group podhd_dev_attr_group = {
	192	.name = "podhd",
	193	.attrs = podhd_dev_attrs,
	194	};
	195
	196	/*
	197	* POD X3 startup procedure.
	198	*
	199	* May be compatible with other POD HD's, since it's also similar to the
	200	* previous POD setup. In any case, it doesn't seem to be required for the
	201	* audio nor bulk interfaces to work.
	202	*/
	203
	204	static void podhd_startup(struct usb_line6_podhd *pod)
	205	{
	206	CHECK_STARTUP_PROGRESS(pod->startup_progress, PODHD_STARTUP_INIT);
	207
	208	/* delay startup procedure: */
	209	line6_start_timer(&pod->startup_timer, PODHD_STARTUP_DELAY,
	210	podhd_startup_start_workqueue, (unsigned long)pod);
	211	}
	212
	213	static void podhd_startup_start_workqueue(unsigned long data)
	214	{
	215	struct usb_line6_podhd pod = (struct usb_line6_podhd )data;
	216
	217	CHECK_STARTUP_PROGRESS(pod->startup_progress,
	218	PODHD_STARTUP_SCHEDULE_WORKQUEUE);
	219
	220	/* schedule work for global work queue: */
	221	schedule_work(&pod->startup_work);
	222	}
223
224	static int podhd_dev_start(struct usb_line6_podhd *pod)
225	{
226	int ret;
227	u8 init_bytes[8];
228	int i;
229	struct usb_device *usbdev = pod->line6.usbdev;
230
231	ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
232	0x67, USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_OUT,
233	0x11, 0,
234	NULL, 0, LINE6_TIMEOUT * HZ);
235	if (ret < 0) {
236	dev_err(pod->line6.ifcdev, "read request failed (error %d)\n", ret);
237	return ret;
238	}
239
240	/* NOTE: looks like some kind of ping message */
241	ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67,
242	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
243	0x11, 0x0,
244	&init_bytes, 3, LINE6_TIMEOUT * HZ);
245	if (ret < 0) {
246	dev_err(pod->line6.ifcdev,
247	"receive length failed (error %d)\n", ret);
248	return ret;
249	}
250
251	pod->firmware_version =
252	(init_bytes[0] << 16) \| (init_bytes[1] << 8) \| (init_bytes[2] << 0);
253
254	for (i = 0; i <= 16; i++) {
255	ret = line6_read_data(&pod->line6, 0xf000 + 0x08 * i, init_bytes, 8);
256	if (ret < 0)
257	return ret;
258	}
259
260	ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
261	USB_REQ_SET_FEATURE,
262	USB_TYPE_STANDARD \| USB_RECIP_DEVICE \| USB_DIR_OUT,
263	1, 0,
264	NULL, 0, LINE6_TIMEOUT * HZ);
265	if (ret < 0)
266	return ret;
267
268	return 0;
269	}
270
271	static void podhd_startup_workqueue(struct work_struct *work)
272	{
273	struct usb_line6_podhd *pod =
274	container_of(work, struct usb_line6_podhd, startup_work);
275
276	CHECK_STARTUP_PROGRESS(pod->startup_progress, PODHD_STARTUP_SETUP);
277
278	podhd_dev_start(pod);
279	line6_read_serial_number(&pod->line6, &pod->serial_number);
280
281	podhd_startup_finalize(pod);
282	}
283
284	static int podhd_startup_finalize(struct usb_line6_podhd *pod)
285	{
286	struct usb_line6 *line6 = &pod->line6;
287
288	/* ALSA audio interface: */
289	return snd_card_register(line6->card);
290	}
291
292	static void podhd_disconnect(struct usb_line6 *line6)
293	{
294	struct usb_line6_podhd pod = (struct usb_line6_podhd )line6;
295
296	if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL) {
fc90172b AK	297	struct usb_interface *intf;
fc90172b AK	298
790869da AK	299	del_timer_sync(&pod->startup_timer);
790869da AK	300	cancel_work_sync(&pod->startup_work);
fc90172b AK	301
	302	intf = usb_ifnum_to_if(line6->usbdev,
	303	pod->line6.properties->ctrl_if);
	304	usb_driver_release_interface(&podhd_driver, intf);
790869da AK	305	}
	306	}
	307
16dc1040 SH	308	/*
	309	Try to init POD HD device.
	310	*/
f66fd990 TI	311	static int podhd_init(struct usb_line6 *line6,
f66fd990 TI	312	const struct usb_device_id *id)
16dc1040 SH	313	{
16dc1040 SH	314	int err;
790869da	315	struct usb_line6_podhd pod = (struct usb_line6_podhd ) line6;
fc90172b	316	struct usb_interface *intf;
790869da AK	317
	318	line6->disconnect = podhd_disconnect;
	319
	320	if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL) {
fc90172b AK	321	/* claim the data interface */
	322	intf = usb_ifnum_to_if(line6->usbdev,
	323	pod->line6.properties->ctrl_if);
	324	if (!intf) {
	325	dev_err(pod->line6.ifcdev, "interface %d not found\n",
	326	pod->line6.properties->ctrl_if);
	327	return -ENODEV;
	328	}
	329
	330	err = usb_driver_claim_interface(&podhd_driver, intf, NULL);
	331	if (err != 0) {
	332	dev_err(pod->line6.ifcdev, "can't claim interface %d, error %d\n",
	333	pod->line6.properties->ctrl_if, err);
	334	return err;
	335	}
	336
790869da AK	337	/* create sysfs entries: */
	338	err = snd_card_add_dev_attr(line6->card, &podhd_dev_attr_group);
	339	if (err < 0)
	340	return err;
	341	}
16dc1040	342
cfa76969 AK	343	if (pod->line6.properties->capabilities & LINE6_CAP_PCM) {
	344	/* initialize PCM subsystem: */
	345	err = line6_init_pcm(line6,
b907900e AK	346	(id->driver_info == LINE6_PODX3 \|\|
b907900e AK	347	id->driver_info == LINE6_PODX3LIVE) ? &podx3_pcm_properties :
cfa76969 AK	348	&podhd_pcm_properties);
	349	if (err < 0)
	350	return err;
	351	}
16dc1040	352
790869da AK	353	if (!(pod->line6.properties->capabilities & LINE6_CAP_CONTROL)) {
	354	/* register USB audio system directly */
	355	return podhd_startup_finalize(pod);
	356	}
	357
	358	/* init device and delay registering */
	359	init_timer(&pod->startup_timer);
	360	INIT_WORK(&pod->startup_work, podhd_startup_workqueue);
	361	podhd_startup(pod);
	362	return 0;
16dc1040 SH	363	}
16dc1040 SH	364
ccddbe4a TI	365	#define LINE6_DEVICE(prod) USB_DEVICE(0x0e41, prod)
	366	#define LINE6_IF_NUM(prod, n) USB_DEVICE_INTERFACE_NUMBER(0x0e41, prod, n)
	367
	368	/* table of devices that work with this driver */
	369	static const struct usb_device_id podhd_id_table[] = {
790869da	370	/* TODO: no need to alloc data interfaces when only audio is used */
ccddbe4a TI	371	{ LINE6_DEVICE(0x5057), .driver_info = LINE6_PODHD300 },
	372	{ LINE6_DEVICE(0x5058), .driver_info = LINE6_PODHD400 },
	373	{ LINE6_IF_NUM(0x414D, 0), .driver_info = LINE6_PODHD500_0 },
	374	{ LINE6_IF_NUM(0x414D, 1), .driver_info = LINE6_PODHD500_1 },
790869da	375	{ LINE6_IF_NUM(0x414A, 0), .driver_info = LINE6_PODX3 },
c039aaa7	376	{ LINE6_IF_NUM(0x414B, 0), .driver_info = LINE6_PODX3LIVE },
c1d25075	377	{ LINE6_IF_NUM(0x4159, 0), .driver_info = LINE6_PODHD500X },
ccddbe4a TI	378	{}
	379	};
	380
	381	MODULE_DEVICE_TABLE(usb, podhd_id_table);
	382
	383	static const struct line6_properties podhd_properties_table[] = {
	384	[LINE6_PODHD300] = {
	385	.id = "PODHD300",
	386	.name = "POD HD300",
790869da	387	.capabilities = LINE6_CAP_PCM
ccddbe4a TI	388	\| LINE6_CAP_HWMON,
	389	.altsetting = 5,
	390	.ep_ctrl_r = 0x84,
	391	.ep_ctrl_w = 0x03,
	392	.ep_audio_r = 0x82,
	393	.ep_audio_w = 0x01,
	394	},
	395	[LINE6_PODHD400] = {
	396	.id = "PODHD400",
	397	.name = "POD HD400",
790869da	398	.capabilities = LINE6_CAP_PCM
ccddbe4a TI	399	\| LINE6_CAP_HWMON,
	400	.altsetting = 5,
	401	.ep_ctrl_r = 0x84,
	402	.ep_ctrl_w = 0x03,
	403	.ep_audio_r = 0x82,
	404	.ep_audio_w = 0x01,
	405	},
	406	[LINE6_PODHD500_0] = {
	407	.id = "PODHD500",
	408	.name = "POD HD500",
790869da	409	.capabilities = LINE6_CAP_PCM
ccddbe4a TI	410	\| LINE6_CAP_HWMON,
	411	.altsetting = 1,
	412	.ep_ctrl_r = 0x81,
	413	.ep_ctrl_w = 0x01,
	414	.ep_audio_r = 0x86,
	415	.ep_audio_w = 0x02,
	416	},
	417	[LINE6_PODHD500_1] = {
	418	.id = "PODHD500",
	419	.name = "POD HD500",
790869da	420	.capabilities = LINE6_CAP_PCM
ccddbe4a TI	421	\| LINE6_CAP_HWMON,
	422	.altsetting = 1,
	423	.ep_ctrl_r = 0x81,
	424	.ep_ctrl_w = 0x01,
	425	.ep_audio_r = 0x86,
	426	.ep_audio_w = 0x02,
	427	},
790869da AK	428	[LINE6_PODX3] = {
	429	.id = "PODX3",
	430	.name = "POD X3",
	431	.capabilities = LINE6_CAP_CONTROL
	432	\| LINE6_CAP_PCM \| LINE6_CAP_HWMON \| LINE6_CAP_IN_NEEDS_OUT,
	433	.altsetting = 1,
	434	.ep_ctrl_r = 0x81,
	435	.ep_ctrl_w = 0x01,
fc90172b	436	.ctrl_if = 1,
790869da AK	437	.ep_audio_r = 0x86,
	438	.ep_audio_w = 0x02,
	439	},
c039aaa7 AK	440	[LINE6_PODX3LIVE] = {
	441	.id = "PODX3LIVE",
	442	.name = "POD X3 LIVE",
	443	.capabilities = LINE6_CAP_CONTROL
	444	\| LINE6_CAP_PCM \| LINE6_CAP_HWMON \| LINE6_CAP_IN_NEEDS_OUT,
	445	.altsetting = 1,
	446	.ep_ctrl_r = 0x81,
	447	.ep_ctrl_w = 0x01,
fc90172b	448	.ctrl_if = 1,
c039aaa7 AK	449	.ep_audio_r = 0x86,
	450	.ep_audio_w = 0x02,
	451	},
c1d25075 HME	452	[LINE6_PODHD500X] = {
	453	.id = "PODHD500X",
	454	.name = "POD HD500X",
	455	.capabilities = LINE6_CAP_CONTROL
	456	\| LINE6_CAP_PCM \| LINE6_CAP_HWMON,
	457	.altsetting = 1,
	458	.ep_ctrl_r = 0x81,
	459	.ep_ctrl_w = 0x01,
	460	.ctrl_if = 1,
	461	.ep_audio_r = 0x86,
	462	.ep_audio_w = 0x02,
	463	},
ccddbe4a TI	464	};
ccddbe4a TI	465
ccddbe4a TI	466	/*
	467	Probe USB device.
	468	*/
	469	static int podhd_probe(struct usb_interface *interface,
	470	const struct usb_device_id *id)
	471	{
12865cac	472	return line6_probe(interface, id, "Line6-PODHD",
85a9339b	473	&podhd_properties_table[id->driver_info],
790869da	474	podhd_init, sizeof(struct usb_line6_podhd));
ccddbe4a TI	475	}
	476
	477	static struct usb_driver podhd_driver = {
	478	.name = KBUILD_MODNAME,
	479	.probe = podhd_probe,
	480	.disconnect = line6_disconnect,
	481	#ifdef CONFIG_PM
	482	.suspend = line6_suspend,
	483	.resume = line6_resume,
	484	.reset_resume = line6_resume,
	485	#endif
	486	.id_table = podhd_id_table,
	487	};
	488
	489	module_usb_driver(podhd_driver);
	490
c6fffce9	491	MODULE_DESCRIPTION("Line 6 PODHD USB driver");
ccddbe4a	492	MODULE_LICENSE("GPL");