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