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> | |
20 | ||
705ececd | 21 | #include "capture.h" |
1027f476 | 22 | #include "driver.h" |
705ececd MG |
23 | #include "midi.h" |
24 | #include "playback.h" | |
705ececd | 25 | |
705ececd | 26 | #define DRIVER_AUTHOR "Markus Grabner <grabner@icg.tugraz.at>" |
c6fffce9 | 27 | #define DRIVER_DESC "Line 6 USB Driver" |
705ececd | 28 | |
705ececd | 29 | /* |
c6fffce9 | 30 | This is Line 6's MIDI manufacturer ID. |
705ececd | 31 | */ |
1027f476 MG |
32 | const unsigned char line6_midi_id[] = { |
33 | 0x00, 0x01, 0x0c | |
34 | }; | |
ccddbe4a | 35 | EXPORT_SYMBOL_GPL(line6_midi_id); |
1027f476 MG |
36 | |
37 | /* | |
38 | Code to request version of POD, Variax interface | |
39 | (and maybe other devices). | |
40 | */ | |
c46b8a65 | 41 | static const char line6_request_version[] = { |
1027f476 MG |
42 | 0xf0, 0x7e, 0x7f, 0x06, 0x01, 0xf7 |
43 | }; | |
44 | ||
cddbd4f1 | 45 | /* |
705ececd MG |
46 | Class for asynchronous messages. |
47 | */ | |
36445bc1 | 48 | struct message { |
705ececd MG |
49 | struct usb_line6 *line6; |
50 | const char *buffer; | |
51 | int size; | |
52 | int done; | |
53 | }; | |
54 | ||
705ececd MG |
55 | /* |
56 | Forward declarations. | |
57 | */ | |
0c7ab158 | 58 | static void line6_data_received(struct urb *urb); |
36445bc1 GKH |
59 | static int line6_send_raw_message_async_part(struct message *msg, |
60 | struct urb *urb); | |
705ececd | 61 | |
705ececd MG |
62 | /* |
63 | Start to listen on endpoint. | |
64 | */ | |
65 | static int line6_start_listen(struct usb_line6 *line6) | |
66 | { | |
1027f476 | 67 | int err; |
a6b4699d | 68 | |
36445bc1 | 69 | usb_fill_int_urb(line6->urb_listen, line6->usbdev, |
9e165be7 CR |
70 | usb_rcvintpipe(line6->usbdev, line6->properties->ep_ctrl_r), |
71 | line6->buffer_listen, LINE6_BUFSIZE_LISTEN, | |
72 | line6_data_received, line6, line6->interval); | |
705ececd | 73 | line6->urb_listen->actual_length = 0; |
e1a164d7 | 74 | err = usb_submit_urb(line6->urb_listen, GFP_ATOMIC); |
1027f476 MG |
75 | return err; |
76 | } | |
77 | ||
78 | /* | |
79 | Stop listening on endpoint. | |
80 | */ | |
81 | static void line6_stop_listen(struct usb_line6 *line6) | |
82 | { | |
83 | usb_kill_urb(line6->urb_listen); | |
705ececd MG |
84 | } |
85 | ||
705ececd | 86 | /* |
1027f476 | 87 | Send raw message in pieces of wMaxPacketSize bytes. |
705ececd | 88 | */ |
73723190 TI |
89 | static int line6_send_raw_message(struct usb_line6 *line6, const char *buffer, |
90 | int size) | |
705ececd MG |
91 | { |
92 | int i, done = 0; | |
93 | ||
1027f476 MG |
94 | for (i = 0; i < size; i += line6->max_packet_size) { |
95 | int partial; | |
705ececd MG |
96 | const char *frag_buf = buffer + i; |
97 | int frag_size = min(line6->max_packet_size, size - i); | |
36445bc1 GKH |
98 | int retval; |
99 | ||
100 | retval = usb_interrupt_msg(line6->usbdev, | |
ba79e52b | 101 | usb_sndintpipe(line6->usbdev, |
9e165be7 | 102 | line6->properties->ep_ctrl_w), |
ba79e52b DB |
103 | (char *)frag_buf, frag_size, |
104 | &partial, LINE6_TIMEOUT * HZ); | |
705ececd | 105 | |
36445bc1 GKH |
106 | if (retval) { |
107 | dev_err(line6->ifcdev, | |
108 | "usb_interrupt_msg failed (%d)\n", retval); | |
705ececd MG |
109 | break; |
110 | } | |
111 | ||
1027f476 | 112 | done += frag_size; |
705ececd MG |
113 | } |
114 | ||
115 | return done; | |
116 | } | |
117 | ||
118 | /* | |
119 | Notification of completion of asynchronous request transmission. | |
120 | */ | |
0c7ab158 | 121 | static void line6_async_request_sent(struct urb *urb) |
705ececd MG |
122 | { |
123 | struct message *msg = (struct message *)urb->context; | |
124 | ||
36445bc1 | 125 | if (msg->done >= msg->size) { |
705ececd MG |
126 | usb_free_urb(urb); |
127 | kfree(msg); | |
36445bc1 | 128 | } else |
705ececd MG |
129 | line6_send_raw_message_async_part(msg, urb); |
130 | } | |
131 | ||
132 | /* | |
133 | Asynchronously send part of a raw message. | |
134 | */ | |
36445bc1 GKH |
135 | static int line6_send_raw_message_async_part(struct message *msg, |
136 | struct urb *urb) | |
705ececd MG |
137 | { |
138 | int retval; | |
139 | struct usb_line6 *line6 = msg->line6; | |
140 | int done = msg->done; | |
141 | int bytes = min(msg->size - done, line6->max_packet_size); | |
142 | ||
36445bc1 | 143 | usb_fill_int_urb(urb, line6->usbdev, |
9e165be7 CR |
144 | usb_sndintpipe(line6->usbdev, line6->properties->ep_ctrl_w), |
145 | (char *)msg->buffer + done, bytes, | |
146 | line6_async_request_sent, msg, line6->interval); | |
705ececd | 147 | |
705ececd MG |
148 | msg->done += bytes; |
149 | retval = usb_submit_urb(urb, GFP_ATOMIC); | |
150 | ||
36445bc1 GKH |
151 | if (retval < 0) { |
152 | dev_err(line6->ifcdev, "%s: usb_submit_urb failed (%d)\n", | |
153 | __func__, retval); | |
705ececd MG |
154 | usb_free_urb(urb); |
155 | kfree(msg); | |
056e0af2 | 156 | return retval; |
705ececd MG |
157 | } |
158 | ||
159 | return 0; | |
160 | } | |
161 | ||
1027f476 MG |
162 | /* |
163 | Setup and start timer. | |
164 | */ | |
6ccd93bd | 165 | void line6_start_timer(struct timer_list *timer, unsigned long msecs, |
1cad608e | 166 | void (*function)(unsigned long), unsigned long data) |
1027f476 MG |
167 | { |
168 | setup_timer(timer, function, data); | |
695758c6 | 169 | mod_timer(timer, jiffies + msecs_to_jiffies(msecs)); |
1027f476 | 170 | } |
ccddbe4a | 171 | EXPORT_SYMBOL_GPL(line6_start_timer); |
1027f476 | 172 | |
705ececd MG |
173 | /* |
174 | Asynchronously send raw message. | |
175 | */ | |
36445bc1 GKH |
176 | int line6_send_raw_message_async(struct usb_line6 *line6, const char *buffer, |
177 | int size) | |
705ececd MG |
178 | { |
179 | struct message *msg; | |
180 | struct urb *urb; | |
181 | ||
182 | /* create message: */ | |
183 | msg = kmalloc(sizeof(struct message), GFP_ATOMIC); | |
78110bb8 | 184 | if (msg == NULL) |
705ececd | 185 | return -ENOMEM; |
705ececd MG |
186 | |
187 | /* create URB: */ | |
188 | urb = usb_alloc_urb(0, GFP_ATOMIC); | |
189 | ||
36445bc1 | 190 | if (urb == NULL) { |
705ececd | 191 | kfree(msg); |
705ececd MG |
192 | return -ENOMEM; |
193 | } | |
194 | ||
195 | /* set message data: */ | |
196 | msg->line6 = line6; | |
197 | msg->buffer = buffer; | |
198 | msg->size = size; | |
199 | msg->done = 0; | |
200 | ||
201 | /* start sending: */ | |
202 | return line6_send_raw_message_async_part(msg, urb); | |
203 | } | |
ccddbe4a | 204 | EXPORT_SYMBOL_GPL(line6_send_raw_message_async); |
705ececd | 205 | |
1027f476 MG |
206 | /* |
207 | Send asynchronous device version request. | |
208 | */ | |
209 | int line6_version_request_async(struct usb_line6 *line6) | |
210 | { | |
c46b8a65 GKH |
211 | char *buffer; |
212 | int retval; | |
213 | ||
77ecb6fe LN |
214 | buffer = kmemdup(line6_request_version, |
215 | sizeof(line6_request_version), GFP_ATOMIC); | |
a019f5e8 | 216 | if (buffer == NULL) |
c46b8a65 | 217 | return -ENOMEM; |
c46b8a65 | 218 | |
c46b8a65 GKH |
219 | retval = line6_send_raw_message_async(line6, buffer, |
220 | sizeof(line6_request_version)); | |
221 | kfree(buffer); | |
222 | return retval; | |
1027f476 | 223 | } |
ccddbe4a | 224 | EXPORT_SYMBOL_GPL(line6_version_request_async); |
1027f476 | 225 | |
705ececd MG |
226 | /* |
227 | Send sysex message in pieces of wMaxPacketSize bytes. | |
228 | */ | |
36445bc1 GKH |
229 | int line6_send_sysex_message(struct usb_line6 *line6, const char *buffer, |
230 | int size) | |
705ececd | 231 | { |
e1a164d7 MG |
232 | return line6_send_raw_message(line6, buffer, |
233 | size + SYSEX_EXTRA_SIZE) - | |
234 | SYSEX_EXTRA_SIZE; | |
705ececd | 235 | } |
ccddbe4a | 236 | EXPORT_SYMBOL_GPL(line6_send_sysex_message); |
705ececd MG |
237 | |
238 | /* | |
239 | Allocate buffer for sysex message and prepare header. | |
240 | @param code sysex message code | |
241 | @param size number of bytes between code and sysex end | |
242 | */ | |
36445bc1 GKH |
243 | char *line6_alloc_sysex_buffer(struct usb_line6 *line6, int code1, int code2, |
244 | int size) | |
705ececd | 245 | { |
1027f476 | 246 | char *buffer = kmalloc(size + SYSEX_EXTRA_SIZE, GFP_ATOMIC); |
705ececd | 247 | |
78110bb8 | 248 | if (!buffer) |
536165d8 | 249 | return NULL; |
705ececd MG |
250 | |
251 | buffer[0] = LINE6_SYSEX_BEGIN; | |
252 | memcpy(buffer + 1, line6_midi_id, sizeof(line6_midi_id)); | |
253 | buffer[sizeof(line6_midi_id) + 1] = code1; | |
254 | buffer[sizeof(line6_midi_id) + 2] = code2; | |
255 | buffer[sizeof(line6_midi_id) + 3 + size] = LINE6_SYSEX_END; | |
256 | return buffer; | |
257 | } | |
ccddbe4a | 258 | EXPORT_SYMBOL_GPL(line6_alloc_sysex_buffer); |
705ececd MG |
259 | |
260 | /* | |
c6fffce9 | 261 | Notification of data received from the Line 6 device. |
705ececd | 262 | */ |
0c7ab158 | 263 | static void line6_data_received(struct urb *urb) |
705ececd MG |
264 | { |
265 | struct usb_line6 *line6 = (struct usb_line6 *)urb->context; | |
269edc8e | 266 | struct midi_buffer *mb = &line6->line6midi->midibuf_in; |
705ececd MG |
267 | int done; |
268 | ||
36445bc1 | 269 | if (urb->status == -ESHUTDOWN) |
705ececd MG |
270 | return; |
271 | ||
e1a164d7 MG |
272 | done = |
273 | line6_midibuf_write(mb, urb->transfer_buffer, urb->actual_length); | |
705ececd | 274 | |
36445bc1 | 275 | if (done < urb->actual_length) { |
1027f476 | 276 | line6_midibuf_ignore(mb, done); |
e00d33cb SH |
277 | dev_dbg(line6->ifcdev, "%d %d buffer overflow - message skipped\n", |
278 | done, urb->actual_length); | |
705ececd MG |
279 | } |
280 | ||
36445bc1 | 281 | for (;;) { |
e1a164d7 MG |
282 | done = |
283 | line6_midibuf_read(mb, line6->buffer_message, | |
284 | LINE6_MESSAGE_MAXLEN); | |
705ececd | 285 | |
36445bc1 | 286 | if (done == 0) |
705ececd MG |
287 | break; |
288 | ||
705ececd | 289 | line6->message_length = done; |
705ececd MG |
290 | line6_midi_receive(line6, line6->buffer_message, done); |
291 | ||
01f6b2bc CR |
292 | if (line6->process_message) |
293 | line6->process_message(line6); | |
705ececd MG |
294 | } |
295 | ||
296 | line6_start_listen(line6); | |
297 | } | |
298 | ||
e64e94df | 299 | #define LINE6_READ_WRITE_STATUS_DELAY 2 /* milliseconds */ |
f3dfd1be | 300 | #define LINE6_READ_WRITE_MAX_RETRIES 50 |
e64e94df | 301 | |
705ececd MG |
302 | /* |
303 | Read data from device. | |
304 | */ | |
25a0707c CR |
305 | int line6_read_data(struct usb_line6 *line6, unsigned address, void *data, |
306 | unsigned datalen) | |
705ececd MG |
307 | { |
308 | struct usb_device *usbdev = line6->usbdev; | |
309 | int ret; | |
310 | unsigned char len; | |
f3dfd1be | 311 | unsigned count; |
705ececd | 312 | |
25a0707c CR |
313 | if (address > 0xffff || datalen > 0xff) |
314 | return -EINVAL; | |
315 | ||
705ececd MG |
316 | /* query the serial number: */ |
317 | ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x67, | |
1027f476 MG |
318 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, |
319 | (datalen << 8) | 0x21, address, | |
320 | NULL, 0, LINE6_TIMEOUT * HZ); | |
705ececd | 321 | |
36445bc1 | 322 | if (ret < 0) { |
705ececd MG |
323 | dev_err(line6->ifcdev, "read request failed (error %d)\n", ret); |
324 | return ret; | |
325 | } | |
326 | ||
bc776f27 | 327 | /* Wait for data length. We'll get 0xff until length arrives. */ |
f3dfd1be | 328 | for (count = 0; count < LINE6_READ_WRITE_MAX_RETRIES; count++) { |
e64e94df CR |
329 | mdelay(LINE6_READ_WRITE_STATUS_DELAY); |
330 | ||
705ececd | 331 | ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67, |
36445bc1 GKH |
332 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | |
333 | USB_DIR_IN, | |
334 | 0x0012, 0x0000, &len, 1, | |
335 | LINE6_TIMEOUT * HZ); | |
336 | if (ret < 0) { | |
337 | dev_err(line6->ifcdev, | |
338 | "receive length failed (error %d)\n", ret); | |
705ececd MG |
339 | return ret; |
340 | } | |
36445bc1 | 341 | |
f3dfd1be CR |
342 | if (len != 0xff) |
343 | break; | |
344 | } | |
345 | ||
346 | if (len == 0xff) { | |
347 | dev_err(line6->ifcdev, "read failed after %d retries\n", | |
348 | count); | |
349 | return -EIO; | |
350 | } else if (len != datalen) { | |
36445bc1 GKH |
351 | /* should be equal or something went wrong */ |
352 | dev_err(line6->ifcdev, | |
353 | "length mismatch (expected %d, got %d)\n", | |
354 | (int)datalen, (int)len); | |
e474e7fd | 355 | return -EIO; |
705ececd MG |
356 | } |
357 | ||
358 | /* receive the result: */ | |
359 | ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67, | |
36445bc1 GKH |
360 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, |
361 | 0x0013, 0x0000, data, datalen, | |
362 | LINE6_TIMEOUT * HZ); | |
705ececd | 363 | |
36445bc1 | 364 | if (ret < 0) { |
705ececd MG |
365 | dev_err(line6->ifcdev, "read failed (error %d)\n", ret); |
366 | return ret; | |
367 | } | |
368 | ||
369 | return 0; | |
370 | } | |
ccddbe4a | 371 | EXPORT_SYMBOL_GPL(line6_read_data); |
705ececd MG |
372 | |
373 | /* | |
374 | Write data to device. | |
375 | */ | |
25a0707c CR |
376 | int line6_write_data(struct usb_line6 *line6, unsigned address, void *data, |
377 | unsigned datalen) | |
705ececd MG |
378 | { |
379 | struct usb_device *usbdev = line6->usbdev; | |
380 | int ret; | |
381 | unsigned char status; | |
f3dfd1be | 382 | int count; |
705ececd | 383 | |
25a0707c CR |
384 | if (address > 0xffff || datalen > 0xffff) |
385 | return -EINVAL; | |
386 | ||
36445bc1 GKH |
387 | ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x67, |
388 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, | |
389 | 0x0022, address, data, datalen, | |
390 | LINE6_TIMEOUT * HZ); | |
705ececd | 391 | |
36445bc1 GKH |
392 | if (ret < 0) { |
393 | dev_err(line6->ifcdev, | |
394 | "write request failed (error %d)\n", ret); | |
705ececd MG |
395 | return ret; |
396 | } | |
397 | ||
f3dfd1be | 398 | for (count = 0; count < LINE6_READ_WRITE_MAX_RETRIES; count++) { |
e64e94df CR |
399 | mdelay(LINE6_READ_WRITE_STATUS_DELAY); |
400 | ||
36445bc1 GKH |
401 | ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), |
402 | 0x67, | |
403 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | | |
404 | USB_DIR_IN, | |
405 | 0x0012, 0x0000, | |
406 | &status, 1, LINE6_TIMEOUT * HZ); | |
407 | ||
408 | if (ret < 0) { | |
409 | dev_err(line6->ifcdev, | |
410 | "receiving status failed (error %d)\n", ret); | |
705ececd MG |
411 | return ret; |
412 | } | |
705ececd | 413 | |
f3dfd1be CR |
414 | if (status != 0xff) |
415 | break; | |
416 | } | |
417 | ||
418 | if (status == 0xff) { | |
419 | dev_err(line6->ifcdev, "write failed after %d retries\n", | |
420 | count); | |
421 | return -EIO; | |
422 | } else if (status != 0) { | |
705ececd | 423 | dev_err(line6->ifcdev, "write failed (error %d)\n", ret); |
e474e7fd | 424 | return -EIO; |
705ececd MG |
425 | } |
426 | ||
427 | return 0; | |
428 | } | |
ccddbe4a | 429 | EXPORT_SYMBOL_GPL(line6_write_data); |
705ececd MG |
430 | |
431 | /* | |
c6fffce9 | 432 | Read Line 6 device serial number. |
705ececd MG |
433 | (POD, TonePort, GuitarPort) |
434 | */ | |
12b00157 | 435 | int line6_read_serial_number(struct usb_line6 *line6, u32 *serial_number) |
705ececd | 436 | { |
e1a164d7 MG |
437 | return line6_read_data(line6, 0x80d0, serial_number, |
438 | sizeof(*serial_number)); | |
705ececd | 439 | } |
ccddbe4a | 440 | EXPORT_SYMBOL_GPL(line6_read_serial_number); |
705ececd | 441 | |
705ececd | 442 | /* |
85a9339b | 443 | Card destructor. |
705ececd | 444 | */ |
85a9339b | 445 | static void line6_destruct(struct snd_card *card) |
705ececd | 446 | { |
85a9339b | 447 | struct usb_line6 *line6 = card->private_data; |
aca514b8 | 448 | struct usb_device *usbdev = line6->usbdev; |
705ececd MG |
449 | |
450 | /* free buffer memory first: */ | |
36445bc1 GKH |
451 | kfree(line6->buffer_message); |
452 | kfree(line6->buffer_listen); | |
705ececd MG |
453 | |
454 | /* then free URBs: */ | |
36445bc1 | 455 | usb_free_urb(line6->urb_listen); |
705ececd | 456 | |
85a9339b TI |
457 | /* decrement reference counters: */ |
458 | usb_put_dev(usbdev); | |
705ececd MG |
459 | } |
460 | ||
644d9085 TI |
461 | /* get data from endpoint descriptor (see usb_maxpacket): */ |
462 | static void line6_get_interval(struct usb_line6 *line6) | |
463 | { | |
464 | struct usb_device *usbdev = line6->usbdev; | |
465 | struct usb_host_endpoint *ep; | |
466 | unsigned pipe = usb_rcvintpipe(usbdev, line6->properties->ep_ctrl_r); | |
467 | unsigned epnum = usb_pipeendpoint(pipe); | |
468 | ||
469 | ep = usbdev->ep_in[epnum]; | |
470 | if (ep) { | |
471 | line6->interval = ep->desc.bInterval; | |
472 | line6->max_packet_size = le16_to_cpu(ep->desc.wMaxPacketSize); | |
473 | } else { | |
474 | dev_err(line6->ifcdev, | |
475 | "endpoint not available, using fallback values"); | |
476 | line6->interval = LINE6_FALLBACK_INTERVAL; | |
477 | line6->max_packet_size = LINE6_FALLBACK_MAXPACKETSIZE; | |
478 | } | |
479 | } | |
480 | ||
481 | static int line6_init_cap_control(struct usb_line6 *line6) | |
482 | { | |
483 | int ret; | |
484 | ||
485 | /* initialize USB buffers: */ | |
486 | line6->buffer_listen = kmalloc(LINE6_BUFSIZE_LISTEN, GFP_KERNEL); | |
487 | if (!line6->buffer_listen) | |
488 | return -ENOMEM; | |
489 | ||
490 | line6->buffer_message = kmalloc(LINE6_MESSAGE_MAXLEN, GFP_KERNEL); | |
491 | if (!line6->buffer_message) | |
492 | return -ENOMEM; | |
493 | ||
494 | line6->urb_listen = usb_alloc_urb(0, GFP_KERNEL); | |
495 | if (!line6->urb_listen) | |
496 | return -ENOMEM; | |
497 | ||
498 | ret = line6_start_listen(line6); | |
499 | if (ret < 0) { | |
500 | dev_err(line6->ifcdev, "cannot start listening: %d\n", ret); | |
501 | return ret; | |
502 | } | |
503 | ||
504 | return 0; | |
505 | } | |
506 | ||
705ececd MG |
507 | /* |
508 | Probe USB device. | |
509 | */ | |
ccddbe4a | 510 | int line6_probe(struct usb_interface *interface, |
f66fd990 | 511 | const struct usb_device_id *id, |
12865cac | 512 | const char *driver_name, |
ccddbe4a | 513 | const struct line6_properties *properties, |
aca514b8 TI |
514 | int (*private_init)(struct usb_line6 *, const struct usb_device_id *id), |
515 | size_t data_size) | |
705ececd | 516 | { |
35ae48a3 | 517 | struct usb_device *usbdev = interface_to_usbdev(interface); |
85a9339b | 518 | struct snd_card *card; |
aca514b8 | 519 | struct usb_line6 *line6; |
7b9584fa | 520 | int interface_number; |
705ececd MG |
521 | int ret; |
522 | ||
aca514b8 TI |
523 | if (WARN_ON(data_size < sizeof(*line6))) |
524 | return -EINVAL; | |
525 | ||
d6ca69d8 TI |
526 | /* we don't handle multiple configurations */ |
527 | if (usbdev->descriptor.bNumConfigurations != 1) | |
528 | return -ENODEV; | |
529 | ||
6b562f63 TI |
530 | ret = snd_card_new(&interface->dev, |
531 | SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1, | |
aca514b8 TI |
532 | THIS_MODULE, data_size, &card); |
533 | if (ret < 0) | |
6b562f63 | 534 | return ret; |
705ececd | 535 | |
705ececd | 536 | /* store basic data: */ |
aca514b8 | 537 | line6 = card->private_data; |
6b562f63 | 538 | line6->card = card; |
705ececd MG |
539 | line6->properties = properties; |
540 | line6->usbdev = usbdev; | |
541 | line6->ifcdev = &interface->dev; | |
705ececd | 542 | |
d6ca69d8 | 543 | strcpy(card->id, properties->id); |
12865cac | 544 | strcpy(card->driver, driver_name); |
d6ca69d8 TI |
545 | strcpy(card->shortname, properties->name); |
546 | sprintf(card->longname, "Line 6 %s at USB %s", properties->name, | |
85a9339b | 547 | dev_name(line6->ifcdev)); |
85a9339b TI |
548 | card->private_free = line6_destruct; |
549 | ||
705ececd MG |
550 | usb_set_intfdata(interface, line6); |
551 | ||
85a9339b TI |
552 | /* increment reference counters: */ |
553 | usb_get_dev(usbdev); | |
554 | ||
6b562f63 TI |
555 | /* initialize device info: */ |
556 | dev_info(&interface->dev, "Line 6 %s found\n", properties->name); | |
557 | ||
558 | /* query interface number */ | |
559 | interface_number = interface->cur_altsetting->desc.bInterfaceNumber; | |
560 | ||
561 | ret = usb_set_interface(usbdev, interface_number, | |
d6ca69d8 | 562 | properties->altsetting); |
6b562f63 TI |
563 | if (ret < 0) { |
564 | dev_err(&interface->dev, "set_interface failed\n"); | |
565 | goto error; | |
566 | } | |
567 | ||
568 | line6_get_interval(line6); | |
569 | ||
4cb1a4ae | 570 | if (properties->capabilities & LINE6_CAP_CONTROL) { |
644d9085 TI |
571 | ret = line6_init_cap_control(line6); |
572 | if (ret < 0) | |
6b562f63 | 573 | goto error; |
705ececd MG |
574 | } |
575 | ||
a23a8bff | 576 | /* initialize device data based on device: */ |
f66fd990 | 577 | ret = private_init(line6, id); |
ab366c1a | 578 | if (ret < 0) |
6b562f63 | 579 | goto error; |
705ececd | 580 | |
1027f476 MG |
581 | /* creation of additional special files should go here */ |
582 | ||
c6fffce9 | 583 | dev_info(&interface->dev, "Line 6 %s now attached\n", |
d6ca69d8 | 584 | properties->name); |
1027f476 | 585 | |
ab366c1a KV |
586 | return 0; |
587 | ||
6b562f63 | 588 | error: |
eedd0e95 | 589 | if (line6->disconnect) |
f66fd990 | 590 | line6->disconnect(line6); |
85a9339b | 591 | snd_card_free(card); |
705ececd MG |
592 | return ret; |
593 | } | |
ccddbe4a | 594 | EXPORT_SYMBOL_GPL(line6_probe); |
705ececd MG |
595 | |
596 | /* | |
c6fffce9 | 597 | Line 6 device disconnected. |
705ececd | 598 | */ |
ccddbe4a | 599 | void line6_disconnect(struct usb_interface *interface) |
705ececd | 600 | { |
270fd9c7 TI |
601 | struct usb_line6 *line6 = usb_get_intfdata(interface); |
602 | struct usb_device *usbdev = interface_to_usbdev(interface); | |
705ececd | 603 | |
85a9339b TI |
604 | if (!line6) |
605 | return; | |
705ececd | 606 | |
2a324fcd TI |
607 | if (WARN_ON(usbdev != line6->usbdev)) |
608 | return; | |
609 | ||
85a9339b TI |
610 | if (line6->urb_listen != NULL) |
611 | line6_stop_listen(line6); | |
705ececd | 612 | |
85a9339b | 613 | snd_card_disconnect(line6->card); |
5a475311 TI |
614 | if (line6->line6pcm) |
615 | line6_pcm_disconnect(line6->line6pcm); | |
85a9339b | 616 | if (line6->disconnect) |
f66fd990 | 617 | line6->disconnect(line6); |
705ececd | 618 | |
c6fffce9 | 619 | dev_info(&interface->dev, "Line 6 %s now disconnected\n", |
85a9339b | 620 | line6->properties->name); |
705ececd | 621 | |
85a9339b TI |
622 | /* make sure the device isn't destructed twice: */ |
623 | usb_set_intfdata(interface, NULL); | |
ccddbe4a | 624 | |
85a9339b | 625 | snd_card_free_when_closed(line6->card); |
1027f476 | 626 | } |
ccddbe4a | 627 | EXPORT_SYMBOL_GPL(line6_disconnect); |
1027f476 MG |
628 | |
629 | #ifdef CONFIG_PM | |
630 | ||
631 | /* | |
c6fffce9 | 632 | Suspend Line 6 device. |
1027f476 | 633 | */ |
ccddbe4a | 634 | int line6_suspend(struct usb_interface *interface, pm_message_t message) |
1027f476 MG |
635 | { |
636 | struct usb_line6 *line6 = usb_get_intfdata(interface); | |
637 | struct snd_line6_pcm *line6pcm = line6->line6pcm; | |
638 | ||
639 | snd_power_change_state(line6->card, SNDRV_CTL_POWER_D3hot); | |
640 | ||
4cb1a4ae | 641 | if (line6->properties->capabilities & LINE6_CAP_CONTROL) |
1027f476 MG |
642 | line6_stop_listen(line6); |
643 | ||
644 | if (line6pcm != NULL) { | |
645 | snd_pcm_suspend_all(line6pcm->pcm); | |
1027f476 MG |
646 | line6pcm->flags = 0; |
647 | } | |
648 | ||
649 | return 0; | |
650 | } | |
ccddbe4a | 651 | EXPORT_SYMBOL_GPL(line6_suspend); |
1027f476 MG |
652 | |
653 | /* | |
c6fffce9 | 654 | Resume Line 6 device. |
1027f476 | 655 | */ |
ccddbe4a | 656 | int line6_resume(struct usb_interface *interface) |
1027f476 MG |
657 | { |
658 | struct usb_line6 *line6 = usb_get_intfdata(interface); | |
659 | ||
4cb1a4ae | 660 | if (line6->properties->capabilities & LINE6_CAP_CONTROL) |
1027f476 MG |
661 | line6_start_listen(line6); |
662 | ||
663 | snd_power_change_state(line6->card, SNDRV_CTL_POWER_D0); | |
664 | return 0; | |
665 | } | |
ccddbe4a | 666 | EXPORT_SYMBOL_GPL(line6_resume); |
705ececd | 667 | |
e1a164d7 | 668 | #endif /* CONFIG_PM */ |
1027f476 | 669 | |
705ececd MG |
670 | MODULE_AUTHOR(DRIVER_AUTHOR); |
671 | MODULE_DESCRIPTION(DRIVER_DESC); | |
672 | MODULE_LICENSE("GPL"); |