Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 1 | /* |
Markus Grabner | e1a164d | 2010-08-23 01:08:25 +0200 | [diff] [blame] | 2 | * Line6 Linux USB driver - 0.9.1beta |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 3 | * |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 4 | * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 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 | |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 12 | #include <linux/kernel.h> |
| 13 | #include <linux/module.h> |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 14 | #include <linux/export.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 15 | #include <linux/slab.h> |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 16 | #include <linux/usb.h> |
| 17 | |
| 18 | #include "audio.h" |
| 19 | #include "capture.h" |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 20 | #include "driver.h" |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 21 | #include "midi.h" |
| 22 | #include "playback.h" |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 23 | #include "revision.h" |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 24 | #include "usbdefs.h" |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 25 | |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 26 | #define DRIVER_AUTHOR "Markus Grabner <grabner@icg.tugraz.at>" |
| 27 | #define DRIVER_DESC "Line6 USB Driver" |
Markus Grabner | e1a164d | 2010-08-23 01:08:25 +0200 | [diff] [blame] | 28 | #define DRIVER_VERSION "0.9.1beta" DRIVER_REVISION |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 29 | |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 30 | /* |
| 31 | This is Line6's MIDI manufacturer ID. |
| 32 | */ |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 33 | const unsigned char line6_midi_id[] = { |
| 34 | 0x00, 0x01, 0x0c |
| 35 | }; |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 36 | EXPORT_SYMBOL_GPL(line6_midi_id); |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 37 | |
| 38 | /* |
| 39 | Code to request version of POD, Variax interface |
| 40 | (and maybe other devices). |
| 41 | */ |
Greg Kroah-Hartman | c46b8a6 | 2012-04-23 16:09:56 -0700 | [diff] [blame] | 42 | static const char line6_request_version[] = { |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 43 | 0xf0, 0x7e, 0x7f, 0x06, 0x01, 0xf7 |
| 44 | }; |
| 45 | |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 46 | /** |
| 47 | Class for asynchronous messages. |
| 48 | */ |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 49 | struct message { |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 50 | struct usb_line6 *line6; |
| 51 | const char *buffer; |
| 52 | int size; |
| 53 | int done; |
| 54 | }; |
| 55 | |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 56 | /* |
| 57 | Forward declarations. |
| 58 | */ |
Greg Kroah-Hartman | 0c7ab15 | 2009-02-27 20:28:04 -0800 | [diff] [blame] | 59 | static void line6_data_received(struct urb *urb); |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 60 | static int line6_send_raw_message_async_part(struct message *msg, |
| 61 | struct urb *urb); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 62 | |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 63 | /* |
| 64 | Start to listen on endpoint. |
| 65 | */ |
| 66 | static int line6_start_listen(struct usb_line6 *line6) |
| 67 | { |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 68 | int err; |
Fabian Mewes | a6b4699 | 2014-03-24 23:46:31 +0100 | [diff] [blame] | 69 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 70 | usb_fill_int_urb(line6->urb_listen, line6->usbdev, |
Chris Rorvick | 9e165be | 2015-01-12 12:42:53 -0800 | [diff] [blame] | 71 | usb_rcvintpipe(line6->usbdev, line6->properties->ep_ctrl_r), |
| 72 | line6->buffer_listen, LINE6_BUFSIZE_LISTEN, |
| 73 | line6_data_received, line6, line6->interval); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 74 | line6->urb_listen->actual_length = 0; |
Markus Grabner | e1a164d | 2010-08-23 01:08:25 +0200 | [diff] [blame] | 75 | err = usb_submit_urb(line6->urb_listen, GFP_ATOMIC); |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 76 | return err; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 77 | } |
| 78 | |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 79 | /* |
| 80 | Stop listening on endpoint. |
| 81 | */ |
| 82 | static void line6_stop_listen(struct usb_line6 *line6) |
| 83 | { |
| 84 | usb_kill_urb(line6->urb_listen); |
| 85 | } |
| 86 | |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 87 | /* |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 88 | Send raw message in pieces of wMaxPacketSize bytes. |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 89 | */ |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 90 | int line6_send_raw_message(struct usb_line6 *line6, const char *buffer, |
| 91 | int size) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 92 | { |
| 93 | int i, done = 0; |
| 94 | |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 95 | for (i = 0; i < size; i += line6->max_packet_size) { |
| 96 | int partial; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 97 | const char *frag_buf = buffer + i; |
| 98 | int frag_size = min(line6->max_packet_size, size - i); |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 99 | int retval; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 100 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 101 | retval = usb_interrupt_msg(line6->usbdev, |
Davide Berardi | ba79e52 | 2014-03-17 03:34:41 +0100 | [diff] [blame] | 102 | usb_sndintpipe(line6->usbdev, |
Chris Rorvick | 9e165be | 2015-01-12 12:42:53 -0800 | [diff] [blame] | 103 | line6->properties->ep_ctrl_w), |
Davide Berardi | ba79e52 | 2014-03-17 03:34:41 +0100 | [diff] [blame] | 104 | (char *)frag_buf, frag_size, |
| 105 | &partial, LINE6_TIMEOUT * HZ); |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 106 | |
| 107 | if (retval) { |
| 108 | dev_err(line6->ifcdev, |
| 109 | "usb_interrupt_msg failed (%d)\n", retval); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 110 | break; |
| 111 | } |
| 112 | |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 113 | done += frag_size; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 114 | } |
| 115 | |
| 116 | return done; |
| 117 | } |
| 118 | |
| 119 | /* |
| 120 | Notification of completion of asynchronous request transmission. |
| 121 | */ |
Greg Kroah-Hartman | 0c7ab15 | 2009-02-27 20:28:04 -0800 | [diff] [blame] | 122 | static void line6_async_request_sent(struct urb *urb) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 123 | { |
| 124 | struct message *msg = (struct message *)urb->context; |
| 125 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 126 | if (msg->done >= msg->size) { |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 127 | usb_free_urb(urb); |
| 128 | kfree(msg); |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 129 | } else |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 130 | line6_send_raw_message_async_part(msg, urb); |
| 131 | } |
| 132 | |
| 133 | /* |
| 134 | Asynchronously send part of a raw message. |
| 135 | */ |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 136 | static int line6_send_raw_message_async_part(struct message *msg, |
| 137 | struct urb *urb) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 138 | { |
| 139 | int retval; |
| 140 | struct usb_line6 *line6 = msg->line6; |
| 141 | int done = msg->done; |
| 142 | int bytes = min(msg->size - done, line6->max_packet_size); |
| 143 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 144 | usb_fill_int_urb(urb, line6->usbdev, |
Chris Rorvick | 9e165be | 2015-01-12 12:42:53 -0800 | [diff] [blame] | 145 | usb_sndintpipe(line6->usbdev, line6->properties->ep_ctrl_w), |
| 146 | (char *)msg->buffer + done, bytes, |
| 147 | line6_async_request_sent, msg, line6->interval); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 148 | |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 149 | msg->done += bytes; |
| 150 | retval = usb_submit_urb(urb, GFP_ATOMIC); |
| 151 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 152 | if (retval < 0) { |
| 153 | dev_err(line6->ifcdev, "%s: usb_submit_urb failed (%d)\n", |
| 154 | __func__, retval); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 155 | usb_free_urb(urb); |
| 156 | kfree(msg); |
Ashvini Varatharaj | 056e0af | 2013-10-19 22:01:22 +0530 | [diff] [blame] | 157 | return retval; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 158 | } |
| 159 | |
| 160 | return 0; |
| 161 | } |
| 162 | |
| 163 | /* |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 164 | Setup and start timer. |
| 165 | */ |
| 166 | void line6_start_timer(struct timer_list *timer, unsigned int msecs, |
Monam Agarwal | 1cad608 | 2014-02-27 21:05:18 +0530 | [diff] [blame] | 167 | void (*function)(unsigned long), unsigned long data) |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 168 | { |
| 169 | setup_timer(timer, function, data); |
Takashi Iwai | 0f2524b | 2015-01-19 11:44:40 +0100 | [diff] [blame] | 170 | mod_timer(timer, jiffies + msecs * HZ / 1000); |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 171 | } |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 172 | EXPORT_SYMBOL_GPL(line6_start_timer); |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 173 | |
| 174 | /* |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 175 | Asynchronously send raw message. |
| 176 | */ |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 177 | int line6_send_raw_message_async(struct usb_line6 *line6, const char *buffer, |
| 178 | int size) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 179 | { |
| 180 | struct message *msg; |
| 181 | struct urb *urb; |
| 182 | |
| 183 | /* create message: */ |
| 184 | msg = kmalloc(sizeof(struct message), GFP_ATOMIC); |
Joe Perches | 78110bb | 2013-02-11 09:41:29 -0800 | [diff] [blame] | 185 | if (msg == NULL) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 186 | return -ENOMEM; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 187 | |
| 188 | /* create URB: */ |
| 189 | urb = usb_alloc_urb(0, GFP_ATOMIC); |
| 190 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 191 | if (urb == NULL) { |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 192 | kfree(msg); |
| 193 | dev_err(line6->ifcdev, "Out of memory\n"); |
| 194 | return -ENOMEM; |
| 195 | } |
| 196 | |
| 197 | /* set message data: */ |
| 198 | msg->line6 = line6; |
| 199 | msg->buffer = buffer; |
| 200 | msg->size = size; |
| 201 | msg->done = 0; |
| 202 | |
| 203 | /* start sending: */ |
| 204 | return line6_send_raw_message_async_part(msg, urb); |
| 205 | } |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 206 | EXPORT_SYMBOL_GPL(line6_send_raw_message_async); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 207 | |
| 208 | /* |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 209 | Send asynchronous device version request. |
| 210 | */ |
| 211 | int line6_version_request_async(struct usb_line6 *line6) |
| 212 | { |
Greg Kroah-Hartman | c46b8a6 | 2012-04-23 16:09:56 -0700 | [diff] [blame] | 213 | char *buffer; |
| 214 | int retval; |
| 215 | |
Laurent Navet | 77ecb6f | 2012-12-03 14:20:25 +0100 | [diff] [blame] | 216 | buffer = kmemdup(line6_request_version, |
| 217 | sizeof(line6_request_version), GFP_ATOMIC); |
Greg Kroah-Hartman | c46b8a6 | 2012-04-23 16:09:56 -0700 | [diff] [blame] | 218 | if (buffer == NULL) { |
| 219 | dev_err(line6->ifcdev, "Out of memory"); |
| 220 | return -ENOMEM; |
| 221 | } |
| 222 | |
Greg Kroah-Hartman | c46b8a6 | 2012-04-23 16:09:56 -0700 | [diff] [blame] | 223 | retval = line6_send_raw_message_async(line6, buffer, |
| 224 | sizeof(line6_request_version)); |
| 225 | kfree(buffer); |
| 226 | return retval; |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 227 | } |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 228 | EXPORT_SYMBOL_GPL(line6_version_request_async); |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 229 | |
| 230 | /* |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 231 | Send sysex message in pieces of wMaxPacketSize bytes. |
| 232 | */ |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 233 | int line6_send_sysex_message(struct usb_line6 *line6, const char *buffer, |
| 234 | int size) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 235 | { |
Markus Grabner | e1a164d | 2010-08-23 01:08:25 +0200 | [diff] [blame] | 236 | return line6_send_raw_message(line6, buffer, |
| 237 | size + SYSEX_EXTRA_SIZE) - |
| 238 | SYSEX_EXTRA_SIZE; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 239 | } |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 240 | EXPORT_SYMBOL_GPL(line6_send_sysex_message); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 241 | |
| 242 | /* |
| 243 | Allocate buffer for sysex message and prepare header. |
| 244 | @param code sysex message code |
| 245 | @param size number of bytes between code and sysex end |
| 246 | */ |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 247 | char *line6_alloc_sysex_buffer(struct usb_line6 *line6, int code1, int code2, |
| 248 | int size) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 249 | { |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 250 | char *buffer = kmalloc(size + SYSEX_EXTRA_SIZE, GFP_ATOMIC); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 251 | |
Joe Perches | 78110bb | 2013-02-11 09:41:29 -0800 | [diff] [blame] | 252 | if (!buffer) |
Greg Kroah-Hartman | 536165d | 2009-02-27 20:49:46 -0800 | [diff] [blame] | 253 | return NULL; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 254 | |
| 255 | buffer[0] = LINE6_SYSEX_BEGIN; |
| 256 | memcpy(buffer + 1, line6_midi_id, sizeof(line6_midi_id)); |
| 257 | buffer[sizeof(line6_midi_id) + 1] = code1; |
| 258 | buffer[sizeof(line6_midi_id) + 2] = code2; |
| 259 | buffer[sizeof(line6_midi_id) + 3 + size] = LINE6_SYSEX_END; |
| 260 | return buffer; |
| 261 | } |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 262 | EXPORT_SYMBOL_GPL(line6_alloc_sysex_buffer); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 263 | |
| 264 | /* |
| 265 | Notification of data received from the Line6 device. |
| 266 | */ |
Greg Kroah-Hartman | 0c7ab15 | 2009-02-27 20:28:04 -0800 | [diff] [blame] | 267 | static void line6_data_received(struct urb *urb) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 268 | { |
| 269 | struct usb_line6 *line6 = (struct usb_line6 *)urb->context; |
Stefan Hajnoczi | 269edc8 | 2013-01-11 23:08:09 +0100 | [diff] [blame] | 270 | struct midi_buffer *mb = &line6->line6midi->midibuf_in; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 271 | int done; |
| 272 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 273 | if (urb->status == -ESHUTDOWN) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 274 | return; |
| 275 | |
Markus Grabner | e1a164d | 2010-08-23 01:08:25 +0200 | [diff] [blame] | 276 | done = |
| 277 | line6_midibuf_write(mb, urb->transfer_buffer, urb->actual_length); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 278 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 279 | if (done < urb->actual_length) { |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 280 | line6_midibuf_ignore(mb, done); |
Stefan Hajnoczi | e00d33c | 2012-11-11 13:52:24 +0100 | [diff] [blame] | 281 | dev_dbg(line6->ifcdev, "%d %d buffer overflow - message skipped\n", |
| 282 | done, urb->actual_length); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 283 | } |
| 284 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 285 | for (;;) { |
Markus Grabner | e1a164d | 2010-08-23 01:08:25 +0200 | [diff] [blame] | 286 | done = |
| 287 | line6_midibuf_read(mb, line6->buffer_message, |
| 288 | LINE6_MESSAGE_MAXLEN); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 289 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 290 | if (done == 0) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 291 | break; |
| 292 | |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 293 | line6->message_length = done; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 294 | line6_midi_receive(line6, line6->buffer_message, done); |
| 295 | |
Chris Rorvick | 01f6b2b | 2015-01-12 12:42:58 -0800 | [diff] [blame] | 296 | if (line6->process_message) |
| 297 | line6->process_message(line6); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 298 | } |
| 299 | |
| 300 | line6_start_listen(line6); |
| 301 | } |
| 302 | |
| 303 | /* |
| 304 | Send channel number (i.e., switch to a different sound). |
| 305 | */ |
Johannes Thumshirn | 317e188 | 2012-06-27 21:25:58 +0200 | [diff] [blame] | 306 | int line6_send_program(struct usb_line6 *line6, u8 value) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 307 | { |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 308 | int retval; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 309 | unsigned char *buffer; |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 310 | int partial; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 311 | |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 312 | buffer = kmalloc(2, GFP_KERNEL); |
Joe Perches | 78110bb | 2013-02-11 09:41:29 -0800 | [diff] [blame] | 313 | if (!buffer) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 314 | return -ENOMEM; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 315 | |
| 316 | buffer[0] = LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_HOST; |
| 317 | buffer[1] = value; |
| 318 | |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 319 | retval = usb_interrupt_msg(line6->usbdev, |
| 320 | usb_sndintpipe(line6->usbdev, |
Chris Rorvick | 9e165be | 2015-01-12 12:42:53 -0800 | [diff] [blame] | 321 | line6->properties->ep_ctrl_w), |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 322 | buffer, 2, &partial, LINE6_TIMEOUT * HZ); |
| 323 | |
| 324 | if (retval) |
Markus Grabner | e1a164d | 2010-08-23 01:08:25 +0200 | [diff] [blame] | 325 | dev_err(line6->ifcdev, "usb_interrupt_msg failed (%d)\n", |
| 326 | retval); |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 327 | |
| 328 | kfree(buffer); |
| 329 | return retval; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 330 | } |
| 331 | |
| 332 | /* |
| 333 | Transmit Line6 control parameter. |
| 334 | */ |
Johannes Thumshirn | 2471c09 | 2012-06-27 21:25:55 +0200 | [diff] [blame] | 335 | int line6_transmit_parameter(struct usb_line6 *line6, int param, u8 value) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 336 | { |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 337 | int retval; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 338 | unsigned char *buffer; |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 339 | int partial; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 340 | |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 341 | buffer = kmalloc(3, GFP_KERNEL); |
Joe Perches | 78110bb | 2013-02-11 09:41:29 -0800 | [diff] [blame] | 342 | if (!buffer) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 343 | return -ENOMEM; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 344 | |
| 345 | buffer[0] = LINE6_PARAM_CHANGE | LINE6_CHANNEL_HOST; |
| 346 | buffer[1] = param; |
| 347 | buffer[2] = value; |
| 348 | |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 349 | retval = usb_interrupt_msg(line6->usbdev, |
Markus Grabner | e1a164d | 2010-08-23 01:08:25 +0200 | [diff] [blame] | 350 | usb_sndintpipe(line6->usbdev, |
Chris Rorvick | 9e165be | 2015-01-12 12:42:53 -0800 | [diff] [blame] | 351 | line6->properties->ep_ctrl_w), |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 352 | buffer, 3, &partial, LINE6_TIMEOUT * HZ); |
| 353 | |
| 354 | if (retval) |
Markus Grabner | e1a164d | 2010-08-23 01:08:25 +0200 | [diff] [blame] | 355 | dev_err(line6->ifcdev, "usb_interrupt_msg failed (%d)\n", |
| 356 | retval); |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 357 | |
| 358 | kfree(buffer); |
| 359 | return retval; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 360 | } |
| 361 | |
| 362 | /* |
| 363 | Read data from device. |
| 364 | */ |
Markus Grabner | e1a164d | 2010-08-23 01:08:25 +0200 | [diff] [blame] | 365 | int line6_read_data(struct usb_line6 *line6, int address, void *data, |
| 366 | size_t datalen) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 367 | { |
| 368 | struct usb_device *usbdev = line6->usbdev; |
| 369 | int ret; |
| 370 | unsigned char len; |
| 371 | |
| 372 | /* query the serial number: */ |
| 373 | ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x67, |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 374 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, |
| 375 | (datalen << 8) | 0x21, address, |
| 376 | NULL, 0, LINE6_TIMEOUT * HZ); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 377 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 378 | if (ret < 0) { |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 379 | dev_err(line6->ifcdev, "read request failed (error %d)\n", ret); |
| 380 | return ret; |
| 381 | } |
| 382 | |
Stefan Hajnoczi | bc776f2 | 2013-01-11 23:08:10 +0100 | [diff] [blame] | 383 | /* Wait for data length. We'll get 0xff until length arrives. */ |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 384 | do { |
| 385 | ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67, |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 386 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | |
| 387 | USB_DIR_IN, |
| 388 | 0x0012, 0x0000, &len, 1, |
| 389 | LINE6_TIMEOUT * HZ); |
| 390 | if (ret < 0) { |
| 391 | dev_err(line6->ifcdev, |
| 392 | "receive length failed (error %d)\n", ret); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 393 | return ret; |
| 394 | } |
Frederik Deweerdt | d722a51 | 2009-09-15 09:29:43 +0000 | [diff] [blame] | 395 | } while (len == 0xff); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 396 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 397 | if (len != datalen) { |
| 398 | /* should be equal or something went wrong */ |
| 399 | dev_err(line6->ifcdev, |
| 400 | "length mismatch (expected %d, got %d)\n", |
| 401 | (int)datalen, (int)len); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 402 | return -EINVAL; |
| 403 | } |
| 404 | |
| 405 | /* receive the result: */ |
| 406 | ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67, |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 407 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, |
| 408 | 0x0013, 0x0000, data, datalen, |
| 409 | LINE6_TIMEOUT * HZ); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 410 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 411 | if (ret < 0) { |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 412 | dev_err(line6->ifcdev, "read failed (error %d)\n", ret); |
| 413 | return ret; |
| 414 | } |
| 415 | |
| 416 | return 0; |
| 417 | } |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 418 | EXPORT_SYMBOL_GPL(line6_read_data); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 419 | |
| 420 | /* |
| 421 | Write data to device. |
| 422 | */ |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 423 | int line6_write_data(struct usb_line6 *line6, int address, void *data, |
| 424 | size_t datalen) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 425 | { |
| 426 | struct usb_device *usbdev = line6->usbdev; |
| 427 | int ret; |
| 428 | unsigned char status; |
| 429 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 430 | ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x67, |
| 431 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, |
| 432 | 0x0022, address, data, datalen, |
| 433 | LINE6_TIMEOUT * HZ); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 434 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 435 | if (ret < 0) { |
| 436 | dev_err(line6->ifcdev, |
| 437 | "write request failed (error %d)\n", ret); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 438 | return ret; |
| 439 | } |
| 440 | |
| 441 | do { |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 442 | ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), |
| 443 | 0x67, |
| 444 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | |
| 445 | USB_DIR_IN, |
| 446 | 0x0012, 0x0000, |
| 447 | &status, 1, LINE6_TIMEOUT * HZ); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 448 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 449 | if (ret < 0) { |
| 450 | dev_err(line6->ifcdev, |
| 451 | "receiving status failed (error %d)\n", ret); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 452 | return ret; |
| 453 | } |
Greg Kroah-Hartman | 027360c | 2010-09-21 16:58:00 -0700 | [diff] [blame] | 454 | } while (status == 0xff); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 455 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 456 | if (status != 0) { |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 457 | dev_err(line6->ifcdev, "write failed (error %d)\n", ret); |
| 458 | return -EINVAL; |
| 459 | } |
| 460 | |
| 461 | return 0; |
| 462 | } |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 463 | EXPORT_SYMBOL_GPL(line6_write_data); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 464 | |
| 465 | /* |
| 466 | Read Line6 device serial number. |
| 467 | (POD, TonePort, GuitarPort) |
| 468 | */ |
| 469 | int line6_read_serial_number(struct usb_line6 *line6, int *serial_number) |
| 470 | { |
Markus Grabner | e1a164d | 2010-08-23 01:08:25 +0200 | [diff] [blame] | 471 | return line6_read_data(line6, 0x80d0, serial_number, |
| 472 | sizeof(*serial_number)); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 473 | } |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 474 | EXPORT_SYMBOL_GPL(line6_read_serial_number); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 475 | |
| 476 | /* |
| 477 | No operation (i.e., unsupported). |
| 478 | */ |
Greg Kroah-Hartman | 77491e5 | 2009-02-27 20:25:43 -0800 | [diff] [blame] | 479 | ssize_t line6_nop_read(struct device *dev, struct device_attribute *attr, |
| 480 | char *buf) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 481 | { |
| 482 | return 0; |
| 483 | } |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 484 | EXPORT_SYMBOL_GPL(line6_nop_read); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 485 | |
| 486 | /* |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 487 | Generic destructor. |
| 488 | */ |
| 489 | static void line6_destruct(struct usb_interface *interface) |
| 490 | { |
| 491 | struct usb_line6 *line6; |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 492 | |
| 493 | if (interface == NULL) |
| 494 | return; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 495 | line6 = usb_get_intfdata(interface); |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 496 | if (line6 == NULL) |
| 497 | return; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 498 | |
| 499 | /* free buffer memory first: */ |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 500 | kfree(line6->buffer_message); |
| 501 | kfree(line6->buffer_listen); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 502 | |
| 503 | /* then free URBs: */ |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 504 | usb_free_urb(line6->urb_listen); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 505 | |
| 506 | /* make sure the device isn't destructed twice: */ |
| 507 | usb_set_intfdata(interface, NULL); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 508 | } |
| 509 | |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 510 | /* |
| 511 | Probe USB device. |
| 512 | */ |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 513 | int line6_probe(struct usb_interface *interface, |
| 514 | struct usb_line6 *line6, |
| 515 | const struct line6_properties *properties, |
| 516 | int (*private_init)(struct usb_interface *, struct usb_line6 *)) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 517 | { |
Dan Carpenter | 4bd8b4d | 2011-11-30 11:43:41 +0300 | [diff] [blame] | 518 | struct usb_device *usbdev; |
Chris Rorvick | 7b9584f | 2015-01-12 12:42:52 -0800 | [diff] [blame] | 519 | int interface_number; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 520 | int ret; |
| 521 | |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 522 | if (!interface) { |
| 523 | ret = -ENODEV; |
| 524 | goto err_put; |
| 525 | } |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 526 | usbdev = interface_to_usbdev(interface); |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 527 | if (!usbdev) { |
| 528 | ret = -ENODEV; |
| 529 | goto err_put; |
| 530 | } |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 531 | |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 532 | /* we don't handle multiple configurations */ |
Kulikov Vasiliy | ab366c1 | 2010-07-13 15:22:46 +0400 | [diff] [blame] | 533 | if (usbdev->descriptor.bNumConfigurations != 1) { |
| 534 | ret = -ENODEV; |
| 535 | goto err_put; |
| 536 | } |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 537 | |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 538 | /* initialize device info: */ |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 539 | dev_info(&interface->dev, "Line6 %s found\n", properties->name); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 540 | |
| 541 | /* query interface number */ |
| 542 | interface_number = interface->cur_altsetting->desc.bInterfaceNumber; |
| 543 | |
Chris Rorvick | 7b9584f | 2015-01-12 12:42:52 -0800 | [diff] [blame] | 544 | ret = usb_set_interface(usbdev, interface_number, |
| 545 | properties->altsetting); |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 546 | if (ret < 0) { |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 547 | dev_err(&interface->dev, "set_interface failed\n"); |
Kulikov Vasiliy | ab366c1 | 2010-07-13 15:22:46 +0400 | [diff] [blame] | 548 | goto err_put; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 549 | } |
| 550 | |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 551 | /* store basic data: */ |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 552 | line6->properties = properties; |
| 553 | line6->usbdev = usbdev; |
| 554 | line6->ifcdev = &interface->dev; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 555 | |
| 556 | /* get data from endpoint descriptor (see usb_maxpacket): */ |
| 557 | { |
| 558 | struct usb_host_endpoint *ep; |
Chris Rorvick | 9e165be | 2015-01-12 12:42:53 -0800 | [diff] [blame] | 559 | unsigned pipe = usb_rcvintpipe(usbdev, properties->ep_ctrl_r); |
| 560 | unsigned epnum = usb_pipeendpoint(pipe); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 561 | ep = usbdev->ep_in[epnum]; |
| 562 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 563 | if (ep != NULL) { |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 564 | line6->interval = ep->desc.bInterval; |
Markus Grabner | e1a164d | 2010-08-23 01:08:25 +0200 | [diff] [blame] | 565 | line6->max_packet_size = |
| 566 | le16_to_cpu(ep->desc.wMaxPacketSize); |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 567 | } else { |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 568 | line6->interval = LINE6_FALLBACK_INTERVAL; |
| 569 | line6->max_packet_size = LINE6_FALLBACK_MAXPACKETSIZE; |
Markus Grabner | e1a164d | 2010-08-23 01:08:25 +0200 | [diff] [blame] | 570 | dev_err(line6->ifcdev, |
| 571 | "endpoint not available, using fallback values"); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 572 | } |
| 573 | } |
| 574 | |
| 575 | usb_set_intfdata(interface, line6); |
| 576 | |
Chris Rorvick | 4cb1a4a | 2015-01-12 12:42:45 -0800 | [diff] [blame] | 577 | if (properties->capabilities & LINE6_CAP_CONTROL) { |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 578 | /* initialize USB buffers: */ |
Markus Grabner | e1a164d | 2010-08-23 01:08:25 +0200 | [diff] [blame] | 579 | line6->buffer_listen = |
| 580 | kmalloc(LINE6_BUFSIZE_LISTEN, GFP_KERNEL); |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 581 | if (line6->buffer_listen == NULL) { |
Kulikov Vasiliy | ab366c1 | 2010-07-13 15:22:46 +0400 | [diff] [blame] | 582 | ret = -ENOMEM; |
| 583 | goto err_destruct; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 584 | } |
| 585 | |
Markus Grabner | e1a164d | 2010-08-23 01:08:25 +0200 | [diff] [blame] | 586 | line6->buffer_message = |
| 587 | kmalloc(LINE6_MESSAGE_MAXLEN, GFP_KERNEL); |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 588 | if (line6->buffer_message == NULL) { |
Kulikov Vasiliy | ab366c1 | 2010-07-13 15:22:46 +0400 | [diff] [blame] | 589 | ret = -ENOMEM; |
| 590 | goto err_destruct; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 591 | } |
| 592 | |
| 593 | line6->urb_listen = usb_alloc_urb(0, GFP_KERNEL); |
| 594 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 595 | if (line6->urb_listen == NULL) { |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 596 | dev_err(&interface->dev, "Out of memory\n"); |
Kulikov Vasiliy | ab366c1 | 2010-07-13 15:22:46 +0400 | [diff] [blame] | 597 | ret = -ENOMEM; |
| 598 | goto err_destruct; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 599 | } |
| 600 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 601 | ret = line6_start_listen(line6); |
| 602 | if (ret < 0) { |
| 603 | dev_err(&interface->dev, "%s: usb_submit_urb failed\n", |
| 604 | __func__); |
Kulikov Vasiliy | ab366c1 | 2010-07-13 15:22:46 +0400 | [diff] [blame] | 605 | goto err_destruct; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 606 | } |
| 607 | } |
| 608 | |
Chris Rorvick | a23a8bf | 2015-01-12 12:42:42 -0800 | [diff] [blame] | 609 | /* initialize device data based on device: */ |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 610 | ret = private_init(interface, line6); |
Kulikov Vasiliy | ab366c1 | 2010-07-13 15:22:46 +0400 | [diff] [blame] | 611 | if (ret < 0) |
| 612 | goto err_destruct; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 613 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 614 | ret = sysfs_create_link(&interface->dev.kobj, &usbdev->dev.kobj, |
| 615 | "usb_device"); |
Kulikov Vasiliy | ab366c1 | 2010-07-13 15:22:46 +0400 | [diff] [blame] | 616 | if (ret < 0) |
| 617 | goto err_destruct; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 618 | |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 619 | /* creation of additional special files should go here */ |
| 620 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 621 | dev_info(&interface->dev, "Line6 %s now attached\n", |
| 622 | line6->properties->name); |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 623 | |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 624 | /* increment reference counters: */ |
| 625 | usb_get_intf(interface); |
| 626 | usb_get_dev(usbdev); |
| 627 | |
Kulikov Vasiliy | ab366c1 | 2010-07-13 15:22:46 +0400 | [diff] [blame] | 628 | return 0; |
| 629 | |
| 630 | err_destruct: |
| 631 | line6_destruct(interface); |
| 632 | err_put: |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 633 | return ret; |
| 634 | } |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 635 | EXPORT_SYMBOL_GPL(line6_probe); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 636 | |
| 637 | /* |
| 638 | Line6 device disconnected. |
| 639 | */ |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 640 | void line6_disconnect(struct usb_interface *interface) |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 641 | { |
| 642 | struct usb_line6 *line6; |
| 643 | struct usb_device *usbdev; |
Stefan Hajnoczi | b430b3d | 2012-10-15 20:26:46 +0200 | [diff] [blame] | 644 | int interface_number; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 645 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 646 | if (interface == NULL) |
| 647 | return; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 648 | usbdev = interface_to_usbdev(interface); |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 649 | if (usbdev == NULL) |
| 650 | return; |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 651 | |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 652 | /* removal of additional special files should go here */ |
| 653 | |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 654 | sysfs_remove_link(&interface->dev.kobj, "usb_device"); |
| 655 | |
| 656 | interface_number = interface->cur_altsetting->desc.bInterfaceNumber; |
| 657 | line6 = usb_get_intfdata(interface); |
| 658 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 659 | if (line6 != NULL) { |
| 660 | if (line6->urb_listen != NULL) |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 661 | line6_stop_listen(line6); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 662 | |
Greg Kroah-Hartman | 36445bc | 2009-02-27 22:42:18 -0800 | [diff] [blame] | 663 | if (usbdev != line6->usbdev) |
| 664 | dev_err(line6->ifcdev, |
| 665 | "driver bug: inconsistent usb device\n"); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 666 | |
Chris Rorvick | a46c467 | 2015-01-12 12:42:59 -0800 | [diff] [blame] | 667 | line6->disconnect(interface); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 668 | |
Markus Grabner | e1a164d | 2010-08-23 01:08:25 +0200 | [diff] [blame] | 669 | dev_info(&interface->dev, "Line6 %s now disconnected\n", |
| 670 | line6->properties->name); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 671 | } |
| 672 | |
| 673 | line6_destruct(interface); |
| 674 | |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 675 | /* free interface data: */ |
| 676 | kfree(line6); |
| 677 | |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 678 | /* decrement reference counters: */ |
| 679 | usb_put_intf(interface); |
| 680 | usb_put_dev(usbdev); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 681 | } |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 682 | EXPORT_SYMBOL_GPL(line6_disconnect); |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 683 | |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 684 | #ifdef CONFIG_PM |
| 685 | |
| 686 | /* |
| 687 | Suspend Line6 device. |
| 688 | */ |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 689 | int line6_suspend(struct usb_interface *interface, pm_message_t message) |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 690 | { |
| 691 | struct usb_line6 *line6 = usb_get_intfdata(interface); |
| 692 | struct snd_line6_pcm *line6pcm = line6->line6pcm; |
| 693 | |
| 694 | snd_power_change_state(line6->card, SNDRV_CTL_POWER_D3hot); |
| 695 | |
Chris Rorvick | 4cb1a4a | 2015-01-12 12:42:45 -0800 | [diff] [blame] | 696 | if (line6->properties->capabilities & LINE6_CAP_CONTROL) |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 697 | line6_stop_listen(line6); |
| 698 | |
| 699 | if (line6pcm != NULL) { |
| 700 | snd_pcm_suspend_all(line6pcm->pcm); |
| 701 | line6_pcm_disconnect(line6pcm); |
| 702 | line6pcm->flags = 0; |
| 703 | } |
| 704 | |
| 705 | return 0; |
| 706 | } |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 707 | EXPORT_SYMBOL_GPL(line6_suspend); |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 708 | |
| 709 | /* |
| 710 | Resume Line6 device. |
| 711 | */ |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 712 | int line6_resume(struct usb_interface *interface) |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 713 | { |
| 714 | struct usb_line6 *line6 = usb_get_intfdata(interface); |
| 715 | |
Chris Rorvick | 4cb1a4a | 2015-01-12 12:42:45 -0800 | [diff] [blame] | 716 | if (line6->properties->capabilities & LINE6_CAP_CONTROL) |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 717 | line6_start_listen(line6); |
| 718 | |
| 719 | snd_power_change_state(line6->card, SNDRV_CTL_POWER_D0); |
| 720 | return 0; |
| 721 | } |
Takashi Iwai | ccddbe4 | 2015-01-15 08:22:31 +0100 | [diff] [blame^] | 722 | EXPORT_SYMBOL_GPL(line6_resume); |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 723 | |
Markus Grabner | e1a164d | 2010-08-23 01:08:25 +0200 | [diff] [blame] | 724 | #endif /* CONFIG_PM */ |
Markus Grabner | 1027f476 | 2010-08-12 01:35:30 +0200 | [diff] [blame] | 725 | |
Markus Grabner | 705ecec | 2009-02-27 19:43:04 -0800 | [diff] [blame] | 726 | MODULE_AUTHOR(DRIVER_AUTHOR); |
| 727 | MODULE_DESCRIPTION(DRIVER_DESC); |
| 728 | MODULE_LICENSE("GPL"); |
| 729 | MODULE_VERSION(DRIVER_VERSION); |