5 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
7 * More accurate positioning and full-duplex support:
8 * Copyright (c) Ahmet İnan <ainan at mathematik.uni-freiburg.de>
10 * Major (almost complete) rewrite:
11 * Copyright (c) by Takashi Iwai <tiwai@suse.de>
13 * A next major update in 2010 (separate timers for playback and capture):
14 * Copyright (c) Jaroslav Kysela <perex@perex.cz>
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
32 #include <linux/init.h>
33 #include <linux/jiffies.h>
34 #include <linux/slab.h>
35 #include <linux/time.h>
36 #include <linux/wait.h>
37 #include <linux/module.h>
38 #include <linux/platform_device.h>
39 #include <sound/core.h>
40 #include <sound/control.h>
41 #include <sound/pcm.h>
42 #include <sound/pcm_params.h>
43 #include <sound/info.h>
44 #include <sound/initval.h>
46 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
47 MODULE_DESCRIPTION("A loopback soundcard");
48 MODULE_LICENSE("GPL");
49 MODULE_SUPPORTED_DEVICE("{{ALSA,Loopback soundcard}}");
51 #define MAX_PCM_SUBSTREAMS 8
53 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
; /* Index 0-MAX */
54 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* ID for this card */
55 static bool enable
[SNDRV_CARDS
] = {1, [1 ... (SNDRV_CARDS
- 1)] = 0};
56 static int pcm_substreams
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = 8};
57 static int pcm_notify
[SNDRV_CARDS
];
59 module_param_array(index
, int, NULL
, 0444);
60 MODULE_PARM_DESC(index
, "Index value for loopback soundcard.");
61 module_param_array(id
, charp
, NULL
, 0444);
62 MODULE_PARM_DESC(id
, "ID string for loopback soundcard.");
63 module_param_array(enable
, bool, NULL
, 0444);
64 MODULE_PARM_DESC(enable
, "Enable this loopback soundcard.");
65 module_param_array(pcm_substreams
, int, NULL
, 0444);
66 MODULE_PARM_DESC(pcm_substreams
, "PCM substreams # (1-8) for loopback driver.");
67 module_param_array(pcm_notify
, int, NULL
, 0444);
68 MODULE_PARM_DESC(pcm_notify
, "Break capture when PCM format/rate/channels changes.");
70 #define NO_PITCH 100000
74 struct loopback_cable
{
76 struct loopback_pcm
*streams
[2];
77 struct snd_pcm_hardware hw
;
84 struct loopback_setup
{
85 unsigned int notify
: 1;
86 unsigned int rate_shift
;
89 unsigned int channels
;
90 struct snd_ctl_elem_id active_id
;
91 struct snd_ctl_elem_id format_id
;
92 struct snd_ctl_elem_id rate_id
;
93 struct snd_ctl_elem_id channels_id
;
97 struct snd_card
*card
;
98 struct mutex cable_lock
;
99 struct loopback_cable
*cables
[MAX_PCM_SUBSTREAMS
][2];
100 struct snd_pcm
*pcm
[2];
101 struct loopback_setup setup
[MAX_PCM_SUBSTREAMS
][2];
104 struct loopback_pcm
{
105 struct loopback
*loopback
;
106 struct snd_pcm_substream
*substream
;
107 struct loopback_cable
*cable
;
108 unsigned int pcm_buffer_size
;
109 unsigned int buf_pos
; /* position in buffer */
110 unsigned int silent_size
;
112 unsigned int pcm_period_size
;
113 unsigned int pcm_bps
; /* bytes per second */
114 unsigned int pcm_salign
; /* bytes per sample * channels */
115 unsigned int pcm_rate_shift
; /* rate shift value */
117 unsigned int period_update_pending
:1;
119 unsigned int irq_pos
; /* fractional IRQ position */
120 unsigned int period_size_frac
;
121 unsigned int last_drift
;
122 unsigned long last_jiffies
;
123 struct timer_list timer
;
126 static struct platform_device
*devices
[SNDRV_CARDS
];
128 static inline unsigned int byte_pos(struct loopback_pcm
*dpcm
, unsigned int x
)
130 if (dpcm
->pcm_rate_shift
== NO_PITCH
) {
133 x
= div_u64(NO_PITCH
* (unsigned long long)x
,
134 HZ
* (unsigned long long)dpcm
->pcm_rate_shift
);
136 return x
- (x
% dpcm
->pcm_salign
);
139 static inline unsigned int frac_pos(struct loopback_pcm
*dpcm
, unsigned int x
)
141 if (dpcm
->pcm_rate_shift
== NO_PITCH
) { /* no pitch */
144 x
= div_u64(dpcm
->pcm_rate_shift
* (unsigned long long)x
* HZ
,
150 static inline struct loopback_setup
*get_setup(struct loopback_pcm
*dpcm
)
152 int device
= dpcm
->substream
->pstr
->pcm
->device
;
154 if (dpcm
->substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
156 return &dpcm
->loopback
->setup
[dpcm
->substream
->number
][device
];
159 static inline unsigned int get_notify(struct loopback_pcm
*dpcm
)
161 return get_setup(dpcm
)->notify
;
164 static inline unsigned int get_rate_shift(struct loopback_pcm
*dpcm
)
166 return get_setup(dpcm
)->rate_shift
;
169 /* call in cable->lock */
170 static void loopback_timer_start(struct loopback_pcm
*dpcm
)
173 unsigned int rate_shift
= get_rate_shift(dpcm
);
175 if (rate_shift
!= dpcm
->pcm_rate_shift
) {
176 dpcm
->pcm_rate_shift
= rate_shift
;
177 dpcm
->period_size_frac
= frac_pos(dpcm
, dpcm
->pcm_period_size
);
179 if (dpcm
->period_size_frac
<= dpcm
->irq_pos
) {
180 dpcm
->irq_pos
%= dpcm
->period_size_frac
;
181 dpcm
->period_update_pending
= 1;
183 tick
= dpcm
->period_size_frac
- dpcm
->irq_pos
;
184 tick
= (tick
+ dpcm
->pcm_bps
- 1) / dpcm
->pcm_bps
;
185 mod_timer(&dpcm
->timer
, jiffies
+ tick
);
188 /* call in cable->lock */
189 static inline void loopback_timer_stop(struct loopback_pcm
*dpcm
)
191 del_timer(&dpcm
->timer
);
192 dpcm
->timer
.expires
= 0;
195 static inline void loopback_timer_stop_sync(struct loopback_pcm
*dpcm
)
197 del_timer_sync(&dpcm
->timer
);
200 #define CABLE_VALID_PLAYBACK (1 << SNDRV_PCM_STREAM_PLAYBACK)
201 #define CABLE_VALID_CAPTURE (1 << SNDRV_PCM_STREAM_CAPTURE)
202 #define CABLE_VALID_BOTH (CABLE_VALID_PLAYBACK|CABLE_VALID_CAPTURE)
204 static int loopback_check_format(struct loopback_cable
*cable
, int stream
)
206 struct snd_pcm_runtime
*runtime
, *cruntime
;
207 struct loopback_setup
*setup
;
208 struct snd_card
*card
;
211 if (cable
->valid
!= CABLE_VALID_BOTH
) {
212 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
)
216 runtime
= cable
->streams
[SNDRV_PCM_STREAM_PLAYBACK
]->
218 cruntime
= cable
->streams
[SNDRV_PCM_STREAM_CAPTURE
]->
220 check
= runtime
->format
!= cruntime
->format
||
221 runtime
->rate
!= cruntime
->rate
||
222 runtime
->channels
!= cruntime
->channels
;
225 if (stream
== SNDRV_PCM_STREAM_CAPTURE
) {
228 snd_pcm_stop(cable
->streams
[SNDRV_PCM_STREAM_CAPTURE
]->
229 substream
, SNDRV_PCM_STATE_DRAINING
);
231 runtime
= cable
->streams
[SNDRV_PCM_STREAM_PLAYBACK
]->
233 setup
= get_setup(cable
->streams
[SNDRV_PCM_STREAM_PLAYBACK
]);
234 card
= cable
->streams
[SNDRV_PCM_STREAM_PLAYBACK
]->loopback
->card
;
235 if (setup
->format
!= runtime
->format
) {
236 snd_ctl_notify(card
, SNDRV_CTL_EVENT_MASK_VALUE
,
238 setup
->format
= runtime
->format
;
240 if (setup
->rate
!= runtime
->rate
) {
241 snd_ctl_notify(card
, SNDRV_CTL_EVENT_MASK_VALUE
,
243 setup
->rate
= runtime
->rate
;
245 if (setup
->channels
!= runtime
->channels
) {
246 snd_ctl_notify(card
, SNDRV_CTL_EVENT_MASK_VALUE
,
247 &setup
->channels_id
);
248 setup
->channels
= runtime
->channels
;
254 static void loopback_active_notify(struct loopback_pcm
*dpcm
)
256 snd_ctl_notify(dpcm
->loopback
->card
,
257 SNDRV_CTL_EVENT_MASK_VALUE
,
258 &get_setup(dpcm
)->active_id
);
261 static int loopback_trigger(struct snd_pcm_substream
*substream
, int cmd
)
263 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
264 struct loopback_pcm
*dpcm
= runtime
->private_data
;
265 struct loopback_cable
*cable
= dpcm
->cable
;
266 int err
, stream
= 1 << substream
->stream
;
269 case SNDRV_PCM_TRIGGER_START
:
270 err
= loopback_check_format(cable
, substream
->stream
);
273 dpcm
->last_jiffies
= jiffies
;
274 dpcm
->pcm_rate_shift
= 0;
275 dpcm
->last_drift
= 0;
276 spin_lock(&cable
->lock
);
277 cable
->running
|= stream
;
278 cable
->pause
&= ~stream
;
279 loopback_timer_start(dpcm
);
280 spin_unlock(&cable
->lock
);
281 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
282 loopback_active_notify(dpcm
);
284 case SNDRV_PCM_TRIGGER_STOP
:
285 spin_lock(&cable
->lock
);
286 cable
->running
&= ~stream
;
287 cable
->pause
&= ~stream
;
288 loopback_timer_stop(dpcm
);
289 spin_unlock(&cable
->lock
);
290 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
291 loopback_active_notify(dpcm
);
293 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
294 case SNDRV_PCM_TRIGGER_SUSPEND
:
295 spin_lock(&cable
->lock
);
296 cable
->pause
|= stream
;
297 loopback_timer_stop(dpcm
);
298 spin_unlock(&cable
->lock
);
299 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
300 loopback_active_notify(dpcm
);
302 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
303 case SNDRV_PCM_TRIGGER_RESUME
:
304 spin_lock(&cable
->lock
);
305 dpcm
->last_jiffies
= jiffies
;
306 cable
->pause
&= ~stream
;
307 loopback_timer_start(dpcm
);
308 spin_unlock(&cable
->lock
);
309 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
310 loopback_active_notify(dpcm
);
318 static void params_change(struct snd_pcm_substream
*substream
)
320 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
321 struct loopback_pcm
*dpcm
= runtime
->private_data
;
322 struct loopback_cable
*cable
= dpcm
->cable
;
324 cable
->hw
.formats
= pcm_format_to_bits(runtime
->format
);
325 cable
->hw
.rate_min
= runtime
->rate
;
326 cable
->hw
.rate_max
= runtime
->rate
;
327 cable
->hw
.channels_min
= runtime
->channels
;
328 cable
->hw
.channels_max
= runtime
->channels
;
331 static int loopback_prepare(struct snd_pcm_substream
*substream
)
333 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
334 struct loopback_pcm
*dpcm
= runtime
->private_data
;
335 struct loopback_cable
*cable
= dpcm
->cable
;
338 loopback_timer_stop_sync(dpcm
);
340 salign
= (snd_pcm_format_physical_width(runtime
->format
) *
341 runtime
->channels
) / 8;
342 bps
= salign
* runtime
->rate
;
343 if (bps
<= 0 || salign
<= 0)
347 dpcm
->pcm_buffer_size
= frames_to_bytes(runtime
, runtime
->buffer_size
);
348 if (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
) {
349 /* clear capture buffer */
350 dpcm
->silent_size
= dpcm
->pcm_buffer_size
;
351 snd_pcm_format_set_silence(runtime
->format
, runtime
->dma_area
,
352 runtime
->buffer_size
* runtime
->channels
);
356 dpcm
->period_update_pending
= 0;
358 dpcm
->pcm_salign
= salign
;
359 dpcm
->pcm_period_size
= frames_to_bytes(runtime
, runtime
->period_size
);
361 mutex_lock(&dpcm
->loopback
->cable_lock
);
362 if (!(cable
->valid
& ~(1 << substream
->stream
)) ||
363 (get_setup(dpcm
)->notify
&&
364 substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
))
365 params_change(substream
);
366 cable
->valid
|= 1 << substream
->stream
;
367 mutex_unlock(&dpcm
->loopback
->cable_lock
);
372 static void clear_capture_buf(struct loopback_pcm
*dpcm
, unsigned int bytes
)
374 struct snd_pcm_runtime
*runtime
= dpcm
->substream
->runtime
;
375 char *dst
= runtime
->dma_area
;
376 unsigned int dst_off
= dpcm
->buf_pos
;
378 if (dpcm
->silent_size
>= dpcm
->pcm_buffer_size
)
380 if (dpcm
->silent_size
+ bytes
> dpcm
->pcm_buffer_size
)
381 bytes
= dpcm
->pcm_buffer_size
- dpcm
->silent_size
;
384 unsigned int size
= bytes
;
385 if (dst_off
+ size
> dpcm
->pcm_buffer_size
)
386 size
= dpcm
->pcm_buffer_size
- dst_off
;
387 snd_pcm_format_set_silence(runtime
->format
, dst
+ dst_off
,
388 bytes_to_frames(runtime
, size
) *
390 dpcm
->silent_size
+= size
;
398 static void copy_play_buf(struct loopback_pcm
*play
,
399 struct loopback_pcm
*capt
,
402 struct snd_pcm_runtime
*runtime
= play
->substream
->runtime
;
403 char *src
= runtime
->dma_area
;
404 char *dst
= capt
->substream
->runtime
->dma_area
;
405 unsigned int src_off
= play
->buf_pos
;
406 unsigned int dst_off
= capt
->buf_pos
;
407 unsigned int clear_bytes
= 0;
409 /* check if playback is draining, trim the capture copy size
410 * when our pointer is at the end of playback ring buffer */
411 if (runtime
->status
->state
== SNDRV_PCM_STATE_DRAINING
&&
412 snd_pcm_playback_hw_avail(runtime
) < runtime
->buffer_size
) {
413 snd_pcm_uframes_t appl_ptr
, appl_ptr1
, diff
;
414 appl_ptr
= appl_ptr1
= runtime
->control
->appl_ptr
;
415 appl_ptr1
-= appl_ptr1
% runtime
->buffer_size
;
416 appl_ptr1
+= play
->buf_pos
/ play
->pcm_salign
;
417 if (appl_ptr
< appl_ptr1
)
418 appl_ptr1
-= runtime
->buffer_size
;
419 diff
= (appl_ptr
- appl_ptr1
) * play
->pcm_salign
;
421 clear_bytes
= bytes
- diff
;
427 unsigned int size
= bytes
;
428 if (src_off
+ size
> play
->pcm_buffer_size
)
429 size
= play
->pcm_buffer_size
- src_off
;
430 if (dst_off
+ size
> capt
->pcm_buffer_size
)
431 size
= capt
->pcm_buffer_size
- dst_off
;
432 memcpy(dst
+ dst_off
, src
+ src_off
, size
);
433 capt
->silent_size
= 0;
437 src_off
= (src_off
+ size
) % play
->pcm_buffer_size
;
438 dst_off
= (dst_off
+ size
) % capt
->pcm_buffer_size
;
441 if (clear_bytes
> 0) {
442 clear_capture_buf(capt
, clear_bytes
);
443 capt
->silent_size
= 0;
447 static inline unsigned int bytepos_delta(struct loopback_pcm
*dpcm
,
448 unsigned int jiffies_delta
)
450 unsigned long last_pos
;
453 last_pos
= byte_pos(dpcm
, dpcm
->irq_pos
);
454 dpcm
->irq_pos
+= jiffies_delta
* dpcm
->pcm_bps
;
455 delta
= byte_pos(dpcm
, dpcm
->irq_pos
) - last_pos
;
456 if (delta
>= dpcm
->last_drift
)
457 delta
-= dpcm
->last_drift
;
458 dpcm
->last_drift
= 0;
459 if (dpcm
->irq_pos
>= dpcm
->period_size_frac
) {
460 dpcm
->irq_pos
%= dpcm
->period_size_frac
;
461 dpcm
->period_update_pending
= 1;
466 static inline void bytepos_finish(struct loopback_pcm
*dpcm
,
469 dpcm
->buf_pos
+= delta
;
470 dpcm
->buf_pos
%= dpcm
->pcm_buffer_size
;
473 /* call in cable->lock */
474 static unsigned int loopback_pos_update(struct loopback_cable
*cable
)
476 struct loopback_pcm
*dpcm_play
=
477 cable
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
478 struct loopback_pcm
*dpcm_capt
=
479 cable
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
480 unsigned long delta_play
= 0, delta_capt
= 0;
481 unsigned int running
, count1
, count2
;
483 running
= cable
->running
^ cable
->pause
;
484 if (running
& (1 << SNDRV_PCM_STREAM_PLAYBACK
)) {
485 delta_play
= jiffies
- dpcm_play
->last_jiffies
;
486 dpcm_play
->last_jiffies
+= delta_play
;
489 if (running
& (1 << SNDRV_PCM_STREAM_CAPTURE
)) {
490 delta_capt
= jiffies
- dpcm_capt
->last_jiffies
;
491 dpcm_capt
->last_jiffies
+= delta_capt
;
494 if (delta_play
== 0 && delta_capt
== 0)
497 if (delta_play
> delta_capt
) {
498 count1
= bytepos_delta(dpcm_play
, delta_play
- delta_capt
);
499 bytepos_finish(dpcm_play
, count1
);
500 delta_play
= delta_capt
;
501 } else if (delta_play
< delta_capt
) {
502 count1
= bytepos_delta(dpcm_capt
, delta_capt
- delta_play
);
503 clear_capture_buf(dpcm_capt
, count1
);
504 bytepos_finish(dpcm_capt
, count1
);
505 delta_capt
= delta_play
;
508 if (delta_play
== 0 && delta_capt
== 0)
511 /* note delta_capt == delta_play at this moment */
512 count1
= bytepos_delta(dpcm_play
, delta_play
);
513 count2
= bytepos_delta(dpcm_capt
, delta_capt
);
514 if (count1
< count2
) {
515 dpcm_capt
->last_drift
= count2
- count1
;
517 } else if (count1
> count2
) {
518 dpcm_play
->last_drift
= count1
- count2
;
520 copy_play_buf(dpcm_play
, dpcm_capt
, count1
);
521 bytepos_finish(dpcm_play
, count1
);
522 bytepos_finish(dpcm_capt
, count1
);
527 static void loopback_timer_function(struct timer_list
*t
)
529 struct loopback_pcm
*dpcm
= from_timer(dpcm
, t
, timer
);
532 spin_lock_irqsave(&dpcm
->cable
->lock
, flags
);
533 if (loopback_pos_update(dpcm
->cable
) & (1 << dpcm
->substream
->stream
)) {
534 loopback_timer_start(dpcm
);
535 if (dpcm
->period_update_pending
) {
536 dpcm
->period_update_pending
= 0;
537 spin_unlock_irqrestore(&dpcm
->cable
->lock
, flags
);
538 /* need to unlock before calling below */
539 snd_pcm_period_elapsed(dpcm
->substream
);
543 spin_unlock_irqrestore(&dpcm
->cable
->lock
, flags
);
546 static snd_pcm_uframes_t
loopback_pointer(struct snd_pcm_substream
*substream
)
548 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
549 struct loopback_pcm
*dpcm
= runtime
->private_data
;
550 snd_pcm_uframes_t pos
;
552 spin_lock(&dpcm
->cable
->lock
);
553 loopback_pos_update(dpcm
->cable
);
555 spin_unlock(&dpcm
->cable
->lock
);
556 return bytes_to_frames(runtime
, pos
);
559 static const struct snd_pcm_hardware loopback_pcm_hardware
=
561 .info
= (SNDRV_PCM_INFO_INTERLEAVED
| SNDRV_PCM_INFO_MMAP
|
562 SNDRV_PCM_INFO_MMAP_VALID
| SNDRV_PCM_INFO_PAUSE
|
563 SNDRV_PCM_INFO_RESUME
),
564 .formats
= (SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_S16_BE
|
565 SNDRV_PCM_FMTBIT_S24_LE
| SNDRV_PCM_FMTBIT_S24_BE
|
566 SNDRV_PCM_FMTBIT_S24_3LE
| SNDRV_PCM_FMTBIT_S24_3BE
|
567 SNDRV_PCM_FMTBIT_S32_LE
| SNDRV_PCM_FMTBIT_S32_BE
|
568 SNDRV_PCM_FMTBIT_FLOAT_LE
| SNDRV_PCM_FMTBIT_FLOAT_BE
),
569 .rates
= SNDRV_PCM_RATE_CONTINUOUS
| SNDRV_PCM_RATE_8000_192000
,
574 .buffer_bytes_max
= 2 * 1024 * 1024,
575 .period_bytes_min
= 64,
576 /* note check overflow in frac_pos() using pcm_rate_shift before
577 changing period_bytes_max value */
578 .period_bytes_max
= 1024 * 1024,
584 static void loopback_runtime_free(struct snd_pcm_runtime
*runtime
)
586 struct loopback_pcm
*dpcm
= runtime
->private_data
;
590 static int loopback_hw_params(struct snd_pcm_substream
*substream
,
591 struct snd_pcm_hw_params
*params
)
593 return snd_pcm_lib_alloc_vmalloc_buffer(substream
,
594 params_buffer_bytes(params
));
597 static int loopback_hw_free(struct snd_pcm_substream
*substream
)
599 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
600 struct loopback_pcm
*dpcm
= runtime
->private_data
;
601 struct loopback_cable
*cable
= dpcm
->cable
;
603 mutex_lock(&dpcm
->loopback
->cable_lock
);
604 cable
->valid
&= ~(1 << substream
->stream
);
605 mutex_unlock(&dpcm
->loopback
->cable_lock
);
606 return snd_pcm_lib_free_vmalloc_buffer(substream
);
609 static unsigned int get_cable_index(struct snd_pcm_substream
*substream
)
611 if (!substream
->pcm
->device
)
612 return substream
->stream
;
614 return !substream
->stream
;
617 static int rule_format(struct snd_pcm_hw_params
*params
,
618 struct snd_pcm_hw_rule
*rule
)
620 struct loopback_pcm
*dpcm
= rule
->private;
621 struct loopback_cable
*cable
= dpcm
->cable
;
625 mutex_lock(&dpcm
->loopback
->cable_lock
);
626 m
.bits
[0] = (u_int32_t
)cable
->hw
.formats
;
627 m
.bits
[1] = (u_int32_t
)(cable
->hw
.formats
>> 32);
628 mutex_unlock(&dpcm
->loopback
->cable_lock
);
629 return snd_mask_refine(hw_param_mask(params
, rule
->var
), &m
);
632 static int rule_rate(struct snd_pcm_hw_params
*params
,
633 struct snd_pcm_hw_rule
*rule
)
635 struct loopback_pcm
*dpcm
= rule
->private;
636 struct loopback_cable
*cable
= dpcm
->cable
;
637 struct snd_interval t
;
639 mutex_lock(&dpcm
->loopback
->cable_lock
);
640 t
.min
= cable
->hw
.rate_min
;
641 t
.max
= cable
->hw
.rate_max
;
642 mutex_unlock(&dpcm
->loopback
->cable_lock
);
643 t
.openmin
= t
.openmax
= 0;
645 return snd_interval_refine(hw_param_interval(params
, rule
->var
), &t
);
648 static int rule_channels(struct snd_pcm_hw_params
*params
,
649 struct snd_pcm_hw_rule
*rule
)
651 struct loopback_pcm
*dpcm
= rule
->private;
652 struct loopback_cable
*cable
= dpcm
->cable
;
653 struct snd_interval t
;
655 mutex_lock(&dpcm
->loopback
->cable_lock
);
656 t
.min
= cable
->hw
.channels_min
;
657 t
.max
= cable
->hw
.channels_max
;
658 mutex_unlock(&dpcm
->loopback
->cable_lock
);
659 t
.openmin
= t
.openmax
= 0;
661 return snd_interval_refine(hw_param_interval(params
, rule
->var
), &t
);
664 static void free_cable(struct snd_pcm_substream
*substream
)
666 struct loopback
*loopback
= substream
->private_data
;
667 int dev
= get_cable_index(substream
);
668 struct loopback_cable
*cable
;
670 cable
= loopback
->cables
[substream
->number
][dev
];
673 if (cable
->streams
[!substream
->stream
]) {
674 /* other stream is still alive */
675 spin_lock_irq(&cable
->lock
);
676 cable
->streams
[substream
->stream
] = NULL
;
677 spin_unlock_irq(&cable
->lock
);
680 loopback
->cables
[substream
->number
][dev
] = NULL
;
685 static int loopback_open(struct snd_pcm_substream
*substream
)
687 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
688 struct loopback
*loopback
= substream
->private_data
;
689 struct loopback_pcm
*dpcm
;
690 struct loopback_cable
*cable
= NULL
;
692 int dev
= get_cable_index(substream
);
694 mutex_lock(&loopback
->cable_lock
);
695 dpcm
= kzalloc(sizeof(*dpcm
), GFP_KERNEL
);
700 dpcm
->loopback
= loopback
;
701 dpcm
->substream
= substream
;
702 timer_setup(&dpcm
->timer
, loopback_timer_function
, 0);
704 cable
= loopback
->cables
[substream
->number
][dev
];
706 cable
= kzalloc(sizeof(*cable
), GFP_KERNEL
);
711 spin_lock_init(&cable
->lock
);
712 cable
->hw
= loopback_pcm_hardware
;
713 loopback
->cables
[substream
->number
][dev
] = cable
;
717 snd_pcm_hw_constraint_integer(runtime
, SNDRV_PCM_HW_PARAM_PERIODS
);
719 /* use dynamic rules based on actual runtime->hw values */
720 /* note that the default rules created in the PCM midlevel code */
721 /* are cached -> they do not reflect the actual state */
722 err
= snd_pcm_hw_rule_add(runtime
, 0,
723 SNDRV_PCM_HW_PARAM_FORMAT
,
725 SNDRV_PCM_HW_PARAM_FORMAT
, -1);
728 err
= snd_pcm_hw_rule_add(runtime
, 0,
729 SNDRV_PCM_HW_PARAM_RATE
,
731 SNDRV_PCM_HW_PARAM_RATE
, -1);
734 err
= snd_pcm_hw_rule_add(runtime
, 0,
735 SNDRV_PCM_HW_PARAM_CHANNELS
,
737 SNDRV_PCM_HW_PARAM_CHANNELS
, -1);
741 runtime
->private_data
= dpcm
;
742 runtime
->private_free
= loopback_runtime_free
;
743 if (get_notify(dpcm
))
744 runtime
->hw
= loopback_pcm_hardware
;
746 runtime
->hw
= cable
->hw
;
748 spin_lock_irq(&cable
->lock
);
749 cable
->streams
[substream
->stream
] = dpcm
;
750 spin_unlock_irq(&cable
->lock
);
754 free_cable(substream
);
757 mutex_unlock(&loopback
->cable_lock
);
761 static int loopback_close(struct snd_pcm_substream
*substream
)
763 struct loopback
*loopback
= substream
->private_data
;
764 struct loopback_pcm
*dpcm
= substream
->runtime
->private_data
;
766 loopback_timer_stop_sync(dpcm
);
767 mutex_lock(&loopback
->cable_lock
);
768 free_cable(substream
);
769 mutex_unlock(&loopback
->cable_lock
);
773 static const struct snd_pcm_ops loopback_pcm_ops
= {
774 .open
= loopback_open
,
775 .close
= loopback_close
,
776 .ioctl
= snd_pcm_lib_ioctl
,
777 .hw_params
= loopback_hw_params
,
778 .hw_free
= loopback_hw_free
,
779 .prepare
= loopback_prepare
,
780 .trigger
= loopback_trigger
,
781 .pointer
= loopback_pointer
,
782 .page
= snd_pcm_lib_get_vmalloc_page
,
785 static int loopback_pcm_new(struct loopback
*loopback
,
786 int device
, int substreams
)
791 err
= snd_pcm_new(loopback
->card
, "Loopback PCM", device
,
792 substreams
, substreams
, &pcm
);
795 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &loopback_pcm_ops
);
796 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &loopback_pcm_ops
);
798 pcm
->private_data
= loopback
;
800 strcpy(pcm
->name
, "Loopback PCM");
802 loopback
->pcm
[device
] = pcm
;
806 static int loopback_rate_shift_info(struct snd_kcontrol
*kcontrol
,
807 struct snd_ctl_elem_info
*uinfo
)
809 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
811 uinfo
->value
.integer
.min
= 80000;
812 uinfo
->value
.integer
.max
= 120000;
813 uinfo
->value
.integer
.step
= 1;
817 static int loopback_rate_shift_get(struct snd_kcontrol
*kcontrol
,
818 struct snd_ctl_elem_value
*ucontrol
)
820 struct loopback
*loopback
= snd_kcontrol_chip(kcontrol
);
822 mutex_lock(&loopback
->cable_lock
);
823 ucontrol
->value
.integer
.value
[0] =
824 loopback
->setup
[kcontrol
->id
.subdevice
]
825 [kcontrol
->id
.device
].rate_shift
;
826 mutex_unlock(&loopback
->cable_lock
);
830 static int loopback_rate_shift_put(struct snd_kcontrol
*kcontrol
,
831 struct snd_ctl_elem_value
*ucontrol
)
833 struct loopback
*loopback
= snd_kcontrol_chip(kcontrol
);
837 val
= ucontrol
->value
.integer
.value
[0];
842 mutex_lock(&loopback
->cable_lock
);
843 if (val
!= loopback
->setup
[kcontrol
->id
.subdevice
]
844 [kcontrol
->id
.device
].rate_shift
) {
845 loopback
->setup
[kcontrol
->id
.subdevice
]
846 [kcontrol
->id
.device
].rate_shift
= val
;
849 mutex_unlock(&loopback
->cable_lock
);
853 static int loopback_notify_get(struct snd_kcontrol
*kcontrol
,
854 struct snd_ctl_elem_value
*ucontrol
)
856 struct loopback
*loopback
= snd_kcontrol_chip(kcontrol
);
858 mutex_lock(&loopback
->cable_lock
);
859 ucontrol
->value
.integer
.value
[0] =
860 loopback
->setup
[kcontrol
->id
.subdevice
]
861 [kcontrol
->id
.device
].notify
;
862 mutex_unlock(&loopback
->cable_lock
);
866 static int loopback_notify_put(struct snd_kcontrol
*kcontrol
,
867 struct snd_ctl_elem_value
*ucontrol
)
869 struct loopback
*loopback
= snd_kcontrol_chip(kcontrol
);
873 val
= ucontrol
->value
.integer
.value
[0] ? 1 : 0;
874 mutex_lock(&loopback
->cable_lock
);
875 if (val
!= loopback
->setup
[kcontrol
->id
.subdevice
]
876 [kcontrol
->id
.device
].notify
) {
877 loopback
->setup
[kcontrol
->id
.subdevice
]
878 [kcontrol
->id
.device
].notify
= val
;
881 mutex_unlock(&loopback
->cable_lock
);
885 static int loopback_active_get(struct snd_kcontrol
*kcontrol
,
886 struct snd_ctl_elem_value
*ucontrol
)
888 struct loopback
*loopback
= snd_kcontrol_chip(kcontrol
);
889 struct loopback_cable
*cable
;
891 unsigned int val
= 0;
893 mutex_lock(&loopback
->cable_lock
);
894 cable
= loopback
->cables
[kcontrol
->id
.subdevice
][kcontrol
->id
.device
^ 1];
896 unsigned int running
= cable
->running
^ cable
->pause
;
898 val
= (running
& (1 << SNDRV_PCM_STREAM_PLAYBACK
)) ? 1 : 0;
900 mutex_unlock(&loopback
->cable_lock
);
901 ucontrol
->value
.integer
.value
[0] = val
;
905 static int loopback_format_info(struct snd_kcontrol
*kcontrol
,
906 struct snd_ctl_elem_info
*uinfo
)
908 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
910 uinfo
->value
.integer
.min
= 0;
911 uinfo
->value
.integer
.max
= SNDRV_PCM_FORMAT_LAST
;
912 uinfo
->value
.integer
.step
= 1;
916 static int loopback_format_get(struct snd_kcontrol
*kcontrol
,
917 struct snd_ctl_elem_value
*ucontrol
)
919 struct loopback
*loopback
= snd_kcontrol_chip(kcontrol
);
921 ucontrol
->value
.integer
.value
[0] =
922 loopback
->setup
[kcontrol
->id
.subdevice
]
923 [kcontrol
->id
.device
].format
;
927 static int loopback_rate_info(struct snd_kcontrol
*kcontrol
,
928 struct snd_ctl_elem_info
*uinfo
)
930 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
932 uinfo
->value
.integer
.min
= 0;
933 uinfo
->value
.integer
.max
= 192000;
934 uinfo
->value
.integer
.step
= 1;
938 static int loopback_rate_get(struct snd_kcontrol
*kcontrol
,
939 struct snd_ctl_elem_value
*ucontrol
)
941 struct loopback
*loopback
= snd_kcontrol_chip(kcontrol
);
943 mutex_lock(&loopback
->cable_lock
);
944 ucontrol
->value
.integer
.value
[0] =
945 loopback
->setup
[kcontrol
->id
.subdevice
]
946 [kcontrol
->id
.device
].rate
;
947 mutex_unlock(&loopback
->cable_lock
);
951 static int loopback_channels_info(struct snd_kcontrol
*kcontrol
,
952 struct snd_ctl_elem_info
*uinfo
)
954 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
956 uinfo
->value
.integer
.min
= 1;
957 uinfo
->value
.integer
.max
= 1024;
958 uinfo
->value
.integer
.step
= 1;
962 static int loopback_channels_get(struct snd_kcontrol
*kcontrol
,
963 struct snd_ctl_elem_value
*ucontrol
)
965 struct loopback
*loopback
= snd_kcontrol_chip(kcontrol
);
967 mutex_lock(&loopback
->cable_lock
);
968 ucontrol
->value
.integer
.value
[0] =
969 loopback
->setup
[kcontrol
->id
.subdevice
]
970 [kcontrol
->id
.device
].channels
;
971 mutex_unlock(&loopback
->cable_lock
);
975 static struct snd_kcontrol_new loopback_controls
[] = {
977 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
978 .name
= "PCM Rate Shift 100000",
979 .info
= loopback_rate_shift_info
,
980 .get
= loopback_rate_shift_get
,
981 .put
= loopback_rate_shift_put
,
984 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
985 .name
= "PCM Notify",
986 .info
= snd_ctl_boolean_mono_info
,
987 .get
= loopback_notify_get
,
988 .put
= loopback_notify_put
,
992 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
993 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
994 .name
= "PCM Slave Active",
995 .info
= snd_ctl_boolean_mono_info
,
996 .get
= loopback_active_get
,
1000 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
1001 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
1002 .name
= "PCM Slave Format",
1003 .info
= loopback_format_info
,
1004 .get
= loopback_format_get
1008 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
1009 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
1010 .name
= "PCM Slave Rate",
1011 .info
= loopback_rate_info
,
1012 .get
= loopback_rate_get
1014 #define CHANNELS_IDX 5
1016 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
1017 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
1018 .name
= "PCM Slave Channels",
1019 .info
= loopback_channels_info
,
1020 .get
= loopback_channels_get
1024 static int loopback_mixer_new(struct loopback
*loopback
, int notify
)
1026 struct snd_card
*card
= loopback
->card
;
1027 struct snd_pcm
*pcm
;
1028 struct snd_kcontrol
*kctl
;
1029 struct loopback_setup
*setup
;
1030 int err
, dev
, substr
, substr_count
, idx
;
1032 strcpy(card
->mixername
, "Loopback Mixer");
1033 for (dev
= 0; dev
< 2; dev
++) {
1034 pcm
= loopback
->pcm
[dev
];
1036 pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream_count
;
1037 for (substr
= 0; substr
< substr_count
; substr
++) {
1038 setup
= &loopback
->setup
[substr
][dev
];
1039 setup
->notify
= notify
;
1040 setup
->rate_shift
= NO_PITCH
;
1041 setup
->format
= SNDRV_PCM_FORMAT_S16_LE
;
1042 setup
->rate
= 48000;
1043 setup
->channels
= 2;
1044 for (idx
= 0; idx
< ARRAY_SIZE(loopback_controls
);
1046 kctl
= snd_ctl_new1(&loopback_controls
[idx
],
1050 kctl
->id
.device
= dev
;
1051 kctl
->id
.subdevice
= substr
;
1054 setup
->active_id
= kctl
->id
;
1057 setup
->format_id
= kctl
->id
;
1060 setup
->rate_id
= kctl
->id
;
1063 setup
->channels_id
= kctl
->id
;
1068 err
= snd_ctl_add(card
, kctl
);
1077 static void print_dpcm_info(struct snd_info_buffer
*buffer
,
1078 struct loopback_pcm
*dpcm
,
1081 snd_iprintf(buffer
, " %s\n", id
);
1083 snd_iprintf(buffer
, " inactive\n");
1086 snd_iprintf(buffer
, " buffer_size:\t%u\n", dpcm
->pcm_buffer_size
);
1087 snd_iprintf(buffer
, " buffer_pos:\t\t%u\n", dpcm
->buf_pos
);
1088 snd_iprintf(buffer
, " silent_size:\t%u\n", dpcm
->silent_size
);
1089 snd_iprintf(buffer
, " period_size:\t%u\n", dpcm
->pcm_period_size
);
1090 snd_iprintf(buffer
, " bytes_per_sec:\t%u\n", dpcm
->pcm_bps
);
1091 snd_iprintf(buffer
, " sample_align:\t%u\n", dpcm
->pcm_salign
);
1092 snd_iprintf(buffer
, " rate_shift:\t\t%u\n", dpcm
->pcm_rate_shift
);
1093 snd_iprintf(buffer
, " update_pending:\t%u\n",
1094 dpcm
->period_update_pending
);
1095 snd_iprintf(buffer
, " irq_pos:\t\t%u\n", dpcm
->irq_pos
);
1096 snd_iprintf(buffer
, " period_frac:\t%u\n", dpcm
->period_size_frac
);
1097 snd_iprintf(buffer
, " last_jiffies:\t%lu (%lu)\n",
1098 dpcm
->last_jiffies
, jiffies
);
1099 snd_iprintf(buffer
, " timer_expires:\t%lu\n", dpcm
->timer
.expires
);
1102 static void print_substream_info(struct snd_info_buffer
*buffer
,
1103 struct loopback
*loopback
,
1107 struct loopback_cable
*cable
= loopback
->cables
[sub
][num
];
1109 snd_iprintf(buffer
, "Cable %i substream %i:\n", num
, sub
);
1110 if (cable
== NULL
) {
1111 snd_iprintf(buffer
, " inactive\n");
1114 snd_iprintf(buffer
, " valid: %u\n", cable
->valid
);
1115 snd_iprintf(buffer
, " running: %u\n", cable
->running
);
1116 snd_iprintf(buffer
, " pause: %u\n", cable
->pause
);
1117 print_dpcm_info(buffer
, cable
->streams
[0], "Playback");
1118 print_dpcm_info(buffer
, cable
->streams
[1], "Capture");
1121 static void print_cable_info(struct snd_info_entry
*entry
,
1122 struct snd_info_buffer
*buffer
)
1124 struct loopback
*loopback
= entry
->private_data
;
1127 mutex_lock(&loopback
->cable_lock
);
1128 num
= entry
->name
[strlen(entry
->name
)-1];
1129 num
= num
== '0' ? 0 : 1;
1130 for (sub
= 0; sub
< MAX_PCM_SUBSTREAMS
; sub
++)
1131 print_substream_info(buffer
, loopback
, sub
, num
);
1132 mutex_unlock(&loopback
->cable_lock
);
1135 static int loopback_proc_new(struct loopback
*loopback
, int cidx
)
1139 snprintf(name
, sizeof(name
), "cable#%d", cidx
);
1140 return snd_card_ro_proc_new(loopback
->card
, name
, loopback
,
1144 static int loopback_probe(struct platform_device
*devptr
)
1146 struct snd_card
*card
;
1147 struct loopback
*loopback
;
1148 int dev
= devptr
->id
;
1151 err
= snd_card_new(&devptr
->dev
, index
[dev
], id
[dev
], THIS_MODULE
,
1152 sizeof(struct loopback
), &card
);
1155 loopback
= card
->private_data
;
1157 if (pcm_substreams
[dev
] < 1)
1158 pcm_substreams
[dev
] = 1;
1159 if (pcm_substreams
[dev
] > MAX_PCM_SUBSTREAMS
)
1160 pcm_substreams
[dev
] = MAX_PCM_SUBSTREAMS
;
1162 loopback
->card
= card
;
1163 mutex_init(&loopback
->cable_lock
);
1165 err
= loopback_pcm_new(loopback
, 0, pcm_substreams
[dev
]);
1168 err
= loopback_pcm_new(loopback
, 1, pcm_substreams
[dev
]);
1171 err
= loopback_mixer_new(loopback
, pcm_notify
[dev
] ? 1 : 0);
1174 loopback_proc_new(loopback
, 0);
1175 loopback_proc_new(loopback
, 1);
1176 strcpy(card
->driver
, "Loopback");
1177 strcpy(card
->shortname
, "Loopback");
1178 sprintf(card
->longname
, "Loopback %i", dev
+ 1);
1179 err
= snd_card_register(card
);
1181 platform_set_drvdata(devptr
, card
);
1185 snd_card_free(card
);
1189 static int loopback_remove(struct platform_device
*devptr
)
1191 snd_card_free(platform_get_drvdata(devptr
));
1195 #ifdef CONFIG_PM_SLEEP
1196 static int loopback_suspend(struct device
*pdev
)
1198 struct snd_card
*card
= dev_get_drvdata(pdev
);
1200 snd_power_change_state(card
, SNDRV_CTL_POWER_D3hot
);
1204 static int loopback_resume(struct device
*pdev
)
1206 struct snd_card
*card
= dev_get_drvdata(pdev
);
1208 snd_power_change_state(card
, SNDRV_CTL_POWER_D0
);
1212 static SIMPLE_DEV_PM_OPS(loopback_pm
, loopback_suspend
, loopback_resume
);
1213 #define LOOPBACK_PM_OPS &loopback_pm
1215 #define LOOPBACK_PM_OPS NULL
1218 #define SND_LOOPBACK_DRIVER "snd_aloop"
1220 static struct platform_driver loopback_driver
= {
1221 .probe
= loopback_probe
,
1222 .remove
= loopback_remove
,
1224 .name
= SND_LOOPBACK_DRIVER
,
1225 .pm
= LOOPBACK_PM_OPS
,
1229 static void loopback_unregister_all(void)
1233 for (i
= 0; i
< ARRAY_SIZE(devices
); ++i
)
1234 platform_device_unregister(devices
[i
]);
1235 platform_driver_unregister(&loopback_driver
);
1238 static int __init
alsa_card_loopback_init(void)
1242 err
= platform_driver_register(&loopback_driver
);
1248 for (i
= 0; i
< SNDRV_CARDS
; i
++) {
1249 struct platform_device
*device
;
1252 device
= platform_device_register_simple(SND_LOOPBACK_DRIVER
,
1256 if (!platform_get_drvdata(device
)) {
1257 platform_device_unregister(device
);
1260 devices
[i
] = device
;
1265 printk(KERN_ERR
"aloop: No loopback enabled\n");
1267 loopback_unregister_all();
1273 static void __exit
alsa_card_loopback_exit(void)
1275 loopback_unregister_all();
1278 module_init(alsa_card_loopback_init
)
1279 module_exit(alsa_card_loopback_exit
)