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 const 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_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 263 int 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 311 int 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 319 static 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 405 static 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 438 static 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 /* sanity checks of EPs before actually submitting */ 465 if (usb_urb_ep_type_check(&cdev->ep1_in_urb) || 466 usb_urb_ep_type_check(&cdev->midi_out_urb)) { 467 dev_err(dev, "invalid EPs\n"); 468 return -EINVAL; 469 } 470 471 init_waitqueue_head(&cdev->ep1_wait_queue); 472 init_waitqueue_head(&cdev->prepare_wait_queue); 473 474 if (usb_submit_urb(&cdev->ep1_in_urb, GFP_KERNEL) != 0) 475 return -EIO; 476 477 err = snd_usb_caiaq_send_command(cdev, EP1_CMD_GET_DEVICE_INFO, NULL, 0); 478 if (err) 479 goto err_kill_urb; 480 481 if (!wait_event_timeout(cdev->ep1_wait_queue, cdev->spec_received, HZ)) { 482 err = -ENODEV; 483 goto err_kill_urb; 484 } 485 486 usb_string(usb_dev, usb_dev->descriptor.iManufacturer, 487 cdev->vendor_name, CAIAQ_USB_STR_LEN); 488 489 usb_string(usb_dev, usb_dev->descriptor.iProduct, 490 cdev->product_name, CAIAQ_USB_STR_LEN); 491 492 strlcpy(card->driver, MODNAME, sizeof(card->driver)); 493 strlcpy(card->shortname, cdev->product_name, sizeof(card->shortname)); 494 strlcpy(card->mixername, cdev->product_name, sizeof(card->mixername)); 495 496 /* if the id was not passed as module option, fill it with a shortened 497 * version of the product string which does not contain any 498 * whitespaces */ 499 500 if (*card->id == '\0') { 501 char id[sizeof(card->id)]; 502 503 memset(id, 0, sizeof(id)); 504 505 for (c = card->shortname, len = 0; 506 *c && len < sizeof(card->id); c++) 507 if (*c != ' ') 508 id[len++] = *c; 509 510 snd_card_set_id(card, id); 511 } 512 513 usb_make_path(usb_dev, usbpath, sizeof(usbpath)); 514 snprintf(card->longname, sizeof(card->longname), "%s %s (%s)", 515 cdev->vendor_name, cdev->product_name, usbpath); 516 517 setup_card(cdev); 518 return 0; 519 520 err_kill_urb: 521 usb_kill_urb(&cdev->ep1_in_urb); 522 return err; 523 } 524 525 static int snd_probe(struct usb_interface *intf, 526 const struct usb_device_id *id) 527 { 528 int ret; 529 struct snd_card *card = NULL; 530 struct usb_device *usb_dev = interface_to_usbdev(intf); 531 532 ret = create_card(usb_dev, intf, &card); 533 534 if (ret < 0) 535 return ret; 536 537 usb_set_intfdata(intf, card); 538 ret = init_card(caiaqdev(card)); 539 if (ret < 0) { 540 dev_err(&usb_dev->dev, "unable to init card! (ret=%d)\n", ret); 541 snd_card_free(card); 542 return ret; 543 } 544 545 return 0; 546 } 547 548 static void snd_disconnect(struct usb_interface *intf) 549 { 550 struct snd_card *card = usb_get_intfdata(intf); 551 struct device *dev = intf->usb_dev; 552 struct snd_usb_caiaqdev *cdev; 553 554 if (!card) 555 return; 556 557 cdev = caiaqdev(card); 558 dev_dbg(dev, "%s(%p)\n", __func__, intf); 559 560 snd_card_disconnect(card); 561 562 #ifdef CONFIG_SND_USB_CAIAQ_INPUT 563 snd_usb_caiaq_input_free(cdev); 564 #endif 565 snd_usb_caiaq_audio_free(cdev); 566 567 usb_kill_urb(&cdev->ep1_in_urb); 568 usb_kill_urb(&cdev->midi_out_urb); 569 570 snd_card_free(card); 571 usb_reset_device(interface_to_usbdev(intf)); 572 } 573 574 575 MODULE_DEVICE_TABLE(usb, snd_usb_id_table); 576 static struct usb_driver snd_usb_driver = { 577 .name = MODNAME, 578 .probe = snd_probe, 579 .disconnect = snd_disconnect, 580 .id_table = snd_usb_id_table, 581 }; 582 583 module_usb_driver(snd_usb_driver); 584