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