?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
iwlwifi: fix skb usage after free
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / staging / line6 / pod.c
blobb9b58aae3ae2a48241e810485ba5d7e5514c6a90
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 int pod_resolve(const char *buf, short block0, short block1, unsigned char *location)
426 {
427 unsigned long value;
428 short block;
429 int ret;
430
431 ret = strict_strtoul(buf, 10, &value);
432 if (ret)
433 return ret;
434
435 block = (value < 0x40) ? block0 : block1;
436 value &= 0x3f;
437 location[0] = block >> 7;
438 location[1] = value | (block & 0x7f);
439 return 0;
440 }
441
442 /*
443 Send command to store channel/effects setup/amp setup to PODxt Pro.
444 */
445 static ssize_t pod_send_store_command(struct device *dev, const char *buf, size_t count, short block0, short block1)
446 {
447 struct usb_interface *interface = to_usb_interface(dev);
448 struct usb_line6_pod *pod = usb_get_intfdata(interface);
449 int ret;
450 int size = 3 + sizeof(pod->prog_data_buf);
451 char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_STORE, size);
452
453 if (!sysex)
454 return 0;
455
456 sysex[SYSEX_DATA_OFS] = 5; /* see pod_dump() */
457 ret = pod_resolve(buf, block0, block1, sysex + SYSEX_DATA_OFS + 1);
458 if (ret) {
459 kfree(sysex);
460 return ret;
461 }
462
463 memcpy(sysex + SYSEX_DATA_OFS + 3, &pod->prog_data_buf, sizeof(pod->prog_data_buf));
464
465 line6_send_sysex_message(&pod->line6, sysex, size);
466 kfree(sysex);
467 /* needs some delay here on AMD64 platform */
468 return count;
469 }
470
471 /*
472 Send command to retrieve channel/effects setup/amp setup to PODxt Pro.
473 */
474 static ssize_t pod_send_retrieve_command(struct device *dev, const char *buf, size_t count, short block0, short block1)
475 {
476 struct usb_interface *interface = to_usb_interface(dev);
477 struct usb_line6_pod *pod = usb_get_intfdata(interface);
478 int ret;
479 int size = 4;
480 char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_DUMPMEM, size);
481
482 if (!sysex)
483 return 0;
484
485 ret = pod_resolve(buf, block0, block1, sysex + SYSEX_DATA_OFS);
486 if (ret) {
487 kfree(sysex);
488 return ret;
489 }
490 sysex[SYSEX_DATA_OFS + 2] = 0;
491 sysex[SYSEX_DATA_OFS + 3] = 0;
492 line6_dump_started(&pod->dumpreq, POD_DUMP_MEMORY);
493
494 if (line6_send_sysex_message(&pod->line6, sysex, size) < size)
495 line6_dump_finished(&pod->dumpreq);
496
497 kfree(sysex);
498 /* needs some delay here on AMD64 platform */
499 return count;
500 }
501
502 /*
503 Generic get name function.
504 */
505 static ssize_t get_name_generic(struct usb_line6_pod *pod, const char *str, char *buf)
506 {
507 int length = 0;
508 const char *p1;
509 char *p2;
510 char *last_non_space = buf;
511
512 int retval = line6_wait_dump(&pod->dumpreq, 0);
513 if (retval < 0)
514 return retval;
515
516 for (p1 = str, p2 = buf; *p1; ++p1, ++p2) {
517 *p2 = *p1;
518 if (*p2 != ' ')
519 last_non_space = p2;
520 if (++length == POD_NAME_LENGTH)
521 break;
522 }
523
524 *(last_non_space + 1) = '\n';
525 return last_non_space - buf + 2;
526 }
527
528 /*
529 "read" request on "channel" special file.
530 */
531 static ssize_t pod_get_channel(struct device *dev,
532 struct device_attribute *attr, char *buf)
533 {
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);
537 }
538
539 /*
540 "write" request on "channel" special file.
541 */
542 static ssize_t pod_set_channel(struct device *dev,
543 struct device_attribute *attr,
544 const char *buf, size_t count)
545 {
546 struct usb_interface *interface = to_usb_interface(dev);
547 struct usb_line6_pod *pod = usb_get_intfdata(interface);
548 unsigned long value;
549 int ret;
550
551 ret = strict_strtoul(buf, 10, &value);
552 if (ret)
553 return ret;
554
555 pod_send_channel(pod, value);
556 return count;
557 }
558
559 /*
560 "read" request on "name" special file.
561 */
562 static ssize_t pod_get_name(struct device *dev, struct device_attribute *attr,
563 char *buf)
564 {
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);
568 }
569
570 /*
571 "read" request on "name" special file.
572 */
573 static ssize_t pod_get_name_buf(struct device *dev,
574 struct device_attribute *attr, char *buf)
575 {
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);
579 }
580
581 /*
582 "read" request on "dump" special file.
583 */
584 static ssize_t pod_get_dump(struct device *dev, struct device_attribute *attr,
585 char *buf)
586 {
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);
590 if (retval < 0)
591 return retval;
592 memcpy(buf, &pod->prog_data, sizeof(pod->prog_data));
593 return sizeof(pod->prog_data);
594 }
595
596 /*
597 "write" request on "dump" special file.
598 */
599 static ssize_t pod_set_dump(struct device *dev, struct device_attribute *attr,
600 const char *buf, size_t count)
601 {
602 struct usb_interface *interface = to_usb_interface(dev);
603 struct usb_line6_pod *pod = usb_get_intfdata(interface);
604
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));
609 return -EINVAL;
610 }
611
612 pod_dump(pod, buf);
613 return sizeof(pod->prog_data);
614 }
615
616 /*
617 Request system parameter.
618 @param tuner non-zero, if code refers to a tuner parameter
619 */
620 static ssize_t pod_get_system_param(struct usb_line6_pod *pod, char *buf, int code, struct ValueWait *param, int tuner, int sign)
621 {
622 char *sysex;
623 int value;
624 static const int size = 1;
625 int retval = 0;
626 DECLARE_WAITQUEUE(wait, current);
627
628 if (((pod->prog_data.control[POD_tuner] & 0x40) == 0) && tuner)
629 return -ENODEV;
630
631 /* send value request to tuner: */
632 param->value = POD_system_invalid;
633 sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_SYSTEMREQ, size);
634 if (!sysex)
635 return 0;
636 sysex[SYSEX_DATA_OFS] = code;
637 line6_send_sysex_message(&pod->line6, sysex, size);
638 kfree(sysex);
639
640 /* wait for tuner to respond: */
641 add_wait_queue(&param->wait, &wait);
642 current->state = TASK_INTERRUPTIBLE;
643
644 while (param->value == POD_system_invalid) {
645 if (signal_pending(current)) {
646 retval = -ERESTARTSYS;
647 break;
648 } else
649 schedule();
650 }
651
652 current->state = TASK_RUNNING;
653 remove_wait_queue(&param->wait, &wait);
654
655 if (retval < 0)
656 return retval;
657
658 value = sign ? (int)(signed short)param->value : (int)(unsigned short)param->value;
659 return sprintf(buf, "%d\n", value);
660 }
661
662 /*
663 Send system parameter.
664 @param tuner non-zero, if code refers to a tuner parameter
665 */
666 static ssize_t pod_set_system_param(struct usb_line6_pod *pod, const char *buf,
667 int count, int code, unsigned short mask,
668 int tuner)
669 {
670 char *sysex;
671 static const int size = 5;
672 unsigned short value;
673 unsigned long result;
674 int ret;
675
676 if (((pod->prog_data.control[POD_tuner] & 0x40) == 0) && tuner)
677 return -EINVAL;
678
679 /* send value to tuner: */
680 sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_SYSTEM, size);
681 if (!sysex)
682 return 0;
683
684 ret = strict_strtoul(buf, 10, &result);
685 if (ret)
686 return ret;
687
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);
695 kfree(sysex);
696 return count;
697 }
698
699 /*
700 "read" request on "dump_buf" special file.
701 */
702 static ssize_t pod_get_dump_buf(struct device *dev,
703 struct device_attribute *attr, char *buf)
704 {
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);
708 if (retval < 0)
709 return retval;
710 memcpy(buf, &pod->prog_data_buf, sizeof(pod->prog_data_buf));
711 return sizeof(pod->prog_data_buf);
712 }
713
714 /*
715 "write" request on "dump_buf" special file.
716 */
717 static ssize_t pod_set_dump_buf(struct device *dev,
718 struct device_attribute *attr,
719 const char *buf, size_t count)
720 {
721 struct usb_interface *interface = to_usb_interface(dev);
722 struct usb_line6_pod *pod = usb_get_intfdata(interface);
723
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));
728 return -EINVAL;
729 }
730
731 memcpy(&pod->prog_data_buf, buf, sizeof(pod->prog_data));
732 return sizeof(pod->prog_data);
733 }
734
735 /*
736 "write" request on "finish" special file.
737 */
738 static ssize_t pod_set_finish(struct device *dev,
739 struct device_attribute *attr,
740 const char *buf, size_t count)
741 {
742 struct usb_interface *interface = to_usb_interface(dev);
743 struct usb_line6_pod *pod = usb_get_intfdata(interface);
744 int size = 0;
745 char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_FINISH, size);
746 if (!sysex)
747 return 0;
748 line6_send_sysex_message(&pod->line6, sysex, size);
749 kfree(sysex);
750 return count;
751 }
752
753 /*
754 "write" request on "store_channel" special file.
755 */
756 static ssize_t pod_set_store_channel(struct device *dev,
757 struct device_attribute *attr,
758 const char *buf, size_t count)
759 {
760 return pod_send_store_command(dev, buf, count, 0x0000, 0x00c0);
761 }
762
763 /*
764 "write" request on "store_effects_setup" special file.
765 */
766 static ssize_t pod_set_store_effects_setup(struct device *dev,
767 struct device_attribute *attr,
768 const char *buf, size_t count)
769 {
770 return pod_send_store_command(dev, buf, count, 0x0080, 0x0080);
771 }
772
773 /*
774 "write" request on "store_amp_setup" special file.
775 */
776 static ssize_t pod_set_store_amp_setup(struct device *dev,
777 struct device_attribute *attr,
778 const char *buf, size_t count)
779 {
780 return pod_send_store_command(dev, buf, count, 0x0040, 0x0100);
781 }
782
783 /*
784 "write" request on "retrieve_channel" special file.
785 */
786 static ssize_t pod_set_retrieve_channel(struct device *dev,
787 struct device_attribute *attr,
788 const char *buf, size_t count)
789 {
790 return pod_send_retrieve_command(dev, buf, count, 0x0000, 0x00c0);
791 }
792
793 /*
794 "write" request on "retrieve_effects_setup" special file.
795 */
796 static ssize_t pod_set_retrieve_effects_setup(struct device *dev,
797 struct device_attribute *attr,
798 const char *buf, size_t count)
799 {
800 return pod_send_retrieve_command(dev, buf, count, 0x0080, 0x0080);
801 }
802
803 /*
804 "write" request on "retrieve_amp_setup" special file.
805 */
806 static ssize_t pod_set_retrieve_amp_setup(struct device *dev,
807 struct device_attribute *attr,
808 const char *buf, size_t count)
809 {
810 return pod_send_retrieve_command(dev, buf, count, 0x0040, 0x0100);
811 }
812
813 /*
814 "read" request on "dirty" special file.
815 */
816 static ssize_t pod_get_dirty(struct device *dev, struct device_attribute *attr,
817 char *buf)
818 {
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';
822 buf[1] = '\n';
823 return 2;
824 }
825
826 /*
827 "read" request on "midi_postprocess" special file.
828 */
829 static ssize_t pod_get_midi_postprocess(struct device *dev,
830 struct device_attribute *attr,
831 char *buf)
832 {
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);
836 }
837
838 /*
839 "write" request on "midi_postprocess" special file.
840 */
841 static ssize_t pod_set_midi_postprocess(struct device *dev,
842 struct device_attribute *attr,
843 const char *buf, size_t count)
844 {
845 struct usb_interface *interface = to_usb_interface(dev);
846 struct usb_line6_pod *pod = usb_get_intfdata(interface);
847 unsigned long value;
848 int ret;
849
850 ret = strict_strtoul(buf, 10, &value);
851 if (ret)
852 return ret;
853
854 pod->midi_postprocess = value ? 1 : 0;
855 return count;
856 }
857
858 /*
859 "read" request on "serial_number" special file.
860 */
861 static ssize_t pod_get_serial_number(struct device *dev,
862 struct device_attribute *attr, char *buf)
863 {
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);
867 }
868
869 /*
870 "read" request on "firmware_version" special file.
871 */
872 static ssize_t pod_get_firmware_version(struct device *dev,
873 struct device_attribute *attr,
874 char *buf)
875 {
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);
880 }
881
882 /*
883 "read" request on "device_id" special file.
884 */
885 static ssize_t pod_get_device_id(struct device *dev,
886 struct device_attribute *attr, char *buf)
887 {
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);
891 }
892
893 /*
894 "read" request on "clip" special file.
895 */
896 static ssize_t pod_wait_for_clip(struct device *dev,
897 struct device_attribute *attr, char *buf)
898 {
899 struct usb_interface *interface = to_usb_interface(dev);
900 struct usb_line6_pod *pod = usb_get_intfdata(interface);
901 int err = 0;
902 DECLARE_WAITQUEUE(wait, current);
903 pod->clipping.value = 0;
904 add_wait_queue(&pod->clipping.wait, &wait);
905 current->state = TASK_INTERRUPTIBLE;
906
907 while (pod->clipping.value == 0) {
908 if (signal_pending(current)) {
909 err = -ERESTARTSYS;
910 break;
911 } else
912 schedule();
913 }
914
915 current->state = TASK_RUNNING;
916 remove_wait_queue(&pod->clipping.wait, &wait);
917 return err;
918 }
919
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) \
923 { \
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, \
927 tuner, sign); \
928 }
929
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) \
935 { \
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, \
939 tuner); \
940 }
941
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);
948
949 #undef GET_SET_SYSTEM_PARAM
950 #undef GET_SYSTEM_PARAM
951
952 /* POD special files: */
953 static DEVICE_ATTR(channel, S_IWUSR | 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_IWUSR | S_IRUGO, pod_get_dump, pod_set_dump);
958 static DEVICE_ATTR(dump_buf, S_IWUSR | S_IRUGO, pod_get_dump_buf, pod_set_dump_buf);
959 static DEVICE_ATTR(finish, S_IWUSR, 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_IWUSR | S_IRUGO, pod_get_midi_postprocess, pod_set_midi_postprocess);
962 static DEVICE_ATTR(monitor_level, S_IWUSR | 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_IWUSR, line6_nop_read, pod_set_retrieve_amp_setup);
966 static DEVICE_ATTR(retrieve_channel, S_IWUSR, line6_nop_read, pod_set_retrieve_channel);
967 static DEVICE_ATTR(retrieve_effects_setup, S_IWUSR, line6_nop_read, pod_set_retrieve_effects_setup);
968 static DEVICE_ATTR(routing, S_IWUSR | 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_IWUSR, line6_nop_read, pod_set_store_amp_setup);
971 static DEVICE_ATTR(store_channel, S_IWUSR, line6_nop_read, pod_set_store_channel);
972 static DEVICE_ATTR(store_effects_setup, S_IWUSR, line6_nop_read, pod_set_store_effects_setup);
973 static DEVICE_ATTR(tuner_freq, S_IWUSR | S_IRUGO, pod_get_tuner_freq, pod_set_tuner_freq);
974 static DEVICE_ATTR(tuner_mute, S_IWUSR | 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);
977
978 #if CREATE_RAW_FILE
979 static DEVICE_ATTR(raw, S_IWUSR, line6_nop_read, line6_set_raw);
980 #endif
981
982 /*
983 POD destructor.
984 */
985 static void pod_destruct(struct usb_interface *interface)
986 {
987 struct usb_line6_pod *pod = usb_get_intfdata(interface);
988 struct usb_line6 *line6;
989
990 if (pod == NULL)
991 return;
992 line6 = &pod->line6;
993 if (line6 == NULL)
994 return;
995 line6_cleanup_audio(line6);
996
997 /* free dump request data: */
998 line6_dumpreq_destruct(&pod->dumpreq);
999
1000 kfree(pod->buffer_versionreq);
1001 }
1002
1003 /*
1004 Create sysfs entries.
1005 */
1006 static int pod_create_files2(struct device *dev)
1007 {
1008 int err;
1009
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));
1034
1035 #if CREATE_RAW_FILE
1036 CHECK_RETURN(device_create_file(dev, &dev_attr_raw));
1037 #endif
1038
1039 return 0;
1040 }
1041
1042 /*
1043 Init POD device.
1044 */
1045 int pod_init(struct usb_interface *interface, struct usb_line6_pod *pod)
1046 {
1047 int err;
1048 struct usb_line6 *line6 = &pod->line6;
1049
1050 if ((interface == NULL) || (pod == NULL))
1051 return -ENODEV;
1052
1053 pod->channel_num = 255;
1054
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);
1063
1064 memset(pod->param_dirty, 0xff, sizeof(pod->param_dirty));
1065
1066 /* initialize USB buffers: */
1067 err = line6_dumpreq_init(&pod->dumpreq, pod_request_channel,
1068 sizeof(pod_request_channel));
1069 if (err < 0) {
1070 dev_err(&interface->dev, "Out of memory\n");
1071 pod_destruct(interface);
1072 return -ENOMEM;
1073 }
1074
1075 pod->buffer_versionreq = kmalloc(sizeof(pod_request_version),
1076 GFP_KERNEL);
1077
1078 if (pod->buffer_versionreq == NULL) {
1079 dev_err(&interface->dev, "Out of memory\n");
1080 pod_destruct(interface);
1081 return -ENOMEM;
1082 }
1083
1084 memcpy(pod->buffer_versionreq, pod_request_version,
1085 sizeof(pod_request_version));
1086
1087 /* create sysfs entries: */
1088 err = pod_create_files2(&interface->dev);
1089 if (err < 0) {
1090 pod_destruct(interface);
1091 return err;
1092 }
1093
1094 /* initialize audio system: */
1095 err = line6_init_audio(line6);
1096 if (err < 0) {
1097 pod_destruct(interface);
1098 return err;
1099 }
1100
1101 /* initialize MIDI subsystem: */
1102 err = line6_init_midi(line6);
1103 if (err < 0) {
1104 pod_destruct(interface);
1105 return err;
1106 }
1107
1108 /* initialize PCM subsystem: */
1109 err = line6_init_pcm(line6, &pod_pcm_properties);
1110 if (err < 0) {
1111 pod_destruct(interface);
1112 return err;
1113 }
1114
1115 /* register audio system: */
1116 err = line6_register_audio(line6);
1117 if (err < 0) {
1118 pod_destruct(interface);
1119 return err;
1120 }
1121
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);
1127 }
1128
1129 return 0;
1130 }
1131
1132 /*
1133 POD device disconnected.
1134 */
1135 void pod_disconnect(struct usb_interface *interface)
1136 {
1137 struct usb_line6_pod *pod;
1138
1139 if (interface == NULL)
1140 return;
1141 pod = usb_get_intfdata(interface);
1142
1143 if (pod != NULL) {
1144 struct snd_line6_pcm *line6pcm = pod->line6.line6pcm;
1145 struct device *dev = &interface->dev;
1146
1147 if (line6pcm != NULL) {
1148 unlink_wait_clear_audio_out_urbs(line6pcm);
1149 unlink_wait_clear_audio_in_urbs(line6pcm);
1150 }
1151
1152 if (dev != NULL) {
1153 /* remove sysfs entries: */
1154 if (pod->versionreq_ok)
1155 pod_remove_files(pod->firmware_version, pod->line6.properties->device_bit, dev);
1156
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);
1181
1182 #if CREATE_RAW_FILE
1183 device_remove_file(dev, &dev_attr_raw);
1184 #endif
1185 }
1186 }
1187
1188 pod_destruct(interface);
1189 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree