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