1 /*
2 * Line 6 Pod HD
3 *
4 * Copyright (C) 2011 Stefan Hajnoczi <stefanha@gmail.com>
5 * Copyright (C) 2015 Andrej Krutak <dev@andree.sk>
6 * Copyright (C) 2017 Hans P. Moller <hmoller@uc.cl>
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
14 #include <linux/usb.h>
15 #include <linux/slab.h>
16 #include <linux/module.h>
17 #include <sound/core.h>
18 #include <sound/pcm.h>
19
20 #include "driver.h"
21 #include "pcm.h"
22
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
35 enum {
36 LINE6_PODHD300,
37 LINE6_PODHD400,
38 LINE6_PODHD500_0,
39 LINE6_PODHD500_1,
40 LINE6_PODX3,
41 LINE6_PODX3LIVE,
42 LINE6_PODHD500X
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;
63 };
64
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 = {
73 .playback_hw = {
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 |
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},
91 .capture_hw = {
92 .info = (SNDRV_PCM_INFO_MMAP |
93 SNDRV_PCM_INFO_INTERLEAVED |
94 SNDRV_PCM_INFO_BLOCK_TRANSFER |
95 SNDRV_PCM_INFO_MMAP_VALID |
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},
108 .rates = {
109 .nrats = 1,
110 .rats = &podhd_ratden},
111 .bytes_per_channel = 3 /* SNDRV_PCM_FMTBIT_S24_3LE */
112 };
113
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 };
158 static struct usb_driver podhd_driver;
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
serial_number_show(struct device * dev,struct device_attribute * attr,char * buf)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
firmware_version_show(struct device * dev,struct device_attribute * attr,char * buf)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
podhd_startup(struct usb_line6_podhd * pod)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
podhd_startup_start_workqueue(unsigned long data)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
podhd_dev_start(struct usb_line6_podhd * pod)224 static int podhd_dev_start(struct usb_line6_podhd *pod)
225 {
226 int ret;
227 u8 *init_bytes;
228 int i;
229 struct usb_device *usbdev = pod->line6.usbdev;
230
231 init_bytes = kmalloc(8, GFP_KERNEL);
232 if (!init_bytes)
233 return -ENOMEM;
234
235 ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
236 0x67, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
237 0x11, 0,
238 NULL, 0, LINE6_TIMEOUT * HZ);
239 if (ret < 0) {
240 dev_err(pod->line6.ifcdev, "read request failed (error %d)\n", ret);
241 goto exit;
242 }
243
244 /* NOTE: looks like some kind of ping message */
245 ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67,
246 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
247 0x11, 0x0,
248 init_bytes, 3, LINE6_TIMEOUT * HZ);
249 if (ret < 0) {
250 dev_err(pod->line6.ifcdev,
251 "receive length failed (error %d)\n", ret);
252 goto exit;
253 }
254
255 pod->firmware_version =
256 (init_bytes[0] << 16) | (init_bytes[1] << 8) | (init_bytes[2] << 0);
257
258 for (i = 0; i <= 16; i++) {
259 ret = line6_read_data(&pod->line6, 0xf000 + 0x08 * i, init_bytes, 8);
260 if (ret < 0)
261 goto exit;
262 }
263
264 ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
265 USB_REQ_SET_FEATURE,
266 USB_TYPE_STANDARD | USB_RECIP_DEVICE | USB_DIR_OUT,
267 1, 0,
268 NULL, 0, LINE6_TIMEOUT * HZ);
269 exit:
270 kfree(init_bytes);
271 return ret;
272 }
273
podhd_startup_workqueue(struct work_struct * work)274 static void podhd_startup_workqueue(struct work_struct *work)
275 {
276 struct usb_line6_podhd *pod =
277 container_of(work, struct usb_line6_podhd, startup_work);
278
279 CHECK_STARTUP_PROGRESS(pod->startup_progress, PODHD_STARTUP_SETUP);
280
281 podhd_dev_start(pod);
282 line6_read_serial_number(&pod->line6, &pod->serial_number);
283
284 podhd_startup_finalize(pod);
285 }
286
podhd_startup_finalize(struct usb_line6_podhd * pod)287 static int podhd_startup_finalize(struct usb_line6_podhd *pod)
288 {
289 struct usb_line6 *line6 = &pod->line6;
290
291 /* ALSA audio interface: */
292 return snd_card_register(line6->card);
293 }
294
podhd_disconnect(struct usb_line6 * line6)295 static void podhd_disconnect(struct usb_line6 *line6)
296 {
297 struct usb_line6_podhd *pod = (struct usb_line6_podhd *)line6;
298
299 if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL_INFO) {
300 struct usb_interface *intf;
301
302 del_timer_sync(&pod->startup_timer);
303 cancel_work_sync(&pod->startup_work);
304
305 intf = usb_ifnum_to_if(line6->usbdev,
306 pod->line6.properties->ctrl_if);
307 if (intf)
308 usb_driver_release_interface(&podhd_driver, intf);
309 }
310 }
311
312 /*
313 Try to init POD HD device.
314 */
podhd_init(struct usb_line6 * line6,const struct usb_device_id * id)315 static int podhd_init(struct usb_line6 *line6,
316 const struct usb_device_id *id)
317 {
318 int err;
319 struct usb_line6_podhd *pod = (struct usb_line6_podhd *) line6;
320 struct usb_interface *intf;
321
322 line6->disconnect = podhd_disconnect;
323
324 init_timer(&pod->startup_timer);
325 INIT_WORK(&pod->startup_work, podhd_startup_workqueue);
326
327 if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL) {
328 /* claim the data interface */
329 intf = usb_ifnum_to_if(line6->usbdev,
330 pod->line6.properties->ctrl_if);
331 if (!intf) {
332 dev_err(pod->line6.ifcdev, "interface %d not found\n",
333 pod->line6.properties->ctrl_if);
334 return -ENODEV;
335 }
336
337 err = usb_driver_claim_interface(&podhd_driver, intf, NULL);
338 if (err != 0) {
339 dev_err(pod->line6.ifcdev, "can't claim interface %d, error %d\n",
340 pod->line6.properties->ctrl_if, err);
341 return err;
342 }
343 }
344
345 if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL_INFO) {
346 /* create sysfs entries: */
347 err = snd_card_add_dev_attr(line6->card, &podhd_dev_attr_group);
348 if (err < 0)
349 return err;
350 }
351
352 if (pod->line6.properties->capabilities & LINE6_CAP_PCM) {
353 /* initialize PCM subsystem: */
354 err = line6_init_pcm(line6,
355 (id->driver_info == LINE6_PODX3 ||
356 id->driver_info == LINE6_PODX3LIVE) ? &podx3_pcm_properties :
357 &podhd_pcm_properties);
358 if (err < 0)
359 return err;
360 }
361
362 if (!(pod->line6.properties->capabilities & LINE6_CAP_CONTROL_INFO)) {
363 /* register USB audio system directly */
364 return podhd_startup_finalize(pod);
365 }
366
367 /* init device and delay registering */
368 podhd_startup(pod);
369 return 0;
370 }
371
372 #define LINE6_DEVICE(prod) USB_DEVICE(0x0e41, prod)
373 #define LINE6_IF_NUM(prod, n) USB_DEVICE_INTERFACE_NUMBER(0x0e41, prod, n)
374
375 /* table of devices that work with this driver */
376 static const struct usb_device_id podhd_id_table[] = {
377 /* TODO: no need to alloc data interfaces when only audio is used */
378 { LINE6_DEVICE(0x5057), .driver_info = LINE6_PODHD300 },
379 { LINE6_DEVICE(0x5058), .driver_info = LINE6_PODHD400 },
380 { LINE6_IF_NUM(0x414D, 0), .driver_info = LINE6_PODHD500_0 },
381 { LINE6_IF_NUM(0x414D, 1), .driver_info = LINE6_PODHD500_1 },
382 { LINE6_IF_NUM(0x414A, 0), .driver_info = LINE6_PODX3 },
383 { LINE6_IF_NUM(0x414B, 0), .driver_info = LINE6_PODX3LIVE },
384 { LINE6_IF_NUM(0x4159, 0), .driver_info = LINE6_PODHD500X },
385 {}
386 };
387
388 MODULE_DEVICE_TABLE(usb, podhd_id_table);
389
390 static const struct line6_properties podhd_properties_table[] = {
391 [LINE6_PODHD300] = {
392 .id = "PODHD300",
393 .name = "POD HD300",
394 .capabilities = LINE6_CAP_PCM
395 | LINE6_CAP_HWMON,
396 .altsetting = 5,
397 .ep_ctrl_r = 0x84,
398 .ep_ctrl_w = 0x03,
399 .ep_audio_r = 0x82,
400 .ep_audio_w = 0x01,
401 },
402 [LINE6_PODHD400] = {
403 .id = "PODHD400",
404 .name = "POD HD400",
405 .capabilities = LINE6_CAP_PCM
406 | LINE6_CAP_HWMON,
407 .altsetting = 5,
408 .ep_ctrl_r = 0x84,
409 .ep_ctrl_w = 0x03,
410 .ep_audio_r = 0x82,
411 .ep_audio_w = 0x01,
412 },
413 [LINE6_PODHD500_0] = {
414 .id = "PODHD500",
415 .name = "POD HD500",
416 .capabilities = LINE6_CAP_PCM
417 | LINE6_CAP_HWMON,
418 .altsetting = 0,
419 .ep_ctrl_r = 0x81,
420 .ep_ctrl_w = 0x01,
421 .ep_audio_r = 0x86,
422 .ep_audio_w = 0x02,
423 },
424 [LINE6_PODHD500_1] = {
425 .id = "PODHD500",
426 .name = "POD HD500",
427 .capabilities = LINE6_CAP_PCM
428 | LINE6_CAP_HWMON,
429 .altsetting = 1,
430 .ep_ctrl_r = 0x81,
431 .ep_ctrl_w = 0x01,
432 .ep_audio_r = 0x86,
433 .ep_audio_w = 0x02,
434 },
435 [LINE6_PODX3] = {
436 .id = "PODX3",
437 .name = "POD X3",
438 .capabilities = LINE6_CAP_CONTROL | LINE6_CAP_CONTROL_INFO
439 | LINE6_CAP_PCM | LINE6_CAP_HWMON | LINE6_CAP_IN_NEEDS_OUT,
440 .altsetting = 1,
441 .ep_ctrl_r = 0x81,
442 .ep_ctrl_w = 0x01,
443 .ctrl_if = 1,
444 .ep_audio_r = 0x86,
445 .ep_audio_w = 0x02,
446 },
447 [LINE6_PODX3LIVE] = {
448 .id = "PODX3LIVE",
449 .name = "POD X3 LIVE",
450 .capabilities = LINE6_CAP_CONTROL | LINE6_CAP_CONTROL_INFO
451 | LINE6_CAP_PCM | LINE6_CAP_HWMON | LINE6_CAP_IN_NEEDS_OUT,
452 .altsetting = 1,
453 .ep_ctrl_r = 0x81,
454 .ep_ctrl_w = 0x01,
455 .ctrl_if = 1,
456 .ep_audio_r = 0x86,
457 .ep_audio_w = 0x02,
458 },
459 [LINE6_PODHD500X] = {
460 .id = "PODHD500X",
461 .name = "POD HD500X",
462 .capabilities = LINE6_CAP_CONTROL
463 | LINE6_CAP_PCM | LINE6_CAP_HWMON,
464 .altsetting = 1,
465 .ep_ctrl_r = 0x81,
466 .ep_ctrl_w = 0x01,
467 .ctrl_if = 1,
468 .ep_audio_r = 0x86,
469 .ep_audio_w = 0x02,
470 },
471 };
472
473 /*
474 Probe USB device.
475 */
podhd_probe(struct usb_interface * interface,const struct usb_device_id * id)476 static int podhd_probe(struct usb_interface *interface,
477 const struct usb_device_id *id)
478 {
479 return line6_probe(interface, id, "Line6-PODHD",
480 &podhd_properties_table[id->driver_info],
481 podhd_init, sizeof(struct usb_line6_podhd));
482 }
483
484 static struct usb_driver podhd_driver = {
485 .name = KBUILD_MODNAME,
486 .probe = podhd_probe,
487 .disconnect = line6_disconnect,
488 #ifdef CONFIG_PM
489 .suspend = line6_suspend,
490 .resume = line6_resume,
491 .reset_resume = line6_resume,
492 #endif
493 .id_table = podhd_id_table,
494 };
495
496 module_usb_driver(podhd_driver);
497
498 MODULE_DESCRIPTION("Line 6 PODHD USB driver");
499 MODULE_LICENSE("GPL");
500