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