]>
Commit | Line | Data |
---|---|---|
705ececd | 1 | /* |
c078a4aa | 2 | * Line 6 Linux USB driver |
705ececd | 3 | * |
1027f476 | 4 | * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at) |
705ececd MG |
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 | ||
705ececd MG |
12 | #include <linux/kernel.h> |
13 | #include <linux/module.h> | |
ccddbe4a | 14 | #include <linux/export.h> |
5a0e3ad6 | 15 | #include <linux/slab.h> |
705ececd MG |
16 | #include <linux/usb.h> |
17 | ||
85a9339b TI |
18 | #include <sound/core.h> |
19 | #include <sound/initval.h> | |
a16039cb | 20 | #include <sound/hwdep.h> |
85a9339b | 21 | |
705ececd | 22 | #include "capture.h" |
1027f476 | 23 | #include "driver.h" |
705ececd MG |
24 | #include "midi.h" |
25 | #include "playback.h" | |
705ececd | 26 | |
705ececd | 27 | #define DRIVER_AUTHOR "Markus Grabner <grabner@icg.tugraz.at>" |
c6fffce9 | 28 | #define DRIVER_DESC "Line 6 USB Driver" |
705ececd | 29 | |
705ececd | 30 | /* |
c6fffce9 | 31 | This is Line 6's MIDI manufacturer ID. |
705ececd | 32 | */ |
8da08ca0 | 33 | const unsigned char line6_midi_id[3] = { |
1027f476 MG |
34 | 0x00, 0x01, 0x0c |
35 | }; | |
ccddbe4a | 36 | EXPORT_SYMBOL_GPL(line6_midi_id); |
1027f476 MG |
37 | |
38 | /* | |
39 | Code to request version of POD, Variax interface | |
40 | (and maybe other devices). | |
41 | */ | |
c46b8a65 | 42 | static const char line6_request_version[] = { |
1027f476 MG |
43 | 0xf0, 0x7e, 0x7f, 0x06, 0x01, 0xf7 |
44 | }; | |
45 | ||
cddbd4f1 | 46 | /* |
705ececd MG |
47 | Class for asynchronous messages. |
48 | */ | |
36445bc1 | 49 | struct message { |
705ececd MG |
50 | struct usb_line6 *line6; |
51 | const char *buffer; | |
52 | int size; | |
53 | int done; | |
54 | }; | |
55 | ||
705ececd MG |
56 | /* |
57 | Forward declarations. | |
58 | */ | |
0c7ab158 | 59 | static void line6_data_received(struct urb *urb); |
36445bc1 GKH |
60 | static int line6_send_raw_message_async_part(struct message *msg, |
61 | struct urb *urb); | |
705ececd | 62 | |
705ececd MG |
63 | /* |
64 | Start to listen on endpoint. | |
65 | */ | |
66 | static int line6_start_listen(struct usb_line6 *line6) | |
67 | { | |
1027f476 | 68 | int err; |
a6b4699d | 69 | |
174e1fc0 AK |
70 | if (line6->properties->capabilities & LINE6_CAP_CONTROL_MIDI) { |
71 | usb_fill_int_urb(line6->urb_listen, line6->usbdev, | |
72 | usb_rcvintpipe(line6->usbdev, line6->properties->ep_ctrl_r), | |
73 | line6->buffer_listen, LINE6_BUFSIZE_LISTEN, | |
74 | line6_data_received, line6, line6->interval); | |
75 | } else { | |
76 | usb_fill_bulk_urb(line6->urb_listen, line6->usbdev, | |
77 | usb_rcvbulkpipe(line6->usbdev, line6->properties->ep_ctrl_r), | |
78 | line6->buffer_listen, LINE6_BUFSIZE_LISTEN, | |
79 | line6_data_received, line6); | |
80 | } | |
705ececd | 81 | line6->urb_listen->actual_length = 0; |
e1a164d7 | 82 | err = usb_submit_urb(line6->urb_listen, GFP_ATOMIC); |
1027f476 MG |
83 | return err; |
84 | } | |
85 | ||
86 | /* | |
87 | Stop listening on endpoint. | |
88 | */ | |
89 | static void line6_stop_listen(struct usb_line6 *line6) | |
90 | { | |
91 | usb_kill_urb(line6->urb_listen); | |
705ececd MG |
92 | } |
93 | ||
705ececd | 94 | /* |
1027f476 | 95 | Send raw message in pieces of wMaxPacketSize bytes. |
705ececd | 96 | */ |
73723190 TI |
97 | static int line6_send_raw_message(struct usb_line6 *line6, const char *buffer, |
98 | int size) | |
705ececd MG |
99 | { |
100 | int i, done = 0; | |
174e1fc0 | 101 | const struct line6_properties *properties = line6->properties; |
705ececd | 102 | |
1027f476 MG |
103 | for (i = 0; i < size; i += line6->max_packet_size) { |
104 | int partial; | |
705ececd MG |
105 | const char *frag_buf = buffer + i; |
106 | int frag_size = min(line6->max_packet_size, size - i); | |
36445bc1 GKH |
107 | int retval; |
108 | ||
174e1fc0 AK |
109 | if (properties->capabilities & LINE6_CAP_CONTROL_MIDI) { |
110 | retval = usb_interrupt_msg(line6->usbdev, | |
111 | usb_sndintpipe(line6->usbdev, properties->ep_ctrl_w), | |
112 | (char *)frag_buf, frag_size, | |
113 | &partial, LINE6_TIMEOUT * HZ); | |
114 | } else { | |
115 | retval = usb_bulk_msg(line6->usbdev, | |
116 | usb_sndbulkpipe(line6->usbdev, properties->ep_ctrl_w), | |
117 | (char *)frag_buf, frag_size, | |
118 | &partial, LINE6_TIMEOUT * HZ); | |
119 | } | |
705ececd | 120 | |
36445bc1 GKH |
121 | if (retval) { |
122 | dev_err(line6->ifcdev, | |
174e1fc0 | 123 | "usb_bulk_msg failed (%d)\n", retval); |
705ececd MG |
124 | break; |
125 | } | |
126 | ||
1027f476 | 127 | done += frag_size; |
705ececd MG |
128 | } |
129 | ||
130 | return done; | |
131 | } | |
132 | ||
133 | /* | |
134 | Notification of completion of asynchronous request transmission. | |
135 | */ | |
0c7ab158 | 136 | static void line6_async_request_sent(struct urb *urb) |
705ececd MG |
137 | { |
138 | struct message *msg = (struct message *)urb->context; | |
139 | ||
36445bc1 | 140 | if (msg->done >= msg->size) { |
705ececd MG |
141 | usb_free_urb(urb); |
142 | kfree(msg); | |
36445bc1 | 143 | } else |
705ececd MG |
144 | line6_send_raw_message_async_part(msg, urb); |
145 | } | |
146 | ||
147 | /* | |
148 | Asynchronously send part of a raw message. | |
149 | */ | |
36445bc1 GKH |
150 | static int line6_send_raw_message_async_part(struct message *msg, |
151 | struct urb *urb) | |
705ececd MG |
152 | { |
153 | int retval; | |
154 | struct usb_line6 *line6 = msg->line6; | |
155 | int done = msg->done; | |
156 | int bytes = min(msg->size - done, line6->max_packet_size); | |
157 | ||
174e1fc0 AK |
158 | if (line6->properties->capabilities & LINE6_CAP_CONTROL_MIDI) { |
159 | usb_fill_int_urb(urb, line6->usbdev, | |
160 | usb_sndintpipe(line6->usbdev, line6->properties->ep_ctrl_w), | |
161 | (char *)msg->buffer + done, bytes, | |
162 | line6_async_request_sent, msg, line6->interval); | |
163 | } else { | |
164 | usb_fill_bulk_urb(urb, line6->usbdev, | |
165 | usb_sndbulkpipe(line6->usbdev, line6->properties->ep_ctrl_w), | |
166 | (char *)msg->buffer + done, bytes, | |
167 | line6_async_request_sent, msg); | |
168 | } | |
705ececd | 169 | |
705ececd MG |
170 | msg->done += bytes; |
171 | retval = usb_submit_urb(urb, GFP_ATOMIC); | |
172 | ||
36445bc1 GKH |
173 | if (retval < 0) { |
174 | dev_err(line6->ifcdev, "%s: usb_submit_urb failed (%d)\n", | |
175 | __func__, retval); | |
705ececd MG |
176 | usb_free_urb(urb); |
177 | kfree(msg); | |
056e0af2 | 178 | return retval; |
705ececd MG |
179 | } |
180 | ||
181 | return 0; | |
182 | } | |
183 | ||
1027f476 MG |
184 | /* |
185 | Setup and start timer. | |
186 | */ | |
6ccd93bd | 187 | void line6_start_timer(struct timer_list *timer, unsigned long msecs, |
1cad608e | 188 | void (*function)(unsigned long), unsigned long data) |
1027f476 MG |
189 | { |
190 | setup_timer(timer, function, data); | |
695758c6 | 191 | mod_timer(timer, jiffies + msecs_to_jiffies(msecs)); |
1027f476 | 192 | } |
ccddbe4a | 193 | EXPORT_SYMBOL_GPL(line6_start_timer); |
1027f476 | 194 | |
705ececd MG |
195 | /* |
196 | Asynchronously send raw message. | |
197 | */ | |
36445bc1 GKH |
198 | int line6_send_raw_message_async(struct usb_line6 *line6, const char *buffer, |
199 | int size) | |
705ececd MG |
200 | { |
201 | struct message *msg; | |
202 | struct urb *urb; | |
203 | ||
204 | /* create message: */ | |
205 | msg = kmalloc(sizeof(struct message), GFP_ATOMIC); | |
78110bb8 | 206 | if (msg == NULL) |
705ececd | 207 | return -ENOMEM; |
705ececd MG |
208 | |
209 | /* create URB: */ | |
210 | urb = usb_alloc_urb(0, GFP_ATOMIC); | |
211 | ||
36445bc1 | 212 | if (urb == NULL) { |
705ececd | 213 | kfree(msg); |
705ececd MG |
214 | return -ENOMEM; |
215 | } | |
216 | ||
217 | /* set message data: */ | |
218 | msg->line6 = line6; | |
219 | msg->buffer = buffer; | |
220 | msg->size = size; | |
221 | msg->done = 0; | |
222 | ||
223 | /* start sending: */ | |
224 | return line6_send_raw_message_async_part(msg, urb); | |
225 | } | |
ccddbe4a | 226 | EXPORT_SYMBOL_GPL(line6_send_raw_message_async); |
705ececd | 227 | |
1027f476 MG |
228 | /* |
229 | Send asynchronous device version request. | |
230 | */ | |
231 | int line6_version_request_async(struct usb_line6 *line6) | |
232 | { | |
c46b8a65 GKH |
233 | char *buffer; |
234 | int retval; | |
235 | ||
77ecb6fe LN |
236 | buffer = kmemdup(line6_request_version, |
237 | sizeof(line6_request_version), GFP_ATOMIC); | |
a019f5e8 | 238 | if (buffer == NULL) |
c46b8a65 | 239 | return -ENOMEM; |
c46b8a65 | 240 | |
c46b8a65 GKH |
241 | retval = line6_send_raw_message_async(line6, buffer, |
242 | sizeof(line6_request_version)); | |
243 | kfree(buffer); | |
244 | return retval; | |
1027f476 | 245 | } |
ccddbe4a | 246 | EXPORT_SYMBOL_GPL(line6_version_request_async); |
1027f476 | 247 | |
705ececd MG |
248 | /* |
249 | Send sysex message in pieces of wMaxPacketSize bytes. | |
250 | */ | |
36445bc1 GKH |
251 | int line6_send_sysex_message(struct usb_line6 *line6, const char *buffer, |
252 | int size) | |
705ececd | 253 | { |
e1a164d7 MG |
254 | return line6_send_raw_message(line6, buffer, |
255 | size + SYSEX_EXTRA_SIZE) - | |
256 | SYSEX_EXTRA_SIZE; | |
705ececd | 257 | } |
ccddbe4a | 258 | EXPORT_SYMBOL_GPL(line6_send_sysex_message); |
705ececd MG |
259 | |
260 | /* | |
261 | Allocate buffer for sysex message and prepare header. | |
262 | @param code sysex message code | |
263 | @param size number of bytes between code and sysex end | |
264 | */ | |
36445bc1 GKH |
265 | char *line6_alloc_sysex_buffer(struct usb_line6 *line6, int code1, int code2, |
266 | int size) | |
705ececd | 267 | { |
1027f476 | 268 | char *buffer = kmalloc(size + SYSEX_EXTRA_SIZE, GFP_ATOMIC); |
705ececd | 269 | |
78110bb8 | 270 | if (!buffer) |
536165d8 | 271 | return NULL; |
705ececd MG |
272 | |
273 | buffer[0] = LINE6_SYSEX_BEGIN; | |
274 | memcpy(buffer + 1, line6_midi_id, sizeof(line6_midi_id)); | |
275 | buffer[sizeof(line6_midi_id) + 1] = code1; | |
276 | buffer[sizeof(line6_midi_id) + 2] = code2; | |
277 | buffer[sizeof(line6_midi_id) + 3 + size] = LINE6_SYSEX_END; | |
278 | return buffer; | |
279 | } | |
ccddbe4a | 280 | EXPORT_SYMBOL_GPL(line6_alloc_sysex_buffer); |
705ececd MG |
281 | |
282 | /* | |
c6fffce9 | 283 | Notification of data received from the Line 6 device. |
705ececd | 284 | */ |
0c7ab158 | 285 | static void line6_data_received(struct urb *urb) |
705ececd MG |
286 | { |
287 | struct usb_line6 *line6 = (struct usb_line6 *)urb->context; | |
269edc8e | 288 | struct midi_buffer *mb = &line6->line6midi->midibuf_in; |
705ececd MG |
289 | int done; |
290 | ||
36445bc1 | 291 | if (urb->status == -ESHUTDOWN) |
705ececd MG |
292 | return; |
293 | ||
7811a3ad AK |
294 | if (line6->properties->capabilities & LINE6_CAP_CONTROL_MIDI) { |
295 | done = | |
296 | line6_midibuf_write(mb, urb->transfer_buffer, urb->actual_length); | |
705ececd | 297 | |
7811a3ad AK |
298 | if (done < urb->actual_length) { |
299 | line6_midibuf_ignore(mb, done); | |
300 | dev_dbg(line6->ifcdev, "%d %d buffer overflow - message skipped\n", | |
301 | done, urb->actual_length); | |
302 | } | |
705ececd | 303 | |
7811a3ad AK |
304 | for (;;) { |
305 | done = | |
306 | line6_midibuf_read(mb, line6->buffer_message, | |
a16039cb | 307 | LINE6_MIDI_MESSAGE_MAXLEN); |
705ececd | 308 | |
7811a3ad AK |
309 | if (done == 0) |
310 | break; | |
705ececd | 311 | |
7811a3ad AK |
312 | line6->message_length = done; |
313 | line6_midi_receive(line6, line6->buffer_message, done); | |
705ececd | 314 | |
7811a3ad AK |
315 | if (line6->process_message) |
316 | line6->process_message(line6); | |
317 | } | |
318 | } else { | |
a16039cb AK |
319 | line6->buffer_message = urb->transfer_buffer; |
320 | line6->message_length = urb->actual_length; | |
01f6b2bc CR |
321 | if (line6->process_message) |
322 | line6->process_message(line6); | |
a16039cb | 323 | line6->buffer_message = NULL; |
705ececd MG |
324 | } |
325 | ||
326 | line6_start_listen(line6); | |
327 | } | |
328 | ||
e64e94df | 329 | #define LINE6_READ_WRITE_STATUS_DELAY 2 /* milliseconds */ |
f3dfd1be | 330 | #define LINE6_READ_WRITE_MAX_RETRIES 50 |
e64e94df | 331 | |
705ececd MG |
332 | /* |
333 | Read data from device. | |
334 | */ | |
25a0707c CR |
335 | int line6_read_data(struct usb_line6 *line6, unsigned address, void *data, |
336 | unsigned datalen) | |
705ececd MG |
337 | { |
338 | struct usb_device *usbdev = line6->usbdev; | |
339 | int ret; | |
340 | unsigned char len; | |
f3dfd1be | 341 | unsigned count; |
705ececd | 342 | |
25a0707c CR |
343 | if (address > 0xffff || datalen > 0xff) |
344 | return -EINVAL; | |
345 | ||
705ececd MG |
346 | /* query the serial number: */ |
347 | ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x67, | |
1027f476 MG |
348 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, |
349 | (datalen << 8) | 0x21, address, | |
350 | NULL, 0, LINE6_TIMEOUT * HZ); | |
705ececd | 351 | |
36445bc1 | 352 | if (ret < 0) { |
705ececd MG |
353 | dev_err(line6->ifcdev, "read request failed (error %d)\n", ret); |
354 | return ret; | |
355 | } | |
356 | ||
bc776f27 | 357 | /* Wait for data length. We'll get 0xff until length arrives. */ |
f3dfd1be | 358 | for (count = 0; count < LINE6_READ_WRITE_MAX_RETRIES; count++) { |
e64e94df CR |
359 | mdelay(LINE6_READ_WRITE_STATUS_DELAY); |
360 | ||
705ececd | 361 | ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67, |
36445bc1 GKH |
362 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | |
363 | USB_DIR_IN, | |
364 | 0x0012, 0x0000, &len, 1, | |
365 | LINE6_TIMEOUT * HZ); | |
366 | if (ret < 0) { | |
367 | dev_err(line6->ifcdev, | |
368 | "receive length failed (error %d)\n", ret); | |
705ececd MG |
369 | return ret; |
370 | } | |
36445bc1 | 371 | |
f3dfd1be CR |
372 | if (len != 0xff) |
373 | break; | |
374 | } | |
375 | ||
376 | if (len == 0xff) { | |
377 | dev_err(line6->ifcdev, "read failed after %d retries\n", | |
378 | count); | |
379 | return -EIO; | |
380 | } else if (len != datalen) { | |
36445bc1 GKH |
381 | /* should be equal or something went wrong */ |
382 | dev_err(line6->ifcdev, | |
383 | "length mismatch (expected %d, got %d)\n", | |
384 | (int)datalen, (int)len); | |
e474e7fd | 385 | return -EIO; |
705ececd MG |
386 | } |
387 | ||
388 | /* receive the result: */ | |
389 | ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67, | |
36445bc1 GKH |
390 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, |
391 | 0x0013, 0x0000, data, datalen, | |
392 | LINE6_TIMEOUT * HZ); | |
705ececd | 393 | |
36445bc1 | 394 | if (ret < 0) { |
705ececd MG |
395 | dev_err(line6->ifcdev, "read failed (error %d)\n", ret); |
396 | return ret; | |
397 | } | |
398 | ||
399 | return 0; | |
400 | } | |
ccddbe4a | 401 | EXPORT_SYMBOL_GPL(line6_read_data); |
705ececd MG |
402 | |
403 | /* | |
404 | Write data to device. | |
405 | */ | |
25a0707c CR |
406 | int line6_write_data(struct usb_line6 *line6, unsigned address, void *data, |
407 | unsigned datalen) | |
705ececd MG |
408 | { |
409 | struct usb_device *usbdev = line6->usbdev; | |
410 | int ret; | |
411 | unsigned char status; | |
f3dfd1be | 412 | int count; |
705ececd | 413 | |
25a0707c CR |
414 | if (address > 0xffff || datalen > 0xffff) |
415 | return -EINVAL; | |
416 | ||
36445bc1 GKH |
417 | ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x67, |
418 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, | |
419 | 0x0022, address, data, datalen, | |
420 | LINE6_TIMEOUT * HZ); | |
705ececd | 421 | |
36445bc1 GKH |
422 | if (ret < 0) { |
423 | dev_err(line6->ifcdev, | |
424 | "write request failed (error %d)\n", ret); | |
705ececd MG |
425 | return ret; |
426 | } | |
427 | ||
f3dfd1be | 428 | for (count = 0; count < LINE6_READ_WRITE_MAX_RETRIES; count++) { |
e64e94df CR |
429 | mdelay(LINE6_READ_WRITE_STATUS_DELAY); |
430 | ||
36445bc1 GKH |
431 | ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), |
432 | 0x67, | |
433 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | | |
434 | USB_DIR_IN, | |
435 | 0x0012, 0x0000, | |
436 | &status, 1, LINE6_TIMEOUT * HZ); | |
437 | ||
438 | if (ret < 0) { | |
439 | dev_err(line6->ifcdev, | |
440 | "receiving status failed (error %d)\n", ret); | |
705ececd MG |
441 | return ret; |
442 | } | |
705ececd | 443 | |
f3dfd1be CR |
444 | if (status != 0xff) |
445 | break; | |
446 | } | |
447 | ||
448 | if (status == 0xff) { | |
449 | dev_err(line6->ifcdev, "write failed after %d retries\n", | |
450 | count); | |
451 | return -EIO; | |
452 | } else if (status != 0) { | |
705ececd | 453 | dev_err(line6->ifcdev, "write failed (error %d)\n", ret); |
e474e7fd | 454 | return -EIO; |
705ececd MG |
455 | } |
456 | ||
457 | return 0; | |
458 | } | |
ccddbe4a | 459 | EXPORT_SYMBOL_GPL(line6_write_data); |
705ececd MG |
460 | |
461 | /* | |
c6fffce9 | 462 | Read Line 6 device serial number. |
705ececd MG |
463 | (POD, TonePort, GuitarPort) |
464 | */ | |
12b00157 | 465 | int line6_read_serial_number(struct usb_line6 *line6, u32 *serial_number) |
705ececd | 466 | { |
e1a164d7 MG |
467 | return line6_read_data(line6, 0x80d0, serial_number, |
468 | sizeof(*serial_number)); | |
705ececd | 469 | } |
ccddbe4a | 470 | EXPORT_SYMBOL_GPL(line6_read_serial_number); |
705ececd | 471 | |
705ececd | 472 | /* |
85a9339b | 473 | Card destructor. |
705ececd | 474 | */ |
85a9339b | 475 | static void line6_destruct(struct snd_card *card) |
705ececd | 476 | { |
85a9339b | 477 | struct usb_line6 *line6 = card->private_data; |
aca514b8 | 478 | struct usb_device *usbdev = line6->usbdev; |
705ececd | 479 | |
a16039cb AK |
480 | /* Free buffer memory first. We cannot depend on the existence of private |
481 | * data from the (podhd) module, it may be gone already during this call | |
482 | */ | |
a4bc746c | 483 | kfree(line6->buffer_message); |
7811a3ad | 484 | |
36445bc1 | 485 | kfree(line6->buffer_listen); |
705ececd MG |
486 | |
487 | /* then free URBs: */ | |
36445bc1 | 488 | usb_free_urb(line6->urb_listen); |
a16039cb | 489 | line6->urb_listen = NULL; |
705ececd | 490 | |
85a9339b TI |
491 | /* decrement reference counters: */ |
492 | usb_put_dev(usbdev); | |
705ececd MG |
493 | } |
494 | ||
644d9085 TI |
495 | /* get data from endpoint descriptor (see usb_maxpacket): */ |
496 | static void line6_get_interval(struct usb_line6 *line6) | |
497 | { | |
498 | struct usb_device *usbdev = line6->usbdev; | |
174e1fc0 AK |
499 | const struct line6_properties *properties = line6->properties; |
500 | int pipe; | |
501 | struct usb_host_endpoint *ep; | |
502 | ||
503 | if (properties->capabilities & LINE6_CAP_CONTROL_MIDI) { | |
504 | pipe = | |
505 | usb_rcvintpipe(line6->usbdev, line6->properties->ep_ctrl_r); | |
506 | } else { | |
507 | pipe = | |
508 | usb_rcvbulkpipe(line6->usbdev, line6->properties->ep_ctrl_r); | |
509 | } | |
510 | ep = usbdev->ep_in[usb_pipeendpoint(pipe)]; | |
644d9085 | 511 | |
644d9085 TI |
512 | if (ep) { |
513 | line6->interval = ep->desc.bInterval; | |
79faa2b0 AK |
514 | if (usbdev->speed == USB_SPEED_LOW) { |
515 | line6->intervals_per_second = USB_LOW_INTERVALS_PER_SECOND; | |
516 | line6->iso_buffers = USB_LOW_ISO_BUFFERS; | |
517 | } else { | |
518 | line6->intervals_per_second = USB_HIGH_INTERVALS_PER_SECOND; | |
519 | line6->iso_buffers = USB_HIGH_ISO_BUFFERS; | |
520 | } | |
521 | ||
644d9085 TI |
522 | line6->max_packet_size = le16_to_cpu(ep->desc.wMaxPacketSize); |
523 | } else { | |
524 | dev_err(line6->ifcdev, | |
525 | "endpoint not available, using fallback values"); | |
526 | line6->interval = LINE6_FALLBACK_INTERVAL; | |
527 | line6->max_packet_size = LINE6_FALLBACK_MAXPACKETSIZE; | |
528 | } | |
529 | } | |
530 | ||
a16039cb AK |
531 | |
532 | /* Enable buffering of incoming messages, flush the buffer */ | |
533 | static int line6_hwdep_open(struct snd_hwdep *hw, struct file *file) | |
534 | { | |
535 | struct usb_line6 *line6 = hw->private_data; | |
536 | ||
537 | /* NOTE: hwdep layer provides atomicity here */ | |
538 | ||
539 | line6->messages.active = 1; | |
540 | ||
541 | return 0; | |
542 | } | |
543 | ||
544 | /* Stop buffering */ | |
545 | static int line6_hwdep_release(struct snd_hwdep *hw, struct file *file) | |
546 | { | |
547 | struct usb_line6 *line6 = hw->private_data; | |
548 | ||
549 | line6->messages.active = 0; | |
550 | ||
551 | return 0; | |
552 | } | |
553 | ||
554 | /* Read from circular buffer, return to user */ | |
555 | static long | |
556 | line6_hwdep_read(struct snd_hwdep *hwdep, char __user *buf, long count, | |
557 | loff_t *offset) | |
558 | { | |
559 | struct usb_line6 *line6 = hwdep->private_data; | |
560 | long rv = 0; | |
561 | unsigned int out_count; | |
562 | ||
563 | if (mutex_lock_interruptible(&line6->messages.read_lock)) | |
564 | return -ERESTARTSYS; | |
565 | ||
566 | while (kfifo_len(&line6->messages.fifo) == 0) { | |
567 | mutex_unlock(&line6->messages.read_lock); | |
568 | ||
569 | rv = wait_event_interruptible( | |
570 | line6->messages.wait_queue, | |
571 | kfifo_len(&line6->messages.fifo) != 0); | |
572 | if (rv < 0) | |
573 | return rv; | |
574 | ||
575 | if (mutex_lock_interruptible(&line6->messages.read_lock)) | |
576 | return -ERESTARTSYS; | |
577 | } | |
578 | ||
579 | if (kfifo_peek_len(&line6->messages.fifo) > count) { | |
580 | /* Buffer too small; allow re-read of the current item... */ | |
581 | rv = -EINVAL; | |
582 | } else { | |
583 | rv = kfifo_to_user(&line6->messages.fifo, buf, count, &out_count); | |
584 | if (rv == 0) | |
585 | rv = out_count; | |
586 | } | |
587 | ||
588 | mutex_unlock(&line6->messages.read_lock); | |
589 | return rv; | |
590 | } | |
591 | ||
592 | /* Write directly (no buffering) to device by user*/ | |
593 | static long | |
594 | line6_hwdep_write(struct snd_hwdep *hwdep, const char __user *data, long count, | |
595 | loff_t *offset) | |
596 | { | |
597 | struct usb_line6 *line6 = hwdep->private_data; | |
598 | int rv; | |
599 | char *data_copy; | |
600 | ||
601 | if (count > line6->max_packet_size * LINE6_RAW_MESSAGES_MAXCOUNT) { | |
602 | /* This is an arbitrary limit - still better than nothing... */ | |
603 | return -EINVAL; | |
604 | } | |
605 | ||
606 | data_copy = memdup_user(data, count); | |
fdd8218d DC |
607 | if (IS_ERR(data_copy)) |
608 | return PTR_ERR(data_copy); | |
a16039cb AK |
609 | |
610 | rv = line6_send_raw_message(line6, data_copy, count); | |
611 | ||
612 | kfree(data_copy); | |
613 | return rv; | |
614 | } | |
615 | ||
616 | static const struct snd_hwdep_ops hwdep_ops = { | |
617 | .open = line6_hwdep_open, | |
618 | .release = line6_hwdep_release, | |
619 | .read = line6_hwdep_read, | |
620 | .write = line6_hwdep_write, | |
621 | }; | |
622 | ||
623 | /* Insert into circular buffer */ | |
624 | static void line6_hwdep_push_message(struct usb_line6 *line6) | |
625 | { | |
626 | if (!line6->messages.active) | |
627 | return; | |
628 | ||
629 | if (kfifo_avail(&line6->messages.fifo) >= line6->message_length) { | |
630 | /* No race condition here, there's only one writer */ | |
631 | kfifo_in(&line6->messages.fifo, | |
632 | line6->buffer_message, line6->message_length); | |
633 | } /* else TODO: signal overflow */ | |
634 | ||
635 | wake_up_interruptible(&line6->messages.wait_queue); | |
636 | } | |
637 | ||
638 | static int line6_hwdep_init(struct usb_line6 *line6) | |
639 | { | |
640 | int err; | |
641 | struct snd_hwdep *hwdep; | |
642 | ||
643 | /* TODO: usb_driver_claim_interface(); */ | |
644 | line6->process_message = line6_hwdep_push_message; | |
645 | line6->messages.active = 0; | |
646 | init_waitqueue_head(&line6->messages.wait_queue); | |
647 | mutex_init(&line6->messages.read_lock); | |
648 | INIT_KFIFO(line6->messages.fifo); | |
649 | ||
650 | err = snd_hwdep_new(line6->card, "config", 0, &hwdep); | |
651 | if (err < 0) | |
652 | goto end; | |
653 | strcpy(hwdep->name, "config"); | |
654 | hwdep->iface = SNDRV_HWDEP_IFACE_LINE6; | |
655 | hwdep->ops = hwdep_ops; | |
656 | hwdep->private_data = line6; | |
657 | hwdep->exclusive = true; | |
658 | ||
659 | end: | |
660 | return err; | |
661 | } | |
662 | ||
7811a3ad | 663 | static int line6_init_cap_control(struct usb_line6 *line6) |
644d9085 TI |
664 | { |
665 | int ret; | |
666 | ||
667 | /* initialize USB buffers: */ | |
668 | line6->buffer_listen = kmalloc(LINE6_BUFSIZE_LISTEN, GFP_KERNEL); | |
669 | if (!line6->buffer_listen) | |
670 | return -ENOMEM; | |
671 | ||
644d9085 TI |
672 | line6->urb_listen = usb_alloc_urb(0, GFP_KERNEL); |
673 | if (!line6->urb_listen) | |
674 | return -ENOMEM; | |
675 | ||
7811a3ad | 676 | if (line6->properties->capabilities & LINE6_CAP_CONTROL_MIDI) { |
a16039cb | 677 | line6->buffer_message = kmalloc(LINE6_MIDI_MESSAGE_MAXLEN, GFP_KERNEL); |
7811a3ad AK |
678 | if (!line6->buffer_message) |
679 | return -ENOMEM; | |
a16039cb AK |
680 | } else { |
681 | ret = line6_hwdep_init(line6); | |
682 | if (ret < 0) | |
683 | return ret; | |
7811a3ad AK |
684 | } |
685 | ||
644d9085 TI |
686 | ret = line6_start_listen(line6); |
687 | if (ret < 0) { | |
688 | dev_err(line6->ifcdev, "cannot start listening: %d\n", ret); | |
689 | return ret; | |
690 | } | |
691 | ||
692 | return 0; | |
693 | } | |
694 | ||
705ececd MG |
695 | /* |
696 | Probe USB device. | |
697 | */ | |
ccddbe4a | 698 | int line6_probe(struct usb_interface *interface, |
f66fd990 | 699 | const struct usb_device_id *id, |
12865cac | 700 | const char *driver_name, |
ccddbe4a | 701 | const struct line6_properties *properties, |
aca514b8 TI |
702 | int (*private_init)(struct usb_line6 *, const struct usb_device_id *id), |
703 | size_t data_size) | |
705ececd | 704 | { |
35ae48a3 | 705 | struct usb_device *usbdev = interface_to_usbdev(interface); |
85a9339b | 706 | struct snd_card *card; |
aca514b8 | 707 | struct usb_line6 *line6; |
7b9584fa | 708 | int interface_number; |
705ececd MG |
709 | int ret; |
710 | ||
aca514b8 TI |
711 | if (WARN_ON(data_size < sizeof(*line6))) |
712 | return -EINVAL; | |
713 | ||
d6ca69d8 TI |
714 | /* we don't handle multiple configurations */ |
715 | if (usbdev->descriptor.bNumConfigurations != 1) | |
716 | return -ENODEV; | |
717 | ||
6b562f63 TI |
718 | ret = snd_card_new(&interface->dev, |
719 | SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1, | |
aca514b8 TI |
720 | THIS_MODULE, data_size, &card); |
721 | if (ret < 0) | |
6b562f63 | 722 | return ret; |
705ececd | 723 | |
705ececd | 724 | /* store basic data: */ |
aca514b8 | 725 | line6 = card->private_data; |
6b562f63 | 726 | line6->card = card; |
705ececd MG |
727 | line6->properties = properties; |
728 | line6->usbdev = usbdev; | |
729 | line6->ifcdev = &interface->dev; | |
705ececd | 730 | |
d6ca69d8 | 731 | strcpy(card->id, properties->id); |
12865cac | 732 | strcpy(card->driver, driver_name); |
d6ca69d8 TI |
733 | strcpy(card->shortname, properties->name); |
734 | sprintf(card->longname, "Line 6 %s at USB %s", properties->name, | |
85a9339b | 735 | dev_name(line6->ifcdev)); |
85a9339b TI |
736 | card->private_free = line6_destruct; |
737 | ||
705ececd MG |
738 | usb_set_intfdata(interface, line6); |
739 | ||
85a9339b TI |
740 | /* increment reference counters: */ |
741 | usb_get_dev(usbdev); | |
742 | ||
6b562f63 TI |
743 | /* initialize device info: */ |
744 | dev_info(&interface->dev, "Line 6 %s found\n", properties->name); | |
745 | ||
746 | /* query interface number */ | |
747 | interface_number = interface->cur_altsetting->desc.bInterfaceNumber; | |
748 | ||
79faa2b0 | 749 | /* TODO reserves the bus bandwidth even without actual transfer */ |
6b562f63 | 750 | ret = usb_set_interface(usbdev, interface_number, |
d6ca69d8 | 751 | properties->altsetting); |
6b562f63 TI |
752 | if (ret < 0) { |
753 | dev_err(&interface->dev, "set_interface failed\n"); | |
754 | goto error; | |
755 | } | |
756 | ||
7811a3ad | 757 | if (properties->capabilities & LINE6_CAP_CONTROL) { |
f6a0dd10 | 758 | line6_get_interval(line6); |
7811a3ad | 759 | ret = line6_init_cap_control(line6); |
644d9085 | 760 | if (ret < 0) |
6b562f63 | 761 | goto error; |
705ececd MG |
762 | } |
763 | ||
a23a8bff | 764 | /* initialize device data based on device: */ |
f66fd990 | 765 | ret = private_init(line6, id); |
ab366c1a | 766 | if (ret < 0) |
6b562f63 | 767 | goto error; |
705ececd | 768 | |
1027f476 MG |
769 | /* creation of additional special files should go here */ |
770 | ||
c6fffce9 | 771 | dev_info(&interface->dev, "Line 6 %s now attached\n", |
d6ca69d8 | 772 | properties->name); |
1027f476 | 773 | |
ab366c1a KV |
774 | return 0; |
775 | ||
6b562f63 | 776 | error: |
eedd0e95 | 777 | if (line6->disconnect) |
f66fd990 | 778 | line6->disconnect(line6); |
85a9339b | 779 | snd_card_free(card); |
705ececd MG |
780 | return ret; |
781 | } | |
ccddbe4a | 782 | EXPORT_SYMBOL_GPL(line6_probe); |
705ececd MG |
783 | |
784 | /* | |
c6fffce9 | 785 | Line 6 device disconnected. |
705ececd | 786 | */ |
ccddbe4a | 787 | void line6_disconnect(struct usb_interface *interface) |
705ececd | 788 | { |
270fd9c7 TI |
789 | struct usb_line6 *line6 = usb_get_intfdata(interface); |
790 | struct usb_device *usbdev = interface_to_usbdev(interface); | |
705ececd | 791 | |
85a9339b TI |
792 | if (!line6) |
793 | return; | |
705ececd | 794 | |
2a324fcd TI |
795 | if (WARN_ON(usbdev != line6->usbdev)) |
796 | return; | |
797 | ||
85a9339b TI |
798 | if (line6->urb_listen != NULL) |
799 | line6_stop_listen(line6); | |
705ececd | 800 | |
85a9339b | 801 | snd_card_disconnect(line6->card); |
5a475311 TI |
802 | if (line6->line6pcm) |
803 | line6_pcm_disconnect(line6->line6pcm); | |
85a9339b | 804 | if (line6->disconnect) |
f66fd990 | 805 | line6->disconnect(line6); |
705ececd | 806 | |
c6fffce9 | 807 | dev_info(&interface->dev, "Line 6 %s now disconnected\n", |
85a9339b | 808 | line6->properties->name); |
705ececd | 809 | |
85a9339b TI |
810 | /* make sure the device isn't destructed twice: */ |
811 | usb_set_intfdata(interface, NULL); | |
ccddbe4a | 812 | |
85a9339b | 813 | snd_card_free_when_closed(line6->card); |
1027f476 | 814 | } |
ccddbe4a | 815 | EXPORT_SYMBOL_GPL(line6_disconnect); |
1027f476 MG |
816 | |
817 | #ifdef CONFIG_PM | |
818 | ||
819 | /* | |
c6fffce9 | 820 | Suspend Line 6 device. |
1027f476 | 821 | */ |
ccddbe4a | 822 | int line6_suspend(struct usb_interface *interface, pm_message_t message) |
1027f476 MG |
823 | { |
824 | struct usb_line6 *line6 = usb_get_intfdata(interface); | |
825 | struct snd_line6_pcm *line6pcm = line6->line6pcm; | |
826 | ||
827 | snd_power_change_state(line6->card, SNDRV_CTL_POWER_D3hot); | |
828 | ||
7811a3ad | 829 | if (line6->properties->capabilities & LINE6_CAP_CONTROL) |
1027f476 MG |
830 | line6_stop_listen(line6); |
831 | ||
832 | if (line6pcm != NULL) { | |
833 | snd_pcm_suspend_all(line6pcm->pcm); | |
1027f476 MG |
834 | line6pcm->flags = 0; |
835 | } | |
836 | ||
837 | return 0; | |
838 | } | |
ccddbe4a | 839 | EXPORT_SYMBOL_GPL(line6_suspend); |
1027f476 MG |
840 | |
841 | /* | |
c6fffce9 | 842 | Resume Line 6 device. |
1027f476 | 843 | */ |
ccddbe4a | 844 | int line6_resume(struct usb_interface *interface) |
1027f476 MG |
845 | { |
846 | struct usb_line6 *line6 = usb_get_intfdata(interface); | |
847 | ||
7811a3ad | 848 | if (line6->properties->capabilities & LINE6_CAP_CONTROL) |
1027f476 MG |
849 | line6_start_listen(line6); |
850 | ||
851 | snd_power_change_state(line6->card, SNDRV_CTL_POWER_D0); | |
852 | return 0; | |
853 | } | |
ccddbe4a | 854 | EXPORT_SYMBOL_GPL(line6_resume); |
705ececd | 855 | |
e1a164d7 | 856 | #endif /* CONFIG_PM */ |
1027f476 | 857 | |
705ececd MG |
858 | MODULE_AUTHOR(DRIVER_AUTHOR); |
859 | MODULE_DESCRIPTION(DRIVER_DESC); | |
860 | MODULE_LICENSE("GPL"); | |
a16039cb | 861 |