drivers/staging/line6/driver.c

   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/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/slab.h>
  15 #include <linux/usb.h>
  16
  17 #include "audio.h"
  18 #include "capture.h"
  19 #include "control.h"
  20 #include "driver.h"
  21 #include "midi.h"
  22 #include "playback.h"
  23 #include "pod.h"
  24 #include "podhd.h"
  25 #include "revision.h"
  26 #include "toneport.h"
  27 #include "usbdefs.h"
  28 #include "variax.h"
  29
  30 #define DRIVER_AUTHOR  "Markus Grabner <grabner@icg.tugraz.at>"
  31 #define DRIVER_DESC    "Line6 USB Driver"
  32 #define DRIVER_VERSION "0.9.1beta" DRIVER_REVISION
  33
  34 /* table of devices that work with this driver */
  35 static const struct usb_device_id line6_id_table[] = {
  36         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_BASSPODXT)},
  37         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_BASSPODXTLIVE)},
  38         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_BASSPODXTPRO)},
  39         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_GUITARPORT)},
  40         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_POCKETPOD)},
  41         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_PODHD300)},
  42         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_PODHD500)},
  43         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_PODSTUDIO_GX)},
  44         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_PODSTUDIO_UX1)},
  45         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_PODSTUDIO_UX2)},
  46         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_PODX3)},
  47         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_PODX3LIVE)},
  48         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_PODXT)},
  49         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_PODXTLIVE)},
  50         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_PODXTPRO)},
  51         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_TONEPORT_GX)},
  52         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_TONEPORT_UX1)},
  53         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_TONEPORT_UX2)},
  54         {USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_VARIAX)},
  55         {},
  56 };
  57
  58 MODULE_DEVICE_TABLE(usb, line6_id_table);
  59
  60 /* *INDENT-OFF* */
  61 static struct line6_properties line6_properties_table[] = {
  62         { LINE6_BIT_BASSPODXT,     "BassPODxt",     "BassPODxt",        LINE6_BIT_CONTROL_PCM_HWMON },
  63         { LINE6_BIT_BASSPODXTLIVE, "BassPODxtLive", "BassPODxt Live",   LINE6_BIT_CONTROL_PCM_HWMON },
  64         { LINE6_BIT_BASSPODXTPRO,  "BassPODxtPro",  "BassPODxt Pro",    LINE6_BIT_CONTROL_PCM_HWMON },
  65         { LINE6_BIT_GUITARPORT,    "GuitarPort",    "GuitarPort",       LINE6_BIT_PCM               },
  66         { LINE6_BIT_POCKETPOD,     "PocketPOD",     "Pocket POD",       LINE6_BIT_CONTROL           },
  67         { LINE6_BIT_PODHD300,      "PODHD300",      "POD HD300",        LINE6_BIT_CONTROL_PCM_HWMON },
  68         { LINE6_BIT_PODHD500,      "PODHD500",      "POD HD500",        LINE6_BIT_CONTROL_PCM_HWMON },
  69         { LINE6_BIT_PODSTUDIO_GX,  "PODStudioGX",   "POD Studio GX",    LINE6_BIT_PCM               },
  70         { LINE6_BIT_PODSTUDIO_UX1, "PODStudioUX1",  "POD Studio UX1",   LINE6_BIT_PCM               },
  71         { LINE6_BIT_PODSTUDIO_UX2, "PODStudioUX2",  "POD Studio UX2",   LINE6_BIT_PCM               },
  72         { LINE6_BIT_PODX3,         "PODX3",         "POD X3",           LINE6_BIT_PCM               },
  73         { LINE6_BIT_PODX3LIVE,     "PODX3Live",     "POD X3 Live",      LINE6_BIT_PCM               },
  74         { LINE6_BIT_PODXT,         "PODxt",         "PODxt",            LINE6_BIT_CONTROL_PCM_HWMON },
  75         { LINE6_BIT_PODXTLIVE,     "PODxtLive",     "PODxt Live",       LINE6_BIT_CONTROL_PCM_HWMON },
  76         { LINE6_BIT_PODXTPRO,      "PODxtPro",      "PODxt Pro",        LINE6_BIT_CONTROL_PCM_HWMON },
  77         { LINE6_BIT_TONEPORT_GX,   "TonePortGX",    "TonePort GX",      LINE6_BIT_PCM               },
  78         { LINE6_BIT_TONEPORT_UX1,  "TonePortUX1",   "TonePort UX1",     LINE6_BIT_PCM               },
  79         { LINE6_BIT_TONEPORT_UX2,  "TonePortUX2",   "TonePort UX2",     LINE6_BIT_PCM               },
  80         { LINE6_BIT_VARIAX,        "Variax",        "Variax Workbench", LINE6_BIT_CONTROL           },
  81 };
  82 /* *INDENT-ON* */
  83
  84 /*
  85         This is Line6's MIDI manufacturer ID.
  86 */
  87 const unsigned char line6_midi_id[] = {
  88         0x00, 0x01, 0x0c
  89 };
  90
  91 /*
  92         Code to request version of POD, Variax interface
  93         (and maybe other devices).
  94 */
  95 static const char line6_request_version[] = {
  96         0xf0, 0x7e, 0x7f, 0x06, 0x01, 0xf7
  97 };
  98
  99 /**
 100          Class for asynchronous messages.
 101 */
 102 struct message {
 103         struct usb_line6 *line6;
 104         const char *buffer;
 105         int size;
 106         int done;
 107 };
 108
 109 /*
 110         Forward declarations.
 111 */
 112 static void line6_data_received(struct urb *urb);
 113 static int line6_send_raw_message_async_part(struct message *msg,
 114                                              struct urb *urb);
 115
 116 /*
 117         Start to listen on endpoint.
 118 */
 119 static int line6_start_listen(struct usb_line6 *line6)
 120 {
 121         int err;
 122         usb_fill_int_urb(line6->urb_listen, line6->usbdev,
 123                          usb_rcvintpipe(line6->usbdev, line6->ep_control_read),
 124                          line6->buffer_listen, LINE6_BUFSIZE_LISTEN,
 125                          line6_data_received, line6, line6->interval);
 126         line6->urb_listen->actual_length = 0;
 127         err = usb_submit_urb(line6->urb_listen, GFP_ATOMIC);
 128         return err;
 129 }
 130
 131 /*
 132         Stop listening on endpoint.
 133 */
 134 static void line6_stop_listen(struct usb_line6 *line6)
 135 {
 136         usb_kill_urb(line6->urb_listen);
 137 }
 138
 139 #ifdef CONFIG_LINE6_USB_DUMP_ANY
 140 /*
 141         Write hexdump to syslog.
 142 */
 143 void line6_write_hexdump(struct usb_line6 *line6, char dir,
 144                          const unsigned char *buffer, int size)
 145 {
 146         static const int BYTES_PER_LINE = 8;
 147         char hexdump[100];
 148         char asc[BYTES_PER_LINE + 1];
 149         int i, j;
 150
 151         for (i = 0; i < size; i += BYTES_PER_LINE) {
 152                 int hexdumpsize = sizeof(hexdump);
 153                 char *p = hexdump;
 154                 int n = min(size - i, BYTES_PER_LINE);
 155                 asc[n] = 0;
 156
 157                 for (j = 0; j < BYTES_PER_LINE; ++j) {
 158                         int bytes;
 159
 160                         if (j < n) {
 161                                 unsigned char val = buffer[i + j];
 162                                 bytes = snprintf(p, hexdumpsize, " %02X", val);
 163                                 asc[j] = ((val >= 0x20)
 164                                           && (val < 0x7f)) ? val : '.';
 165                         } else
 166                                 bytes = snprintf(p, hexdumpsize, "   ");
 167
 168                         if (bytes > hexdumpsize)
 169                                 break;  /* buffer overflow */
 170
 171                         p += bytes;
 172                         hexdumpsize -= bytes;
 173                 }
 174
 175                 dev_info(line6->ifcdev, "%c%04X:%s %s\n", dir, i, hexdump, asc);
 176         }
 177 }
 178 #endif
 179
 180 #ifdef CONFIG_LINE6_USB_DUMP_CTRL
 181 /*
 182         Dump URB data to syslog.
 183 */
 184 static void line6_dump_urb(struct urb *urb)
 185 {
 186         struct usb_line6 *line6 = (struct usb_line6 *)urb->context;
 187
 188         if (urb->status < 0)
 189                 return;
 190
 191         line6_write_hexdump(line6, 'R', (unsigned char *)urb->transfer_buffer,
 192                             urb->actual_length);
 193 }
 194 #endif
 195
 196 /*
 197         Send raw message in pieces of wMaxPacketSize bytes.
 198 */
 199 int line6_send_raw_message(struct usb_line6 *line6, const char *buffer,
 200                            int size)
 201 {
 202         int i, done = 0;
 203
 204 #ifdef CONFIG_LINE6_USB_DUMP_CTRL
 205         line6_write_hexdump(line6, 'S', buffer, size);
 206 #endif
 207
 208         for (i = 0; i < size; i += line6->max_packet_size) {
 209                 int partial;
 210                 const char *frag_buf = buffer + i;
 211                 int frag_size = min(line6->max_packet_size, size - i);
 212                 int retval;
 213
 214                 retval = usb_interrupt_msg(line6->usbdev,
 215                                            usb_sndintpipe(line6->usbdev,
 216                                                           line6->ep_control_write),
 217                                            (char *)frag_buf, frag_size,
 218                                            &partial, LINE6_TIMEOUT * HZ);
 219
 220                 if (retval) {
 221                         dev_err(line6->ifcdev,
 222                                 "usb_interrupt_msg failed (%d)\n", retval);
 223                         break;
 224                 }
 225
 226                 done += frag_size;
 227         }
 228
 229         return done;
 230 }
 231
 232 /*
 233         Notification of completion of asynchronous request transmission.
 234 */
 235 static void line6_async_request_sent(struct urb *urb)
 236 {
 237         struct message *msg = (struct message *)urb->context;
 238
 239         if (msg->done >= msg->size) {
 240                 usb_free_urb(urb);
 241                 kfree(msg);
 242         } else
 243                 line6_send_raw_message_async_part(msg, urb);
 244 }
 245
 246 /*
 247         Asynchronously send part of a raw message.
 248 */
 249 static int line6_send_raw_message_async_part(struct message *msg,
 250                                              struct urb *urb)
 251 {
 252         int retval;
 253         struct usb_line6 *line6 = msg->line6;
 254         int done = msg->done;
 255         int bytes = min(msg->size - done, line6->max_packet_size);
 256
 257         usb_fill_int_urb(urb, line6->usbdev,
 258                          usb_sndintpipe(line6->usbdev, line6->ep_control_write),
 259                          (char *)msg->buffer + done, bytes,
 260                          line6_async_request_sent, msg, line6->interval);
 261
 262 #ifdef CONFIG_LINE6_USB_DUMP_CTRL
 263         line6_write_hexdump(line6, 'S', (char *)msg->buffer + done, bytes);
 264 #endif
 265
 266         msg->done += bytes;
 267         retval = usb_submit_urb(urb, GFP_ATOMIC);
 268
 269         if (retval < 0) {
 270                 dev_err(line6->ifcdev, "%s: usb_submit_urb failed (%d)\n",
 271                         __func__, retval);
 272                 usb_free_urb(urb);
 273                 kfree(msg);
 274                 return -EINVAL;
 275         }
 276
 277         return 0;
 278 }
 279
 280 /*
 281         Setup and start timer.
 282 */
 283 void line6_start_timer(struct timer_list *timer, unsigned int msecs,
 284                        void (*function) (unsigned long), unsigned long data)
 285 {
 286         setup_timer(timer, function, data);
 287         timer->expires = jiffies + msecs * HZ / 1000;
 288         add_timer(timer);
 289 }
 290
 291 /*
 292         Asynchronously send raw message.
 293 */
 294 int line6_send_raw_message_async(struct usb_line6 *line6, const char *buffer,
 295                                  int size)
 296 {
 297         struct message *msg;
 298         struct urb *urb;
 299
 300         /* create message: */
 301         msg = kmalloc(sizeof(struct message), GFP_ATOMIC);
 302
 303         if (msg == NULL) {
 304                 dev_err(line6->ifcdev, "Out of memory\n");
 305                 return -ENOMEM;
 306         }
 307
 308         /* create URB: */
 309         urb = usb_alloc_urb(0, GFP_ATOMIC);
 310
 311         if (urb == NULL) {
 312                 kfree(msg);
 313                 dev_err(line6->ifcdev, "Out of memory\n");
 314                 return -ENOMEM;
 315         }
 316
 317         /* set message data: */
 318         msg->line6 = line6;
 319         msg->buffer = buffer;
 320         msg->size = size;
 321         msg->done = 0;
 322
 323         /* start sending: */
 324         return line6_send_raw_message_async_part(msg, urb);
 325 }
 326
 327 /*
 328         Send asynchronous device version request.
 329 */
 330 int line6_version_request_async(struct usb_line6 *line6)
 331 {
 332         char *buffer;
 333         int retval;
 334
 335         buffer = kmalloc(sizeof(line6_request_version), GFP_ATOMIC);
 336         if (buffer == NULL) {
 337                 dev_err(line6->ifcdev, "Out of memory");
 338                 return -ENOMEM;
 339         }
 340
 341         memcpy(buffer, line6_request_version, sizeof(line6_request_version));
 342
 343         retval = line6_send_raw_message_async(line6, buffer,
 344                                               sizeof(line6_request_version));
 345         kfree(buffer);
 346         return retval;
 347 }
 348
 349 /*
 350         Send sysex message in pieces of wMaxPacketSize bytes.
 351 */
 352 int line6_send_sysex_message(struct usb_line6 *line6, const char *buffer,
 353                              int size)
 354 {
 355         return line6_send_raw_message(line6, buffer,
 356                                       size + SYSEX_EXTRA_SIZE) -
 357             SYSEX_EXTRA_SIZE;
 358 }
 359
 360 /*
 361         Send sysex message in pieces of wMaxPacketSize bytes.
 362 */
 363 int line6_send_sysex_message_async(struct usb_line6 *line6, const char *buffer,
 364                                    int size)
 365 {
 366         return line6_send_raw_message_async(line6, buffer,
 367                                             size + SYSEX_EXTRA_SIZE) -
 368             SYSEX_EXTRA_SIZE;
 369 }
 370
 371 /*
 372         Allocate buffer for sysex message and prepare header.
 373         @param code sysex message code
 374         @param size number of bytes between code and sysex end
 375 */
 376 char *line6_alloc_sysex_buffer(struct usb_line6 *line6, int code1, int code2,
 377                                int size)
 378 {
 379         char *buffer = kmalloc(size + SYSEX_EXTRA_SIZE, GFP_ATOMIC);
 380
 381         if (!buffer) {
 382                 dev_err(line6->ifcdev, "out of memory\n");
 383                 return NULL;
 384         }
 385
 386         buffer[0] = LINE6_SYSEX_BEGIN;
 387         memcpy(buffer + 1, line6_midi_id, sizeof(line6_midi_id));
 388         buffer[sizeof(line6_midi_id) + 1] = code1;
 389         buffer[sizeof(line6_midi_id) + 2] = code2;
 390         buffer[sizeof(line6_midi_id) + 3 + size] = LINE6_SYSEX_END;
 391         return buffer;
 392 }
 393
 394 /*
 395         Notification of data received from the Line6 device.
 396 */
 397 static void line6_data_received(struct urb *urb)
 398 {
 399         struct usb_line6 *line6 = (struct usb_line6 *)urb->context;
 400         struct MidiBuffer *mb = &line6->line6midi->midibuf_in;
 401         int done;
 402
 403         if (urb->status == -ESHUTDOWN)
 404                 return;
 405
 406 #ifdef CONFIG_LINE6_USB_DUMP_CTRL
 407         line6_dump_urb(urb);
 408 #endif
 409
 410         done =
 411             line6_midibuf_write(mb, urb->transfer_buffer, urb->actual_length);
 412
 413         if (done < urb->actual_length) {
 414                 line6_midibuf_ignore(mb, done);
 415                 dev_dbg(line6->ifcdev, "%d %d buffer overflow - message skipped\n",
 416                         done, urb->actual_length);
 417         }
 418
 419         for (;;) {
 420                 done =
 421                     line6_midibuf_read(mb, line6->buffer_message,
 422                                        LINE6_MESSAGE_MAXLEN);
 423
 424                 if (done == 0)
 425                         break;
 426
 427                 /* MIDI input filter */
 428                 if (line6_midibuf_skip_message
 429                     (mb, line6->line6midi->midi_mask_receive))
 430                         continue;
 431
 432                 line6->message_length = done;
 433 #ifdef CONFIG_LINE6_USB_DUMP_MIDI
 434                 line6_write_hexdump(line6, 'r', line6->buffer_message, done);
 435 #endif
 436                 line6_midi_receive(line6, line6->buffer_message, done);
 437
 438                 switch (line6->usbdev->descriptor.idProduct) {
 439                 case LINE6_DEVID_BASSPODXT:
 440                 case LINE6_DEVID_BASSPODXTLIVE:
 441                 case LINE6_DEVID_BASSPODXTPRO:
 442                 case LINE6_DEVID_PODXT:
 443                 case LINE6_DEVID_PODXTPRO:
 444                 case LINE6_DEVID_POCKETPOD:
 445                         line6_pod_process_message((struct usb_line6_pod *)
 446                                                   line6);
 447                         break;
 448
 449                 case LINE6_DEVID_PODHD300:
 450                 case LINE6_DEVID_PODHD500:
 451                         break; /* let userspace handle MIDI */
 452
 453                 case LINE6_DEVID_PODXTLIVE:
 454                         switch (line6->interface_number) {
 455                         case PODXTLIVE_INTERFACE_POD:
 456                                 line6_pod_process_message((struct usb_line6_pod
 457                                                            *)line6);
 458                                 break;
 459
 460                         case PODXTLIVE_INTERFACE_VARIAX:
 461                                 line6_variax_process_message((struct
 462                                                               usb_line6_variax
 463                                                               *)line6);
 464                                 break;
 465
 466                         default:
 467                                 dev_err(line6->ifcdev,
 468                                         "PODxt Live interface %d not supported\n",
 469                                         line6->interface_number);
 470                         }
 471                         break;
 472
 473                 case LINE6_DEVID_VARIAX:
 474                         line6_variax_process_message((struct usb_line6_variax *)
 475                                                      line6);
 476                         break;
 477
 478                 default:
 479                         MISSING_CASE;
 480                 }
 481         }
 482
 483         line6_start_listen(line6);
 484 }
 485
 486 /*
 487         Send channel number (i.e., switch to a different sound).
 488 */
 489 int line6_send_program(struct usb_line6 *line6, u8 value)
 490 {
 491         int retval;
 492         unsigned char *buffer;
 493         int partial;
 494
 495         buffer = kmalloc(2, GFP_KERNEL);
 496
 497         if (!buffer) {
 498                 dev_err(line6->ifcdev, "out of memory\n");
 499                 return -ENOMEM;
 500         }
 501
 502         buffer[0] = LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_HOST;
 503         buffer[1] = value;
 504
 505 #ifdef CONFIG_LINE6_USB_DUMP_CTRL
 506         line6_write_hexdump(line6, 'S', buffer, 2);
 507 #endif
 508
 509         retval = usb_interrupt_msg(line6->usbdev,
 510                                    usb_sndintpipe(line6->usbdev,
 511                                                   line6->ep_control_write),
 512                                    buffer, 2, &partial, LINE6_TIMEOUT * HZ);
 513
 514         if (retval)
 515                 dev_err(line6->ifcdev, "usb_interrupt_msg failed (%d)\n",
 516                         retval);
 517
 518         kfree(buffer);
 519         return retval;
 520 }
 521
 522 /*
 523         Transmit Line6 control parameter.
 524 */
 525 int line6_transmit_parameter(struct usb_line6 *line6, int param, u8 value)
 526 {
 527         int retval;
 528         unsigned char *buffer;
 529         int partial;
 530
 531         buffer = kmalloc(3, GFP_KERNEL);
 532
 533         if (!buffer) {
 534                 dev_err(line6->ifcdev, "out of memory\n");
 535                 return -ENOMEM;
 536         }
 537
 538         buffer[0] = LINE6_PARAM_CHANGE | LINE6_CHANNEL_HOST;
 539         buffer[1] = param;
 540         buffer[2] = value;
 541
 542 #ifdef CONFIG_LINE6_USB_DUMP_CTRL
 543         line6_write_hexdump(line6, 'S', buffer, 3);
 544 #endif
 545
 546         retval = usb_interrupt_msg(line6->usbdev,
 547                                    usb_sndintpipe(line6->usbdev,
 548                                                   line6->ep_control_write),
 549                                    buffer, 3, &partial, LINE6_TIMEOUT * HZ);
 550
 551         if (retval)
 552                 dev_err(line6->ifcdev, "usb_interrupt_msg failed (%d)\n",
 553                         retval);
 554
 555         kfree(buffer);
 556         return retval;
 557 }
 558
 559 /*
 560         Read data from device.
 561 */
 562 int line6_read_data(struct usb_line6 *line6, int address, void *data,
 563                     size_t datalen)
 564 {
 565         struct usb_device *usbdev = line6->usbdev;
 566         int ret;
 567         unsigned char len;
 568
 569         /* query the serial number: */
 570         ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x67,
 571                               USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
 572                               (datalen << 8) | 0x21, address,
 573                               NULL, 0, LINE6_TIMEOUT * HZ);
 574
 575         if (ret < 0) {
 576                 dev_err(line6->ifcdev, "read request failed (error %d)\n", ret);
 577                 return ret;
 578         }
 579
 580         /* Wait for data length. We'll get a couple of 0xff until length arrives. */
 581         do {
 582                 ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67,
 583                                       USB_TYPE_VENDOR | USB_RECIP_DEVICE |
 584                                       USB_DIR_IN,
 585                                       0x0012, 0x0000, &len, 1,
 586                                       LINE6_TIMEOUT * HZ);
 587                 if (ret < 0) {
 588                         dev_err(line6->ifcdev,
 589                                 "receive length failed (error %d)\n", ret);
 590                         return ret;
 591                 }
 592         } while (len == 0xff);
 593
 594         if (len != datalen) {
 595                 /* should be equal or something went wrong */
 596                 dev_err(line6->ifcdev,
 597                         "length mismatch (expected %d, got %d)\n",
 598                         (int)datalen, (int)len);
 599                 return -EINVAL;
 600         }
 601
 602         /* receive the result: */
 603         ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67,
 604                               USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
 605                               0x0013, 0x0000, data, datalen,
 606                               LINE6_TIMEOUT * HZ);
 607
 608         if (ret < 0) {
 609                 dev_err(line6->ifcdev, "read failed (error %d)\n", ret);
 610                 return ret;
 611         }
 612
 613         return 0;
 614 }
 615
 616 /*
 617         Write data to device.
 618 */
 619 int line6_write_data(struct usb_line6 *line6, int address, void *data,
 620                      size_t datalen)
 621 {
 622         struct usb_device *usbdev = line6->usbdev;
 623         int ret;
 624         unsigned char status;
 625
 626         ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x67,
 627                               USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
 628                               0x0022, address, data, datalen,
 629                               LINE6_TIMEOUT * HZ);
 630
 631         if (ret < 0) {
 632                 dev_err(line6->ifcdev,
 633                         "write request failed (error %d)\n", ret);
 634                 return ret;
 635         }
 636
 637         do {
 638                 ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
 639                                       0x67,
 640                                       USB_TYPE_VENDOR | USB_RECIP_DEVICE |
 641                                       USB_DIR_IN,
 642                                       0x0012, 0x0000,
 643                                       &status, 1, LINE6_TIMEOUT * HZ);
 644
 645                 if (ret < 0) {
 646                         dev_err(line6->ifcdev,
 647                                 "receiving status failed (error %d)\n", ret);
 648                         return ret;
 649                 }
 650         } while (status == 0xff);
 651
 652         if (status != 0) {
 653                 dev_err(line6->ifcdev, "write failed (error %d)\n", ret);
 654                 return -EINVAL;
 655         }
 656
 657         return 0;
 658 }
 659
 660 /*
 661         Read Line6 device serial number.
 662         (POD, TonePort, GuitarPort)
 663 */
 664 int line6_read_serial_number(struct usb_line6 *line6, int *serial_number)
 665 {
 666         return line6_read_data(line6, 0x80d0, serial_number,
 667                                sizeof(*serial_number));
 668 }
 669
 670 /*
 671         No operation (i.e., unsupported).
 672 */
 673 ssize_t line6_nop_read(struct device *dev, struct device_attribute *attr,
 674                        char *buf)
 675 {
 676         return 0;
 677 }
 678
 679 /*
 680         No operation (i.e., unsupported).
 681 */
 682 ssize_t line6_nop_write(struct device *dev, struct device_attribute *attr,
 683                         const char *buf, size_t count)
 684 {
 685         return count;
 686 }
 687
 688 /*
 689         "write" request on "raw" special file.
 690 */
 691 #ifdef CONFIG_LINE6_USB_RAW
 692 ssize_t line6_set_raw(struct device *dev, struct device_attribute *attr,
 693                       const char *buf, size_t count)
 694 {
 695         struct usb_interface *interface = to_usb_interface(dev);
 696         struct usb_line6 *line6 = usb_get_intfdata(interface);
 697         line6_send_raw_message(line6, buf, count);
 698         return count;
 699 }
 700 #endif
 701
 702 /*
 703         Generic destructor.
 704 */
 705 static void line6_destruct(struct usb_interface *interface)
 706 {
 707         struct usb_line6 *line6;
 708
 709         if (interface == NULL)
 710                 return;
 711         line6 = usb_get_intfdata(interface);
 712         if (line6 == NULL)
 713                 return;
 714
 715         /* free buffer memory first: */
 716         kfree(line6->buffer_message);
 717         kfree(line6->buffer_listen);
 718
 719         /* then free URBs: */
 720         usb_free_urb(line6->urb_listen);
 721
 722         /* make sure the device isn't destructed twice: */
 723         usb_set_intfdata(interface, NULL);
 724
 725         /* free interface data: */
 726         kfree(line6);
 727 }
 728
 729 /*
 730         Probe USB device.
 731 */
 732 static int line6_probe(struct usb_interface *interface,
 733                        const struct usb_device_id *id)
 734 {
 735         int devtype;
 736         struct usb_device *usbdev;
 737         struct usb_line6 *line6;
 738         const struct line6_properties *properties;
 739         int interface_number, alternate = 0;
 740         int product;
 741         int size = 0;
 742         int ep_read = 0, ep_write = 0;
 743         int ret;
 744
 745         if (interface == NULL)
 746                 return -ENODEV;
 747         usbdev = interface_to_usbdev(interface);
 748         if (usbdev == NULL)
 749                 return -ENODEV;
 750
 751         /* we don't handle multiple configurations */
 752         if (usbdev->descriptor.bNumConfigurations != 1) {
 753                 ret = -ENODEV;
 754                 goto err_put;
 755         }
 756
 757         /* check vendor and product id */
 758         for (devtype = ARRAY_SIZE(line6_id_table) - 1; devtype--;) {
 759                 u16 idVendor = le16_to_cpu(usbdev->descriptor.idVendor);
 760                 u16 idProduct = le16_to_cpu(usbdev->descriptor.idProduct);
 761
 762                 if (idVendor == line6_id_table[devtype].idVendor &&
 763                     idProduct == line6_id_table[devtype].idProduct)
 764                         break;
 765         }
 766
 767         if (devtype < 0) {
 768                 ret = -ENODEV;
 769                 goto err_put;
 770         }
 771
 772         /* initialize device info: */
 773         properties = &line6_properties_table[devtype];
 774         dev_info(&interface->dev, "Line6 %s found\n", properties->name);
 775         product = le16_to_cpu(usbdev->descriptor.idProduct);
 776
 777         /* query interface number */
 778         interface_number = interface->cur_altsetting->desc.bInterfaceNumber;
 779
 780         switch (product) {
 781         case LINE6_DEVID_BASSPODXTLIVE:
 782         case LINE6_DEVID_PODXTLIVE:
 783         case LINE6_DEVID_VARIAX:
 784                 alternate = 1;
 785                 break;
 786
 787         case LINE6_DEVID_POCKETPOD:
 788                 switch (interface_number) {
 789                 case 0:
 790                         return 0;       /* this interface has no endpoints */
 791                 case 1:
 792                         alternate = 0;
 793                         break;
 794                 default:
 795                         MISSING_CASE;
 796                 }
 797                 break;
 798
 799         case LINE6_DEVID_PODHD500:
 800         case LINE6_DEVID_PODX3:
 801         case LINE6_DEVID_PODX3LIVE:
 802                 switch (interface_number) {
 803                 case 0:
 804                         alternate = 1;
 805                         break;
 806                 case 1:
 807                         alternate = 0;
 808                         break;
 809                 default:
 810                         MISSING_CASE;
 811                 }
 812                 break;
 813
 814         case LINE6_DEVID_BASSPODXT:
 815         case LINE6_DEVID_BASSPODXTPRO:
 816         case LINE6_DEVID_PODXT:
 817         case LINE6_DEVID_PODXTPRO:
 818         case LINE6_DEVID_PODHD300:
 819                 alternate = 5;
 820                 break;
 821
 822         case LINE6_DEVID_GUITARPORT:
 823         case LINE6_DEVID_PODSTUDIO_GX:
 824         case LINE6_DEVID_PODSTUDIO_UX1:
 825         case LINE6_DEVID_TONEPORT_GX:
 826         case LINE6_DEVID_TONEPORT_UX1:
 827                 alternate = 2;  /* 1..4 seem to be ok */
 828                 break;
 829
 830         case LINE6_DEVID_TONEPORT_UX2:
 831         case LINE6_DEVID_PODSTUDIO_UX2:
 832                 switch (interface_number) {
 833                 case 0:
 834                         /* defaults to 44.1kHz, 16-bit */
 835                         alternate = 2;
 836                         break;
 837                 case 1:
 838                         /* don't know yet what this is ...
 839                            alternate = 1;
 840                            break;
 841                          */
 842                         return -ENODEV;
 843                 default:
 844                         MISSING_CASE;
 845                 }
 846                 break;
 847
 848         default:
 849                 MISSING_CASE;
 850                 ret = -ENODEV;
 851                 goto err_put;
 852         }
 853
 854         ret = usb_set_interface(usbdev, interface_number, alternate);
 855         if (ret < 0) {
 856                 dev_err(&interface->dev, "set_interface failed\n");
 857                 goto err_put;
 858         }
 859
 860         /* initialize device data based on product id: */
 861         switch (product) {
 862         case LINE6_DEVID_BASSPODXT:
 863         case LINE6_DEVID_BASSPODXTLIVE:
 864         case LINE6_DEVID_BASSPODXTPRO:
 865         case LINE6_DEVID_PODXT:
 866         case LINE6_DEVID_PODXTPRO:
 867                 size = sizeof(struct usb_line6_pod);
 868                 ep_read = 0x84;
 869                 ep_write = 0x03;
 870                 break;
 871
 872         case LINE6_DEVID_PODHD300:
 873                 size = sizeof(struct usb_line6_podhd);
 874                 ep_read = 0x84;
 875                 ep_write = 0x03;
 876                 break;
 877
 878         case LINE6_DEVID_PODHD500:
 879                 size = sizeof(struct usb_line6_podhd);
 880                 ep_read = 0x81;
 881                 ep_write = 0x01;
 882                 break;
 883
 884         case LINE6_DEVID_POCKETPOD:
 885                 size = sizeof(struct usb_line6_pod);
 886                 ep_read = 0x82;
 887                 ep_write = 0x02;
 888                 break;
 889
 890         case LINE6_DEVID_PODX3:
 891         case LINE6_DEVID_PODX3LIVE:
 892                 /* currently unused! */
 893                 size = sizeof(struct usb_line6_pod);
 894                 ep_read = 0x81;
 895                 ep_write = 0x01;
 896                 break;
 897
 898         case LINE6_DEVID_PODSTUDIO_GX:
 899         case LINE6_DEVID_PODSTUDIO_UX1:
 900         case LINE6_DEVID_PODSTUDIO_UX2:
 901         case LINE6_DEVID_TONEPORT_GX:
 902         case LINE6_DEVID_TONEPORT_UX1:
 903         case LINE6_DEVID_TONEPORT_UX2:
 904         case LINE6_DEVID_GUITARPORT:
 905                 size = sizeof(struct usb_line6_toneport);
 906                 /* these don't have a control channel */
 907                 break;
 908
 909         case LINE6_DEVID_PODXTLIVE:
 910                 switch (interface_number) {
 911                 case PODXTLIVE_INTERFACE_POD:
 912                         size = sizeof(struct usb_line6_pod);
 913                         ep_read = 0x84;
 914                         ep_write = 0x03;
 915                         break;
 916
 917                 case PODXTLIVE_INTERFACE_VARIAX:
 918                         size = sizeof(struct usb_line6_variax);
 919                         ep_read = 0x86;
 920                         ep_write = 0x05;
 921                         break;
 922
 923                 default:
 924                         ret = -ENODEV;
 925                         goto err_put;
 926                 }
 927                 break;
 928
 929         case LINE6_DEVID_VARIAX:
 930                 size = sizeof(struct usb_line6_variax);
 931                 ep_read = 0x82;
 932                 ep_write = 0x01;
 933                 break;
 934
 935         default:
 936                 MISSING_CASE;
 937                 ret = -ENODEV;
 938                 goto err_put;
 939         }
 940
 941         if (size == 0) {
 942                 dev_err(&interface->dev,
 943                         "driver bug: interface data size not set\n");
 944                 ret = -ENODEV;
 945                 goto err_put;
 946         }
 947
 948         line6 = kzalloc(size, GFP_KERNEL);
 949
 950         if (line6 == NULL) {
 951                 dev_err(&interface->dev, "Out of memory\n");
 952                 ret = -ENODEV;
 953                 goto err_put;
 954         }
 955
 956         /* store basic data: */
 957         line6->interface_number = interface_number;
 958         line6->properties = properties;
 959         line6->usbdev = usbdev;
 960         line6->ifcdev = &interface->dev;
 961         line6->ep_control_read = ep_read;
 962         line6->ep_control_write = ep_write;
 963         line6->product = product;
 964
 965         /* get data from endpoint descriptor (see usb_maxpacket): */
 966         {
 967                 struct usb_host_endpoint *ep;
 968                 unsigned epnum =
 969                     usb_pipeendpoint(usb_rcvintpipe(usbdev, ep_read));
 970                 ep = usbdev->ep_in[epnum];
 971
 972                 if (ep != NULL) {
 973                         line6->interval = ep->desc.bInterval;
 974                         line6->max_packet_size =
 975                             le16_to_cpu(ep->desc.wMaxPacketSize);
 976                 } else {
 977                         line6->interval = LINE6_FALLBACK_INTERVAL;
 978                         line6->max_packet_size = LINE6_FALLBACK_MAXPACKETSIZE;
 979                         dev_err(line6->ifcdev,
 980                                 "endpoint not available, using fallback values");
 981                 }
 982         }
 983
 984         usb_set_intfdata(interface, line6);
 985
 986         if (properties->capabilities & LINE6_BIT_CONTROL) {
 987                 /* initialize USB buffers: */
 988                 line6->buffer_listen =
 989                     kmalloc(LINE6_BUFSIZE_LISTEN, GFP_KERNEL);
 990
 991                 if (line6->buffer_listen == NULL) {
 992                         dev_err(&interface->dev, "Out of memory\n");
 993                         ret = -ENOMEM;
 994                         goto err_destruct;
 995                 }
 996
 997                 line6->buffer_message =
 998                     kmalloc(LINE6_MESSAGE_MAXLEN, GFP_KERNEL);
 999
1000                 if (line6->buffer_message == NULL) {
1001                         dev_err(&interface->dev, "Out of memory\n");
1002                         ret = -ENOMEM;
1003                         goto err_destruct;
1004                 }
1005
1006                 line6->urb_listen = usb_alloc_urb(0, GFP_KERNEL);
1007
1008                 if (line6->urb_listen == NULL) {
1009                         dev_err(&interface->dev, "Out of memory\n");
1010                         line6_destruct(interface);
1011                         ret = -ENOMEM;
1012                         goto err_destruct;
1013                 }
1014
1015                 ret = line6_start_listen(line6);
1016                 if (ret < 0) {
1017                         dev_err(&interface->dev, "%s: usb_submit_urb failed\n",
1018                                 __func__);
1019                         goto err_destruct;
1020                 }
1021         }
1022
1023         /* initialize device data based on product id: */
1024         switch (product) {
1025         case LINE6_DEVID_BASSPODXT:
1026         case LINE6_DEVID_BASSPODXTLIVE:
1027         case LINE6_DEVID_BASSPODXTPRO:
1028         case LINE6_DEVID_POCKETPOD:
1029         case LINE6_DEVID_PODX3:
1030         case LINE6_DEVID_PODX3LIVE:
1031         case LINE6_DEVID_PODXT:
1032         case LINE6_DEVID_PODXTPRO:
1033                 ret = line6_pod_init(interface, (struct usb_line6_pod *)line6);
1034                 break;
1035
1036         case LINE6_DEVID_PODHD300:
1037         case LINE6_DEVID_PODHD500:
1038                 ret = line6_podhd_init(interface,
1039                                        (struct usb_line6_podhd *)line6);
1040                 break;
1041
1042         case LINE6_DEVID_PODXTLIVE:
1043                 switch (interface_number) {
1044                 case PODXTLIVE_INTERFACE_POD:
1045                         ret =
1046                             line6_pod_init(interface,
1047                                            (struct usb_line6_pod *)line6);
1048                         break;
1049
1050                 case PODXTLIVE_INTERFACE_VARIAX:
1051                         ret =
1052                             line6_variax_init(interface,
1053                                               (struct usb_line6_variax *)line6);
1054                         break;
1055
1056                 default:
1057                         dev_err(&interface->dev,
1058                                 "PODxt Live interface %d not supported\n",
1059                                 interface_number);
1060                         ret = -ENODEV;
1061                 }
1062
1063                 break;
1064
1065         case LINE6_DEVID_VARIAX:
1066                 ret =
1067                     line6_variax_init(interface,
1068                                       (struct usb_line6_variax *)line6);
1069                 break;
1070
1071         case LINE6_DEVID_PODSTUDIO_GX:
1072         case LINE6_DEVID_PODSTUDIO_UX1:
1073         case LINE6_DEVID_PODSTUDIO_UX2:
1074         case LINE6_DEVID_TONEPORT_GX:
1075         case LINE6_DEVID_TONEPORT_UX1:
1076         case LINE6_DEVID_TONEPORT_UX2:
1077         case LINE6_DEVID_GUITARPORT:
1078                 ret =
1079                     line6_toneport_init(interface,
1080                                         (struct usb_line6_toneport *)line6);
1081                 break;
1082
1083         default:
1084                 MISSING_CASE;
1085                 ret = -ENODEV;
1086         }
1087
1088         if (ret < 0)
1089                 goto err_destruct;
1090
1091         ret = sysfs_create_link(&interface->dev.kobj, &usbdev->dev.kobj,
1092                                 "usb_device");
1093         if (ret < 0)
1094                 goto err_destruct;
1095
1096         /* creation of additional special files should go here */
1097
1098         dev_info(&interface->dev, "Line6 %s now attached\n",
1099                  line6->properties->name);
1100
1101         switch (product) {
1102         case LINE6_DEVID_PODX3:
1103         case LINE6_DEVID_PODX3LIVE:
1104                 dev_info(&interface->dev,
1105                          "NOTE: the Line6 %s is detected, but not yet supported\n",
1106                          line6->properties->name);
1107         }
1108
1109         /* increment reference counters: */
1110         usb_get_intf(interface);
1111         usb_get_dev(usbdev);
1112
1113         return 0;
1114
1115 err_destruct:
1116         line6_destruct(interface);
1117 err_put:
1118         return ret;
1119 }
1120
1121 /*
1122         Line6 device disconnected.
1123 */
1124 static void line6_disconnect(struct usb_interface *interface)
1125 {
1126         struct usb_line6 *line6;
1127         struct usb_device *usbdev;
1128         int interface_number;
1129
1130         if (interface == NULL)
1131                 return;
1132         usbdev = interface_to_usbdev(interface);
1133         if (usbdev == NULL)
1134                 return;
1135
1136         /* removal of additional special files should go here */
1137
1138         sysfs_remove_link(&interface->dev.kobj, "usb_device");
1139
1140         interface_number = interface->cur_altsetting->desc.bInterfaceNumber;
1141         line6 = usb_get_intfdata(interface);
1142
1143         if (line6 != NULL) {
1144                 if (line6->urb_listen != NULL)
1145                         line6_stop_listen(line6);
1146
1147                 if (usbdev != line6->usbdev)
1148                         dev_err(line6->ifcdev,
1149                                 "driver bug: inconsistent usb device\n");
1150
1151                 switch (line6->usbdev->descriptor.idProduct) {
1152                 case LINE6_DEVID_BASSPODXT:
1153                 case LINE6_DEVID_BASSPODXTLIVE:
1154                 case LINE6_DEVID_BASSPODXTPRO:
1155                 case LINE6_DEVID_POCKETPOD:
1156                 case LINE6_DEVID_PODX3:
1157                 case LINE6_DEVID_PODX3LIVE:
1158                 case LINE6_DEVID_PODXT:
1159                 case LINE6_DEVID_PODXTPRO:
1160                         line6_pod_disconnect(interface);
1161                         break;
1162
1163                 case LINE6_DEVID_PODHD300:
1164                 case LINE6_DEVID_PODHD500:
1165                         line6_podhd_disconnect(interface);
1166                         break;
1167
1168                 case LINE6_DEVID_PODXTLIVE:
1169                         switch (interface_number) {
1170                         case PODXTLIVE_INTERFACE_POD:
1171                                 line6_pod_disconnect(interface);
1172                                 break;
1173
1174                         case PODXTLIVE_INTERFACE_VARIAX:
1175                                 line6_variax_disconnect(interface);
1176                                 break;
1177                         }
1178
1179                         break;
1180
1181                 case LINE6_DEVID_VARIAX:
1182                         line6_variax_disconnect(interface);
1183                         break;
1184
1185                 case LINE6_DEVID_PODSTUDIO_GX:
1186                 case LINE6_DEVID_PODSTUDIO_UX1:
1187                 case LINE6_DEVID_PODSTUDIO_UX2:
1188                 case LINE6_DEVID_TONEPORT_GX:
1189                 case LINE6_DEVID_TONEPORT_UX1:
1190                 case LINE6_DEVID_TONEPORT_UX2:
1191                 case LINE6_DEVID_GUITARPORT:
1192                         line6_toneport_disconnect(interface);
1193                         break;
1194
1195                 default:
1196                         MISSING_CASE;
1197                 }
1198
1199                 dev_info(&interface->dev, "Line6 %s now disconnected\n",
1200                          line6->properties->name);
1201         }
1202
1203         line6_destruct(interface);
1204
1205         /* decrement reference counters: */
1206         usb_put_intf(interface);
1207         usb_put_dev(usbdev);
1208 }
1209
1210 #ifdef CONFIG_PM
1211
1212 /*
1213         Suspend Line6 device.
1214 */
1215 static int line6_suspend(struct usb_interface *interface, pm_message_t message)
1216 {
1217         struct usb_line6 *line6 = usb_get_intfdata(interface);
1218         struct snd_line6_pcm *line6pcm = line6->line6pcm;
1219
1220         snd_power_change_state(line6->card, SNDRV_CTL_POWER_D3hot);
1221
1222         if (line6->properties->capabilities & LINE6_BIT_CONTROL)
1223                 line6_stop_listen(line6);
1224
1225         if (line6pcm != NULL) {
1226                 snd_pcm_suspend_all(line6pcm->pcm);
1227                 line6_pcm_disconnect(line6pcm);
1228                 line6pcm->flags = 0;
1229         }
1230
1231         return 0;
1232 }
1233
1234 /*
1235         Resume Line6 device.
1236 */
1237 static int line6_resume(struct usb_interface *interface)
1238 {
1239         struct usb_line6 *line6 = usb_get_intfdata(interface);
1240
1241         if (line6->properties->capabilities & LINE6_BIT_CONTROL)
1242                 line6_start_listen(line6);
1243
1244         snd_power_change_state(line6->card, SNDRV_CTL_POWER_D0);
1245         return 0;
1246 }
1247
1248 /*
1249         Resume Line6 device after reset.
1250 */
1251 static int line6_reset_resume(struct usb_interface *interface)
1252 {
1253         struct usb_line6 *line6 = usb_get_intfdata(interface);
1254
1255         switch (line6->usbdev->descriptor.idProduct) {
1256         case LINE6_DEVID_PODSTUDIO_GX:
1257         case LINE6_DEVID_PODSTUDIO_UX1:
1258         case LINE6_DEVID_PODSTUDIO_UX2:
1259         case LINE6_DEVID_TONEPORT_GX:
1260         case LINE6_DEVID_TONEPORT_UX1:
1261         case LINE6_DEVID_TONEPORT_UX2:
1262         case LINE6_DEVID_GUITARPORT:
1263                 line6_toneport_reset_resume((struct usb_line6_toneport *)line6);
1264         }
1265
1266         return line6_resume(interface);
1267 }
1268
1269 #endif /* CONFIG_PM */
1270
1271 static struct usb_driver line6_driver = {
1272         .name = DRIVER_NAME,
1273         .probe = line6_probe,
1274         .disconnect = line6_disconnect,
1275 #ifdef CONFIG_PM
1276         .suspend = line6_suspend,
1277         .resume = line6_resume,
1278         .reset_resume = line6_reset_resume,
1279 #endif
1280         .id_table = line6_id_table,
1281 };
1282
1283 module_usb_driver(line6_driver);
1284
1285 MODULE_AUTHOR(DRIVER_AUTHOR);
1286 MODULE_DESCRIPTION(DRIVER_DESC);
1287 MODULE_LICENSE("GPL");
1288 MODULE_VERSION(DRIVER_VERSION);