SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/staging/line6/driver.c

   1 /*
   2  * Line6 Linux USB driver - 0.8.0
   3  *
   4  * Copyright (C) 2004-2009 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 "driver.h"
  13
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/usb.h>
  17
  18 #include "audio.h"
  19 #include "capture.h"
  20 #include "control.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
  30 #define DRIVER_AUTHOR  "Markus Grabner <grabner@icg.tugraz.at>"
  31 #define DRIVER_DESC    "Line6 USB Driver"
  32 #define DRIVER_VERSION "0.8.0"
  33
  34
  35 /* table of devices that work with this driver */
  36 static struct usb_device_id line6_id_table[] = {
  37         { USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_BASSPODXT) },
  38         { USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_BASSPODXTLIVE) },
  39         { USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_BASSPODXTPRO) },
  40         { USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_GUITARPORT) },
  41         { USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_POCKETPOD) },
  42         { USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_PODX3) },
  43         { USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_PODX3LIVE) },
  44         { USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_PODXT) },
  45         { USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_PODXTLIVE) },
  46         { USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_PODXTPRO) },
  47         { USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_TONEPORT_GX) },
  48         { USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_TONEPORT_UX1) },
  49         { USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_TONEPORT_UX2) },
  50         { USB_DEVICE(LINE6_VENDOR_ID, LINE6_DEVID_VARIAX) },
  51         { },
  52 };
  53 MODULE_DEVICE_TABLE (usb, line6_id_table);
  54
  55 static struct line6_properties line6_properties_table[] = {
  56         { "BassPODxt",        LINE6_BIT_BASSPODXT,     LINE6_BIT_CONTROL_PCM },
  57         { "BassPODxt Live",   LINE6_BIT_BASSPODXTLIVE, LINE6_BIT_CONTROL_PCM },
  58         { "BassPODxt Pro",    LINE6_BIT_BASSPODXTPRO,  LINE6_BIT_CONTROL_PCM },
  59         { "GuitarPort",       LINE6_BIT_GUITARPORT,    LINE6_BIT_PCM         },
  60         { "Pocket POD",       LINE6_BIT_POCKETPOD,     LINE6_BIT_CONTROL_PCM },
  61         { "POD X3",           LINE6_BIT_PODX3,         LINE6_BIT_PCM         },
  62         { "POD X3 Live",      LINE6_BIT_PODX3LIVE,     LINE6_BIT_PCM         },
  63         { "PODxt",            LINE6_BIT_PODXT,         LINE6_BIT_CONTROL_PCM },
  64         { "PODxt Live",       LINE6_BIT_PODXTLIVE,     LINE6_BIT_CONTROL_PCM },
  65         { "PODxt Pro",        LINE6_BIT_PODXTPRO,      LINE6_BIT_CONTROL_PCM },
  66         { "TonePort GX",      LINE6_BIT_TONEPORT_GX,   LINE6_BIT_PCM         },
  67         { "TonePort UX1",     LINE6_BIT_TONEPORT_UX1,  LINE6_BIT_PCM         },
  68         { "TonePort UX2",     LINE6_BIT_TONEPORT_UX2,  LINE6_BIT_PCM         },
  69         { "Variax Workbench", LINE6_BIT_VARIAX,        LINE6_BIT_CONTROL     }
  70 };
  71
  72
  73 /*
  74         This is Line6's MIDI manufacturer ID.
  75 */
  76 const unsigned char line6_midi_id[] = { 0x00, 0x01, 0x0c };
  77
  78 struct usb_line6 *line6_devices[LINE6_MAX_DEVICES];
  79 struct workqueue_struct *line6_workqueue;
  80
  81
  82 /**
  83          Class for asynchronous messages.
  84 */
  85 struct message
  86 {
  87         struct usb_line6 *line6;
  88         const char *buffer;
  89         int size;
  90         int done;
  91 };
  92
  93
  94 /*
  95         Forward declarations.
  96 */
  97 static void line6_data_received(struct urb *urb PT_REGS);
  98 static int line6_send_raw_message_async_part(struct message *msg, struct urb *urb);
  99
 100
 101 /*
 102         Start to listen on endpoint.
 103 */
 104 static int line6_start_listen(struct usb_line6 *line6)
 105 {
 106         usb_fill_int_urb(line6->urb_listen,
 107                                                                          line6->usbdev,
 108                                                                          usb_rcvintpipe(line6->usbdev, line6->ep_control_read),
 109                                                                          line6->buffer_listen, LINE6_BUFSIZE_LISTEN,
 110                                                                          line6_data_received,
 111                                                                          line6,
 112                                                                          line6->interval);
 113         line6->urb_listen->actual_length = 0;
 114         return usb_submit_urb(line6->urb_listen, GFP_KERNEL);
 115 }
 116
 117 #if DO_DUMP_ANY
 118 /*
 119         Write hexdump to syslog.
 120 */
 121 void line6_write_hexdump(struct usb_line6 *line6, char dir, const unsigned char *buffer, int size)
 122 {
 123         static const int BYTES_PER_LINE = 8;
 124         char hexdump[100];
 125         char asc[BYTES_PER_LINE + 1];
 126         int i, j;
 127
 128         for(i = 0; i < size; i += BYTES_PER_LINE) {
 129                 int hexdumpsize = sizeof(hexdump);
 130                 char *p = hexdump;
 131                 int n = min(size - i, BYTES_PER_LINE);
 132                 asc[n] = 0;
 133
 134                 for(j = 0; j < BYTES_PER_LINE; ++j) {
 135                         int bytes;
 136
 137                         if(j < n) {
 138                                 unsigned char val = buffer[i + j];
 139                                 bytes = snprintf(p, hexdumpsize, " %02X", val);
 140                                 asc[j] = ((val >= 0x20) && (val < 0x7f)) ? val : '.';
 141                         }
 142                         else
 143                                 bytes = snprintf(p, hexdumpsize, "   ");
 144
 145                         if(bytes > hexdumpsize)
 146                                 break;  /* buffer overflow */
 147
 148                         p += bytes;
 149                         hexdumpsize -= bytes;
 150                 }
 151
 152                 dev_info(line6->ifcdev, "%c%04X:%s %s\n", dir, i, hexdump, asc);
 153         }
 154 }
 155 #endif
 156
 157 #if DO_DUMP_URB_RECEIVE
 158 /*
 159         Dump URB data to syslog.
 160 */
 161 static void line6_dump_urb(struct urb *urb)
 162 {
 163         struct usb_line6 *line6 = (struct usb_line6 *)urb->context;
 164
 165         if(urb->status < 0)
 166                 return;
 167
 168         line6_write_hexdump(line6, 'R', (unsigned char *)urb->transfer_buffer, urb->actual_length);
 169 }
 170 #endif
 171
 172 /*
 173         Send raw message in pieces of wMaxPacketSize bytes.
 174 */
 175 int line6_send_raw_message(struct usb_line6 *line6, const char *buffer, int size)
 176 {
 177         int i, done = 0;
 178
 179 #if DO_DUMP_URB_SEND
 180         line6_write_hexdump(line6, 'S', buffer, size);
 181 #endif
 182
 183         for(i = 0; i < size; i += line6->max_packet_size)       {
 184                 int partial;
 185                 const char *frag_buf = buffer + i;
 186                 int frag_size = min(line6->max_packet_size, size - i);
 187                 int retval = usb_interrupt_msg(line6->usbdev,
 188                                                                                                                                          usb_sndintpipe(line6->usbdev, line6->ep_control_write),
 189                                                                                                                                          (char *)frag_buf, frag_size, &partial, LINE6_TIMEOUT * HZ);
 190
 191                 if(retval) {
 192                         dev_err(line6->ifcdev, "usb_interrupt_msg failed (%d)\n", retval);
 193                         break;
 194                 }
 195
 196                 done += frag_size;
 197         }
 198
 199         return done;
 200 }
 201
 202 /*
 203         Notification of completion of asynchronous request transmission.
 204 */
 205 static void line6_async_request_sent(struct urb *urb PT_REGS)
 206 {
 207         struct message *msg = (struct message *)urb->context;
 208
 209         if(msg->done >= msg->size) {
 210                 usb_free_urb(urb);
 211                 kfree(msg);
 212         }
 213         else
 214                 line6_send_raw_message_async_part(msg, urb);
 215 }
 216
 217 /*
 218         Asynchronously send part of a raw message.
 219 */
 220 static int line6_send_raw_message_async_part(struct message *msg, struct urb *urb)
 221 {
 222         int retval;
 223         struct usb_line6 *line6 = msg->line6;
 224         int done = msg->done;
 225         int bytes = min(msg->size - done, line6->max_packet_size);
 226
 227         usb_fill_int_urb(urb,
 228                                                                          line6->usbdev,
 229                                                                          usb_sndintpipe(line6->usbdev, line6->ep_control_write),
 230                                                                          (char *)msg->buffer + done, bytes,
 231                                                                          line6_async_request_sent, msg, line6->interval);
 232
 233 #if DO_DUMP_URB_SEND
 234         line6_write_hexdump(line6, 'S', (char *)msg->buffer + done, bytes);
 235 #endif
 236
 237         msg->done += bytes;
 238         retval = usb_submit_urb(urb, GFP_ATOMIC);
 239
 240         if(retval < 0) {
 241                 dev_err(line6->ifcdev, "line6_send_raw_message_async: usb_submit_urb failed (%d)\n", retval);
 242                 usb_free_urb(urb);
 243                 kfree(msg);
 244                 return -EINVAL;
 245         }
 246
 247         return 0;
 248 }
 249
 250 /*
 251         Asynchronously send raw message.
 252 */
 253 int line6_send_raw_message_async(struct usb_line6 *line6, const char *buffer, int size)
 254 {
 255         struct message *msg;
 256         struct urb *urb;
 257
 258         /* create message: */
 259         msg = kmalloc(sizeof(struct message), GFP_ATOMIC);
 260
 261         if(msg == NULL) {
 262                 dev_err(line6->ifcdev, "Out of memory\n");
 263                 return -ENOMEM;
 264         }
 265
 266         /* create URB: */
 267         urb = usb_alloc_urb(0, GFP_ATOMIC);
 268
 269         if(urb == NULL) {
 270                 kfree(msg);
 271                 dev_err(line6->ifcdev, "Out of memory\n");
 272                 return -ENOMEM;
 273         }
 274
 275         /* set message data: */
 276         msg->line6 = line6;
 277         msg->buffer = buffer;
 278         msg->size = size;
 279         msg->done = 0;
 280
 281         /* start sending: */
 282         return line6_send_raw_message_async_part(msg, urb);
 283 }
 284
 285 /*
 286         Send sysex message in pieces of wMaxPacketSize bytes.
 287 */
 288 int line6_send_sysex_message(struct usb_line6 *line6, const char *buffer, int size)
 289 {
 290         return line6_send_raw_message(line6, buffer, size + SYSEX_EXTRA_SIZE) - SYSEX_EXTRA_SIZE;
 291 }
 292
 293 /*
 294         Allocate buffer for sysex message and prepare header.
 295         @param code sysex message code
 296         @param size number of bytes between code and sysex end
 297 */
 298 char *line6_alloc_sysex_buffer(struct usb_line6 *line6, int code1, int code2, int size)
 299 {
 300         char *buffer = kmalloc(size + SYSEX_EXTRA_SIZE, GFP_KERNEL);
 301
 302         if(!buffer) {
 303                 dev_err(line6->ifcdev, "out of memory\n");
 304                 return 0;
 305         }
 306
 307         buffer[0] = LINE6_SYSEX_BEGIN;
 308         memcpy(buffer + 1, line6_midi_id, sizeof(line6_midi_id));
 309         buffer[sizeof(line6_midi_id) + 1] = code1;
 310         buffer[sizeof(line6_midi_id) + 2] = code2;
 311         buffer[sizeof(line6_midi_id) + 3 + size] = LINE6_SYSEX_END;
 312         return buffer;
 313 }
 314
 315 /*
 316         Notification of data received from the Line6 device.
 317 */
 318 static void line6_data_received(struct urb *urb PT_REGS)
 319 {
 320         struct usb_line6 *line6 = (struct usb_line6 *)urb->context;
 321         struct MidiBuffer *mb = &line6->line6midi->midibuf_in;
 322         int done;
 323
 324         if(urb->status == -ESHUTDOWN)
 325                 return;
 326
 327 #if DO_DUMP_URB_RECEIVE
 328         line6_dump_urb(urb);
 329 #endif
 330
 331         done = midibuf_write(mb, urb->transfer_buffer, urb->actual_length);
 332
 333         if(done < urb->actual_length) {
 334                 midibuf_ignore(mb, done);
 335                 DEBUG_MESSAGES(dev_err(line6->ifcdev, "%d %d buffer overflow - message skipped\n", done, urb->actual_length));
 336         }
 337
 338         for(;;) {
 339                 done = midibuf_read(mb, line6->buffer_message, LINE6_MESSAGE_MAXLEN);
 340
 341                 if(done == 0)
 342                         break;
 343
 344                 /* MIDI input filter */
 345                 if(midibuf_skip_message(mb, line6->line6midi->midi_mask_receive))
 346                         continue;
 347
 348                 line6->message_length = done;
 349 #if DO_DUMP_MIDI_RECEIVE
 350                 line6_write_hexdump(line6, 'r', line6->buffer_message, done);
 351 #endif
 352                 line6_midi_receive(line6, line6->buffer_message, done);
 353
 354                 switch(line6->usbdev->descriptor.idProduct) {
 355                 case LINE6_DEVID_BASSPODXT:
 356                 case LINE6_DEVID_BASSPODXTLIVE:
 357                 case LINE6_DEVID_BASSPODXTPRO:
 358                 case LINE6_DEVID_PODXT:
 359                 case LINE6_DEVID_PODXTPRO:
 360                 case LINE6_DEVID_POCKETPOD:
 361                         pod_process_message((struct usb_line6_pod *)line6);
 362                         break;
 363
 364                 case LINE6_DEVID_PODXTLIVE:
 365                         switch(line6->interface_number) {
 366                         case PODXTLIVE_INTERFACE_POD:
 367                                 pod_process_message((struct usb_line6_pod *)line6);
 368                                 break;
 369
 370                         case PODXTLIVE_INTERFACE_VARIAX:
 371                                 variax_process_message((struct usb_line6_variax *)line6);
 372                                 break;
 373
 374                         default:
 375                                 dev_err(line6->ifcdev, "PODxt Live interface %d not supported\n", line6->interface_number);
 376                         }
 377                         break;
 378
 379                 case LINE6_DEVID_VARIAX:
 380                         variax_process_message((struct usb_line6_variax *)line6);
 381                         break;
 382
 383                 default:
 384                         MISSING_CASE;
 385                 }
 386         }
 387
 388         line6_start_listen(line6);
 389 }
 390
 391 /*
 392         Send channel number (i.e., switch to a different sound).
 393 */
 394 int line6_send_program(struct usb_line6 *line6, int value)
 395 {
 396         int retval;
 397         unsigned char *buffer;
 398         unsigned int partial;
 399
 400         buffer = kmalloc(2, GFP_KERNEL);
 401
 402         if(!buffer) {
 403                 dev_err(line6->ifcdev, "out of memory\n");
 404                 return -ENOMEM;
 405         }
 406
 407         buffer[0] = LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_HOST;
 408         buffer[1] = value;
 409
 410 #if DO_DUMP_URB_SEND
 411         line6_write_hexdump(line6, 'S', buffer, 2);
 412 #endif
 413
 414         retval = usb_interrupt_msg(line6->usbdev,
 415                                                                                                                  usb_sndintpipe(line6->usbdev, line6->ep_control_write),
 416                                                                                                                  buffer, 2, &partial, LINE6_TIMEOUT * HZ);
 417
 418         if(retval)
 419                 dev_err(line6->ifcdev, "usb_interrupt_msg failed (%d)\n", retval);
 420
 421         kfree(buffer);
 422         return retval;
 423 }
 424
 425 /*
 426         Transmit Line6 control parameter.
 427 */
 428 int line6_transmit_parameter(struct usb_line6 *line6, int param, int value)
 429 {
 430         int retval;
 431         unsigned char *buffer;
 432         unsigned int partial;
 433
 434         buffer = kmalloc(3, GFP_KERNEL);
 435
 436         if(!buffer) {
 437                 dev_err(line6->ifcdev, "out of memory\n");
 438                 return -ENOMEM;
 439         }
 440
 441         buffer[0] = LINE6_PARAM_CHANGE | LINE6_CHANNEL_HOST;
 442         buffer[1] = param;
 443         buffer[2] = value;
 444
 445 #if DO_DUMP_URB_SEND
 446         line6_write_hexdump(line6, 'S', buffer, 3);
 447 #endif
 448
 449         retval = usb_interrupt_msg(line6->usbdev,
 450                                                                                                                  usb_sndintpipe(line6->usbdev, line6->ep_control_write),
 451                                                                                                                  buffer, 3, &partial, LINE6_TIMEOUT * HZ);
 452
 453         if(retval)
 454                 dev_err(line6->ifcdev, "usb_interrupt_msg failed (%d)\n", retval);
 455
 456         kfree(buffer);
 457         return retval;
 458 }
 459
 460 /*
 461         Read data from device.
 462 */
 463 int line6_read_data(struct usb_line6 *line6, int address, void *data, size_t datalen)
 464 {
 465         struct usb_device *usbdev = line6->usbdev;
 466         int ret;
 467         unsigned char len;
 468
 469         /* query the serial number: */
 470         ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x67,
 471                                                                                                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
 472                                                                                                 (datalen << 8) | 0x21, address, 0, 0, LINE6_TIMEOUT * HZ);
 473
 474         if(ret < 0) {
 475                 dev_err(line6->ifcdev, "read request failed (error %d)\n", ret);
 476                 return ret;
 477         }
 478
 479         /* Wait for data length. We'll get a couple of 0xff until length arrives. */
 480         do {
 481                 ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67,
 482                                                                                                         USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
 483                                                                                                         0x0012, 0x0000, &len, 1, LINE6_TIMEOUT * HZ);
 484                 if(ret < 0) {
 485                         dev_err(line6->ifcdev, "receive length failed (error %d)\n", ret);
 486                         return ret;
 487                 }
 488         }
 489         while(len == 0xff);
 490
 491         if(len != datalen) {  /* should be equal or something went wrong */
 492                 dev_err(line6->ifcdev, "length mismatch (expected %d, got %d)\n", (int)datalen, (int)len);
 493                 return -EINVAL;
 494         }
 495
 496         /* receive the result: */
 497         ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67,
 498                                                                                                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
 499                                                                                                 0x0013, 0x0000, data, datalen, LINE6_TIMEOUT * HZ);
 500
 501         if(ret < 0) {
 502                 dev_err(line6->ifcdev, "read failed (error %d)\n", ret);
 503                 return ret;
 504         }
 505
 506         return 0;
 507 }
 508
 509 /*
 510         Write data to device.
 511 */
 512 int line6_write_data(struct usb_line6 *line6, int address, void *data, size_t datalen)
 513 {
 514         struct usb_device *usbdev = line6->usbdev;
 515         int ret;
 516         unsigned char status;
 517
 518         ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev,0), 0x67,
 519                                                                         USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
 520                                                                         0x0022, address, data, datalen, LINE6_TIMEOUT * HZ);
 521
 522         if(ret < 0) {
 523                 dev_err(line6->ifcdev, "write request failed (error %d)\n", ret);
 524                 return ret;
 525         }
 526
 527         do {
 528                 ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev,0), 0x67,
 529                                                                                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
 530                                                                                 0x0012, 0x0000, &status, 1, LINE6_TIMEOUT * HZ);
 531
 532                 if(ret < 0) {
 533                         dev_err(line6->ifcdev, "receiving status failed (error %d)\n", ret);
 534                         return ret;
 535                 }
 536         }
 537         while(status == 0xff);
 538
 539         if(status != 0) {
 540                 dev_err(line6->ifcdev, "write failed (error %d)\n", ret);
 541                 return -EINVAL;
 542         }
 543
 544         return 0;
 545 }
 546
 547 /*
 548         Read Line6 device serial number.
 549         (POD, TonePort, GuitarPort)
 550 */
 551 int line6_read_serial_number(struct usb_line6 *line6, int *serial_number)
 552 {
 553         return line6_read_data(line6, 0x80d0, serial_number, sizeof(*serial_number));
 554 }
 555
 556 /*
 557         No operation (i.e., unsupported).
 558 */
 559 ssize_t line6_nop_read(struct device *dev, struct device_attribute *attr,
 560                        char *buf)
 561 {
 562         return 0;
 563 }
 564
 565 /*
 566         No operation (i.e., unsupported).
 567 */
 568 ssize_t line6_nop_write(struct device *dev, struct device_attribute *attr,
 569                         const char *buf, size_t count)
 570 {
 571         return count;
 572 }
 573
 574 /*
 575         "write" request on "raw" special file.
 576 */
 577 #if CREATE_RAW_FILE
 578 ssize_t line6_set_raw(struct device *dev, struct device_attribute *attr,
 579                       const char *buf, size_t count)
 580 {
 581         struct usb_interface *interface = to_usb_interface(dev);
 582         struct usb_line6 *line6 = usb_get_intfdata(interface);
 583         line6_send_raw_message(line6, buf, count);
 584         return count;
 585 }
 586 #endif
 587
 588 /*
 589         Generic destructor.
 590 */
 591 static void line6_destruct(struct usb_interface *interface)
 592 {
 593         struct usb_line6 *line6;
 594         if(interface == NULL) return;
 595         line6 = usb_get_intfdata(interface);
 596         if(line6 == NULL) return;
 597
 598         /* free buffer memory first: */
 599         if(line6->buffer_message != NULL) kfree(line6->buffer_message);
 600         if(line6->buffer_listen != NULL) kfree(line6->buffer_listen);
 601
 602         /* then free URBs: */
 603         if(line6->urb_listen != NULL) usb_free_urb(line6->urb_listen);
 604
 605         /* make sure the device isn't destructed twice: */
 606         usb_set_intfdata(interface, NULL);
 607
 608         /* free interface data: */
 609         kfree(line6);
 610 }
 611
 612 static void line6_list_devices(void)
 613 {
 614         int i;
 615
 616         for(i = 0; i < LINE6_MAX_DEVICES; ++i) {
 617                 struct usb_line6 *dev = line6_devices[i];
 618                 printk(KERN_INFO "Line6 device %d: ", i);
 619
 620                 if(dev == NULL)
 621                         printk("(not used)\n");
 622                 else
 623                         printk("%s:%d\n", dev->properties->name, dev->interface_number);
 624         }
 625 }
 626
 627 /*
 628         Probe USB device.
 629 */
 630 static int line6_probe(struct usb_interface *interface, const struct usb_device_id *id)
 631 {
 632         int devtype;
 633         struct usb_device *usbdev = 0;
 634         struct usb_line6 *line6 = 0;
 635         const struct line6_properties *properties;
 636         int devnum;
 637         int interface_number, alternate = 0;
 638         int product;
 639         int size = 0;
 640         int ep_read = 0, ep_write = 0;
 641         int ret;
 642
 643         if(interface == NULL) return -ENODEV;
 644         usbdev = interface_to_usbdev(interface);
 645         if(usbdev == NULL) return -ENODEV;
 646
 647         /* increment reference counters: */
 648         usb_get_intf(interface);
 649         usb_get_dev(usbdev);
 650
 651         /* we don't handle multiple configurations */
 652         if(usbdev->descriptor.bNumConfigurations != 1)
 653                 return -ENODEV;
 654
 655         /* check vendor and product id */
 656         for(devtype = sizeof(line6_id_table) / sizeof(line6_id_table[0]) - 1; devtype--;)
 657                 if((le16_to_cpu(usbdev->descriptor.idVendor) == line6_id_table[devtype].idVendor) &&
 658                          (le16_to_cpu(usbdev->descriptor.idProduct) == line6_id_table[devtype].idProduct))
 659                         break;
 660
 661         if(devtype < 0)
 662                 return -ENODEV;
 663
 664         /* find free slot in device table: */
 665         for(devnum = 0; devnum < LINE6_MAX_DEVICES; ++devnum)
 666                 if(line6_devices[devnum] == NULL)
 667                         break;
 668
 669         if(devnum == LINE6_MAX_DEVICES)
 670                 return -ENODEV;
 671
 672         /* initialize device info: */
 673         properties = &line6_properties_table[devtype];
 674         dev_info(&interface->dev, "Line6 %s found\n", properties->name);
 675         product = le16_to_cpu(usbdev->descriptor.idProduct);
 676
 677         /* query interface number */
 678         interface_number = interface->cur_altsetting->desc.bInterfaceNumber;
 679
 680         switch(product) {
 681         case LINE6_DEVID_BASSPODXTLIVE:
 682         case LINE6_DEVID_POCKETPOD:
 683         case LINE6_DEVID_PODXTLIVE:
 684         case LINE6_DEVID_VARIAX:
 685                 alternate = 1;
 686                 break;
 687
 688         case LINE6_DEVID_PODX3:
 689         case LINE6_DEVID_PODX3LIVE:
 690                 switch(interface_number) {
 691                 case 0: alternate = 1; break;
 692                 case 1: alternate = 0; break;
 693                 default: MISSING_CASE;
 694                 }
 695                 break;
 696
 697         case LINE6_DEVID_BASSPODXT:
 698         case LINE6_DEVID_BASSPODXTPRO:
 699         case LINE6_DEVID_PODXT:
 700         case LINE6_DEVID_PODXTPRO:
 701                 alternate = 5;
 702                 break;
 703
 704         case LINE6_DEVID_TONEPORT_GX:
 705         case LINE6_DEVID_GUITARPORT:
 706                 alternate = 2;  // 1..4 seem to be ok
 707                 break;
 708
 709         case LINE6_DEVID_TONEPORT_UX1:
 710         case LINE6_DEVID_TONEPORT_UX2:
 711                 switch(interface_number) {
 712                 case 0: alternate = 2; break; /* defaults to 44.1kHz, 16-bit */
 713                 case 1: alternate = 0; break;
 714                 default: MISSING_CASE;
 715                 }
 716                 break;
 717
 718         default:
 719                 MISSING_CASE;
 720                 return -ENODEV;
 721         }
 722
 723         if((ret = usb_set_interface(usbdev, interface_number, alternate)) < 0) {
 724                 dev_err(&interface->dev, "set_interface failed\n");
 725                 return ret;
 726         }
 727
 728         /* initialize device data based on product id: */
 729         switch(product) {
 730         case LINE6_DEVID_BASSPODXT:
 731         case LINE6_DEVID_BASSPODXTLIVE:
 732         case LINE6_DEVID_BASSPODXTPRO:
 733         case LINE6_DEVID_POCKETPOD:
 734         case LINE6_DEVID_PODXT:
 735         case LINE6_DEVID_PODXTPRO:
 736                 size = sizeof(struct usb_line6_pod);
 737                 ep_read  = 0x84;
 738                 ep_write = 0x03;
 739                 break;
 740
 741         case LINE6_DEVID_PODX3:
 742         case LINE6_DEVID_PODX3LIVE:
 743                 /* currently unused! */
 744                 size = sizeof(struct usb_line6_pod);
 745                 ep_read  = 0x81;
 746                 ep_write = 0x01;
 747                 break;
 748
 749         case LINE6_DEVID_TONEPORT_GX:
 750         case LINE6_DEVID_TONEPORT_UX1:
 751         case LINE6_DEVID_TONEPORT_UX2:
 752         case LINE6_DEVID_GUITARPORT:
 753                 size = sizeof(struct usb_line6_toneport);
 754                 /* these don't have a control channel */
 755                 break;
 756
 757         case LINE6_DEVID_PODXTLIVE:
 758                 switch(interface_number) {
 759                 case PODXTLIVE_INTERFACE_POD:
 760                         size = sizeof(struct usb_line6_pod);
 761                         ep_read  = 0x84;
 762                         ep_write = 0x03;
 763                         break;
 764
 765                 case PODXTLIVE_INTERFACE_VARIAX:
 766                         size = sizeof(struct usb_line6_variax);
 767                         ep_read  = 0x86;
 768                         ep_write = 0x05;
 769                         break;
 770
 771                 default:
 772                         return -ENODEV;
 773                 }
 774                 break;
 775
 776         case LINE6_DEVID_VARIAX:
 777                 size = sizeof(struct usb_line6_variax);
 778                 ep_read  = 0x82;
 779                 ep_write = 0x01;
 780                 break;
 781
 782         default:
 783                 MISSING_CASE;
 784                 return -ENODEV;
 785         }
 786
 787         if(size == 0) {
 788                 dev_err(line6->ifcdev, "driver bug: interface data size not set\n");
 789                 return -ENODEV;
 790         }
 791
 792         line6 = kzalloc(size, GFP_KERNEL);
 793
 794         if(line6 == NULL) {
 795                 dev_err(&interface->dev, "Out of memory\n");
 796                 return -ENOMEM;
 797         }
 798
 799         /* store basic data: */
 800         line6->interface_number = interface_number;
 801         line6->properties = properties;
 802         line6->usbdev = usbdev;
 803         line6->ifcdev = &interface->dev;
 804         line6->ep_control_read = ep_read;
 805         line6->ep_control_write = ep_write;
 806         line6->product = product;
 807
 808         /* get data from endpoint descriptor (see usb_maxpacket): */
 809         {
 810                 struct usb_host_endpoint *ep;
 811                 unsigned epnum = usb_pipeendpoint(usb_rcvintpipe(usbdev, ep_read));
 812                 ep = usbdev->ep_in[epnum];
 813
 814                 if(ep != NULL) {
 815                         line6->interval = ep->desc.bInterval;
 816                         line6->max_packet_size = le16_to_cpu(ep->desc.wMaxPacketSize);
 817                 }
 818                 else {
 819                         line6->interval = LINE6_FALLBACK_INTERVAL;
 820                         line6->max_packet_size = LINE6_FALLBACK_MAXPACKETSIZE;
 821                         dev_err(line6->ifcdev, "endpoint not available, using fallback values");
 822                 }
 823         }
 824
 825         usb_set_intfdata(interface, line6);
 826
 827         if(properties->capabilities & LINE6_BIT_CONTROL) {
 828                 /* initialize USB buffers: */
 829                 line6->buffer_listen = kmalloc(LINE6_BUFSIZE_LISTEN, GFP_KERNEL);
 830
 831                 if(line6->buffer_listen == NULL) {
 832                         dev_err(&interface->dev, "Out of memory\n");
 833                         line6_destruct(interface);
 834                         return -ENOMEM;
 835                 }
 836
 837                 line6->buffer_message = kmalloc(LINE6_MESSAGE_MAXLEN, GFP_KERNEL);
 838
 839                 if(line6->buffer_message == NULL) {
 840                         dev_err(&interface->dev, "Out of memory\n");
 841                         line6_destruct(interface);
 842                         return -ENOMEM;
 843                 }
 844
 845                 line6->urb_listen = usb_alloc_urb(0, GFP_KERNEL);
 846
 847                 if(line6->urb_listen == NULL) {
 848                         dev_err(&interface->dev, "Out of memory\n");
 849                         line6_destruct(interface);
 850                         return -ENOMEM;
 851                 }
 852
 853                 if((ret = line6_start_listen(line6)) < 0) {
 854                         dev_err(&interface->dev, " line6_probe: usb_submit_urb failed\n");
 855                         line6_destruct(interface);
 856                         return ret;
 857                 }
 858         }
 859
 860         /* initialize device data based on product id: */
 861         switch(product) {
 862         case LINE6_DEVID_BASSPODXT:
 863         case LINE6_DEVID_BASSPODXTLIVE:
 864         case LINE6_DEVID_BASSPODXTPRO:
 865         case LINE6_DEVID_POCKETPOD:
 866         case LINE6_DEVID_PODX3:
 867         case LINE6_DEVID_PODX3LIVE:
 868         case LINE6_DEVID_PODXT:
 869         case LINE6_DEVID_PODXTPRO:
 870                 ret = pod_init(interface, (struct usb_line6_pod *)line6);
 871                 break;
 872
 873         case LINE6_DEVID_PODXTLIVE:
 874                 switch(interface_number) {
 875                 case PODXTLIVE_INTERFACE_POD:
 876                         ret = pod_init(interface, (struct usb_line6_pod *)line6);
 877                         break;
 878
 879                 case PODXTLIVE_INTERFACE_VARIAX:
 880                         ret = variax_init(interface, (struct usb_line6_variax *)line6);
 881                         break;
 882
 883                 default:
 884                         dev_err(&interface->dev, "PODxt Live interface %d not supported\n", interface_number);
 885                         ret = -ENODEV;
 886                 }
 887
 888                 break;
 889
 890         case LINE6_DEVID_VARIAX:
 891                 ret = variax_init(interface, (struct usb_line6_variax *)line6);
 892                 break;
 893
 894         case LINE6_DEVID_TONEPORT_GX:
 895         case LINE6_DEVID_TONEPORT_UX1:
 896         case LINE6_DEVID_TONEPORT_UX2:
 897         case LINE6_DEVID_GUITARPORT:
 898                 ret = toneport_init(interface, (struct usb_line6_toneport *)line6);
 899                 break;
 900
 901         default:
 902                 MISSING_CASE;
 903                 ret = -ENODEV;
 904         }
 905
 906         if(ret < 0) {
 907                 line6_destruct(interface);
 908                 return ret;
 909         }
 910
 911         if((ret = sysfs_create_link(&interface->dev.kobj, &usbdev->dev.kobj, "usb_device")) < 0) {
 912                 line6_destruct(interface);
 913                 return ret;
 914         }
 915
 916         dev_info(&interface->dev, "Line6 %s now attached\n", line6->properties->name);
 917         line6_devices[devnum] = line6;
 918         line6_list_devices();
 919         return ret;
 920 }
 921
 922 /*
 923         Line6 device disconnected.
 924 */
 925 static void line6_disconnect(struct usb_interface *interface)
 926 {
 927         struct usb_line6 *line6;
 928         struct usb_device *usbdev;
 929         int interface_number, i;
 930
 931         if(interface == NULL) return;
 932         usbdev = interface_to_usbdev(interface);
 933         if(usbdev == NULL) return;
 934
 935         sysfs_remove_link(&interface->dev.kobj, "usb_device");
 936
 937         interface_number = interface->cur_altsetting->desc.bInterfaceNumber;
 938         line6 = usb_get_intfdata(interface);
 939
 940         if(line6 != NULL) {
 941                 if(line6->urb_listen != NULL) usb_kill_urb(line6->urb_listen);
 942
 943                 if(usbdev != line6->usbdev)
 944                         dev_err(line6->ifcdev, "driver bug: inconsistent usb device\n");
 945
 946                 switch(line6->usbdev->descriptor.idProduct) {
 947                 case LINE6_DEVID_BASSPODXT:
 948                 case LINE6_DEVID_BASSPODXTLIVE:
 949                 case LINE6_DEVID_BASSPODXTPRO:
 950                 case LINE6_DEVID_POCKETPOD:
 951                 case LINE6_DEVID_PODX3:
 952                 case LINE6_DEVID_PODX3LIVE:
 953                 case LINE6_DEVID_PODXT:
 954                 case LINE6_DEVID_PODXTPRO:
 955                         pod_disconnect(interface);
 956                         break;
 957
 958                 case LINE6_DEVID_PODXTLIVE:
 959                         switch(interface_number) {
 960                         case PODXTLIVE_INTERFACE_POD:
 961                                 pod_disconnect(interface);
 962                                 break;
 963
 964                         case PODXTLIVE_INTERFACE_VARIAX:
 965                                 variax_disconnect(interface);
 966                                 break;
 967                         }
 968
 969                         break;
 970
 971                 case LINE6_DEVID_VARIAX:
 972                         variax_disconnect(interface);
 973                         break;
 974
 975                 case LINE6_DEVID_TONEPORT_GX:
 976                 case LINE6_DEVID_TONEPORT_UX1:
 977                 case LINE6_DEVID_TONEPORT_UX2:
 978                 case LINE6_DEVID_GUITARPORT:
 979                         toneport_disconnect(interface);
 980                         break;
 981
 982                 default:
 983                         MISSING_CASE;
 984                 }
 985
 986                 dev_info(&interface->dev, "Line6 %s now disconnected\n", line6->properties->name);
 987
 988                 for(i = LINE6_MAX_DEVICES; i--;)
 989                         if(line6_devices[i] == line6)
 990                                 line6_devices[i] = 0;
 991         }
 992
 993         line6_destruct(interface);
 994
 995         /* decrement reference counters: */
 996         usb_put_intf(interface);
 997         usb_put_dev(usbdev);
 998
 999         line6_list_devices();
1000 }
1001
1002 static struct usb_driver line6_driver = {
1003 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 16)
1004         .owner = THIS_MODULE,
1005 #endif
1006         .name = DRIVER_NAME,
1007         .probe = line6_probe,
1008         .disconnect = line6_disconnect,
1009         .id_table = line6_id_table,
1010 };
1011
1012 /*
1013         Module initialization.
1014 */
1015 static int __init line6_init(void)
1016 {
1017         int i, retval;
1018
1019         printk("%s driver version %s%s\n", DRIVER_NAME, DRIVER_VERSION, DRIVER_REVISION);
1020         line6_workqueue = create_workqueue(DRIVER_NAME);
1021
1022         if(line6_workqueue == 0) {
1023                 err("couldn't create workqueue");
1024                 return -EINVAL;
1025         }
1026
1027         for(i = LINE6_MAX_DEVICES; i--;)
1028                 line6_devices[i] = 0;
1029
1030         retval = usb_register(&line6_driver);
1031
1032         if(retval)
1033                 err("usb_register failed. Error number %d", retval);
1034
1035         return retval;
1036 }
1037
1038 /*
1039         Module cleanup.
1040 */
1041 static void __exit line6_exit(void)
1042 {
1043         destroy_workqueue(line6_workqueue);
1044         usb_deregister(&line6_driver);
1045 }
1046
1047 module_init(line6_init);
1048 module_exit(line6_exit);
1049
1050 MODULE_AUTHOR(DRIVER_AUTHOR);
1051 MODULE_DESCRIPTION(DRIVER_DESC);
1052 MODULE_LICENSE("GPL");
1053 MODULE_VERSION(DRIVER_VERSION);