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