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