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