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