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 u32 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 .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 .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 .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, "%u\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 static struct attribute *pod_dev_attrs[] = { 334 &dev_attr_device_id.attr, 335 &dev_attr_firmware_version.attr, 336 &dev_attr_serial_number.attr, 337 NULL 338 }; 339 340 static const struct attribute_group pod_dev_attr_group = { 341 .name = "pod", 342 .attrs = pod_dev_attrs, 343 }; 344 345 /* control info callback */ 346 static int snd_pod_control_monitor_info(struct snd_kcontrol *kcontrol, 347 struct snd_ctl_elem_info *uinfo) 348 { 349 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 350 uinfo->count = 1; 351 uinfo->value.integer.min = 0; 352 uinfo->value.integer.max = 65535; 353 return 0; 354 } 355 356 /* control get callback */ 357 static int snd_pod_control_monitor_get(struct snd_kcontrol *kcontrol, 358 struct snd_ctl_elem_value *ucontrol) 359 { 360 struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); 361 struct usb_line6_pod *pod = (struct usb_line6_pod *)line6pcm->line6; 362 363 ucontrol->value.integer.value[0] = pod->monitor_level; 364 return 0; 365 } 366 367 /* control put callback */ 368 static int snd_pod_control_monitor_put(struct snd_kcontrol *kcontrol, 369 struct snd_ctl_elem_value *ucontrol) 370 { 371 struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); 372 struct usb_line6_pod *pod = (struct usb_line6_pod *)line6pcm->line6; 373 374 if (ucontrol->value.integer.value[0] == pod->monitor_level) 375 return 0; 376 377 pod->monitor_level = ucontrol->value.integer.value[0]; 378 pod_set_system_param_int(pod, ucontrol->value.integer.value[0], 379 POD_MONITOR_LEVEL); 380 return 1; 381 } 382 383 /* control definition */ 384 static struct snd_kcontrol_new pod_control_monitor = { 385 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 386 .name = "Monitor Playback Volume", 387 .index = 0, 388 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 389 .info = snd_pod_control_monitor_info, 390 .get = snd_pod_control_monitor_get, 391 .put = snd_pod_control_monitor_put 392 }; 393 394 /* 395 POD device disconnected. 396 */ 397 static void line6_pod_disconnect(struct usb_line6 *line6) 398 { 399 struct usb_line6_pod *pod = (struct usb_line6_pod *)line6; 400 401 del_timer_sync(&pod->startup_timer); 402 cancel_work_sync(&pod->startup_work); 403 } 404 405 /* 406 Try to init POD device. 407 */ 408 static int pod_init(struct usb_line6 *line6, 409 const struct usb_device_id *id) 410 { 411 int err; 412 struct usb_line6_pod *pod = (struct usb_line6_pod *) line6; 413 414 line6->process_message = line6_pod_process_message; 415 line6->disconnect = line6_pod_disconnect; 416 417 init_timer(&pod->startup_timer); 418 INIT_WORK(&pod->startup_work, pod_startup4); 419 420 /* create sysfs entries: */ 421 err = snd_card_add_dev_attr(line6->card, &pod_dev_attr_group); 422 if (err < 0) 423 return err; 424 425 /* initialize MIDI subsystem: */ 426 err = line6_init_midi(line6); 427 if (err < 0) 428 return err; 429 430 /* initialize PCM subsystem: */ 431 err = line6_init_pcm(line6, &pod_pcm_properties); 432 if (err < 0) 433 return err; 434 435 /* register monitor control: */ 436 err = snd_ctl_add(line6->card, 437 snd_ctl_new1(&pod_control_monitor, line6->line6pcm)); 438 if (err < 0) 439 return err; 440 441 /* 442 When the sound card is registered at this point, the PODxt Live 443 displays "Invalid Code Error 07", so we do it later in the event 444 handler. 445 */ 446 447 if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL) { 448 pod->monitor_level = POD_SYSTEM_INVALID; 449 450 /* initiate startup procedure: */ 451 pod_startup1(pod); 452 } 453 454 return 0; 455 } 456 457 #define LINE6_DEVICE(prod) USB_DEVICE(0x0e41, prod) 458 #define LINE6_IF_NUM(prod, n) USB_DEVICE_INTERFACE_NUMBER(0x0e41, prod, n) 459 460 /* table of devices that work with this driver */ 461 static const struct usb_device_id pod_id_table[] = { 462 { LINE6_DEVICE(0x4250), .driver_info = LINE6_BASSPODXT }, 463 { LINE6_DEVICE(0x4642), .driver_info = LINE6_BASSPODXTLIVE }, 464 { LINE6_DEVICE(0x4252), .driver_info = LINE6_BASSPODXTPRO }, 465 { LINE6_IF_NUM(0x5051, 1), .driver_info = LINE6_POCKETPOD }, 466 { LINE6_DEVICE(0x5044), .driver_info = LINE6_PODXT }, 467 { LINE6_IF_NUM(0x4650, 0), .driver_info = LINE6_PODXTLIVE_POD }, 468 { LINE6_DEVICE(0x5050), .driver_info = LINE6_PODXTPRO }, 469 {} 470 }; 471 472 MODULE_DEVICE_TABLE(usb, pod_id_table); 473 474 static const struct line6_properties pod_properties_table[] = { 475 [LINE6_BASSPODXT] = { 476 .id = "BassPODxt", 477 .name = "BassPODxt", 478 .capabilities = LINE6_CAP_CONTROL 479 | LINE6_CAP_PCM 480 | LINE6_CAP_HWMON, 481 .altsetting = 5, 482 .ep_ctrl_r = 0x84, 483 .ep_ctrl_w = 0x03, 484 .ep_audio_r = 0x82, 485 .ep_audio_w = 0x01, 486 }, 487 [LINE6_BASSPODXTLIVE] = { 488 .id = "BassPODxtLive", 489 .name = "BassPODxt Live", 490 .capabilities = LINE6_CAP_CONTROL 491 | LINE6_CAP_PCM 492 | LINE6_CAP_HWMON, 493 .altsetting = 1, 494 .ep_ctrl_r = 0x84, 495 .ep_ctrl_w = 0x03, 496 .ep_audio_r = 0x82, 497 .ep_audio_w = 0x01, 498 }, 499 [LINE6_BASSPODXTPRO] = { 500 .id = "BassPODxtPro", 501 .name = "BassPODxt Pro", 502 .capabilities = LINE6_CAP_CONTROL 503 | LINE6_CAP_PCM 504 | LINE6_CAP_HWMON, 505 .altsetting = 5, 506 .ep_ctrl_r = 0x84, 507 .ep_ctrl_w = 0x03, 508 .ep_audio_r = 0x82, 509 .ep_audio_w = 0x01, 510 }, 511 [LINE6_POCKETPOD] = { 512 .id = "PocketPOD", 513 .name = "Pocket POD", 514 .capabilities = LINE6_CAP_CONTROL, 515 .altsetting = 0, 516 .ep_ctrl_r = 0x82, 517 .ep_ctrl_w = 0x02, 518 /* no audio channel */ 519 }, 520 [LINE6_PODXT] = { 521 .id = "PODxt", 522 .name = "PODxt", 523 .capabilities = LINE6_CAP_CONTROL 524 | LINE6_CAP_PCM 525 | LINE6_CAP_HWMON, 526 .altsetting = 5, 527 .ep_ctrl_r = 0x84, 528 .ep_ctrl_w = 0x03, 529 .ep_audio_r = 0x82, 530 .ep_audio_w = 0x01, 531 }, 532 [LINE6_PODXTLIVE_POD] = { 533 .id = "PODxtLive", 534 .name = "PODxt Live", 535 .capabilities = LINE6_CAP_CONTROL 536 | LINE6_CAP_PCM 537 | LINE6_CAP_HWMON, 538 .altsetting = 1, 539 .ep_ctrl_r = 0x84, 540 .ep_ctrl_w = 0x03, 541 .ep_audio_r = 0x82, 542 .ep_audio_w = 0x01, 543 }, 544 [LINE6_PODXTPRO] = { 545 .id = "PODxtPro", 546 .name = "PODxt Pro", 547 .capabilities = LINE6_CAP_CONTROL 548 | LINE6_CAP_PCM 549 | LINE6_CAP_HWMON, 550 .altsetting = 5, 551 .ep_ctrl_r = 0x84, 552 .ep_ctrl_w = 0x03, 553 .ep_audio_r = 0x82, 554 .ep_audio_w = 0x01, 555 }, 556 }; 557 558 /* 559 Probe USB device. 560 */ 561 static int pod_probe(struct usb_interface *interface, 562 const struct usb_device_id *id) 563 { 564 return line6_probe(interface, id, "Line6-POD", 565 &pod_properties_table[id->driver_info], 566 pod_init, sizeof(struct usb_line6_pod)); 567 } 568 569 static struct usb_driver pod_driver = { 570 .name = KBUILD_MODNAME, 571 .probe = pod_probe, 572 .disconnect = line6_disconnect, 573 #ifdef CONFIG_PM 574 .suspend = line6_suspend, 575 .resume = line6_resume, 576 .reset_resume = line6_resume, 577 #endif 578 .id_table = pod_id_table, 579 }; 580 581 module_usb_driver(pod_driver); 582 583 MODULE_DESCRIPTION("Line 6 POD USB driver"); 584 MODULE_LICENSE("GPL"); 585