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