1/*
2 * Line 6 Linux USB driver
3 *
4 * Copyright (C) 2004-2010 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 <linux/slab.h>
13#include <linux/wait.h>
14#include <linux/interrupt.h>
15#include <linux/module.h>
16#include <linux/usb.h>
17
18#include <sound/core.h>
19#include <sound/control.h>
20
21#include "capture.h"
22#include "driver.h"
23#include "playback.h"
24
25/*
26	Locate name in binary program dump
27*/
28#define	POD_NAME_OFFSET 0
29#define	POD_NAME_LENGTH 16
30
31/*
32	Other constants
33*/
34#define POD_CONTROL_SIZE 0x80
35#define POD_BUFSIZE_DUMPREQ 7
36#define POD_STARTUP_DELAY 1000
37
38/*
39	Stages of POD startup procedure
40*/
41enum {
42	POD_STARTUP_INIT = 1,
43	POD_STARTUP_VERSIONREQ,
44	POD_STARTUP_WORKQUEUE,
45	POD_STARTUP_SETUP,
46	POD_STARTUP_LAST = POD_STARTUP_SETUP - 1
47};
48
49enum {
50	LINE6_BASSPODXT,
51	LINE6_BASSPODXTLIVE,
52	LINE6_BASSPODXTPRO,
53	LINE6_POCKETPOD,
54	LINE6_PODXT,
55	LINE6_PODXTLIVE_POD,
56	LINE6_PODXTPRO,
57};
58
59struct usb_line6_pod {
60	/* Generic Line 6 USB data */
61	struct usb_line6 line6;
62
63	/* Instrument monitor level */
64	int monitor_level;
65
66	/* Timer for device initialization */
67	struct timer_list startup_timer;
68
69	/* Work handler for device initialization */
70	struct work_struct startup_work;
71
72	/* Current progress in startup procedure */
73	int startup_progress;
74
75	/* Serial number of device */
76	u32 serial_number;
77
78	/* Firmware version (x 100) */
79	int firmware_version;
80
81	/* Device ID */
82	int device_id;
83};
84
85#define POD_SYSEX_CODE 3
86#define POD_BYTES_PER_FRAME 6	/* 24bit audio (stereo) */
87
88/* *INDENT-OFF* */
89
90enum {
91	POD_SYSEX_SAVE      = 0x24,
92	POD_SYSEX_SYSTEM    = 0x56,
93	POD_SYSEX_SYSTEMREQ = 0x57,
94	/* POD_SYSEX_UPDATE    = 0x6c, */  /* software update! */
95	POD_SYSEX_STORE     = 0x71,
96	POD_SYSEX_FINISH    = 0x72,
97	POD_SYSEX_DUMPMEM   = 0x73,
98	POD_SYSEX_DUMP      = 0x74,
99	POD_SYSEX_DUMPREQ   = 0x75
100
101	/* dumps entire internal memory of PODxt Pro */
102	/* POD_SYSEX_DUMPMEM2  = 0x76 */
103};
104
105enum {
106	POD_MONITOR_LEVEL  = 0x04,
107	POD_SYSTEM_INVALID = 0x10000
108};
109
110/* *INDENT-ON* */
111
112enum {
113	POD_DUMP_MEMORY = 2
114};
115
116enum {
117	POD_BUSY_READ,
118	POD_BUSY_WRITE,
119	POD_CHANNEL_DIRTY,
120	POD_SAVE_PRESSED,
121	POD_BUSY_MIDISEND
122};
123
124static struct snd_ratden pod_ratden = {
125	.num_min = 78125,
126	.num_max = 78125,
127	.num_step = 1,
128	.den = 2
129};
130
131static struct line6_pcm_properties pod_pcm_properties = {
132	.playback_hw = {
133				  .info = (SNDRV_PCM_INFO_MMAP |
134					   SNDRV_PCM_INFO_INTERLEAVED |
135					   SNDRV_PCM_INFO_BLOCK_TRANSFER |
136					   SNDRV_PCM_INFO_MMAP_VALID |
137					   SNDRV_PCM_INFO_PAUSE |
138					   SNDRV_PCM_INFO_SYNC_START),
139				  .formats = SNDRV_PCM_FMTBIT_S24_3LE,
140				  .rates = SNDRV_PCM_RATE_KNOT,
141				  .rate_min = 39062,
142				  .rate_max = 39063,
143				  .channels_min = 2,
144				  .channels_max = 2,
145				  .buffer_bytes_max = 60000,
146				  .period_bytes_min = 64,
147				  .period_bytes_max = 8192,
148				  .periods_min = 1,
149				  .periods_max = 1024},
150	.capture_hw = {
151				 .info = (SNDRV_PCM_INFO_MMAP |
152					  SNDRV_PCM_INFO_INTERLEAVED |
153					  SNDRV_PCM_INFO_BLOCK_TRANSFER |
154					  SNDRV_PCM_INFO_MMAP_VALID |
155					  SNDRV_PCM_INFO_SYNC_START),
156				 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
157				 .rates = SNDRV_PCM_RATE_KNOT,
158				 .rate_min = 39062,
159				 .rate_max = 39063,
160				 .channels_min = 2,
161				 .channels_max = 2,
162				 .buffer_bytes_max = 60000,
163				 .period_bytes_min = 64,
164				 .period_bytes_max = 8192,
165				 .periods_min = 1,
166				 .periods_max = 1024},
167	.rates = {
168			    .nrats = 1,
169			    .rats = &pod_ratden},
170	.bytes_per_frame = POD_BYTES_PER_FRAME
171};
172
173static const char pod_version_header[] = {
174	0xf2, 0x7e, 0x7f, 0x06, 0x02
175};
176
177/* forward declarations: */
178static void pod_startup2(unsigned long data);
179static void pod_startup3(struct usb_line6_pod *pod);
180
181static char *pod_alloc_sysex_buffer(struct usb_line6_pod *pod, int code,
182				    int size)
183{
184	return line6_alloc_sysex_buffer(&pod->line6, POD_SYSEX_CODE, code,
185					size);
186}
187
188/*
189	Process a completely received message.
190*/
191static void line6_pod_process_message(struct usb_line6 *line6)
192{
193	struct usb_line6_pod *pod = (struct usb_line6_pod *) line6;
194	const unsigned char *buf = pod->line6.buffer_message;
195
196	if (memcmp(buf, pod_version_header, sizeof(pod_version_header)) == 0) {
197		pod->firmware_version = buf[13] * 100 + buf[14] * 10 + buf[15];
198		pod->device_id = ((int)buf[8] << 16) | ((int)buf[9] << 8) |
199				 (int) buf[10];
200		pod_startup3(pod);
201		return;
202	}
203
204	/* Only look for sysex messages from this device */
205	if (buf[0] != (LINE6_SYSEX_BEGIN | LINE6_CHANNEL_DEVICE) &&
206	    buf[0] != (LINE6_SYSEX_BEGIN | LINE6_CHANNEL_UNKNOWN)) {
207		return;
208	}
209	if (memcmp(buf + 1, line6_midi_id, sizeof(line6_midi_id)) != 0)
210		return;
211
212	if (buf[5] == POD_SYSEX_SYSTEM && buf[6] == POD_MONITOR_LEVEL) {
213		short value = ((int)buf[7] << 12) | ((int)buf[8] << 8) |
214			      ((int)buf[9] << 4) | (int)buf[10];
215		pod->monitor_level = value;
216	}
217}
218
219/*
220	Send system parameter (from integer).
221*/
222static int pod_set_system_param_int(struct usb_line6_pod *pod, int value,
223				    int code)
224{
225	char *sysex;
226	static const int size = 5;
227
228	sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_SYSTEM, size);
229	if (!sysex)
230		return -ENOMEM;
231	sysex[SYSEX_DATA_OFS] = code;
232	sysex[SYSEX_DATA_OFS + 1] = (value >> 12) & 0x0f;
233	sysex[SYSEX_DATA_OFS + 2] = (value >> 8) & 0x0f;
234	sysex[SYSEX_DATA_OFS + 3] = (value >> 4) & 0x0f;
235	sysex[SYSEX_DATA_OFS + 4] = (value) & 0x0f;
236	line6_send_sysex_message(&pod->line6, sysex, size);
237	kfree(sysex);
238	return 0;
239}
240
241/*
242	"read" request on "serial_number" special file.
243*/
244static ssize_t serial_number_show(struct device *dev,
245				  struct device_attribute *attr, char *buf)
246{
247	struct usb_interface *interface = to_usb_interface(dev);
248	struct usb_line6_pod *pod = usb_get_intfdata(interface);
249
250	return sprintf(buf, "%u\n", pod->serial_number);
251}
252
253/*
254	"read" request on "firmware_version" special file.
255*/
256static ssize_t firmware_version_show(struct device *dev,
257				     struct device_attribute *attr, char *buf)
258{
259	struct usb_interface *interface = to_usb_interface(dev);
260	struct usb_line6_pod *pod = usb_get_intfdata(interface);
261
262	return sprintf(buf, "%d.%02d\n", pod->firmware_version / 100,
263		       pod->firmware_version % 100);
264}
265
266/*
267	"read" request on "device_id" special file.
268*/
269static ssize_t device_id_show(struct device *dev,
270			      struct device_attribute *attr, char *buf)
271{
272	struct usb_interface *interface = to_usb_interface(dev);
273	struct usb_line6_pod *pod = usb_get_intfdata(interface);
274
275	return sprintf(buf, "%d\n", pod->device_id);
276}
277
278/*
279	POD startup procedure.
280	This is a sequence of functions with special requirements (e.g., must
281	not run immediately after initialization, must not run in interrupt
282	context). After the last one has finished, the device is ready to use.
283*/
284
285static void pod_startup1(struct usb_line6_pod *pod)
286{
287	CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_INIT);
288
289	/* delay startup procedure: */
290	line6_start_timer(&pod->startup_timer, POD_STARTUP_DELAY, pod_startup2,
291			  (unsigned long)pod);
292}
293
294static void pod_startup2(unsigned long data)
295{
296	struct usb_line6_pod *pod = (struct usb_line6_pod *)data;
297	struct usb_line6 *line6 = &pod->line6;
298
299	CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_VERSIONREQ);
300
301	/* request firmware version: */
302	line6_version_request_async(line6);
303}
304
305static void pod_startup3(struct usb_line6_pod *pod)
306{
307	CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_WORKQUEUE);
308
309	/* schedule work for global work queue: */
310	schedule_work(&pod->startup_work);
311}
312
313static void pod_startup4(struct work_struct *work)
314{
315	struct usb_line6_pod *pod =
316	    container_of(work, struct usb_line6_pod, startup_work);
317	struct usb_line6 *line6 = &pod->line6;
318
319	CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_SETUP);
320
321	/* serial number: */
322	line6_read_serial_number(&pod->line6, &pod->serial_number);
323
324	/* ALSA audio interface: */
325	snd_card_register(line6->card);
326}
327
328/* POD special files: */
329static DEVICE_ATTR_RO(device_id);
330static DEVICE_ATTR_RO(firmware_version);
331static DEVICE_ATTR_RO(serial_number);
332
333static struct attribute *pod_dev_attrs[] = {
334	&dev_attr_device_id.attr,
335	&dev_attr_firmware_version.attr,
336	&dev_attr_serial_number.attr,
337	NULL
338};
339
340static const struct attribute_group pod_dev_attr_group = {
341	.name = "pod",
342	.attrs = pod_dev_attrs,
343};
344
345/* control info callback */
346static int snd_pod_control_monitor_info(struct snd_kcontrol *kcontrol,
347					struct snd_ctl_elem_info *uinfo)
348{
349	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
350	uinfo->count = 1;
351	uinfo->value.integer.min = 0;
352	uinfo->value.integer.max = 65535;
353	return 0;
354}
355
356/* control get callback */
357static int snd_pod_control_monitor_get(struct snd_kcontrol *kcontrol,
358				       struct snd_ctl_elem_value *ucontrol)
359{
360	struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
361	struct usb_line6_pod *pod = (struct usb_line6_pod *)line6pcm->line6;
362
363	ucontrol->value.integer.value[0] = pod->monitor_level;
364	return 0;
365}
366
367/* control put callback */
368static int snd_pod_control_monitor_put(struct snd_kcontrol *kcontrol,
369				       struct snd_ctl_elem_value *ucontrol)
370{
371	struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
372	struct usb_line6_pod *pod = (struct usb_line6_pod *)line6pcm->line6;
373
374	if (ucontrol->value.integer.value[0] == pod->monitor_level)
375		return 0;
376
377	pod->monitor_level = ucontrol->value.integer.value[0];
378	pod_set_system_param_int(pod, ucontrol->value.integer.value[0],
379				 POD_MONITOR_LEVEL);
380	return 1;
381}
382
383/* control definition */
384static struct snd_kcontrol_new pod_control_monitor = {
385	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
386	.name = "Monitor Playback Volume",
387	.index = 0,
388	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
389	.info = snd_pod_control_monitor_info,
390	.get = snd_pod_control_monitor_get,
391	.put = snd_pod_control_monitor_put
392};
393
394/*
395	POD device disconnected.
396*/
397static void line6_pod_disconnect(struct usb_line6 *line6)
398{
399	struct usb_line6_pod *pod = (struct usb_line6_pod *)line6;
400
401	del_timer_sync(&pod->startup_timer);
402	cancel_work_sync(&pod->startup_work);
403}
404
405/*
406	 Try to init POD device.
407*/
408static int pod_init(struct usb_line6 *line6,
409		    const struct usb_device_id *id)
410{
411	int err;
412	struct usb_line6_pod *pod = (struct usb_line6_pod *) line6;
413
414	line6->process_message = line6_pod_process_message;
415	line6->disconnect = line6_pod_disconnect;
416
417	init_timer(&pod->startup_timer);
418	INIT_WORK(&pod->startup_work, pod_startup4);
419
420	/* create sysfs entries: */
421	err = snd_card_add_dev_attr(line6->card, &pod_dev_attr_group);
422	if (err < 0)
423		return err;
424
425	/* initialize MIDI subsystem: */
426	err = line6_init_midi(line6);
427	if (err < 0)
428		return err;
429
430	/* initialize PCM subsystem: */
431	err = line6_init_pcm(line6, &pod_pcm_properties);
432	if (err < 0)
433		return err;
434
435	/* register monitor control: */
436	err = snd_ctl_add(line6->card,
437			  snd_ctl_new1(&pod_control_monitor, line6->line6pcm));
438	if (err < 0)
439		return err;
440
441	/*
442	   When the sound card is registered at this point, the PODxt Live
443	   displays "Invalid Code Error 07", so we do it later in the event
444	   handler.
445	 */
446
447	if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL) {
448		pod->monitor_level = POD_SYSTEM_INVALID;
449
450		/* initiate startup procedure: */
451		pod_startup1(pod);
452	}
453
454	return 0;
455}
456
457#define LINE6_DEVICE(prod) USB_DEVICE(0x0e41, prod)
458#define LINE6_IF_NUM(prod, n) USB_DEVICE_INTERFACE_NUMBER(0x0e41, prod, n)
459
460/* table of devices that work with this driver */
461static const struct usb_device_id pod_id_table[] = {
462	{ LINE6_DEVICE(0x4250),    .driver_info = LINE6_BASSPODXT },
463	{ LINE6_DEVICE(0x4642),    .driver_info = LINE6_BASSPODXTLIVE },
464	{ LINE6_DEVICE(0x4252),    .driver_info = LINE6_BASSPODXTPRO },
465	{ LINE6_IF_NUM(0x5051, 1), .driver_info = LINE6_POCKETPOD },
466	{ LINE6_DEVICE(0x5044),    .driver_info = LINE6_PODXT },
467	{ LINE6_IF_NUM(0x4650, 0), .driver_info = LINE6_PODXTLIVE_POD },
468	{ LINE6_DEVICE(0x5050),    .driver_info = LINE6_PODXTPRO },
469	{}
470};
471
472MODULE_DEVICE_TABLE(usb, pod_id_table);
473
474static const struct line6_properties pod_properties_table[] = {
475	[LINE6_BASSPODXT] = {
476		.id = "BassPODxt",
477		.name = "BassPODxt",
478		.capabilities	= LINE6_CAP_CONTROL
479				| LINE6_CAP_PCM
480				| LINE6_CAP_HWMON,
481		.altsetting = 5,
482		.ep_ctrl_r = 0x84,
483		.ep_ctrl_w = 0x03,
484		.ep_audio_r = 0x82,
485		.ep_audio_w = 0x01,
486	},
487	[LINE6_BASSPODXTLIVE] = {
488		.id = "BassPODxtLive",
489		.name = "BassPODxt Live",
490		.capabilities	= LINE6_CAP_CONTROL
491				| LINE6_CAP_PCM
492				| LINE6_CAP_HWMON,
493		.altsetting = 1,
494		.ep_ctrl_r = 0x84,
495		.ep_ctrl_w = 0x03,
496		.ep_audio_r = 0x82,
497		.ep_audio_w = 0x01,
498	},
499	[LINE6_BASSPODXTPRO] = {
500		.id = "BassPODxtPro",
501		.name = "BassPODxt Pro",
502		.capabilities	= LINE6_CAP_CONTROL
503				| LINE6_CAP_PCM
504				| LINE6_CAP_HWMON,
505		.altsetting = 5,
506		.ep_ctrl_r = 0x84,
507		.ep_ctrl_w = 0x03,
508		.ep_audio_r = 0x82,
509		.ep_audio_w = 0x01,
510	},
511	[LINE6_POCKETPOD] = {
512		.id = "PocketPOD",
513		.name = "Pocket POD",
514		.capabilities	= LINE6_CAP_CONTROL,
515		.altsetting = 0,
516		.ep_ctrl_r = 0x82,
517		.ep_ctrl_w = 0x02,
518		/* no audio channel */
519	},
520	[LINE6_PODXT] = {
521		.id = "PODxt",
522		.name = "PODxt",
523		.capabilities	= LINE6_CAP_CONTROL
524				| LINE6_CAP_PCM
525				| LINE6_CAP_HWMON,
526		.altsetting = 5,
527		.ep_ctrl_r = 0x84,
528		.ep_ctrl_w = 0x03,
529		.ep_audio_r = 0x82,
530		.ep_audio_w = 0x01,
531	},
532	[LINE6_PODXTLIVE_POD] = {
533		.id = "PODxtLive",
534		.name = "PODxt Live",
535		.capabilities	= LINE6_CAP_CONTROL
536				| LINE6_CAP_PCM
537				| LINE6_CAP_HWMON,
538		.altsetting = 1,
539		.ep_ctrl_r = 0x84,
540		.ep_ctrl_w = 0x03,
541		.ep_audio_r = 0x82,
542		.ep_audio_w = 0x01,
543	},
544	[LINE6_PODXTPRO] = {
545		.id = "PODxtPro",
546		.name = "PODxt Pro",
547		.capabilities	= LINE6_CAP_CONTROL
548				| LINE6_CAP_PCM
549				| LINE6_CAP_HWMON,
550		.altsetting = 5,
551		.ep_ctrl_r = 0x84,
552		.ep_ctrl_w = 0x03,
553		.ep_audio_r = 0x82,
554		.ep_audio_w = 0x01,
555	},
556};
557
558/*
559	Probe USB device.
560*/
561static int pod_probe(struct usb_interface *interface,
562		     const struct usb_device_id *id)
563{
564	return line6_probe(interface, id, "Line6-POD",
565			   &pod_properties_table[id->driver_info],
566			   pod_init, sizeof(struct usb_line6_pod));
567}
568
569static struct usb_driver pod_driver = {
570	.name = KBUILD_MODNAME,
571	.probe = pod_probe,
572	.disconnect = line6_disconnect,
573#ifdef CONFIG_PM
574	.suspend = line6_suspend,
575	.resume = line6_resume,
576	.reset_resume = line6_resume,
577#endif
578	.id_table = pod_id_table,
579};
580
581module_usb_driver(pod_driver);
582
583MODULE_DESCRIPTION("Line 6 POD USB driver");
584MODULE_LICENSE("GPL");
585