2 * Digital Audio (PCM) abstract layer / OSS compatible
3 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 #include <linux/init.h>
30 #include <linux/slab.h>
31 #include <linux/sched/signal.h>
32 #include <linux/time.h>
33 #include <linux/vmalloc.h>
34 #include <linux/module.h>
35 #include <linux/math64.h>
36 #include <linux/string.h>
37 #include <linux/compat.h>
38 #include <sound/core.h>
39 #include <sound/minors.h>
40 #include <sound/pcm.h>
41 #include <sound/pcm_params.h>
42 #include "pcm_plugin.h"
43 #include <sound/info.h>
44 #include <linux/soundcard.h>
45 #include <sound/initval.h>
46 #include <sound/mixer_oss.h>
48 #define OSS_ALSAEMULVER _SIOR ('M', 249, int)
50 static int dsp_map
[SNDRV_CARDS
];
51 static int adsp_map
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
-1)] = 1};
52 static bool nonblock_open
= 1;
54 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Abramo Bagnara <abramo@alsa-project.org>");
55 MODULE_DESCRIPTION("PCM OSS emulation for ALSA.");
56 MODULE_LICENSE("GPL");
57 module_param_array(dsp_map
, int, NULL
, 0444);
58 MODULE_PARM_DESC(dsp_map
, "PCM device number assigned to 1st OSS device.");
59 module_param_array(adsp_map
, int, NULL
, 0444);
60 MODULE_PARM_DESC(adsp_map
, "PCM device number assigned to 2nd OSS device.");
61 module_param(nonblock_open
, bool, 0644);
62 MODULE_PARM_DESC(nonblock_open
, "Don't block opening busy PCM devices.");
63 MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM
);
64 MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM1
);
66 static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file
*pcm_oss_file
);
67 static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file
*pcm_oss_file
);
68 static int snd_pcm_oss_get_format(struct snd_pcm_oss_file
*pcm_oss_file
);
71 * helper functions to process hw_params
73 static int snd_interval_refine_min(struct snd_interval
*i
, unsigned int min
, int openmin
)
80 } else if (i
->min
== min
&& !i
->openmin
&& openmin
) {
90 if (snd_interval_checkempty(i
)) {
97 static int snd_interval_refine_max(struct snd_interval
*i
, unsigned int max
, int openmax
)
102 i
->openmax
= openmax
;
104 } else if (i
->max
== max
&& !i
->openmax
&& openmax
) {
114 if (snd_interval_checkempty(i
)) {
115 snd_interval_none(i
);
121 static int snd_interval_refine_set(struct snd_interval
*i
, unsigned int val
)
123 struct snd_interval t
;
126 t
.openmin
= t
.openmax
= 0;
128 return snd_interval_refine(i
, &t
);
132 * snd_pcm_hw_param_value_min
133 * @params: the hw_params instance
134 * @var: parameter to retrieve
135 * @dir: pointer to the direction (-1,0,1) or NULL
137 * Return the minimum value for field PAR.
140 snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params
*params
,
141 snd_pcm_hw_param_t var
, int *dir
)
143 if (hw_is_mask(var
)) {
146 return snd_mask_min(hw_param_mask_c(params
, var
));
148 if (hw_is_interval(var
)) {
149 const struct snd_interval
*i
= hw_param_interval_c(params
, var
);
152 return snd_interval_min(i
);
158 * snd_pcm_hw_param_value_max
159 * @params: the hw_params instance
160 * @var: parameter to retrieve
161 * @dir: pointer to the direction (-1,0,1) or NULL
163 * Return the maximum value for field PAR.
166 snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params
*params
,
167 snd_pcm_hw_param_t var
, int *dir
)
169 if (hw_is_mask(var
)) {
172 return snd_mask_max(hw_param_mask_c(params
, var
));
174 if (hw_is_interval(var
)) {
175 const struct snd_interval
*i
= hw_param_interval_c(params
, var
);
177 *dir
= - (int) i
->openmax
;
178 return snd_interval_max(i
);
183 static int _snd_pcm_hw_param_mask(struct snd_pcm_hw_params
*params
,
184 snd_pcm_hw_param_t var
,
185 const struct snd_mask
*val
)
188 changed
= snd_mask_refine(hw_param_mask(params
, var
), val
);
190 params
->cmask
|= 1 << var
;
191 params
->rmask
|= 1 << var
;
196 static int snd_pcm_hw_param_mask(struct snd_pcm_substream
*pcm
,
197 struct snd_pcm_hw_params
*params
,
198 snd_pcm_hw_param_t var
,
199 const struct snd_mask
*val
)
201 int changed
= _snd_pcm_hw_param_mask(params
, var
, val
);
205 int err
= snd_pcm_hw_refine(pcm
, params
);
212 static int _snd_pcm_hw_param_min(struct snd_pcm_hw_params
*params
,
213 snd_pcm_hw_param_t var
, unsigned int val
,
221 } else if (dir
< 0) {
229 changed
= snd_mask_refine_min(hw_param_mask(params
, var
),
231 else if (hw_is_interval(var
))
232 changed
= snd_interval_refine_min(hw_param_interval(params
, var
),
237 params
->cmask
|= 1 << var
;
238 params
->rmask
|= 1 << var
;
244 * snd_pcm_hw_param_min
246 * @params: the hw_params instance
247 * @var: parameter to retrieve
248 * @val: minimal value
249 * @dir: pointer to the direction (-1,0,1) or NULL
251 * Inside configuration space defined by PARAMS remove from PAR all
252 * values < VAL. Reduce configuration space accordingly.
253 * Return new minimum or -EINVAL if the configuration space is empty
255 static int snd_pcm_hw_param_min(struct snd_pcm_substream
*pcm
,
256 struct snd_pcm_hw_params
*params
,
257 snd_pcm_hw_param_t var
, unsigned int val
,
260 int changed
= _snd_pcm_hw_param_min(params
, var
, val
, dir
? *dir
: 0);
264 int err
= snd_pcm_hw_refine(pcm
, params
);
268 return snd_pcm_hw_param_value_min(params
, var
, dir
);
271 static int _snd_pcm_hw_param_max(struct snd_pcm_hw_params
*params
,
272 snd_pcm_hw_param_t var
, unsigned int val
,
280 } else if (dir
> 0) {
285 if (hw_is_mask(var
)) {
286 if (val
== 0 && open
) {
287 snd_mask_none(hw_param_mask(params
, var
));
290 changed
= snd_mask_refine_max(hw_param_mask(params
, var
),
292 } else if (hw_is_interval(var
))
293 changed
= snd_interval_refine_max(hw_param_interval(params
, var
),
298 params
->cmask
|= 1 << var
;
299 params
->rmask
|= 1 << var
;
305 * snd_pcm_hw_param_max
307 * @params: the hw_params instance
308 * @var: parameter to retrieve
309 * @val: maximal value
310 * @dir: pointer to the direction (-1,0,1) or NULL
312 * Inside configuration space defined by PARAMS remove from PAR all
313 * values >= VAL + 1. Reduce configuration space accordingly.
314 * Return new maximum or -EINVAL if the configuration space is empty
316 static int snd_pcm_hw_param_max(struct snd_pcm_substream
*pcm
,
317 struct snd_pcm_hw_params
*params
,
318 snd_pcm_hw_param_t var
, unsigned int val
,
321 int changed
= _snd_pcm_hw_param_max(params
, var
, val
, dir
? *dir
: 0);
325 int err
= snd_pcm_hw_refine(pcm
, params
);
329 return snd_pcm_hw_param_value_max(params
, var
, dir
);
332 static int boundary_sub(int a
, int adir
,
336 adir
= adir
< 0 ? -1 : (adir
> 0 ? 1 : 0);
337 bdir
= bdir
< 0 ? -1 : (bdir
> 0 ? 1 : 0);
342 } else if (*cdir
== 2) {
348 static int boundary_lt(unsigned int a
, int adir
,
349 unsigned int b
, int bdir
)
361 return a
< b
|| (a
== b
&& adir
< bdir
);
364 /* Return 1 if min is nearer to best than max */
365 static int boundary_nearer(int min
, int mindir
,
366 int best
, int bestdir
,
371 boundary_sub(best
, bestdir
, min
, mindir
, &dmin
, &dmindir
);
372 boundary_sub(max
, maxdir
, best
, bestdir
, &dmax
, &dmaxdir
);
373 return boundary_lt(dmin
, dmindir
, dmax
, dmaxdir
);
377 * snd_pcm_hw_param_near
379 * @params: the hw_params instance
380 * @var: parameter to retrieve
381 * @best: value to set
382 * @dir: pointer to the direction (-1,0,1) or NULL
384 * Inside configuration space defined by PARAMS set PAR to the available value
385 * nearest to VAL. Reduce configuration space accordingly.
386 * This function cannot be called for SNDRV_PCM_HW_PARAM_ACCESS,
387 * SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_SUBFORMAT.
388 * Return the value found.
390 static int snd_pcm_hw_param_near(struct snd_pcm_substream
*pcm
,
391 struct snd_pcm_hw_params
*params
,
392 snd_pcm_hw_param_t var
, unsigned int best
,
395 struct snd_pcm_hw_params
*save
= NULL
;
397 unsigned int saved_min
;
401 int valdir
= dir
? *dir
: 0;
406 mindir
= maxdir
= valdir
;
409 else if (maxdir
== 0)
415 save
= kmalloc(sizeof(*save
), GFP_KERNEL
);
420 min
= snd_pcm_hw_param_min(pcm
, params
, var
, min
, &mindir
);
422 struct snd_pcm_hw_params
*params1
;
425 if ((unsigned int)min
== saved_min
&& mindir
== valdir
)
427 params1
= kmalloc(sizeof(*params1
), GFP_KERNEL
);
428 if (params1
== NULL
) {
433 max
= snd_pcm_hw_param_max(pcm
, params1
, var
, max
, &maxdir
);
438 if (boundary_nearer(max
, maxdir
, best
, valdir
, min
, mindir
)) {
445 max
= snd_pcm_hw_param_max(pcm
, params
, var
, max
, &maxdir
);
455 v
= snd_pcm_hw_param_last(pcm
, params
, var
, dir
);
457 v
= snd_pcm_hw_param_first(pcm
, params
, var
, dir
);
461 static int _snd_pcm_hw_param_set(struct snd_pcm_hw_params
*params
,
462 snd_pcm_hw_param_t var
, unsigned int val
,
466 if (hw_is_mask(var
)) {
467 struct snd_mask
*m
= hw_param_mask(params
, var
);
468 if (val
== 0 && dir
< 0) {
476 changed
= snd_mask_refine_set(hw_param_mask(params
, var
), val
);
478 } else if (hw_is_interval(var
)) {
479 struct snd_interval
*i
= hw_param_interval(params
, var
);
480 if (val
== 0 && dir
< 0) {
482 snd_interval_none(i
);
484 changed
= snd_interval_refine_set(i
, val
);
486 struct snd_interval t
;
498 changed
= snd_interval_refine(i
, &t
);
503 params
->cmask
|= 1 << var
;
504 params
->rmask
|= 1 << var
;
510 * snd_pcm_hw_param_set
512 * @params: the hw_params instance
513 * @var: parameter to retrieve
515 * @dir: pointer to the direction (-1,0,1) or NULL
517 * Inside configuration space defined by PARAMS remove from PAR all
518 * values != VAL. Reduce configuration space accordingly.
519 * Return VAL or -EINVAL if the configuration space is empty
521 static int snd_pcm_hw_param_set(struct snd_pcm_substream
*pcm
,
522 struct snd_pcm_hw_params
*params
,
523 snd_pcm_hw_param_t var
, unsigned int val
,
526 int changed
= _snd_pcm_hw_param_set(params
, var
, val
, dir
);
530 int err
= snd_pcm_hw_refine(pcm
, params
);
534 return snd_pcm_hw_param_value(params
, var
, NULL
);
537 static int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params
*params
,
538 snd_pcm_hw_param_t var
)
541 changed
= snd_interval_setinteger(hw_param_interval(params
, var
));
543 params
->cmask
|= 1 << var
;
544 params
->rmask
|= 1 << var
;
553 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
554 static int snd_pcm_oss_plugin_clear(struct snd_pcm_substream
*substream
)
556 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
557 struct snd_pcm_plugin
*plugin
, *next
;
559 plugin
= runtime
->oss
.plugin_first
;
562 snd_pcm_plugin_free(plugin
);
565 runtime
->oss
.plugin_first
= runtime
->oss
.plugin_last
= NULL
;
569 static int snd_pcm_plugin_insert(struct snd_pcm_plugin
*plugin
)
571 struct snd_pcm_runtime
*runtime
= plugin
->plug
->runtime
;
572 plugin
->next
= runtime
->oss
.plugin_first
;
574 if (runtime
->oss
.plugin_first
) {
575 runtime
->oss
.plugin_first
->prev
= plugin
;
576 runtime
->oss
.plugin_first
= plugin
;
578 runtime
->oss
.plugin_last
=
579 runtime
->oss
.plugin_first
= plugin
;
584 int snd_pcm_plugin_append(struct snd_pcm_plugin
*plugin
)
586 struct snd_pcm_runtime
*runtime
= plugin
->plug
->runtime
;
588 plugin
->prev
= runtime
->oss
.plugin_last
;
589 if (runtime
->oss
.plugin_last
) {
590 runtime
->oss
.plugin_last
->next
= plugin
;
591 runtime
->oss
.plugin_last
= plugin
;
593 runtime
->oss
.plugin_last
=
594 runtime
->oss
.plugin_first
= plugin
;
598 #endif /* CONFIG_SND_PCM_OSS_PLUGINS */
600 static long snd_pcm_oss_bytes(struct snd_pcm_substream
*substream
, long frames
)
602 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
603 long buffer_size
= snd_pcm_lib_buffer_bytes(substream
);
604 long bytes
= frames_to_bytes(runtime
, frames
);
605 if (buffer_size
== runtime
->oss
.buffer_bytes
)
607 #if BITS_PER_LONG >= 64
608 return runtime
->oss
.buffer_bytes
* bytes
/ buffer_size
;
611 u64 bsize
= (u64
)runtime
->oss
.buffer_bytes
* (u64
)bytes
;
612 return div_u64(bsize
, buffer_size
);
617 static long snd_pcm_alsa_frames(struct snd_pcm_substream
*substream
, long bytes
)
619 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
620 long buffer_size
= snd_pcm_lib_buffer_bytes(substream
);
621 if (buffer_size
== runtime
->oss
.buffer_bytes
)
622 return bytes_to_frames(runtime
, bytes
);
623 return bytes_to_frames(runtime
, (buffer_size
* bytes
) / runtime
->oss
.buffer_bytes
);
627 snd_pcm_uframes_t
get_hw_ptr_period(struct snd_pcm_runtime
*runtime
)
629 return runtime
->hw_ptr_interrupt
;
632 /* define extended formats in the recent OSS versions (if any) */
634 #define AFMT_S32_LE 0x00001000
635 #define AFMT_S32_BE 0x00002000
636 #define AFMT_S24_LE 0x00008000
637 #define AFMT_S24_BE 0x00010000
638 #define AFMT_S24_PACKED 0x00040000
640 /* other supported formats */
641 #define AFMT_FLOAT 0x00004000
642 #define AFMT_SPDIF_RAW 0x00020000
644 /* unsupported formats */
645 #define AFMT_AC3 0x00000400
646 #define AFMT_VORBIS 0x00000800
648 static snd_pcm_format_t
snd_pcm_oss_format_from(int format
)
651 case AFMT_MU_LAW
: return SNDRV_PCM_FORMAT_MU_LAW
;
652 case AFMT_A_LAW
: return SNDRV_PCM_FORMAT_A_LAW
;
653 case AFMT_IMA_ADPCM
: return SNDRV_PCM_FORMAT_IMA_ADPCM
;
654 case AFMT_U8
: return SNDRV_PCM_FORMAT_U8
;
655 case AFMT_S16_LE
: return SNDRV_PCM_FORMAT_S16_LE
;
656 case AFMT_S16_BE
: return SNDRV_PCM_FORMAT_S16_BE
;
657 case AFMT_S8
: return SNDRV_PCM_FORMAT_S8
;
658 case AFMT_U16_LE
: return SNDRV_PCM_FORMAT_U16_LE
;
659 case AFMT_U16_BE
: return SNDRV_PCM_FORMAT_U16_BE
;
660 case AFMT_MPEG
: return SNDRV_PCM_FORMAT_MPEG
;
661 case AFMT_S32_LE
: return SNDRV_PCM_FORMAT_S32_LE
;
662 case AFMT_S32_BE
: return SNDRV_PCM_FORMAT_S32_BE
;
663 case AFMT_S24_LE
: return SNDRV_PCM_FORMAT_S24_LE
;
664 case AFMT_S24_BE
: return SNDRV_PCM_FORMAT_S24_BE
;
665 case AFMT_S24_PACKED
: return SNDRV_PCM_FORMAT_S24_3LE
;
666 case AFMT_FLOAT
: return SNDRV_PCM_FORMAT_FLOAT
;
667 case AFMT_SPDIF_RAW
: return SNDRV_PCM_FORMAT_IEC958_SUBFRAME
;
668 default: return SNDRV_PCM_FORMAT_U8
;
672 static int snd_pcm_oss_format_to(snd_pcm_format_t format
)
675 case SNDRV_PCM_FORMAT_MU_LAW
: return AFMT_MU_LAW
;
676 case SNDRV_PCM_FORMAT_A_LAW
: return AFMT_A_LAW
;
677 case SNDRV_PCM_FORMAT_IMA_ADPCM
: return AFMT_IMA_ADPCM
;
678 case SNDRV_PCM_FORMAT_U8
: return AFMT_U8
;
679 case SNDRV_PCM_FORMAT_S16_LE
: return AFMT_S16_LE
;
680 case SNDRV_PCM_FORMAT_S16_BE
: return AFMT_S16_BE
;
681 case SNDRV_PCM_FORMAT_S8
: return AFMT_S8
;
682 case SNDRV_PCM_FORMAT_U16_LE
: return AFMT_U16_LE
;
683 case SNDRV_PCM_FORMAT_U16_BE
: return AFMT_U16_BE
;
684 case SNDRV_PCM_FORMAT_MPEG
: return AFMT_MPEG
;
685 case SNDRV_PCM_FORMAT_S32_LE
: return AFMT_S32_LE
;
686 case SNDRV_PCM_FORMAT_S32_BE
: return AFMT_S32_BE
;
687 case SNDRV_PCM_FORMAT_S24_LE
: return AFMT_S24_LE
;
688 case SNDRV_PCM_FORMAT_S24_BE
: return AFMT_S24_BE
;
689 case SNDRV_PCM_FORMAT_S24_3LE
: return AFMT_S24_PACKED
;
690 case SNDRV_PCM_FORMAT_FLOAT
: return AFMT_FLOAT
;
691 case SNDRV_PCM_FORMAT_IEC958_SUBFRAME
: return AFMT_SPDIF_RAW
;
692 default: return -EINVAL
;
696 static int snd_pcm_oss_period_size(struct snd_pcm_substream
*substream
,
697 struct snd_pcm_hw_params
*oss_params
,
698 struct snd_pcm_hw_params
*slave_params
)
701 size_t oss_buffer_size
, oss_period_size
, oss_periods
;
702 size_t min_period_size
, max_period_size
;
703 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
704 size_t oss_frame_size
;
706 oss_frame_size
= snd_pcm_format_physical_width(params_format(oss_params
)) *
707 params_channels(oss_params
) / 8;
709 oss_buffer_size
= snd_pcm_plug_client_size(substream
,
710 snd_pcm_hw_param_value_max(slave_params
, SNDRV_PCM_HW_PARAM_BUFFER_SIZE
, NULL
)) * oss_frame_size
;
711 oss_buffer_size
= rounddown_pow_of_two(oss_buffer_size
);
712 if (atomic_read(&substream
->mmap_count
)) {
713 if (oss_buffer_size
> runtime
->oss
.mmap_bytes
)
714 oss_buffer_size
= runtime
->oss
.mmap_bytes
;
717 if (substream
->oss
.setup
.period_size
> 16)
718 oss_period_size
= substream
->oss
.setup
.period_size
;
719 else if (runtime
->oss
.fragshift
) {
720 oss_period_size
= 1 << runtime
->oss
.fragshift
;
721 if (oss_period_size
> oss_buffer_size
/ 2)
722 oss_period_size
= oss_buffer_size
/ 2;
725 size_t bytes_per_sec
= params_rate(oss_params
) * snd_pcm_format_physical_width(params_format(oss_params
)) * params_channels(oss_params
) / 8;
727 oss_period_size
= oss_buffer_size
;
729 oss_period_size
/= 2;
730 } while (oss_period_size
> bytes_per_sec
);
731 if (runtime
->oss
.subdivision
== 0) {
733 if (oss_period_size
/ sd
> 4096)
735 if (oss_period_size
/ sd
< 4096)
738 sd
= runtime
->oss
.subdivision
;
739 oss_period_size
/= sd
;
740 if (oss_period_size
< 16)
741 oss_period_size
= 16;
744 min_period_size
= snd_pcm_plug_client_size(substream
,
745 snd_pcm_hw_param_value_min(slave_params
, SNDRV_PCM_HW_PARAM_PERIOD_SIZE
, NULL
));
746 min_period_size
*= oss_frame_size
;
747 min_period_size
= roundup_pow_of_two(min_period_size
);
748 if (oss_period_size
< min_period_size
)
749 oss_period_size
= min_period_size
;
751 max_period_size
= snd_pcm_plug_client_size(substream
,
752 snd_pcm_hw_param_value_max(slave_params
, SNDRV_PCM_HW_PARAM_PERIOD_SIZE
, NULL
));
753 max_period_size
*= oss_frame_size
;
754 max_period_size
= rounddown_pow_of_two(max_period_size
);
755 if (oss_period_size
> max_period_size
)
756 oss_period_size
= max_period_size
;
758 oss_periods
= oss_buffer_size
/ oss_period_size
;
760 if (substream
->oss
.setup
.periods
> 1)
761 oss_periods
= substream
->oss
.setup
.periods
;
763 s
= snd_pcm_hw_param_value_max(slave_params
, SNDRV_PCM_HW_PARAM_PERIODS
, NULL
);
764 if (runtime
->oss
.maxfrags
&& s
> runtime
->oss
.maxfrags
)
765 s
= runtime
->oss
.maxfrags
;
769 s
= snd_pcm_hw_param_value_min(slave_params
, SNDRV_PCM_HW_PARAM_PERIODS
, NULL
);
775 while (oss_period_size
* oss_periods
> oss_buffer_size
)
776 oss_period_size
/= 2;
778 if (oss_period_size
< 16)
780 runtime
->oss
.period_bytes
= oss_period_size
;
781 runtime
->oss
.period_frames
= 1;
782 runtime
->oss
.periods
= oss_periods
;
786 static int choose_rate(struct snd_pcm_substream
*substream
,
787 struct snd_pcm_hw_params
*params
, unsigned int best_rate
)
789 const struct snd_interval
*it
;
790 struct snd_pcm_hw_params
*save
;
791 unsigned int rate
, prev
;
793 save
= kmalloc(sizeof(*save
), GFP_KERNEL
);
797 it
= hw_param_interval_c(save
, SNDRV_PCM_HW_PARAM_RATE
);
799 /* try multiples of the best rate */
802 if (it
->max
< rate
|| (it
->max
== rate
&& it
->openmax
))
804 if (it
->min
< rate
|| (it
->min
== rate
&& !it
->openmin
)) {
806 ret
= snd_pcm_hw_param_set(substream
, params
,
807 SNDRV_PCM_HW_PARAM_RATE
,
809 if (ret
== (int)rate
) {
821 /* not found, use the nearest rate */
823 return snd_pcm_hw_param_near(substream
, params
, SNDRV_PCM_HW_PARAM_RATE
, best_rate
, NULL
);
826 /* parameter locking: returns immediately if tried during streaming */
827 static int lock_params(struct snd_pcm_runtime
*runtime
)
829 if (mutex_lock_interruptible(&runtime
->oss
.params_lock
))
831 if (atomic_read(&runtime
->oss
.rw_ref
)) {
832 mutex_unlock(&runtime
->oss
.params_lock
);
838 static void unlock_params(struct snd_pcm_runtime
*runtime
)
840 mutex_unlock(&runtime
->oss
.params_lock
);
843 /* call with params_lock held */
844 static int snd_pcm_oss_change_params_locked(struct snd_pcm_substream
*substream
)
846 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
847 struct snd_pcm_hw_params
*params
, *sparams
;
848 struct snd_pcm_sw_params
*sw_params
;
849 ssize_t oss_buffer_size
, oss_period_size
;
850 size_t oss_frame_size
;
853 snd_pcm_format_t format
, sformat
;
855 const struct snd_mask
*sformat_mask
;
856 struct snd_mask mask
;
858 if (!runtime
->oss
.params
)
860 sw_params
= kzalloc(sizeof(*sw_params
), GFP_KERNEL
);
861 params
= kmalloc(sizeof(*params
), GFP_KERNEL
);
862 sparams
= kmalloc(sizeof(*sparams
), GFP_KERNEL
);
863 if (!sw_params
|| !params
|| !sparams
) {
868 if (atomic_read(&substream
->mmap_count
))
871 direct
= substream
->oss
.setup
.direct
;
873 _snd_pcm_hw_params_any(sparams
);
874 _snd_pcm_hw_param_setinteger(sparams
, SNDRV_PCM_HW_PARAM_PERIODS
);
875 _snd_pcm_hw_param_min(sparams
, SNDRV_PCM_HW_PARAM_PERIODS
, 2, 0);
876 snd_mask_none(&mask
);
877 if (atomic_read(&substream
->mmap_count
))
878 snd_mask_set(&mask
, (__force
int)SNDRV_PCM_ACCESS_MMAP_INTERLEAVED
);
880 snd_mask_set(&mask
, (__force
int)SNDRV_PCM_ACCESS_RW_INTERLEAVED
);
882 snd_mask_set(&mask
, (__force
int)SNDRV_PCM_ACCESS_RW_NONINTERLEAVED
);
884 err
= snd_pcm_hw_param_mask(substream
, sparams
, SNDRV_PCM_HW_PARAM_ACCESS
, &mask
);
886 pcm_dbg(substream
->pcm
, "No usable accesses\n");
890 choose_rate(substream
, sparams
, runtime
->oss
.rate
);
891 snd_pcm_hw_param_near(substream
, sparams
, SNDRV_PCM_HW_PARAM_CHANNELS
, runtime
->oss
.channels
, NULL
);
893 format
= snd_pcm_oss_format_from(runtime
->oss
.format
);
895 sformat_mask
= hw_param_mask_c(sparams
, SNDRV_PCM_HW_PARAM_FORMAT
);
899 sformat
= snd_pcm_plug_slave_format(format
, sformat_mask
);
901 if ((__force
int)sformat
< 0 ||
902 !snd_mask_test(sformat_mask
, (__force
int)sformat
)) {
903 for (sformat
= (__force snd_pcm_format_t
)0;
904 (__force
int)sformat
<= (__force
int)SNDRV_PCM_FORMAT_LAST
;
905 sformat
= (__force snd_pcm_format_t
)((__force
int)sformat
+ 1)) {
906 if (snd_mask_test(sformat_mask
, (__force
int)sformat
) &&
907 snd_pcm_oss_format_to(sformat
) >= 0)
910 if ((__force
int)sformat
> (__force
int)SNDRV_PCM_FORMAT_LAST
) {
911 pcm_dbg(substream
->pcm
, "Cannot find a format!!!\n");
916 err
= _snd_pcm_hw_param_set(sparams
, SNDRV_PCM_HW_PARAM_FORMAT
, (__force
int)sformat
, 0);
921 memcpy(params
, sparams
, sizeof(*params
));
923 _snd_pcm_hw_params_any(params
);
924 _snd_pcm_hw_param_set(params
, SNDRV_PCM_HW_PARAM_ACCESS
,
925 (__force
int)SNDRV_PCM_ACCESS_RW_INTERLEAVED
, 0);
926 _snd_pcm_hw_param_set(params
, SNDRV_PCM_HW_PARAM_FORMAT
,
927 (__force
int)snd_pcm_oss_format_from(runtime
->oss
.format
), 0);
928 _snd_pcm_hw_param_set(params
, SNDRV_PCM_HW_PARAM_CHANNELS
,
929 runtime
->oss
.channels
, 0);
930 _snd_pcm_hw_param_set(params
, SNDRV_PCM_HW_PARAM_RATE
,
931 runtime
->oss
.rate
, 0);
932 pdprintf("client: access = %i, format = %i, channels = %i, rate = %i\n",
933 params_access(params
), params_format(params
),
934 params_channels(params
), params_rate(params
));
936 pdprintf("slave: access = %i, format = %i, channels = %i, rate = %i\n",
937 params_access(sparams
), params_format(sparams
),
938 params_channels(sparams
), params_rate(sparams
));
940 oss_frame_size
= snd_pcm_format_physical_width(params_format(params
)) *
941 params_channels(params
) / 8;
943 err
= snd_pcm_oss_period_size(substream
, params
, sparams
);
947 n
= snd_pcm_plug_slave_size(substream
, runtime
->oss
.period_bytes
/ oss_frame_size
);
948 err
= snd_pcm_hw_param_near(substream
, sparams
, SNDRV_PCM_HW_PARAM_PERIOD_SIZE
, n
, NULL
);
952 err
= snd_pcm_hw_param_near(substream
, sparams
, SNDRV_PCM_HW_PARAM_PERIODS
,
953 runtime
->oss
.periods
, NULL
);
957 snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DROP
, NULL
);
959 err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_HW_PARAMS
, sparams
);
961 pcm_dbg(substream
->pcm
, "HW_PARAMS failed: %i\n", err
);
965 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
966 snd_pcm_oss_plugin_clear(substream
);
968 /* add necessary plugins */
969 snd_pcm_oss_plugin_clear(substream
);
970 if ((err
= snd_pcm_plug_format_plugins(substream
,
973 pcm_dbg(substream
->pcm
,
974 "snd_pcm_plug_format_plugins failed: %i\n", err
);
975 snd_pcm_oss_plugin_clear(substream
);
978 if (runtime
->oss
.plugin_first
) {
979 struct snd_pcm_plugin
*plugin
;
980 if ((err
= snd_pcm_plugin_build_io(substream
, sparams
, &plugin
)) < 0) {
981 pcm_dbg(substream
->pcm
,
982 "snd_pcm_plugin_build_io failed: %i\n", err
);
983 snd_pcm_oss_plugin_clear(substream
);
986 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
987 err
= snd_pcm_plugin_append(plugin
);
989 err
= snd_pcm_plugin_insert(plugin
);
992 snd_pcm_oss_plugin_clear(substream
);
999 if (runtime
->oss
.trigger
) {
1000 sw_params
->start_threshold
= 1;
1002 sw_params
->start_threshold
= runtime
->boundary
;
1004 if (atomic_read(&substream
->mmap_count
) ||
1005 substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
)
1006 sw_params
->stop_threshold
= runtime
->boundary
;
1008 sw_params
->stop_threshold
= runtime
->buffer_size
;
1009 sw_params
->tstamp_mode
= SNDRV_PCM_TSTAMP_NONE
;
1010 sw_params
->period_step
= 1;
1011 sw_params
->avail_min
= substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
?
1012 1 : runtime
->period_size
;
1013 if (atomic_read(&substream
->mmap_count
) ||
1014 substream
->oss
.setup
.nosilence
) {
1015 sw_params
->silence_threshold
= 0;
1016 sw_params
->silence_size
= 0;
1018 snd_pcm_uframes_t frames
;
1019 frames
= runtime
->period_size
+ 16;
1020 if (frames
> runtime
->buffer_size
)
1021 frames
= runtime
->buffer_size
;
1022 sw_params
->silence_threshold
= frames
;
1023 sw_params
->silence_size
= frames
;
1026 if ((err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_SW_PARAMS
, sw_params
)) < 0) {
1027 pcm_dbg(substream
->pcm
, "SW_PARAMS failed: %i\n", err
);
1031 runtime
->oss
.periods
= params_periods(sparams
);
1032 oss_period_size
= snd_pcm_plug_client_size(substream
, params_period_size(sparams
));
1033 if (oss_period_size
< 0) {
1037 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
1038 if (runtime
->oss
.plugin_first
) {
1039 err
= snd_pcm_plug_alloc(substream
, oss_period_size
);
1044 oss_period_size
*= oss_frame_size
;
1046 oss_buffer_size
= oss_period_size
* runtime
->oss
.periods
;
1047 if (oss_buffer_size
< 0) {
1052 runtime
->oss
.period_bytes
= oss_period_size
;
1053 runtime
->oss
.buffer_bytes
= oss_buffer_size
;
1055 pdprintf("oss: period bytes = %i, buffer bytes = %i\n",
1056 runtime
->oss
.period_bytes
,
1057 runtime
->oss
.buffer_bytes
);
1058 pdprintf("slave: period_size = %i, buffer_size = %i\n",
1059 params_period_size(sparams
),
1060 params_buffer_size(sparams
));
1062 runtime
->oss
.format
= snd_pcm_oss_format_to(params_format(params
));
1063 runtime
->oss
.channels
= params_channels(params
);
1064 runtime
->oss
.rate
= params_rate(params
);
1066 kvfree(runtime
->oss
.buffer
);
1067 runtime
->oss
.buffer
= kvzalloc(runtime
->oss
.period_bytes
, GFP_KERNEL
);
1068 if (!runtime
->oss
.buffer
) {
1073 runtime
->oss
.params
= 0;
1074 runtime
->oss
.prepare
= 1;
1075 runtime
->oss
.buffer_used
= 0;
1076 if (runtime
->dma_area
)
1077 snd_pcm_format_set_silence(runtime
->format
, runtime
->dma_area
, bytes_to_samples(runtime
, runtime
->dma_bytes
));
1079 runtime
->oss
.period_frames
= snd_pcm_alsa_frames(substream
, oss_period_size
);
1089 /* this one takes the lock by itself */
1090 static int snd_pcm_oss_change_params(struct snd_pcm_substream
*substream
,
1093 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1097 if (!(mutex_trylock(&runtime
->oss
.params_lock
)))
1099 } else if (mutex_lock_interruptible(&runtime
->oss
.params_lock
))
1100 return -ERESTARTSYS
;
1102 err
= snd_pcm_oss_change_params_locked(substream
);
1103 mutex_unlock(&runtime
->oss
.params_lock
);
1107 static int snd_pcm_oss_get_active_substream(struct snd_pcm_oss_file
*pcm_oss_file
, struct snd_pcm_substream
**r_substream
)
1110 struct snd_pcm_substream
*asubstream
= NULL
, *substream
;
1112 for (idx
= 0; idx
< 2; idx
++) {
1113 substream
= pcm_oss_file
->streams
[idx
];
1114 if (substream
== NULL
)
1116 if (asubstream
== NULL
)
1117 asubstream
= substream
;
1118 if (substream
->runtime
->oss
.params
) {
1119 err
= snd_pcm_oss_change_params(substream
, false);
1127 *r_substream
= asubstream
;
1131 /* call with params_lock held */
1132 /* NOTE: this always call PREPARE unconditionally no matter whether
1133 * runtime->oss.prepare is set or not
1135 static int snd_pcm_oss_prepare(struct snd_pcm_substream
*substream
)
1138 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1140 err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_PREPARE
, NULL
);
1142 pcm_dbg(substream
->pcm
,
1143 "snd_pcm_oss_prepare: SNDRV_PCM_IOCTL_PREPARE failed\n");
1146 runtime
->oss
.prepare
= 0;
1147 runtime
->oss
.prev_hw_ptr_period
= 0;
1148 runtime
->oss
.period_ptr
= 0;
1149 runtime
->oss
.buffer_used
= 0;
1154 static int snd_pcm_oss_make_ready(struct snd_pcm_substream
*substream
)
1156 struct snd_pcm_runtime
*runtime
;
1159 runtime
= substream
->runtime
;
1160 if (runtime
->oss
.params
) {
1161 err
= snd_pcm_oss_change_params(substream
, false);
1165 if (runtime
->oss
.prepare
) {
1166 if (mutex_lock_interruptible(&runtime
->oss
.params_lock
))
1167 return -ERESTARTSYS
;
1168 err
= snd_pcm_oss_prepare(substream
);
1169 mutex_unlock(&runtime
->oss
.params_lock
);
1176 /* call with params_lock held */
1177 static int snd_pcm_oss_make_ready_locked(struct snd_pcm_substream
*substream
)
1179 struct snd_pcm_runtime
*runtime
;
1182 runtime
= substream
->runtime
;
1183 if (runtime
->oss
.params
) {
1184 err
= snd_pcm_oss_change_params_locked(substream
);
1188 if (runtime
->oss
.prepare
) {
1189 err
= snd_pcm_oss_prepare(substream
);
1196 static int snd_pcm_oss_capture_position_fixup(struct snd_pcm_substream
*substream
, snd_pcm_sframes_t
*delay
)
1198 struct snd_pcm_runtime
*runtime
;
1199 snd_pcm_uframes_t frames
;
1203 err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DELAY
, delay
);
1206 runtime
= substream
->runtime
;
1207 if (*delay
<= (snd_pcm_sframes_t
)runtime
->buffer_size
)
1209 /* in case of overrun, skip whole periods like OSS/Linux driver does */
1210 /* until avail(delay) <= buffer_size */
1211 frames
= (*delay
- runtime
->buffer_size
) + runtime
->period_size
- 1;
1212 frames
/= runtime
->period_size
;
1213 frames
*= runtime
->period_size
;
1214 err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_FORWARD
, &frames
);
1221 snd_pcm_sframes_t
snd_pcm_oss_write3(struct snd_pcm_substream
*substream
, const char *ptr
, snd_pcm_uframes_t frames
, int in_kernel
)
1223 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1226 if (runtime
->status
->state
== SNDRV_PCM_STATE_XRUN
||
1227 runtime
->status
->state
== SNDRV_PCM_STATE_SUSPENDED
) {
1229 pcm_dbg(substream
->pcm
,
1230 "pcm_oss: write: recovering from %s\n",
1231 runtime
->status
->state
== SNDRV_PCM_STATE_XRUN
?
1232 "XRUN" : "SUSPEND");
1234 ret
= snd_pcm_oss_prepare(substream
);
1238 ret
= __snd_pcm_lib_xfer(substream
, (void *)ptr
, true,
1240 if (ret
!= -EPIPE
&& ret
!= -ESTRPIPE
)
1242 /* test, if we can't store new data, because the stream */
1243 /* has not been started */
1244 if (runtime
->status
->state
== SNDRV_PCM_STATE_PREPARED
)
1250 snd_pcm_sframes_t
snd_pcm_oss_read3(struct snd_pcm_substream
*substream
, char *ptr
, snd_pcm_uframes_t frames
, int in_kernel
)
1252 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1253 snd_pcm_sframes_t delay
;
1256 if (runtime
->status
->state
== SNDRV_PCM_STATE_XRUN
||
1257 runtime
->status
->state
== SNDRV_PCM_STATE_SUSPENDED
) {
1259 pcm_dbg(substream
->pcm
,
1260 "pcm_oss: read: recovering from %s\n",
1261 runtime
->status
->state
== SNDRV_PCM_STATE_XRUN
?
1262 "XRUN" : "SUSPEND");
1264 ret
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DRAIN
, NULL
);
1267 } else if (runtime
->status
->state
== SNDRV_PCM_STATE_SETUP
) {
1268 ret
= snd_pcm_oss_prepare(substream
);
1272 ret
= snd_pcm_oss_capture_position_fixup(substream
, &delay
);
1275 ret
= __snd_pcm_lib_xfer(substream
, (void *)ptr
, true,
1277 if (ret
== -EPIPE
) {
1278 if (runtime
->status
->state
== SNDRV_PCM_STATE_DRAINING
) {
1279 ret
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DROP
, NULL
);
1285 if (ret
!= -ESTRPIPE
)
1291 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
1292 snd_pcm_sframes_t
snd_pcm_oss_writev3(struct snd_pcm_substream
*substream
, void **bufs
, snd_pcm_uframes_t frames
)
1294 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1297 if (runtime
->status
->state
== SNDRV_PCM_STATE_XRUN
||
1298 runtime
->status
->state
== SNDRV_PCM_STATE_SUSPENDED
) {
1300 pcm_dbg(substream
->pcm
,
1301 "pcm_oss: writev: recovering from %s\n",
1302 runtime
->status
->state
== SNDRV_PCM_STATE_XRUN
?
1303 "XRUN" : "SUSPEND");
1305 ret
= snd_pcm_oss_prepare(substream
);
1309 ret
= snd_pcm_kernel_writev(substream
, bufs
, frames
);
1310 if (ret
!= -EPIPE
&& ret
!= -ESTRPIPE
)
1313 /* test, if we can't store new data, because the stream */
1314 /* has not been started */
1315 if (runtime
->status
->state
== SNDRV_PCM_STATE_PREPARED
)
1321 snd_pcm_sframes_t
snd_pcm_oss_readv3(struct snd_pcm_substream
*substream
, void **bufs
, snd_pcm_uframes_t frames
)
1323 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1326 if (runtime
->status
->state
== SNDRV_PCM_STATE_XRUN
||
1327 runtime
->status
->state
== SNDRV_PCM_STATE_SUSPENDED
) {
1329 pcm_dbg(substream
->pcm
,
1330 "pcm_oss: readv: recovering from %s\n",
1331 runtime
->status
->state
== SNDRV_PCM_STATE_XRUN
?
1332 "XRUN" : "SUSPEND");
1334 ret
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DRAIN
, NULL
);
1337 } else if (runtime
->status
->state
== SNDRV_PCM_STATE_SETUP
) {
1338 ret
= snd_pcm_oss_prepare(substream
);
1342 ret
= snd_pcm_kernel_readv(substream
, bufs
, frames
);
1343 if (ret
!= -EPIPE
&& ret
!= -ESTRPIPE
)
1348 #endif /* CONFIG_SND_PCM_OSS_PLUGINS */
1350 static ssize_t
snd_pcm_oss_write2(struct snd_pcm_substream
*substream
, const char *buf
, size_t bytes
, int in_kernel
)
1352 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1353 snd_pcm_sframes_t frames
, frames1
;
1354 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
1355 if (runtime
->oss
.plugin_first
) {
1356 struct snd_pcm_plugin_channel
*channels
;
1357 size_t oss_frame_bytes
= (runtime
->oss
.plugin_first
->src_width
* runtime
->oss
.plugin_first
->src_format
.channels
) / 8;
1359 if (copy_from_user(runtime
->oss
.buffer
, (const char __force __user
*)buf
, bytes
))
1361 buf
= runtime
->oss
.buffer
;
1363 frames
= bytes
/ oss_frame_bytes
;
1364 frames1
= snd_pcm_plug_client_channels_buf(substream
, (char *)buf
, frames
, &channels
);
1367 frames1
= snd_pcm_plug_write_transfer(substream
, channels
, frames1
);
1370 bytes
= frames1
* oss_frame_bytes
;
1374 frames
= bytes_to_frames(runtime
, bytes
);
1375 frames1
= snd_pcm_oss_write3(substream
, buf
, frames
, in_kernel
);
1378 bytes
= frames_to_bytes(runtime
, frames1
);
1383 static ssize_t
snd_pcm_oss_write1(struct snd_pcm_substream
*substream
, const char __user
*buf
, size_t bytes
)
1387 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1389 if (atomic_read(&substream
->mmap_count
))
1392 atomic_inc(&runtime
->oss
.rw_ref
);
1394 if (mutex_lock_interruptible(&runtime
->oss
.params_lock
)) {
1398 tmp
= snd_pcm_oss_make_ready_locked(substream
);
1401 if (bytes
< runtime
->oss
.period_bytes
|| runtime
->oss
.buffer_used
> 0) {
1403 if (tmp
+ runtime
->oss
.buffer_used
> runtime
->oss
.period_bytes
)
1404 tmp
= runtime
->oss
.period_bytes
- runtime
->oss
.buffer_used
;
1406 if (copy_from_user(runtime
->oss
.buffer
+ runtime
->oss
.buffer_used
, buf
, tmp
)) {
1411 runtime
->oss
.buffer_used
+= tmp
;
1415 if (substream
->oss
.setup
.partialfrag
||
1416 runtime
->oss
.buffer_used
== runtime
->oss
.period_bytes
) {
1417 tmp
= snd_pcm_oss_write2(substream
, runtime
->oss
.buffer
+ runtime
->oss
.period_ptr
,
1418 runtime
->oss
.buffer_used
- runtime
->oss
.period_ptr
, 1);
1421 runtime
->oss
.bytes
+= tmp
;
1422 runtime
->oss
.period_ptr
+= tmp
;
1423 runtime
->oss
.period_ptr
%= runtime
->oss
.period_bytes
;
1424 if (runtime
->oss
.period_ptr
== 0 ||
1425 runtime
->oss
.period_ptr
== runtime
->oss
.buffer_used
)
1426 runtime
->oss
.buffer_used
= 0;
1427 else if ((substream
->f_flags
& O_NONBLOCK
) != 0) {
1433 tmp
= snd_pcm_oss_write2(substream
,
1434 (const char __force
*)buf
,
1435 runtime
->oss
.period_bytes
, 0);
1438 runtime
->oss
.bytes
+= tmp
;
1442 if ((substream
->f_flags
& O_NONBLOCK
) != 0 &&
1443 tmp
!= runtime
->oss
.period_bytes
)
1447 mutex_unlock(&runtime
->oss
.params_lock
);
1450 if (signal_pending(current
)) {
1456 atomic_dec(&runtime
->oss
.rw_ref
);
1457 return xfer
> 0 ? (snd_pcm_sframes_t
)xfer
: tmp
;
1460 static ssize_t
snd_pcm_oss_read2(struct snd_pcm_substream
*substream
, char *buf
, size_t bytes
, int in_kernel
)
1462 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1463 snd_pcm_sframes_t frames
, frames1
;
1464 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
1465 char __user
*final_dst
= (char __force __user
*)buf
;
1466 if (runtime
->oss
.plugin_first
) {
1467 struct snd_pcm_plugin_channel
*channels
;
1468 size_t oss_frame_bytes
= (runtime
->oss
.plugin_last
->dst_width
* runtime
->oss
.plugin_last
->dst_format
.channels
) / 8;
1470 buf
= runtime
->oss
.buffer
;
1471 frames
= bytes
/ oss_frame_bytes
;
1472 frames1
= snd_pcm_plug_client_channels_buf(substream
, buf
, frames
, &channels
);
1475 frames1
= snd_pcm_plug_read_transfer(substream
, channels
, frames1
);
1478 bytes
= frames1
* oss_frame_bytes
;
1479 if (!in_kernel
&& copy_to_user(final_dst
, buf
, bytes
))
1484 frames
= bytes_to_frames(runtime
, bytes
);
1485 frames1
= snd_pcm_oss_read3(substream
, buf
, frames
, in_kernel
);
1488 bytes
= frames_to_bytes(runtime
, frames1
);
1493 static ssize_t
snd_pcm_oss_read1(struct snd_pcm_substream
*substream
, char __user
*buf
, size_t bytes
)
1497 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1499 if (atomic_read(&substream
->mmap_count
))
1502 atomic_inc(&runtime
->oss
.rw_ref
);
1504 if (mutex_lock_interruptible(&runtime
->oss
.params_lock
)) {
1508 tmp
= snd_pcm_oss_make_ready_locked(substream
);
1511 if (bytes
< runtime
->oss
.period_bytes
|| runtime
->oss
.buffer_used
> 0) {
1512 if (runtime
->oss
.buffer_used
== 0) {
1513 tmp
= snd_pcm_oss_read2(substream
, runtime
->oss
.buffer
, runtime
->oss
.period_bytes
, 1);
1516 runtime
->oss
.bytes
+= tmp
;
1517 runtime
->oss
.period_ptr
= tmp
;
1518 runtime
->oss
.buffer_used
= tmp
;
1521 if ((size_t) tmp
> runtime
->oss
.buffer_used
)
1522 tmp
= runtime
->oss
.buffer_used
;
1523 if (copy_to_user(buf
, runtime
->oss
.buffer
+ (runtime
->oss
.period_ptr
- runtime
->oss
.buffer_used
), tmp
)) {
1530 runtime
->oss
.buffer_used
-= tmp
;
1532 tmp
= snd_pcm_oss_read2(substream
, (char __force
*)buf
,
1533 runtime
->oss
.period_bytes
, 0);
1536 runtime
->oss
.bytes
+= tmp
;
1542 mutex_unlock(&runtime
->oss
.params_lock
);
1545 if (signal_pending(current
)) {
1551 atomic_dec(&runtime
->oss
.rw_ref
);
1552 return xfer
> 0 ? (snd_pcm_sframes_t
)xfer
: tmp
;
1555 static int snd_pcm_oss_reset(struct snd_pcm_oss_file
*pcm_oss_file
)
1557 struct snd_pcm_substream
*substream
;
1558 struct snd_pcm_runtime
*runtime
;
1561 for (i
= 0; i
< 2; i
++) {
1562 substream
= pcm_oss_file
->streams
[i
];
1565 runtime
= substream
->runtime
;
1566 snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DROP
, NULL
);
1567 mutex_lock(&runtime
->oss
.params_lock
);
1568 runtime
->oss
.prepare
= 1;
1569 runtime
->oss
.buffer_used
= 0;
1570 runtime
->oss
.prev_hw_ptr_period
= 0;
1571 runtime
->oss
.period_ptr
= 0;
1572 mutex_unlock(&runtime
->oss
.params_lock
);
1577 static int snd_pcm_oss_post(struct snd_pcm_oss_file
*pcm_oss_file
)
1579 struct snd_pcm_substream
*substream
;
1582 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
1583 if (substream
!= NULL
) {
1584 if ((err
= snd_pcm_oss_make_ready(substream
)) < 0)
1586 snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_START
, NULL
);
1588 /* note: all errors from the start action are ignored */
1589 /* OSS apps do not know, how to handle them */
1593 static int snd_pcm_oss_sync1(struct snd_pcm_substream
*substream
, size_t size
)
1595 struct snd_pcm_runtime
*runtime
;
1597 snd_pcm_state_t state
;
1599 wait_queue_entry_t wait
;
1601 runtime
= substream
->runtime
;
1602 init_waitqueue_entry(&wait
, current
);
1603 add_wait_queue(&runtime
->sleep
, &wait
);
1605 pcm_dbg(substream
->pcm
, "sync1: size = %li\n", size
);
1608 result
= snd_pcm_oss_write2(substream
, runtime
->oss
.buffer
, size
, 1);
1610 runtime
->oss
.buffer_used
= 0;
1614 if (result
!= 0 && result
!= -EAGAIN
)
1617 set_current_state(TASK_INTERRUPTIBLE
);
1618 snd_pcm_stream_lock_irq(substream
);
1619 state
= runtime
->status
->state
;
1620 snd_pcm_stream_unlock_irq(substream
);
1621 if (state
!= SNDRV_PCM_STATE_RUNNING
) {
1622 set_current_state(TASK_RUNNING
);
1625 res
= schedule_timeout(10 * HZ
);
1626 if (signal_pending(current
)) {
1627 result
= -ERESTARTSYS
;
1631 pcm_err(substream
->pcm
,
1632 "OSS sync error - DMA timeout\n");
1637 remove_wait_queue(&runtime
->sleep
, &wait
);
1641 static int snd_pcm_oss_sync(struct snd_pcm_oss_file
*pcm_oss_file
)
1644 unsigned int saved_f_flags
;
1645 struct snd_pcm_substream
*substream
;
1646 struct snd_pcm_runtime
*runtime
;
1647 snd_pcm_format_t format
;
1648 unsigned long width
;
1651 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
1652 if (substream
!= NULL
) {
1653 runtime
= substream
->runtime
;
1654 if (atomic_read(&substream
->mmap_count
))
1656 if ((err
= snd_pcm_oss_make_ready(substream
)) < 0)
1658 atomic_inc(&runtime
->oss
.rw_ref
);
1659 if (mutex_lock_interruptible(&runtime
->oss
.params_lock
)) {
1660 atomic_dec(&runtime
->oss
.rw_ref
);
1661 return -ERESTARTSYS
;
1663 format
= snd_pcm_oss_format_from(runtime
->oss
.format
);
1664 width
= snd_pcm_format_physical_width(format
);
1665 if (runtime
->oss
.buffer_used
> 0) {
1667 pcm_dbg(substream
->pcm
, "sync: buffer_used\n");
1669 size
= (8 * (runtime
->oss
.period_bytes
- runtime
->oss
.buffer_used
) + 7) / width
;
1670 snd_pcm_format_set_silence(format
,
1671 runtime
->oss
.buffer
+ runtime
->oss
.buffer_used
,
1673 err
= snd_pcm_oss_sync1(substream
, runtime
->oss
.period_bytes
);
1676 } else if (runtime
->oss
.period_ptr
> 0) {
1678 pcm_dbg(substream
->pcm
, "sync: period_ptr\n");
1680 size
= runtime
->oss
.period_bytes
- runtime
->oss
.period_ptr
;
1681 snd_pcm_format_set_silence(format
,
1682 runtime
->oss
.buffer
,
1684 err
= snd_pcm_oss_sync1(substream
, size
);
1689 * The ALSA's period might be a bit large than OSS one.
1690 * Fill the remain portion of ALSA period with zeros.
1692 size
= runtime
->control
->appl_ptr
% runtime
->period_size
;
1694 size
= runtime
->period_size
- size
;
1695 if (runtime
->access
== SNDRV_PCM_ACCESS_RW_INTERLEAVED
)
1696 snd_pcm_lib_write(substream
, NULL
, size
);
1697 else if (runtime
->access
== SNDRV_PCM_ACCESS_RW_NONINTERLEAVED
)
1698 snd_pcm_lib_writev(substream
, NULL
, size
);
1701 mutex_unlock(&runtime
->oss
.params_lock
);
1702 atomic_dec(&runtime
->oss
.rw_ref
);
1706 * finish sync: drain the buffer
1709 saved_f_flags
= substream
->f_flags
;
1710 substream
->f_flags
&= ~O_NONBLOCK
;
1711 err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DRAIN
, NULL
);
1712 substream
->f_flags
= saved_f_flags
;
1715 mutex_lock(&runtime
->oss
.params_lock
);
1716 runtime
->oss
.prepare
= 1;
1717 mutex_unlock(&runtime
->oss
.params_lock
);
1720 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
1721 if (substream
!= NULL
) {
1722 if ((err
= snd_pcm_oss_make_ready(substream
)) < 0)
1724 runtime
= substream
->runtime
;
1725 err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DROP
, NULL
);
1728 mutex_lock(&runtime
->oss
.params_lock
);
1729 runtime
->oss
.buffer_used
= 0;
1730 runtime
->oss
.prepare
= 1;
1731 mutex_unlock(&runtime
->oss
.params_lock
);
1736 static int snd_pcm_oss_set_rate(struct snd_pcm_oss_file
*pcm_oss_file
, int rate
)
1740 for (idx
= 1; idx
>= 0; --idx
) {
1741 struct snd_pcm_substream
*substream
= pcm_oss_file
->streams
[idx
];
1742 struct snd_pcm_runtime
*runtime
;
1745 if (substream
== NULL
)
1747 runtime
= substream
->runtime
;
1750 else if (rate
> 192000)
1752 err
= lock_params(runtime
);
1755 if (runtime
->oss
.rate
!= rate
) {
1756 runtime
->oss
.params
= 1;
1757 runtime
->oss
.rate
= rate
;
1759 unlock_params(runtime
);
1761 return snd_pcm_oss_get_rate(pcm_oss_file
);
1764 static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file
*pcm_oss_file
)
1766 struct snd_pcm_substream
*substream
;
1769 if ((err
= snd_pcm_oss_get_active_substream(pcm_oss_file
, &substream
)) < 0)
1771 return substream
->runtime
->oss
.rate
;
1774 static int snd_pcm_oss_set_channels(struct snd_pcm_oss_file
*pcm_oss_file
, unsigned int channels
)
1781 for (idx
= 1; idx
>= 0; --idx
) {
1782 struct snd_pcm_substream
*substream
= pcm_oss_file
->streams
[idx
];
1783 struct snd_pcm_runtime
*runtime
;
1786 if (substream
== NULL
)
1788 runtime
= substream
->runtime
;
1789 err
= lock_params(runtime
);
1792 if (runtime
->oss
.channels
!= channels
) {
1793 runtime
->oss
.params
= 1;
1794 runtime
->oss
.channels
= channels
;
1796 unlock_params(runtime
);
1798 return snd_pcm_oss_get_channels(pcm_oss_file
);
1801 static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file
*pcm_oss_file
)
1803 struct snd_pcm_substream
*substream
;
1806 if ((err
= snd_pcm_oss_get_active_substream(pcm_oss_file
, &substream
)) < 0)
1808 return substream
->runtime
->oss
.channels
;
1811 static int snd_pcm_oss_get_block_size(struct snd_pcm_oss_file
*pcm_oss_file
)
1813 struct snd_pcm_substream
*substream
;
1816 if ((err
= snd_pcm_oss_get_active_substream(pcm_oss_file
, &substream
)) < 0)
1818 return substream
->runtime
->oss
.period_bytes
;
1821 static int snd_pcm_oss_get_formats(struct snd_pcm_oss_file
*pcm_oss_file
)
1823 struct snd_pcm_substream
*substream
;
1826 struct snd_pcm_hw_params
*params
;
1827 unsigned int formats
= 0;
1828 const struct snd_mask
*format_mask
;
1831 if ((err
= snd_pcm_oss_get_active_substream(pcm_oss_file
, &substream
)) < 0)
1833 if (atomic_read(&substream
->mmap_count
))
1836 direct
= substream
->oss
.setup
.direct
;
1838 return AFMT_MU_LAW
| AFMT_U8
|
1839 AFMT_S16_LE
| AFMT_S16_BE
|
1840 AFMT_S8
| AFMT_U16_LE
|
1842 AFMT_S32_LE
| AFMT_S32_BE
|
1843 AFMT_S24_LE
| AFMT_S24_BE
|
1845 params
= kmalloc(sizeof(*params
), GFP_KERNEL
);
1848 _snd_pcm_hw_params_any(params
);
1849 err
= snd_pcm_hw_refine(substream
, params
);
1852 format_mask
= hw_param_mask_c(params
, SNDRV_PCM_HW_PARAM_FORMAT
);
1853 for (fmt
= 0; fmt
< 32; ++fmt
) {
1854 if (snd_mask_test(format_mask
, fmt
)) {
1855 int f
= snd_pcm_oss_format_to((__force snd_pcm_format_t
)fmt
);
1863 return err
< 0 ? err
: formats
;
1866 static int snd_pcm_oss_set_format(struct snd_pcm_oss_file
*pcm_oss_file
, int format
)
1871 if (format
!= AFMT_QUERY
) {
1872 formats
= snd_pcm_oss_get_formats(pcm_oss_file
);
1875 if (!(formats
& format
))
1877 for (idx
= 1; idx
>= 0; --idx
) {
1878 struct snd_pcm_substream
*substream
= pcm_oss_file
->streams
[idx
];
1879 struct snd_pcm_runtime
*runtime
;
1880 if (substream
== NULL
)
1882 runtime
= substream
->runtime
;
1883 err
= lock_params(runtime
);
1886 if (runtime
->oss
.format
!= format
) {
1887 runtime
->oss
.params
= 1;
1888 runtime
->oss
.format
= format
;
1890 unlock_params(runtime
);
1893 return snd_pcm_oss_get_format(pcm_oss_file
);
1896 static int snd_pcm_oss_get_format(struct snd_pcm_oss_file
*pcm_oss_file
)
1898 struct snd_pcm_substream
*substream
;
1901 if ((err
= snd_pcm_oss_get_active_substream(pcm_oss_file
, &substream
)) < 0)
1903 return substream
->runtime
->oss
.format
;
1906 static int snd_pcm_oss_set_subdivide1(struct snd_pcm_substream
*substream
, int subdivide
)
1908 struct snd_pcm_runtime
*runtime
;
1910 runtime
= substream
->runtime
;
1911 if (subdivide
== 0) {
1912 subdivide
= runtime
->oss
.subdivision
;
1917 if (runtime
->oss
.subdivision
|| runtime
->oss
.fragshift
)
1919 if (subdivide
!= 1 && subdivide
!= 2 && subdivide
!= 4 &&
1920 subdivide
!= 8 && subdivide
!= 16)
1922 runtime
->oss
.subdivision
= subdivide
;
1923 runtime
->oss
.params
= 1;
1927 static int snd_pcm_oss_set_subdivide(struct snd_pcm_oss_file
*pcm_oss_file
, int subdivide
)
1929 int err
= -EINVAL
, idx
;
1931 for (idx
= 1; idx
>= 0; --idx
) {
1932 struct snd_pcm_substream
*substream
= pcm_oss_file
->streams
[idx
];
1933 struct snd_pcm_runtime
*runtime
;
1935 if (substream
== NULL
)
1937 runtime
= substream
->runtime
;
1938 err
= lock_params(runtime
);
1941 err
= snd_pcm_oss_set_subdivide1(substream
, subdivide
);
1942 unlock_params(runtime
);
1949 static int snd_pcm_oss_set_fragment1(struct snd_pcm_substream
*substream
, unsigned int val
)
1951 struct snd_pcm_runtime
*runtime
;
1953 runtime
= substream
->runtime
;
1954 if (runtime
->oss
.subdivision
|| runtime
->oss
.fragshift
)
1956 runtime
->oss
.fragshift
= val
& 0xffff;
1957 runtime
->oss
.maxfrags
= (val
>> 16) & 0xffff;
1958 if (runtime
->oss
.fragshift
< 4) /* < 16 */
1959 runtime
->oss
.fragshift
= 4;
1960 if (runtime
->oss
.maxfrags
< 2)
1961 runtime
->oss
.maxfrags
= 2;
1962 runtime
->oss
.params
= 1;
1966 static int snd_pcm_oss_set_fragment(struct snd_pcm_oss_file
*pcm_oss_file
, unsigned int val
)
1968 int err
= -EINVAL
, idx
;
1970 for (idx
= 1; idx
>= 0; --idx
) {
1971 struct snd_pcm_substream
*substream
= pcm_oss_file
->streams
[idx
];
1972 struct snd_pcm_runtime
*runtime
;
1974 if (substream
== NULL
)
1976 runtime
= substream
->runtime
;
1977 err
= lock_params(runtime
);
1980 err
= snd_pcm_oss_set_fragment1(substream
, val
);
1981 unlock_params(runtime
);
1988 static int snd_pcm_oss_nonblock(struct file
* file
)
1990 spin_lock(&file
->f_lock
);
1991 file
->f_flags
|= O_NONBLOCK
;
1992 spin_unlock(&file
->f_lock
);
1996 static int snd_pcm_oss_get_caps1(struct snd_pcm_substream
*substream
, int res
)
1999 if (substream
== NULL
) {
2000 res
&= ~DSP_CAP_DUPLEX
;
2003 #ifdef DSP_CAP_MULTI
2004 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
2005 if (substream
->pstr
->substream_count
> 1)
2006 res
|= DSP_CAP_MULTI
;
2008 /* DSP_CAP_REALTIME is set all times: */
2009 /* all ALSA drivers can return actual pointer in ring buffer */
2010 #if defined(DSP_CAP_REALTIME) && 0
2012 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
2013 if (runtime
->info
& (SNDRV_PCM_INFO_BLOCK_TRANSFER
|SNDRV_PCM_INFO_BATCH
))
2014 res
&= ~DSP_CAP_REALTIME
;
2020 static int snd_pcm_oss_get_caps(struct snd_pcm_oss_file
*pcm_oss_file
)
2024 result
= DSP_CAP_TRIGGER
| DSP_CAP_MMAP
| DSP_CAP_DUPLEX
| DSP_CAP_REALTIME
;
2025 for (idx
= 0; idx
< 2; idx
++) {
2026 struct snd_pcm_substream
*substream
= pcm_oss_file
->streams
[idx
];
2027 result
= snd_pcm_oss_get_caps1(substream
, result
);
2029 result
|= 0x0001; /* revision - same as SB AWE 64 */
2033 static void snd_pcm_oss_simulate_fill(struct snd_pcm_substream
*substream
,
2034 snd_pcm_uframes_t hw_ptr
)
2036 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
2037 snd_pcm_uframes_t appl_ptr
;
2038 appl_ptr
= hw_ptr
+ runtime
->buffer_size
;
2039 appl_ptr
%= runtime
->boundary
;
2040 runtime
->control
->appl_ptr
= appl_ptr
;
2043 static int snd_pcm_oss_set_trigger(struct snd_pcm_oss_file
*pcm_oss_file
, int trigger
)
2045 struct snd_pcm_runtime
*runtime
;
2046 struct snd_pcm_substream
*psubstream
= NULL
, *csubstream
= NULL
;
2050 pcm_dbg(substream
->pcm
, "pcm_oss: trigger = 0x%x\n", trigger
);
2053 psubstream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
2054 csubstream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
2057 if ((err
= snd_pcm_oss_make_ready(psubstream
)) < 0)
2061 if ((err
= snd_pcm_oss_make_ready(csubstream
)) < 0)
2065 runtime
= psubstream
->runtime
;
2067 if (mutex_lock_interruptible(&runtime
->oss
.params_lock
))
2068 return -ERESTARTSYS
;
2069 if (trigger
& PCM_ENABLE_OUTPUT
) {
2070 if (runtime
->oss
.trigger
)
2072 if (atomic_read(&psubstream
->mmap_count
))
2073 snd_pcm_oss_simulate_fill(psubstream
,
2074 get_hw_ptr_period(runtime
));
2075 runtime
->oss
.trigger
= 1;
2076 runtime
->start_threshold
= 1;
2077 cmd
= SNDRV_PCM_IOCTL_START
;
2079 if (!runtime
->oss
.trigger
)
2081 runtime
->oss
.trigger
= 0;
2082 runtime
->start_threshold
= runtime
->boundary
;
2083 cmd
= SNDRV_PCM_IOCTL_DROP
;
2084 runtime
->oss
.prepare
= 1;
2087 mutex_unlock(&runtime
->oss
.params_lock
);
2089 err
= snd_pcm_kernel_ioctl(psubstream
, cmd
, NULL
);
2095 runtime
= csubstream
->runtime
;
2097 if (mutex_lock_interruptible(&runtime
->oss
.params_lock
))
2098 return -ERESTARTSYS
;
2099 if (trigger
& PCM_ENABLE_INPUT
) {
2100 if (runtime
->oss
.trigger
)
2102 runtime
->oss
.trigger
= 1;
2103 runtime
->start_threshold
= 1;
2104 cmd
= SNDRV_PCM_IOCTL_START
;
2106 if (!runtime
->oss
.trigger
)
2108 runtime
->oss
.trigger
= 0;
2109 runtime
->start_threshold
= runtime
->boundary
;
2110 cmd
= SNDRV_PCM_IOCTL_DROP
;
2111 runtime
->oss
.prepare
= 1;
2114 mutex_unlock(&runtime
->oss
.params_lock
);
2116 err
= snd_pcm_kernel_ioctl(csubstream
, cmd
, NULL
);
2124 static int snd_pcm_oss_get_trigger(struct snd_pcm_oss_file
*pcm_oss_file
)
2126 struct snd_pcm_substream
*psubstream
= NULL
, *csubstream
= NULL
;
2129 psubstream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
2130 csubstream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
2131 if (psubstream
&& psubstream
->runtime
&& psubstream
->runtime
->oss
.trigger
)
2132 result
|= PCM_ENABLE_OUTPUT
;
2133 if (csubstream
&& csubstream
->runtime
&& csubstream
->runtime
->oss
.trigger
)
2134 result
|= PCM_ENABLE_INPUT
;
2138 static int snd_pcm_oss_get_odelay(struct snd_pcm_oss_file
*pcm_oss_file
)
2140 struct snd_pcm_substream
*substream
;
2141 struct snd_pcm_runtime
*runtime
;
2142 snd_pcm_sframes_t delay
;
2145 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
2146 if (substream
== NULL
)
2148 if ((err
= snd_pcm_oss_make_ready(substream
)) < 0)
2150 runtime
= substream
->runtime
;
2151 if (runtime
->oss
.params
|| runtime
->oss
.prepare
)
2153 err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DELAY
, &delay
);
2155 delay
= 0; /* hack for broken OSS applications */
2158 return snd_pcm_oss_bytes(substream
, delay
);
2161 static int snd_pcm_oss_get_ptr(struct snd_pcm_oss_file
*pcm_oss_file
, int stream
, struct count_info __user
* _info
)
2163 struct snd_pcm_substream
*substream
;
2164 struct snd_pcm_runtime
*runtime
;
2165 snd_pcm_sframes_t delay
;
2167 struct count_info info
;
2172 substream
= pcm_oss_file
->streams
[stream
];
2173 if (substream
== NULL
)
2175 if ((err
= snd_pcm_oss_make_ready(substream
)) < 0)
2177 runtime
= substream
->runtime
;
2178 if (runtime
->oss
.params
|| runtime
->oss
.prepare
) {
2179 memset(&info
, 0, sizeof(info
));
2180 if (copy_to_user(_info
, &info
, sizeof(info
)))
2184 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
2185 err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DELAY
, &delay
);
2186 if (err
== -EPIPE
|| err
== -ESTRPIPE
|| (! err
&& delay
< 0)) {
2191 fixup
= runtime
->oss
.buffer_used
;
2194 err
= snd_pcm_oss_capture_position_fixup(substream
, &delay
);
2195 fixup
= -runtime
->oss
.buffer_used
;
2199 info
.ptr
= snd_pcm_oss_bytes(substream
, runtime
->status
->hw_ptr
% runtime
->buffer_size
);
2200 if (atomic_read(&substream
->mmap_count
)) {
2201 snd_pcm_sframes_t n
;
2202 delay
= get_hw_ptr_period(runtime
);
2203 n
= delay
- runtime
->oss
.prev_hw_ptr_period
;
2205 n
+= runtime
->boundary
;
2206 info
.blocks
= n
/ runtime
->period_size
;
2207 runtime
->oss
.prev_hw_ptr_period
= delay
;
2208 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
2209 snd_pcm_oss_simulate_fill(substream
, delay
);
2210 info
.bytes
= snd_pcm_oss_bytes(substream
, runtime
->status
->hw_ptr
) & INT_MAX
;
2212 delay
= snd_pcm_oss_bytes(substream
, delay
);
2213 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
2214 if (substream
->oss
.setup
.buggyptr
)
2215 info
.blocks
= (runtime
->oss
.buffer_bytes
- delay
- fixup
) / runtime
->oss
.period_bytes
;
2217 info
.blocks
= (delay
+ fixup
) / runtime
->oss
.period_bytes
;
2218 info
.bytes
= (runtime
->oss
.bytes
- delay
) & INT_MAX
;
2221 info
.blocks
= delay
/ runtime
->oss
.period_bytes
;
2222 info
.bytes
= (runtime
->oss
.bytes
+ delay
) & INT_MAX
;
2225 if (copy_to_user(_info
, &info
, sizeof(info
)))
2230 static int snd_pcm_oss_get_space(struct snd_pcm_oss_file
*pcm_oss_file
, int stream
, struct audio_buf_info __user
*_info
)
2232 struct snd_pcm_substream
*substream
;
2233 struct snd_pcm_runtime
*runtime
;
2234 snd_pcm_sframes_t avail
;
2236 struct audio_buf_info info
;
2241 substream
= pcm_oss_file
->streams
[stream
];
2242 if (substream
== NULL
)
2244 runtime
= substream
->runtime
;
2246 if (runtime
->oss
.params
&&
2247 (err
= snd_pcm_oss_change_params(substream
, false)) < 0)
2250 info
.fragsize
= runtime
->oss
.period_bytes
;
2251 info
.fragstotal
= runtime
->periods
;
2252 if (runtime
->oss
.prepare
) {
2253 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
2254 info
.bytes
= runtime
->oss
.period_bytes
* runtime
->oss
.periods
;
2255 info
.fragments
= runtime
->oss
.periods
;
2261 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
2262 err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DELAY
, &avail
);
2263 if (err
== -EPIPE
|| err
== -ESTRPIPE
|| (! err
&& avail
< 0)) {
2264 avail
= runtime
->buffer_size
;
2268 avail
= runtime
->buffer_size
- avail
;
2269 fixup
= -runtime
->oss
.buffer_used
;
2272 err
= snd_pcm_oss_capture_position_fixup(substream
, &avail
);
2273 fixup
= runtime
->oss
.buffer_used
;
2277 info
.bytes
= snd_pcm_oss_bytes(substream
, avail
) + fixup
;
2278 info
.fragments
= info
.bytes
/ runtime
->oss
.period_bytes
;
2282 pcm_dbg(substream
->pcm
,
2283 "pcm_oss: space: bytes = %i, fragments = %i, fragstotal = %i, fragsize = %i\n",
2284 info
.bytes
, info
.fragments
, info
.fragstotal
, info
.fragsize
);
2286 if (copy_to_user(_info
, &info
, sizeof(info
)))
2291 static int snd_pcm_oss_get_mapbuf(struct snd_pcm_oss_file
*pcm_oss_file
, int stream
, struct buffmem_desc __user
* _info
)
2293 // it won't be probably implemented
2294 // pr_debug("TODO: snd_pcm_oss_get_mapbuf\n");
2298 static const char *strip_task_path(const char *path
)
2300 const char *ptr
, *ptrl
= NULL
;
2301 for (ptr
= path
; *ptr
; ptr
++) {
2308 static void snd_pcm_oss_look_for_setup(struct snd_pcm
*pcm
, int stream
,
2309 const char *task_name
,
2310 struct snd_pcm_oss_setup
*rsetup
)
2312 struct snd_pcm_oss_setup
*setup
;
2314 mutex_lock(&pcm
->streams
[stream
].oss
.setup_mutex
);
2316 for (setup
= pcm
->streams
[stream
].oss
.setup_list
; setup
;
2317 setup
= setup
->next
) {
2318 if (!strcmp(setup
->task_name
, task_name
))
2321 } while ((task_name
= strip_task_path(task_name
)) != NULL
);
2325 mutex_unlock(&pcm
->streams
[stream
].oss
.setup_mutex
);
2328 static void snd_pcm_oss_release_substream(struct snd_pcm_substream
*substream
)
2330 struct snd_pcm_runtime
*runtime
;
2331 runtime
= substream
->runtime
;
2332 kvfree(runtime
->oss
.buffer
);
2333 runtime
->oss
.buffer
= NULL
;
2334 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
2335 snd_pcm_oss_plugin_clear(substream
);
2337 substream
->oss
.oss
= 0;
2340 static void snd_pcm_oss_init_substream(struct snd_pcm_substream
*substream
,
2341 struct snd_pcm_oss_setup
*setup
,
2344 struct snd_pcm_runtime
*runtime
;
2346 substream
->oss
.oss
= 1;
2347 substream
->oss
.setup
= *setup
;
2348 if (setup
->nonblock
)
2349 substream
->f_flags
|= O_NONBLOCK
;
2350 else if (setup
->block
)
2351 substream
->f_flags
&= ~O_NONBLOCK
;
2352 runtime
= substream
->runtime
;
2353 runtime
->oss
.params
= 1;
2354 runtime
->oss
.trigger
= 1;
2355 runtime
->oss
.rate
= 8000;
2356 mutex_init(&runtime
->oss
.params_lock
);
2357 switch (SNDRV_MINOR_OSS_DEVICE(minor
)) {
2358 case SNDRV_MINOR_OSS_PCM_8
:
2359 runtime
->oss
.format
= AFMT_U8
;
2361 case SNDRV_MINOR_OSS_PCM_16
:
2362 runtime
->oss
.format
= AFMT_S16_LE
;
2365 runtime
->oss
.format
= AFMT_MU_LAW
;
2367 runtime
->oss
.channels
= 1;
2368 runtime
->oss
.fragshift
= 0;
2369 runtime
->oss
.maxfrags
= 0;
2370 runtime
->oss
.subdivision
= 0;
2371 substream
->pcm_release
= snd_pcm_oss_release_substream
;
2372 atomic_set(&runtime
->oss
.rw_ref
, 0);
2375 static int snd_pcm_oss_release_file(struct snd_pcm_oss_file
*pcm_oss_file
)
2380 for (cidx
= 0; cidx
< 2; ++cidx
) {
2381 struct snd_pcm_substream
*substream
= pcm_oss_file
->streams
[cidx
];
2383 snd_pcm_release_substream(substream
);
2385 kfree(pcm_oss_file
);
2389 static int snd_pcm_oss_open_file(struct file
*file
,
2390 struct snd_pcm
*pcm
,
2391 struct snd_pcm_oss_file
**rpcm_oss_file
,
2393 struct snd_pcm_oss_setup
*setup
)
2396 struct snd_pcm_oss_file
*pcm_oss_file
;
2397 struct snd_pcm_substream
*substream
;
2398 fmode_t f_mode
= file
->f_mode
;
2401 *rpcm_oss_file
= NULL
;
2403 pcm_oss_file
= kzalloc(sizeof(*pcm_oss_file
), GFP_KERNEL
);
2404 if (pcm_oss_file
== NULL
)
2407 if ((f_mode
& (FMODE_WRITE
|FMODE_READ
)) == (FMODE_WRITE
|FMODE_READ
) &&
2408 (pcm
->info_flags
& SNDRV_PCM_INFO_HALF_DUPLEX
))
2409 f_mode
= FMODE_WRITE
;
2411 file
->f_flags
&= ~O_APPEND
;
2412 for (idx
= 0; idx
< 2; idx
++) {
2413 if (setup
[idx
].disable
)
2415 if (! pcm
->streams
[idx
].substream_count
)
2416 continue; /* no matching substream */
2417 if (idx
== SNDRV_PCM_STREAM_PLAYBACK
) {
2418 if (! (f_mode
& FMODE_WRITE
))
2421 if (! (f_mode
& FMODE_READ
))
2424 err
= snd_pcm_open_substream(pcm
, idx
, file
, &substream
);
2426 snd_pcm_oss_release_file(pcm_oss_file
);
2430 pcm_oss_file
->streams
[idx
] = substream
;
2431 snd_pcm_oss_init_substream(substream
, &setup
[idx
], minor
);
2434 if (!pcm_oss_file
->streams
[0] && !pcm_oss_file
->streams
[1]) {
2435 snd_pcm_oss_release_file(pcm_oss_file
);
2439 file
->private_data
= pcm_oss_file
;
2441 *rpcm_oss_file
= pcm_oss_file
;
2446 static int snd_task_name(struct task_struct
*task
, char *name
, size_t size
)
2450 if (snd_BUG_ON(!task
|| !name
|| size
< 2))
2452 for (idx
= 0; idx
< sizeof(task
->comm
) && idx
+ 1 < size
; idx
++)
2453 name
[idx
] = task
->comm
[idx
];
2458 static int snd_pcm_oss_open(struct inode
*inode
, struct file
*file
)
2462 struct snd_pcm
*pcm
;
2463 struct snd_pcm_oss_file
*pcm_oss_file
;
2464 struct snd_pcm_oss_setup setup
[2];
2466 wait_queue_entry_t wait
;
2468 err
= nonseekable_open(inode
, file
);
2472 pcm
= snd_lookup_oss_minor_data(iminor(inode
),
2473 SNDRV_OSS_DEVICE_TYPE_PCM
);
2478 err
= snd_card_file_add(pcm
->card
, file
);
2481 if (!try_module_get(pcm
->card
->module
)) {
2485 if (snd_task_name(current
, task_name
, sizeof(task_name
)) < 0) {
2489 memset(setup
, 0, sizeof(setup
));
2490 if (file
->f_mode
& FMODE_WRITE
)
2491 snd_pcm_oss_look_for_setup(pcm
, SNDRV_PCM_STREAM_PLAYBACK
,
2492 task_name
, &setup
[0]);
2493 if (file
->f_mode
& FMODE_READ
)
2494 snd_pcm_oss_look_for_setup(pcm
, SNDRV_PCM_STREAM_CAPTURE
,
2495 task_name
, &setup
[1]);
2497 nonblock
= !!(file
->f_flags
& O_NONBLOCK
);
2499 nonblock
= nonblock_open
;
2501 init_waitqueue_entry(&wait
, current
);
2502 add_wait_queue(&pcm
->open_wait
, &wait
);
2503 mutex_lock(&pcm
->open_mutex
);
2505 err
= snd_pcm_oss_open_file(file
, pcm
, &pcm_oss_file
,
2506 iminor(inode
), setup
);
2509 if (err
== -EAGAIN
) {
2516 set_current_state(TASK_INTERRUPTIBLE
);
2517 mutex_unlock(&pcm
->open_mutex
);
2519 mutex_lock(&pcm
->open_mutex
);
2520 if (pcm
->card
->shutdown
) {
2524 if (signal_pending(current
)) {
2529 remove_wait_queue(&pcm
->open_wait
, &wait
);
2530 mutex_unlock(&pcm
->open_mutex
);
2533 snd_card_unref(pcm
->card
);
2537 module_put(pcm
->card
->module
);
2539 snd_card_file_remove(pcm
->card
, file
);
2542 snd_card_unref(pcm
->card
);
2546 static int snd_pcm_oss_release(struct inode
*inode
, struct file
*file
)
2548 struct snd_pcm
*pcm
;
2549 struct snd_pcm_substream
*substream
;
2550 struct snd_pcm_oss_file
*pcm_oss_file
;
2552 pcm_oss_file
= file
->private_data
;
2553 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
2554 if (substream
== NULL
)
2555 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
2556 if (snd_BUG_ON(!substream
))
2558 pcm
= substream
->pcm
;
2559 if (!pcm
->card
->shutdown
)
2560 snd_pcm_oss_sync(pcm_oss_file
);
2561 mutex_lock(&pcm
->open_mutex
);
2562 snd_pcm_oss_release_file(pcm_oss_file
);
2563 mutex_unlock(&pcm
->open_mutex
);
2564 wake_up(&pcm
->open_wait
);
2565 module_put(pcm
->card
->module
);
2566 snd_card_file_remove(pcm
->card
, file
);
2570 static long snd_pcm_oss_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
2572 struct snd_pcm_oss_file
*pcm_oss_file
;
2573 int __user
*p
= (int __user
*)arg
;
2576 pcm_oss_file
= file
->private_data
;
2577 if (cmd
== OSS_GETVERSION
)
2578 return put_user(SNDRV_OSS_VERSION
, p
);
2579 if (cmd
== OSS_ALSAEMULVER
)
2580 return put_user(1, p
);
2581 #if IS_REACHABLE(CONFIG_SND_MIXER_OSS)
2582 if (((cmd
>> 8) & 0xff) == 'M') { /* mixer ioctl - for OSS compatibility */
2583 struct snd_pcm_substream
*substream
;
2585 for (idx
= 0; idx
< 2; ++idx
) {
2586 substream
= pcm_oss_file
->streams
[idx
];
2587 if (substream
!= NULL
)
2590 if (snd_BUG_ON(idx
>= 2))
2592 return snd_mixer_oss_ioctl_card(substream
->pcm
->card
, cmd
, arg
);
2595 if (((cmd
>> 8) & 0xff) != 'P')
2598 pr_debug("pcm_oss: ioctl = 0x%x\n", cmd
);
2601 case SNDCTL_DSP_RESET
:
2602 return snd_pcm_oss_reset(pcm_oss_file
);
2603 case SNDCTL_DSP_SYNC
:
2604 return snd_pcm_oss_sync(pcm_oss_file
);
2605 case SNDCTL_DSP_SPEED
:
2606 if (get_user(res
, p
))
2608 if ((res
= snd_pcm_oss_set_rate(pcm_oss_file
, res
))<0)
2610 return put_user(res
, p
);
2611 case SOUND_PCM_READ_RATE
:
2612 res
= snd_pcm_oss_get_rate(pcm_oss_file
);
2615 return put_user(res
, p
);
2616 case SNDCTL_DSP_STEREO
:
2617 if (get_user(res
, p
))
2619 res
= res
> 0 ? 2 : 1;
2620 if ((res
= snd_pcm_oss_set_channels(pcm_oss_file
, res
)) < 0)
2622 return put_user(--res
, p
);
2623 case SNDCTL_DSP_GETBLKSIZE
:
2624 res
= snd_pcm_oss_get_block_size(pcm_oss_file
);
2627 return put_user(res
, p
);
2628 case SNDCTL_DSP_SETFMT
:
2629 if (get_user(res
, p
))
2631 res
= snd_pcm_oss_set_format(pcm_oss_file
, res
);
2634 return put_user(res
, p
);
2635 case SOUND_PCM_READ_BITS
:
2636 res
= snd_pcm_oss_get_format(pcm_oss_file
);
2639 return put_user(res
, p
);
2640 case SNDCTL_DSP_CHANNELS
:
2641 if (get_user(res
, p
))
2643 res
= snd_pcm_oss_set_channels(pcm_oss_file
, res
);
2646 return put_user(res
, p
);
2647 case SOUND_PCM_READ_CHANNELS
:
2648 res
= snd_pcm_oss_get_channels(pcm_oss_file
);
2651 return put_user(res
, p
);
2652 case SOUND_PCM_WRITE_FILTER
:
2653 case SOUND_PCM_READ_FILTER
:
2655 case SNDCTL_DSP_POST
:
2656 return snd_pcm_oss_post(pcm_oss_file
);
2657 case SNDCTL_DSP_SUBDIVIDE
:
2658 if (get_user(res
, p
))
2660 res
= snd_pcm_oss_set_subdivide(pcm_oss_file
, res
);
2663 return put_user(res
, p
);
2664 case SNDCTL_DSP_SETFRAGMENT
:
2665 if (get_user(res
, p
))
2667 return snd_pcm_oss_set_fragment(pcm_oss_file
, res
);
2668 case SNDCTL_DSP_GETFMTS
:
2669 res
= snd_pcm_oss_get_formats(pcm_oss_file
);
2672 return put_user(res
, p
);
2673 case SNDCTL_DSP_GETOSPACE
:
2674 case SNDCTL_DSP_GETISPACE
:
2675 return snd_pcm_oss_get_space(pcm_oss_file
,
2676 cmd
== SNDCTL_DSP_GETISPACE
?
2677 SNDRV_PCM_STREAM_CAPTURE
: SNDRV_PCM_STREAM_PLAYBACK
,
2678 (struct audio_buf_info __user
*) arg
);
2679 case SNDCTL_DSP_NONBLOCK
:
2680 return snd_pcm_oss_nonblock(file
);
2681 case SNDCTL_DSP_GETCAPS
:
2682 res
= snd_pcm_oss_get_caps(pcm_oss_file
);
2685 return put_user(res
, p
);
2686 case SNDCTL_DSP_GETTRIGGER
:
2687 res
= snd_pcm_oss_get_trigger(pcm_oss_file
);
2690 return put_user(res
, p
);
2691 case SNDCTL_DSP_SETTRIGGER
:
2692 if (get_user(res
, p
))
2694 return snd_pcm_oss_set_trigger(pcm_oss_file
, res
);
2695 case SNDCTL_DSP_GETIPTR
:
2696 case SNDCTL_DSP_GETOPTR
:
2697 return snd_pcm_oss_get_ptr(pcm_oss_file
,
2698 cmd
== SNDCTL_DSP_GETIPTR
?
2699 SNDRV_PCM_STREAM_CAPTURE
: SNDRV_PCM_STREAM_PLAYBACK
,
2700 (struct count_info __user
*) arg
);
2701 case SNDCTL_DSP_MAPINBUF
:
2702 case SNDCTL_DSP_MAPOUTBUF
:
2703 return snd_pcm_oss_get_mapbuf(pcm_oss_file
,
2704 cmd
== SNDCTL_DSP_MAPINBUF
?
2705 SNDRV_PCM_STREAM_CAPTURE
: SNDRV_PCM_STREAM_PLAYBACK
,
2706 (struct buffmem_desc __user
*) arg
);
2707 case SNDCTL_DSP_SETSYNCRO
:
2708 /* stop DMA now.. */
2710 case SNDCTL_DSP_SETDUPLEX
:
2711 if (snd_pcm_oss_get_caps(pcm_oss_file
) & DSP_CAP_DUPLEX
)
2714 case SNDCTL_DSP_GETODELAY
:
2715 res
= snd_pcm_oss_get_odelay(pcm_oss_file
);
2717 /* it's for sure, some broken apps don't check for error codes */
2721 return put_user(res
, p
);
2722 case SNDCTL_DSP_PROFILE
:
2723 return 0; /* silently ignore */
2725 pr_debug("pcm_oss: unknown command = 0x%x\n", cmd
);
2730 #ifdef CONFIG_COMPAT
2731 /* all compatible */
2732 static long snd_pcm_oss_ioctl_compat(struct file
*file
, unsigned int cmd
,
2735 return snd_pcm_oss_ioctl(file
, cmd
, (unsigned long)compat_ptr(arg
));
2738 #define snd_pcm_oss_ioctl_compat NULL
2741 static ssize_t
snd_pcm_oss_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*offset
)
2743 struct snd_pcm_oss_file
*pcm_oss_file
;
2744 struct snd_pcm_substream
*substream
;
2746 pcm_oss_file
= file
->private_data
;
2747 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
2748 if (substream
== NULL
)
2750 substream
->f_flags
= file
->f_flags
& O_NONBLOCK
;
2752 return snd_pcm_oss_read1(substream
, buf
, count
);
2755 ssize_t res
= snd_pcm_oss_read1(substream
, buf
, count
);
2756 pcm_dbg(substream
->pcm
,
2757 "pcm_oss: read %li bytes (returned %li bytes)\n",
2758 (long)count
, (long)res
);
2764 static ssize_t
snd_pcm_oss_write(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
*offset
)
2766 struct snd_pcm_oss_file
*pcm_oss_file
;
2767 struct snd_pcm_substream
*substream
;
2770 pcm_oss_file
= file
->private_data
;
2771 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
2772 if (substream
== NULL
)
2774 substream
->f_flags
= file
->f_flags
& O_NONBLOCK
;
2775 result
= snd_pcm_oss_write1(substream
, buf
, count
);
2777 pcm_dbg(substream
->pcm
, "pcm_oss: write %li bytes (wrote %li bytes)\n",
2778 (long)count
, (long)result
);
2783 static int snd_pcm_oss_playback_ready(struct snd_pcm_substream
*substream
)
2785 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
2786 if (atomic_read(&substream
->mmap_count
))
2787 return runtime
->oss
.prev_hw_ptr_period
!=
2788 get_hw_ptr_period(runtime
);
2790 return snd_pcm_playback_avail(runtime
) >=
2791 runtime
->oss
.period_frames
;
2794 static int snd_pcm_oss_capture_ready(struct snd_pcm_substream
*substream
)
2796 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
2797 if (atomic_read(&substream
->mmap_count
))
2798 return runtime
->oss
.prev_hw_ptr_period
!=
2799 get_hw_ptr_period(runtime
);
2801 return snd_pcm_capture_avail(runtime
) >=
2802 runtime
->oss
.period_frames
;
2805 static __poll_t
snd_pcm_oss_poll(struct file
*file
, poll_table
* wait
)
2807 struct snd_pcm_oss_file
*pcm_oss_file
;
2809 struct snd_pcm_substream
*psubstream
= NULL
, *csubstream
= NULL
;
2811 pcm_oss_file
= file
->private_data
;
2813 psubstream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
2814 csubstream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
2817 if (psubstream
!= NULL
) {
2818 struct snd_pcm_runtime
*runtime
= psubstream
->runtime
;
2819 poll_wait(file
, &runtime
->sleep
, wait
);
2820 snd_pcm_stream_lock_irq(psubstream
);
2821 if (runtime
->status
->state
!= SNDRV_PCM_STATE_DRAINING
&&
2822 (runtime
->status
->state
!= SNDRV_PCM_STATE_RUNNING
||
2823 snd_pcm_oss_playback_ready(psubstream
)))
2824 mask
|= EPOLLOUT
| EPOLLWRNORM
;
2825 snd_pcm_stream_unlock_irq(psubstream
);
2827 if (csubstream
!= NULL
) {
2828 struct snd_pcm_runtime
*runtime
= csubstream
->runtime
;
2829 snd_pcm_state_t ostate
;
2830 poll_wait(file
, &runtime
->sleep
, wait
);
2831 snd_pcm_stream_lock_irq(csubstream
);
2832 if ((ostate
= runtime
->status
->state
) != SNDRV_PCM_STATE_RUNNING
||
2833 snd_pcm_oss_capture_ready(csubstream
))
2834 mask
|= EPOLLIN
| EPOLLRDNORM
;
2835 snd_pcm_stream_unlock_irq(csubstream
);
2836 if (ostate
!= SNDRV_PCM_STATE_RUNNING
&& runtime
->oss
.trigger
) {
2837 struct snd_pcm_oss_file ofile
;
2838 memset(&ofile
, 0, sizeof(ofile
));
2839 ofile
.streams
[SNDRV_PCM_STREAM_CAPTURE
] = pcm_oss_file
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
2840 runtime
->oss
.trigger
= 0;
2841 snd_pcm_oss_set_trigger(&ofile
, PCM_ENABLE_INPUT
);
2848 static int snd_pcm_oss_mmap(struct file
*file
, struct vm_area_struct
*area
)
2850 struct snd_pcm_oss_file
*pcm_oss_file
;
2851 struct snd_pcm_substream
*substream
= NULL
;
2852 struct snd_pcm_runtime
*runtime
;
2856 pr_debug("pcm_oss: mmap begin\n");
2858 pcm_oss_file
= file
->private_data
;
2859 switch ((area
->vm_flags
& (VM_READ
| VM_WRITE
))) {
2860 case VM_READ
| VM_WRITE
:
2861 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
2866 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
2869 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
2874 /* set VM_READ access as well to fix memset() routines that do
2875 reads before writes (to improve performance) */
2876 area
->vm_flags
|= VM_READ
;
2877 if (substream
== NULL
)
2879 runtime
= substream
->runtime
;
2880 if (!(runtime
->info
& SNDRV_PCM_INFO_MMAP_VALID
))
2882 if (runtime
->info
& SNDRV_PCM_INFO_INTERLEAVED
)
2883 runtime
->access
= SNDRV_PCM_ACCESS_MMAP_INTERLEAVED
;
2887 if (runtime
->oss
.params
) {
2888 /* use mutex_trylock() for params_lock for avoiding a deadlock
2889 * between mmap_sem and params_lock taken by
2890 * copy_from/to_user() in snd_pcm_oss_write/read()
2892 err
= snd_pcm_oss_change_params(substream
, true);
2896 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
2897 if (runtime
->oss
.plugin_first
!= NULL
)
2901 if (area
->vm_pgoff
!= 0)
2904 err
= snd_pcm_mmap_data(substream
, file
, area
);
2907 runtime
->oss
.mmap_bytes
= area
->vm_end
- area
->vm_start
;
2908 runtime
->silence_threshold
= 0;
2909 runtime
->silence_size
= 0;
2911 pr_debug("pcm_oss: mmap ok, bytes = 0x%x\n",
2912 runtime
->oss
.mmap_bytes
);
2914 /* In mmap mode we never stop */
2915 runtime
->stop_threshold
= runtime
->boundary
;
2920 #ifdef CONFIG_SND_VERBOSE_PROCFS
2925 static void snd_pcm_oss_proc_read(struct snd_info_entry
*entry
,
2926 struct snd_info_buffer
*buffer
)
2928 struct snd_pcm_str
*pstr
= entry
->private_data
;
2929 struct snd_pcm_oss_setup
*setup
= pstr
->oss
.setup_list
;
2930 mutex_lock(&pstr
->oss
.setup_mutex
);
2932 snd_iprintf(buffer
, "%s %u %u%s%s%s%s%s%s\n",
2936 setup
->disable
? " disable" : "",
2937 setup
->direct
? " direct" : "",
2938 setup
->block
? " block" : "",
2939 setup
->nonblock
? " non-block" : "",
2940 setup
->partialfrag
? " partial-frag" : "",
2941 setup
->nosilence
? " no-silence" : "");
2942 setup
= setup
->next
;
2944 mutex_unlock(&pstr
->oss
.setup_mutex
);
2947 static void snd_pcm_oss_proc_free_setup_list(struct snd_pcm_str
* pstr
)
2949 struct snd_pcm_oss_setup
*setup
, *setupn
;
2951 for (setup
= pstr
->oss
.setup_list
, pstr
->oss
.setup_list
= NULL
;
2952 setup
; setup
= setupn
) {
2953 setupn
= setup
->next
;
2954 kfree(setup
->task_name
);
2957 pstr
->oss
.setup_list
= NULL
;
2960 static void snd_pcm_oss_proc_write(struct snd_info_entry
*entry
,
2961 struct snd_info_buffer
*buffer
)
2963 struct snd_pcm_str
*pstr
= entry
->private_data
;
2964 char line
[128], str
[32], task_name
[32];
2967 struct snd_pcm_oss_setup
*setup
, *setup1
, template;
2969 while (!snd_info_get_line(buffer
, line
, sizeof(line
))) {
2970 mutex_lock(&pstr
->oss
.setup_mutex
);
2971 memset(&template, 0, sizeof(template));
2972 ptr
= snd_info_get_str(task_name
, line
, sizeof(task_name
));
2973 if (!strcmp(task_name
, "clear") || !strcmp(task_name
, "erase")) {
2974 snd_pcm_oss_proc_free_setup_list(pstr
);
2975 mutex_unlock(&pstr
->oss
.setup_mutex
);
2978 for (setup
= pstr
->oss
.setup_list
; setup
; setup
= setup
->next
) {
2979 if (!strcmp(setup
->task_name
, task_name
)) {
2984 ptr
= snd_info_get_str(str
, ptr
, sizeof(str
));
2985 template.periods
= simple_strtoul(str
, NULL
, 10);
2986 ptr
= snd_info_get_str(str
, ptr
, sizeof(str
));
2987 template.period_size
= simple_strtoul(str
, NULL
, 10);
2988 for (idx1
= 31; idx1
>= 0; idx1
--)
2989 if (template.period_size
& (1 << idx1
))
2991 for (idx1
--; idx1
>= 0; idx1
--)
2992 template.period_size
&= ~(1 << idx1
);
2994 ptr
= snd_info_get_str(str
, ptr
, sizeof(str
));
2995 if (!strcmp(str
, "disable")) {
2996 template.disable
= 1;
2997 } else if (!strcmp(str
, "direct")) {
2998 template.direct
= 1;
2999 } else if (!strcmp(str
, "block")) {
3001 } else if (!strcmp(str
, "non-block")) {
3002 template.nonblock
= 1;
3003 } else if (!strcmp(str
, "partial-frag")) {
3004 template.partialfrag
= 1;
3005 } else if (!strcmp(str
, "no-silence")) {
3006 template.nosilence
= 1;
3007 } else if (!strcmp(str
, "buggy-ptr")) {
3008 template.buggyptr
= 1;
3011 if (setup
== NULL
) {
3012 setup
= kmalloc(sizeof(*setup
), GFP_KERNEL
);
3014 buffer
->error
= -ENOMEM
;
3015 mutex_unlock(&pstr
->oss
.setup_mutex
);
3018 if (pstr
->oss
.setup_list
== NULL
)
3019 pstr
->oss
.setup_list
= setup
;
3021 for (setup1
= pstr
->oss
.setup_list
;
3022 setup1
->next
; setup1
= setup1
->next
);
3023 setup1
->next
= setup
;
3025 template.task_name
= kstrdup(task_name
, GFP_KERNEL
);
3026 if (! template.task_name
) {
3028 buffer
->error
= -ENOMEM
;
3029 mutex_unlock(&pstr
->oss
.setup_mutex
);
3034 mutex_unlock(&pstr
->oss
.setup_mutex
);
3038 static void snd_pcm_oss_proc_init(struct snd_pcm
*pcm
)
3041 for (stream
= 0; stream
< 2; ++stream
) {
3042 struct snd_info_entry
*entry
;
3043 struct snd_pcm_str
*pstr
= &pcm
->streams
[stream
];
3044 if (pstr
->substream_count
== 0)
3046 if ((entry
= snd_info_create_card_entry(pcm
->card
, "oss", pstr
->proc_root
)) != NULL
) {
3047 entry
->content
= SNDRV_INFO_CONTENT_TEXT
;
3048 entry
->mode
= S_IFREG
| 0644;
3049 entry
->c
.text
.read
= snd_pcm_oss_proc_read
;
3050 entry
->c
.text
.write
= snd_pcm_oss_proc_write
;
3051 entry
->private_data
= pstr
;
3052 if (snd_info_register(entry
) < 0) {
3053 snd_info_free_entry(entry
);
3057 pstr
->oss
.proc_entry
= entry
;
3061 static void snd_pcm_oss_proc_done(struct snd_pcm
*pcm
)
3064 for (stream
= 0; stream
< 2; ++stream
) {
3065 struct snd_pcm_str
*pstr
= &pcm
->streams
[stream
];
3066 snd_info_free_entry(pstr
->oss
.proc_entry
);
3067 pstr
->oss
.proc_entry
= NULL
;
3068 snd_pcm_oss_proc_free_setup_list(pstr
);
3071 #else /* !CONFIG_SND_VERBOSE_PROCFS */
3072 #define snd_pcm_oss_proc_init(pcm)
3073 #define snd_pcm_oss_proc_done(pcm)
3074 #endif /* CONFIG_SND_VERBOSE_PROCFS */
3080 static const struct file_operations snd_pcm_oss_f_reg
=
3082 .owner
= THIS_MODULE
,
3083 .read
= snd_pcm_oss_read
,
3084 .write
= snd_pcm_oss_write
,
3085 .open
= snd_pcm_oss_open
,
3086 .release
= snd_pcm_oss_release
,
3087 .llseek
= no_llseek
,
3088 .poll
= snd_pcm_oss_poll
,
3089 .unlocked_ioctl
= snd_pcm_oss_ioctl
,
3090 .compat_ioctl
= snd_pcm_oss_ioctl_compat
,
3091 .mmap
= snd_pcm_oss_mmap
,
3094 static void register_oss_dsp(struct snd_pcm
*pcm
, int index
)
3096 if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM
,
3097 pcm
->card
, index
, &snd_pcm_oss_f_reg
,
3099 pcm_err(pcm
, "unable to register OSS PCM device %i:%i\n",
3100 pcm
->card
->number
, pcm
->device
);
3104 static int snd_pcm_oss_register_minor(struct snd_pcm
*pcm
)
3107 if (dsp_map
[pcm
->card
->number
] == (int)pcm
->device
) {
3110 register_oss_dsp(pcm
, 0);
3111 duplex
= (pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream_count
> 0 &&
3112 pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream_count
&&
3113 !(pcm
->info_flags
& SNDRV_PCM_INFO_HALF_DUPLEX
));
3114 sprintf(name
, "%s%s", pcm
->name
, duplex
? " (DUPLEX)" : "");
3115 #ifdef SNDRV_OSS_INFO_DEV_AUDIO
3116 snd_oss_info_register(SNDRV_OSS_INFO_DEV_AUDIO
,
3121 pcm
->oss
.reg_mask
|= 1;
3123 if (adsp_map
[pcm
->card
->number
] == (int)pcm
->device
) {
3124 register_oss_dsp(pcm
, 1);
3126 pcm
->oss
.reg_mask
|= 2;
3130 snd_pcm_oss_proc_init(pcm
);
3135 static int snd_pcm_oss_disconnect_minor(struct snd_pcm
*pcm
)
3138 if (pcm
->oss
.reg_mask
& 1) {
3139 pcm
->oss
.reg_mask
&= ~1;
3140 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM
,
3143 if (pcm
->oss
.reg_mask
& 2) {
3144 pcm
->oss
.reg_mask
&= ~2;
3145 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM
,
3148 if (dsp_map
[pcm
->card
->number
] == (int)pcm
->device
) {
3149 #ifdef SNDRV_OSS_INFO_DEV_AUDIO
3150 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_AUDIO
, pcm
->card
->number
);
3158 static int snd_pcm_oss_unregister_minor(struct snd_pcm
*pcm
)
3160 snd_pcm_oss_disconnect_minor(pcm
);
3161 snd_pcm_oss_proc_done(pcm
);
3165 static struct snd_pcm_notify snd_pcm_oss_notify
=
3167 .n_register
= snd_pcm_oss_register_minor
,
3168 .n_disconnect
= snd_pcm_oss_disconnect_minor
,
3169 .n_unregister
= snd_pcm_oss_unregister_minor
,
3172 static int __init
alsa_pcm_oss_init(void)
3177 /* check device map table */
3178 for (i
= 0; i
< SNDRV_CARDS
; i
++) {
3179 if (dsp_map
[i
] < 0 || dsp_map
[i
] >= SNDRV_PCM_DEVICES
) {
3180 pr_err("ALSA: pcm_oss: invalid dsp_map[%d] = %d\n",
3184 if (adsp_map
[i
] < 0 || adsp_map
[i
] >= SNDRV_PCM_DEVICES
) {
3185 pr_err("ALSA: pcm_oss: invalid adsp_map[%d] = %d\n",
3190 if ((err
= snd_pcm_notify(&snd_pcm_oss_notify
, 0)) < 0)
3195 static void __exit
alsa_pcm_oss_exit(void)
3197 snd_pcm_notify(&snd_pcm_oss_notify
, 1);
3200 module_init(alsa_pcm_oss_init
)
3201 module_exit(alsa_pcm_oss_exit
)