]>
Commit | Line | Data |
---|---|---|
16dc1040 | 1 | /* |
c6fffce9 | 2 | * Line 6 Pod HD |
16dc1040 SH |
3 | * |
4 | * Copyright (C) 2011 Stefan Hajnoczi <stefanha@gmail.com> | |
790869da | 5 | * Copyright (C) 2015 Andrej Krutak <dev@andree.sk> |
c1d25075 | 6 | * Copyright (C) 2017 Hans P. Moller <hmoller@uc.cl> |
16dc1040 SH |
7 | * |
8 | * This program is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU General Public License as | |
10 | * published by the Free Software Foundation, version 2. | |
11 | * | |
12 | */ | |
13 | ||
ccddbe4a TI |
14 | #include <linux/usb.h> |
15 | #include <linux/slab.h> | |
16 | #include <linux/module.h> | |
16dc1040 SH |
17 | #include <sound/core.h> |
18 | #include <sound/pcm.h> | |
19 | ||
16dc1040 SH |
20 | #include "driver.h" |
21 | #include "pcm.h" | |
ccddbe4a | 22 | |
790869da AK |
23 | #define PODHD_STARTUP_DELAY 500 |
24 | ||
25 | /* | |
26 | * Stages of POD startup procedure | |
27 | */ | |
28 | enum { | |
29 | PODHD_STARTUP_INIT = 1, | |
30 | PODHD_STARTUP_SCHEDULE_WORKQUEUE, | |
31 | PODHD_STARTUP_SETUP, | |
32 | PODHD_STARTUP_LAST = PODHD_STARTUP_SETUP - 1 | |
33 | }; | |
34 | ||
ccddbe4a TI |
35 | enum { |
36 | LINE6_PODHD300, | |
37 | LINE6_PODHD400, | |
38 | LINE6_PODHD500_0, | |
39 | LINE6_PODHD500_1, | |
790869da | 40 | LINE6_PODX3, |
c1d25075 HME |
41 | LINE6_PODX3LIVE, |
42 | LINE6_PODHD500X | |
790869da AK |
43 | }; |
44 | ||
45 | struct usb_line6_podhd { | |
46 | /* Generic Line 6 USB data */ | |
47 | struct usb_line6 line6; | |
48 | ||
49 | /* Timer for device initialization */ | |
50 | struct timer_list startup_timer; | |
51 | ||
52 | /* Work handler for device initialization */ | |
53 | struct work_struct startup_work; | |
54 | ||
55 | /* Current progress in startup procedure */ | |
56 | int startup_progress; | |
57 | ||
58 | /* Serial number of device */ | |
59 | u32 serial_number; | |
60 | ||
61 | /* Firmware version */ | |
62 | int firmware_version; | |
ccddbe4a TI |
63 | }; |
64 | ||
16dc1040 SH |
65 | static struct snd_ratden podhd_ratden = { |
66 | .num_min = 48000, | |
67 | .num_max = 48000, | |
68 | .num_step = 1, | |
69 | .den = 1, | |
70 | }; | |
71 | ||
72 | static struct line6_pcm_properties podhd_pcm_properties = { | |
1263f611 | 73 | .playback_hw = { |
16dc1040 SH |
74 | .info = (SNDRV_PCM_INFO_MMAP | |
75 | SNDRV_PCM_INFO_INTERLEAVED | | |
76 | SNDRV_PCM_INFO_BLOCK_TRANSFER | | |
77 | SNDRV_PCM_INFO_MMAP_VALID | | |
78 | SNDRV_PCM_INFO_PAUSE | | |
16dc1040 SH |
79 | SNDRV_PCM_INFO_SYNC_START), |
80 | .formats = SNDRV_PCM_FMTBIT_S24_3LE, | |
81 | .rates = SNDRV_PCM_RATE_48000, | |
82 | .rate_min = 48000, | |
83 | .rate_max = 48000, | |
84 | .channels_min = 2, | |
85 | .channels_max = 2, | |
86 | .buffer_bytes_max = 60000, | |
87 | .period_bytes_min = 64, | |
88 | .period_bytes_max = 8192, | |
89 | .periods_min = 1, | |
90 | .periods_max = 1024}, | |
1263f611 | 91 | .capture_hw = { |
16dc1040 SH |
92 | .info = (SNDRV_PCM_INFO_MMAP | |
93 | SNDRV_PCM_INFO_INTERLEAVED | | |
94 | SNDRV_PCM_INFO_BLOCK_TRANSFER | | |
95 | SNDRV_PCM_INFO_MMAP_VALID | | |
16dc1040 SH |
96 | SNDRV_PCM_INFO_SYNC_START), |
97 | .formats = SNDRV_PCM_FMTBIT_S24_3LE, | |
98 | .rates = SNDRV_PCM_RATE_48000, | |
99 | .rate_min = 48000, | |
100 | .rate_max = 48000, | |
101 | .channels_min = 2, | |
102 | .channels_max = 2, | |
103 | .buffer_bytes_max = 60000, | |
104 | .period_bytes_min = 64, | |
105 | .period_bytes_max = 8192, | |
106 | .periods_min = 1, | |
107 | .periods_max = 1024}, | |
1263f611 | 108 | .rates = { |
16dc1040 SH |
109 | .nrats = 1, |
110 | .rats = &podhd_ratden}, | |
790869da | 111 | .bytes_per_channel = 3 /* SNDRV_PCM_FMTBIT_S24_3LE */ |
16dc1040 SH |
112 | }; |
113 | ||
790869da AK |
114 | static struct line6_pcm_properties podx3_pcm_properties = { |
115 | .playback_hw = { | |
116 | .info = (SNDRV_PCM_INFO_MMAP | | |
117 | SNDRV_PCM_INFO_INTERLEAVED | | |
118 | SNDRV_PCM_INFO_BLOCK_TRANSFER | | |
119 | SNDRV_PCM_INFO_MMAP_VALID | | |
120 | SNDRV_PCM_INFO_PAUSE | | |
121 | SNDRV_PCM_INFO_SYNC_START), | |
122 | .formats = SNDRV_PCM_FMTBIT_S24_3LE, | |
123 | .rates = SNDRV_PCM_RATE_48000, | |
124 | .rate_min = 48000, | |
125 | .rate_max = 48000, | |
126 | .channels_min = 2, | |
127 | .channels_max = 2, | |
128 | .buffer_bytes_max = 60000, | |
129 | .period_bytes_min = 64, | |
130 | .period_bytes_max = 8192, | |
131 | .periods_min = 1, | |
132 | .periods_max = 1024}, | |
133 | .capture_hw = { | |
134 | .info = (SNDRV_PCM_INFO_MMAP | | |
135 | SNDRV_PCM_INFO_INTERLEAVED | | |
136 | SNDRV_PCM_INFO_BLOCK_TRANSFER | | |
137 | SNDRV_PCM_INFO_MMAP_VALID | | |
138 | SNDRV_PCM_INFO_SYNC_START), | |
139 | .formats = SNDRV_PCM_FMTBIT_S24_3LE, | |
140 | .rates = SNDRV_PCM_RATE_48000, | |
141 | .rate_min = 48000, | |
142 | .rate_max = 48000, | |
143 | /* 1+2: Main signal (out), 3+4: Tone 1, | |
144 | * 5+6: Tone 2, 7+8: raw | |
145 | */ | |
146 | .channels_min = 8, | |
147 | .channels_max = 8, | |
148 | .buffer_bytes_max = 60000, | |
149 | .period_bytes_min = 64, | |
150 | .period_bytes_max = 8192, | |
151 | .periods_min = 1, | |
152 | .periods_max = 1024}, | |
153 | .rates = { | |
154 | .nrats = 1, | |
155 | .rats = &podhd_ratden}, | |
156 | .bytes_per_channel = 3 /* SNDRV_PCM_FMTBIT_S24_3LE */ | |
157 | }; | |
fc90172b | 158 | static struct usb_driver podhd_driver; |
790869da AK |
159 | |
160 | static void podhd_startup_start_workqueue(unsigned long data); | |
161 | static void podhd_startup_workqueue(struct work_struct *work); | |
162 | static int podhd_startup_finalize(struct usb_line6_podhd *pod); | |
163 | ||
164 | static ssize_t serial_number_show(struct device *dev, | |
165 | struct device_attribute *attr, char *buf) | |
166 | { | |
167 | struct snd_card *card = dev_to_snd_card(dev); | |
168 | struct usb_line6_podhd *pod = card->private_data; | |
169 | ||
170 | return sprintf(buf, "%u\n", pod->serial_number); | |
171 | } | |
172 | ||
173 | static ssize_t firmware_version_show(struct device *dev, | |
174 | struct device_attribute *attr, char *buf) | |
175 | { | |
176 | struct snd_card *card = dev_to_snd_card(dev); | |
177 | struct usb_line6_podhd *pod = card->private_data; | |
178 | ||
179 | return sprintf(buf, "%06x\n", pod->firmware_version); | |
180 | } | |
181 | ||
182 | static DEVICE_ATTR_RO(firmware_version); | |
183 | static DEVICE_ATTR_RO(serial_number); | |
184 | ||
185 | static struct attribute *podhd_dev_attrs[] = { | |
186 | &dev_attr_firmware_version.attr, | |
187 | &dev_attr_serial_number.attr, | |
188 | NULL | |
189 | }; | |
190 | ||
191 | static const struct attribute_group podhd_dev_attr_group = { | |
192 | .name = "podhd", | |
193 | .attrs = podhd_dev_attrs, | |
194 | }; | |
195 | ||
196 | /* | |
197 | * POD X3 startup procedure. | |
198 | * | |
199 | * May be compatible with other POD HD's, since it's also similar to the | |
200 | * previous POD setup. In any case, it doesn't seem to be required for the | |
201 | * audio nor bulk interfaces to work. | |
202 | */ | |
203 | ||
204 | static void podhd_startup(struct usb_line6_podhd *pod) | |
205 | { | |
206 | CHECK_STARTUP_PROGRESS(pod->startup_progress, PODHD_STARTUP_INIT); | |
207 | ||
208 | /* delay startup procedure: */ | |
209 | line6_start_timer(&pod->startup_timer, PODHD_STARTUP_DELAY, | |
210 | podhd_startup_start_workqueue, (unsigned long)pod); | |
211 | } | |
212 | ||
213 | static void podhd_startup_start_workqueue(unsigned long data) | |
214 | { | |
215 | struct usb_line6_podhd *pod = (struct usb_line6_podhd *)data; | |
216 | ||
217 | CHECK_STARTUP_PROGRESS(pod->startup_progress, | |
218 | PODHD_STARTUP_SCHEDULE_WORKQUEUE); | |
219 | ||
220 | /* schedule work for global work queue: */ | |
221 | schedule_work(&pod->startup_work); | |
222 | } | |
223 | ||
224 | static int podhd_dev_start(struct usb_line6_podhd *pod) | |
225 | { | |
226 | int ret; | |
227 | u8 init_bytes[8]; | |
228 | int i; | |
229 | struct usb_device *usbdev = pod->line6.usbdev; | |
230 | ||
231 | ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), | |
232 | 0x67, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, | |
233 | 0x11, 0, | |
234 | NULL, 0, LINE6_TIMEOUT * HZ); | |
235 | if (ret < 0) { | |
236 | dev_err(pod->line6.ifcdev, "read request failed (error %d)\n", ret); | |
237 | return ret; | |
238 | } | |
239 | ||
240 | /* NOTE: looks like some kind of ping message */ | |
241 | ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67, | |
242 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, | |
243 | 0x11, 0x0, | |
244 | &init_bytes, 3, LINE6_TIMEOUT * HZ); | |
245 | if (ret < 0) { | |
246 | dev_err(pod->line6.ifcdev, | |
247 | "receive length failed (error %d)\n", ret); | |
248 | return ret; | |
249 | } | |
250 | ||
251 | pod->firmware_version = | |
252 | (init_bytes[0] << 16) | (init_bytes[1] << 8) | (init_bytes[2] << 0); | |
253 | ||
254 | for (i = 0; i <= 16; i++) { | |
255 | ret = line6_read_data(&pod->line6, 0xf000 + 0x08 * i, init_bytes, 8); | |
256 | if (ret < 0) | |
257 | return ret; | |
258 | } | |
259 | ||
260 | ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), | |
261 | USB_REQ_SET_FEATURE, | |
262 | USB_TYPE_STANDARD | USB_RECIP_DEVICE | USB_DIR_OUT, | |
263 | 1, 0, | |
264 | NULL, 0, LINE6_TIMEOUT * HZ); | |
265 | if (ret < 0) | |
266 | return ret; | |
267 | ||
268 | return 0; | |
269 | } | |
270 | ||
271 | static void podhd_startup_workqueue(struct work_struct *work) | |
272 | { | |
273 | struct usb_line6_podhd *pod = | |
274 | container_of(work, struct usb_line6_podhd, startup_work); | |
275 | ||
276 | CHECK_STARTUP_PROGRESS(pod->startup_progress, PODHD_STARTUP_SETUP); | |
277 | ||
278 | podhd_dev_start(pod); | |
279 | line6_read_serial_number(&pod->line6, &pod->serial_number); | |
280 | ||
281 | podhd_startup_finalize(pod); | |
282 | } | |
283 | ||
284 | static int podhd_startup_finalize(struct usb_line6_podhd *pod) | |
285 | { | |
286 | struct usb_line6 *line6 = &pod->line6; | |
287 | ||
288 | /* ALSA audio interface: */ | |
289 | return snd_card_register(line6->card); | |
290 | } | |
291 | ||
292 | static void podhd_disconnect(struct usb_line6 *line6) | |
293 | { | |
294 | struct usb_line6_podhd *pod = (struct usb_line6_podhd *)line6; | |
295 | ||
8cad7a3d | 296 | if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL_INFO) { |
fc90172b AK |
297 | struct usb_interface *intf; |
298 | ||
790869da AK |
299 | del_timer_sync(&pod->startup_timer); |
300 | cancel_work_sync(&pod->startup_work); | |
fc90172b AK |
301 | |
302 | intf = usb_ifnum_to_if(line6->usbdev, | |
303 | pod->line6.properties->ctrl_if); | |
304 | usb_driver_release_interface(&podhd_driver, intf); | |
790869da AK |
305 | } |
306 | } | |
307 | ||
16dc1040 SH |
308 | /* |
309 | Try to init POD HD device. | |
310 | */ | |
f66fd990 TI |
311 | static int podhd_init(struct usb_line6 *line6, |
312 | const struct usb_device_id *id) | |
16dc1040 SH |
313 | { |
314 | int err; | |
790869da | 315 | struct usb_line6_podhd *pod = (struct usb_line6_podhd *) line6; |
fc90172b | 316 | struct usb_interface *intf; |
790869da AK |
317 | |
318 | line6->disconnect = podhd_disconnect; | |
319 | ||
320 | if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL) { | |
fc90172b AK |
321 | /* claim the data interface */ |
322 | intf = usb_ifnum_to_if(line6->usbdev, | |
323 | pod->line6.properties->ctrl_if); | |
324 | if (!intf) { | |
325 | dev_err(pod->line6.ifcdev, "interface %d not found\n", | |
326 | pod->line6.properties->ctrl_if); | |
327 | return -ENODEV; | |
328 | } | |
329 | ||
330 | err = usb_driver_claim_interface(&podhd_driver, intf, NULL); | |
331 | if (err != 0) { | |
332 | dev_err(pod->line6.ifcdev, "can't claim interface %d, error %d\n", | |
333 | pod->line6.properties->ctrl_if, err); | |
334 | return err; | |
335 | } | |
8cad7a3d | 336 | } |
fc90172b | 337 | |
8cad7a3d | 338 | if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL_INFO) { |
790869da AK |
339 | /* create sysfs entries: */ |
340 | err = snd_card_add_dev_attr(line6->card, &podhd_dev_attr_group); | |
341 | if (err < 0) | |
342 | return err; | |
343 | } | |
16dc1040 | 344 | |
cfa76969 AK |
345 | if (pod->line6.properties->capabilities & LINE6_CAP_PCM) { |
346 | /* initialize PCM subsystem: */ | |
347 | err = line6_init_pcm(line6, | |
b907900e AK |
348 | (id->driver_info == LINE6_PODX3 || |
349 | id->driver_info == LINE6_PODX3LIVE) ? &podx3_pcm_properties : | |
cfa76969 AK |
350 | &podhd_pcm_properties); |
351 | if (err < 0) | |
352 | return err; | |
353 | } | |
16dc1040 | 354 | |
8cad7a3d | 355 | if (!(pod->line6.properties->capabilities & LINE6_CAP_CONTROL_INFO)) { |
790869da AK |
356 | /* register USB audio system directly */ |
357 | return podhd_startup_finalize(pod); | |
358 | } | |
359 | ||
360 | /* init device and delay registering */ | |
361 | init_timer(&pod->startup_timer); | |
362 | INIT_WORK(&pod->startup_work, podhd_startup_workqueue); | |
363 | podhd_startup(pod); | |
364 | return 0; | |
16dc1040 SH |
365 | } |
366 | ||
ccddbe4a TI |
367 | #define LINE6_DEVICE(prod) USB_DEVICE(0x0e41, prod) |
368 | #define LINE6_IF_NUM(prod, n) USB_DEVICE_INTERFACE_NUMBER(0x0e41, prod, n) | |
369 | ||
370 | /* table of devices that work with this driver */ | |
371 | static const struct usb_device_id podhd_id_table[] = { | |
790869da | 372 | /* TODO: no need to alloc data interfaces when only audio is used */ |
ccddbe4a TI |
373 | { LINE6_DEVICE(0x5057), .driver_info = LINE6_PODHD300 }, |
374 | { LINE6_DEVICE(0x5058), .driver_info = LINE6_PODHD400 }, | |
375 | { LINE6_IF_NUM(0x414D, 0), .driver_info = LINE6_PODHD500_0 }, | |
376 | { LINE6_IF_NUM(0x414D, 1), .driver_info = LINE6_PODHD500_1 }, | |
790869da | 377 | { LINE6_IF_NUM(0x414A, 0), .driver_info = LINE6_PODX3 }, |
c039aaa7 | 378 | { LINE6_IF_NUM(0x414B, 0), .driver_info = LINE6_PODX3LIVE }, |
c1d25075 | 379 | { LINE6_IF_NUM(0x4159, 0), .driver_info = LINE6_PODHD500X }, |
ccddbe4a TI |
380 | {} |
381 | }; | |
382 | ||
383 | MODULE_DEVICE_TABLE(usb, podhd_id_table); | |
384 | ||
385 | static const struct line6_properties podhd_properties_table[] = { | |
386 | [LINE6_PODHD300] = { | |
387 | .id = "PODHD300", | |
388 | .name = "POD HD300", | |
790869da | 389 | .capabilities = LINE6_CAP_PCM |
ccddbe4a TI |
390 | | LINE6_CAP_HWMON, |
391 | .altsetting = 5, | |
392 | .ep_ctrl_r = 0x84, | |
393 | .ep_ctrl_w = 0x03, | |
394 | .ep_audio_r = 0x82, | |
395 | .ep_audio_w = 0x01, | |
396 | }, | |
397 | [LINE6_PODHD400] = { | |
398 | .id = "PODHD400", | |
399 | .name = "POD HD400", | |
790869da | 400 | .capabilities = LINE6_CAP_PCM |
ccddbe4a TI |
401 | | LINE6_CAP_HWMON, |
402 | .altsetting = 5, | |
403 | .ep_ctrl_r = 0x84, | |
404 | .ep_ctrl_w = 0x03, | |
405 | .ep_audio_r = 0x82, | |
406 | .ep_audio_w = 0x01, | |
407 | }, | |
408 | [LINE6_PODHD500_0] = { | |
409 | .id = "PODHD500", | |
410 | .name = "POD HD500", | |
790869da | 411 | .capabilities = LINE6_CAP_PCM |
ccddbe4a TI |
412 | | LINE6_CAP_HWMON, |
413 | .altsetting = 1, | |
414 | .ep_ctrl_r = 0x81, | |
415 | .ep_ctrl_w = 0x01, | |
416 | .ep_audio_r = 0x86, | |
417 | .ep_audio_w = 0x02, | |
418 | }, | |
419 | [LINE6_PODHD500_1] = { | |
420 | .id = "PODHD500", | |
421 | .name = "POD HD500", | |
790869da | 422 | .capabilities = LINE6_CAP_PCM |
ccddbe4a TI |
423 | | LINE6_CAP_HWMON, |
424 | .altsetting = 1, | |
425 | .ep_ctrl_r = 0x81, | |
426 | .ep_ctrl_w = 0x01, | |
427 | .ep_audio_r = 0x86, | |
428 | .ep_audio_w = 0x02, | |
429 | }, | |
790869da AK |
430 | [LINE6_PODX3] = { |
431 | .id = "PODX3", | |
432 | .name = "POD X3", | |
8cad7a3d | 433 | .capabilities = LINE6_CAP_CONTROL | LINE6_CAP_CONTROL_INFO |
790869da AK |
434 | | LINE6_CAP_PCM | LINE6_CAP_HWMON | LINE6_CAP_IN_NEEDS_OUT, |
435 | .altsetting = 1, | |
436 | .ep_ctrl_r = 0x81, | |
437 | .ep_ctrl_w = 0x01, | |
fc90172b | 438 | .ctrl_if = 1, |
790869da AK |
439 | .ep_audio_r = 0x86, |
440 | .ep_audio_w = 0x02, | |
441 | }, | |
c039aaa7 AK |
442 | [LINE6_PODX3LIVE] = { |
443 | .id = "PODX3LIVE", | |
444 | .name = "POD X3 LIVE", | |
8cad7a3d | 445 | .capabilities = LINE6_CAP_CONTROL | LINE6_CAP_CONTROL_INFO |
c039aaa7 AK |
446 | | LINE6_CAP_PCM | LINE6_CAP_HWMON | LINE6_CAP_IN_NEEDS_OUT, |
447 | .altsetting = 1, | |
448 | .ep_ctrl_r = 0x81, | |
449 | .ep_ctrl_w = 0x01, | |
fc90172b | 450 | .ctrl_if = 1, |
c039aaa7 AK |
451 | .ep_audio_r = 0x86, |
452 | .ep_audio_w = 0x02, | |
453 | }, | |
c1d25075 HME |
454 | [LINE6_PODHD500X] = { |
455 | .id = "PODHD500X", | |
456 | .name = "POD HD500X", | |
457 | .capabilities = LINE6_CAP_CONTROL | |
458 | | LINE6_CAP_PCM | LINE6_CAP_HWMON, | |
459 | .altsetting = 1, | |
460 | .ep_ctrl_r = 0x81, | |
461 | .ep_ctrl_w = 0x01, | |
462 | .ctrl_if = 1, | |
463 | .ep_audio_r = 0x86, | |
464 | .ep_audio_w = 0x02, | |
465 | }, | |
ccddbe4a TI |
466 | }; |
467 | ||
ccddbe4a TI |
468 | /* |
469 | Probe USB device. | |
470 | */ | |
471 | static int podhd_probe(struct usb_interface *interface, | |
472 | const struct usb_device_id *id) | |
473 | { | |
12865cac | 474 | return line6_probe(interface, id, "Line6-PODHD", |
85a9339b | 475 | &podhd_properties_table[id->driver_info], |
790869da | 476 | podhd_init, sizeof(struct usb_line6_podhd)); |
ccddbe4a TI |
477 | } |
478 | ||
479 | static struct usb_driver podhd_driver = { | |
480 | .name = KBUILD_MODNAME, | |
481 | .probe = podhd_probe, | |
482 | .disconnect = line6_disconnect, | |
483 | #ifdef CONFIG_PM | |
484 | .suspend = line6_suspend, | |
485 | .resume = line6_resume, | |
486 | .reset_resume = line6_resume, | |
487 | #endif | |
488 | .id_table = podhd_id_table, | |
489 | }; | |
490 | ||
491 | module_usb_driver(podhd_driver); | |
492 | ||
c6fffce9 | 493 | MODULE_DESCRIPTION("Line 6 PODHD USB driver"); |
ccddbe4a | 494 | MODULE_LICENSE("GPL"); |