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 39 MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>"); 40 MODULE_DESCRIPTION("caiaq USB audio"); 41 MODULE_LICENSE("GPL"); 42 MODULE_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 57 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-max */ 58 static char* id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* Id for this card */ 59 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */ 60 61 module_param_array(index, int, NULL, 0444); 62 MODULE_PARM_DESC(index, "Index value for the caiaq sound device"); 63 module_param_array(id, charp, NULL, 0444); 64 MODULE_PARM_DESC(id, "ID string for the caiaq soundcard."); 65 module_param_array(enable, bool, NULL, 0444); 66 MODULE_PARM_DESC(enable, "Enable the caiaq soundcard."); 67 68 enum { 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 77 enum { 78 DEPTH_NONE = 0, 79 DEPTH_16 = 1, 80 DEPTH_24 = 2, 81 DEPTH_32 = 3 82 }; 83 84 static 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 158 static 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 216 int 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 238 int snd_usb_caiaq_set_audio_params (struct snd_usb_caiaqdev *cdev, 239 int rate, int depth, int bpp) 240 { 241 int ret; 242 char tmp[5]; 243 struct device *dev = caiaqdev_to_dev(cdev); 244 245 switch (rate) { 246 case 44100: tmp[0] = SAMPLERATE_44100; break; 247 case 48000: tmp[0] = SAMPLERATE_48000; break; 248 case 88200: tmp[0] = SAMPLERATE_88200; break; 249 case 96000: tmp[0] = SAMPLERATE_96000; break; 250 case 192000: tmp[0] = SAMPLERATE_192000; break; 251 default: return -EINVAL; 252 } 253 254 switch (depth) { 255 case 16: tmp[1] = DEPTH_16; break; 256 case 24: tmp[1] = DEPTH_24; break; 257 default: return -EINVAL; 258 } 259 260 tmp[2] = bpp & 0xff; 261 tmp[3] = bpp >> 8; 262 tmp[4] = 1; /* packets per microframe */ 263 264 dev_dbg(dev, "setting audio params: %d Hz, %d bits, %d bpp\n", 265 rate, depth, bpp); 266 267 cdev->audio_parm_answer = -1; 268 ret = snd_usb_caiaq_send_command(cdev, EP1_CMD_AUDIO_PARAMS, 269 tmp, sizeof(tmp)); 270 271 if (ret) 272 return ret; 273 274 if (!wait_event_timeout(cdev->ep1_wait_queue, 275 cdev->audio_parm_answer >= 0, HZ)) 276 return -EPIPE; 277 278 if (cdev->audio_parm_answer != 1) 279 dev_dbg(dev, "unable to set the device's audio params\n"); 280 else 281 cdev->bpp = bpp; 282 283 return cdev->audio_parm_answer == 1 ? 0 : -EINVAL; 284 } 285 286 int snd_usb_caiaq_set_auto_msg(struct snd_usb_caiaqdev *cdev, 287 int digital, int analog, int erp) 288 { 289 char tmp[3] = { digital, analog, erp }; 290 return snd_usb_caiaq_send_command(cdev, EP1_CMD_AUTO_MSG, 291 tmp, sizeof(tmp)); 292 } 293 294 static void setup_card(struct snd_usb_caiaqdev *cdev) 295 { 296 int ret; 297 char val[4]; 298 struct device *dev = caiaqdev_to_dev(cdev); 299 300 /* device-specific startup specials */ 301 switch (cdev->chip.usb_id) { 302 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2): 303 /* RigKontrol2 - display centered dash ('-') */ 304 val[0] = 0x00; 305 val[1] = 0x00; 306 val[2] = 0x01; 307 snd_usb_caiaq_send_command(cdev, EP1_CMD_WRITE_IO, val, 3); 308 break; 309 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3): 310 /* RigKontrol2 - display two centered dashes ('--') */ 311 val[0] = 0x00; 312 val[1] = 0x40; 313 val[2] = 0x40; 314 val[3] = 0x00; 315 snd_usb_caiaq_send_command(cdev, EP1_CMD_WRITE_IO, val, 4); 316 break; 317 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1): 318 /* Audio Kontrol 1 - make USB-LED stop blinking */ 319 val[0] = 0x00; 320 snd_usb_caiaq_send_command(cdev, EP1_CMD_WRITE_IO, val, 1); 321 break; 322 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ): 323 /* Audio 8 DJ - trigger read of current settings */ 324 cdev->control_state[0] = 0xff; 325 snd_usb_caiaq_set_auto_msg(cdev, 1, 0, 0); 326 snd_usb_caiaq_send_command(cdev, EP1_CMD_READ_IO, NULL, 0); 327 328 if (!wait_event_timeout(cdev->ep1_wait_queue, 329 cdev->control_state[0] != 0xff, HZ)) 330 return; 331 332 /* fix up some defaults */ 333 if ((cdev->control_state[1] != 2) || 334 (cdev->control_state[2] != 3) || 335 (cdev->control_state[4] != 2)) { 336 cdev->control_state[1] = 2; 337 cdev->control_state[2] = 3; 338 cdev->control_state[4] = 2; 339 snd_usb_caiaq_send_command(cdev, 340 EP1_CMD_WRITE_IO, cdev->control_state, 6); 341 } 342 343 break; 344 } 345 346 if (cdev->spec.num_analog_audio_out + 347 cdev->spec.num_analog_audio_in + 348 cdev->spec.num_digital_audio_out + 349 cdev->spec.num_digital_audio_in > 0) { 350 ret = snd_usb_caiaq_audio_init(cdev); 351 if (ret < 0) 352 dev_err(dev, "Unable to set up audio system (ret=%d)\n", ret); 353 } 354 355 if (cdev->spec.num_midi_in + 356 cdev->spec.num_midi_out > 0) { 357 ret = snd_usb_caiaq_midi_init(cdev); 358 if (ret < 0) 359 dev_err(dev, "Unable to set up MIDI system (ret=%d)\n", ret); 360 } 361 362 #ifdef CONFIG_SND_USB_CAIAQ_INPUT 363 ret = snd_usb_caiaq_input_init(cdev); 364 if (ret < 0) 365 dev_err(dev, "Unable to set up input system (ret=%d)\n", ret); 366 #endif 367 368 /* finally, register the card and all its sub-instances */ 369 ret = snd_card_register(cdev->chip.card); 370 if (ret < 0) { 371 dev_err(dev, "snd_card_register() returned %d\n", ret); 372 snd_card_free(cdev->chip.card); 373 } 374 375 ret = snd_usb_caiaq_control_init(cdev); 376 if (ret < 0) 377 dev_err(dev, "Unable to set up control system (ret=%d)\n", ret); 378 } 379 380 static int create_card(struct usb_device *usb_dev, 381 struct usb_interface *intf, 382 struct snd_card **cardp) 383 { 384 int devnum; 385 int err; 386 struct snd_card *card; 387 struct snd_usb_caiaqdev *cdev; 388 389 for (devnum = 0; devnum < SNDRV_CARDS; devnum++) 390 if (enable[devnum]) 391 break; 392 393 if (devnum >= SNDRV_CARDS) 394 return -ENODEV; 395 396 err = snd_card_create(index[devnum], id[devnum], THIS_MODULE, 397 sizeof(struct snd_usb_caiaqdev), &card); 398 if (err < 0) 399 return err; 400 401 cdev = caiaqdev(card); 402 cdev->chip.dev = usb_dev; 403 cdev->chip.card = card; 404 cdev->chip.usb_id = USB_ID(le16_to_cpu(usb_dev->descriptor.idVendor), 405 le16_to_cpu(usb_dev->descriptor.idProduct)); 406 spin_lock_init(&cdev->spinlock); 407 snd_card_set_dev(card, &intf->dev); 408 409 *cardp = card; 410 return 0; 411 } 412 413 static int init_card(struct snd_usb_caiaqdev *cdev) 414 { 415 char *c, usbpath[32]; 416 struct usb_device *usb_dev = cdev->chip.dev; 417 struct snd_card *card = cdev->chip.card; 418 struct device *dev = caiaqdev_to_dev(cdev); 419 int err, len; 420 421 if (usb_set_interface(usb_dev, 0, 1) != 0) { 422 dev_err(dev, "can't set alt interface.\n"); 423 return -EIO; 424 } 425 426 usb_init_urb(&cdev->ep1_in_urb); 427 usb_init_urb(&cdev->midi_out_urb); 428 429 usb_fill_bulk_urb(&cdev->ep1_in_urb, usb_dev, 430 usb_rcvbulkpipe(usb_dev, 0x1), 431 cdev->ep1_in_buf, EP1_BUFSIZE, 432 usb_ep1_command_reply_dispatch, cdev); 433 434 usb_fill_bulk_urb(&cdev->midi_out_urb, usb_dev, 435 usb_sndbulkpipe(usb_dev, 0x1), 436 cdev->midi_out_buf, EP1_BUFSIZE, 437 snd_usb_caiaq_midi_output_done, cdev); 438 439 init_waitqueue_head(&cdev->ep1_wait_queue); 440 init_waitqueue_head(&cdev->prepare_wait_queue); 441 442 if (usb_submit_urb(&cdev->ep1_in_urb, GFP_KERNEL) != 0) 443 return -EIO; 444 445 err = snd_usb_caiaq_send_command(cdev, EP1_CMD_GET_DEVICE_INFO, NULL, 0); 446 if (err) 447 return err; 448 449 if (!wait_event_timeout(cdev->ep1_wait_queue, cdev->spec_received, HZ)) 450 return -ENODEV; 451 452 usb_string(usb_dev, usb_dev->descriptor.iManufacturer, 453 cdev->vendor_name, CAIAQ_USB_STR_LEN); 454 455 usb_string(usb_dev, usb_dev->descriptor.iProduct, 456 cdev->product_name, CAIAQ_USB_STR_LEN); 457 458 strlcpy(card->driver, MODNAME, sizeof(card->driver)); 459 strlcpy(card->shortname, cdev->product_name, sizeof(card->shortname)); 460 strlcpy(card->mixername, cdev->product_name, sizeof(card->mixername)); 461 462 /* if the id was not passed as module option, fill it with a shortened 463 * version of the product string which does not contain any 464 * whitespaces */ 465 466 if (*card->id == '\0') { 467 char id[sizeof(card->id)]; 468 469 memset(id, 0, sizeof(id)); 470 471 for (c = card->shortname, len = 0; 472 *c && len < sizeof(card->id); c++) 473 if (*c != ' ') 474 id[len++] = *c; 475 476 snd_card_set_id(card, id); 477 } 478 479 usb_make_path(usb_dev, usbpath, sizeof(usbpath)); 480 snprintf(card->longname, sizeof(card->longname), "%s %s (%s)", 481 cdev->vendor_name, cdev->product_name, usbpath); 482 483 setup_card(cdev); 484 return 0; 485 } 486 487 static int snd_probe(struct usb_interface *intf, 488 const struct usb_device_id *id) 489 { 490 int ret; 491 struct snd_card *card = NULL; 492 struct usb_device *usb_dev = interface_to_usbdev(intf); 493 494 ret = create_card(usb_dev, intf, &card); 495 496 if (ret < 0) 497 return ret; 498 499 usb_set_intfdata(intf, card); 500 ret = init_card(caiaqdev(card)); 501 if (ret < 0) { 502 dev_err(&usb_dev->dev, "unable to init card! (ret=%d)\n", ret); 503 snd_card_free(card); 504 return ret; 505 } 506 507 return 0; 508 } 509 510 static void snd_disconnect(struct usb_interface *intf) 511 { 512 struct snd_card *card = usb_get_intfdata(intf); 513 struct device *dev = intf->usb_dev; 514 struct snd_usb_caiaqdev *cdev; 515 516 if (!card) 517 return; 518 519 cdev = caiaqdev(card); 520 dev_dbg(dev, "%s(%p)\n", __func__, intf); 521 522 snd_card_disconnect(card); 523 524 #ifdef CONFIG_SND_USB_CAIAQ_INPUT 525 snd_usb_caiaq_input_free(cdev); 526 #endif 527 snd_usb_caiaq_audio_free(cdev); 528 529 usb_kill_urb(&cdev->ep1_in_urb); 530 usb_kill_urb(&cdev->midi_out_urb); 531 532 snd_card_free(card); 533 usb_reset_device(interface_to_usbdev(intf)); 534 } 535 536 537 MODULE_DEVICE_TABLE(usb, snd_usb_id_table); 538 static struct usb_driver snd_usb_driver = { 539 .name = MODNAME, 540 .probe = snd_probe, 541 .disconnect = snd_disconnect, 542 .id_table = snd_usb_id_table, 543 }; 544 545 module_usb_driver(snd_usb_driver); 546