Pileus Git - ~andy/linux/blob - drivers/staging/line6/driver.c

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