Root/drivers/staging/line6/pod.c

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
28enum {
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
42enum {
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
54enum {
55    POD_DUMP_MEMORY = 2
56};
57
58enum {
59    POD_BUSY_READ,
60    POD_BUSY_WRITE,
61    POD_CHANNEL_DIRTY,
62    POD_SAVE_PRESSED,
63    POD_BUSY_MIDISEND
64};
65
66static struct snd_ratden pod_ratden = {
67    .num_min = 78125,
68    .num_max = 78125,
69    .num_step = 1,
70    .den = 2
71};
72
73static 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
121static const char pod_request_channel[] = {
122    0xf0, 0x00, 0x01, 0x0c, 0x03, 0x75, 0xf7
123};
124
125static const char pod_version_header[] = {
126    0xf2, 0x7e, 0x7f, 0x06, 0x02
127};
128
129/* forward declarations: */
130static void pod_startup2(unsigned long data);
131static void pod_startup3(struct usb_line6_pod *pod);
132static void pod_startup4(struct usb_line6_pod *pod);
133
134/*
135    Mark all parameters as dirty and notify waiting processes.
136*/
137static 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
145static 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*/
155static 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*/
174static 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*/
184static 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*/
194void 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*/
382void 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*/
408static void pod_send_channel(struct usb_line6_pod *pod, u8 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*/
421void line6_pod_transmit_parameter(struct usb_line6_pod *pod, int param,
422                  u8 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*/
434static int pod_resolve(const char *buf, short block0, short block1,
435               unsigned char *location)
436{
437    u8 value;
438    short block;
439    int ret;
440
441    ret = kstrtou8(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*/
455static 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*/
486static 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*/
519static 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*/
546static 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*/
557static 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    u8 value;
564    int ret;
565
566    ret = kstrtou8(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*/
577static 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*/
589static 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*/
602static 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*/
617static 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*/
637static 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*/
649static 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*/
692static 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*/
709static 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*/
737static 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*/
750static 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*/
765static 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*/
786static 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*/
804static 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*/
814static 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*/
824static 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*/
834static 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*/
844static 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*/
854static 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*/
864static 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*/
877static 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*/
889static 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    u8 value;
896    int ret;
897
898    ret = kstrtou8(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*/
909static 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*/
920static 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*/
933static 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*/
944static 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
960static 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
969static 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
986static 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
995static 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
1003static 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) \
1023static 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) \
1033POD_GET_SYSTEM_PARAM(code, sign) \
1034static 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
1043POD_GET_SET_SYSTEM_PARAM(monitor_level, 0xffff, 0);
1044POD_GET_SET_SYSTEM_PARAM(routing, 0x0003, 0);
1045POD_GET_SET_SYSTEM_PARAM(tuner_mute, 0x0001, 0);
1046POD_GET_SET_SYSTEM_PARAM(tuner_freq, 0xffff, 0);
1047POD_GET_SYSTEM_PARAM(tuner_note, 1);
1048POD_GET_SYSTEM_PARAM(tuner_pitch, 1);
1049
1050#undef GET_SET_SYSTEM_PARAM
1051#undef GET_SYSTEM_PARAM
1052
1053/* POD special files: */
1054static DEVICE_ATTR(channel, S_IWUSR | S_IRUGO, pod_get_channel,
1055           pod_set_channel);
1056static DEVICE_ATTR(clip, S_IRUGO, pod_wait_for_clip, line6_nop_write);
1057static DEVICE_ATTR(device_id, S_IRUGO, pod_get_device_id, line6_nop_write);
1058static DEVICE_ATTR(dirty, S_IRUGO, pod_get_dirty, line6_nop_write);
1059static DEVICE_ATTR(dump, S_IWUSR | S_IRUGO, pod_get_dump, pod_set_dump);
1060static DEVICE_ATTR(dump_buf, S_IWUSR | S_IRUGO, pod_get_dump_buf,
1061           pod_set_dump_buf);
1062static DEVICE_ATTR(finish, S_IWUSR, line6_nop_read, pod_set_finish);
1063static DEVICE_ATTR(firmware_version, S_IRUGO, pod_get_firmware_version,
1064           line6_nop_write);
1065static DEVICE_ATTR(midi_postprocess, S_IWUSR | S_IRUGO,
1066           pod_get_midi_postprocess, pod_set_midi_postprocess);
1067static DEVICE_ATTR(monitor_level, S_IWUSR | S_IRUGO, pod_get_monitor_level,
1068           pod_set_monitor_level);
1069static DEVICE_ATTR(name, S_IRUGO, pod_get_name, line6_nop_write);
1070static DEVICE_ATTR(name_buf, S_IRUGO, pod_get_name_buf, line6_nop_write);
1071static DEVICE_ATTR(retrieve_amp_setup, S_IWUSR, line6_nop_read,
1072           pod_set_retrieve_amp_setup);
1073static DEVICE_ATTR(retrieve_channel, S_IWUSR, line6_nop_read,
1074           pod_set_retrieve_channel);
1075static DEVICE_ATTR(retrieve_effects_setup, S_IWUSR, line6_nop_read,
1076           pod_set_retrieve_effects_setup);
1077static DEVICE_ATTR(routing, S_IWUSR | S_IRUGO, pod_get_routing,
1078           pod_set_routing);
1079static DEVICE_ATTR(serial_number, S_IRUGO, pod_get_serial_number,
1080           line6_nop_write);
1081static DEVICE_ATTR(store_amp_setup, S_IWUSR, line6_nop_read,
1082           pod_set_store_amp_setup);
1083static DEVICE_ATTR(store_channel, S_IWUSR, line6_nop_read,
1084           pod_set_store_channel);
1085static DEVICE_ATTR(store_effects_setup, S_IWUSR, line6_nop_read,
1086           pod_set_store_effects_setup);
1087static DEVICE_ATTR(tuner_freq, S_IWUSR | S_IRUGO, pod_get_tuner_freq,
1088           pod_set_tuner_freq);
1089static DEVICE_ATTR(tuner_mute, S_IWUSR | S_IRUGO, pod_get_tuner_mute,
1090           pod_set_tuner_mute);
1091static DEVICE_ATTR(tuner_note, S_IRUGO, pod_get_tuner_note, line6_nop_write);
1092static DEVICE_ATTR(tuner_pitch, S_IRUGO, pod_get_tuner_pitch, line6_nop_write);
1093
1094#ifdef CONFIG_LINE6_USB_RAW
1095static DEVICE_ATTR(raw, S_IWUSR, line6_nop_read, line6_set_raw);
1096#endif
1097
1098/* control info callback */
1099static 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 */
1110static 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 */
1120static 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 */
1136static 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*/
1149static 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*/
1167static 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*/
1206static 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*/
1284int 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*/
1297void 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}
1352

Archive Download this file



interactive