1
2
3
4
5
6
7
8
9
10
11
12#include "driver.h"
13
14#include "audio.h"
15#include "capture.h"
16#include "control.h"
17#include "playback.h"
18#include "pod.h"
19
20
21#define POD_SYSEX_CODE 3
22#define POD_BYTES_PER_FRAME 6
23
24
25enum {
26 POD_SYSEX_CLIP = 0x0f,
27 POD_SYSEX_SAVE = 0x24,
28 POD_SYSEX_SYSTEM = 0x56,
29 POD_SYSEX_SYSTEMREQ = 0x57,
30
31 POD_SYSEX_STORE = 0x71,
32 POD_SYSEX_FINISH = 0x72,
33 POD_SYSEX_DUMPMEM = 0x73,
34 POD_SYSEX_DUMP = 0x74,
35 POD_SYSEX_DUMPREQ = 0x75
36
37};
38
39enum {
40 POD_monitor_level = 0x04,
41 POD_routing = 0x05,
42 POD_tuner_mute = 0x13,
43 POD_tuner_freq = 0x15,
44 POD_tuner_note = 0x16,
45 POD_tuner_pitch = 0x17,
46 POD_system_invalid = 0x7fff
47};
48
49enum {
50 POD_DUMP_MEMORY = 2
51};
52
53enum {
54 POD_BUSY_READ,
55 POD_BUSY_WRITE,
56 POD_CHANNEL_DIRTY,
57 POD_SAVE_PRESSED,
58 POD_BUSY_MIDISEND
59};
60
61
62static struct snd_ratden pod_ratden = {
63 .num_min = 78125,
64 .num_max = 78125,
65 .num_step = 1,
66 .den = 2
67};
68
69static struct line6_pcm_properties pod_pcm_properties = {
70 .snd_line6_playback_hw = {
71 .info = (SNDRV_PCM_INFO_MMAP |
72 SNDRV_PCM_INFO_INTERLEAVED |
73 SNDRV_PCM_INFO_BLOCK_TRANSFER |
74 SNDRV_PCM_INFO_MMAP_VALID |
75 SNDRV_PCM_INFO_PAUSE |
76 SNDRV_PCM_INFO_SYNC_START),
77 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
78 .rates = SNDRV_PCM_RATE_KNOT,
79 .rate_min = 39062,
80 .rate_max = 39063,
81 .channels_min = 2,
82 .channels_max = 2,
83 .buffer_bytes_max = 60000,
84 .period_bytes_min = LINE6_ISO_PACKET_SIZE_MAX * POD_BYTES_PER_FRAME,
85 .period_bytes_max = 8192,
86 .periods_min = 1,
87 .periods_max = 1024
88 },
89 .snd_line6_capture_hw = {
90 .info = (SNDRV_PCM_INFO_MMAP |
91 SNDRV_PCM_INFO_INTERLEAVED |
92 SNDRV_PCM_INFO_BLOCK_TRANSFER |
93 SNDRV_PCM_INFO_MMAP_VALID |
94 SNDRV_PCM_INFO_SYNC_START),
95 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
96 .rates = SNDRV_PCM_RATE_KNOT,
97 .rate_min = 39062,
98 .rate_max = 39063,
99 .channels_min = 2,
100 .channels_max = 2,
101 .buffer_bytes_max = 60000,
102 .period_bytes_min = LINE6_ISO_PACKET_SIZE_MAX * POD_BYTES_PER_FRAME,
103 .period_bytes_max = 8192,
104 .periods_min = 1,
105 .periods_max = 1024
106 },
107 .snd_line6_rates = {
108 .nrats = 1,
109 .rats = &pod_ratden
110 },
111 .bytes_per_frame = POD_BYTES_PER_FRAME
112};
113
114static const char pod_request_version[] = { 0xf0, 0x7e, 0x7f, 0x06, 0x01, 0xf7 };
115static const char pod_request_channel[] = { 0xf0, 0x00, 0x01, 0x0c, 0x03, 0x75, 0xf7 };
116static const char pod_version_header[] = { 0xf2, 0x7e, 0x7f, 0x06, 0x02 };
117
118
119
120
121
122static void pod_mark_batch_all_dirty(struct usb_line6_pod *pod)
123{
124 int i;
125
126 for (i = 0; i < POD_CONTROL_SIZE; i++)
127 set_bit(i, pod->param_dirty);
128}
129
130
131
132
133static int pod_version_request_async(struct usb_line6_pod *pod)
134{
135 return line6_send_raw_message_async(&pod->line6, pod->buffer_versionreq, sizeof(pod_request_version));
136}
137
138static void pod_create_files_work(struct work_struct *work)
139{
140 struct usb_line6_pod *pod = container_of(work, struct usb_line6_pod, create_files_work);
141
142 pod_create_files(pod->firmware_version, pod->line6.properties->device_bit, pod->line6.ifcdev);
143}
144
145static void pod_startup_timeout(unsigned long arg)
146{
147 enum {
148 REQUEST_NONE,
149 REQUEST_DUMP,
150 REQUEST_VERSION
151 };
152
153 int request = REQUEST_NONE;
154 struct usb_line6_pod *pod = (struct usb_line6_pod *)arg;
155
156 if (pod->dumpreq.ok) {
157 if (!pod->versionreq_ok)
158 request = REQUEST_VERSION;
159 } else {
160 if (pod->versionreq_ok)
161 request = REQUEST_DUMP;
162 else if (pod->startup_count++ & 1)
163 request = REQUEST_DUMP;
164 else
165 request = REQUEST_VERSION;
166 }
167
168 switch (request) {
169 case REQUEST_DUMP:
170 line6_dump_request_async(&pod->dumpreq, &pod->line6, 0);
171 break;
172
173 case REQUEST_VERSION:
174 pod_version_request_async(pod);
175 break;
176
177 default:
178 return;
179 }
180
181 line6_startup_delayed(&pod->dumpreq, 1, pod_startup_timeout, pod);
182}
183
184static char *pod_alloc_sysex_buffer(struct usb_line6_pod *pod, int code, int size)
185{
186 return line6_alloc_sysex_buffer(&pod->line6, POD_SYSEX_CODE, code, size);
187}
188
189
190
191
192static void pod_dump(struct usb_line6_pod *pod, const unsigned char *data)
193{
194 int size = 1 + sizeof(pod->prog_data);
195 char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_DUMP, size);
196 if (!sysex)
197 return;
198
199
200 sysex[SYSEX_DATA_OFS] = 5;
201 memcpy(sysex + SYSEX_DATA_OFS + 1, data, sizeof(pod->prog_data));
202 line6_send_sysex_message(&pod->line6, sysex, size);
203 memcpy(&pod->prog_data, data, sizeof(pod->prog_data));
204 pod_mark_batch_all_dirty(pod);
205 kfree(sysex);
206}
207
208
209
210
211static void pod_store_parameter(struct usb_line6_pod *pod, int param, int value)
212{
213 pod->prog_data.control[param] = value;
214 set_bit(param, pod->param_dirty);
215 pod->dirty = 1;
216}
217
218
219
220
221static void pod_save_button_pressed(struct usb_line6_pod *pod, int type, int index)
222{
223 pod->dirty = 0;
224 set_bit(POD_SAVE_PRESSED, &pod->atomic_flags);
225}
226
227
228
229
230void pod_process_message(struct usb_line6_pod *pod)
231{
232 const unsigned char *buf = pod->line6.buffer_message;
233
234
235 switch (buf[0] & 0xf0) {
236 case LINE6_PARAM_CHANGE:
237 case LINE6_PROGRAM_CHANGE:
238 case LINE6_SYSEX_BEGIN:
239 break;
240
241 default:
242 return;
243 }
244
245
246 switch (buf[0]) {
247 case LINE6_PARAM_CHANGE | LINE6_CHANNEL_DEVICE:
248 pod_store_parameter(pod, buf[1], buf[2]);
249
250
251 case LINE6_PARAM_CHANGE | LINE6_CHANNEL_HOST:
252 if ((buf[1] == POD_amp_model_setup) ||
253 (buf[1] == POD_effect_setup))
254
255 line6_dump_request_async(&pod->dumpreq, &pod->line6, 0);
256
257 break;
258
259 case LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_DEVICE:
260 case LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_HOST:
261 pod->channel_num = buf[1];
262 pod->dirty = 0;
263 set_bit(POD_CHANNEL_DIRTY, &pod->atomic_flags);
264 line6_dump_request_async(&pod->dumpreq, &pod->line6, 0);
265 break;
266
267 case LINE6_SYSEX_BEGIN | LINE6_CHANNEL_DEVICE:
268 case LINE6_SYSEX_BEGIN | LINE6_CHANNEL_UNKNOWN:
269 if (memcmp(buf + 1, line6_midi_id, sizeof(line6_midi_id)) == 0) {
270 switch (buf[5]) {
271 case POD_SYSEX_DUMP:
272 if (pod->line6.message_length == sizeof(pod->prog_data) + 7) {
273 switch (pod->dumpreq.in_progress) {
274 case LINE6_DUMP_CURRENT:
275 memcpy(&pod->prog_data, buf + 7, sizeof(pod->prog_data));
276 pod_mark_batch_all_dirty(pod);
277 pod->dumpreq.ok = 1;
278 break;
279
280 case POD_DUMP_MEMORY:
281 memcpy(&pod->prog_data_buf, buf + 7, sizeof(pod->prog_data_buf));
282 break;
283
284 default:
285 DEBUG_MESSAGES(dev_err(pod->line6.ifcdev, "unknown dump code %02X\n", pod->dumpreq.in_progress));
286 }
287
288 line6_dump_finished(&pod->dumpreq);
289 } else
290 DEBUG_MESSAGES(dev_err(pod->line6.ifcdev, "wrong size of channel dump message (%d instead of %d)\n",
291 pod->line6.message_length, (int)sizeof(pod->prog_data) + 7));
292
293 break;
294
295 case POD_SYSEX_SYSTEM: {
296 short value = ((int)buf[7] << 12) | ((int)buf[8] << 8) | ((int)buf[9] << 4) | (int)buf[10];
297
298#define PROCESS_SYSTEM_PARAM(x) \
299 case POD_ ## x: \
300 pod->x.value = value; \
301 wake_up_interruptible(&pod->x.wait); \
302 break;
303
304 switch (buf[6]) {
305 PROCESS_SYSTEM_PARAM(monitor_level);
306 PROCESS_SYSTEM_PARAM(routing);
307 PROCESS_SYSTEM_PARAM(tuner_mute);
308 PROCESS_SYSTEM_PARAM(tuner_freq);
309 PROCESS_SYSTEM_PARAM(tuner_note);
310 PROCESS_SYSTEM_PARAM(tuner_pitch);
311
312#undef PROCESS_SYSTEM_PARAM
313
314 default:
315 DEBUG_MESSAGES(dev_err(pod->line6.ifcdev, "unknown tuner/system response %02X\n", buf[6]));
316 }
317
318 break;
319 }
320
321 case POD_SYSEX_FINISH:
322
323 break;
324
325 case POD_SYSEX_SAVE:
326 pod_save_button_pressed(pod, buf[6], buf[7]);
327 break;
328
329 case POD_SYSEX_CLIP:
330 DEBUG_MESSAGES(dev_err(pod->line6.ifcdev, "audio clipped\n"));
331 pod->clipping.value = 1;
332 wake_up_interruptible(&pod->clipping.wait);
333 break;
334
335 case POD_SYSEX_STORE:
336 DEBUG_MESSAGES(dev_err(pod->line6.ifcdev, "message %02X not yet implemented\n", buf[5]));
337 break;
338
339 default:
340 DEBUG_MESSAGES(dev_err(pod->line6.ifcdev, "unknown sysex message %02X\n", buf[5]));
341 }
342 } else if (memcmp(buf, pod_version_header, sizeof(pod_version_header)) == 0) {
343 if (pod->versionreq_ok == 0) {
344 pod->firmware_version = buf[13] * 100 + buf[14] * 10 + buf[15];
345 pod->device_id = ((int)buf[8] << 16) | ((int)buf[9] << 8) | (int)buf[10];
346 pod->versionreq_ok = 1;
347
348
349
350 INIT_WORK(&pod->create_files_work, pod_create_files_work);
351 queue_work(line6_workqueue, &pod->create_files_work);
352 } else
353 DEBUG_MESSAGES(dev_err(pod->line6.ifcdev, "multiple firmware version message\n"));
354 } else
355 DEBUG_MESSAGES(dev_err(pod->line6.ifcdev, "unknown sysex header\n"));
356
357 break;
358
359 case LINE6_SYSEX_END:
360 break;
361
362 default:
363 DEBUG_MESSAGES(dev_err(pod->line6.ifcdev, "POD: unknown message %02X\n", buf[0]));
364 }
365}
366
367
368
369
370
371
372
373
374
375
376
377
378void pod_midi_postprocess(struct usb_line6_pod *pod, unsigned char *data, int length)
379{
380 int i;
381
382 if (!pod->midi_postprocess)
383 return;
384
385 for (i = 0; i < length; ++i) {
386 if (data[i] == (LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_HOST)) {
387 line6_invalidate_current(&pod->dumpreq);
388 break;
389 } else if ((data[i] == (LINE6_PARAM_CHANGE | LINE6_CHANNEL_HOST)) && (i < length - 1))
390 if ((data[i + 1] == POD_amp_model_setup) || (data[i + 1] == POD_effect_setup)) {
391 line6_invalidate_current(&pod->dumpreq);
392 break;
393 }
394 }
395}
396
397
398
399
400static void pod_send_channel(struct usb_line6_pod *pod, int value)
401{
402 line6_invalidate_current(&pod->dumpreq);
403
404 if (line6_send_program(&pod->line6, value) == 0)
405 pod->channel_num = value;
406 else
407 line6_dump_finished(&pod->dumpreq);
408}
409
410
411
412
413void pod_transmit_parameter(struct usb_line6_pod *pod, int param, int value)
414{
415 if (line6_transmit_parameter(&pod->line6, param, value) == 0)
416 pod_store_parameter(pod, param, value);
417
418 if ((param == POD_amp_model_setup) || (param == POD_effect_setup))
419 line6_invalidate_current(&pod->dumpreq);
420}
421
422
423
424
425static void pod_resolve(const char *buf, short block0, short block1, unsigned char *location)
426{
427 int value = simple_strtoul(buf, NULL, 10);
428 short block = (value < 0x40) ? block0 : block1;
429 value &= 0x3f;
430 location[0] = block >> 7;
431 location[1] = value | (block & 0x7f);
432}
433
434
435
436
437static ssize_t pod_send_store_command(struct device *dev, const char *buf, size_t count, short block0, short block1)
438{
439 struct usb_interface *interface = to_usb_interface(dev);
440 struct usb_line6_pod *pod = usb_get_intfdata(interface);
441
442 int size = 3 + sizeof(pod->prog_data_buf);
443 char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_STORE, size);
444 if (!sysex)
445 return 0;
446
447 sysex[SYSEX_DATA_OFS] = 5;
448 pod_resolve(buf, block0, block1, sysex + SYSEX_DATA_OFS + 1);
449 memcpy(sysex + SYSEX_DATA_OFS + 3, &pod->prog_data_buf, sizeof(pod->prog_data_buf));
450
451 line6_send_sysex_message(&pod->line6, sysex, size);
452 kfree(sysex);
453
454 return count;
455}
456
457
458
459
460static ssize_t pod_send_retrieve_command(struct device *dev, const char *buf, size_t count, short block0, short block1)
461{
462 struct usb_interface *interface = to_usb_interface(dev);
463 struct usb_line6_pod *pod = usb_get_intfdata(interface);
464 int size = 4;
465 char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_DUMPMEM, size);
466
467 if (!sysex)
468 return 0;
469
470 pod_resolve(buf, block0, block1, sysex + SYSEX_DATA_OFS);
471 sysex[SYSEX_DATA_OFS + 2] = 0;
472 sysex[SYSEX_DATA_OFS + 3] = 0;
473 line6_dump_started(&pod->dumpreq, POD_DUMP_MEMORY);
474
475 if (line6_send_sysex_message(&pod->line6, sysex, size) < size)
476 line6_dump_finished(&pod->dumpreq);
477
478 kfree(sysex);
479
480 return count;
481}
482
483
484
485
486static ssize_t get_name_generic(struct usb_line6_pod *pod, const char *str, char *buf)
487{
488 int length = 0;
489 const char *p1;
490 char *p2;
491 char *last_non_space = buf;
492
493 int retval = line6_wait_dump(&pod->dumpreq, 0);
494 if (retval < 0)
495 return retval;
496
497 for (p1 = str, p2 = buf; *p1; ++p1, ++p2) {
498 *p2 = *p1;
499 if (*p2 != ' ')
500 last_non_space = p2;
501 if (++length == POD_NAME_LENGTH)
502 break;
503 }
504
505 *(last_non_space + 1) = '\n';
506 return last_non_space - buf + 2;
507}
508
509
510
511
512static ssize_t pod_get_channel(struct device *dev,
513 struct device_attribute *attr, char *buf)
514{
515 struct usb_interface *interface = to_usb_interface(dev);
516 struct usb_line6_pod *pod = usb_get_intfdata(interface);
517 return sprintf(buf, "%d\n", pod->channel_num);
518}
519
520
521
522
523static ssize_t pod_set_channel(struct device *dev,
524 struct device_attribute *attr,
525 const char *buf, size_t count)
526{
527 struct usb_interface *interface = to_usb_interface(dev);
528 struct usb_line6_pod *pod = usb_get_intfdata(interface);
529 int value = simple_strtoul(buf, NULL, 10);
530 pod_send_channel(pod, value);
531 return count;
532}
533
534
535
536
537static ssize_t pod_get_name(struct device *dev, struct device_attribute *attr,
538 char *buf)
539{
540 struct usb_interface *interface = to_usb_interface(dev);
541 struct usb_line6_pod *pod = usb_get_intfdata(interface);
542 return get_name_generic(pod, pod->prog_data.header + POD_NAME_OFFSET, buf);
543}
544
545
546
547
548static ssize_t pod_get_name_buf(struct device *dev,
549 struct device_attribute *attr, char *buf)
550{
551 struct usb_interface *interface = to_usb_interface(dev);
552 struct usb_line6_pod *pod = usb_get_intfdata(interface);
553 return get_name_generic(pod, pod->prog_data_buf.header + POD_NAME_OFFSET, buf);
554}
555
556
557
558
559static ssize_t pod_get_dump(struct device *dev, struct device_attribute *attr,
560 char *buf)
561{
562 struct usb_interface *interface = to_usb_interface(dev);
563 struct usb_line6_pod *pod = usb_get_intfdata(interface);
564 int retval = line6_wait_dump(&pod->dumpreq, 0);
565 if (retval < 0)
566 return retval;
567 memcpy(buf, &pod->prog_data, sizeof(pod->prog_data));
568 return sizeof(pod->prog_data);
569}
570
571
572
573
574static ssize_t pod_set_dump(struct device *dev, struct device_attribute *attr,
575 const char *buf, size_t count)
576{
577 struct usb_interface *interface = to_usb_interface(dev);
578 struct usb_line6_pod *pod = usb_get_intfdata(interface);
579
580 if (count != sizeof(pod->prog_data)) {
581 dev_err(pod->line6.ifcdev,
582 "data block must be exactly %d bytes\n",
583 sizeof(pod->prog_data));
584 return -EINVAL;
585 }
586
587 pod_dump(pod, buf);
588 return sizeof(pod->prog_data);
589}
590
591
592
593
594
595static ssize_t pod_get_system_param(struct usb_line6_pod *pod, char *buf, int code, struct ValueWait *param, int tuner, int sign)
596{
597 char *sysex;
598 int value;
599 static const int size = 1;
600 int retval = 0;
601 DECLARE_WAITQUEUE(wait, current);
602
603 if (((pod->prog_data.control[POD_tuner] & 0x40) == 0) && tuner)
604 return -ENODEV;
605
606
607 param->value = POD_system_invalid;
608 sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_SYSTEMREQ, size);
609 if (!sysex)
610 return 0;
611 sysex[SYSEX_DATA_OFS] = code;
612 line6_send_sysex_message(&pod->line6, sysex, size);
613 kfree(sysex);
614
615
616 add_wait_queue(¶m->wait, &wait);
617 current->state = TASK_INTERRUPTIBLE;
618
619 while (param->value == POD_system_invalid) {
620 if (signal_pending(current)) {
621 retval = -ERESTARTSYS;
622 break;
623 } else
624 schedule();
625 }
626
627 current->state = TASK_RUNNING;
628 remove_wait_queue(¶m->wait, &wait);
629
630 if (retval < 0)
631 return retval;
632
633 value = sign ? (int)(signed short)param->value : (int)(unsigned short)param->value;
634 return sprintf(buf, "%d\n", value);
635}
636
637
638
639
640
641static ssize_t pod_set_system_param(struct usb_line6_pod *pod, const char *buf,
642 int count, int code, unsigned short mask,
643 int tuner)
644{
645 char *sysex;
646 static const int size = 5;
647 unsigned short value;
648
649 if (((pod->prog_data.control[POD_tuner] & 0x40) == 0) && tuner)
650 return -EINVAL;
651
652
653 sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_SYSTEM, size);
654 if (!sysex)
655 return 0;
656 value = simple_strtoul(buf, NULL, 10) & mask;
657 sysex[SYSEX_DATA_OFS] = code;
658 sysex[SYSEX_DATA_OFS + 1] = (value >> 12) & 0x0f;
659 sysex[SYSEX_DATA_OFS + 2] = (value >> 8) & 0x0f;
660 sysex[SYSEX_DATA_OFS + 3] = (value >> 4) & 0x0f;
661 sysex[SYSEX_DATA_OFS + 4] = (value ) & 0x0f;
662 line6_send_sysex_message(&pod->line6, sysex, size);
663 kfree(sysex);
664 return count;
665}
666
667
668
669
670static ssize_t pod_get_dump_buf(struct device *dev,
671 struct device_attribute *attr, char *buf)
672{
673 struct usb_interface *interface = to_usb_interface(dev);
674 struct usb_line6_pod *pod = usb_get_intfdata(interface);
675 int retval = line6_wait_dump(&pod->dumpreq, 0);
676 if (retval < 0)
677 return retval;
678 memcpy(buf, &pod->prog_data_buf, sizeof(pod->prog_data_buf));
679 return sizeof(pod->prog_data_buf);
680}
681
682
683
684
685static ssize_t pod_set_dump_buf(struct device *dev,
686 struct device_attribute *attr,
687 const char *buf, size_t count)
688{
689 struct usb_interface *interface = to_usb_interface(dev);
690 struct usb_line6_pod *pod = usb_get_intfdata(interface);
691
692 if (count != sizeof(pod->prog_data)) {
693 dev_err(pod->line6.ifcdev,
694 "data block must be exactly %d bytes\n",
695 sizeof(pod->prog_data));
696 return -EINVAL;
697 }
698
699 memcpy(&pod->prog_data_buf, buf, sizeof(pod->prog_data));
700 return sizeof(pod->prog_data);
701}
702
703
704
705
706static ssize_t pod_set_finish(struct device *dev,
707 struct device_attribute *attr,
708 const char *buf, size_t count)
709{
710 struct usb_interface *interface = to_usb_interface(dev);
711 struct usb_line6_pod *pod = usb_get_intfdata(interface);
712 int size = 0;
713 char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_FINISH, size);
714 if (!sysex)
715 return 0;
716 line6_send_sysex_message(&pod->line6, sysex, size);
717 kfree(sysex);
718 return count;
719}
720
721
722
723
724static ssize_t pod_set_store_channel(struct device *dev,
725 struct device_attribute *attr,
726 const char *buf, size_t count)
727{
728 return pod_send_store_command(dev, buf, count, 0x0000, 0x00c0);
729}
730
731
732
733
734static ssize_t pod_set_store_effects_setup(struct device *dev,
735 struct device_attribute *attr,
736 const char *buf, size_t count)
737{
738 return pod_send_store_command(dev, buf, count, 0x0080, 0x0080);
739}
740
741
742
743
744static ssize_t pod_set_store_amp_setup(struct device *dev,
745 struct device_attribute *attr,
746 const char *buf, size_t count)
747{
748 return pod_send_store_command(dev, buf, count, 0x0040, 0x0100);
749}
750
751
752
753
754static ssize_t pod_set_retrieve_channel(struct device *dev,
755 struct device_attribute *attr,
756 const char *buf, size_t count)
757{
758 return pod_send_retrieve_command(dev, buf, count, 0x0000, 0x00c0);
759}
760
761
762
763
764static ssize_t pod_set_retrieve_effects_setup(struct device *dev,
765 struct device_attribute *attr,
766 const char *buf, size_t count)
767{
768 return pod_send_retrieve_command(dev, buf, count, 0x0080, 0x0080);
769}
770
771
772
773
774static ssize_t pod_set_retrieve_amp_setup(struct device *dev,
775 struct device_attribute *attr,
776 const char *buf, size_t count)
777{
778 return pod_send_retrieve_command(dev, buf, count, 0x0040, 0x0100);
779}
780
781
782
783
784static ssize_t pod_get_dirty(struct device *dev, struct device_attribute *attr,
785 char *buf)
786{
787 struct usb_interface *interface = to_usb_interface(dev);
788 struct usb_line6_pod *pod = usb_get_intfdata(interface);
789 buf[0] = pod->dirty ? '1' : '0';
790 buf[1] = '\n';
791 return 2;
792}
793
794
795
796
797static ssize_t pod_get_midi_postprocess(struct device *dev,
798 struct device_attribute *attr,
799 char *buf)
800{
801 struct usb_interface *interface = to_usb_interface(dev);
802 struct usb_line6_pod *pod = usb_get_intfdata(interface);
803 return sprintf(buf, "%d\n", pod->midi_postprocess);
804}
805
806
807
808
809static ssize_t pod_set_midi_postprocess(struct device *dev,
810 struct device_attribute *attr,
811 const char *buf, size_t count)
812{
813 struct usb_interface *interface = to_usb_interface(dev);
814 struct usb_line6_pod *pod = usb_get_intfdata(interface);
815 int value = simple_strtoul(buf, NULL, 10);
816 pod->midi_postprocess = value ? 1 : 0;
817 return count;
818}
819
820
821
822
823static ssize_t pod_get_serial_number(struct device *dev,
824 struct device_attribute *attr, char *buf)
825{
826 struct usb_interface *interface = to_usb_interface(dev);
827 struct usb_line6_pod *pod = usb_get_intfdata(interface);
828 return sprintf(buf, "%d\n", pod->serial_number);
829}
830
831
832
833
834static ssize_t pod_get_firmware_version(struct device *dev,
835 struct device_attribute *attr,
836 char *buf)
837{
838 struct usb_interface *interface = to_usb_interface(dev);
839 struct usb_line6_pod *pod = usb_get_intfdata(interface);
840 return sprintf(buf, "%d.%02d\n", pod->firmware_version / 100,
841 pod->firmware_version % 100);
842}
843
844
845
846
847static ssize_t pod_get_device_id(struct device *dev,
848 struct device_attribute *attr, char *buf)
849{
850 struct usb_interface *interface = to_usb_interface(dev);
851 struct usb_line6_pod *pod = usb_get_intfdata(interface);
852 return sprintf(buf, "%d\n", pod->device_id);
853}
854
855
856
857
858static ssize_t pod_wait_for_clip(struct device *dev,
859 struct device_attribute *attr, char *buf)
860{
861 struct usb_interface *interface = to_usb_interface(dev);
862 struct usb_line6_pod *pod = usb_get_intfdata(interface);
863 int err = 0;
864 DECLARE_WAITQUEUE(wait, current);
865 pod->clipping.value = 0;
866 add_wait_queue(&pod->clipping.wait, &wait);
867 current->state = TASK_INTERRUPTIBLE;
868
869 while (pod->clipping.value == 0) {
870 if (signal_pending(current)) {
871 err = -ERESTARTSYS;
872 break;
873 } else
874 schedule();
875 }
876
877 current->state = TASK_RUNNING;
878 remove_wait_queue(&pod->clipping.wait, &wait);
879 return err;
880}
881
882#define POD_GET_SYSTEM_PARAM(code, tuner, sign) \
883static ssize_t pod_get_ ## code(struct device *dev, \
884 struct device_attribute *attr, char *buf) \
885{ \
886 struct usb_interface *interface = to_usb_interface(dev); \
887 struct usb_line6_pod *pod = usb_get_intfdata(interface); \
888 return pod_get_system_param(pod, buf, POD_ ## code, &pod->code, \
889 tuner, sign); \
890}
891
892#define POD_GET_SET_SYSTEM_PARAM(code, mask, tuner, sign) \
893POD_GET_SYSTEM_PARAM(code, tuner, sign) \
894static ssize_t pod_set_ ## code(struct device *dev, \
895 struct device_attribute *attr, \
896 const char *buf, size_t count) \
897{ \
898 struct usb_interface *interface = to_usb_interface(dev); \
899 struct usb_line6_pod *pod = usb_get_intfdata(interface); \
900 return pod_set_system_param(pod, buf, count, POD_ ## code, mask, \
901 tuner); \
902}
903
904POD_GET_SET_SYSTEM_PARAM(monitor_level, 0xffff, 0, 0);
905POD_GET_SET_SYSTEM_PARAM(routing, 0x0003, 0, 0);
906POD_GET_SET_SYSTEM_PARAM(tuner_mute, 0x0001, 1, 0);
907POD_GET_SET_SYSTEM_PARAM(tuner_freq, 0xffff, 1, 0);
908POD_GET_SYSTEM_PARAM(tuner_note, 1, 1);
909POD_GET_SYSTEM_PARAM(tuner_pitch, 1, 1);
910
911#undef GET_SET_SYSTEM_PARAM
912#undef GET_SYSTEM_PARAM
913
914
915static DEVICE_ATTR(channel, S_IWUGO | S_IRUGO, pod_get_channel, pod_set_channel);
916static DEVICE_ATTR(clip, S_IRUGO, pod_wait_for_clip, line6_nop_write);
917static DEVICE_ATTR(device_id, S_IRUGO, pod_get_device_id, line6_nop_write);
918static DEVICE_ATTR(dirty, S_IRUGO, pod_get_dirty, line6_nop_write);
919static DEVICE_ATTR(dump, S_IWUGO | S_IRUGO, pod_get_dump, pod_set_dump);
920static DEVICE_ATTR(dump_buf, S_IWUGO | S_IRUGO, pod_get_dump_buf, pod_set_dump_buf);
921static DEVICE_ATTR(finish, S_IWUGO, line6_nop_read, pod_set_finish);
922static DEVICE_ATTR(firmware_version, S_IRUGO, pod_get_firmware_version, line6_nop_write);
923static DEVICE_ATTR(midi_postprocess, S_IWUGO | S_IRUGO, pod_get_midi_postprocess, pod_set_midi_postprocess);
924static DEVICE_ATTR(monitor_level, S_IWUGO | S_IRUGO, pod_get_monitor_level, pod_set_monitor_level);
925static DEVICE_ATTR(name, S_IRUGO, pod_get_name, line6_nop_write);
926static DEVICE_ATTR(name_buf, S_IRUGO, pod_get_name_buf, line6_nop_write);
927static DEVICE_ATTR(retrieve_amp_setup, S_IWUGO, line6_nop_read, pod_set_retrieve_amp_setup);
928static DEVICE_ATTR(retrieve_channel, S_IWUGO, line6_nop_read, pod_set_retrieve_channel);
929static DEVICE_ATTR(retrieve_effects_setup, S_IWUGO, line6_nop_read, pod_set_retrieve_effects_setup);
930static DEVICE_ATTR(routing, S_IWUGO | S_IRUGO, pod_get_routing, pod_set_routing);
931static DEVICE_ATTR(serial_number, S_IRUGO, pod_get_serial_number, line6_nop_write);
932static DEVICE_ATTR(store_amp_setup, S_IWUGO, line6_nop_read, pod_set_store_amp_setup);
933static DEVICE_ATTR(store_channel, S_IWUGO, line6_nop_read, pod_set_store_channel);
934static DEVICE_ATTR(store_effects_setup, S_IWUGO, line6_nop_read, pod_set_store_effects_setup);
935static DEVICE_ATTR(tuner_freq, S_IWUGO | S_IRUGO, pod_get_tuner_freq, pod_set_tuner_freq);
936static DEVICE_ATTR(tuner_mute, S_IWUGO | S_IRUGO, pod_get_tuner_mute, pod_set_tuner_mute);
937static DEVICE_ATTR(tuner_note, S_IRUGO, pod_get_tuner_note, line6_nop_write);
938static DEVICE_ATTR(tuner_pitch, S_IRUGO, pod_get_tuner_pitch, line6_nop_write);
939
940#if CREATE_RAW_FILE
941static DEVICE_ATTR(raw, S_IWUGO, line6_nop_read, line6_set_raw);
942#endif
943
944
945
946
947static void pod_destruct(struct usb_interface *interface)
948{
949 struct usb_line6_pod *pod = usb_get_intfdata(interface);
950 struct usb_line6 *line6;
951
952 if (pod == NULL)
953 return;
954 line6 = &pod->line6;
955 if (line6 == NULL)
956 return;
957 line6_cleanup_audio(line6);
958
959
960 line6_dumpreq_destruct(&pod->dumpreq);
961
962 kfree(pod->buffer_versionreq);
963}
964
965
966
967
968static int pod_create_files2(struct device *dev)
969{
970 int err;
971
972 CHECK_RETURN(device_create_file(dev, &dev_attr_channel));
973 CHECK_RETURN(device_create_file(dev, &dev_attr_clip));
974 CHECK_RETURN(device_create_file(dev, &dev_attr_device_id));
975 CHECK_RETURN(device_create_file(dev, &dev_attr_dirty));
976 CHECK_RETURN(device_create_file(dev, &dev_attr_dump));
977 CHECK_RETURN(device_create_file(dev, &dev_attr_dump_buf));
978 CHECK_RETURN(device_create_file(dev, &dev_attr_finish));
979 CHECK_RETURN(device_create_file(dev, &dev_attr_firmware_version));
980 CHECK_RETURN(device_create_file(dev, &dev_attr_midi_postprocess));
981 CHECK_RETURN(device_create_file(dev, &dev_attr_monitor_level));
982 CHECK_RETURN(device_create_file(dev, &dev_attr_name));
983 CHECK_RETURN(device_create_file(dev, &dev_attr_name_buf));
984 CHECK_RETURN(device_create_file(dev, &dev_attr_retrieve_amp_setup));
985 CHECK_RETURN(device_create_file(dev, &dev_attr_retrieve_channel));
986 CHECK_RETURN(device_create_file(dev, &dev_attr_retrieve_effects_setup));
987 CHECK_RETURN(device_create_file(dev, &dev_attr_routing));
988 CHECK_RETURN(device_create_file(dev, &dev_attr_serial_number));
989 CHECK_RETURN(device_create_file(dev, &dev_attr_store_amp_setup));
990 CHECK_RETURN(device_create_file(dev, &dev_attr_store_channel));
991 CHECK_RETURN(device_create_file(dev, &dev_attr_store_effects_setup));
992 CHECK_RETURN(device_create_file(dev, &dev_attr_tuner_freq));
993 CHECK_RETURN(device_create_file(dev, &dev_attr_tuner_mute));
994 CHECK_RETURN(device_create_file(dev, &dev_attr_tuner_note));
995 CHECK_RETURN(device_create_file(dev, &dev_attr_tuner_pitch));
996
997#if CREATE_RAW_FILE
998 CHECK_RETURN(device_create_file(dev, &dev_attr_raw));
999#endif
1000
1001 return 0;
1002}
1003
1004
1005
1006
1007int pod_init(struct usb_interface *interface, struct usb_line6_pod *pod)
1008{
1009 int err;
1010 struct usb_line6 *line6 = &pod->line6;
1011
1012 if ((interface == NULL) || (pod == NULL))
1013 return -ENODEV;
1014
1015 pod->channel_num = 255;
1016
1017
1018 init_waitqueue_head(&pod->monitor_level.wait);
1019 init_waitqueue_head(&pod->routing.wait);
1020 init_waitqueue_head(&pod->tuner_mute.wait);
1021 init_waitqueue_head(&pod->tuner_freq.wait);
1022 init_waitqueue_head(&pod->tuner_note.wait);
1023 init_waitqueue_head(&pod->tuner_pitch.wait);
1024 init_waitqueue_head(&pod->clipping.wait);
1025
1026 memset(pod->param_dirty, 0xff, sizeof(pod->param_dirty));
1027
1028
1029 err = line6_dumpreq_init(&pod->dumpreq, pod_request_channel,
1030 sizeof(pod_request_channel));
1031 if (err < 0) {
1032 dev_err(&interface->dev, "Out of memory\n");
1033 pod_destruct(interface);
1034 return -ENOMEM;
1035 }
1036
1037 pod->buffer_versionreq = kmalloc(sizeof(pod_request_version),
1038 GFP_KERNEL);
1039
1040 if (pod->buffer_versionreq == NULL) {
1041 dev_err(&interface->dev, "Out of memory\n");
1042 pod_destruct(interface);
1043 return -ENOMEM;
1044 }
1045
1046 memcpy(pod->buffer_versionreq, pod_request_version,
1047 sizeof(pod_request_version));
1048
1049
1050 err = pod_create_files2(&interface->dev);
1051 if (err < 0) {
1052 pod_destruct(interface);
1053 return err;
1054 }
1055
1056
1057 err = line6_init_audio(line6);
1058 if (err < 0) {
1059 pod_destruct(interface);
1060 return err;
1061 }
1062
1063
1064 err = line6_init_midi(line6);
1065 if (err < 0) {
1066 pod_destruct(interface);
1067 return err;
1068 }
1069
1070
1071 err = line6_init_pcm(line6, &pod_pcm_properties);
1072 if (err < 0) {
1073 pod_destruct(interface);
1074 return err;
1075 }
1076
1077
1078 err = line6_register_audio(line6);
1079 if (err < 0) {
1080 pod_destruct(interface);
1081 return err;
1082 }
1083
1084 if (pod->line6.properties->capabilities & LINE6_BIT_CONTROL) {
1085
1086 line6_startup_delayed(&pod->dumpreq, POD_STARTUP_DELAY,
1087 pod_startup_timeout, pod);
1088 line6_read_serial_number(&pod->line6, &pod->serial_number);
1089 }
1090
1091 return 0;
1092}
1093
1094
1095
1096
1097void pod_disconnect(struct usb_interface *interface)
1098{
1099 struct usb_line6_pod *pod;
1100
1101 if (interface == NULL)
1102 return;
1103 pod = usb_get_intfdata(interface);
1104
1105 if (pod != NULL) {
1106 struct snd_line6_pcm *line6pcm = pod->line6.line6pcm;
1107 struct device *dev = &interface->dev;
1108
1109 if (line6pcm != NULL) {
1110 unlink_wait_clear_audio_out_urbs(line6pcm);
1111 unlink_wait_clear_audio_in_urbs(line6pcm);
1112 }
1113
1114 if (dev != NULL) {
1115
1116 if (pod->versionreq_ok)
1117 pod_remove_files(pod->firmware_version, pod->line6.properties->device_bit, dev);
1118
1119 device_remove_file(dev, &dev_attr_channel);
1120 device_remove_file(dev, &dev_attr_clip);
1121 device_remove_file(dev, &dev_attr_device_id);
1122 device_remove_file(dev, &dev_attr_dirty);
1123 device_remove_file(dev, &dev_attr_dump);
1124 device_remove_file(dev, &dev_attr_dump_buf);
1125 device_remove_file(dev, &dev_attr_finish);
1126 device_remove_file(dev, &dev_attr_firmware_version);
1127 device_remove_file(dev, &dev_attr_midi_postprocess);
1128 device_remove_file(dev, &dev_attr_monitor_level);
1129 device_remove_file(dev, &dev_attr_name);
1130 device_remove_file(dev, &dev_attr_name_buf);
1131 device_remove_file(dev, &dev_attr_retrieve_amp_setup);
1132 device_remove_file(dev, &dev_attr_retrieve_channel);
1133 device_remove_file(dev, &dev_attr_retrieve_effects_setup);
1134 device_remove_file(dev, &dev_attr_routing);
1135 device_remove_file(dev, &dev_attr_serial_number);
1136 device_remove_file(dev, &dev_attr_store_amp_setup);
1137 device_remove_file(dev, &dev_attr_store_channel);
1138 device_remove_file(dev, &dev_attr_store_effects_setup);
1139 device_remove_file(dev, &dev_attr_tuner_freq);
1140 device_remove_file(dev, &dev_attr_tuner_mute);
1141 device_remove_file(dev, &dev_attr_tuner_note);
1142 device_remove_file(dev, &dev_attr_tuner_pitch);
1143
1144#if CREATE_RAW_FILE
1145 device_remove_file(dev, &dev_attr_raw);
1146#endif
1147 }
1148 }
1149
1150 pod_destruct(interface);
1151}
1152
