2 * Line 6 Linux USB driver
4 * Copyright (C) 2004-2010 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.
12 #include <linux/slab.h>
13 #include <sound/core.h>
14 #include <sound/pcm.h>
15 #include <sound/pcm_params.h>
23 Software stereo volume control.
25 static void change_volume(struct urb
*urb_out
, int volume
[],
30 if (volume
[0] == 256 && volume
[1] == 256)
31 return; /* maximum volume - no change */
33 if (bytes_per_frame
== 4) {
36 p
= (short *)urb_out
->transfer_buffer
;
37 buf_end
= p
+ urb_out
->transfer_buffer_length
/ sizeof(*p
);
39 for (; p
< buf_end
; ++p
) {
40 int val
= (*p
* volume
[chn
& 1]) >> 8;
41 *p
= clamp(val
, 0x7fff, -0x8000);
44 } else if (bytes_per_frame
== 6) {
45 unsigned char *p
, *buf_end
;
47 p
= (unsigned char *)urb_out
->transfer_buffer
;
48 buf_end
= p
+ urb_out
->transfer_buffer_length
;
50 for (; p
< buf_end
; p
+= 3) {
53 val
= p
[0] + (p
[1] << 8) + ((signed char)p
[2] << 16);
54 val
= (val
* volume
[chn
& 1]) >> 8;
55 val
= clamp(val
, 0x7fffff, -0x800000);
65 Create signal for impulse response test.
67 static void create_impulse_test_signal(struct snd_line6_pcm
*line6pcm
,
68 struct urb
*urb_out
, int bytes_per_frame
)
70 int frames
= urb_out
->transfer_buffer_length
/ bytes_per_frame
;
72 if (bytes_per_frame
== 4) {
74 short *pi
= (short *)line6pcm
->prev_fbuf
;
75 short *po
= (short *)urb_out
->transfer_buffer
;
77 for (i
= 0; i
< frames
; ++i
) {
83 } else if (bytes_per_frame
== 6) {
85 unsigned char *pi
= line6pcm
->prev_fbuf
;
86 unsigned char *po
= urb_out
->transfer_buffer
;
88 for (i
= 0; i
< frames
; ++i
) {
89 for (j
= 0; j
< bytes_per_frame
/ 2; ++j
)
92 for (; j
< bytes_per_frame
; ++j
)
95 pi
+= bytes_per_frame
;
96 po
+= bytes_per_frame
;
99 if (--line6pcm
->impulse_count
<= 0) {
100 ((unsigned char *)(urb_out
->transfer_buffer
))[bytes_per_frame
-
102 line6pcm
->impulse_volume
;
103 line6pcm
->impulse_count
= line6pcm
->impulse_period
;
108 Add signal to buffer for software monitoring.
110 static void add_monitor_signal(struct urb
*urb_out
, unsigned char *signal
,
111 int volume
, int bytes_per_frame
)
114 return; /* zero volume - no change */
116 if (bytes_per_frame
== 4) {
117 short *pi
, *po
, *buf_end
;
119 pi
= (short *)signal
;
120 po
= (short *)urb_out
->transfer_buffer
;
121 buf_end
= po
+ urb_out
->transfer_buffer_length
/ sizeof(*po
);
123 for (; po
< buf_end
; ++pi
, ++po
) {
124 int val
= *po
+ ((*pi
* volume
) >> 8);
125 *po
= clamp(val
, 0x7fff, -0x8000);
130 We don't need to handle devices with 6 bytes per frame here
131 since they all support hardware monitoring.
136 Find a free URB, prepare audio data, and submit URB.
138 static int submit_audio_out_urb(struct snd_line6_pcm
*line6pcm
)
142 int i
, urb_size
, urb_frames
;
144 const int bytes_per_frame
= line6pcm
->properties
->bytes_per_frame
;
145 const int frame_increment
=
146 line6pcm
->properties
->snd_line6_rates
.rats
[0].num_min
;
147 const int frame_factor
=
148 line6pcm
->properties
->snd_line6_rates
.rats
[0].den
*
149 (USB_INTERVALS_PER_SECOND
/ LINE6_ISO_INTERVAL
);
152 spin_lock_irqsave(&line6pcm
->out
.lock
, flags
);
154 find_first_zero_bit(&line6pcm
->out
.active_urbs
, LINE6_ISO_BUFFERS
);
156 if (index
< 0 || index
>= LINE6_ISO_BUFFERS
) {
157 spin_unlock_irqrestore(&line6pcm
->out
.lock
, flags
);
158 dev_err(line6pcm
->line6
->ifcdev
, "no free URB found\n");
162 urb_out
= line6pcm
->out
.urbs
[index
];
165 for (i
= 0; i
< LINE6_ISO_PACKETS
; ++i
) {
166 /* compute frame size for given sampling rate */
168 struct usb_iso_packet_descriptor
*fout
=
169 &urb_out
->iso_frame_desc
[i
];
171 if (line6pcm
->flags
& LINE6_BITS_CAPTURE_STREAM
)
172 fsize
= line6pcm
->prev_fsize
;
177 line6pcm
->out
.count
+= frame_increment
;
178 n
= line6pcm
->out
.count
/ frame_factor
;
179 line6pcm
->out
.count
-= n
* frame_factor
;
180 fsize
= n
* bytes_per_frame
;
183 fout
->offset
= urb_size
;
184 fout
->length
= fsize
;
189 /* can't determine URB size */
190 spin_unlock_irqrestore(&line6pcm
->out
.lock
, flags
);
191 dev_err(line6pcm
->line6
->ifcdev
, "driver bug: urb_size = 0\n");
195 urb_frames
= urb_size
/ bytes_per_frame
;
196 urb_out
->transfer_buffer
=
197 line6pcm
->out
.buffer
+
198 index
* LINE6_ISO_PACKETS
* line6pcm
->max_packet_size
;
199 urb_out
->transfer_buffer_length
= urb_size
;
200 urb_out
->context
= line6pcm
;
202 if (test_bit(LINE6_INDEX_PCM_ALSA_PLAYBACK_STREAM
, &line6pcm
->flags
) &&
203 !test_bit(LINE6_INDEX_PAUSE_PLAYBACK
, &line6pcm
->flags
)) {
204 struct snd_pcm_runtime
*runtime
=
205 get_substream(line6pcm
, SNDRV_PCM_STREAM_PLAYBACK
)->runtime
;
207 if (line6pcm
->out
.pos
+ urb_frames
> runtime
->buffer_size
) {
209 The transferred area goes over buffer boundary,
210 copy the data to the temp buffer.
214 len
= runtime
->buffer_size
- line6pcm
->out
.pos
;
217 memcpy(urb_out
->transfer_buffer
,
219 line6pcm
->out
.pos
* bytes_per_frame
,
220 len
* bytes_per_frame
);
221 memcpy(urb_out
->transfer_buffer
+
222 len
* bytes_per_frame
, runtime
->dma_area
,
223 (urb_frames
- len
) * bytes_per_frame
);
225 dev_err(line6pcm
->line6
->ifcdev
, "driver bug: len = %d\n",
228 memcpy(urb_out
->transfer_buffer
,
230 line6pcm
->out
.pos
* bytes_per_frame
,
231 urb_out
->transfer_buffer_length
);
234 line6pcm
->out
.pos
+= urb_frames
;
235 if (line6pcm
->out
.pos
>= runtime
->buffer_size
)
236 line6pcm
->out
.pos
-= runtime
->buffer_size
;
238 change_volume(urb_out
, line6pcm
->volume_playback
,
241 memset(urb_out
->transfer_buffer
, 0,
242 urb_out
->transfer_buffer_length
);
245 if (line6pcm
->prev_fbuf
!= NULL
) {
246 if (line6pcm
->flags
& LINE6_BITS_PCM_IMPULSE
) {
247 create_impulse_test_signal(line6pcm
, urb_out
,
249 if (line6pcm
->flags
&
250 LINE6_BIT_PCM_ALSA_CAPTURE_STREAM
) {
251 line6_capture_copy(line6pcm
,
252 urb_out
->transfer_buffer
,
254 transfer_buffer_length
);
255 line6_capture_check_period(line6pcm
,
256 urb_out
->transfer_buffer_length
);
261 properties
->capabilities
& LINE6_CAP_HWMON
)
262 && (line6pcm
->flags
& LINE6_BITS_PLAYBACK_STREAM
)
263 && (line6pcm
->flags
& LINE6_BITS_CAPTURE_STREAM
))
264 add_monitor_signal(urb_out
, line6pcm
->prev_fbuf
,
265 line6pcm
->volume_monitor
,
270 ret
= usb_submit_urb(urb_out
, GFP_ATOMIC
);
273 set_bit(index
, &line6pcm
->out
.active_urbs
);
275 dev_err(line6pcm
->line6
->ifcdev
,
276 "URB out #%d submission failed (%d)\n", index
, ret
);
278 spin_unlock_irqrestore(&line6pcm
->out
.lock
, flags
);
283 Submit all currently available playback URBs.
285 int line6_submit_audio_out_all_urbs(struct snd_line6_pcm
*line6pcm
)
289 for (i
= 0; i
< LINE6_ISO_BUFFERS
; ++i
) {
290 ret
= submit_audio_out_urb(line6pcm
);
299 Callback for completed playback URB.
301 static void audio_out_callback(struct urb
*urb
)
303 int i
, index
, length
= 0, shutdown
= 0;
305 struct snd_line6_pcm
*line6pcm
= (struct snd_line6_pcm
*)urb
->context
;
306 struct snd_pcm_substream
*substream
=
307 get_substream(line6pcm
, SNDRV_PCM_STREAM_PLAYBACK
);
309 #if USE_CLEAR_BUFFER_WORKAROUND
310 memset(urb
->transfer_buffer
, 0, urb
->transfer_buffer_length
);
313 line6pcm
->out
.last_frame
= urb
->start_frame
;
315 /* find index of URB */
316 for (index
= 0; index
< LINE6_ISO_BUFFERS
; index
++)
317 if (urb
== line6pcm
->out
.urbs
[index
])
320 if (index
>= LINE6_ISO_BUFFERS
)
321 return; /* URB has been unlinked asynchronously */
323 for (i
= 0; i
< LINE6_ISO_PACKETS
; i
++)
324 length
+= urb
->iso_frame_desc
[i
].length
;
326 spin_lock_irqsave(&line6pcm
->out
.lock
, flags
);
328 if (test_bit(LINE6_INDEX_PCM_ALSA_PLAYBACK_STREAM
, &line6pcm
->flags
)) {
329 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
331 line6pcm
->out
.pos_done
+=
332 length
/ line6pcm
->properties
->bytes_per_frame
;
334 if (line6pcm
->out
.pos_done
>= runtime
->buffer_size
)
335 line6pcm
->out
.pos_done
-= runtime
->buffer_size
;
338 clear_bit(index
, &line6pcm
->out
.active_urbs
);
340 for (i
= 0; i
< LINE6_ISO_PACKETS
; i
++)
341 if (urb
->iso_frame_desc
[i
].status
== -EXDEV
) {
346 if (test_and_clear_bit(index
, &line6pcm
->out
.unlink_urbs
))
349 spin_unlock_irqrestore(&line6pcm
->out
.lock
, flags
);
352 submit_audio_out_urb(line6pcm
);
354 if (test_bit(LINE6_INDEX_PCM_ALSA_PLAYBACK_STREAM
,
356 line6pcm
->out
.bytes
+= length
;
357 if (line6pcm
->out
.bytes
>= line6pcm
->out
.period
) {
358 line6pcm
->out
.bytes
%= line6pcm
->out
.period
;
359 snd_pcm_period_elapsed(substream
);
365 /* open playback callback */
366 static int snd_line6_playback_open(struct snd_pcm_substream
*substream
)
369 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
370 struct snd_line6_pcm
*line6pcm
= snd_pcm_substream_chip(substream
);
372 err
= snd_pcm_hw_constraint_ratdens(runtime
, 0, SNDRV_PCM_HW_PARAM_RATE
,
374 properties
->snd_line6_rates
));
378 runtime
->hw
= line6pcm
->properties
->snd_line6_playback_hw
;
382 /* close playback callback */
383 static int snd_line6_playback_close(struct snd_pcm_substream
*substream
)
388 /* hw_params playback callback */
389 static int snd_line6_playback_hw_params(struct snd_pcm_substream
*substream
,
390 struct snd_pcm_hw_params
*hw_params
)
393 struct snd_line6_pcm
*line6pcm
= snd_pcm_substream_chip(substream
);
395 ret
= line6_pcm_acquire(line6pcm
, LINE6_BIT_PCM_ALSA_PLAYBACK_BUFFER
);
400 ret
= snd_pcm_lib_malloc_pages(substream
,
401 params_buffer_bytes(hw_params
));
403 line6_pcm_release(line6pcm
, LINE6_BIT_PCM_ALSA_PLAYBACK_BUFFER
);
407 line6pcm
->out
.period
= params_period_bytes(hw_params
);
411 /* hw_free playback callback */
412 static int snd_line6_playback_hw_free(struct snd_pcm_substream
*substream
)
414 struct snd_line6_pcm
*line6pcm
= snd_pcm_substream_chip(substream
);
416 line6_pcm_release(line6pcm
, LINE6_BIT_PCM_ALSA_PLAYBACK_BUFFER
);
417 return snd_pcm_lib_free_pages(substream
);
420 /* trigger playback callback */
421 int snd_line6_playback_trigger(struct snd_line6_pcm
*line6pcm
, int cmd
)
426 case SNDRV_PCM_TRIGGER_START
:
427 case SNDRV_PCM_TRIGGER_RESUME
:
428 err
= line6_pcm_acquire(line6pcm
,
429 LINE6_BIT_PCM_ALSA_PLAYBACK_STREAM
);
436 case SNDRV_PCM_TRIGGER_STOP
:
437 case SNDRV_PCM_TRIGGER_SUSPEND
:
438 err
= line6_pcm_release(line6pcm
,
439 LINE6_BIT_PCM_ALSA_PLAYBACK_STREAM
);
446 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
447 set_bit(LINE6_INDEX_PAUSE_PLAYBACK
, &line6pcm
->flags
);
450 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
451 clear_bit(LINE6_INDEX_PAUSE_PLAYBACK
, &line6pcm
->flags
);
461 /* playback pointer callback */
462 static snd_pcm_uframes_t
463 snd_line6_playback_pointer(struct snd_pcm_substream
*substream
)
465 struct snd_line6_pcm
*line6pcm
= snd_pcm_substream_chip(substream
);
467 return line6pcm
->out
.pos_done
;
470 /* playback operators */
471 struct snd_pcm_ops snd_line6_playback_ops
= {
472 .open
= snd_line6_playback_open
,
473 .close
= snd_line6_playback_close
,
474 .ioctl
= snd_pcm_lib_ioctl
,
475 .hw_params
= snd_line6_playback_hw_params
,
476 .hw_free
= snd_line6_playback_hw_free
,
477 .prepare
= snd_line6_prepare
,
478 .trigger
= snd_line6_trigger
,
479 .pointer
= snd_line6_playback_pointer
,
482 int line6_create_audio_out_urbs(struct snd_line6_pcm
*line6pcm
)
484 struct usb_line6
*line6
= line6pcm
->line6
;
487 /* create audio URBs and fill in constant values: */
488 for (i
= 0; i
< LINE6_ISO_BUFFERS
; ++i
) {
491 /* URB for audio out: */
492 urb
= line6pcm
->out
.urbs
[i
] =
493 usb_alloc_urb(LINE6_ISO_PACKETS
, GFP_KERNEL
);
498 urb
->dev
= line6
->usbdev
;
500 usb_sndisocpipe(line6
->usbdev
,
501 line6
->properties
->ep_audio_w
&
502 USB_ENDPOINT_NUMBER_MASK
);
503 urb
->transfer_flags
= URB_ISO_ASAP
;
504 urb
->start_frame
= -1;
505 urb
->number_of_packets
= LINE6_ISO_PACKETS
;
506 urb
->interval
= LINE6_ISO_INTERVAL
;
507 urb
->error_count
= 0;
508 urb
->complete
= audio_out_callback
;