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.
14 #include <sound/core.h>
15 #include <sound/pcm.h>
16 #include <sound/pcm_params.h>
24 Software stereo volume control.
26 static void change_volume(struct urb
*urb_out
, int volume
[],
31 if (volume
[0] == 256 && volume
[1] == 256)
32 return; /* maximum volume - no change */
34 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 *p
= (*p
* volume
[chn
& 1]) >> 8;
43 } else if (bytes_per_frame
== 6) {
44 unsigned char *p
, *buf_end
;
45 p
= (unsigned char *)urb_out
->transfer_buffer
;
46 buf_end
= p
+ urb_out
->transfer_buffer_length
;
48 for (; p
< buf_end
; p
+= 3) {
50 val
= p
[0] + (p
[1] << 8) + ((signed char)p
[2] << 16);
51 val
= (val
* volume
[chn
& 1]) >> 8;
61 Find a free URB, prepare audio data, and submit URB.
63 static int submit_audio_out_urb(struct snd_pcm_substream
*substream
)
67 int i
, urb_size
, urb_frames
;
68 struct snd_line6_pcm
*line6pcm
= snd_pcm_substream_chip(substream
);
69 const int bytes_per_frame
= line6pcm
->properties
->bytes_per_frame
;
70 const int frame_increment
=
71 line6pcm
->properties
->snd_line6_rates
.rats
[0].num_min
;
72 const int frame_factor
=
73 line6pcm
->properties
->snd_line6_rates
.rats
[0].den
*
74 (USB_INTERVALS_PER_SECOND
/ LINE6_ISO_INTERVAL
);
75 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
78 spin_lock_irqsave(&line6pcm
->lock_audio_out
, flags
);
80 find_first_zero_bit(&line6pcm
->active_urb_out
, LINE6_ISO_BUFFERS
);
82 if (index
< 0 || index
>= LINE6_ISO_BUFFERS
) {
83 spin_unlock_irqrestore(&line6pcm
->lock_audio_out
, flags
);
84 dev_err(s2m(substream
), "no free URB found\n");
88 urb_out
= line6pcm
->urb_audio_out
[index
];
91 for (i
= 0; i
< LINE6_ISO_PACKETS
; ++i
) {
92 /* compute frame size for given sampling rate */
94 struct usb_iso_packet_descriptor
*fout
=
95 &urb_out
->iso_frame_desc
[i
];
96 line6pcm
->count_out
+= frame_increment
;
97 n
= line6pcm
->count_out
/ frame_factor
;
98 line6pcm
->count_out
-= n
* frame_factor
;
99 fs
= n
* bytes_per_frame
;
100 fout
->offset
= urb_size
;
105 urb_frames
= urb_size
/ bytes_per_frame
;
107 if (test_bit(BIT_PAUSE_PLAYBACK
, &line6pcm
->flags
)) {
108 urb_out
->transfer_buffer
= line6pcm
->wrap_out
;
109 memset(line6pcm
->wrap_out
, 0, urb_size
);
111 if (line6pcm
->pos_out
+ urb_frames
> runtime
->buffer_size
) {
113 The transferred area goes over buffer boundary,
114 copy the data to the temp buffer.
117 len
= runtime
->buffer_size
- line6pcm
->pos_out
;
118 urb_out
->transfer_buffer
= line6pcm
->wrap_out
;
121 memcpy(line6pcm
->wrap_out
,
123 line6pcm
->pos_out
* bytes_per_frame
,
124 len
* bytes_per_frame
);
125 memcpy(line6pcm
->wrap_out
+
126 len
* bytes_per_frame
, runtime
->dma_area
,
127 (urb_frames
- len
) * bytes_per_frame
);
129 /* this is somewhat paranoid */
130 dev_err(s2m(substream
),
131 "driver bug: len = %d\n", len
);
134 /* set the buffer pointer */
135 urb_out
->transfer_buffer
=
137 line6pcm
->pos_out
* bytes_per_frame
;
141 line6pcm
->pos_out
+= urb_frames
;
142 if (line6pcm
->pos_out
>= runtime
->buffer_size
)
143 line6pcm
->pos_out
-= runtime
->buffer_size
;
145 urb_out
->transfer_buffer_length
= urb_size
;
146 urb_out
->context
= substream
;
147 change_volume(urb_out
, line6pcm
->volume
, bytes_per_frame
);
150 for (i
= 0; i
< LINE6_ISO_PACKETS
; ++i
) {
151 struct usb_iso_packet_descriptor
*fout
=
152 &urb_out
->iso_frame_desc
[i
];
153 line6_write_hexdump(line6pcm
->line6
, 'P',
154 urb_out
->transfer_buffer
+ fout
->offset
,
159 if (usb_submit_urb(urb_out
, GFP_ATOMIC
) == 0)
160 set_bit(index
, &line6pcm
->active_urb_out
);
162 dev_err(s2m(substream
), "URB out #%d submission failed\n",
165 spin_unlock_irqrestore(&line6pcm
->lock_audio_out
, flags
);
170 Submit all currently available playback URBs.
172 static int submit_audio_out_all_urbs(struct snd_pcm_substream
*substream
)
176 for (i
= 0; i
< LINE6_ISO_BUFFERS
; ++i
) {
177 ret
= submit_audio_out_urb(substream
);
186 Unlink all currently active playback URBs.
188 static void unlink_audio_out_urbs(struct snd_line6_pcm
*line6pcm
)
192 for (i
= LINE6_ISO_BUFFERS
; i
--;) {
193 if (test_bit(i
, &line6pcm
->active_urb_out
)) {
194 if (!test_and_set_bit(i
, &line6pcm
->unlink_urb_out
)) {
195 struct urb
*u
= line6pcm
->urb_audio_out
[i
];
203 Wait until unlinking of all currently active playback URBs has been finished.
205 static void wait_clear_audio_out_urbs(struct snd_line6_pcm
*line6pcm
)
213 for (i
= LINE6_ISO_BUFFERS
; i
--;) {
214 if (test_bit(i
, &line6pcm
->active_urb_out
))
219 set_current_state(TASK_UNINTERRUPTIBLE
);
221 } while (--timeout
> 0);
223 snd_printk(KERN_ERR
"timeout: still %d active urbs..\n", alive
);
225 line6pcm
->active_urb_out
= 0;
226 line6pcm
->unlink_urb_out
= 0;
230 Unlink all currently active playback URBs, and wait for finishing.
232 void unlink_wait_clear_audio_out_urbs(struct snd_line6_pcm
*line6pcm
)
234 unlink_audio_out_urbs(line6pcm
);
235 wait_clear_audio_out_urbs(line6pcm
);
239 Callback for completed playback URB.
241 static void audio_out_callback(struct urb
*urb
)
243 int i
, index
, length
= 0, shutdown
= 0;
246 struct snd_pcm_substream
*substream
=
247 (struct snd_pcm_substream
*)urb
->context
;
248 struct snd_line6_pcm
*line6pcm
= snd_pcm_substream_chip(substream
);
249 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
251 /* find index of URB */
252 for (index
= LINE6_ISO_BUFFERS
; index
--;)
253 if (urb
== line6pcm
->urb_audio_out
[index
])
257 return; /* URB has been unlinked asynchronously */
259 for (i
= LINE6_ISO_PACKETS
; i
--;)
260 length
+= urb
->iso_frame_desc
[i
].length
;
262 spin_lock_irqsave(&line6pcm
->lock_audio_out
, flags
);
263 line6pcm
->pos_out_done
+=
264 length
/ line6pcm
->properties
->bytes_per_frame
;
266 if (line6pcm
->pos_out_done
>= runtime
->buffer_size
)
267 line6pcm
->pos_out_done
-= runtime
->buffer_size
;
269 clear_bit(index
, &line6pcm
->active_urb_out
);
271 for (i
= LINE6_ISO_PACKETS
; i
--;)
272 if (urb
->iso_frame_desc
[i
].status
== -ESHUTDOWN
) {
277 if (test_bit(index
, &line6pcm
->unlink_urb_out
))
280 spin_unlock_irqrestore(&line6pcm
->lock_audio_out
, flags
);
283 submit_audio_out_urb(substream
);
285 line6pcm
->bytes_out
+= length
;
286 if (line6pcm
->bytes_out
>= line6pcm
->period_out
) {
287 line6pcm
->bytes_out
-= line6pcm
->period_out
;
288 snd_pcm_period_elapsed(substream
);
293 /* open playback callback */
294 static int snd_line6_playback_open(struct snd_pcm_substream
*substream
)
297 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
298 struct snd_line6_pcm
*line6pcm
= snd_pcm_substream_chip(substream
);
300 err
= snd_pcm_hw_constraint_ratdens(runtime
, 0, SNDRV_PCM_HW_PARAM_RATE
,
301 (&line6pcm
->properties
->
306 runtime
->hw
= line6pcm
->properties
->snd_line6_playback_hw
;
310 /* close playback callback */
311 static int snd_line6_playback_close(struct snd_pcm_substream
*substream
)
316 /* hw_params playback callback */
317 static int snd_line6_playback_hw_params(struct snd_pcm_substream
*substream
,
318 struct snd_pcm_hw_params
*hw_params
)
321 struct snd_line6_pcm
*line6pcm
= snd_pcm_substream_chip(substream
);
323 /* -- Florian Demski [FD] */
324 /* don't ask me why, but this fixes the bug on my machine */
325 if (line6pcm
== NULL
) {
326 if (substream
->pcm
== NULL
)
328 if (substream
->pcm
->private_data
== NULL
)
330 substream
->private_data
= substream
->pcm
->private_data
;
331 line6pcm
= snd_pcm_substream_chip(substream
);
335 ret
= snd_pcm_lib_malloc_pages(substream
,
336 params_buffer_bytes(hw_params
));
340 line6pcm
->period_out
= params_period_bytes(hw_params
);
341 line6pcm
->wrap_out
= kmalloc(2 * LINE6_ISO_PACKET_SIZE_MAX
, GFP_KERNEL
);
343 if (!line6pcm
->wrap_out
) {
344 dev_err(s2m(substream
), "cannot malloc wrap_out\n");
351 /* hw_free playback callback */
352 static int snd_line6_playback_hw_free(struct snd_pcm_substream
*substream
)
354 struct snd_line6_pcm
*line6pcm
= snd_pcm_substream_chip(substream
);
355 unlink_wait_clear_audio_out_urbs(line6pcm
);
357 kfree(line6pcm
->wrap_out
);
358 line6pcm
->wrap_out
= NULL
;
360 return snd_pcm_lib_free_pages(substream
);
363 /* trigger playback callback */
364 int snd_line6_playback_trigger(struct snd_pcm_substream
*substream
, int cmd
)
366 struct snd_line6_pcm
*line6pcm
= snd_pcm_substream_chip(substream
);
368 line6pcm
->count_out
= 0;
371 case SNDRV_PCM_TRIGGER_START
:
372 if (!test_and_set_bit(BIT_RUNNING_PLAYBACK
, &line6pcm
->flags
)) {
373 err
= submit_audio_out_all_urbs(substream
);
376 clear_bit(BIT_RUNNING_PLAYBACK
,
384 case SNDRV_PCM_TRIGGER_STOP
:
385 if (test_and_clear_bit(BIT_RUNNING_PLAYBACK
, &line6pcm
->flags
))
386 unlink_audio_out_urbs(line6pcm
);
390 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
391 set_bit(BIT_PAUSE_PLAYBACK
, &line6pcm
->flags
);
394 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
395 clear_bit(BIT_PAUSE_PLAYBACK
, &line6pcm
->flags
);
405 /* playback pointer callback */
406 static snd_pcm_uframes_t
407 snd_line6_playback_pointer(struct snd_pcm_substream
*substream
)
409 struct snd_line6_pcm
*line6pcm
= snd_pcm_substream_chip(substream
);
410 return line6pcm
->pos_out_done
;
413 /* playback operators */
414 struct snd_pcm_ops snd_line6_playback_ops
= {
415 .open
= snd_line6_playback_open
,
416 .close
= snd_line6_playback_close
,
417 .ioctl
= snd_pcm_lib_ioctl
,
418 .hw_params
= snd_line6_playback_hw_params
,
419 .hw_free
= snd_line6_playback_hw_free
,
420 .prepare
= snd_line6_prepare
,
421 .trigger
= snd_line6_trigger
,
422 .pointer
= snd_line6_playback_pointer
,
425 int create_audio_out_urbs(struct snd_line6_pcm
*line6pcm
)
429 /* create audio URBs and fill in constant values: */
430 for (i
= 0; i
< LINE6_ISO_BUFFERS
; ++i
) {
433 /* URB for audio out: */
434 urb
= line6pcm
->urb_audio_out
[i
] =
435 usb_alloc_urb(LINE6_ISO_PACKETS
, GFP_KERNEL
);
438 dev_err(line6pcm
->line6
->ifcdev
, "Out of memory\n");
442 urb
->dev
= line6pcm
->line6
->usbdev
;
444 usb_sndisocpipe(line6pcm
->line6
->usbdev
,
446 ep_audio_write
& USB_ENDPOINT_NUMBER_MASK
);
447 urb
->transfer_flags
= URB_ISO_ASAP
;
448 urb
->start_frame
= -1;
449 urb
->number_of_packets
= LINE6_ISO_PACKETS
;
450 urb
->interval
= LINE6_ISO_INTERVAL
;
451 urb
->error_count
= 0;
452 urb
->complete
= audio_out_callback
;