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 <linux/export.h>
14 #include <sound/core.h>
15 #include <sound/control.h>
16 #include <sound/pcm.h>
17 #include <sound/pcm_params.h>
23 /* impulse response volume controls */
24 static int snd_line6_impulse_volume_info(struct snd_kcontrol
*kcontrol
,
25 struct snd_ctl_elem_info
*uinfo
)
27 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
29 uinfo
->value
.integer
.min
= 0;
30 uinfo
->value
.integer
.max
= 255;
34 static int snd_line6_impulse_volume_get(struct snd_kcontrol
*kcontrol
,
35 struct snd_ctl_elem_value
*ucontrol
)
37 struct snd_line6_pcm
*line6pcm
= snd_kcontrol_chip(kcontrol
);
39 ucontrol
->value
.integer
.value
[0] = line6pcm
->impulse_volume
;
43 static int snd_line6_impulse_volume_put(struct snd_kcontrol
*kcontrol
,
44 struct snd_ctl_elem_value
*ucontrol
)
46 struct snd_line6_pcm
*line6pcm
= snd_kcontrol_chip(kcontrol
);
47 int value
= ucontrol
->value
.integer
.value
[0];
50 if (line6pcm
->impulse_volume
== value
)
53 line6pcm
->impulse_volume
= value
;
55 err
= line6_pcm_acquire(line6pcm
, LINE6_STREAM_IMPULSE
);
57 line6pcm
->impulse_volume
= 0;
61 line6_pcm_release(line6pcm
, LINE6_STREAM_IMPULSE
);
66 /* impulse response period controls */
67 static int snd_line6_impulse_period_info(struct snd_kcontrol
*kcontrol
,
68 struct snd_ctl_elem_info
*uinfo
)
70 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
72 uinfo
->value
.integer
.min
= 0;
73 uinfo
->value
.integer
.max
= 2000;
77 static int snd_line6_impulse_period_get(struct snd_kcontrol
*kcontrol
,
78 struct snd_ctl_elem_value
*ucontrol
)
80 struct snd_line6_pcm
*line6pcm
= snd_kcontrol_chip(kcontrol
);
82 ucontrol
->value
.integer
.value
[0] = line6pcm
->impulse_period
;
86 static int snd_line6_impulse_period_put(struct snd_kcontrol
*kcontrol
,
87 struct snd_ctl_elem_value
*ucontrol
)
89 struct snd_line6_pcm
*line6pcm
= snd_kcontrol_chip(kcontrol
);
90 int value
= ucontrol
->value
.integer
.value
[0];
92 if (line6pcm
->impulse_period
== value
)
95 line6pcm
->impulse_period
= value
;
100 Unlink all currently active URBs.
102 static void line6_unlink_audio_urbs(struct snd_line6_pcm
*line6pcm
,
103 struct line6_pcm_stream
*pcms
)
107 for (i
= 0; i
< LINE6_ISO_BUFFERS
; i
++) {
108 if (test_bit(i
, &pcms
->active_urbs
)) {
109 if (!test_and_set_bit(i
, &pcms
->unlink_urbs
))
110 usb_unlink_urb(pcms
->urbs
[i
]);
116 Wait until unlinking of all currently active URBs has been finished.
118 static void line6_wait_clear_audio_urbs(struct snd_line6_pcm
*line6pcm
,
119 struct line6_pcm_stream
*pcms
)
127 for (i
= 0; i
< LINE6_ISO_BUFFERS
; i
++) {
128 if (test_bit(i
, &pcms
->active_urbs
))
133 set_current_state(TASK_UNINTERRUPTIBLE
);
135 } while (--timeout
> 0);
137 dev_err(line6pcm
->line6
->ifcdev
,
138 "timeout: still %d active urbs..\n", alive
);
141 static inline struct line6_pcm_stream
*
142 get_stream(struct snd_line6_pcm
*line6pcm
, int direction
)
144 return (direction
== SNDRV_PCM_STREAM_PLAYBACK
) ?
145 &line6pcm
->out
: &line6pcm
->in
;
148 /* allocate a buffer if not opened yet;
149 * call this in line6pcm.state_change mutex
151 static int line6_buffer_acquire(struct snd_line6_pcm
*line6pcm
,
152 struct line6_pcm_stream
*pstr
, int type
)
154 /* Invoked multiple times in a row so allocate once only */
155 if (!test_and_set_bit(type
, &pstr
->opened
) && !pstr
->buffer
) {
156 pstr
->buffer
= kmalloc(LINE6_ISO_BUFFERS
* LINE6_ISO_PACKETS
*
157 line6pcm
->max_packet_size
, GFP_KERNEL
);
164 /* free a buffer if all streams are closed;
165 * call this in line6pcm.state_change mutex
167 static void line6_buffer_release(struct snd_line6_pcm
*line6pcm
,
168 struct line6_pcm_stream
*pstr
, int type
)
171 clear_bit(type
, &pstr
->opened
);
173 line6_wait_clear_audio_urbs(line6pcm
, pstr
);
179 /* start a PCM stream */
180 static int line6_stream_start(struct snd_line6_pcm
*line6pcm
, int direction
,
184 struct line6_pcm_stream
*pstr
= get_stream(line6pcm
, direction
);
187 spin_lock_irqsave(&pstr
->lock
, flags
);
188 if (!test_and_set_bit(type
, &pstr
->running
) &&
189 !(pstr
->active_urbs
|| pstr
->unlink_urbs
)) {
191 /* Submit all currently available URBs */
192 if (direction
== SNDRV_PCM_STREAM_PLAYBACK
)
193 ret
= line6_submit_audio_out_all_urbs(line6pcm
);
195 ret
= line6_submit_audio_in_all_urbs(line6pcm
);
198 clear_bit(type
, &pstr
->running
);
199 spin_unlock_irqrestore(&pstr
->lock
, flags
);
203 /* stop a PCM stream; this doesn't sync with the unlinked URBs */
204 static void line6_stream_stop(struct snd_line6_pcm
*line6pcm
, int direction
,
208 struct line6_pcm_stream
*pstr
= get_stream(line6pcm
, direction
);
210 spin_lock_irqsave(&pstr
->lock
, flags
);
211 clear_bit(type
, &pstr
->running
);
212 if (!pstr
->running
) {
213 line6_unlink_audio_urbs(line6pcm
, pstr
);
214 if (direction
== SNDRV_PCM_STREAM_CAPTURE
) {
215 line6pcm
->prev_fbuf
= NULL
;
216 line6pcm
->prev_fsize
= 0;
219 spin_unlock_irqrestore(&pstr
->lock
, flags
);
222 /* common PCM trigger callback */
223 int snd_line6_trigger(struct snd_pcm_substream
*substream
, int cmd
)
225 struct snd_line6_pcm
*line6pcm
= snd_pcm_substream_chip(substream
);
226 struct snd_pcm_substream
*s
;
229 clear_bit(LINE6_FLAG_PREPARED
, &line6pcm
->flags
);
231 snd_pcm_group_for_each_entry(s
, substream
) {
232 if (s
->pcm
->card
!= substream
->pcm
->card
)
236 case SNDRV_PCM_TRIGGER_START
:
237 case SNDRV_PCM_TRIGGER_RESUME
:
238 err
= line6_stream_start(line6pcm
, s
->stream
,
244 case SNDRV_PCM_TRIGGER_STOP
:
245 case SNDRV_PCM_TRIGGER_SUSPEND
:
246 line6_stream_stop(line6pcm
, s
->stream
,
250 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
251 if (s
->stream
!= SNDRV_PCM_STREAM_PLAYBACK
)
253 set_bit(LINE6_FLAG_PAUSE_PLAYBACK
, &line6pcm
->flags
);
256 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
257 if (s
->stream
!= SNDRV_PCM_STREAM_PLAYBACK
)
259 clear_bit(LINE6_FLAG_PAUSE_PLAYBACK
, &line6pcm
->flags
);
270 /* common PCM pointer callback */
271 snd_pcm_uframes_t
snd_line6_pointer(struct snd_pcm_substream
*substream
)
273 struct snd_line6_pcm
*line6pcm
= snd_pcm_substream_chip(substream
);
274 struct line6_pcm_stream
*pstr
= get_stream(line6pcm
, substream
->stream
);
276 return pstr
->pos_done
;
279 /* Acquire and start duplex streams:
280 * type is either LINE6_STREAM_IMPULSE or LINE6_STREAM_MONITOR
282 int line6_pcm_acquire(struct snd_line6_pcm
*line6pcm
, int type
)
284 struct line6_pcm_stream
*pstr
;
287 mutex_lock(&line6pcm
->state_mutex
);
288 for (dir
= 0; dir
< 2; dir
++) {
289 pstr
= get_stream(line6pcm
, dir
);
290 ret
= line6_buffer_acquire(line6pcm
, pstr
, type
);
294 line6_wait_clear_audio_urbs(line6pcm
, pstr
);
296 for (dir
= 0; dir
< 2; dir
++) {
297 ret
= line6_stream_start(line6pcm
, dir
, type
);
302 mutex_unlock(&line6pcm
->state_mutex
);
304 line6_pcm_release(line6pcm
, type
);
307 EXPORT_SYMBOL_GPL(line6_pcm_acquire
);
309 /* Stop and release duplex streams */
310 void line6_pcm_release(struct snd_line6_pcm
*line6pcm
, int type
)
312 struct line6_pcm_stream
*pstr
;
315 mutex_lock(&line6pcm
->state_mutex
);
316 for (dir
= 0; dir
< 2; dir
++)
317 line6_stream_stop(line6pcm
, dir
, type
);
318 for (dir
= 0; dir
< 2; dir
++) {
319 pstr
= get_stream(line6pcm
, dir
);
320 line6_buffer_release(line6pcm
, pstr
, type
);
322 mutex_unlock(&line6pcm
->state_mutex
);
324 EXPORT_SYMBOL_GPL(line6_pcm_release
);
326 /* common PCM hw_params callback */
327 int snd_line6_hw_params(struct snd_pcm_substream
*substream
,
328 struct snd_pcm_hw_params
*hw_params
)
331 struct snd_line6_pcm
*line6pcm
= snd_pcm_substream_chip(substream
);
332 struct line6_pcm_stream
*pstr
= get_stream(line6pcm
, substream
->stream
);
334 mutex_lock(&line6pcm
->state_mutex
);
335 ret
= line6_buffer_acquire(line6pcm
, pstr
, LINE6_STREAM_PCM
);
339 ret
= snd_pcm_lib_malloc_pages(substream
,
340 params_buffer_bytes(hw_params
));
342 line6_buffer_release(line6pcm
, pstr
, LINE6_STREAM_PCM
);
346 pstr
->period
= params_period_bytes(hw_params
);
348 mutex_unlock(&line6pcm
->state_mutex
);
352 /* common PCM hw_free callback */
353 int snd_line6_hw_free(struct snd_pcm_substream
*substream
)
355 struct snd_line6_pcm
*line6pcm
= snd_pcm_substream_chip(substream
);
356 struct line6_pcm_stream
*pstr
= get_stream(line6pcm
, substream
->stream
);
358 mutex_lock(&line6pcm
->state_mutex
);
359 line6_buffer_release(line6pcm
, pstr
, LINE6_STREAM_PCM
);
360 mutex_unlock(&line6pcm
->state_mutex
);
361 return snd_pcm_lib_free_pages(substream
);
365 /* control info callback */
366 static int snd_line6_control_playback_info(struct snd_kcontrol
*kcontrol
,
367 struct snd_ctl_elem_info
*uinfo
)
369 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
371 uinfo
->value
.integer
.min
= 0;
372 uinfo
->value
.integer
.max
= 256;
376 /* control get callback */
377 static int snd_line6_control_playback_get(struct snd_kcontrol
*kcontrol
,
378 struct snd_ctl_elem_value
*ucontrol
)
381 struct snd_line6_pcm
*line6pcm
= snd_kcontrol_chip(kcontrol
);
383 for (i
= 0; i
< 2; i
++)
384 ucontrol
->value
.integer
.value
[i
] = line6pcm
->volume_playback
[i
];
389 /* control put callback */
390 static int snd_line6_control_playback_put(struct snd_kcontrol
*kcontrol
,
391 struct snd_ctl_elem_value
*ucontrol
)
394 struct snd_line6_pcm
*line6pcm
= snd_kcontrol_chip(kcontrol
);
396 for (i
= 0; i
< 2; i
++)
397 if (line6pcm
->volume_playback
[i
] !=
398 ucontrol
->value
.integer
.value
[i
]) {
399 line6pcm
->volume_playback
[i
] =
400 ucontrol
->value
.integer
.value
[i
];
407 /* control definition */
408 static struct snd_kcontrol_new line6_controls
[] = {
410 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
411 .name
= "PCM Playback Volume",
412 .info
= snd_line6_control_playback_info
,
413 .get
= snd_line6_control_playback_get
,
414 .put
= snd_line6_control_playback_put
417 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
418 .name
= "Impulse Response Volume",
419 .info
= snd_line6_impulse_volume_info
,
420 .get
= snd_line6_impulse_volume_get
,
421 .put
= snd_line6_impulse_volume_put
424 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
425 .name
= "Impulse Response Period",
426 .info
= snd_line6_impulse_period_info
,
427 .get
= snd_line6_impulse_period_get
,
428 .put
= snd_line6_impulse_period_put
433 Cleanup the PCM device.
435 static void cleanup_urbs(struct line6_pcm_stream
*pcms
)
439 for (i
= 0; i
< LINE6_ISO_BUFFERS
; i
++) {
441 usb_kill_urb(pcms
->urbs
[i
]);
442 usb_free_urb(pcms
->urbs
[i
]);
447 static void line6_cleanup_pcm(struct snd_pcm
*pcm
)
449 struct snd_line6_pcm
*line6pcm
= snd_pcm_chip(pcm
);
451 cleanup_urbs(&line6pcm
->out
);
452 cleanup_urbs(&line6pcm
->in
);
456 /* create a PCM device */
457 static int snd_line6_new_pcm(struct usb_line6
*line6
, struct snd_pcm
**pcm_ret
)
462 err
= snd_pcm_new(line6
->card
, (char *)line6
->properties
->name
,
467 strcpy(pcm
->name
, line6
->properties
->name
);
470 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
,
471 &snd_line6_playback_ops
);
472 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_line6_capture_ops
);
474 /* pre-allocation of buffers */
475 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_CONTINUOUS
,
476 snd_dma_continuous_data
477 (GFP_KERNEL
), 64 * 1024,
483 Sync with PCM stream stops.
485 void line6_pcm_disconnect(struct snd_line6_pcm
*line6pcm
)
487 line6_unlink_audio_urbs(line6pcm
, &line6pcm
->out
);
488 line6_unlink_audio_urbs(line6pcm
, &line6pcm
->in
);
489 line6_wait_clear_audio_urbs(line6pcm
, &line6pcm
->out
);
490 line6_wait_clear_audio_urbs(line6pcm
, &line6pcm
->in
);
494 Create and register the PCM device and mixer entries.
495 Create URBs for playback and capture.
497 int line6_init_pcm(struct usb_line6
*line6
,
498 struct line6_pcm_properties
*properties
)
501 unsigned ep_read
= line6
->properties
->ep_audio_r
;
502 unsigned ep_write
= line6
->properties
->ep_audio_w
;
504 struct snd_line6_pcm
*line6pcm
;
506 if (!(line6
->properties
->capabilities
& LINE6_CAP_PCM
))
507 return 0; /* skip PCM initialization and report success */
509 err
= snd_line6_new_pcm(line6
, &pcm
);
513 line6pcm
= kzalloc(sizeof(*line6pcm
), GFP_KERNEL
);
517 mutex_init(&line6pcm
->state_mutex
);
519 line6pcm
->properties
= properties
;
520 line6pcm
->volume_playback
[0] = line6pcm
->volume_playback
[1] = 255;
521 line6pcm
->volume_monitor
= 255;
522 line6pcm
->line6
= line6
;
524 /* Read and write buffers are sized identically, so choose minimum */
525 line6pcm
->max_packet_size
= min(
526 usb_maxpacket(line6
->usbdev
,
527 usb_rcvisocpipe(line6
->usbdev
, ep_read
), 0),
528 usb_maxpacket(line6
->usbdev
,
529 usb_sndisocpipe(line6
->usbdev
, ep_write
), 1));
531 spin_lock_init(&line6pcm
->out
.lock
);
532 spin_lock_init(&line6pcm
->in
.lock
);
533 line6pcm
->impulse_period
= LINE6_IMPULSE_DEFAULT_PERIOD
;
535 line6
->line6pcm
= line6pcm
;
537 pcm
->private_data
= line6pcm
;
538 pcm
->private_free
= line6_cleanup_pcm
;
540 err
= line6_create_audio_out_urbs(line6pcm
);
544 err
= line6_create_audio_in_urbs(line6pcm
);
549 for (i
= 0; i
< ARRAY_SIZE(line6_controls
); i
++) {
550 err
= snd_ctl_add(line6
->card
,
551 snd_ctl_new1(&line6_controls
[i
], line6pcm
));
558 EXPORT_SYMBOL_GPL(line6_init_pcm
);
560 /* prepare pcm callback */
561 int snd_line6_prepare(struct snd_pcm_substream
*substream
)
563 struct snd_line6_pcm
*line6pcm
= snd_pcm_substream_chip(substream
);
564 struct line6_pcm_stream
*pstr
= get_stream(line6pcm
, substream
->stream
);
566 mutex_lock(&line6pcm
->state_mutex
);
568 line6_wait_clear_audio_urbs(line6pcm
, pstr
);
570 if (!test_and_set_bit(LINE6_FLAG_PREPARED
, &line6pcm
->flags
)) {
571 line6pcm
->out
.count
= 0;
572 line6pcm
->out
.pos
= 0;
573 line6pcm
->out
.pos_done
= 0;
574 line6pcm
->out
.bytes
= 0;
575 line6pcm
->in
.count
= 0;
576 line6pcm
->in
.pos_done
= 0;
577 line6pcm
->in
.bytes
= 0;
580 mutex_unlock(&line6pcm
->state_mutex
);