?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.3-rc6
[linux/fpc-iii.git] / drivers / staging / line6 / pod.c
blob4dadc571d9617c798835defdffd8977637658761
1 /*
2 * Line6 Linux USB driver - 0.9.1beta
3 *
4 * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
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
12 #include <linux/slab.h>
13 #include <linux/wait.h>
14 #include <sound/control.h>
15
16 #include "audio.h"
17 #include "capture.h"
18 #include "control.h"
19 #include "driver.h"
20 #include "playback.h"
21 #include "pod.h"
22
23 #define POD_SYSEX_CODE 3
24 #define POD_BYTES_PER_FRAME 6 /* 24bit audio (stereo) */
25
26 /* *INDENT-OFF* */
27
28 enum {
29 POD_SYSEX_CLIP = 0x0f,
30 POD_SYSEX_SAVE = 0x24,
31 POD_SYSEX_SYSTEM = 0x56,
32 POD_SYSEX_SYSTEMREQ = 0x57,
33 /* POD_SYSEX_UPDATE = 0x6c, */ /* software update! */
34 POD_SYSEX_STORE = 0x71,
35 POD_SYSEX_FINISH = 0x72,
36 POD_SYSEX_DUMPMEM = 0x73,
37 POD_SYSEX_DUMP = 0x74,
38 POD_SYSEX_DUMPREQ = 0x75
39 /* POD_SYSEX_DUMPMEM2 = 0x76 */ /* dumps entire internal memory of PODxt Pro */
40 };
41
42 enum {
43 POD_monitor_level = 0x04,
44 POD_routing = 0x05,
45 POD_tuner_mute = 0x13,
46 POD_tuner_freq = 0x15,
47 POD_tuner_note = 0x16,
48 POD_tuner_pitch = 0x17,
49 POD_system_invalid = 0x10000
50 };
51
52 /* *INDENT-ON* */
53
54 enum {
55 POD_DUMP_MEMORY = 2
56 };
57
58 enum {
59 POD_BUSY_READ,
60 POD_BUSY_WRITE,
61 POD_CHANNEL_DIRTY,
62 POD_SAVE_PRESSED,
63 POD_BUSY_MIDISEND
64 };
65
66 static struct snd_ratden pod_ratden = {
67 .num_min = 78125,
68 .num_max = 78125,
69 .num_step = 1,
70 .den = 2
71 };
72
73 static struct line6_pcm_properties pod_pcm_properties = {
74 .snd_line6_playback_hw = {
75 .info = (SNDRV_PCM_INFO_MMAP |
76 SNDRV_PCM_INFO_INTERLEAVED |
77 SNDRV_PCM_INFO_BLOCK_TRANSFER |
78 SNDRV_PCM_INFO_MMAP_VALID |
79 SNDRV_PCM_INFO_PAUSE |
80 #ifdef CONFIG_PM
81 SNDRV_PCM_INFO_RESUME |
82 #endif
83 SNDRV_PCM_INFO_SYNC_START),
84 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
85 .rates = SNDRV_PCM_RATE_KNOT,
86 .rate_min = 39062,
87 .rate_max = 39063,
88 .channels_min = 2,
89 .channels_max = 2,
90 .buffer_bytes_max = 60000,
91 .period_bytes_min = 64,
92 .period_bytes_max = 8192,
93 .periods_min = 1,
94 .periods_max = 1024},
95 .snd_line6_capture_hw = {
96 .info = (SNDRV_PCM_INFO_MMAP |
97 SNDRV_PCM_INFO_INTERLEAVED |
98 SNDRV_PCM_INFO_BLOCK_TRANSFER |
99 SNDRV_PCM_INFO_MMAP_VALID |
100 #ifdef CONFIG_PM
101 SNDRV_PCM_INFO_RESUME |
102 #endif
103 SNDRV_PCM_INFO_SYNC_START),
104 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
105 .rates = SNDRV_PCM_RATE_KNOT,
106 .rate_min = 39062,
107 .rate_max = 39063,
108 .channels_min = 2,
109 .channels_max = 2,
110 .buffer_bytes_max = 60000,
111 .period_bytes_min = 64,
112 .period_bytes_max = 8192,
113 .periods_min = 1,
114 .periods_max = 1024},
115 .snd_line6_rates = {
116 .nrats = 1,
117 .rats = &pod_ratden},
118 .bytes_per_frame = POD_BYTES_PER_FRAME
119 };
120
121 static const char pod_request_channel[] = {
122 0xf0, 0x00, 0x01, 0x0c, 0x03, 0x75, 0xf7
123 };
124
125 static const char pod_version_header[] = {
126 0xf2, 0x7e, 0x7f, 0x06, 0x02
127 };
128
129 /* forward declarations: */
130 static void pod_startup2(unsigned long data);
131 static void pod_startup3(struct usb_line6_pod *pod);
132 static void pod_startup4(struct usb_line6_pod *pod);
133
134 /*
135 Mark all parameters as dirty and notify waiting processes.
136 */
137 static void pod_mark_batch_all_dirty(struct usb_line6_pod *pod)
138 {
139 int i;
140
141 for (i = 0; i < POD_CONTROL_SIZE; i++)
142 set_bit(i, pod->param_dirty);
143 }
144
145 static char *pod_alloc_sysex_buffer(struct usb_line6_pod *pod, int code,
146 int size)
147 {
148 return line6_alloc_sysex_buffer(&pod->line6, POD_SYSEX_CODE, code,
149 size);
150 }
151
152 /*
153 Send channel dump data to the PODxt Pro.
154 */
155 static void pod_dump(struct usb_line6_pod *pod, const unsigned char *data)
156 {
157 int size = 1 + sizeof(pod->prog_data);
158 char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_DUMP, size);
159 if (!sysex)
160 return;
161 /* Don't know what this is good for, but PODxt Pro transmits it, so we
162 * also do... */
163 sysex[SYSEX_DATA_OFS] = 5;
164 memcpy(sysex + SYSEX_DATA_OFS + 1, data, sizeof(pod->prog_data));
165 line6_send_sysex_message(&pod->line6, sysex, size);
166 memcpy(&pod->prog_data, data, sizeof(pod->prog_data));
167 pod_mark_batch_all_dirty(pod);
168 kfree(sysex);
169 }
170
171 /*
172 Store parameter value in driver memory and mark it as dirty.
173 */
174 static void pod_store_parameter(struct usb_line6_pod *pod, int param, int value)
175 {
176 pod->prog_data.control[param] = value;
177 set_bit(param, pod->param_dirty);
178 pod->dirty = 1;
179 }
180
181 /*
182 Handle SAVE button.
183 */
184 static void pod_save_button_pressed(struct usb_line6_pod *pod, int type,
185 int index)
186 {
187 pod->dirty = 0;
188 set_bit(POD_SAVE_PRESSED, &pod->atomic_flags);
189 }
190
191 /*
192 Process a completely received message.
193 */
194 void line6_pod_process_message(struct usb_line6_pod *pod)
195 {
196 const unsigned char *buf = pod->line6.buffer_message;
197
198 /* filter messages by type */
199 switch (buf[0] & 0xf0) {
200 case LINE6_PARAM_CHANGE:
201 case LINE6_PROGRAM_CHANGE:
202 case LINE6_SYSEX_BEGIN:
203 break; /* handle these further down */
204
205 default:
206 return; /* ignore all others */
207 }
208
209 /* process all remaining messages */
210 switch (buf[0]) {
211 case LINE6_PARAM_CHANGE | LINE6_CHANNEL_DEVICE:
212 pod_store_parameter(pod, buf[1], buf[2]);
213 /* intentionally no break here! */
214
215 case LINE6_PARAM_CHANGE | LINE6_CHANNEL_HOST:
216 if ((buf[1] == POD_amp_model_setup) ||
217 (buf[1] == POD_effect_setup))
218 /* these also affect other settings */
219 line6_dump_request_async(&pod->dumpreq, &pod->line6, 0,
220 LINE6_DUMP_CURRENT);
221
222 break;
223
224 case LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_DEVICE:
225 case LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_HOST:
226 pod->channel_num = buf[1];
227 pod->dirty = 0;
228 set_bit(POD_CHANNEL_DIRTY, &pod->atomic_flags);
229 line6_dump_request_async(&pod->dumpreq, &pod->line6, 0,
230 LINE6_DUMP_CURRENT);
231 break;
232
233 case LINE6_SYSEX_BEGIN | LINE6_CHANNEL_DEVICE:
234 case LINE6_SYSEX_BEGIN | LINE6_CHANNEL_UNKNOWN:
235 if (memcmp(buf + 1, line6_midi_id, sizeof(line6_midi_id)) == 0) {
236 switch (buf[5]) {
237 case POD_SYSEX_DUMP:
238 if (pod->line6.message_length ==
239 sizeof(pod->prog_data) + 7) {
240 switch (pod->dumpreq.in_progress) {
241 case LINE6_DUMP_CURRENT:
242 memcpy(&pod->prog_data, buf + 7,
243 sizeof(pod->prog_data));
244 pod_mark_batch_all_dirty(pod);
245 break;
246
247 case POD_DUMP_MEMORY:
248 memcpy(&pod->prog_data_buf,
249 buf + 7,
250 sizeof
251 (pod->prog_data_buf));
252 break;
253
254 default:
255 DEBUG_MESSAGES(dev_err
256 (pod->
257 line6.ifcdev,
258 "unknown dump code %02X\n",
259 pod->
260 dumpreq.in_progress));
261 }
262
263 line6_dump_finished(&pod->dumpreq);
264 pod_startup3(pod);
265 } else
266 DEBUG_MESSAGES(dev_err
267 (pod->line6.ifcdev,
268 "wrong size of channel dump message (%d instead of %d)\n",
269 pod->
270 line6.message_length,
271 (int)
272 sizeof(pod->prog_data) +
273 7));
274
275 break;
276
277 case POD_SYSEX_SYSTEM:{
278 short value =
279 ((int)buf[7] << 12) | ((int)buf[8]
280 << 8) |
281 ((int)buf[9] << 4) | (int)buf[10];
282
283 #define PROCESS_SYSTEM_PARAM(x) \
284 case POD_ ## x: \
285 pod->x.value = value; \
286 wake_up(&pod->x.wait); \
287 break;
288
289 switch (buf[6]) {
290 PROCESS_SYSTEM_PARAM
291 (monitor_level);
292 PROCESS_SYSTEM_PARAM(routing);
293 PROCESS_SYSTEM_PARAM
294 (tuner_mute);
295 PROCESS_SYSTEM_PARAM
296 (tuner_freq);
297 PROCESS_SYSTEM_PARAM
298 (tuner_note);
299 PROCESS_SYSTEM_PARAM
300 (tuner_pitch);
301
302 #undef PROCESS_SYSTEM_PARAM
303
304 default:
305 DEBUG_MESSAGES(dev_err
306 (pod->
307 line6.ifcdev,
308 "unknown tuner/system response %02X\n",
309 buf[6]));
310 }
311
312 break;
313 }
314
315 case POD_SYSEX_FINISH:
316 /* do we need to respond to this? */
317 break;
318
319 case POD_SYSEX_SAVE:
320 pod_save_button_pressed(pod, buf[6], buf[7]);
321 break;
322
323 case POD_SYSEX_CLIP:
324 DEBUG_MESSAGES(dev_err
325 (pod->line6.ifcdev,
326 "audio clipped\n"));
327 pod->clipping.value = 1;
328 wake_up(&pod->clipping.wait);
329 break;
330
331 case POD_SYSEX_STORE:
332 DEBUG_MESSAGES(dev_err
333 (pod->line6.ifcdev,
334 "message %02X not yet implemented\n",
335 buf[5]));
336 break;
337
338 default:
339 DEBUG_MESSAGES(dev_err
340 (pod->line6.ifcdev,
341 "unknown sysex message %02X\n",
342 buf[5]));
343 }
344 } else
345 if (memcmp
346 (buf, pod_version_header,
347 sizeof(pod_version_header)) == 0) {
348 pod->firmware_version =
349 buf[13] * 100 + buf[14] * 10 + buf[15];
350 pod->device_id =
351 ((int)buf[8] << 16) | ((int)buf[9] << 8) | (int)
352 buf[10];
353 pod_startup4(pod);
354 } else
355 DEBUG_MESSAGES(dev_err
356 (pod->line6.ifcdev,
357 "unknown sysex header\n"));
358
359 break;
360
361 case LINE6_SYSEX_END:
362 break;
363
364 default:
365 DEBUG_MESSAGES(dev_err
366 (pod->line6.ifcdev,
367 "POD: unknown message %02X\n", buf[0]));
368 }
369 }
370
371 /*
372 Detect some cases that require a channel dump after sending a command to the
373 device. Important notes:
374 *) The actual dump request can not be sent here since we are not allowed to
375 wait for the completion of the first message in this context, and sending
376 the dump request before completion of the previous message leaves the POD
377 in an undefined state. The dump request will be sent when the echoed
378 commands are received.
379 *) This method fails if a param change message is "chopped" after the first
380 byte.
381 */
382 void line6_pod_midi_postprocess(struct usb_line6_pod *pod, unsigned char *data,
383 int length)
384 {
385 int i;
386
387 if (!pod->midi_postprocess)
388 return;
389
390 for (i = 0; i < length; ++i) {
391 if (data[i] == (LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_HOST)) {
392 line6_invalidate_current(&pod->dumpreq);
393 break;
394 } else
395 if ((data[i] == (LINE6_PARAM_CHANGE | LINE6_CHANNEL_HOST))
396 && (i < length - 1))
397 if ((data[i + 1] == POD_amp_model_setup)
398 || (data[i + 1] == POD_effect_setup)) {
399 line6_invalidate_current(&pod->dumpreq);
400 break;
401 }
402 }
403 }
404
405 /*
406 Send channel number (i.e., switch to a different sound).
407 */
408 static void pod_send_channel(struct usb_line6_pod *pod, int value)
409 {
410 line6_invalidate_current(&pod->dumpreq);
411
412 if (line6_send_program(&pod->line6, value) == 0)
413 pod->channel_num = value;
414 else
415 line6_dump_finished(&pod->dumpreq);
416 }
417
418 /*
419 Transmit PODxt Pro control parameter.
420 */
421 void line6_pod_transmit_parameter(struct usb_line6_pod *pod, int param,
422 int value)
423 {
424 if (line6_transmit_parameter(&pod->line6, param, value) == 0)
425 pod_store_parameter(pod, param, value);
426
427 if ((param == POD_amp_model_setup) || (param == POD_effect_setup)) /* these also affect other settings */
428 line6_invalidate_current(&pod->dumpreq);
429 }
430
431 /*
432 Resolve value to memory location.
433 */
434 static int pod_resolve(const char *buf, short block0, short block1,
435 unsigned char *location)
436 {
437 unsigned long value;
438 short block;
439 int ret;
440
441 ret = strict_strtoul(buf, 10, &value);
442 if (ret)
443 return ret;
444
445 block = (value < 0x40) ? block0 : block1;
446 value &= 0x3f;
447 location[0] = block >> 7;
448 location[1] = value | (block & 0x7f);
449 return 0;
450 }
451
452 /*
453 Send command to store channel/effects setup/amp setup to PODxt Pro.
454 */
455 static ssize_t pod_send_store_command(struct device *dev, const char *buf,
456 size_t count, short block0, short block1)
457 {
458 struct usb_interface *interface = to_usb_interface(dev);
459 struct usb_line6_pod *pod = usb_get_intfdata(interface);
460 int ret;
461 int size = 3 + sizeof(pod->prog_data_buf);
462 char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_STORE, size);
463
464 if (!sysex)
465 return 0;
466
467 sysex[SYSEX_DATA_OFS] = 5; /* see pod_dump() */
468 ret = pod_resolve(buf, block0, block1, sysex + SYSEX_DATA_OFS + 1);
469 if (ret) {
470 kfree(sysex);
471 return ret;
472 }
473
474 memcpy(sysex + SYSEX_DATA_OFS + 3, &pod->prog_data_buf,
475 sizeof(pod->prog_data_buf));
476
477 line6_send_sysex_message(&pod->line6, sysex, size);
478 kfree(sysex);
479 /* needs some delay here on AMD64 platform */
480 return count;
481 }
482
483 /*
484 Send command to retrieve channel/effects setup/amp setup to PODxt Pro.
485 */
486 static ssize_t pod_send_retrieve_command(struct device *dev, const char *buf,
487 size_t count, short block0,
488 short block1)
489 {
490 struct usb_interface *interface = to_usb_interface(dev);
491 struct usb_line6_pod *pod = usb_get_intfdata(interface);
492 int ret;
493 int size = 4;
494 char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_DUMPMEM, size);
495
496 if (!sysex)
497 return 0;
498
499 ret = pod_resolve(buf, block0, block1, sysex + SYSEX_DATA_OFS);
500 if (ret) {
501 kfree(sysex);
502 return ret;
503 }
504 sysex[SYSEX_DATA_OFS + 2] = 0;
505 sysex[SYSEX_DATA_OFS + 3] = 0;
506 line6_dump_started(&pod->dumpreq, POD_DUMP_MEMORY);
507
508 if (line6_send_sysex_message(&pod->line6, sysex, size) < size)
509 line6_dump_finished(&pod->dumpreq);
510
511 kfree(sysex);
512 /* needs some delay here on AMD64 platform */
513 return count;
514 }
515
516 /*
517 Generic get name function.
518 */
519 static ssize_t get_name_generic(struct usb_line6_pod *pod, const char *str,
520 char *buf)
521 {
522 int length = 0;
523 const char *p1;
524 char *p2;
525 char *last_non_space = buf;
526
527 int retval = line6_dump_wait_interruptible(&pod->dumpreq);
528 if (retval < 0)
529 return retval;
530
531 for (p1 = str, p2 = buf; *p1; ++p1, ++p2) {
532 *p2 = *p1;
533 if (*p2 != ' ')
534 last_non_space = p2;
535 if (++length == POD_NAME_LENGTH)
536 break;
537 }
538
539 *(last_non_space + 1) = '\n';
540 return last_non_space - buf + 2;
541 }
542
543 /*
544 "read" request on "channel" special file.
545 */
546 static ssize_t pod_get_channel(struct device *dev,
547 struct device_attribute *attr, char *buf)
548 {
549 struct usb_interface *interface = to_usb_interface(dev);
550 struct usb_line6_pod *pod = usb_get_intfdata(interface);
551 return sprintf(buf, "%d\n", pod->channel_num);
552 }
553
554 /*
555 "write" request on "channel" special file.
556 */
557 static ssize_t pod_set_channel(struct device *dev,
558 struct device_attribute *attr,
559 const char *buf, size_t count)
560 {
561 struct usb_interface *interface = to_usb_interface(dev);
562 struct usb_line6_pod *pod = usb_get_intfdata(interface);
563 unsigned long value;
564 int ret;
565
566 ret = strict_strtoul(buf, 10, &value);
567 if (ret)
568 return ret;
569
570 pod_send_channel(pod, value);
571 return count;
572 }
573
574 /*
575 "read" request on "name" special file.
576 */
577 static ssize_t pod_get_name(struct device *dev, struct device_attribute *attr,
578 char *buf)
579 {
580 struct usb_interface *interface = to_usb_interface(dev);
581 struct usb_line6_pod *pod = usb_get_intfdata(interface);
582 return get_name_generic(pod, pod->prog_data.header + POD_NAME_OFFSET,
583 buf);
584 }
585
586 /*
587 "read" request on "name" special file.
588 */
589 static ssize_t pod_get_name_buf(struct device *dev,
590 struct device_attribute *attr, char *buf)
591 {
592 struct usb_interface *interface = to_usb_interface(dev);
593 struct usb_line6_pod *pod = usb_get_intfdata(interface);
594 return get_name_generic(pod,
595 pod->prog_data_buf.header + POD_NAME_OFFSET,
596 buf);
597 }
598
599 /*
600 "read" request on "dump" special file.
601 */
602 static ssize_t pod_get_dump(struct device *dev, struct device_attribute *attr,
603 char *buf)
604 {
605 struct usb_interface *interface = to_usb_interface(dev);
606 struct usb_line6_pod *pod = usb_get_intfdata(interface);
607 int retval = line6_dump_wait_interruptible(&pod->dumpreq);
608 if (retval < 0)
609 return retval;
610 memcpy(buf, &pod->prog_data, sizeof(pod->prog_data));
611 return sizeof(pod->prog_data);
612 }
613
614 /*
615 "write" request on "dump" special file.
616 */
617 static ssize_t pod_set_dump(struct device *dev, struct device_attribute *attr,
618 const char *buf, size_t count)
619 {
620 struct usb_interface *interface = to_usb_interface(dev);
621 struct usb_line6_pod *pod = usb_get_intfdata(interface);
622
623 if (count != sizeof(pod->prog_data)) {
624 dev_err(pod->line6.ifcdev,
625 "data block must be exactly %d bytes\n",
626 (int)sizeof(pod->prog_data));
627 return -EINVAL;
628 }
629
630 pod_dump(pod, buf);
631 return sizeof(pod->prog_data);
632 }
633
634 /*
635 Identify system parameters related to the tuner.
636 */
637 static bool pod_is_tuner(int code)
638 {
639 return
640 (code == POD_tuner_mute) ||
641 (code == POD_tuner_freq) ||
642 (code == POD_tuner_note) || (code == POD_tuner_pitch);
643 }
644
645 /*
646 Get system parameter (as integer).
647 @param tuner non-zero, if code refers to a tuner parameter
648 */
649 static int pod_get_system_param_int(struct usb_line6_pod *pod, int *value,
650 int code, struct ValueWait *param, int sign)
651 {
652 char *sysex;
653 static const int size = 1;
654 int retval = 0;
655
656 if (((pod->prog_data.control[POD_tuner] & 0x40) == 0)
657 && pod_is_tuner(code))
658 return -ENODEV;
659
660 /* send value request to device: */
661 param->value = POD_system_invalid;
662 sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_SYSTEMREQ, size);
663
664 if (!sysex)
665 return -ENOMEM;
666
667 sysex[SYSEX_DATA_OFS] = code;
668 line6_send_sysex_message(&pod->line6, sysex, size);
669 kfree(sysex);
670
671 /* wait for device to respond: */
672 retval =
673 wait_event_interruptible(param->wait,
674 param->value != POD_system_invalid);
675
676 if (retval < 0)
677 return retval;
678
679 *value = sign ? (int)(signed short)param->value : (int)(unsigned short)
680 param->value;
681
682 if (*value == POD_system_invalid)
683 *value = 0; /* don't report uninitialized values */
684
685 return 0;
686 }
687
688 /*
689 Get system parameter (as string).
690 @param tuner non-zero, if code refers to a tuner parameter
691 */
692 static ssize_t pod_get_system_param_string(struct usb_line6_pod *pod, char *buf,
693 int code, struct ValueWait *param,
694 int sign)
695 {
696 int retval, value = 0;
697 retval = pod_get_system_param_int(pod, &value, code, param, sign);
698
699 if (retval < 0)
700 return retval;
701
702 return sprintf(buf, "%d\n", value);
703 }
704
705 /*
706 Send system parameter (from integer).
707 @param tuner non-zero, if code refers to a tuner parameter
708 */
709 static int pod_set_system_param_int(struct usb_line6_pod *pod, int value,
710 int code)
711 {
712 char *sysex;
713 static const int size = 5;
714
715 if (((pod->prog_data.control[POD_tuner] & 0x40) == 0)
716 && pod_is_tuner(code))
717 return -EINVAL;
718
719 /* send value to tuner: */
720 sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_SYSTEM, size);
721 if (!sysex)
722 return -ENOMEM;
723 sysex[SYSEX_DATA_OFS] = code;
724 sysex[SYSEX_DATA_OFS + 1] = (value >> 12) & 0x0f;
725 sysex[SYSEX_DATA_OFS + 2] = (value >> 8) & 0x0f;
726 sysex[SYSEX_DATA_OFS + 3] = (value >> 4) & 0x0f;
727 sysex[SYSEX_DATA_OFS + 4] = (value) & 0x0f;
728 line6_send_sysex_message(&pod->line6, sysex, size);
729 kfree(sysex);
730 return 0;
731 }
732
733 /*
734 Send system parameter (from string).
735 @param tuner non-zero, if code refers to a tuner parameter
736 */
737 static ssize_t pod_set_system_param_string(struct usb_line6_pod *pod,
738 const char *buf, int count, int code,
739 unsigned short mask)
740 {
741 int retval;
742 unsigned short value = simple_strtoul(buf, NULL, 10) & mask;
743 retval = pod_set_system_param_int(pod, value, code);
744 return (retval < 0) ? retval : count;
745 }
746
747 /*
748 "read" request on "dump_buf" special file.
749 */
750 static ssize_t pod_get_dump_buf(struct device *dev,
751 struct device_attribute *attr, char *buf)
752 {
753 struct usb_interface *interface = to_usb_interface(dev);
754 struct usb_line6_pod *pod = usb_get_intfdata(interface);
755 int retval = line6_dump_wait_interruptible(&pod->dumpreq);
756 if (retval < 0)
757 return retval;
758 memcpy(buf, &pod->prog_data_buf, sizeof(pod->prog_data_buf));
759 return sizeof(pod->prog_data_buf);
760 }
761
762 /*
763 "write" request on "dump_buf" special file.
764 */
765 static ssize_t pod_set_dump_buf(struct device *dev,
766 struct device_attribute *attr,
767 const char *buf, size_t count)
768 {
769 struct usb_interface *interface = to_usb_interface(dev);
770 struct usb_line6_pod *pod = usb_get_intfdata(interface);
771
772 if (count != sizeof(pod->prog_data)) {
773 dev_err(pod->line6.ifcdev,
774 "data block must be exactly %d bytes\n",
775 (int)sizeof(pod->prog_data));
776 return -EINVAL;
777 }
778
779 memcpy(&pod->prog_data_buf, buf, sizeof(pod->prog_data));
780 return sizeof(pod->prog_data);
781 }
782
783 /*
784 "write" request on "finish" special file.
785 */
786 static ssize_t pod_set_finish(struct device *dev,
787 struct device_attribute *attr,
788 const char *buf, size_t count)
789 {
790 struct usb_interface *interface = to_usb_interface(dev);
791 struct usb_line6_pod *pod = usb_get_intfdata(interface);
792 int size = 0;
793 char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_FINISH, size);
794 if (!sysex)
795 return 0;
796 line6_send_sysex_message(&pod->line6, sysex, size);
797 kfree(sysex);
798 return count;
799 }
800
801 /*
802 "write" request on "store_channel" special file.
803 */
804 static ssize_t pod_set_store_channel(struct device *dev,
805 struct device_attribute *attr,
806 const char *buf, size_t count)
807 {
808 return pod_send_store_command(dev, buf, count, 0x0000, 0x00c0);
809 }
810
811 /*
812 "write" request on "store_effects_setup" special file.
813 */
814 static ssize_t pod_set_store_effects_setup(struct device *dev,
815 struct device_attribute *attr,
816 const char *buf, size_t count)
817 {
818 return pod_send_store_command(dev, buf, count, 0x0080, 0x0080);
819 }
820
821 /*
822 "write" request on "store_amp_setup" special file.
823 */
824 static ssize_t pod_set_store_amp_setup(struct device *dev,
825 struct device_attribute *attr,
826 const char *buf, size_t count)
827 {
828 return pod_send_store_command(dev, buf, count, 0x0040, 0x0100);
829 }
830
831 /*
832 "write" request on "retrieve_channel" special file.
833 */
834 static ssize_t pod_set_retrieve_channel(struct device *dev,
835 struct device_attribute *attr,
836 const char *buf, size_t count)
837 {
838 return pod_send_retrieve_command(dev, buf, count, 0x0000, 0x00c0);
839 }
840
841 /*
842 "write" request on "retrieve_effects_setup" special file.
843 */
844 static ssize_t pod_set_retrieve_effects_setup(struct device *dev,
845 struct device_attribute *attr,
846 const char *buf, size_t count)
847 {
848 return pod_send_retrieve_command(dev, buf, count, 0x0080, 0x0080);
849 }
850
851 /*
852 "write" request on "retrieve_amp_setup" special file.
853 */
854 static ssize_t pod_set_retrieve_amp_setup(struct device *dev,
855 struct device_attribute *attr,
856 const char *buf, size_t count)
857 {
858 return pod_send_retrieve_command(dev, buf, count, 0x0040, 0x0100);
859 }
860
861 /*
862 "read" request on "dirty" special file.
863 */
864 static ssize_t pod_get_dirty(struct device *dev, struct device_attribute *attr,
865 char *buf)
866 {
867 struct usb_interface *interface = to_usb_interface(dev);
868 struct usb_line6_pod *pod = usb_get_intfdata(interface);
869 buf[0] = pod->dirty ? '1' : '0';
870 buf[1] = '\n';
871 return 2;
872 }
873
874 /*
875 "read" request on "midi_postprocess" special file.
876 */
877 static ssize_t pod_get_midi_postprocess(struct device *dev,
878 struct device_attribute *attr,
879 char *buf)
880 {
881 struct usb_interface *interface = to_usb_interface(dev);
882 struct usb_line6_pod *pod = usb_get_intfdata(interface);
883 return sprintf(buf, "%d\n", pod->midi_postprocess);
884 }
885
886 /*
887 "write" request on "midi_postprocess" special file.
888 */
889 static ssize_t pod_set_midi_postprocess(struct device *dev,
890 struct device_attribute *attr,
891 const char *buf, size_t count)
892 {
893 struct usb_interface *interface = to_usb_interface(dev);
894 struct usb_line6_pod *pod = usb_get_intfdata(interface);
895 unsigned long value;
896 int ret;
897
898 ret = strict_strtoul(buf, 10, &value);
899 if (ret)
900 return ret;
901
902 pod->midi_postprocess = value ? 1 : 0;
903 return count;
904 }
905
906 /*
907 "read" request on "serial_number" special file.
908 */
909 static ssize_t pod_get_serial_number(struct device *dev,
910 struct device_attribute *attr, char *buf)
911 {
912 struct usb_interface *interface = to_usb_interface(dev);
913 struct usb_line6_pod *pod = usb_get_intfdata(interface);
914 return sprintf(buf, "%d\n", pod->serial_number);
915 }
916
917 /*
918 "read" request on "firmware_version" special file.
919 */
920 static ssize_t pod_get_firmware_version(struct device *dev,
921 struct device_attribute *attr,
922 char *buf)
923 {
924 struct usb_interface *interface = to_usb_interface(dev);
925 struct usb_line6_pod *pod = usb_get_intfdata(interface);
926 return sprintf(buf, "%d.%02d\n", pod->firmware_version / 100,
927 pod->firmware_version % 100);
928 }
929
930 /*
931 "read" request on "device_id" special file.
932 */
933 static ssize_t pod_get_device_id(struct device *dev,
934 struct device_attribute *attr, char *buf)
935 {
936 struct usb_interface *interface = to_usb_interface(dev);
937 struct usb_line6_pod *pod = usb_get_intfdata(interface);
938 return sprintf(buf, "%d\n", pod->device_id);
939 }
940
941 /*
942 "read" request on "clip" special file.
943 */
944 static ssize_t pod_wait_for_clip(struct device *dev,
945 struct device_attribute *attr, char *buf)
946 {
947 struct usb_interface *interface = to_usb_interface(dev);
948 struct usb_line6_pod *pod = usb_get_intfdata(interface);
949 return wait_event_interruptible(pod->clipping.wait,
950 pod->clipping.value != 0);
951 }
952
953 /*
954 POD startup procedure.
955 This is a sequence of functions with special requirements (e.g., must
956 not run immediately after initialization, must not run in interrupt
957 context). After the last one has finished, the device is ready to use.
958 */
959
960 static void pod_startup1(struct usb_line6_pod *pod)
961 {
962 CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_INIT);
963
964 /* delay startup procedure: */
965 line6_start_timer(&pod->startup_timer, POD_STARTUP_DELAY, pod_startup2,
966 (unsigned long)pod);
967 }
968
969 static void pod_startup2(unsigned long data)
970 {
971 struct usb_line6_pod *pod = (struct usb_line6_pod *)data;
972
973 /* schedule another startup procedure until startup is complete: */
974 if (pod->startup_progress >= POD_STARTUP_LAST)
975 return;
976
977 pod->startup_progress = POD_STARTUP_DUMPREQ;
978 line6_start_timer(&pod->startup_timer, POD_STARTUP_DELAY, pod_startup2,
979 (unsigned long)pod);
980
981 /* current channel dump: */
982 line6_dump_request_async(&pod->dumpreq, &pod->line6, 0,
983 LINE6_DUMP_CURRENT);
984 }
985
986 static void pod_startup3(struct usb_line6_pod *pod)
987 {
988 struct usb_line6 *line6 = &pod->line6;
989 CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_VERSIONREQ);
990
991 /* request firmware version: */
992 line6_version_request_async(line6);
993 }
994
995 static void pod_startup4(struct usb_line6_pod *pod)
996 {
997 CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_WORKQUEUE);
998
999 /* schedule work for global work queue: */
1000 schedule_work(&pod->startup_work);
1001 }
1002
1003 static void pod_startup5(struct work_struct *work)
1004 {
1005 struct usb_line6_pod *pod =
1006 container_of(work, struct usb_line6_pod, startup_work);
1007 struct usb_line6 *line6 = &pod->line6;
1008
1009 CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_SETUP);
1010
1011 /* serial number: */
1012 line6_read_serial_number(&pod->line6, &pod->serial_number);
1013
1014 /* ALSA audio interface: */
1015 line6_register_audio(line6);
1016
1017 /* device files: */
1018 line6_pod_create_files(pod->firmware_version,
1019 line6->properties->device_bit, line6->ifcdev);
1020 }
1021
1022 #define POD_GET_SYSTEM_PARAM(code, sign) \
1023 static ssize_t pod_get_ ## code(struct device *dev, \
1024 struct device_attribute *attr, char *buf) \
1025 { \
1026 struct usb_interface *interface = to_usb_interface(dev); \
1027 struct usb_line6_pod *pod = usb_get_intfdata(interface); \
1028 return pod_get_system_param_string(pod, buf, POD_ ## code, \
1029 &pod->code, sign); \
1030 }
1031
1032 #define POD_GET_SET_SYSTEM_PARAM(code, mask, sign) \
1033 POD_GET_SYSTEM_PARAM(code, sign) \
1034 static ssize_t pod_set_ ## code(struct device *dev, \
1035 struct device_attribute *attr, \
1036 const char *buf, size_t count) \
1037 { \
1038 struct usb_interface *interface = to_usb_interface(dev); \
1039 struct usb_line6_pod *pod = usb_get_intfdata(interface); \
1040 return pod_set_system_param_string(pod, buf, count, POD_ ## code, mask); \
1041 }
1042
1043 POD_GET_SET_SYSTEM_PARAM(monitor_level, 0xffff, 0);
1044 POD_GET_SET_SYSTEM_PARAM(routing, 0x0003, 0);
1045 POD_GET_SET_SYSTEM_PARAM(tuner_mute, 0x0001, 0);
1046 POD_GET_SET_SYSTEM_PARAM(tuner_freq, 0xffff, 0);
1047 POD_GET_SYSTEM_PARAM(tuner_note, 1);
1048 POD_GET_SYSTEM_PARAM(tuner_pitch, 1);
1049
1050 #undef GET_SET_SYSTEM_PARAM
1051 #undef GET_SYSTEM_PARAM
1052
1053 /* POD special files: */
1054 static DEVICE_ATTR(channel, S_IWUSR | S_IRUGO, pod_get_channel,
1055 pod_set_channel);
1056 static DEVICE_ATTR(clip, S_IRUGO, pod_wait_for_clip, line6_nop_write);
1057 static DEVICE_ATTR(device_id, S_IRUGO, pod_get_device_id, line6_nop_write);
1058 static DEVICE_ATTR(dirty, S_IRUGO, pod_get_dirty, line6_nop_write);
1059 static DEVICE_ATTR(dump, S_IWUSR | S_IRUGO, pod_get_dump, pod_set_dump);
1060 static DEVICE_ATTR(dump_buf, S_IWUSR | S_IRUGO, pod_get_dump_buf,
1061 pod_set_dump_buf);
1062 static DEVICE_ATTR(finish, S_IWUSR, line6_nop_read, pod_set_finish);
1063 static DEVICE_ATTR(firmware_version, S_IRUGO, pod_get_firmware_version,
1064 line6_nop_write);
1065 static DEVICE_ATTR(midi_postprocess, S_IWUSR | S_IRUGO,
1066 pod_get_midi_postprocess, pod_set_midi_postprocess);
1067 static DEVICE_ATTR(monitor_level, S_IWUSR | S_IRUGO, pod_get_monitor_level,
1068 pod_set_monitor_level);
1069 static DEVICE_ATTR(name, S_IRUGO, pod_get_name, line6_nop_write);
1070 static DEVICE_ATTR(name_buf, S_IRUGO, pod_get_name_buf, line6_nop_write);
1071 static DEVICE_ATTR(retrieve_amp_setup, S_IWUSR, line6_nop_read,
1072 pod_set_retrieve_amp_setup);
1073 static DEVICE_ATTR(retrieve_channel, S_IWUSR, line6_nop_read,
1074 pod_set_retrieve_channel);
1075 static DEVICE_ATTR(retrieve_effects_setup, S_IWUSR, line6_nop_read,
1076 pod_set_retrieve_effects_setup);
1077 static DEVICE_ATTR(routing, S_IWUSR | S_IRUGO, pod_get_routing,
1078 pod_set_routing);
1079 static DEVICE_ATTR(serial_number, S_IRUGO, pod_get_serial_number,
1080 line6_nop_write);
1081 static DEVICE_ATTR(store_amp_setup, S_IWUSR, line6_nop_read,
1082 pod_set_store_amp_setup);
1083 static DEVICE_ATTR(store_channel, S_IWUSR, line6_nop_read,
1084 pod_set_store_channel);
1085 static DEVICE_ATTR(store_effects_setup, S_IWUSR, line6_nop_read,
1086 pod_set_store_effects_setup);
1087 static DEVICE_ATTR(tuner_freq, S_IWUSR | S_IRUGO, pod_get_tuner_freq,
1088 pod_set_tuner_freq);
1089 static DEVICE_ATTR(tuner_mute, S_IWUSR | S_IRUGO, pod_get_tuner_mute,
1090 pod_set_tuner_mute);
1091 static DEVICE_ATTR(tuner_note, S_IRUGO, pod_get_tuner_note, line6_nop_write);
1092 static DEVICE_ATTR(tuner_pitch, S_IRUGO, pod_get_tuner_pitch, line6_nop_write);
1093
1094 #ifdef CONFIG_LINE6_USB_RAW
1095 static DEVICE_ATTR(raw, S_IWUSR, line6_nop_read, line6_set_raw);
1096 #endif
1097
1098 /* control info callback */
1099 static int snd_pod_control_monitor_info(struct snd_kcontrol *kcontrol,
1100 struct snd_ctl_elem_info *uinfo)
1101 {
1102 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1103 uinfo->count = 1;
1104 uinfo->value.integer.min = 0;
1105 uinfo->value.integer.max = 65535;
1106 return 0;
1107 }
1108
1109 /* control get callback */
1110 static int snd_pod_control_monitor_get(struct snd_kcontrol *kcontrol,
1111 struct snd_ctl_elem_value *ucontrol)
1112 {
1113 struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
1114 struct usb_line6_pod *pod = (struct usb_line6_pod *)line6pcm->line6;
1115 ucontrol->value.integer.value[0] = pod->monitor_level.value;
1116 return 0;
1117 }
1118
1119 /* control put callback */
1120 static int snd_pod_control_monitor_put(struct snd_kcontrol *kcontrol,
1121 struct snd_ctl_elem_value *ucontrol)
1122 {
1123 struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
1124 struct usb_line6_pod *pod = (struct usb_line6_pod *)line6pcm->line6;
1125
1126 if (ucontrol->value.integer.value[0] == pod->monitor_level.value)
1127 return 0;
1128
1129 pod->monitor_level.value = ucontrol->value.integer.value[0];
1130 pod_set_system_param_int(pod, ucontrol->value.integer.value[0],
1131 POD_monitor_level);
1132 return 1;
1133 }
1134
1135 /* control definition */
1136 static struct snd_kcontrol_new pod_control_monitor = {
1137 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1138 .name = "Monitor Playback Volume",
1139 .index = 0,
1140 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1141 .info = snd_pod_control_monitor_info,
1142 .get = snd_pod_control_monitor_get,
1143 .put = snd_pod_control_monitor_put
1144 };
1145
1146 /*
1147 POD destructor.
1148 */
1149 static void pod_destruct(struct usb_interface *interface)
1150 {
1151 struct usb_line6_pod *pod = usb_get_intfdata(interface);
1152
1153 if (pod == NULL)
1154 return;
1155 line6_cleanup_audio(&pod->line6);
1156
1157 del_timer(&pod->startup_timer);
1158 cancel_work_sync(&pod->startup_work);
1159
1160 /* free dump request data: */
1161 line6_dumpreq_destruct(&pod->dumpreq);
1162 }
1163
1164 /*
1165 Create sysfs entries.
1166 */
1167 static int pod_create_files2(struct device *dev)
1168 {
1169 int err;
1170
1171 CHECK_RETURN(device_create_file(dev, &dev_attr_channel));
1172 CHECK_RETURN(device_create_file(dev, &dev_attr_clip));
1173 CHECK_RETURN(device_create_file(dev, &dev_attr_device_id));
1174 CHECK_RETURN(device_create_file(dev, &dev_attr_dirty));
1175 CHECK_RETURN(device_create_file(dev, &dev_attr_dump));
1176 CHECK_RETURN(device_create_file(dev, &dev_attr_dump_buf));
1177 CHECK_RETURN(device_create_file(dev, &dev_attr_finish));
1178 CHECK_RETURN(device_create_file(dev, &dev_attr_firmware_version));
1179 CHECK_RETURN(device_create_file(dev, &dev_attr_midi_postprocess));
1180 CHECK_RETURN(device_create_file(dev, &dev_attr_monitor_level));
1181 CHECK_RETURN(device_create_file(dev, &dev_attr_name));
1182 CHECK_RETURN(device_create_file(dev, &dev_attr_name_buf));
1183 CHECK_RETURN(device_create_file(dev, &dev_attr_retrieve_amp_setup));
1184 CHECK_RETURN(device_create_file(dev, &dev_attr_retrieve_channel));
1185 CHECK_RETURN(device_create_file(dev, &dev_attr_retrieve_effects_setup));
1186 CHECK_RETURN(device_create_file(dev, &dev_attr_routing));
1187 CHECK_RETURN(device_create_file(dev, &dev_attr_serial_number));
1188 CHECK_RETURN(device_create_file(dev, &dev_attr_store_amp_setup));
1189 CHECK_RETURN(device_create_file(dev, &dev_attr_store_channel));
1190 CHECK_RETURN(device_create_file(dev, &dev_attr_store_effects_setup));
1191 CHECK_RETURN(device_create_file(dev, &dev_attr_tuner_freq));
1192 CHECK_RETURN(device_create_file(dev, &dev_attr_tuner_mute));
1193 CHECK_RETURN(device_create_file(dev, &dev_attr_tuner_note));
1194 CHECK_RETURN(device_create_file(dev, &dev_attr_tuner_pitch));
1195
1196 #ifdef CONFIG_LINE6_USB_RAW
1197 CHECK_RETURN(device_create_file(dev, &dev_attr_raw));
1198 #endif
1199
1200 return 0;
1201 }
1202
1203 /*
1204 Try to init POD device.
1205 */
1206 static int pod_try_init(struct usb_interface *interface,
1207 struct usb_line6_pod *pod)
1208 {
1209 int err;
1210 struct usb_line6 *line6 = &pod->line6;
1211
1212 init_timer(&pod->startup_timer);
1213 INIT_WORK(&pod->startup_work, pod_startup5);
1214
1215 if ((interface == NULL) || (pod == NULL))
1216 return -ENODEV;
1217
1218 pod->channel_num = 255;
1219
1220 /* initialize wait queues: */
1221 init_waitqueue_head(&pod->monitor_level.wait);
1222 init_waitqueue_head(&pod->routing.wait);
1223 init_waitqueue_head(&pod->tuner_mute.wait);
1224 init_waitqueue_head(&pod->tuner_freq.wait);
1225 init_waitqueue_head(&pod->tuner_note.wait);
1226 init_waitqueue_head(&pod->tuner_pitch.wait);
1227 init_waitqueue_head(&pod->clipping.wait);
1228
1229 memset(pod->param_dirty, 0xff, sizeof(pod->param_dirty));
1230
1231 /* initialize USB buffers: */
1232 err = line6_dumpreq_init(&pod->dumpreq, pod_request_channel,
1233 sizeof(pod_request_channel));
1234 if (err < 0) {
1235 dev_err(&interface->dev, "Out of memory\n");
1236 return -ENOMEM;
1237 }
1238
1239 /* create sysfs entries: */
1240 err = pod_create_files2(&interface->dev);
1241 if (err < 0)
1242 return err;
1243
1244 /* initialize audio system: */
1245 err = line6_init_audio(line6);
1246 if (err < 0)
1247 return err;
1248
1249 /* initialize MIDI subsystem: */
1250 err = line6_init_midi(line6);
1251 if (err < 0)
1252 return err;
1253
1254 /* initialize PCM subsystem: */
1255 err = line6_init_pcm(line6, &pod_pcm_properties);
1256 if (err < 0)
1257 return err;
1258
1259 /* register monitor control: */
1260 err = snd_ctl_add(line6->card,
1261 snd_ctl_new1(&pod_control_monitor, line6->line6pcm));
1262 if (err < 0)
1263 return err;
1264
1265 /*
1266 When the sound card is registered at this point, the PODxt Live
1267 displays "Invalid Code Error 07", so we do it later in the event
1268 handler.
1269 */
1270
1271 if (pod->line6.properties->capabilities & LINE6_BIT_CONTROL) {
1272 pod->monitor_level.value = POD_system_invalid;
1273
1274 /* initiate startup procedure: */
1275 pod_startup1(pod);
1276 }
1277
1278 return 0;
1279 }
1280
1281 /*
1282 Init POD device (and clean up in case of failure).
1283 */
1284 int line6_pod_init(struct usb_interface *interface, struct usb_line6_pod *pod)
1285 {
1286 int err = pod_try_init(interface, pod);
1287
1288 if (err < 0)
1289 pod_destruct(interface);
1290
1291 return err;
1292 }
1293
1294 /*
1295 POD device disconnected.
1296 */
1297 void line6_pod_disconnect(struct usb_interface *interface)
1298 {
1299 struct usb_line6_pod *pod;
1300
1301 if (interface == NULL)
1302 return;
1303 pod = usb_get_intfdata(interface);
1304
1305 if (pod != NULL) {
1306 struct snd_line6_pcm *line6pcm = pod->line6.line6pcm;
1307 struct device *dev = &interface->dev;
1308
1309 if (line6pcm != NULL)
1310 line6_pcm_disconnect(line6pcm);
1311
1312 if (dev != NULL) {
1313 /* remove sysfs entries: */
1314 line6_pod_remove_files(pod->firmware_version,
1315 pod->line6.
1316 properties->device_bit, dev);
1317
1318 device_remove_file(dev, &dev_attr_channel);
1319 device_remove_file(dev, &dev_attr_clip);
1320 device_remove_file(dev, &dev_attr_device_id);
1321 device_remove_file(dev, &dev_attr_dirty);
1322 device_remove_file(dev, &dev_attr_dump);
1323 device_remove_file(dev, &dev_attr_dump_buf);
1324 device_remove_file(dev, &dev_attr_finish);
1325 device_remove_file(dev, &dev_attr_firmware_version);
1326 device_remove_file(dev, &dev_attr_midi_postprocess);
1327 device_remove_file(dev, &dev_attr_monitor_level);
1328 device_remove_file(dev, &dev_attr_name);
1329 device_remove_file(dev, &dev_attr_name_buf);
1330 device_remove_file(dev, &dev_attr_retrieve_amp_setup);
1331 device_remove_file(dev, &dev_attr_retrieve_channel);
1332 device_remove_file(dev,
1333 &dev_attr_retrieve_effects_setup);
1334 device_remove_file(dev, &dev_attr_routing);
1335 device_remove_file(dev, &dev_attr_serial_number);
1336 device_remove_file(dev, &dev_attr_store_amp_setup);
1337 device_remove_file(dev, &dev_attr_store_channel);
1338 device_remove_file(dev, &dev_attr_store_effects_setup);
1339 device_remove_file(dev, &dev_attr_tuner_freq);
1340 device_remove_file(dev, &dev_attr_tuner_mute);
1341 device_remove_file(dev, &dev_attr_tuner_note);
1342 device_remove_file(dev, &dev_attr_tuner_pitch);
1343
1344 #ifdef CONFIG_LINE6_USB_RAW
1345 device_remove_file(dev, &dev_attr_raw);
1346 #endif
1347 }
1348 }
1349
1350 pod_destruct(interface);
1351 }
Linux with added FPC-III support