2 * Line6 Linux USB driver - 0.8.0
4 * Copyright (C) 2004-2009 Markus Grabner (grabner@icg.tugraz.at)
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.
21 #define POD_SYSEX_CODE 3
22 #define POD_BYTES_PER_FRAME 6 /* 24bit audio (stereo) */
26 POD_SYSEX_CLIP = 0x0f,
27 POD_SYSEX_SAVE = 0x24,
28 POD_SYSEX_SYSTEM = 0x56,
29 POD_SYSEX_SYSTEMREQ = 0x57,
30 /* POD_SYSEX_UPDATE = 0x6c, */ /* software update! */
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 /* POD_SYSEX_DUMPMEM2 = 0x76 */ /* dumps entire internal memory of PODxt Pro */
40 POD_monitor_level = 0x04,
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
62 static struct snd_ratden pod_ratden = {
69 static 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,
83 .buffer_bytes_max = 60000,
84 .period_bytes_min = LINE6_ISO_PACKET_SIZE_MAX * POD_BYTES_PER_FRAME, /* at least one URB must fit into one period */
85 .period_bytes_max = 8192,
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,
101 .buffer_bytes_max = 60000,
102 .period_bytes_min = LINE6_ISO_PACKET_SIZE_MAX * POD_BYTES_PER_FRAME, /* at least one URB must fit into one period */
103 .period_bytes_max = 8192,
111 .bytes_per_frame = POD_BYTES_PER_FRAME
114 static const char pod_request_version[] = { 0xf0, 0x7e, 0x7f, 0x06, 0x01, 0xf7 };
115 static const char pod_request_channel[] = { 0xf0, 0x00, 0x01, 0x0c, 0x03, 0x75, 0xf7 };
116 static const char pod_version_header[] = { 0xf2, 0x7e, 0x7f, 0x06, 0x02 };
120 Mark all parameters as dirty and notify waiting processes.
122 static void pod_mark_batch_all_dirty(struct usb_line6_pod *pod)
126 for (i = 0; i < POD_CONTROL_SIZE; i++)
127 set_bit(i, pod->param_dirty);
131 Send an asynchronous request for the POD firmware version and device ID.
133 static int pod_version_request_async(struct usb_line6_pod *pod)
135 return line6_send_raw_message_async(&pod->line6, pod->buffer_versionreq, sizeof(pod_request_version));
138 static void pod_create_files_work(struct work_struct *work)
140 struct usb_line6_pod *pod = container_of(work, struct usb_line6_pod, create_files_work);
142 pod_create_files(pod->firmware_version, pod->line6.properties->device_bit, pod->line6.ifcdev);
145 static void pod_startup_timeout(unsigned long arg)
153 int request = REQUEST_NONE;
154 struct usb_line6_pod *pod = (struct usb_line6_pod *)arg;
156 if (pod->dumpreq.ok) {
157 if (!pod->versionreq_ok)
158 request = REQUEST_VERSION;
160 if (pod->versionreq_ok)
161 request = REQUEST_DUMP;
162 else if (pod->startup_count++ & 1)
163 request = REQUEST_DUMP;
165 request = REQUEST_VERSION;
170 line6_dump_request_async(&pod->dumpreq, &pod->line6, 0);
173 case REQUEST_VERSION:
174 pod_version_request_async(pod);
181 line6_startup_delayed(&pod->dumpreq, 1, pod_startup_timeout, pod);
184 static char *pod_alloc_sysex_buffer(struct usb_line6_pod *pod, int code, int size)
186 return line6_alloc_sysex_buffer(&pod->line6, POD_SYSEX_CODE, code, size);
190 Send channel dump data to the PODxt Pro.
192 static void pod_dump(struct usb_line6_pod *pod, const unsigned char *data)
194 int size = 1 + sizeof(pod->prog_data);
195 char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_DUMP, size);
198 /* Don't know what this is good for, but PODxt Pro transmits it, so we
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);
209 Store parameter value in driver memory and mark it as dirty.
211 static void pod_store_parameter(struct usb_line6_pod *pod, int param, int value)
213 pod->prog_data.control[param] = value;
214 set_bit(param, pod->param_dirty);
221 static void pod_save_button_pressed(struct usb_line6_pod *pod, int type, int index)
224 set_bit(POD_SAVE_PRESSED, &pod->atomic_flags);
228 Process a completely received message.
230 void pod_process_message(struct usb_line6_pod *pod)
232 const unsigned char *buf = pod->line6.buffer_message;
234 /* filter messages by type */
235 switch (buf[0] & 0xf0) {
236 case LINE6_PARAM_CHANGE:
237 case LINE6_PROGRAM_CHANGE:
238 case LINE6_SYSEX_BEGIN:
239 break; /* handle these further down */
242 return; /* ignore all others */
245 /* process all remaining messages */
247 case LINE6_PARAM_CHANGE | LINE6_CHANNEL_DEVICE:
248 pod_store_parameter(pod, buf[1], buf[2]);
249 /* intentionally no break here! */
251 case LINE6_PARAM_CHANGE | LINE6_CHANNEL_HOST:
252 if ((buf[1] == POD_amp_model_setup) ||
253 (buf[1] == POD_effect_setup))
254 /* these also affect other settings */
255 line6_dump_request_async(&pod->dumpreq, &pod->line6, 0);
259 case LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_DEVICE:
260 case LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_HOST:
261 pod->channel_num = buf[1];
263 set_bit(POD_CHANNEL_DIRTY, &pod->atomic_flags);
264 line6_dump_request_async(&pod->dumpreq, &pod->line6, 0);
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) {
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);
280 case POD_DUMP_MEMORY:
281 memcpy(&pod->prog_data_buf, buf + 7, sizeof(pod->prog_data_buf));
285 DEBUG_MESSAGES(dev_err(pod->line6.ifcdev, "unknown dump code %02X\n", pod->dumpreq.in_progress));
288 line6_dump_finished(&pod->dumpreq);
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));
295 case POD_SYSEX_SYSTEM: {
296 short value = ((int)buf[7] << 12) | ((int)buf[8] << 8) | ((int)buf[9] << 4) | (int)buf[10];
298 #define PROCESS_SYSTEM_PARAM(x) \
300 pod->x.value = value; \
301 wake_up_interruptible(&pod->x.wait); \
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);
312 #undef PROCESS_SYSTEM_PARAM
315 DEBUG_MESSAGES(dev_err(pod->line6.ifcdev, "unknown tuner/system response %02X\n", buf[6]));
321 case POD_SYSEX_FINISH:
322 /* do we need to respond to this? */
326 pod_save_button_pressed(pod, buf[6], buf[7]);
330 DEBUG_MESSAGES(dev_err(pod->line6.ifcdev, "audio clipped\n"));
331 pod->clipping.value = 1;
332 wake_up_interruptible(&pod->clipping.wait);
335 case POD_SYSEX_STORE:
336 DEBUG_MESSAGES(dev_err(pod->line6.ifcdev, "message %02X not yet implemented\n", buf[5]));
340 DEBUG_MESSAGES(dev_err(pod->line6.ifcdev, "unknown sysex message %02X\n", buf[5]));
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;
348 /* Now we know the firmware version, so we schedule a bottom half
349 handler to create the special files: */
350 INIT_WORK(&pod->create_files_work, pod_create_files_work);
351 queue_work(line6_workqueue, &pod->create_files_work);
353 DEBUG_MESSAGES(dev_err(pod->line6.ifcdev, "multiple firmware version message\n"));
355 DEBUG_MESSAGES(dev_err(pod->line6.ifcdev, "unknown sysex header\n"));
359 case LINE6_SYSEX_END:
363 DEBUG_MESSAGES(dev_err(pod->line6.ifcdev, "POD: unknown message %02X\n", buf[0]));
368 Detect some cases that require a channel dump after sending a command to the
369 device. Important notes:
370 *) The actual dump request can not be sent here since we are not allowed to
371 wait for the completion of the first message in this context, and sending
372 the dump request before completion of the previous message leaves the POD
373 in an undefined state. The dump request will be sent when the echoed
374 commands are received.
375 *) This method fails if a param change message is "chopped" after the first
378 void pod_midi_postprocess(struct usb_line6_pod *pod, unsigned char *data, int length)
382 if (!pod->midi_postprocess)
385 for (i = 0; i < length; ++i) {
386 if (data[i] == (LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_HOST)) {
387 line6_invalidate_current(&pod->dumpreq);
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);
398 Send channel number (i.e., switch to a different sound).
400 static void pod_send_channel(struct usb_line6_pod *pod, int value)
402 line6_invalidate_current(&pod->dumpreq);
404 if (line6_send_program(&pod->line6, value) == 0)
405 pod->channel_num = value;
407 line6_dump_finished(&pod->dumpreq);
411 Transmit PODxt Pro control parameter.
413 void pod_transmit_parameter(struct usb_line6_pod *pod, int param, int value)
415 if (line6_transmit_parameter(&pod->line6, param, value) == 0)
416 pod_store_parameter(pod, param, value);
418 if ((param == POD_amp_model_setup) || (param == POD_effect_setup)) /* these also affect other settings */
419 line6_invalidate_current(&pod->dumpreq);
423 Resolve value to memory location.
425 static int pod_resolve(const char *buf, short block0, short block1, unsigned char *location)
431 ret = strict_strtoul(buf, 10, &value);
435 block = (value < 0x40) ? block0 : block1;
437 location[0] = block >> 7;
438 location[1] = value | (block & 0x7f);
443 Send command to store channel/effects setup/amp setup to PODxt Pro.
445 static ssize_t pod_send_store_command(struct device *dev, const char *buf, size_t count, short block0, short block1)
447 struct usb_interface *interface = to_usb_interface(dev);
448 struct usb_line6_pod *pod = usb_get_intfdata(interface);
450 int size = 3 + sizeof(pod->prog_data_buf);
451 char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_STORE, size);
456 sysex[SYSEX_DATA_OFS] = 5; /* see pod_dump() */
457 ret = pod_resolve(buf, block0, block1, sysex + SYSEX_DATA_OFS + 1);
463 memcpy(sysex + SYSEX_DATA_OFS + 3, &pod->prog_data_buf, sizeof(pod->prog_data_buf));
465 line6_send_sysex_message(&pod->line6, sysex, size);
467 /* needs some delay here on AMD64 platform */
472 Send command to retrieve channel/effects setup/amp setup to PODxt Pro.
474 static ssize_t pod_send_retrieve_command(struct device *dev, const char *buf, size_t count, short block0, short block1)
476 struct usb_interface *interface = to_usb_interface(dev);
477 struct usb_line6_pod *pod = usb_get_intfdata(interface);
480 char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_DUMPMEM, size);
485 ret = pod_resolve(buf, block0, block1, sysex + SYSEX_DATA_OFS);
490 sysex[SYSEX_DATA_OFS + 2] = 0;
491 sysex[SYSEX_DATA_OFS + 3] = 0;
492 line6_dump_started(&pod->dumpreq, POD_DUMP_MEMORY);
494 if (line6_send_sysex_message(&pod->line6, sysex, size) < size)
495 line6_dump_finished(&pod->dumpreq);
498 /* needs some delay here on AMD64 platform */
503 Generic get name function.
505 static ssize_t get_name_generic(struct usb_line6_pod *pod, const char *str, char *buf)
510 char *last_non_space = buf;
512 int retval = line6_wait_dump(&pod->dumpreq, 0);
516 for (p1 = str, p2 = buf; *p1; ++p1, ++p2) {
520 if (++length == POD_NAME_LENGTH)
524 *(last_non_space + 1) = '\n';
525 return last_non_space - buf + 2;
529 "read" request on "channel" special file.
531 static ssize_t pod_get_channel(struct device *dev,
532 struct device_attribute *attr, char *buf)
534 struct usb_interface *interface = to_usb_interface(dev);
535 struct usb_line6_pod *pod = usb_get_intfdata(interface);
536 return sprintf(buf, "%d\n", pod->channel_num);
540 "write" request on "channel" special file.
542 static ssize_t pod_set_channel(struct device *dev,
543 struct device_attribute *attr,
544 const char *buf, size_t count)
546 struct usb_interface *interface = to_usb_interface(dev);
547 struct usb_line6_pod *pod = usb_get_intfdata(interface);
551 ret = strict_strtoul(buf, 10, &value);
555 pod_send_channel(pod, value);
560 "read" request on "name" special file.
562 static ssize_t pod_get_name(struct device *dev, struct device_attribute *attr,
565 struct usb_interface *interface = to_usb_interface(dev);
566 struct usb_line6_pod *pod = usb_get_intfdata(interface);
567 return get_name_generic(pod, pod->prog_data.header + POD_NAME_OFFSET, buf);
571 "read" request on "name" special file.
573 static ssize_t pod_get_name_buf(struct device *dev,
574 struct device_attribute *attr, char *buf)
576 struct usb_interface *interface = to_usb_interface(dev);
577 struct usb_line6_pod *pod = usb_get_intfdata(interface);
578 return get_name_generic(pod, pod->prog_data_buf.header + POD_NAME_OFFSET, buf);
582 "read" request on "dump" special file.
584 static ssize_t pod_get_dump(struct device *dev, struct device_attribute *attr,
587 struct usb_interface *interface = to_usb_interface(dev);
588 struct usb_line6_pod *pod = usb_get_intfdata(interface);
589 int retval = line6_wait_dump(&pod->dumpreq, 0);
592 memcpy(buf, &pod->prog_data, sizeof(pod->prog_data));
593 return sizeof(pod->prog_data);
597 "write" request on "dump" special file.
599 static ssize_t pod_set_dump(struct device *dev, struct device_attribute *attr,
600 const char *buf, size_t count)
602 struct usb_interface *interface = to_usb_interface(dev);
603 struct usb_line6_pod *pod = usb_get_intfdata(interface);
605 if (count != sizeof(pod->prog_data)) {
606 dev_err(pod->line6.ifcdev,
607 "data block must be exactly %zu bytes\n",
608 sizeof(pod->prog_data));
613 return sizeof(pod->prog_data);
617 Request system parameter.
618 @param tuner non-zero, if code refers to a tuner parameter
620 static ssize_t pod_get_system_param(struct usb_line6_pod *pod, char *buf, int code, struct ValueWait *param, int tuner, int sign)
624 static const int size = 1;
626 DECLARE_WAITQUEUE(wait, current);
628 if (((pod->prog_data.control[POD_tuner] & 0x40) == 0) && tuner)
631 /* send value request to tuner: */
632 param->value = POD_system_invalid;
633 sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_SYSTEMREQ, size);
636 sysex[SYSEX_DATA_OFS] = code;
637 line6_send_sysex_message(&pod->line6, sysex, size);
640 /* wait for tuner to respond: */
641 add_wait_queue(¶m->wait, &wait);
642 current->state = TASK_INTERRUPTIBLE;
644 while (param->value == POD_system_invalid) {
645 if (signal_pending(current)) {
646 retval = -ERESTARTSYS;
652 current->state = TASK_RUNNING;
653 remove_wait_queue(¶m->wait, &wait);
658 value = sign ? (int)(signed short)param->value : (int)(unsigned short)param->value;
659 return sprintf(buf, "%d\n", value);
663 Send system parameter.
664 @param tuner non-zero, if code refers to a tuner parameter
666 static ssize_t pod_set_system_param(struct usb_line6_pod *pod, const char *buf,
667 int count, int code, unsigned short mask,
671 static const int size = 5;
672 unsigned short value;
673 unsigned long result;
676 if (((pod->prog_data.control[POD_tuner] & 0x40) == 0) && tuner)
679 /* send value to tuner: */
680 sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_SYSTEM, size);
684 ret = strict_strtoul(buf, 10, &result);
688 value = result & mask;
689 sysex[SYSEX_DATA_OFS] = code;
690 sysex[SYSEX_DATA_OFS + 1] = (value >> 12) & 0x0f;
691 sysex[SYSEX_DATA_OFS + 2] = (value >> 8) & 0x0f;
692 sysex[SYSEX_DATA_OFS + 3] = (value >> 4) & 0x0f;
693 sysex[SYSEX_DATA_OFS + 4] = (value ) & 0x0f;
694 line6_send_sysex_message(&pod->line6, sysex, size);
700 "read" request on "dump_buf" special file.
702 static ssize_t pod_get_dump_buf(struct device *dev,
703 struct device_attribute *attr, char *buf)
705 struct usb_interface *interface = to_usb_interface(dev);
706 struct usb_line6_pod *pod = usb_get_intfdata(interface);
707 int retval = line6_wait_dump(&pod->dumpreq, 0);
710 memcpy(buf, &pod->prog_data_buf, sizeof(pod->prog_data_buf));
711 return sizeof(pod->prog_data_buf);
715 "write" request on "dump_buf" special file.
717 static ssize_t pod_set_dump_buf(struct device *dev,
718 struct device_attribute *attr,
719 const char *buf, size_t count)
721 struct usb_interface *interface = to_usb_interface(dev);
722 struct usb_line6_pod *pod = usb_get_intfdata(interface);
724 if (count != sizeof(pod->prog_data)) {
725 dev_err(pod->line6.ifcdev,
726 "data block must be exactly %zu bytes\n",
727 sizeof(pod->prog_data));
731 memcpy(&pod->prog_data_buf, buf, sizeof(pod->prog_data));
732 return sizeof(pod->prog_data);
736 "write" request on "finish" special file.
738 static ssize_t pod_set_finish(struct device *dev,
739 struct device_attribute *attr,
740 const char *buf, size_t count)
742 struct usb_interface *interface = to_usb_interface(dev);
743 struct usb_line6_pod *pod = usb_get_intfdata(interface);
745 char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_FINISH, size);
748 line6_send_sysex_message(&pod->line6, sysex, size);
754 "write" request on "store_channel" special file.
756 static ssize_t pod_set_store_channel(struct device *dev,
757 struct device_attribute *attr,
758 const char *buf, size_t count)
760 return pod_send_store_command(dev, buf, count, 0x0000, 0x00c0);
764 "write" request on "store_effects_setup" special file.
766 static ssize_t pod_set_store_effects_setup(struct device *dev,
767 struct device_attribute *attr,
768 const char *buf, size_t count)
770 return pod_send_store_command(dev, buf, count, 0x0080, 0x0080);
774 "write" request on "store_amp_setup" special file.
776 static ssize_t pod_set_store_amp_setup(struct device *dev,
777 struct device_attribute *attr,
778 const char *buf, size_t count)
780 return pod_send_store_command(dev, buf, count, 0x0040, 0x0100);
784 "write" request on "retrieve_channel" special file.
786 static ssize_t pod_set_retrieve_channel(struct device *dev,
787 struct device_attribute *attr,
788 const char *buf, size_t count)
790 return pod_send_retrieve_command(dev, buf, count, 0x0000, 0x00c0);
794 "write" request on "retrieve_effects_setup" special file.
796 static ssize_t pod_set_retrieve_effects_setup(struct device *dev,
797 struct device_attribute *attr,
798 const char *buf, size_t count)
800 return pod_send_retrieve_command(dev, buf, count, 0x0080, 0x0080);
804 "write" request on "retrieve_amp_setup" special file.
806 static ssize_t pod_set_retrieve_amp_setup(struct device *dev,
807 struct device_attribute *attr,
808 const char *buf, size_t count)
810 return pod_send_retrieve_command(dev, buf, count, 0x0040, 0x0100);
814 "read" request on "dirty" special file.
816 static ssize_t pod_get_dirty(struct device *dev, struct device_attribute *attr,
819 struct usb_interface *interface = to_usb_interface(dev);
820 struct usb_line6_pod *pod = usb_get_intfdata(interface);
821 buf[0] = pod->dirty ? '1' : '0';
827 "read" request on "midi_postprocess" special file.
829 static ssize_t pod_get_midi_postprocess(struct device *dev,
830 struct device_attribute *attr,
833 struct usb_interface *interface = to_usb_interface(dev);
834 struct usb_line6_pod *pod = usb_get_intfdata(interface);
835 return sprintf(buf, "%d\n", pod->midi_postprocess);
839 "write" request on "midi_postprocess" special file.
841 static ssize_t pod_set_midi_postprocess(struct device *dev,
842 struct device_attribute *attr,
843 const char *buf, size_t count)
845 struct usb_interface *interface = to_usb_interface(dev);
846 struct usb_line6_pod *pod = usb_get_intfdata(interface);
850 ret = strict_strtoul(buf, 10, &value);
854 pod->midi_postprocess = value ? 1 : 0;
859 "read" request on "serial_number" special file.
861 static ssize_t pod_get_serial_number(struct device *dev,
862 struct device_attribute *attr, char *buf)
864 struct usb_interface *interface = to_usb_interface(dev);
865 struct usb_line6_pod *pod = usb_get_intfdata(interface);
866 return sprintf(buf, "%d\n", pod->serial_number);
870 "read" request on "firmware_version" special file.
872 static ssize_t pod_get_firmware_version(struct device *dev,
873 struct device_attribute *attr,
876 struct usb_interface *interface = to_usb_interface(dev);
877 struct usb_line6_pod *pod = usb_get_intfdata(interface);
878 return sprintf(buf, "%d.%02d\n", pod->firmware_version / 100,
879 pod->firmware_version % 100);
883 "read" request on "device_id" special file.
885 static ssize_t pod_get_device_id(struct device *dev,
886 struct device_attribute *attr, char *buf)
888 struct usb_interface *interface = to_usb_interface(dev);
889 struct usb_line6_pod *pod = usb_get_intfdata(interface);
890 return sprintf(buf, "%d\n", pod->device_id);
894 "read" request on "clip" special file.
896 static ssize_t pod_wait_for_clip(struct device *dev,
897 struct device_attribute *attr, char *buf)
899 struct usb_interface *interface = to_usb_interface(dev);
900 struct usb_line6_pod *pod = usb_get_intfdata(interface);
902 DECLARE_WAITQUEUE(wait, current);
903 pod->clipping.value = 0;
904 add_wait_queue(&pod->clipping.wait, &wait);
905 current->state = TASK_INTERRUPTIBLE;
907 while (pod->clipping.value == 0) {
908 if (signal_pending(current)) {
915 current->state = TASK_RUNNING;
916 remove_wait_queue(&pod->clipping.wait, &wait);
920 #define POD_GET_SYSTEM_PARAM(code, tuner, sign) \
921 static ssize_t pod_get_ ## code(struct device *dev, \
922 struct device_attribute *attr, char *buf) \
924 struct usb_interface *interface = to_usb_interface(dev); \
925 struct usb_line6_pod *pod = usb_get_intfdata(interface); \
926 return pod_get_system_param(pod, buf, POD_ ## code, &pod->code, \
930 #define POD_GET_SET_SYSTEM_PARAM(code, mask, tuner, sign) \
931 POD_GET_SYSTEM_PARAM(code, tuner, sign) \
932 static ssize_t pod_set_ ## code(struct device *dev, \
933 struct device_attribute *attr, \
934 const char *buf, size_t count) \
936 struct usb_interface *interface = to_usb_interface(dev); \
937 struct usb_line6_pod *pod = usb_get_intfdata(interface); \
938 return pod_set_system_param(pod, buf, count, POD_ ## code, mask, \
942 POD_GET_SET_SYSTEM_PARAM(monitor_level, 0xffff, 0, 0);
943 POD_GET_SET_SYSTEM_PARAM(routing, 0x0003, 0, 0);
944 POD_GET_SET_SYSTEM_PARAM(tuner_mute, 0x0001, 1, 0);
945 POD_GET_SET_SYSTEM_PARAM(tuner_freq, 0xffff, 1, 0);
946 POD_GET_SYSTEM_PARAM(tuner_note, 1, 1);
947 POD_GET_SYSTEM_PARAM(tuner_pitch, 1, 1);
949 #undef GET_SET_SYSTEM_PARAM
950 #undef GET_SYSTEM_PARAM
952 /* POD special files: */
953 static DEVICE_ATTR(channel, S_IWUGO | S_IRUGO, pod_get_channel, pod_set_channel);
954 static DEVICE_ATTR(clip, S_IRUGO, pod_wait_for_clip, line6_nop_write);
955 static DEVICE_ATTR(device_id, S_IRUGO, pod_get_device_id, line6_nop_write);
956 static DEVICE_ATTR(dirty, S_IRUGO, pod_get_dirty, line6_nop_write);
957 static DEVICE_ATTR(dump, S_IWUGO | S_IRUGO, pod_get_dump, pod_set_dump);
958 static DEVICE_ATTR(dump_buf, S_IWUGO | S_IRUGO, pod_get_dump_buf, pod_set_dump_buf);
959 static DEVICE_ATTR(finish, S_IWUGO, line6_nop_read, pod_set_finish);
960 static DEVICE_ATTR(firmware_version, S_IRUGO, pod_get_firmware_version, line6_nop_write);
961 static DEVICE_ATTR(midi_postprocess, S_IWUGO | S_IRUGO, pod_get_midi_postprocess, pod_set_midi_postprocess);
962 static DEVICE_ATTR(monitor_level, S_IWUGO | S_IRUGO, pod_get_monitor_level, pod_set_monitor_level);
963 static DEVICE_ATTR(name, S_IRUGO, pod_get_name, line6_nop_write);
964 static DEVICE_ATTR(name_buf, S_IRUGO, pod_get_name_buf, line6_nop_write);
965 static DEVICE_ATTR(retrieve_amp_setup, S_IWUGO, line6_nop_read, pod_set_retrieve_amp_setup);
966 static DEVICE_ATTR(retrieve_channel, S_IWUGO, line6_nop_read, pod_set_retrieve_channel);
967 static DEVICE_ATTR(retrieve_effects_setup, S_IWUGO, line6_nop_read, pod_set_retrieve_effects_setup);
968 static DEVICE_ATTR(routing, S_IWUGO | S_IRUGO, pod_get_routing, pod_set_routing);
969 static DEVICE_ATTR(serial_number, S_IRUGO, pod_get_serial_number, line6_nop_write);
970 static DEVICE_ATTR(store_amp_setup, S_IWUGO, line6_nop_read, pod_set_store_amp_setup);
971 static DEVICE_ATTR(store_channel, S_IWUGO, line6_nop_read, pod_set_store_channel);
972 static DEVICE_ATTR(store_effects_setup, S_IWUGO, line6_nop_read, pod_set_store_effects_setup);
973 static DEVICE_ATTR(tuner_freq, S_IWUGO | S_IRUGO, pod_get_tuner_freq, pod_set_tuner_freq);
974 static DEVICE_ATTR(tuner_mute, S_IWUGO | S_IRUGO, pod_get_tuner_mute, pod_set_tuner_mute);
975 static DEVICE_ATTR(tuner_note, S_IRUGO, pod_get_tuner_note, line6_nop_write);
976 static DEVICE_ATTR(tuner_pitch, S_IRUGO, pod_get_tuner_pitch, line6_nop_write);
979 static DEVICE_ATTR(raw, S_IWUGO, line6_nop_read, line6_set_raw);
985 static void pod_destruct(struct usb_interface *interface)
987 struct usb_line6_pod *pod = usb_get_intfdata(interface);
988 struct usb_line6 *line6;
995 line6_cleanup_audio(line6);
997 /* free dump request data: */
998 line6_dumpreq_destruct(&pod->dumpreq);
1000 kfree(pod->buffer_versionreq);
1004 Create sysfs entries.
1006 static int pod_create_files2(struct device *dev)
1010 CHECK_RETURN(device_create_file(dev, &dev_attr_channel));
1011 CHECK_RETURN(device_create_file(dev, &dev_attr_clip));
1012 CHECK_RETURN(device_create_file(dev, &dev_attr_device_id));
1013 CHECK_RETURN(device_create_file(dev, &dev_attr_dirty));
1014 CHECK_RETURN(device_create_file(dev, &dev_attr_dump));
1015 CHECK_RETURN(device_create_file(dev, &dev_attr_dump_buf));
1016 CHECK_RETURN(device_create_file(dev, &dev_attr_finish));
1017 CHECK_RETURN(device_create_file(dev, &dev_attr_firmware_version));
1018 CHECK_RETURN(device_create_file(dev, &dev_attr_midi_postprocess));
1019 CHECK_RETURN(device_create_file(dev, &dev_attr_monitor_level));
1020 CHECK_RETURN(device_create_file(dev, &dev_attr_name));
1021 CHECK_RETURN(device_create_file(dev, &dev_attr_name_buf));
1022 CHECK_RETURN(device_create_file(dev, &dev_attr_retrieve_amp_setup));
1023 CHECK_RETURN(device_create_file(dev, &dev_attr_retrieve_channel));
1024 CHECK_RETURN(device_create_file(dev, &dev_attr_retrieve_effects_setup));
1025 CHECK_RETURN(device_create_file(dev, &dev_attr_routing));
1026 CHECK_RETURN(device_create_file(dev, &dev_attr_serial_number));
1027 CHECK_RETURN(device_create_file(dev, &dev_attr_store_amp_setup));
1028 CHECK_RETURN(device_create_file(dev, &dev_attr_store_channel));
1029 CHECK_RETURN(device_create_file(dev, &dev_attr_store_effects_setup));
1030 CHECK_RETURN(device_create_file(dev, &dev_attr_tuner_freq));
1031 CHECK_RETURN(device_create_file(dev, &dev_attr_tuner_mute));
1032 CHECK_RETURN(device_create_file(dev, &dev_attr_tuner_note));
1033 CHECK_RETURN(device_create_file(dev, &dev_attr_tuner_pitch));
1036 CHECK_RETURN(device_create_file(dev, &dev_attr_raw));
1045 int pod_init(struct usb_interface *interface, struct usb_line6_pod *pod)
1048 struct usb_line6 *line6 = &pod->line6;
1050 if ((interface == NULL) || (pod == NULL))
1053 pod->channel_num = 255;
1055 /* initialize wait queues: */
1056 init_waitqueue_head(&pod->monitor_level.wait);
1057 init_waitqueue_head(&pod->routing.wait);
1058 init_waitqueue_head(&pod->tuner_mute.wait);
1059 init_waitqueue_head(&pod->tuner_freq.wait);
1060 init_waitqueue_head(&pod->tuner_note.wait);
1061 init_waitqueue_head(&pod->tuner_pitch.wait);
1062 init_waitqueue_head(&pod->clipping.wait);
1064 memset(pod->param_dirty, 0xff, sizeof(pod->param_dirty));
1066 /* initialize USB buffers: */
1067 err = line6_dumpreq_init(&pod->dumpreq, pod_request_channel,
1068 sizeof(pod_request_channel));
1070 dev_err(&interface->dev, "Out of memory\n");
1071 pod_destruct(interface);
1075 pod->buffer_versionreq = kmalloc(sizeof(pod_request_version),
1078 if (pod->buffer_versionreq == NULL) {
1079 dev_err(&interface->dev, "Out of memory\n");
1080 pod_destruct(interface);
1084 memcpy(pod->buffer_versionreq, pod_request_version,
1085 sizeof(pod_request_version));
1087 /* create sysfs entries: */
1088 err = pod_create_files2(&interface->dev);
1090 pod_destruct(interface);
1094 /* initialize audio system: */
1095 err = line6_init_audio(line6);
1097 pod_destruct(interface);
1101 /* initialize MIDI subsystem: */
1102 err = line6_init_midi(line6);
1104 pod_destruct(interface);
1108 /* initialize PCM subsystem: */
1109 err = line6_init_pcm(line6, &pod_pcm_properties);
1111 pod_destruct(interface);
1115 /* register audio system: */
1116 err = line6_register_audio(line6);
1118 pod_destruct(interface);
1122 if (pod->line6.properties->capabilities & LINE6_BIT_CONTROL) {
1123 /* query some data: */
1124 line6_startup_delayed(&pod->dumpreq, POD_STARTUP_DELAY,
1125 pod_startup_timeout, pod);
1126 line6_read_serial_number(&pod->line6, &pod->serial_number);
1133 POD device disconnected.
1135 void pod_disconnect(struct usb_interface *interface)
1137 struct usb_line6_pod *pod;
1139 if (interface == NULL)
1141 pod = usb_get_intfdata(interface);
1144 struct snd_line6_pcm *line6pcm = pod->line6.line6pcm;
1145 struct device *dev = &interface->dev;
1147 if (line6pcm != NULL) {
1148 unlink_wait_clear_audio_out_urbs(line6pcm);
1149 unlink_wait_clear_audio_in_urbs(line6pcm);
1153 /* remove sysfs entries: */
1154 if (pod->versionreq_ok)
1155 pod_remove_files(pod->firmware_version, pod->line6.properties->device_bit, dev);
1157 device_remove_file(dev, &dev_attr_channel);
1158 device_remove_file(dev, &dev_attr_clip);
1159 device_remove_file(dev, &dev_attr_device_id);
1160 device_remove_file(dev, &dev_attr_dirty);
1161 device_remove_file(dev, &dev_attr_dump);
1162 device_remove_file(dev, &dev_attr_dump_buf);
1163 device_remove_file(dev, &dev_attr_finish);
1164 device_remove_file(dev, &dev_attr_firmware_version);
1165 device_remove_file(dev, &dev_attr_midi_postprocess);
1166 device_remove_file(dev, &dev_attr_monitor_level);
1167 device_remove_file(dev, &dev_attr_name);
1168 device_remove_file(dev, &dev_attr_name_buf);
1169 device_remove_file(dev, &dev_attr_retrieve_amp_setup);
1170 device_remove_file(dev, &dev_attr_retrieve_channel);
1171 device_remove_file(dev, &dev_attr_retrieve_effects_setup);
1172 device_remove_file(dev, &dev_attr_routing);
1173 device_remove_file(dev, &dev_attr_serial_number);
1174 device_remove_file(dev, &dev_attr_store_amp_setup);
1175 device_remove_file(dev, &dev_attr_store_channel);
1176 device_remove_file(dev, &dev_attr_store_effects_setup);
1177 device_remove_file(dev, &dev_attr_tuner_freq);
1178 device_remove_file(dev, &dev_attr_tuner_mute);
1179 device_remove_file(dev, &dev_attr_tuner_note);
1180 device_remove_file(dev, &dev_attr_tuner_pitch);
1183 device_remove_file(dev, &dev_attr_raw);
1188 pod_destruct(interface);