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