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                 /* MIDI input filter */
 400                 if (line6_midibuf_skip_message
 401                     (mb, line6->line6midi->midi_mask_receive))
 402                         continue;
 403
 404                 line6->message_length = done;
 405                 line6_midi_receive(line6, line6->buffer_message, done);
 406
 407                 switch (line6->usbdev->descriptor.idProduct) {
 408                 case LINE6_DEVID_BASSPODXT:
 409                 case LINE6_DEVID_BASSPODXTLIVE:
 410                 case LINE6_DEVID_BASSPODXTPRO:
 411                 case LINE6_DEVID_PODXT:
 412                 case LINE6_DEVID_PODXTPRO:
 413                 case LINE6_DEVID_POCKETPOD:
 414                         line6_pod_process_message((struct usb_line6_pod *)
 415                                                   line6);
 416                         break;
 417
 418                 case LINE6_DEVID_PODHD300:
 419                 case LINE6_DEVID_PODHD500:
 420                         break; /* let userspace handle MIDI */
 421
 422                 case LINE6_DEVID_PODXTLIVE:
 423                         switch (line6->interface_number) {
 424                         case PODXTLIVE_INTERFACE_POD:
 425                                 line6_pod_process_message((struct usb_line6_pod
 426                                                            *)line6);
 427                                 break;
 428
 429                         case PODXTLIVE_INTERFACE_VARIAX:
 430                                 line6_variax_process_message((struct
 431                                                               usb_line6_variax
 432                                                               *)line6);
 433                                 break;
 434
 435                         default:
 436                                 dev_err(line6->ifcdev,
 437                                         "PODxt Live interface %d not supported\n",
 438                                         line6->interface_number);
 439                         }
 440                         break;
 441
 442                 case LINE6_DEVID_VARIAX:
 443                         line6_variax_process_message((struct usb_line6_variax *)
 444                                                      line6);
 445                         break;
 446
 447                 default:
 448                         MISSING_CASE;
 449                 }
 450         }
 451
 452         line6_start_listen(line6);
 453 }
 454
 455 /*
 456         Send channel number (i.e., switch to a different sound).
 457 */
 458 int line6_send_program(struct usb_line6 *line6, u8 value)
 459 {
 460         int retval;
 461         unsigned char *buffer;
 462         int partial;
 463
 464         buffer = kmalloc(2, GFP_KERNEL);
 465
 466         if (!buffer) {
 467                 dev_err(line6->ifcdev, "out of memory\n");
 468                 return -ENOMEM;
 469         }
 470
 471         buffer[0] = LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_HOST;
 472         buffer[1] = value;
 473
 474         retval = usb_interrupt_msg(line6->usbdev,
 475                                    usb_sndintpipe(line6->usbdev,
 476                                                   line6->ep_control_write),
 477                                    buffer, 2, &partial, LINE6_TIMEOUT * HZ);
 478
 479         if (retval)
 480                 dev_err(line6->ifcdev, "usb_interrupt_msg failed (%d)\n",
 481                         retval);
 482
 483         kfree(buffer);
 484         return retval;
 485 }
 486
 487 /*
 488         Transmit Line6 control parameter.
 489 */
 490 int line6_transmit_parameter(struct usb_line6 *line6, int param, u8 value)
 491 {
 492         int retval;
 493         unsigned char *buffer;
 494         int partial;
 495
 496         buffer = kmalloc(3, GFP_KERNEL);
 497
 498         if (!buffer) {
 499                 dev_err(line6->ifcdev, "out of memory\n");
 500                 return -ENOMEM;
 501         }
 502
 503         buffer[0] = LINE6_PARAM_CHANGE | LINE6_CHANNEL_HOST;
 504         buffer[1] = param;
 505         buffer[2] = value;
 506
 507         retval = usb_interrupt_msg(line6->usbdev,
 508                                    usb_sndintpipe(line6->usbdev,
 509                                                   line6->ep_control_write),
 510                                    buffer, 3, &partial, LINE6_TIMEOUT * HZ);
 511
 512         if (retval)
 513                 dev_err(line6->ifcdev, "usb_interrupt_msg failed (%d)\n",
 514                         retval);
 515
 516         kfree(buffer);
 517         return retval;
 518 }
 519
 520 /*
 521         Read data from device.
 522 */
 523 int line6_read_data(struct usb_line6 *line6, int address, void *data,
 524                     size_t datalen)
 525 {
 526         struct usb_device *usbdev = line6->usbdev;
 527         int ret;
 528         unsigned char len;
 529
 530         /* query the serial number: */
 531         ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x67,
 532                               USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
 533                               (datalen << 8) | 0x21, address,
 534                               NULL, 0, LINE6_TIMEOUT * HZ);
 535
 536         if (ret < 0) {
 537                 dev_err(line6->ifcdev, "read request failed (error %d)\n", ret);
 538                 return ret;
 539         }
 540
 541         /* Wait for data length. We'll get a couple of 0xff until length arrives. */
 542         do {
 543                 ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67,
 544                                       USB_TYPE_VENDOR | USB_RECIP_DEVICE |
 545                                       USB_DIR_IN,
 546                                       0x0012, 0x0000, &len, 1,
 547                                       LINE6_TIMEOUT * HZ);
 548                 if (ret < 0) {
 549                         dev_err(line6->ifcdev,
 550                                 "receive length failed (error %d)\n", ret);
 551                         return ret;
 552                 }
 553         } while (len == 0xff);
 554
 555         if (len != datalen) {
 556                 /* should be equal or something went wrong */
 557                 dev_err(line6->ifcdev,
 558                         "length mismatch (expected %d, got %d)\n",
 559                         (int)datalen, (int)len);
 560                 return -EINVAL;
 561         }
 562
 563         /* receive the result: */
 564         ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67,
 565                               USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
 566                               0x0013, 0x0000, data, datalen,
 567                               LINE6_TIMEOUT * HZ);
 568
 569         if (ret < 0) {
 570                 dev_err(line6->ifcdev, "read failed (error %d)\n", ret);
 571                 return ret;
 572         }
 573
 574         return 0;
 575 }
 576
 577 /*
 578         Write data to device.
 579 */
 580 int line6_write_data(struct usb_line6 *line6, int address, void *data,
 581                      size_t datalen)
 582 {
 583         struct usb_device *usbdev = line6->usbdev;
 584         int ret;
 585         unsigned char status;
 586
 587         ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x67,
 588                               USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
 589                               0x0022, address, data, datalen,
 590                               LINE6_TIMEOUT * HZ);
 591
 592         if (ret < 0) {
 593                 dev_err(line6->ifcdev,
 594                         "write request failed (error %d)\n", ret);
 595                 return ret;
 596         }
 597
 598         do {
 599                 ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
 600                                       0x67,
 601                                       USB_TYPE_VENDOR | USB_RECIP_DEVICE |
 602                                       USB_DIR_IN,
 603                                       0x0012, 0x0000,
 604                                       &status, 1, LINE6_TIMEOUT * HZ);
 605
 606                 if (ret < 0) {
 607                         dev_err(line6->ifcdev,
 608                                 "receiving status failed (error %d)\n", ret);
 609                         return ret;
 610                 }
 611         } while (status == 0xff);
 612
 613         if (status != 0) {
 614                 dev_err(line6->ifcdev, "write failed (error %d)\n", ret);
 615                 return -EINVAL;
 616         }
 617
 618         return 0;
 619 }
 620
 621 /*
 622         Read Line6 device serial number.
 623         (POD, TonePort, GuitarPort)
 624 */
 625 int line6_read_serial_number(struct usb_line6 *line6, int *serial_number)
 626 {
 627         return line6_read_data(line6, 0x80d0, serial_number,
 628                                sizeof(*serial_number));
 629 }
 630
 631 /*
 632         No operation (i.e., unsupported).
 633 */
 634 ssize_t line6_nop_read(struct device *dev, struct device_attribute *attr,
 635                        char *buf)
 636 {
 637         return 0;
 638 }
 639
 640 /*
 641         No operation (i.e., unsupported).
 642 */
 643 ssize_t line6_nop_write(struct device *dev, struct device_attribute *attr,
 644                         const char *buf, size_t count)
 645 {
 646         return count;
 647 }
 648
 649 /*
 650         "write" request on "raw" special file.
 651 */
 652 #ifdef CONFIG_LINE6_USB_RAW
 653 ssize_t line6_set_raw(struct device *dev, struct device_attribute *attr,
 654                       const char *buf, size_t count)
 655 {
 656         struct usb_interface *interface = to_usb_interface(dev);
 657         struct usb_line6 *line6 = usb_get_intfdata(interface);
 658         line6_send_raw_message(line6, buf, count);
 659         return count;
 660 }
 661 #endif
 662
 663 /*
 664         Generic destructor.
 665 */
 666 static void line6_destruct(struct usb_interface *interface)
 667 {
 668         struct usb_line6 *line6;
 669
 670         if (interface == NULL)
 671                 return;
 672         line6 = usb_get_intfdata(interface);
 673         if (line6 == NULL)
 674                 return;
 675
 676         /* free buffer memory first: */
 677         kfree(line6->buffer_message);
 678         kfree(line6->buffer_listen);
 679
 680         /* then free URBs: */
 681         usb_free_urb(line6->urb_listen);
 682
 683         /* make sure the device isn't destructed twice: */
 684         usb_set_intfdata(interface, NULL);
 685
 686         /* free interface data: */
 687         kfree(line6);
 688 }
 689
 690 /*
 691         Probe USB device.
 692 */
 693 static int line6_probe(struct usb_interface *interface,
 694                        const struct usb_device_id *id)
 695 {
 696         int devtype;
 697         struct usb_device *usbdev;
 698         struct usb_line6 *line6;
 699         const struct line6_properties *properties;
 700         int interface_number, alternate = 0;
 701         int product;
 702         int size = 0;
 703         int ep_read = 0, ep_write = 0;
 704         int ret;
 705
 706         if (interface == NULL)
 707                 return -ENODEV;
 708         usbdev = interface_to_usbdev(interface);
 709         if (usbdev == NULL)
 710                 return -ENODEV;
 711
 712         /* we don't handle multiple configurations */
 713         if (usbdev->descriptor.bNumConfigurations != 1) {
 714                 ret = -ENODEV;
 715                 goto err_put;
 716         }
 717
 718         /* check vendor and product id */
 719         for (devtype = ARRAY_SIZE(line6_id_table) - 1; devtype--;) {
 720                 u16 idVendor = le16_to_cpu(usbdev->descriptor.idVendor);
 721                 u16 idProduct = le16_to_cpu(usbdev->descriptor.idProduct);
 722
 723                 if (idVendor == line6_id_table[devtype].idVendor &&
 724                     idProduct == line6_id_table[devtype].idProduct)
 725                         break;
 726         }
 727
 728         if (devtype < 0) {
 729                 ret = -ENODEV;
 730                 goto err_put;
 731         }
 732
 733         /* initialize device info: */
 734         properties = &line6_properties_table[devtype];
 735         dev_info(&interface->dev, "Line6 %s found\n", properties->name);
 736         product = le16_to_cpu(usbdev->descriptor.idProduct);
 737
 738         /* query interface number */
 739         interface_number = interface->cur_altsetting->desc.bInterfaceNumber;
 740
 741         switch (product) {
 742         case LINE6_DEVID_BASSPODXTLIVE:
 743         case LINE6_DEVID_PODXTLIVE:
 744         case LINE6_DEVID_VARIAX:
 745                 alternate = 1;
 746                 break;
 747
 748         case LINE6_DEVID_POCKETPOD:
 749                 switch (interface_number) {
 750                 case 0:
 751                         return 0;       /* this interface has no endpoints */
 752                 case 1:
 753                         alternate = 0;
 754                         break;
 755                 default:
 756                         MISSING_CASE;
 757                 }
 758                 break;
 759
 760         case LINE6_DEVID_PODHD500:
 761         case LINE6_DEVID_PODX3:
 762         case LINE6_DEVID_PODX3LIVE:
 763                 switch (interface_number) {
 764                 case 0:
 765                         alternate = 1;
 766                         break;
 767                 case 1:
 768                         alternate = 0;
 769                         break;
 770                 default:
 771                         MISSING_CASE;
 772                 }
 773                 break;
 774
 775         case LINE6_DEVID_BASSPODXT:
 776         case LINE6_DEVID_BASSPODXTPRO:
 777         case LINE6_DEVID_PODXT:
 778         case LINE6_DEVID_PODXTPRO:
 779         case LINE6_DEVID_PODHD300:
 780                 alternate = 5;
 781                 break;
 782
 783         case LINE6_DEVID_GUITARPORT:
 784         case LINE6_DEVID_PODSTUDIO_GX:
 785         case LINE6_DEVID_PODSTUDIO_UX1:
 786         case LINE6_DEVID_TONEPORT_GX:
 787         case LINE6_DEVID_TONEPORT_UX1:
 788                 alternate = 2;  /* 1..4 seem to be ok */
 789                 break;
 790
 791         case LINE6_DEVID_TONEPORT_UX2:
 792         case LINE6_DEVID_PODSTUDIO_UX2:
 793                 switch (interface_number) {
 794                 case 0:
 795                         /* defaults to 44.1kHz, 16-bit */
 796                         alternate = 2;
 797                         break;
 798                 case 1:
 799                         /* don't know yet what this is ...
 800                            alternate = 1;
 801                            break;
 802                          */
 803                         return -ENODEV;
 804                 default:
 805                         MISSING_CASE;
 806                 }
 807                 break;
 808
 809         default:
 810                 MISSING_CASE;
 811                 ret = -ENODEV;
 812                 goto err_put;
 813         }
 814
 815         ret = usb_set_interface(usbdev, interface_number, alternate);
 816         if (ret < 0) {
 817                 dev_err(&interface->dev, "set_interface failed\n");
 818                 goto err_put;
 819         }
 820
 821         /* initialize device data based on product id: */
 822         switch (product) {
 823         case LINE6_DEVID_BASSPODXT:
 824         case LINE6_DEVID_BASSPODXTLIVE:
 825         case LINE6_DEVID_BASSPODXTPRO:
 826         case LINE6_DEVID_PODXT:
 827         case LINE6_DEVID_PODXTPRO:
 828                 size = sizeof(struct usb_line6_pod);
 829                 ep_read = 0x84;
 830                 ep_write = 0x03;
 831                 break;
 832
 833         case LINE6_DEVID_PODHD300:
 834                 size = sizeof(struct usb_line6_podhd);
 835                 ep_read = 0x84;
 836                 ep_write = 0x03;
 837                 break;
 838
 839         case LINE6_DEVID_PODHD500:
 840                 size = sizeof(struct usb_line6_podhd);
 841                 ep_read = 0x81;
 842                 ep_write = 0x01;
 843                 break;
 844
 845         case LINE6_DEVID_POCKETPOD:
 846                 size = sizeof(struct usb_line6_pod);
 847                 ep_read = 0x82;
 848                 ep_write = 0x02;
 849                 break;
 850
 851         case LINE6_DEVID_PODX3:
 852         case LINE6_DEVID_PODX3LIVE:
 853                 /* currently unused! */
 854                 size = sizeof(struct usb_line6_pod);
 855                 ep_read = 0x81;
 856                 ep_write = 0x01;
 857                 break;
 858
 859         case LINE6_DEVID_PODSTUDIO_GX:
 860         case LINE6_DEVID_PODSTUDIO_UX1:
 861         case LINE6_DEVID_PODSTUDIO_UX2:
 862         case LINE6_DEVID_TONEPORT_GX:
 863         case LINE6_DEVID_TONEPORT_UX1:
 864         case LINE6_DEVID_TONEPORT_UX2:
 865         case LINE6_DEVID_GUITARPORT:
 866                 size = sizeof(struct usb_line6_toneport);
 867                 /* these don't have a control channel */
 868                 break;
 869
 870         case LINE6_DEVID_PODXTLIVE:
 871                 switch (interface_number) {
 872                 case PODXTLIVE_INTERFACE_POD:
 873                         size = sizeof(struct usb_line6_pod);
 874                         ep_read = 0x84;
 875                         ep_write = 0x03;
 876                         break;
 877
 878                 case PODXTLIVE_INTERFACE_VARIAX:
 879                         size = sizeof(struct usb_line6_variax);
 880                         ep_read = 0x86;
 881                         ep_write = 0x05;
 882                         break;
 883
 884                 default:
 885                         ret = -ENODEV;
 886                         goto err_put;
 887                 }
 888                 break;
 889
 890         case LINE6_DEVID_VARIAX:
 891                 size = sizeof(struct usb_line6_variax);
 892                 ep_read = 0x82;
 893                 ep_write = 0x01;
 894                 break;
 895
 896         default:
 897                 MISSING_CASE;
 898                 ret = -ENODEV;
 899                 goto err_put;
 900         }
 901
 902         if (size == 0) {
 903                 dev_err(&interface->dev,
 904                         "driver bug: interface data size not set\n");
 905                 ret = -ENODEV;
 906                 goto err_put;
 907         }
 908
 909         line6 = kzalloc(size, GFP_KERNEL);
 910
 911         if (line6 == NULL) {
 912                 dev_err(&interface->dev, "Out of memory\n");
 913                 ret = -ENODEV;
 914                 goto err_put;
 915         }
 916
 917         /* store basic data: */
 918         line6->interface_number = interface_number;
 919         line6->properties = properties;
 920         line6->usbdev = usbdev;
 921         line6->ifcdev = &interface->dev;
 922         line6->ep_control_read = ep_read;
 923         line6->ep_control_write = ep_write;
 924         line6->product = product;
 925
 926         /* get data from endpoint descriptor (see usb_maxpacket): */
 927         {
 928                 struct usb_host_endpoint *ep;
 929                 unsigned epnum =
 930                     usb_pipeendpoint(usb_rcvintpipe(usbdev, ep_read));
 931                 ep = usbdev->ep_in[epnum];
 932
 933                 if (ep != NULL) {
 934                         line6->interval = ep->desc.bInterval;
 935                         line6->max_packet_size =
 936                             le16_to_cpu(ep->desc.wMaxPacketSize);
 937                 } else {
 938                         line6->interval = LINE6_FALLBACK_INTERVAL;
 939                         line6->max_packet_size = LINE6_FALLBACK_MAXPACKETSIZE;
 940                         dev_err(line6->ifcdev,
 941                                 "endpoint not available, using fallback values");
 942                 }
 943         }
 944
 945         usb_set_intfdata(interface, line6);
 946
 947         if (properties->capabilities & LINE6_BIT_CONTROL) {
 948                 /* initialize USB buffers: */
 949                 line6->buffer_listen =
 950                     kmalloc(LINE6_BUFSIZE_LISTEN, GFP_KERNEL);
 951
 952                 if (line6->buffer_listen == NULL) {
 953                         dev_err(&interface->dev, "Out of memory\n");
 954                         ret = -ENOMEM;
 955                         goto err_destruct;
 956                 }
 957
 958                 line6->buffer_message =
 959                     kmalloc(LINE6_MESSAGE_MAXLEN, GFP_KERNEL);
 960
 961                 if (line6->buffer_message == NULL) {
 962                         dev_err(&interface->dev, "Out of memory\n");
 963                         ret = -ENOMEM;
 964                         goto err_destruct;
 965                 }
 966
 967                 line6->urb_listen = usb_alloc_urb(0, GFP_KERNEL);
 968
 969                 if (line6->urb_listen == NULL) {
 970                         dev_err(&interface->dev, "Out of memory\n");
 971                         line6_destruct(interface);
 972                         ret = -ENOMEM;
 973                         goto err_destruct;
 974                 }
 975
 976                 ret = line6_start_listen(line6);
 977                 if (ret < 0) {
 978                         dev_err(&interface->dev, "%s: usb_submit_urb failed\n",
 979                                 __func__);
 980                         goto err_destruct;
 981                 }
 982         }
 983
 984         /* initialize device data based on product id: */
 985         switch (product) {
 986         case LINE6_DEVID_BASSPODXT:
 987         case LINE6_DEVID_BASSPODXTLIVE:
 988         case LINE6_DEVID_BASSPODXTPRO:
 989         case LINE6_DEVID_POCKETPOD:
 990         case LINE6_DEVID_PODX3:
 991         case LINE6_DEVID_PODX3LIVE:
 992         case LINE6_DEVID_PODXT:
 993         case LINE6_DEVID_PODXTPRO:
 994                 ret = line6_pod_init(interface, (struct usb_line6_pod *)line6);
 995                 break;
 996
 997         case LINE6_DEVID_PODHD300:
 998         case LINE6_DEVID_PODHD500:
 999                 ret = line6_podhd_init(interface,
1000                                        (struct usb_line6_podhd *)line6);
1001                 break;
1002
1003         case LINE6_DEVID_PODXTLIVE:
1004                 switch (interface_number) {
1005                 case PODXTLIVE_INTERFACE_POD:
1006                         ret =
1007                             line6_pod_init(interface,
1008                                            (struct usb_line6_pod *)line6);
1009                         break;
1010
1011                 case PODXTLIVE_INTERFACE_VARIAX:
1012                         ret =
1013                             line6_variax_init(interface,
1014                                               (struct usb_line6_variax *)line6);
1015                         break;
1016
1017                 default:
1018                         dev_err(&interface->dev,
1019                                 "PODxt Live interface %d not supported\n",
1020                                 interface_number);
1021                         ret = -ENODEV;
1022                 }
1023
1024                 break;
1025
1026         case LINE6_DEVID_VARIAX:
1027                 ret =
1028                     line6_variax_init(interface,
1029                                       (struct usb_line6_variax *)line6);
1030                 break;
1031
1032         case LINE6_DEVID_PODSTUDIO_GX:
1033         case LINE6_DEVID_PODSTUDIO_UX1:
1034         case LINE6_DEVID_PODSTUDIO_UX2:
1035         case LINE6_DEVID_TONEPORT_GX:
1036         case LINE6_DEVID_TONEPORT_UX1:
1037         case LINE6_DEVID_TONEPORT_UX2:
1038         case LINE6_DEVID_GUITARPORT:
1039                 ret =
1040                     line6_toneport_init(interface,
1041                                         (struct usb_line6_toneport *)line6);
1042                 break;
1043
1044         default:
1045                 MISSING_CASE;
1046                 ret = -ENODEV;
1047         }
1048
1049         if (ret < 0)
1050                 goto err_destruct;
1051
1052         ret = sysfs_create_link(&interface->dev.kobj, &usbdev->dev.kobj,
1053                                 "usb_device");
1054         if (ret < 0)
1055                 goto err_destruct;
1056
1057         /* creation of additional special files should go here */
1058
1059         dev_info(&interface->dev, "Line6 %s now attached\n",
1060                  line6->properties->name);
1061
1062         switch (product) {
1063         case LINE6_DEVID_PODX3:
1064         case LINE6_DEVID_PODX3LIVE:
1065                 dev_info(&interface->dev,
1066                          "NOTE: the Line6 %s is detected, but not yet supported\n",
1067                          line6->properties->name);
1068         }
1069
1070         /* increment reference counters: */
1071         usb_get_intf(interface);
1072         usb_get_dev(usbdev);
1073
1074         return 0;
1075
1076 err_destruct:
1077         line6_destruct(interface);
1078 err_put:
1079         return ret;
1080 }
1081
1082 /*
1083         Line6 device disconnected.
1084 */
1085 static void line6_disconnect(struct usb_interface *interface)
1086 {
1087         struct usb_line6 *line6;
1088         struct usb_device *usbdev;
1089         int interface_number;
1090
1091         if (interface == NULL)
1092                 return;
1093         usbdev = interface_to_usbdev(interface);
1094         if (usbdev == NULL)
1095                 return;
1096
1097         /* removal of additional special files should go here */
1098
1099         sysfs_remove_link(&interface->dev.kobj, "usb_device");
1100
1101         interface_number = interface->cur_altsetting->desc.bInterfaceNumber;
1102         line6 = usb_get_intfdata(interface);
1103
1104         if (line6 != NULL) {
1105                 if (line6->urb_listen != NULL)
1106                         line6_stop_listen(line6);
1107
1108                 if (usbdev != line6->usbdev)
1109                         dev_err(line6->ifcdev,
1110                                 "driver bug: inconsistent usb device\n");
1111
1112                 switch (line6->usbdev->descriptor.idProduct) {
1113                 case LINE6_DEVID_BASSPODXT:
1114                 case LINE6_DEVID_BASSPODXTLIVE:
1115                 case LINE6_DEVID_BASSPODXTPRO:
1116                 case LINE6_DEVID_POCKETPOD:
1117                 case LINE6_DEVID_PODX3:
1118                 case LINE6_DEVID_PODX3LIVE:
1119                 case LINE6_DEVID_PODXT:
1120                 case LINE6_DEVID_PODXTPRO:
1121                         line6_pod_disconnect(interface);
1122                         break;
1123
1124                 case LINE6_DEVID_PODHD300:
1125                 case LINE6_DEVID_PODHD500:
1126                         line6_podhd_disconnect(interface);
1127                         break;
1128
1129                 case LINE6_DEVID_PODXTLIVE:
1130                         switch (interface_number) {
1131                         case PODXTLIVE_INTERFACE_POD:
1132                                 line6_pod_disconnect(interface);
1133                                 break;
1134
1135                         case PODXTLIVE_INTERFACE_VARIAX:
1136                                 line6_variax_disconnect(interface);
1137                                 break;
1138                         }
1139
1140                         break;
1141
1142                 case LINE6_DEVID_VARIAX:
1143                         line6_variax_disconnect(interface);
1144                         break;
1145
1146                 case LINE6_DEVID_PODSTUDIO_GX:
1147                 case LINE6_DEVID_PODSTUDIO_UX1:
1148                 case LINE6_DEVID_PODSTUDIO_UX2:
1149                 case LINE6_DEVID_TONEPORT_GX:
1150                 case LINE6_DEVID_TONEPORT_UX1:
1151                 case LINE6_DEVID_TONEPORT_UX2:
1152                 case LINE6_DEVID_GUITARPORT:
1153                         line6_toneport_disconnect(interface);
1154                         break;
1155
1156                 default:
1157                         MISSING_CASE;
1158                 }
1159
1160                 dev_info(&interface->dev, "Line6 %s now disconnected\n",
1161                          line6->properties->name);
1162         }
1163
1164         line6_destruct(interface);
1165
1166         /* decrement reference counters: */
1167         usb_put_intf(interface);
1168         usb_put_dev(usbdev);
1169 }
1170
1171 #ifdef CONFIG_PM
1172
1173 /*
1174         Suspend Line6 device.
1175 */
1176 static int line6_suspend(struct usb_interface *interface, pm_message_t message)
1177 {
1178         struct usb_line6 *line6 = usb_get_intfdata(interface);
1179         struct snd_line6_pcm *line6pcm = line6->line6pcm;
1180
1181         snd_power_change_state(line6->card, SNDRV_CTL_POWER_D3hot);
1182
1183         if (line6->properties->capabilities & LINE6_BIT_CONTROL)
1184                 line6_stop_listen(line6);
1185
1186         if (line6pcm != NULL) {
1187                 snd_pcm_suspend_all(line6pcm->pcm);
1188                 line6_pcm_disconnect(line6pcm);
1189                 line6pcm->flags = 0;
1190         }
1191
1192         return 0;
1193 }
1194
1195 /*
1196         Resume Line6 device.
1197 */
1198 static int line6_resume(struct usb_interface *interface)
1199 {
1200         struct usb_line6 *line6 = usb_get_intfdata(interface);
1201
1202         if (line6->properties->capabilities & LINE6_BIT_CONTROL)
1203                 line6_start_listen(line6);
1204
1205         snd_power_change_state(line6->card, SNDRV_CTL_POWER_D0);
1206         return 0;
1207 }
1208
1209 /*
1210         Resume Line6 device after reset.
1211 */
1212 static int line6_reset_resume(struct usb_interface *interface)
1213 {
1214         struct usb_line6 *line6 = usb_get_intfdata(interface);
1215
1216         switch (line6->usbdev->descriptor.idProduct) {
1217         case LINE6_DEVID_PODSTUDIO_GX:
1218         case LINE6_DEVID_PODSTUDIO_UX1:
1219         case LINE6_DEVID_PODSTUDIO_UX2:
1220         case LINE6_DEVID_TONEPORT_GX:
1221         case LINE6_DEVID_TONEPORT_UX1:
1222         case LINE6_DEVID_TONEPORT_UX2:
1223         case LINE6_DEVID_GUITARPORT:
1224                 line6_toneport_reset_resume((struct usb_line6_toneport *)line6);
1225         }
1226
1227         return line6_resume(interface);
1228 }
1229
1230 #endif /* CONFIG_PM */
1231
1232 static struct usb_driver line6_driver = {
1233         .name = DRIVER_NAME,
1234         .probe = line6_probe,
1235         .disconnect = line6_disconnect,
1236 #ifdef CONFIG_PM
1237         .suspend = line6_suspend,
1238         .resume = line6_resume,
1239         .reset_resume = line6_reset_resume,
1240 #endif
1241         .id_table = line6_id_table,
1242 };
1243
1244 module_usb_driver(line6_driver);
1245
1246 MODULE_AUTHOR(DRIVER_AUTHOR);
1247 MODULE_DESCRIPTION(DRIVER_DESC);
1248 MODULE_LICENSE("GPL");
1249 MODULE_VERSION(DRIVER_VERSION);