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