1/*
2 * caiaq.c: ALSA driver for caiaq/NativeInstruments devices
3 *
4 *   Copyright (c) 2007 Daniel Mack <daniel@caiaq.de>
5 *                      Karsten Wiese <fzu@wemgehoertderstaat.de>
6 *
7 *   This program is free software; you can redistribute it and/or modify
8 *   it under the terms of the GNU General Public License as published by
9 *   the Free Software Foundation; either version 2 of the License, or
10 *   (at your option) any later version.
11 *
12 *   This program is distributed in the hope that it will be useful,
13 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 *   GNU General Public License for more details.
16 *
17 *   You should have received a copy of the GNU General Public License
18 *   along with this program; if not, write to the Free Software
19 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
20*/
21
22#include <linux/moduleparam.h>
23#include <linux/device.h>
24#include <linux/interrupt.h>
25#include <linux/module.h>
26#include <linux/init.h>
27#include <linux/gfp.h>
28#include <linux/usb.h>
29#include <sound/initval.h>
30#include <sound/core.h>
31#include <sound/pcm.h>
32
33#include "device.h"
34#include "audio.h"
35#include "midi.h"
36#include "control.h"
37#include "input.h"
38
39MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>");
40MODULE_DESCRIPTION("caiaq USB audio");
41MODULE_LICENSE("GPL");
42MODULE_SUPPORTED_DEVICE("{{Native Instruments,RigKontrol2},"
43			 "{Native Instruments,RigKontrol3},"
44			 "{Native Instruments,Kore Controller},"
45			 "{Native Instruments,Kore Controller 2},"
46			 "{Native Instruments,Audio Kontrol 1},"
47			 "{Native Instruments,Audio 2 DJ},"
48			 "{Native Instruments,Audio 4 DJ},"
49			 "{Native Instruments,Audio 8 DJ},"
50			 "{Native Instruments,Traktor Audio 2},"
51			 "{Native Instruments,Session I/O},"
52			 "{Native Instruments,GuitarRig mobile},"
53			 "{Native Instruments,Traktor Kontrol X1},"
54			 "{Native Instruments,Traktor Kontrol S4},"
55			 "{Native Instruments,Maschine Controller}}");
56
57static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-max */
58static char* id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* Id for this card */
59static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */
60
61module_param_array(index, int, NULL, 0444);
62MODULE_PARM_DESC(index, "Index value for the caiaq sound device");
63module_param_array(id, charp, NULL, 0444);
64MODULE_PARM_DESC(id, "ID string for the caiaq soundcard.");
65module_param_array(enable, bool, NULL, 0444);
66MODULE_PARM_DESC(enable, "Enable the caiaq soundcard.");
67
68enum {
69	SAMPLERATE_44100	= 0,
70	SAMPLERATE_48000	= 1,
71	SAMPLERATE_96000	= 2,
72	SAMPLERATE_192000	= 3,
73	SAMPLERATE_88200	= 4,
74	SAMPLERATE_INVALID	= 0xff
75};
76
77enum {
78	DEPTH_NONE	= 0,
79	DEPTH_16	= 1,
80	DEPTH_24	= 2,
81	DEPTH_32	= 3
82};
83
84static struct usb_device_id snd_usb_id_table[] = {
85	{
86		.match_flags =	USB_DEVICE_ID_MATCH_DEVICE,
87		.idVendor =	USB_VID_NATIVEINSTRUMENTS,
88		.idProduct =	USB_PID_RIGKONTROL2
89	},
90	{
91		.match_flags =	USB_DEVICE_ID_MATCH_DEVICE,
92		.idVendor =	USB_VID_NATIVEINSTRUMENTS,
93		.idProduct =	USB_PID_RIGKONTROL3
94	},
95	{
96		.match_flags =	USB_DEVICE_ID_MATCH_DEVICE,
97		.idVendor =	USB_VID_NATIVEINSTRUMENTS,
98		.idProduct =	USB_PID_KORECONTROLLER
99	},
100	{
101		.match_flags =	USB_DEVICE_ID_MATCH_DEVICE,
102		.idVendor =	USB_VID_NATIVEINSTRUMENTS,
103		.idProduct =	USB_PID_KORECONTROLLER2
104	},
105	{
106		.match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
107		.idVendor =     USB_VID_NATIVEINSTRUMENTS,
108		.idProduct =    USB_PID_AK1
109	},
110	{
111		.match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
112		.idVendor =     USB_VID_NATIVEINSTRUMENTS,
113		.idProduct =    USB_PID_AUDIO8DJ
114	},
115	{
116		.match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
117		.idVendor =     USB_VID_NATIVEINSTRUMENTS,
118		.idProduct =    USB_PID_SESSIONIO
119	},
120	{
121		.match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
122		.idVendor =     USB_VID_NATIVEINSTRUMENTS,
123		.idProduct =    USB_PID_GUITARRIGMOBILE
124	},
125	{
126		.match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
127		.idVendor =     USB_VID_NATIVEINSTRUMENTS,
128		.idProduct =    USB_PID_AUDIO4DJ
129	},
130	{
131		.match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
132		.idVendor =     USB_VID_NATIVEINSTRUMENTS,
133		.idProduct =    USB_PID_AUDIO2DJ
134	},
135	{
136		.match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
137		.idVendor =     USB_VID_NATIVEINSTRUMENTS,
138		.idProduct =    USB_PID_TRAKTORKONTROLX1
139	},
140	{
141		.match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
142		.idVendor =     USB_VID_NATIVEINSTRUMENTS,
143		.idProduct =    USB_PID_TRAKTORKONTROLS4
144	},
145	{
146		.match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
147		.idVendor =     USB_VID_NATIVEINSTRUMENTS,
148		.idProduct =    USB_PID_TRAKTORAUDIO2
149	},
150	{
151		.match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
152		.idVendor =     USB_VID_NATIVEINSTRUMENTS,
153		.idProduct =    USB_PID_MASCHINECONTROLLER
154	},
155	{ /* terminator */ }
156};
157
158static void usb_ep1_command_reply_dispatch (struct urb* urb)
159{
160	int ret;
161	struct device *dev = &urb->dev->dev;
162	struct snd_usb_caiaqdev *cdev = urb->context;
163	unsigned char *buf = urb->transfer_buffer;
164
165	if (urb->status || !cdev) {
166		dev_warn(dev, "received EP1 urb->status = %i\n", urb->status);
167		return;
168	}
169
170	switch(buf[0]) {
171	case EP1_CMD_GET_DEVICE_INFO:
172	 	memcpy(&cdev->spec, buf+1, sizeof(struct caiaq_device_spec));
173		cdev->spec.fw_version = le16_to_cpu(cdev->spec.fw_version);
174		dev_dbg(dev, "device spec (firmware %d): audio: %d in, %d out, "
175			"MIDI: %d in, %d out, data alignment %d\n",
176			cdev->spec.fw_version,
177			cdev->spec.num_analog_audio_in,
178			cdev->spec.num_analog_audio_out,
179			cdev->spec.num_midi_in,
180			cdev->spec.num_midi_out,
181			cdev->spec.data_alignment);
182
183		cdev->spec_received++;
184		wake_up(&cdev->ep1_wait_queue);
185		break;
186	case EP1_CMD_AUDIO_PARAMS:
187		cdev->audio_parm_answer = buf[1];
188		wake_up(&cdev->ep1_wait_queue);
189		break;
190	case EP1_CMD_MIDI_READ:
191		snd_usb_caiaq_midi_handle_input(cdev, buf[1], buf + 3, buf[2]);
192		break;
193	case EP1_CMD_READ_IO:
194		if (cdev->chip.usb_id ==
195			USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ)) {
196			if (urb->actual_length > sizeof(cdev->control_state))
197				urb->actual_length = sizeof(cdev->control_state);
198			memcpy(cdev->control_state, buf + 1, urb->actual_length);
199			wake_up(&cdev->ep1_wait_queue);
200			break;
201		}
202#ifdef CONFIG_SND_USB_CAIAQ_INPUT
203	case EP1_CMD_READ_ERP:
204	case EP1_CMD_READ_ANALOG:
205		snd_usb_caiaq_input_dispatch(cdev, buf, urb->actual_length);
206#endif
207		break;
208	}
209
210	cdev->ep1_in_urb.actual_length = 0;
211	ret = usb_submit_urb(&cdev->ep1_in_urb, GFP_ATOMIC);
212	if (ret < 0)
213		dev_err(dev, "unable to submit urb. OOM!?\n");
214}
215
216int snd_usb_caiaq_send_command(struct snd_usb_caiaqdev *cdev,
217			       unsigned char command,
218			       const unsigned char *buffer,
219			       int len)
220{
221	int actual_len;
222	struct usb_device *usb_dev = cdev->chip.dev;
223
224	if (!usb_dev)
225		return -EIO;
226
227	if (len > EP1_BUFSIZE - 1)
228		len = EP1_BUFSIZE - 1;
229
230	if (buffer && len > 0)
231		memcpy(cdev->ep1_out_buf+1, buffer, len);
232
233	cdev->ep1_out_buf[0] = command;
234	return usb_bulk_msg(usb_dev, usb_sndbulkpipe(usb_dev, 1),
235			   cdev->ep1_out_buf, len+1, &actual_len, 200);
236}
237
238int snd_usb_caiaq_send_command_bank(struct snd_usb_caiaqdev *cdev,
239			       unsigned char command,
240			       unsigned char bank,
241			       const unsigned char *buffer,
242			       int len)
243{
244	int actual_len;
245	struct usb_device *usb_dev = cdev->chip.dev;
246
247	if (!usb_dev)
248		return -EIO;
249
250	if (len > EP1_BUFSIZE - 2)
251		len = EP1_BUFSIZE - 2;
252
253	if (buffer && len > 0)
254		memcpy(cdev->ep1_out_buf+2, buffer, len);
255
256	cdev->ep1_out_buf[0] = command;
257	cdev->ep1_out_buf[1] = bank;
258
259	return usb_bulk_msg(usb_dev, usb_sndbulkpipe(usb_dev, 1),
260			   cdev->ep1_out_buf, len+2, &actual_len, 200);
261}
262
263int snd_usb_caiaq_set_audio_params (struct snd_usb_caiaqdev *cdev,
264		   		    int rate, int depth, int bpp)
265{
266	int ret;
267	char tmp[5];
268	struct device *dev = caiaqdev_to_dev(cdev);
269
270	switch (rate) {
271	case 44100:	tmp[0] = SAMPLERATE_44100;   break;
272	case 48000:	tmp[0] = SAMPLERATE_48000;   break;
273	case 88200:	tmp[0] = SAMPLERATE_88200;   break;
274	case 96000:	tmp[0] = SAMPLERATE_96000;   break;
275	case 192000:	tmp[0] = SAMPLERATE_192000;  break;
276	default:	return -EINVAL;
277	}
278
279	switch (depth) {
280	case 16:	tmp[1] = DEPTH_16;   break;
281	case 24:	tmp[1] = DEPTH_24;   break;
282	default:	return -EINVAL;
283	}
284
285	tmp[2] = bpp & 0xff;
286	tmp[3] = bpp >> 8;
287	tmp[4] = 1; /* packets per microframe */
288
289	dev_dbg(dev, "setting audio params: %d Hz, %d bits, %d bpp\n",
290		rate, depth, bpp);
291
292	cdev->audio_parm_answer = -1;
293	ret = snd_usb_caiaq_send_command(cdev, EP1_CMD_AUDIO_PARAMS,
294					 tmp, sizeof(tmp));
295
296	if (ret)
297		return ret;
298
299	if (!wait_event_timeout(cdev->ep1_wait_queue,
300	    cdev->audio_parm_answer >= 0, HZ))
301		return -EPIPE;
302
303	if (cdev->audio_parm_answer != 1)
304		dev_dbg(dev, "unable to set the device's audio params\n");
305	else
306		cdev->bpp = bpp;
307
308	return cdev->audio_parm_answer == 1 ? 0 : -EINVAL;
309}
310
311int snd_usb_caiaq_set_auto_msg(struct snd_usb_caiaqdev *cdev,
312			       int digital, int analog, int erp)
313{
314	char tmp[3] = { digital, analog, erp };
315	return snd_usb_caiaq_send_command(cdev, EP1_CMD_AUTO_MSG,
316					  tmp, sizeof(tmp));
317}
318
319static void setup_card(struct snd_usb_caiaqdev *cdev)
320{
321	int ret;
322	char val[4];
323	struct device *dev = caiaqdev_to_dev(cdev);
324
325	/* device-specific startup specials */
326	switch (cdev->chip.usb_id) {
327	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2):
328		/* RigKontrol2 - display centered dash ('-') */
329		val[0] = 0x00;
330		val[1] = 0x00;
331		val[2] = 0x01;
332		snd_usb_caiaq_send_command(cdev, EP1_CMD_WRITE_IO, val, 3);
333		break;
334	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3):
335		/* RigKontrol2 - display two centered dashes ('--') */
336		val[0] = 0x00;
337		val[1] = 0x40;
338		val[2] = 0x40;
339		val[3] = 0x00;
340		snd_usb_caiaq_send_command(cdev, EP1_CMD_WRITE_IO, val, 4);
341		break;
342	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1):
343		/* Audio Kontrol 1 - make USB-LED stop blinking */
344		val[0] = 0x00;
345		snd_usb_caiaq_send_command(cdev, EP1_CMD_WRITE_IO, val, 1);
346		break;
347	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ):
348		/* Audio 8 DJ - trigger read of current settings */
349		cdev->control_state[0] = 0xff;
350		snd_usb_caiaq_set_auto_msg(cdev, 1, 0, 0);
351		snd_usb_caiaq_send_command(cdev, EP1_CMD_READ_IO, NULL, 0);
352
353		if (!wait_event_timeout(cdev->ep1_wait_queue,
354					cdev->control_state[0] != 0xff, HZ))
355			return;
356
357		/* fix up some defaults */
358		if ((cdev->control_state[1] != 2) ||
359		    (cdev->control_state[2] != 3) ||
360		    (cdev->control_state[4] != 2)) {
361			cdev->control_state[1] = 2;
362			cdev->control_state[2] = 3;
363			cdev->control_state[4] = 2;
364			snd_usb_caiaq_send_command(cdev,
365				EP1_CMD_WRITE_IO, cdev->control_state, 6);
366		}
367
368		break;
369	}
370
371	if (cdev->spec.num_analog_audio_out +
372	    cdev->spec.num_analog_audio_in +
373	    cdev->spec.num_digital_audio_out +
374	    cdev->spec.num_digital_audio_in > 0) {
375		ret = snd_usb_caiaq_audio_init(cdev);
376		if (ret < 0)
377			dev_err(dev, "Unable to set up audio system (ret=%d)\n", ret);
378	}
379
380	if (cdev->spec.num_midi_in +
381	    cdev->spec.num_midi_out > 0) {
382		ret = snd_usb_caiaq_midi_init(cdev);
383		if (ret < 0)
384			dev_err(dev, "Unable to set up MIDI system (ret=%d)\n", ret);
385	}
386
387#ifdef CONFIG_SND_USB_CAIAQ_INPUT
388	ret = snd_usb_caiaq_input_init(cdev);
389	if (ret < 0)
390		dev_err(dev, "Unable to set up input system (ret=%d)\n", ret);
391#endif
392
393	/* finally, register the card and all its sub-instances */
394	ret = snd_card_register(cdev->chip.card);
395	if (ret < 0) {
396		dev_err(dev, "snd_card_register() returned %d\n", ret);
397		snd_card_free(cdev->chip.card);
398	}
399
400	ret = snd_usb_caiaq_control_init(cdev);
401	if (ret < 0)
402		dev_err(dev, "Unable to set up control system (ret=%d)\n", ret);
403}
404
405static int create_card(struct usb_device *usb_dev,
406		       struct usb_interface *intf,
407		       struct snd_card **cardp)
408{
409	int devnum;
410	int err;
411	struct snd_card *card;
412	struct snd_usb_caiaqdev *cdev;
413
414	for (devnum = 0; devnum < SNDRV_CARDS; devnum++)
415		if (enable[devnum])
416			break;
417
418	if (devnum >= SNDRV_CARDS)
419		return -ENODEV;
420
421	err = snd_card_new(&intf->dev,
422			   index[devnum], id[devnum], THIS_MODULE,
423			   sizeof(struct snd_usb_caiaqdev), &card);
424	if (err < 0)
425		return err;
426
427	cdev = caiaqdev(card);
428	cdev->chip.dev = usb_dev;
429	cdev->chip.card = card;
430	cdev->chip.usb_id = USB_ID(le16_to_cpu(usb_dev->descriptor.idVendor),
431				  le16_to_cpu(usb_dev->descriptor.idProduct));
432	spin_lock_init(&cdev->spinlock);
433
434	*cardp = card;
435	return 0;
436}
437
438static int init_card(struct snd_usb_caiaqdev *cdev)
439{
440	char *c, usbpath[32];
441	struct usb_device *usb_dev = cdev->chip.dev;
442	struct snd_card *card = cdev->chip.card;
443	struct device *dev = caiaqdev_to_dev(cdev);
444	int err, len;
445
446	if (usb_set_interface(usb_dev, 0, 1) != 0) {
447		dev_err(dev, "can't set alt interface.\n");
448		return -EIO;
449	}
450
451	usb_init_urb(&cdev->ep1_in_urb);
452	usb_init_urb(&cdev->midi_out_urb);
453
454	usb_fill_bulk_urb(&cdev->ep1_in_urb, usb_dev,
455			  usb_rcvbulkpipe(usb_dev, 0x1),
456			  cdev->ep1_in_buf, EP1_BUFSIZE,
457			  usb_ep1_command_reply_dispatch, cdev);
458
459	usb_fill_bulk_urb(&cdev->midi_out_urb, usb_dev,
460			  usb_sndbulkpipe(usb_dev, 0x1),
461			  cdev->midi_out_buf, EP1_BUFSIZE,
462			  snd_usb_caiaq_midi_output_done, cdev);
463
464	init_waitqueue_head(&cdev->ep1_wait_queue);
465	init_waitqueue_head(&cdev->prepare_wait_queue);
466
467	if (usb_submit_urb(&cdev->ep1_in_urb, GFP_KERNEL) != 0)
468		return -EIO;
469
470	err = snd_usb_caiaq_send_command(cdev, EP1_CMD_GET_DEVICE_INFO, NULL, 0);
471	if (err)
472		return err;
473
474	if (!wait_event_timeout(cdev->ep1_wait_queue, cdev->spec_received, HZ))
475		return -ENODEV;
476
477	usb_string(usb_dev, usb_dev->descriptor.iManufacturer,
478		   cdev->vendor_name, CAIAQ_USB_STR_LEN);
479
480	usb_string(usb_dev, usb_dev->descriptor.iProduct,
481		   cdev->product_name, CAIAQ_USB_STR_LEN);
482
483	strlcpy(card->driver, MODNAME, sizeof(card->driver));
484	strlcpy(card->shortname, cdev->product_name, sizeof(card->shortname));
485	strlcpy(card->mixername, cdev->product_name, sizeof(card->mixername));
486
487	/* if the id was not passed as module option, fill it with a shortened
488	 * version of the product string which does not contain any
489	 * whitespaces */
490
491	if (*card->id == '\0') {
492		char id[sizeof(card->id)];
493
494		memset(id, 0, sizeof(id));
495
496		for (c = card->shortname, len = 0;
497			*c && len < sizeof(card->id); c++)
498			if (*c != ' ')
499				id[len++] = *c;
500
501		snd_card_set_id(card, id);
502	}
503
504	usb_make_path(usb_dev, usbpath, sizeof(usbpath));
505	snprintf(card->longname, sizeof(card->longname), "%s %s (%s)",
506		       cdev->vendor_name, cdev->product_name, usbpath);
507
508	setup_card(cdev);
509	return 0;
510}
511
512static int snd_probe(struct usb_interface *intf,
513		     const struct usb_device_id *id)
514{
515	int ret;
516	struct snd_card *card = NULL;
517	struct usb_device *usb_dev = interface_to_usbdev(intf);
518
519	ret = create_card(usb_dev, intf, &card);
520
521	if (ret < 0)
522		return ret;
523
524	usb_set_intfdata(intf, card);
525	ret = init_card(caiaqdev(card));
526	if (ret < 0) {
527		dev_err(&usb_dev->dev, "unable to init card! (ret=%d)\n", ret);
528		snd_card_free(card);
529		return ret;
530	}
531
532	return 0;
533}
534
535static void snd_disconnect(struct usb_interface *intf)
536{
537	struct snd_card *card = usb_get_intfdata(intf);
538	struct device *dev = intf->usb_dev;
539	struct snd_usb_caiaqdev *cdev;
540
541	if (!card)
542		return;
543
544	cdev = caiaqdev(card);
545	dev_dbg(dev, "%s(%p)\n", __func__, intf);
546
547	snd_card_disconnect(card);
548
549#ifdef CONFIG_SND_USB_CAIAQ_INPUT
550	snd_usb_caiaq_input_free(cdev);
551#endif
552	snd_usb_caiaq_audio_free(cdev);
553
554	usb_kill_urb(&cdev->ep1_in_urb);
555	usb_kill_urb(&cdev->midi_out_urb);
556
557	snd_card_free(card);
558	usb_reset_device(interface_to_usbdev(intf));
559}
560
561
562MODULE_DEVICE_TABLE(usb, snd_usb_id_table);
563static struct usb_driver snd_usb_driver = {
564	.name 		= MODNAME,
565	.probe 		= snd_probe,
566	.disconnect	= snd_disconnect,
567	.id_table 	= snd_usb_id_table,
568};
569
570module_usb_driver(snd_usb_driver);
571