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/time.h>
32 #include <linux/vmalloc.h>
33 #include <linux/module.h>
34 #include <linux/math64.h>
35 #include <linux/string.h>
36 #include <linux/compat.h>
37 #include <sound/core.h>
38 #include <sound/minors.h>
39 #include <sound/pcm.h>
40 #include <sound/pcm_params.h>
41 #include "pcm_plugin.h"
42 #include <sound/info.h>
43 #include <linux/soundcard.h>
44 #include <sound/initval.h>
45 #include <sound/mixer_oss.h>
47 #define OSS_ALSAEMULVER _SIOR ('M', 249, int)
49 static int dsp_map
[SNDRV_CARDS
];
50 static int adsp_map
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
-1)] = 1};
51 static bool nonblock_open
= 1;
53 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Abramo Bagnara <abramo@alsa-project.org>");
54 MODULE_DESCRIPTION("PCM OSS emulation for ALSA.");
55 MODULE_LICENSE("GPL");
56 module_param_array(dsp_map
, int, NULL
, 0444);
57 MODULE_PARM_DESC(dsp_map
, "PCM device number assigned to 1st OSS device.");
58 module_param_array(adsp_map
, int, NULL
, 0444);
59 MODULE_PARM_DESC(adsp_map
, "PCM device number assigned to 2nd OSS device.");
60 module_param(nonblock_open
, bool, 0644);
61 MODULE_PARM_DESC(nonblock_open
, "Don't block opening busy PCM devices.");
62 MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM
);
63 MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM1
);
65 static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file
*pcm_oss_file
);
66 static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file
*pcm_oss_file
);
67 static int snd_pcm_oss_get_format(struct snd_pcm_oss_file
*pcm_oss_file
);
69 static inline mm_segment_t
snd_enter_user(void)
71 mm_segment_t fs
= get_fs();
76 static inline void snd_leave_user(mm_segment_t fs
)
82 * helper functions to process hw_params
84 static int snd_interval_refine_min(struct snd_interval
*i
, unsigned int min
, int openmin
)
91 } else if (i
->min
== min
&& !i
->openmin
&& openmin
) {
101 if (snd_interval_checkempty(i
)) {
102 snd_interval_none(i
);
108 static int snd_interval_refine_max(struct snd_interval
*i
, unsigned int max
, int openmax
)
113 i
->openmax
= openmax
;
115 } else if (i
->max
== max
&& !i
->openmax
&& openmax
) {
125 if (snd_interval_checkempty(i
)) {
126 snd_interval_none(i
);
132 static int snd_interval_refine_set(struct snd_interval
*i
, unsigned int val
)
134 struct snd_interval t
;
137 t
.openmin
= t
.openmax
= 0;
139 return snd_interval_refine(i
, &t
);
143 * snd_pcm_hw_param_value_min
144 * @params: the hw_params instance
145 * @var: parameter to retrieve
146 * @dir: pointer to the direction (-1,0,1) or NULL
148 * Return the minimum value for field PAR.
151 snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params
*params
,
152 snd_pcm_hw_param_t var
, int *dir
)
154 if (hw_is_mask(var
)) {
157 return snd_mask_min(hw_param_mask_c(params
, var
));
159 if (hw_is_interval(var
)) {
160 const struct snd_interval
*i
= hw_param_interval_c(params
, var
);
163 return snd_interval_min(i
);
169 * snd_pcm_hw_param_value_max
170 * @params: the hw_params instance
171 * @var: parameter to retrieve
172 * @dir: pointer to the direction (-1,0,1) or NULL
174 * Return the maximum value for field PAR.
177 snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params
*params
,
178 snd_pcm_hw_param_t var
, int *dir
)
180 if (hw_is_mask(var
)) {
183 return snd_mask_max(hw_param_mask_c(params
, var
));
185 if (hw_is_interval(var
)) {
186 const struct snd_interval
*i
= hw_param_interval_c(params
, var
);
188 *dir
= - (int) i
->openmax
;
189 return snd_interval_max(i
);
194 static int _snd_pcm_hw_param_mask(struct snd_pcm_hw_params
*params
,
195 snd_pcm_hw_param_t var
,
196 const struct snd_mask
*val
)
199 changed
= snd_mask_refine(hw_param_mask(params
, var
), val
);
201 params
->cmask
|= 1 << var
;
202 params
->rmask
|= 1 << var
;
207 static int snd_pcm_hw_param_mask(struct snd_pcm_substream
*pcm
,
208 struct snd_pcm_hw_params
*params
,
209 snd_pcm_hw_param_t var
,
210 const struct snd_mask
*val
)
212 int changed
= _snd_pcm_hw_param_mask(params
, var
, val
);
216 int err
= snd_pcm_hw_refine(pcm
, params
);
223 static int _snd_pcm_hw_param_min(struct snd_pcm_hw_params
*params
,
224 snd_pcm_hw_param_t var
, unsigned int val
,
232 } else if (dir
< 0) {
240 changed
= snd_mask_refine_min(hw_param_mask(params
, var
),
242 else if (hw_is_interval(var
))
243 changed
= snd_interval_refine_min(hw_param_interval(params
, var
),
248 params
->cmask
|= 1 << var
;
249 params
->rmask
|= 1 << var
;
255 * snd_pcm_hw_param_min
257 * @params: the hw_params instance
258 * @var: parameter to retrieve
259 * @val: minimal value
260 * @dir: pointer to the direction (-1,0,1) or NULL
262 * Inside configuration space defined by PARAMS remove from PAR all
263 * values < VAL. Reduce configuration space accordingly.
264 * Return new minimum or -EINVAL if the configuration space is empty
266 static int snd_pcm_hw_param_min(struct snd_pcm_substream
*pcm
,
267 struct snd_pcm_hw_params
*params
,
268 snd_pcm_hw_param_t var
, unsigned int val
,
271 int changed
= _snd_pcm_hw_param_min(params
, var
, val
, dir
? *dir
: 0);
275 int err
= snd_pcm_hw_refine(pcm
, params
);
279 return snd_pcm_hw_param_value_min(params
, var
, dir
);
282 static int _snd_pcm_hw_param_max(struct snd_pcm_hw_params
*params
,
283 snd_pcm_hw_param_t var
, unsigned int val
,
291 } else if (dir
> 0) {
296 if (hw_is_mask(var
)) {
297 if (val
== 0 && open
) {
298 snd_mask_none(hw_param_mask(params
, var
));
301 changed
= snd_mask_refine_max(hw_param_mask(params
, var
),
303 } else if (hw_is_interval(var
))
304 changed
= snd_interval_refine_max(hw_param_interval(params
, var
),
309 params
->cmask
|= 1 << var
;
310 params
->rmask
|= 1 << var
;
316 * snd_pcm_hw_param_max
318 * @params: the hw_params instance
319 * @var: parameter to retrieve
320 * @val: maximal value
321 * @dir: pointer to the direction (-1,0,1) or NULL
323 * Inside configuration space defined by PARAMS remove from PAR all
324 * values >= VAL + 1. Reduce configuration space accordingly.
325 * Return new maximum or -EINVAL if the configuration space is empty
327 static int snd_pcm_hw_param_max(struct snd_pcm_substream
*pcm
,
328 struct snd_pcm_hw_params
*params
,
329 snd_pcm_hw_param_t var
, unsigned int val
,
332 int changed
= _snd_pcm_hw_param_max(params
, var
, val
, dir
? *dir
: 0);
336 int err
= snd_pcm_hw_refine(pcm
, params
);
340 return snd_pcm_hw_param_value_max(params
, var
, dir
);
343 static int boundary_sub(int a
, int adir
,
347 adir
= adir
< 0 ? -1 : (adir
> 0 ? 1 : 0);
348 bdir
= bdir
< 0 ? -1 : (bdir
> 0 ? 1 : 0);
353 } else if (*cdir
== 2) {
359 static int boundary_lt(unsigned int a
, int adir
,
360 unsigned int b
, int bdir
)
372 return a
< b
|| (a
== b
&& adir
< bdir
);
375 /* Return 1 if min is nearer to best than max */
376 static int boundary_nearer(int min
, int mindir
,
377 int best
, int bestdir
,
382 boundary_sub(best
, bestdir
, min
, mindir
, &dmin
, &dmindir
);
383 boundary_sub(max
, maxdir
, best
, bestdir
, &dmax
, &dmaxdir
);
384 return boundary_lt(dmin
, dmindir
, dmax
, dmaxdir
);
388 * snd_pcm_hw_param_near
390 * @params: the hw_params instance
391 * @var: parameter to retrieve
392 * @best: value to set
393 * @dir: pointer to the direction (-1,0,1) or NULL
395 * Inside configuration space defined by PARAMS set PAR to the available value
396 * nearest to VAL. Reduce configuration space accordingly.
397 * This function cannot be called for SNDRV_PCM_HW_PARAM_ACCESS,
398 * SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_SUBFORMAT.
399 * Return the value found.
401 static int snd_pcm_hw_param_near(struct snd_pcm_substream
*pcm
,
402 struct snd_pcm_hw_params
*params
,
403 snd_pcm_hw_param_t var
, unsigned int best
,
406 struct snd_pcm_hw_params
*save
= NULL
;
408 unsigned int saved_min
;
412 int valdir
= dir
? *dir
: 0;
417 mindir
= maxdir
= valdir
;
420 else if (maxdir
== 0)
426 save
= kmalloc(sizeof(*save
), GFP_KERNEL
);
431 min
= snd_pcm_hw_param_min(pcm
, params
, var
, min
, &mindir
);
433 struct snd_pcm_hw_params
*params1
;
436 if ((unsigned int)min
== saved_min
&& mindir
== valdir
)
438 params1
= kmalloc(sizeof(*params1
), GFP_KERNEL
);
439 if (params1
== NULL
) {
444 max
= snd_pcm_hw_param_max(pcm
, params1
, var
, max
, &maxdir
);
449 if (boundary_nearer(max
, maxdir
, best
, valdir
, min
, mindir
)) {
456 max
= snd_pcm_hw_param_max(pcm
, params
, var
, max
, &maxdir
);
466 v
= snd_pcm_hw_param_last(pcm
, params
, var
, dir
);
468 v
= snd_pcm_hw_param_first(pcm
, params
, var
, dir
);
473 static int _snd_pcm_hw_param_set(struct snd_pcm_hw_params
*params
,
474 snd_pcm_hw_param_t var
, unsigned int val
,
478 if (hw_is_mask(var
)) {
479 struct snd_mask
*m
= hw_param_mask(params
, var
);
480 if (val
== 0 && dir
< 0) {
488 changed
= snd_mask_refine_set(hw_param_mask(params
, var
), val
);
490 } else if (hw_is_interval(var
)) {
491 struct snd_interval
*i
= hw_param_interval(params
, var
);
492 if (val
== 0 && dir
< 0) {
494 snd_interval_none(i
);
496 changed
= snd_interval_refine_set(i
, val
);
498 struct snd_interval t
;
510 changed
= snd_interval_refine(i
, &t
);
515 params
->cmask
|= 1 << var
;
516 params
->rmask
|= 1 << var
;
522 * snd_pcm_hw_param_set
524 * @params: the hw_params instance
525 * @var: parameter to retrieve
527 * @dir: pointer to the direction (-1,0,1) or NULL
529 * Inside configuration space defined by PARAMS remove from PAR all
530 * values != VAL. Reduce configuration space accordingly.
531 * Return VAL or -EINVAL if the configuration space is empty
533 static int snd_pcm_hw_param_set(struct snd_pcm_substream
*pcm
,
534 struct snd_pcm_hw_params
*params
,
535 snd_pcm_hw_param_t var
, unsigned int val
,
538 int changed
= _snd_pcm_hw_param_set(params
, var
, val
, dir
);
542 int err
= snd_pcm_hw_refine(pcm
, params
);
546 return snd_pcm_hw_param_value(params
, var
, NULL
);
549 static int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params
*params
,
550 snd_pcm_hw_param_t var
)
553 changed
= snd_interval_setinteger(hw_param_interval(params
, var
));
555 params
->cmask
|= 1 << var
;
556 params
->rmask
|= 1 << var
;
565 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
566 static int snd_pcm_oss_plugin_clear(struct snd_pcm_substream
*substream
)
568 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
569 struct snd_pcm_plugin
*plugin
, *next
;
571 plugin
= runtime
->oss
.plugin_first
;
574 snd_pcm_plugin_free(plugin
);
577 runtime
->oss
.plugin_first
= runtime
->oss
.plugin_last
= NULL
;
581 static int snd_pcm_plugin_insert(struct snd_pcm_plugin
*plugin
)
583 struct snd_pcm_runtime
*runtime
= plugin
->plug
->runtime
;
584 plugin
->next
= runtime
->oss
.plugin_first
;
586 if (runtime
->oss
.plugin_first
) {
587 runtime
->oss
.plugin_first
->prev
= plugin
;
588 runtime
->oss
.plugin_first
= plugin
;
590 runtime
->oss
.plugin_last
=
591 runtime
->oss
.plugin_first
= plugin
;
596 int snd_pcm_plugin_append(struct snd_pcm_plugin
*plugin
)
598 struct snd_pcm_runtime
*runtime
= plugin
->plug
->runtime
;
600 plugin
->prev
= runtime
->oss
.plugin_last
;
601 if (runtime
->oss
.plugin_last
) {
602 runtime
->oss
.plugin_last
->next
= plugin
;
603 runtime
->oss
.plugin_last
= plugin
;
605 runtime
->oss
.plugin_last
=
606 runtime
->oss
.plugin_first
= plugin
;
610 #endif /* CONFIG_SND_PCM_OSS_PLUGINS */
612 static long snd_pcm_oss_bytes(struct snd_pcm_substream
*substream
, long frames
)
614 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
615 long buffer_size
= snd_pcm_lib_buffer_bytes(substream
);
616 long bytes
= frames_to_bytes(runtime
, frames
);
617 if (buffer_size
== runtime
->oss
.buffer_bytes
)
619 #if BITS_PER_LONG >= 64
620 return runtime
->oss
.buffer_bytes
* bytes
/ buffer_size
;
623 u64 bsize
= (u64
)runtime
->oss
.buffer_bytes
* (u64
)bytes
;
624 return div_u64(bsize
, buffer_size
);
629 static long snd_pcm_alsa_frames(struct snd_pcm_substream
*substream
, long bytes
)
631 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
632 long buffer_size
= snd_pcm_lib_buffer_bytes(substream
);
633 if (buffer_size
== runtime
->oss
.buffer_bytes
)
634 return bytes_to_frames(runtime
, bytes
);
635 return bytes_to_frames(runtime
, (buffer_size
* bytes
) / runtime
->oss
.buffer_bytes
);
639 snd_pcm_uframes_t
get_hw_ptr_period(struct snd_pcm_runtime
*runtime
)
641 return runtime
->hw_ptr_interrupt
;
644 /* define extended formats in the recent OSS versions (if any) */
646 #define AFMT_S32_LE 0x00001000
647 #define AFMT_S32_BE 0x00002000
648 #define AFMT_S24_LE 0x00008000
649 #define AFMT_S24_BE 0x00010000
650 #define AFMT_S24_PACKED 0x00040000
652 /* other supported formats */
653 #define AFMT_FLOAT 0x00004000
654 #define AFMT_SPDIF_RAW 0x00020000
656 /* unsupported formats */
657 #define AFMT_AC3 0x00000400
658 #define AFMT_VORBIS 0x00000800
660 static snd_pcm_format_t
snd_pcm_oss_format_from(int format
)
663 case AFMT_MU_LAW
: return SNDRV_PCM_FORMAT_MU_LAW
;
664 case AFMT_A_LAW
: return SNDRV_PCM_FORMAT_A_LAW
;
665 case AFMT_IMA_ADPCM
: return SNDRV_PCM_FORMAT_IMA_ADPCM
;
666 case AFMT_U8
: return SNDRV_PCM_FORMAT_U8
;
667 case AFMT_S16_LE
: return SNDRV_PCM_FORMAT_S16_LE
;
668 case AFMT_S16_BE
: return SNDRV_PCM_FORMAT_S16_BE
;
669 case AFMT_S8
: return SNDRV_PCM_FORMAT_S8
;
670 case AFMT_U16_LE
: return SNDRV_PCM_FORMAT_U16_LE
;
671 case AFMT_U16_BE
: return SNDRV_PCM_FORMAT_U16_BE
;
672 case AFMT_MPEG
: return SNDRV_PCM_FORMAT_MPEG
;
673 case AFMT_S32_LE
: return SNDRV_PCM_FORMAT_S32_LE
;
674 case AFMT_S32_BE
: return SNDRV_PCM_FORMAT_S32_BE
;
675 case AFMT_S24_LE
: return SNDRV_PCM_FORMAT_S24_LE
;
676 case AFMT_S24_BE
: return SNDRV_PCM_FORMAT_S24_BE
;
677 case AFMT_S24_PACKED
: return SNDRV_PCM_FORMAT_S24_3LE
;
678 case AFMT_FLOAT
: return SNDRV_PCM_FORMAT_FLOAT
;
679 case AFMT_SPDIF_RAW
: return SNDRV_PCM_FORMAT_IEC958_SUBFRAME
;
680 default: return SNDRV_PCM_FORMAT_U8
;
684 static int snd_pcm_oss_format_to(snd_pcm_format_t format
)
687 case SNDRV_PCM_FORMAT_MU_LAW
: return AFMT_MU_LAW
;
688 case SNDRV_PCM_FORMAT_A_LAW
: return AFMT_A_LAW
;
689 case SNDRV_PCM_FORMAT_IMA_ADPCM
: return AFMT_IMA_ADPCM
;
690 case SNDRV_PCM_FORMAT_U8
: return AFMT_U8
;
691 case SNDRV_PCM_FORMAT_S16_LE
: return AFMT_S16_LE
;
692 case SNDRV_PCM_FORMAT_S16_BE
: return AFMT_S16_BE
;
693 case SNDRV_PCM_FORMAT_S8
: return AFMT_S8
;
694 case SNDRV_PCM_FORMAT_U16_LE
: return AFMT_U16_LE
;
695 case SNDRV_PCM_FORMAT_U16_BE
: return AFMT_U16_BE
;
696 case SNDRV_PCM_FORMAT_MPEG
: return AFMT_MPEG
;
697 case SNDRV_PCM_FORMAT_S32_LE
: return AFMT_S32_LE
;
698 case SNDRV_PCM_FORMAT_S32_BE
: return AFMT_S32_BE
;
699 case SNDRV_PCM_FORMAT_S24_LE
: return AFMT_S24_LE
;
700 case SNDRV_PCM_FORMAT_S24_BE
: return AFMT_S24_BE
;
701 case SNDRV_PCM_FORMAT_S24_3LE
: return AFMT_S24_PACKED
;
702 case SNDRV_PCM_FORMAT_FLOAT
: return AFMT_FLOAT
;
703 case SNDRV_PCM_FORMAT_IEC958_SUBFRAME
: return AFMT_SPDIF_RAW
;
704 default: return -EINVAL
;
708 static int snd_pcm_oss_period_size(struct snd_pcm_substream
*substream
,
709 struct snd_pcm_hw_params
*oss_params
,
710 struct snd_pcm_hw_params
*slave_params
)
713 size_t oss_buffer_size
, oss_period_size
, oss_periods
;
714 size_t min_period_size
, max_period_size
;
715 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
716 size_t oss_frame_size
;
718 oss_frame_size
= snd_pcm_format_physical_width(params_format(oss_params
)) *
719 params_channels(oss_params
) / 8;
721 oss_buffer_size
= snd_pcm_plug_client_size(substream
,
722 snd_pcm_hw_param_value_max(slave_params
, SNDRV_PCM_HW_PARAM_BUFFER_SIZE
, NULL
)) * oss_frame_size
;
723 oss_buffer_size
= rounddown_pow_of_two(oss_buffer_size
);
724 if (atomic_read(&substream
->mmap_count
)) {
725 if (oss_buffer_size
> runtime
->oss
.mmap_bytes
)
726 oss_buffer_size
= runtime
->oss
.mmap_bytes
;
729 if (substream
->oss
.setup
.period_size
> 16)
730 oss_period_size
= substream
->oss
.setup
.period_size
;
731 else if (runtime
->oss
.fragshift
) {
732 oss_period_size
= 1 << runtime
->oss
.fragshift
;
733 if (oss_period_size
> oss_buffer_size
/ 2)
734 oss_period_size
= oss_buffer_size
/ 2;
737 size_t bytes_per_sec
= params_rate(oss_params
) * snd_pcm_format_physical_width(params_format(oss_params
)) * params_channels(oss_params
) / 8;
739 oss_period_size
= oss_buffer_size
;
741 oss_period_size
/= 2;
742 } while (oss_period_size
> bytes_per_sec
);
743 if (runtime
->oss
.subdivision
== 0) {
745 if (oss_period_size
/ sd
> 4096)
747 if (oss_period_size
/ sd
< 4096)
750 sd
= runtime
->oss
.subdivision
;
751 oss_period_size
/= sd
;
752 if (oss_period_size
< 16)
753 oss_period_size
= 16;
756 min_period_size
= snd_pcm_plug_client_size(substream
,
757 snd_pcm_hw_param_value_min(slave_params
, SNDRV_PCM_HW_PARAM_PERIOD_SIZE
, NULL
));
758 min_period_size
*= oss_frame_size
;
759 min_period_size
= roundup_pow_of_two(min_period_size
);
760 if (oss_period_size
< min_period_size
)
761 oss_period_size
= min_period_size
;
763 max_period_size
= snd_pcm_plug_client_size(substream
,
764 snd_pcm_hw_param_value_max(slave_params
, SNDRV_PCM_HW_PARAM_PERIOD_SIZE
, NULL
));
765 max_period_size
*= oss_frame_size
;
766 max_period_size
= rounddown_pow_of_two(max_period_size
);
767 if (oss_period_size
> max_period_size
)
768 oss_period_size
= max_period_size
;
770 oss_periods
= oss_buffer_size
/ oss_period_size
;
772 if (substream
->oss
.setup
.periods
> 1)
773 oss_periods
= substream
->oss
.setup
.periods
;
775 s
= snd_pcm_hw_param_value_max(slave_params
, SNDRV_PCM_HW_PARAM_PERIODS
, NULL
);
776 if (runtime
->oss
.maxfrags
&& s
> runtime
->oss
.maxfrags
)
777 s
= runtime
->oss
.maxfrags
;
781 s
= snd_pcm_hw_param_value_min(slave_params
, SNDRV_PCM_HW_PARAM_PERIODS
, NULL
);
787 while (oss_period_size
* oss_periods
> oss_buffer_size
)
788 oss_period_size
/= 2;
790 if (oss_period_size
< 16)
792 runtime
->oss
.period_bytes
= oss_period_size
;
793 runtime
->oss
.period_frames
= 1;
794 runtime
->oss
.periods
= oss_periods
;
798 static int choose_rate(struct snd_pcm_substream
*substream
,
799 struct snd_pcm_hw_params
*params
, unsigned int best_rate
)
801 struct snd_interval
*it
;
802 struct snd_pcm_hw_params
*save
;
803 unsigned int rate
, prev
;
805 save
= kmalloc(sizeof(*save
), GFP_KERNEL
);
809 it
= hw_param_interval(save
, SNDRV_PCM_HW_PARAM_RATE
);
811 /* try multiples of the best rate */
814 if (it
->max
< rate
|| (it
->max
== rate
&& it
->openmax
))
816 if (it
->min
< rate
|| (it
->min
== rate
&& !it
->openmin
)) {
818 ret
= snd_pcm_hw_param_set(substream
, params
,
819 SNDRV_PCM_HW_PARAM_RATE
,
821 if (ret
== (int)rate
) {
833 /* not found, use the nearest rate */
835 return snd_pcm_hw_param_near(substream
, params
, SNDRV_PCM_HW_PARAM_RATE
, best_rate
, NULL
);
838 static int snd_pcm_oss_change_params(struct snd_pcm_substream
*substream
)
840 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
841 struct snd_pcm_hw_params
*params
, *sparams
;
842 struct snd_pcm_sw_params
*sw_params
;
843 ssize_t oss_buffer_size
, oss_period_size
;
844 size_t oss_frame_size
;
847 snd_pcm_format_t format
, sformat
;
849 struct snd_mask sformat_mask
;
850 struct snd_mask mask
;
852 if (mutex_lock_interruptible(&runtime
->oss
.params_lock
))
854 sw_params
= kzalloc(sizeof(*sw_params
), GFP_KERNEL
);
855 params
= kmalloc(sizeof(*params
), GFP_KERNEL
);
856 sparams
= kmalloc(sizeof(*sparams
), GFP_KERNEL
);
857 if (!sw_params
|| !params
|| !sparams
) {
862 if (atomic_read(&substream
->mmap_count
))
865 direct
= substream
->oss
.setup
.direct
;
867 _snd_pcm_hw_params_any(sparams
);
868 _snd_pcm_hw_param_setinteger(sparams
, SNDRV_PCM_HW_PARAM_PERIODS
);
869 _snd_pcm_hw_param_min(sparams
, SNDRV_PCM_HW_PARAM_PERIODS
, 2, 0);
870 snd_mask_none(&mask
);
871 if (atomic_read(&substream
->mmap_count
))
872 snd_mask_set(&mask
, (__force
int)SNDRV_PCM_ACCESS_MMAP_INTERLEAVED
);
874 snd_mask_set(&mask
, (__force
int)SNDRV_PCM_ACCESS_RW_INTERLEAVED
);
876 snd_mask_set(&mask
, (__force
int)SNDRV_PCM_ACCESS_RW_NONINTERLEAVED
);
878 err
= snd_pcm_hw_param_mask(substream
, sparams
, SNDRV_PCM_HW_PARAM_ACCESS
, &mask
);
880 pcm_dbg(substream
->pcm
, "No usable accesses\n");
884 choose_rate(substream
, sparams
, runtime
->oss
.rate
);
885 snd_pcm_hw_param_near(substream
, sparams
, SNDRV_PCM_HW_PARAM_CHANNELS
, runtime
->oss
.channels
, NULL
);
887 format
= snd_pcm_oss_format_from(runtime
->oss
.format
);
889 sformat_mask
= *hw_param_mask(sparams
, SNDRV_PCM_HW_PARAM_FORMAT
);
893 sformat
= snd_pcm_plug_slave_format(format
, &sformat_mask
);
895 if ((__force
int)sformat
< 0 ||
896 !snd_mask_test(&sformat_mask
, (__force
int)sformat
)) {
897 for (sformat
= (__force snd_pcm_format_t
)0;
898 (__force
int)sformat
<= (__force
int)SNDRV_PCM_FORMAT_LAST
;
899 sformat
= (__force snd_pcm_format_t
)((__force
int)sformat
+ 1)) {
900 if (snd_mask_test(&sformat_mask
, (__force
int)sformat
) &&
901 snd_pcm_oss_format_to(sformat
) >= 0)
904 if ((__force
int)sformat
> (__force
int)SNDRV_PCM_FORMAT_LAST
) {
905 pcm_dbg(substream
->pcm
, "Cannot find a format!!!\n");
910 err
= _snd_pcm_hw_param_set(sparams
, SNDRV_PCM_HW_PARAM_FORMAT
, (__force
int)sformat
, 0);
915 memcpy(params
, sparams
, sizeof(*params
));
917 _snd_pcm_hw_params_any(params
);
918 _snd_pcm_hw_param_set(params
, SNDRV_PCM_HW_PARAM_ACCESS
,
919 (__force
int)SNDRV_PCM_ACCESS_RW_INTERLEAVED
, 0);
920 _snd_pcm_hw_param_set(params
, SNDRV_PCM_HW_PARAM_FORMAT
,
921 (__force
int)snd_pcm_oss_format_from(runtime
->oss
.format
), 0);
922 _snd_pcm_hw_param_set(params
, SNDRV_PCM_HW_PARAM_CHANNELS
,
923 runtime
->oss
.channels
, 0);
924 _snd_pcm_hw_param_set(params
, SNDRV_PCM_HW_PARAM_RATE
,
925 runtime
->oss
.rate
, 0);
926 pdprintf("client: access = %i, format = %i, channels = %i, rate = %i\n",
927 params_access(params
), params_format(params
),
928 params_channels(params
), params_rate(params
));
930 pdprintf("slave: access = %i, format = %i, channels = %i, rate = %i\n",
931 params_access(sparams
), params_format(sparams
),
932 params_channels(sparams
), params_rate(sparams
));
934 oss_frame_size
= snd_pcm_format_physical_width(params_format(params
)) *
935 params_channels(params
) / 8;
937 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
938 snd_pcm_oss_plugin_clear(substream
);
940 /* add necessary plugins */
941 snd_pcm_oss_plugin_clear(substream
);
942 if ((err
= snd_pcm_plug_format_plugins(substream
,
945 pcm_dbg(substream
->pcm
,
946 "snd_pcm_plug_format_plugins failed: %i\n", err
);
947 snd_pcm_oss_plugin_clear(substream
);
950 if (runtime
->oss
.plugin_first
) {
951 struct snd_pcm_plugin
*plugin
;
952 if ((err
= snd_pcm_plugin_build_io(substream
, sparams
, &plugin
)) < 0) {
953 pcm_dbg(substream
->pcm
,
954 "snd_pcm_plugin_build_io failed: %i\n", err
);
955 snd_pcm_oss_plugin_clear(substream
);
958 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
959 err
= snd_pcm_plugin_append(plugin
);
961 err
= snd_pcm_plugin_insert(plugin
);
964 snd_pcm_oss_plugin_clear(substream
);
971 err
= snd_pcm_oss_period_size(substream
, params
, sparams
);
975 n
= snd_pcm_plug_slave_size(substream
, runtime
->oss
.period_bytes
/ oss_frame_size
);
976 err
= snd_pcm_hw_param_near(substream
, sparams
, SNDRV_PCM_HW_PARAM_PERIOD_SIZE
, n
, NULL
);
980 err
= snd_pcm_hw_param_near(substream
, sparams
, SNDRV_PCM_HW_PARAM_PERIODS
,
981 runtime
->oss
.periods
, NULL
);
985 snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DROP
, NULL
);
987 if ((err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_HW_PARAMS
, sparams
)) < 0) {
988 pcm_dbg(substream
->pcm
, "HW_PARAMS failed: %i\n", err
);
992 if (runtime
->oss
.trigger
) {
993 sw_params
->start_threshold
= 1;
995 sw_params
->start_threshold
= runtime
->boundary
;
997 if (atomic_read(&substream
->mmap_count
) ||
998 substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
)
999 sw_params
->stop_threshold
= runtime
->boundary
;
1001 sw_params
->stop_threshold
= runtime
->buffer_size
;
1002 sw_params
->tstamp_mode
= SNDRV_PCM_TSTAMP_NONE
;
1003 sw_params
->period_step
= 1;
1004 sw_params
->avail_min
= substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
?
1005 1 : runtime
->period_size
;
1006 if (atomic_read(&substream
->mmap_count
) ||
1007 substream
->oss
.setup
.nosilence
) {
1008 sw_params
->silence_threshold
= 0;
1009 sw_params
->silence_size
= 0;
1011 snd_pcm_uframes_t frames
;
1012 frames
= runtime
->period_size
+ 16;
1013 if (frames
> runtime
->buffer_size
)
1014 frames
= runtime
->buffer_size
;
1015 sw_params
->silence_threshold
= frames
;
1016 sw_params
->silence_size
= frames
;
1019 if ((err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_SW_PARAMS
, sw_params
)) < 0) {
1020 pcm_dbg(substream
->pcm
, "SW_PARAMS failed: %i\n", err
);
1024 runtime
->oss
.periods
= params_periods(sparams
);
1025 oss_period_size
= snd_pcm_plug_client_size(substream
, params_period_size(sparams
));
1026 if (oss_period_size
< 0) {
1030 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
1031 if (runtime
->oss
.plugin_first
) {
1032 err
= snd_pcm_plug_alloc(substream
, oss_period_size
);
1037 oss_period_size
*= oss_frame_size
;
1039 oss_buffer_size
= oss_period_size
* runtime
->oss
.periods
;
1040 if (oss_buffer_size
< 0) {
1045 runtime
->oss
.period_bytes
= oss_period_size
;
1046 runtime
->oss
.buffer_bytes
= oss_buffer_size
;
1048 pdprintf("oss: period bytes = %i, buffer bytes = %i\n",
1049 runtime
->oss
.period_bytes
,
1050 runtime
->oss
.buffer_bytes
);
1051 pdprintf("slave: period_size = %i, buffer_size = %i\n",
1052 params_period_size(sparams
),
1053 params_buffer_size(sparams
));
1055 runtime
->oss
.format
= snd_pcm_oss_format_to(params_format(params
));
1056 runtime
->oss
.channels
= params_channels(params
);
1057 runtime
->oss
.rate
= params_rate(params
);
1059 vfree(runtime
->oss
.buffer
);
1060 runtime
->oss
.buffer
= vmalloc(runtime
->oss
.period_bytes
);
1061 if (!runtime
->oss
.buffer
) {
1066 runtime
->oss
.params
= 0;
1067 runtime
->oss
.prepare
= 1;
1068 runtime
->oss
.buffer_used
= 0;
1069 if (runtime
->dma_area
)
1070 snd_pcm_format_set_silence(runtime
->format
, runtime
->dma_area
, bytes_to_samples(runtime
, runtime
->dma_bytes
));
1072 runtime
->oss
.period_frames
= snd_pcm_alsa_frames(substream
, oss_period_size
);
1079 mutex_unlock(&runtime
->oss
.params_lock
);
1083 static int snd_pcm_oss_get_active_substream(struct snd_pcm_oss_file
*pcm_oss_file
, struct snd_pcm_substream
**r_substream
)
1086 struct snd_pcm_substream
*asubstream
= NULL
, *substream
;
1088 for (idx
= 0; idx
< 2; idx
++) {
1089 substream
= pcm_oss_file
->streams
[idx
];
1090 if (substream
== NULL
)
1092 if (asubstream
== NULL
)
1093 asubstream
= substream
;
1094 if (substream
->runtime
->oss
.params
) {
1095 err
= snd_pcm_oss_change_params(substream
);
1103 *r_substream
= asubstream
;
1107 static int snd_pcm_oss_prepare(struct snd_pcm_substream
*substream
)
1110 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1112 err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_PREPARE
, NULL
);
1114 pcm_dbg(substream
->pcm
,
1115 "snd_pcm_oss_prepare: SNDRV_PCM_IOCTL_PREPARE failed\n");
1118 runtime
->oss
.prepare
= 0;
1119 runtime
->oss
.prev_hw_ptr_period
= 0;
1120 runtime
->oss
.period_ptr
= 0;
1121 runtime
->oss
.buffer_used
= 0;
1126 static int snd_pcm_oss_make_ready(struct snd_pcm_substream
*substream
)
1128 struct snd_pcm_runtime
*runtime
;
1131 if (substream
== NULL
)
1133 runtime
= substream
->runtime
;
1134 if (runtime
->oss
.params
) {
1135 err
= snd_pcm_oss_change_params(substream
);
1139 if (runtime
->oss
.prepare
) {
1140 err
= snd_pcm_oss_prepare(substream
);
1147 static int snd_pcm_oss_capture_position_fixup(struct snd_pcm_substream
*substream
, snd_pcm_sframes_t
*delay
)
1149 struct snd_pcm_runtime
*runtime
;
1150 snd_pcm_uframes_t frames
;
1154 err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DELAY
, delay
);
1157 runtime
= substream
->runtime
;
1158 if (*delay
<= (snd_pcm_sframes_t
)runtime
->buffer_size
)
1160 /* in case of overrun, skip whole periods like OSS/Linux driver does */
1161 /* until avail(delay) <= buffer_size */
1162 frames
= (*delay
- runtime
->buffer_size
) + runtime
->period_size
- 1;
1163 frames
/= runtime
->period_size
;
1164 frames
*= runtime
->period_size
;
1165 err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_FORWARD
, &frames
);
1172 snd_pcm_sframes_t
snd_pcm_oss_write3(struct snd_pcm_substream
*substream
, const char *ptr
, snd_pcm_uframes_t frames
, int in_kernel
)
1174 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1177 if (runtime
->status
->state
== SNDRV_PCM_STATE_XRUN
||
1178 runtime
->status
->state
== SNDRV_PCM_STATE_SUSPENDED
) {
1180 pcm_dbg(substream
->pcm
,
1181 "pcm_oss: write: recovering from %s\n",
1182 runtime
->status
->state
== SNDRV_PCM_STATE_XRUN
?
1183 "XRUN" : "SUSPEND");
1185 ret
= snd_pcm_oss_prepare(substream
);
1191 fs
= snd_enter_user();
1192 ret
= snd_pcm_lib_write(substream
, (void __force __user
*)ptr
, frames
);
1195 ret
= snd_pcm_lib_write(substream
, (void __force __user
*)ptr
, frames
);
1197 if (ret
!= -EPIPE
&& ret
!= -ESTRPIPE
)
1199 /* test, if we can't store new data, because the stream */
1200 /* has not been started */
1201 if (runtime
->status
->state
== SNDRV_PCM_STATE_PREPARED
)
1207 snd_pcm_sframes_t
snd_pcm_oss_read3(struct snd_pcm_substream
*substream
, char *ptr
, snd_pcm_uframes_t frames
, int in_kernel
)
1209 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1210 snd_pcm_sframes_t delay
;
1213 if (runtime
->status
->state
== SNDRV_PCM_STATE_XRUN
||
1214 runtime
->status
->state
== SNDRV_PCM_STATE_SUSPENDED
) {
1216 pcm_dbg(substream
->pcm
,
1217 "pcm_oss: read: recovering from %s\n",
1218 runtime
->status
->state
== SNDRV_PCM_STATE_XRUN
?
1219 "XRUN" : "SUSPEND");
1221 ret
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DRAIN
, NULL
);
1224 } else if (runtime
->status
->state
== SNDRV_PCM_STATE_SETUP
) {
1225 ret
= snd_pcm_oss_prepare(substream
);
1229 ret
= snd_pcm_oss_capture_position_fixup(substream
, &delay
);
1234 fs
= snd_enter_user();
1235 ret
= snd_pcm_lib_read(substream
, (void __force __user
*)ptr
, frames
);
1238 ret
= snd_pcm_lib_read(substream
, (void __force __user
*)ptr
, frames
);
1240 if (ret
== -EPIPE
) {
1241 if (runtime
->status
->state
== SNDRV_PCM_STATE_DRAINING
) {
1242 ret
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DROP
, NULL
);
1248 if (ret
!= -ESTRPIPE
)
1254 snd_pcm_sframes_t
snd_pcm_oss_writev3(struct snd_pcm_substream
*substream
, void **bufs
, snd_pcm_uframes_t frames
, int in_kernel
)
1256 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1259 if (runtime
->status
->state
== SNDRV_PCM_STATE_XRUN
||
1260 runtime
->status
->state
== SNDRV_PCM_STATE_SUSPENDED
) {
1262 pcm_dbg(substream
->pcm
,
1263 "pcm_oss: writev: recovering from %s\n",
1264 runtime
->status
->state
== SNDRV_PCM_STATE_XRUN
?
1265 "XRUN" : "SUSPEND");
1267 ret
= snd_pcm_oss_prepare(substream
);
1273 fs
= snd_enter_user();
1274 ret
= snd_pcm_lib_writev(substream
, (void __user
**)bufs
, frames
);
1277 ret
= snd_pcm_lib_writev(substream
, (void __user
**)bufs
, frames
);
1279 if (ret
!= -EPIPE
&& ret
!= -ESTRPIPE
)
1282 /* test, if we can't store new data, because the stream */
1283 /* has not been started */
1284 if (runtime
->status
->state
== SNDRV_PCM_STATE_PREPARED
)
1290 snd_pcm_sframes_t
snd_pcm_oss_readv3(struct snd_pcm_substream
*substream
, void **bufs
, snd_pcm_uframes_t frames
, int in_kernel
)
1292 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1295 if (runtime
->status
->state
== SNDRV_PCM_STATE_XRUN
||
1296 runtime
->status
->state
== SNDRV_PCM_STATE_SUSPENDED
) {
1298 pcm_dbg(substream
->pcm
,
1299 "pcm_oss: readv: recovering from %s\n",
1300 runtime
->status
->state
== SNDRV_PCM_STATE_XRUN
?
1301 "XRUN" : "SUSPEND");
1303 ret
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DRAIN
, NULL
);
1306 } else if (runtime
->status
->state
== SNDRV_PCM_STATE_SETUP
) {
1307 ret
= snd_pcm_oss_prepare(substream
);
1313 fs
= snd_enter_user();
1314 ret
= snd_pcm_lib_readv(substream
, (void __user
**)bufs
, frames
);
1317 ret
= snd_pcm_lib_readv(substream
, (void __user
**)bufs
, frames
);
1319 if (ret
!= -EPIPE
&& ret
!= -ESTRPIPE
)
1325 static ssize_t
snd_pcm_oss_write2(struct snd_pcm_substream
*substream
, const char *buf
, size_t bytes
, int in_kernel
)
1327 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1328 snd_pcm_sframes_t frames
, frames1
;
1329 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
1330 if (runtime
->oss
.plugin_first
) {
1331 struct snd_pcm_plugin_channel
*channels
;
1332 size_t oss_frame_bytes
= (runtime
->oss
.plugin_first
->src_width
* runtime
->oss
.plugin_first
->src_format
.channels
) / 8;
1334 if (copy_from_user(runtime
->oss
.buffer
, (const char __force __user
*)buf
, bytes
))
1336 buf
= runtime
->oss
.buffer
;
1338 frames
= bytes
/ oss_frame_bytes
;
1339 frames1
= snd_pcm_plug_client_channels_buf(substream
, (char *)buf
, frames
, &channels
);
1342 frames1
= snd_pcm_plug_write_transfer(substream
, channels
, frames1
);
1345 bytes
= frames1
* oss_frame_bytes
;
1349 frames
= bytes_to_frames(runtime
, bytes
);
1350 frames1
= snd_pcm_oss_write3(substream
, buf
, frames
, in_kernel
);
1353 bytes
= frames_to_bytes(runtime
, frames1
);
1358 static ssize_t
snd_pcm_oss_write1(struct snd_pcm_substream
*substream
, const char __user
*buf
, size_t bytes
)
1362 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1364 if (atomic_read(&substream
->mmap_count
))
1367 if ((tmp
= snd_pcm_oss_make_ready(substream
)) < 0)
1369 mutex_lock(&runtime
->oss
.params_lock
);
1371 if (bytes
< runtime
->oss
.period_bytes
|| runtime
->oss
.buffer_used
> 0) {
1373 if (tmp
+ runtime
->oss
.buffer_used
> runtime
->oss
.period_bytes
)
1374 tmp
= runtime
->oss
.period_bytes
- runtime
->oss
.buffer_used
;
1376 if (copy_from_user(runtime
->oss
.buffer
+ runtime
->oss
.buffer_used
, buf
, tmp
)) {
1381 runtime
->oss
.buffer_used
+= tmp
;
1385 if (substream
->oss
.setup
.partialfrag
||
1386 runtime
->oss
.buffer_used
== runtime
->oss
.period_bytes
) {
1387 tmp
= snd_pcm_oss_write2(substream
, runtime
->oss
.buffer
+ runtime
->oss
.period_ptr
,
1388 runtime
->oss
.buffer_used
- runtime
->oss
.period_ptr
, 1);
1391 runtime
->oss
.bytes
+= tmp
;
1392 runtime
->oss
.period_ptr
+= tmp
;
1393 runtime
->oss
.period_ptr
%= runtime
->oss
.period_bytes
;
1394 if (runtime
->oss
.period_ptr
== 0 ||
1395 runtime
->oss
.period_ptr
== runtime
->oss
.buffer_used
)
1396 runtime
->oss
.buffer_used
= 0;
1397 else if ((substream
->f_flags
& O_NONBLOCK
) != 0) {
1403 tmp
= snd_pcm_oss_write2(substream
,
1404 (const char __force
*)buf
,
1405 runtime
->oss
.period_bytes
, 0);
1408 runtime
->oss
.bytes
+= tmp
;
1412 if ((substream
->f_flags
& O_NONBLOCK
) != 0 &&
1413 tmp
!= runtime
->oss
.period_bytes
)
1417 mutex_unlock(&runtime
->oss
.params_lock
);
1421 mutex_unlock(&runtime
->oss
.params_lock
);
1422 return xfer
> 0 ? (snd_pcm_sframes_t
)xfer
: tmp
;
1425 static ssize_t
snd_pcm_oss_read2(struct snd_pcm_substream
*substream
, char *buf
, size_t bytes
, int in_kernel
)
1427 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1428 snd_pcm_sframes_t frames
, frames1
;
1429 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
1430 char __user
*final_dst
= (char __force __user
*)buf
;
1431 if (runtime
->oss
.plugin_first
) {
1432 struct snd_pcm_plugin_channel
*channels
;
1433 size_t oss_frame_bytes
= (runtime
->oss
.plugin_last
->dst_width
* runtime
->oss
.plugin_last
->dst_format
.channels
) / 8;
1435 buf
= runtime
->oss
.buffer
;
1436 frames
= bytes
/ oss_frame_bytes
;
1437 frames1
= snd_pcm_plug_client_channels_buf(substream
, buf
, frames
, &channels
);
1440 frames1
= snd_pcm_plug_read_transfer(substream
, channels
, frames1
);
1443 bytes
= frames1
* oss_frame_bytes
;
1444 if (!in_kernel
&& copy_to_user(final_dst
, buf
, bytes
))
1449 frames
= bytes_to_frames(runtime
, bytes
);
1450 frames1
= snd_pcm_oss_read3(substream
, buf
, frames
, in_kernel
);
1453 bytes
= frames_to_bytes(runtime
, frames1
);
1458 static ssize_t
snd_pcm_oss_read1(struct snd_pcm_substream
*substream
, char __user
*buf
, size_t bytes
)
1462 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1464 if (atomic_read(&substream
->mmap_count
))
1467 if ((tmp
= snd_pcm_oss_make_ready(substream
)) < 0)
1469 mutex_lock(&runtime
->oss
.params_lock
);
1471 if (bytes
< runtime
->oss
.period_bytes
|| runtime
->oss
.buffer_used
> 0) {
1472 if (runtime
->oss
.buffer_used
== 0) {
1473 tmp
= snd_pcm_oss_read2(substream
, runtime
->oss
.buffer
, runtime
->oss
.period_bytes
, 1);
1476 runtime
->oss
.bytes
+= tmp
;
1477 runtime
->oss
.period_ptr
= tmp
;
1478 runtime
->oss
.buffer_used
= tmp
;
1481 if ((size_t) tmp
> runtime
->oss
.buffer_used
)
1482 tmp
= runtime
->oss
.buffer_used
;
1483 if (copy_to_user(buf
, runtime
->oss
.buffer
+ (runtime
->oss
.period_ptr
- runtime
->oss
.buffer_used
), tmp
)) {
1490 runtime
->oss
.buffer_used
-= tmp
;
1492 tmp
= snd_pcm_oss_read2(substream
, (char __force
*)buf
,
1493 runtime
->oss
.period_bytes
, 0);
1496 runtime
->oss
.bytes
+= tmp
;
1502 mutex_unlock(&runtime
->oss
.params_lock
);
1506 mutex_unlock(&runtime
->oss
.params_lock
);
1507 return xfer
> 0 ? (snd_pcm_sframes_t
)xfer
: tmp
;
1510 static int snd_pcm_oss_reset(struct snd_pcm_oss_file
*pcm_oss_file
)
1512 struct snd_pcm_substream
*substream
;
1513 struct snd_pcm_runtime
*runtime
;
1516 for (i
= 0; i
< 2; i
++) {
1517 substream
= pcm_oss_file
->streams
[i
];
1520 runtime
= substream
->runtime
;
1521 snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DROP
, NULL
);
1522 runtime
->oss
.prepare
= 1;
1523 runtime
->oss
.buffer_used
= 0;
1524 runtime
->oss
.prev_hw_ptr_period
= 0;
1525 runtime
->oss
.period_ptr
= 0;
1530 static int snd_pcm_oss_post(struct snd_pcm_oss_file
*pcm_oss_file
)
1532 struct snd_pcm_substream
*substream
;
1535 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
1536 if (substream
!= NULL
) {
1537 if ((err
= snd_pcm_oss_make_ready(substream
)) < 0)
1539 snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_START
, NULL
);
1541 /* note: all errors from the start action are ignored */
1542 /* OSS apps do not know, how to handle them */
1546 static int snd_pcm_oss_sync1(struct snd_pcm_substream
*substream
, size_t size
)
1548 struct snd_pcm_runtime
*runtime
;
1550 snd_pcm_state_t state
;
1554 runtime
= substream
->runtime
;
1555 init_waitqueue_entry(&wait
, current
);
1556 add_wait_queue(&runtime
->sleep
, &wait
);
1558 pcm_dbg(substream
->pcm
, "sync1: size = %li\n", size
);
1561 result
= snd_pcm_oss_write2(substream
, runtime
->oss
.buffer
, size
, 1);
1563 runtime
->oss
.buffer_used
= 0;
1567 if (result
!= 0 && result
!= -EAGAIN
)
1570 set_current_state(TASK_INTERRUPTIBLE
);
1571 snd_pcm_stream_lock_irq(substream
);
1572 state
= runtime
->status
->state
;
1573 snd_pcm_stream_unlock_irq(substream
);
1574 if (state
!= SNDRV_PCM_STATE_RUNNING
) {
1575 set_current_state(TASK_RUNNING
);
1578 res
= schedule_timeout(10 * HZ
);
1579 if (signal_pending(current
)) {
1580 result
= -ERESTARTSYS
;
1584 pcm_err(substream
->pcm
,
1585 "OSS sync error - DMA timeout\n");
1590 remove_wait_queue(&runtime
->sleep
, &wait
);
1594 static int snd_pcm_oss_sync(struct snd_pcm_oss_file
*pcm_oss_file
)
1597 unsigned int saved_f_flags
;
1598 struct snd_pcm_substream
*substream
;
1599 struct snd_pcm_runtime
*runtime
;
1600 snd_pcm_format_t format
;
1601 unsigned long width
;
1604 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
1605 if (substream
!= NULL
) {
1606 runtime
= substream
->runtime
;
1607 if (atomic_read(&substream
->mmap_count
))
1609 if ((err
= snd_pcm_oss_make_ready(substream
)) < 0)
1611 format
= snd_pcm_oss_format_from(runtime
->oss
.format
);
1612 width
= snd_pcm_format_physical_width(format
);
1613 mutex_lock(&runtime
->oss
.params_lock
);
1614 if (runtime
->oss
.buffer_used
> 0) {
1616 pcm_dbg(substream
->pcm
, "sync: buffer_used\n");
1618 size
= (8 * (runtime
->oss
.period_bytes
- runtime
->oss
.buffer_used
) + 7) / width
;
1619 snd_pcm_format_set_silence(format
,
1620 runtime
->oss
.buffer
+ runtime
->oss
.buffer_used
,
1622 err
= snd_pcm_oss_sync1(substream
, runtime
->oss
.period_bytes
);
1624 mutex_unlock(&runtime
->oss
.params_lock
);
1627 } else if (runtime
->oss
.period_ptr
> 0) {
1629 pcm_dbg(substream
->pcm
, "sync: period_ptr\n");
1631 size
= runtime
->oss
.period_bytes
- runtime
->oss
.period_ptr
;
1632 snd_pcm_format_set_silence(format
,
1633 runtime
->oss
.buffer
,
1635 err
= snd_pcm_oss_sync1(substream
, size
);
1637 mutex_unlock(&runtime
->oss
.params_lock
);
1642 * The ALSA's period might be a bit large than OSS one.
1643 * Fill the remain portion of ALSA period with zeros.
1645 size
= runtime
->control
->appl_ptr
% runtime
->period_size
;
1647 size
= runtime
->period_size
- size
;
1648 if (runtime
->access
== SNDRV_PCM_ACCESS_RW_INTERLEAVED
) {
1649 size
= (runtime
->frame_bits
* size
) / 8;
1652 size_t size1
= size
< runtime
->oss
.period_bytes
? size
: runtime
->oss
.period_bytes
;
1655 size1
/= runtime
->sample_bits
;
1656 snd_pcm_format_set_silence(runtime
->format
,
1657 runtime
->oss
.buffer
,
1659 size1
/= runtime
->channels
; /* frames */
1660 fs
= snd_enter_user();
1661 snd_pcm_lib_write(substream
, (void __force __user
*)runtime
->oss
.buffer
, size1
);
1664 } else if (runtime
->access
== SNDRV_PCM_ACCESS_RW_NONINTERLEAVED
) {
1665 void __user
*buffers
[runtime
->channels
];
1666 memset(buffers
, 0, runtime
->channels
* sizeof(void *));
1667 snd_pcm_lib_writev(substream
, buffers
, size
);
1670 mutex_unlock(&runtime
->oss
.params_lock
);
1672 * finish sync: drain the buffer
1675 saved_f_flags
= substream
->f_flags
;
1676 substream
->f_flags
&= ~O_NONBLOCK
;
1677 err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DRAIN
, NULL
);
1678 substream
->f_flags
= saved_f_flags
;
1681 runtime
->oss
.prepare
= 1;
1684 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
1685 if (substream
!= NULL
) {
1686 if ((err
= snd_pcm_oss_make_ready(substream
)) < 0)
1688 runtime
= substream
->runtime
;
1689 err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DROP
, NULL
);
1692 runtime
->oss
.buffer_used
= 0;
1693 runtime
->oss
.prepare
= 1;
1698 static int snd_pcm_oss_set_rate(struct snd_pcm_oss_file
*pcm_oss_file
, int rate
)
1702 for (idx
= 1; idx
>= 0; --idx
) {
1703 struct snd_pcm_substream
*substream
= pcm_oss_file
->streams
[idx
];
1704 struct snd_pcm_runtime
*runtime
;
1705 if (substream
== NULL
)
1707 runtime
= substream
->runtime
;
1710 else if (rate
> 192000)
1712 if (runtime
->oss
.rate
!= rate
) {
1713 runtime
->oss
.params
= 1;
1714 runtime
->oss
.rate
= rate
;
1717 return snd_pcm_oss_get_rate(pcm_oss_file
);
1720 static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file
*pcm_oss_file
)
1722 struct snd_pcm_substream
*substream
;
1725 if ((err
= snd_pcm_oss_get_active_substream(pcm_oss_file
, &substream
)) < 0)
1727 return substream
->runtime
->oss
.rate
;
1730 static int snd_pcm_oss_set_channels(struct snd_pcm_oss_file
*pcm_oss_file
, unsigned int channels
)
1737 for (idx
= 1; idx
>= 0; --idx
) {
1738 struct snd_pcm_substream
*substream
= pcm_oss_file
->streams
[idx
];
1739 struct snd_pcm_runtime
*runtime
;
1740 if (substream
== NULL
)
1742 runtime
= substream
->runtime
;
1743 if (runtime
->oss
.channels
!= channels
) {
1744 runtime
->oss
.params
= 1;
1745 runtime
->oss
.channels
= channels
;
1748 return snd_pcm_oss_get_channels(pcm_oss_file
);
1751 static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file
*pcm_oss_file
)
1753 struct snd_pcm_substream
*substream
;
1756 if ((err
= snd_pcm_oss_get_active_substream(pcm_oss_file
, &substream
)) < 0)
1758 return substream
->runtime
->oss
.channels
;
1761 static int snd_pcm_oss_get_block_size(struct snd_pcm_oss_file
*pcm_oss_file
)
1763 struct snd_pcm_substream
*substream
;
1766 if ((err
= snd_pcm_oss_get_active_substream(pcm_oss_file
, &substream
)) < 0)
1768 return substream
->runtime
->oss
.period_bytes
;
1771 static int snd_pcm_oss_get_formats(struct snd_pcm_oss_file
*pcm_oss_file
)
1773 struct snd_pcm_substream
*substream
;
1776 struct snd_pcm_hw_params
*params
;
1777 unsigned int formats
= 0;
1778 struct snd_mask format_mask
;
1781 if ((err
= snd_pcm_oss_get_active_substream(pcm_oss_file
, &substream
)) < 0)
1783 if (atomic_read(&substream
->mmap_count
))
1786 direct
= substream
->oss
.setup
.direct
;
1788 return AFMT_MU_LAW
| AFMT_U8
|
1789 AFMT_S16_LE
| AFMT_S16_BE
|
1790 AFMT_S8
| AFMT_U16_LE
|
1792 AFMT_S32_LE
| AFMT_S32_BE
|
1793 AFMT_S24_LE
| AFMT_S24_BE
|
1795 params
= kmalloc(sizeof(*params
), GFP_KERNEL
);
1798 _snd_pcm_hw_params_any(params
);
1799 err
= snd_pcm_hw_refine(substream
, params
);
1800 format_mask
= *hw_param_mask(params
, SNDRV_PCM_HW_PARAM_FORMAT
);
1804 for (fmt
= 0; fmt
< 32; ++fmt
) {
1805 if (snd_mask_test(&format_mask
, fmt
)) {
1806 int f
= snd_pcm_oss_format_to(fmt
);
1814 static int snd_pcm_oss_set_format(struct snd_pcm_oss_file
*pcm_oss_file
, int format
)
1818 if (format
!= AFMT_QUERY
) {
1819 formats
= snd_pcm_oss_get_formats(pcm_oss_file
);
1822 if (!(formats
& format
))
1824 for (idx
= 1; idx
>= 0; --idx
) {
1825 struct snd_pcm_substream
*substream
= pcm_oss_file
->streams
[idx
];
1826 struct snd_pcm_runtime
*runtime
;
1827 if (substream
== NULL
)
1829 runtime
= substream
->runtime
;
1830 if (runtime
->oss
.format
!= format
) {
1831 runtime
->oss
.params
= 1;
1832 runtime
->oss
.format
= format
;
1836 return snd_pcm_oss_get_format(pcm_oss_file
);
1839 static int snd_pcm_oss_get_format(struct snd_pcm_oss_file
*pcm_oss_file
)
1841 struct snd_pcm_substream
*substream
;
1844 if ((err
= snd_pcm_oss_get_active_substream(pcm_oss_file
, &substream
)) < 0)
1846 return substream
->runtime
->oss
.format
;
1849 static int snd_pcm_oss_set_subdivide1(struct snd_pcm_substream
*substream
, int subdivide
)
1851 struct snd_pcm_runtime
*runtime
;
1853 if (substream
== NULL
)
1855 runtime
= substream
->runtime
;
1856 if (subdivide
== 0) {
1857 subdivide
= runtime
->oss
.subdivision
;
1862 if (runtime
->oss
.subdivision
|| runtime
->oss
.fragshift
)
1864 if (subdivide
!= 1 && subdivide
!= 2 && subdivide
!= 4 &&
1865 subdivide
!= 8 && subdivide
!= 16)
1867 runtime
->oss
.subdivision
= subdivide
;
1868 runtime
->oss
.params
= 1;
1872 static int snd_pcm_oss_set_subdivide(struct snd_pcm_oss_file
*pcm_oss_file
, int subdivide
)
1874 int err
= -EINVAL
, idx
;
1876 for (idx
= 1; idx
>= 0; --idx
) {
1877 struct snd_pcm_substream
*substream
= pcm_oss_file
->streams
[idx
];
1878 if (substream
== NULL
)
1880 if ((err
= snd_pcm_oss_set_subdivide1(substream
, subdivide
)) < 0)
1886 static int snd_pcm_oss_set_fragment1(struct snd_pcm_substream
*substream
, unsigned int val
)
1888 struct snd_pcm_runtime
*runtime
;
1890 if (substream
== NULL
)
1892 runtime
= substream
->runtime
;
1893 if (runtime
->oss
.subdivision
|| runtime
->oss
.fragshift
)
1895 runtime
->oss
.fragshift
= val
& 0xffff;
1896 runtime
->oss
.maxfrags
= (val
>> 16) & 0xffff;
1897 if (runtime
->oss
.fragshift
< 4) /* < 16 */
1898 runtime
->oss
.fragshift
= 4;
1899 if (runtime
->oss
.maxfrags
< 2)
1900 runtime
->oss
.maxfrags
= 2;
1901 runtime
->oss
.params
= 1;
1905 static int snd_pcm_oss_set_fragment(struct snd_pcm_oss_file
*pcm_oss_file
, unsigned int val
)
1907 int err
= -EINVAL
, idx
;
1909 for (idx
= 1; idx
>= 0; --idx
) {
1910 struct snd_pcm_substream
*substream
= pcm_oss_file
->streams
[idx
];
1911 if (substream
== NULL
)
1913 if ((err
= snd_pcm_oss_set_fragment1(substream
, val
)) < 0)
1919 static int snd_pcm_oss_nonblock(struct file
* file
)
1921 spin_lock(&file
->f_lock
);
1922 file
->f_flags
|= O_NONBLOCK
;
1923 spin_unlock(&file
->f_lock
);
1927 static int snd_pcm_oss_get_caps1(struct snd_pcm_substream
*substream
, int res
)
1930 if (substream
== NULL
) {
1931 res
&= ~DSP_CAP_DUPLEX
;
1934 #ifdef DSP_CAP_MULTI
1935 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
1936 if (substream
->pstr
->substream_count
> 1)
1937 res
|= DSP_CAP_MULTI
;
1939 /* DSP_CAP_REALTIME is set all times: */
1940 /* all ALSA drivers can return actual pointer in ring buffer */
1941 #if defined(DSP_CAP_REALTIME) && 0
1943 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1944 if (runtime
->info
& (SNDRV_PCM_INFO_BLOCK_TRANSFER
|SNDRV_PCM_INFO_BATCH
))
1945 res
&= ~DSP_CAP_REALTIME
;
1951 static int snd_pcm_oss_get_caps(struct snd_pcm_oss_file
*pcm_oss_file
)
1955 result
= DSP_CAP_TRIGGER
| DSP_CAP_MMAP
| DSP_CAP_DUPLEX
| DSP_CAP_REALTIME
;
1956 for (idx
= 0; idx
< 2; idx
++) {
1957 struct snd_pcm_substream
*substream
= pcm_oss_file
->streams
[idx
];
1958 result
= snd_pcm_oss_get_caps1(substream
, result
);
1960 result
|= 0x0001; /* revision - same as SB AWE 64 */
1964 static void snd_pcm_oss_simulate_fill(struct snd_pcm_substream
*substream
,
1965 snd_pcm_uframes_t hw_ptr
)
1967 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1968 snd_pcm_uframes_t appl_ptr
;
1969 appl_ptr
= hw_ptr
+ runtime
->buffer_size
;
1970 appl_ptr
%= runtime
->boundary
;
1971 runtime
->control
->appl_ptr
= appl_ptr
;
1974 static int snd_pcm_oss_set_trigger(struct snd_pcm_oss_file
*pcm_oss_file
, int trigger
)
1976 struct snd_pcm_runtime
*runtime
;
1977 struct snd_pcm_substream
*psubstream
= NULL
, *csubstream
= NULL
;
1981 pcm_dbg(substream
->pcm
, "pcm_oss: trigger = 0x%x\n", trigger
);
1984 psubstream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
1985 csubstream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
1988 if ((err
= snd_pcm_oss_make_ready(psubstream
)) < 0)
1992 if ((err
= snd_pcm_oss_make_ready(csubstream
)) < 0)
1996 runtime
= psubstream
->runtime
;
1997 if (trigger
& PCM_ENABLE_OUTPUT
) {
1998 if (runtime
->oss
.trigger
)
2000 if (atomic_read(&psubstream
->mmap_count
))
2001 snd_pcm_oss_simulate_fill(psubstream
,
2002 get_hw_ptr_period(runtime
));
2003 runtime
->oss
.trigger
= 1;
2004 runtime
->start_threshold
= 1;
2005 cmd
= SNDRV_PCM_IOCTL_START
;
2007 if (!runtime
->oss
.trigger
)
2009 runtime
->oss
.trigger
= 0;
2010 runtime
->start_threshold
= runtime
->boundary
;
2011 cmd
= SNDRV_PCM_IOCTL_DROP
;
2012 runtime
->oss
.prepare
= 1;
2014 err
= snd_pcm_kernel_ioctl(psubstream
, cmd
, NULL
);
2020 runtime
= csubstream
->runtime
;
2021 if (trigger
& PCM_ENABLE_INPUT
) {
2022 if (runtime
->oss
.trigger
)
2024 runtime
->oss
.trigger
= 1;
2025 runtime
->start_threshold
= 1;
2026 cmd
= SNDRV_PCM_IOCTL_START
;
2028 if (!runtime
->oss
.trigger
)
2030 runtime
->oss
.trigger
= 0;
2031 runtime
->start_threshold
= runtime
->boundary
;
2032 cmd
= SNDRV_PCM_IOCTL_DROP
;
2033 runtime
->oss
.prepare
= 1;
2035 err
= snd_pcm_kernel_ioctl(csubstream
, cmd
, NULL
);
2043 static int snd_pcm_oss_get_trigger(struct snd_pcm_oss_file
*pcm_oss_file
)
2045 struct snd_pcm_substream
*psubstream
= NULL
, *csubstream
= NULL
;
2048 psubstream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
2049 csubstream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
2050 if (psubstream
&& psubstream
->runtime
&& psubstream
->runtime
->oss
.trigger
)
2051 result
|= PCM_ENABLE_OUTPUT
;
2052 if (csubstream
&& csubstream
->runtime
&& csubstream
->runtime
->oss
.trigger
)
2053 result
|= PCM_ENABLE_INPUT
;
2057 static int snd_pcm_oss_get_odelay(struct snd_pcm_oss_file
*pcm_oss_file
)
2059 struct snd_pcm_substream
*substream
;
2060 struct snd_pcm_runtime
*runtime
;
2061 snd_pcm_sframes_t delay
;
2064 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
2065 if (substream
== NULL
)
2067 if ((err
= snd_pcm_oss_make_ready(substream
)) < 0)
2069 runtime
= substream
->runtime
;
2070 if (runtime
->oss
.params
|| runtime
->oss
.prepare
)
2072 err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DELAY
, &delay
);
2074 delay
= 0; /* hack for broken OSS applications */
2077 return snd_pcm_oss_bytes(substream
, delay
);
2080 static int snd_pcm_oss_get_ptr(struct snd_pcm_oss_file
*pcm_oss_file
, int stream
, struct count_info __user
* _info
)
2082 struct snd_pcm_substream
*substream
;
2083 struct snd_pcm_runtime
*runtime
;
2084 snd_pcm_sframes_t delay
;
2086 struct count_info info
;
2091 substream
= pcm_oss_file
->streams
[stream
];
2092 if (substream
== NULL
)
2094 if ((err
= snd_pcm_oss_make_ready(substream
)) < 0)
2096 runtime
= substream
->runtime
;
2097 if (runtime
->oss
.params
|| runtime
->oss
.prepare
) {
2098 memset(&info
, 0, sizeof(info
));
2099 if (copy_to_user(_info
, &info
, sizeof(info
)))
2103 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
2104 err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DELAY
, &delay
);
2105 if (err
== -EPIPE
|| err
== -ESTRPIPE
|| (! err
&& delay
< 0)) {
2110 fixup
= runtime
->oss
.buffer_used
;
2113 err
= snd_pcm_oss_capture_position_fixup(substream
, &delay
);
2114 fixup
= -runtime
->oss
.buffer_used
;
2118 info
.ptr
= snd_pcm_oss_bytes(substream
, runtime
->status
->hw_ptr
% runtime
->buffer_size
);
2119 if (atomic_read(&substream
->mmap_count
)) {
2120 snd_pcm_sframes_t n
;
2121 delay
= get_hw_ptr_period(runtime
);
2122 n
= delay
- runtime
->oss
.prev_hw_ptr_period
;
2124 n
+= runtime
->boundary
;
2125 info
.blocks
= n
/ runtime
->period_size
;
2126 runtime
->oss
.prev_hw_ptr_period
= delay
;
2127 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
2128 snd_pcm_oss_simulate_fill(substream
, delay
);
2129 info
.bytes
= snd_pcm_oss_bytes(substream
, runtime
->status
->hw_ptr
) & INT_MAX
;
2131 delay
= snd_pcm_oss_bytes(substream
, delay
);
2132 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
2133 if (substream
->oss
.setup
.buggyptr
)
2134 info
.blocks
= (runtime
->oss
.buffer_bytes
- delay
- fixup
) / runtime
->oss
.period_bytes
;
2136 info
.blocks
= (delay
+ fixup
) / runtime
->oss
.period_bytes
;
2137 info
.bytes
= (runtime
->oss
.bytes
- delay
) & INT_MAX
;
2140 info
.blocks
= delay
/ runtime
->oss
.period_bytes
;
2141 info
.bytes
= (runtime
->oss
.bytes
+ delay
) & INT_MAX
;
2144 if (copy_to_user(_info
, &info
, sizeof(info
)))
2149 static int snd_pcm_oss_get_space(struct snd_pcm_oss_file
*pcm_oss_file
, int stream
, struct audio_buf_info __user
*_info
)
2151 struct snd_pcm_substream
*substream
;
2152 struct snd_pcm_runtime
*runtime
;
2153 snd_pcm_sframes_t avail
;
2155 struct audio_buf_info info
;
2160 substream
= pcm_oss_file
->streams
[stream
];
2161 if (substream
== NULL
)
2163 runtime
= substream
->runtime
;
2165 if (runtime
->oss
.params
&&
2166 (err
= snd_pcm_oss_change_params(substream
)) < 0)
2169 info
.fragsize
= runtime
->oss
.period_bytes
;
2170 info
.fragstotal
= runtime
->periods
;
2171 if (runtime
->oss
.prepare
) {
2172 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
2173 info
.bytes
= runtime
->oss
.period_bytes
* runtime
->oss
.periods
;
2174 info
.fragments
= runtime
->oss
.periods
;
2180 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
2181 err
= snd_pcm_kernel_ioctl(substream
, SNDRV_PCM_IOCTL_DELAY
, &avail
);
2182 if (err
== -EPIPE
|| err
== -ESTRPIPE
|| (! err
&& avail
< 0)) {
2183 avail
= runtime
->buffer_size
;
2187 avail
= runtime
->buffer_size
- avail
;
2188 fixup
= -runtime
->oss
.buffer_used
;
2191 err
= snd_pcm_oss_capture_position_fixup(substream
, &avail
);
2192 fixup
= runtime
->oss
.buffer_used
;
2196 info
.bytes
= snd_pcm_oss_bytes(substream
, avail
) + fixup
;
2197 info
.fragments
= info
.bytes
/ runtime
->oss
.period_bytes
;
2201 pcm_dbg(substream
->pcm
,
2202 "pcm_oss: space: bytes = %i, fragments = %i, fragstotal = %i, fragsize = %i\n",
2203 info
.bytes
, info
.fragments
, info
.fragstotal
, info
.fragsize
);
2205 if (copy_to_user(_info
, &info
, sizeof(info
)))
2210 static int snd_pcm_oss_get_mapbuf(struct snd_pcm_oss_file
*pcm_oss_file
, int stream
, struct buffmem_desc __user
* _info
)
2212 // it won't be probably implemented
2213 // pr_debug("TODO: snd_pcm_oss_get_mapbuf\n");
2217 static const char *strip_task_path(const char *path
)
2219 const char *ptr
, *ptrl
= NULL
;
2220 for (ptr
= path
; *ptr
; ptr
++) {
2227 static void snd_pcm_oss_look_for_setup(struct snd_pcm
*pcm
, int stream
,
2228 const char *task_name
,
2229 struct snd_pcm_oss_setup
*rsetup
)
2231 struct snd_pcm_oss_setup
*setup
;
2233 mutex_lock(&pcm
->streams
[stream
].oss
.setup_mutex
);
2235 for (setup
= pcm
->streams
[stream
].oss
.setup_list
; setup
;
2236 setup
= setup
->next
) {
2237 if (!strcmp(setup
->task_name
, task_name
))
2240 } while ((task_name
= strip_task_path(task_name
)) != NULL
);
2244 mutex_unlock(&pcm
->streams
[stream
].oss
.setup_mutex
);
2247 static void snd_pcm_oss_release_substream(struct snd_pcm_substream
*substream
)
2249 struct snd_pcm_runtime
*runtime
;
2250 runtime
= substream
->runtime
;
2251 vfree(runtime
->oss
.buffer
);
2252 runtime
->oss
.buffer
= NULL
;
2253 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
2254 snd_pcm_oss_plugin_clear(substream
);
2256 substream
->oss
.oss
= 0;
2259 static void snd_pcm_oss_init_substream(struct snd_pcm_substream
*substream
,
2260 struct snd_pcm_oss_setup
*setup
,
2263 struct snd_pcm_runtime
*runtime
;
2265 substream
->oss
.oss
= 1;
2266 substream
->oss
.setup
= *setup
;
2267 if (setup
->nonblock
)
2268 substream
->f_flags
|= O_NONBLOCK
;
2269 else if (setup
->block
)
2270 substream
->f_flags
&= ~O_NONBLOCK
;
2271 runtime
= substream
->runtime
;
2272 runtime
->oss
.params
= 1;
2273 runtime
->oss
.trigger
= 1;
2274 runtime
->oss
.rate
= 8000;
2275 mutex_init(&runtime
->oss
.params_lock
);
2276 switch (SNDRV_MINOR_OSS_DEVICE(minor
)) {
2277 case SNDRV_MINOR_OSS_PCM_8
:
2278 runtime
->oss
.format
= AFMT_U8
;
2280 case SNDRV_MINOR_OSS_PCM_16
:
2281 runtime
->oss
.format
= AFMT_S16_LE
;
2284 runtime
->oss
.format
= AFMT_MU_LAW
;
2286 runtime
->oss
.channels
= 1;
2287 runtime
->oss
.fragshift
= 0;
2288 runtime
->oss
.maxfrags
= 0;
2289 runtime
->oss
.subdivision
= 0;
2290 substream
->pcm_release
= snd_pcm_oss_release_substream
;
2293 static int snd_pcm_oss_release_file(struct snd_pcm_oss_file
*pcm_oss_file
)
2298 for (cidx
= 0; cidx
< 2; ++cidx
) {
2299 struct snd_pcm_substream
*substream
= pcm_oss_file
->streams
[cidx
];
2301 snd_pcm_release_substream(substream
);
2303 kfree(pcm_oss_file
);
2307 static int snd_pcm_oss_open_file(struct file
*file
,
2308 struct snd_pcm
*pcm
,
2309 struct snd_pcm_oss_file
**rpcm_oss_file
,
2311 struct snd_pcm_oss_setup
*setup
)
2314 struct snd_pcm_oss_file
*pcm_oss_file
;
2315 struct snd_pcm_substream
*substream
;
2316 fmode_t f_mode
= file
->f_mode
;
2319 *rpcm_oss_file
= NULL
;
2321 pcm_oss_file
= kzalloc(sizeof(*pcm_oss_file
), GFP_KERNEL
);
2322 if (pcm_oss_file
== NULL
)
2325 if ((f_mode
& (FMODE_WRITE
|FMODE_READ
)) == (FMODE_WRITE
|FMODE_READ
) &&
2326 (pcm
->info_flags
& SNDRV_PCM_INFO_HALF_DUPLEX
))
2327 f_mode
= FMODE_WRITE
;
2329 file
->f_flags
&= ~O_APPEND
;
2330 for (idx
= 0; idx
< 2; idx
++) {
2331 if (setup
[idx
].disable
)
2333 if (! pcm
->streams
[idx
].substream_count
)
2334 continue; /* no matching substream */
2335 if (idx
== SNDRV_PCM_STREAM_PLAYBACK
) {
2336 if (! (f_mode
& FMODE_WRITE
))
2339 if (! (f_mode
& FMODE_READ
))
2342 err
= snd_pcm_open_substream(pcm
, idx
, file
, &substream
);
2344 snd_pcm_oss_release_file(pcm_oss_file
);
2348 pcm_oss_file
->streams
[idx
] = substream
;
2349 substream
->file
= pcm_oss_file
;
2350 snd_pcm_oss_init_substream(substream
, &setup
[idx
], minor
);
2353 if (!pcm_oss_file
->streams
[0] && !pcm_oss_file
->streams
[1]) {
2354 snd_pcm_oss_release_file(pcm_oss_file
);
2358 file
->private_data
= pcm_oss_file
;
2360 *rpcm_oss_file
= pcm_oss_file
;
2365 static int snd_task_name(struct task_struct
*task
, char *name
, size_t size
)
2369 if (snd_BUG_ON(!task
|| !name
|| size
< 2))
2371 for (idx
= 0; idx
< sizeof(task
->comm
) && idx
+ 1 < size
; idx
++)
2372 name
[idx
] = task
->comm
[idx
];
2377 static int snd_pcm_oss_open(struct inode
*inode
, struct file
*file
)
2381 struct snd_pcm
*pcm
;
2382 struct snd_pcm_oss_file
*pcm_oss_file
;
2383 struct snd_pcm_oss_setup setup
[2];
2387 err
= nonseekable_open(inode
, file
);
2391 pcm
= snd_lookup_oss_minor_data(iminor(inode
),
2392 SNDRV_OSS_DEVICE_TYPE_PCM
);
2397 err
= snd_card_file_add(pcm
->card
, file
);
2400 if (!try_module_get(pcm
->card
->module
)) {
2404 if (snd_task_name(current
, task_name
, sizeof(task_name
)) < 0) {
2408 memset(setup
, 0, sizeof(setup
));
2409 if (file
->f_mode
& FMODE_WRITE
)
2410 snd_pcm_oss_look_for_setup(pcm
, SNDRV_PCM_STREAM_PLAYBACK
,
2411 task_name
, &setup
[0]);
2412 if (file
->f_mode
& FMODE_READ
)
2413 snd_pcm_oss_look_for_setup(pcm
, SNDRV_PCM_STREAM_CAPTURE
,
2414 task_name
, &setup
[1]);
2416 nonblock
= !!(file
->f_flags
& O_NONBLOCK
);
2418 nonblock
= nonblock_open
;
2420 init_waitqueue_entry(&wait
, current
);
2421 add_wait_queue(&pcm
->open_wait
, &wait
);
2422 mutex_lock(&pcm
->open_mutex
);
2424 err
= snd_pcm_oss_open_file(file
, pcm
, &pcm_oss_file
,
2425 iminor(inode
), setup
);
2428 if (err
== -EAGAIN
) {
2435 set_current_state(TASK_INTERRUPTIBLE
);
2436 mutex_unlock(&pcm
->open_mutex
);
2438 mutex_lock(&pcm
->open_mutex
);
2439 if (pcm
->card
->shutdown
) {
2443 if (signal_pending(current
)) {
2448 remove_wait_queue(&pcm
->open_wait
, &wait
);
2449 mutex_unlock(&pcm
->open_mutex
);
2452 snd_card_unref(pcm
->card
);
2456 module_put(pcm
->card
->module
);
2458 snd_card_file_remove(pcm
->card
, file
);
2461 snd_card_unref(pcm
->card
);
2465 static int snd_pcm_oss_release(struct inode
*inode
, struct file
*file
)
2467 struct snd_pcm
*pcm
;
2468 struct snd_pcm_substream
*substream
;
2469 struct snd_pcm_oss_file
*pcm_oss_file
;
2471 pcm_oss_file
= file
->private_data
;
2472 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
2473 if (substream
== NULL
)
2474 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
2475 if (snd_BUG_ON(!substream
))
2477 pcm
= substream
->pcm
;
2478 if (!pcm
->card
->shutdown
)
2479 snd_pcm_oss_sync(pcm_oss_file
);
2480 mutex_lock(&pcm
->open_mutex
);
2481 snd_pcm_oss_release_file(pcm_oss_file
);
2482 mutex_unlock(&pcm
->open_mutex
);
2483 wake_up(&pcm
->open_wait
);
2484 module_put(pcm
->card
->module
);
2485 snd_card_file_remove(pcm
->card
, file
);
2489 static long snd_pcm_oss_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
2491 struct snd_pcm_oss_file
*pcm_oss_file
;
2492 int __user
*p
= (int __user
*)arg
;
2495 pcm_oss_file
= file
->private_data
;
2496 if (cmd
== OSS_GETVERSION
)
2497 return put_user(SNDRV_OSS_VERSION
, p
);
2498 if (cmd
== OSS_ALSAEMULVER
)
2499 return put_user(1, p
);
2500 #if defined(CONFIG_SND_MIXER_OSS) || (defined(MODULE) && defined(CONFIG_SND_MIXER_OSS_MODULE))
2501 if (((cmd
>> 8) & 0xff) == 'M') { /* mixer ioctl - for OSS compatibility */
2502 struct snd_pcm_substream
*substream
;
2504 for (idx
= 0; idx
< 2; ++idx
) {
2505 substream
= pcm_oss_file
->streams
[idx
];
2506 if (substream
!= NULL
)
2509 if (snd_BUG_ON(idx
>= 2))
2511 return snd_mixer_oss_ioctl_card(substream
->pcm
->card
, cmd
, arg
);
2514 if (((cmd
>> 8) & 0xff) != 'P')
2517 pr_debug("pcm_oss: ioctl = 0x%x\n", cmd
);
2520 case SNDCTL_DSP_RESET
:
2521 return snd_pcm_oss_reset(pcm_oss_file
);
2522 case SNDCTL_DSP_SYNC
:
2523 return snd_pcm_oss_sync(pcm_oss_file
);
2524 case SNDCTL_DSP_SPEED
:
2525 if (get_user(res
, p
))
2527 if ((res
= snd_pcm_oss_set_rate(pcm_oss_file
, res
))<0)
2529 return put_user(res
, p
);
2530 case SOUND_PCM_READ_RATE
:
2531 res
= snd_pcm_oss_get_rate(pcm_oss_file
);
2534 return put_user(res
, p
);
2535 case SNDCTL_DSP_STEREO
:
2536 if (get_user(res
, p
))
2538 res
= res
> 0 ? 2 : 1;
2539 if ((res
= snd_pcm_oss_set_channels(pcm_oss_file
, res
)) < 0)
2541 return put_user(--res
, p
);
2542 case SNDCTL_DSP_GETBLKSIZE
:
2543 res
= snd_pcm_oss_get_block_size(pcm_oss_file
);
2546 return put_user(res
, p
);
2547 case SNDCTL_DSP_SETFMT
:
2548 if (get_user(res
, p
))
2550 res
= snd_pcm_oss_set_format(pcm_oss_file
, res
);
2553 return put_user(res
, p
);
2554 case SOUND_PCM_READ_BITS
:
2555 res
= snd_pcm_oss_get_format(pcm_oss_file
);
2558 return put_user(res
, p
);
2559 case SNDCTL_DSP_CHANNELS
:
2560 if (get_user(res
, p
))
2562 res
= snd_pcm_oss_set_channels(pcm_oss_file
, res
);
2565 return put_user(res
, p
);
2566 case SOUND_PCM_READ_CHANNELS
:
2567 res
= snd_pcm_oss_get_channels(pcm_oss_file
);
2570 return put_user(res
, p
);
2571 case SOUND_PCM_WRITE_FILTER
:
2572 case SOUND_PCM_READ_FILTER
:
2574 case SNDCTL_DSP_POST
:
2575 return snd_pcm_oss_post(pcm_oss_file
);
2576 case SNDCTL_DSP_SUBDIVIDE
:
2577 if (get_user(res
, p
))
2579 res
= snd_pcm_oss_set_subdivide(pcm_oss_file
, res
);
2582 return put_user(res
, p
);
2583 case SNDCTL_DSP_SETFRAGMENT
:
2584 if (get_user(res
, p
))
2586 return snd_pcm_oss_set_fragment(pcm_oss_file
, res
);
2587 case SNDCTL_DSP_GETFMTS
:
2588 res
= snd_pcm_oss_get_formats(pcm_oss_file
);
2591 return put_user(res
, p
);
2592 case SNDCTL_DSP_GETOSPACE
:
2593 case SNDCTL_DSP_GETISPACE
:
2594 return snd_pcm_oss_get_space(pcm_oss_file
,
2595 cmd
== SNDCTL_DSP_GETISPACE
?
2596 SNDRV_PCM_STREAM_CAPTURE
: SNDRV_PCM_STREAM_PLAYBACK
,
2597 (struct audio_buf_info __user
*) arg
);
2598 case SNDCTL_DSP_NONBLOCK
:
2599 return snd_pcm_oss_nonblock(file
);
2600 case SNDCTL_DSP_GETCAPS
:
2601 res
= snd_pcm_oss_get_caps(pcm_oss_file
);
2604 return put_user(res
, p
);
2605 case SNDCTL_DSP_GETTRIGGER
:
2606 res
= snd_pcm_oss_get_trigger(pcm_oss_file
);
2609 return put_user(res
, p
);
2610 case SNDCTL_DSP_SETTRIGGER
:
2611 if (get_user(res
, p
))
2613 return snd_pcm_oss_set_trigger(pcm_oss_file
, res
);
2614 case SNDCTL_DSP_GETIPTR
:
2615 case SNDCTL_DSP_GETOPTR
:
2616 return snd_pcm_oss_get_ptr(pcm_oss_file
,
2617 cmd
== SNDCTL_DSP_GETIPTR
?
2618 SNDRV_PCM_STREAM_CAPTURE
: SNDRV_PCM_STREAM_PLAYBACK
,
2619 (struct count_info __user
*) arg
);
2620 case SNDCTL_DSP_MAPINBUF
:
2621 case SNDCTL_DSP_MAPOUTBUF
:
2622 return snd_pcm_oss_get_mapbuf(pcm_oss_file
,
2623 cmd
== SNDCTL_DSP_MAPINBUF
?
2624 SNDRV_PCM_STREAM_CAPTURE
: SNDRV_PCM_STREAM_PLAYBACK
,
2625 (struct buffmem_desc __user
*) arg
);
2626 case SNDCTL_DSP_SETSYNCRO
:
2627 /* stop DMA now.. */
2629 case SNDCTL_DSP_SETDUPLEX
:
2630 if (snd_pcm_oss_get_caps(pcm_oss_file
) & DSP_CAP_DUPLEX
)
2633 case SNDCTL_DSP_GETODELAY
:
2634 res
= snd_pcm_oss_get_odelay(pcm_oss_file
);
2636 /* it's for sure, some broken apps don't check for error codes */
2640 return put_user(res
, p
);
2641 case SNDCTL_DSP_PROFILE
:
2642 return 0; /* silently ignore */
2644 pr_debug("pcm_oss: unknown command = 0x%x\n", cmd
);
2649 #ifdef CONFIG_COMPAT
2650 /* all compatible */
2651 static long snd_pcm_oss_ioctl_compat(struct file
*file
, unsigned int cmd
,
2654 return snd_pcm_oss_ioctl(file
, cmd
, (unsigned long)compat_ptr(arg
));
2657 #define snd_pcm_oss_ioctl_compat NULL
2660 static ssize_t
snd_pcm_oss_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*offset
)
2662 struct snd_pcm_oss_file
*pcm_oss_file
;
2663 struct snd_pcm_substream
*substream
;
2665 pcm_oss_file
= file
->private_data
;
2666 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
2667 if (substream
== NULL
)
2669 substream
->f_flags
= file
->f_flags
& O_NONBLOCK
;
2671 return snd_pcm_oss_read1(substream
, buf
, count
);
2674 ssize_t res
= snd_pcm_oss_read1(substream
, buf
, count
);
2675 pcm_dbg(substream
->pcm
,
2676 "pcm_oss: read %li bytes (returned %li bytes)\n",
2677 (long)count
, (long)res
);
2683 static ssize_t
snd_pcm_oss_write(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
*offset
)
2685 struct snd_pcm_oss_file
*pcm_oss_file
;
2686 struct snd_pcm_substream
*substream
;
2689 pcm_oss_file
= file
->private_data
;
2690 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
2691 if (substream
== NULL
)
2693 substream
->f_flags
= file
->f_flags
& O_NONBLOCK
;
2694 result
= snd_pcm_oss_write1(substream
, buf
, count
);
2696 pcm_dbg(substream
->pcm
, "pcm_oss: write %li bytes (wrote %li bytes)\n",
2697 (long)count
, (long)result
);
2702 static int snd_pcm_oss_playback_ready(struct snd_pcm_substream
*substream
)
2704 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
2705 if (atomic_read(&substream
->mmap_count
))
2706 return runtime
->oss
.prev_hw_ptr_period
!=
2707 get_hw_ptr_period(runtime
);
2709 return snd_pcm_playback_avail(runtime
) >=
2710 runtime
->oss
.period_frames
;
2713 static int snd_pcm_oss_capture_ready(struct snd_pcm_substream
*substream
)
2715 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
2716 if (atomic_read(&substream
->mmap_count
))
2717 return runtime
->oss
.prev_hw_ptr_period
!=
2718 get_hw_ptr_period(runtime
);
2720 return snd_pcm_capture_avail(runtime
) >=
2721 runtime
->oss
.period_frames
;
2724 static unsigned int snd_pcm_oss_poll(struct file
*file
, poll_table
* wait
)
2726 struct snd_pcm_oss_file
*pcm_oss_file
;
2728 struct snd_pcm_substream
*psubstream
= NULL
, *csubstream
= NULL
;
2730 pcm_oss_file
= file
->private_data
;
2732 psubstream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
2733 csubstream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
2736 if (psubstream
!= NULL
) {
2737 struct snd_pcm_runtime
*runtime
= psubstream
->runtime
;
2738 poll_wait(file
, &runtime
->sleep
, wait
);
2739 snd_pcm_stream_lock_irq(psubstream
);
2740 if (runtime
->status
->state
!= SNDRV_PCM_STATE_DRAINING
&&
2741 (runtime
->status
->state
!= SNDRV_PCM_STATE_RUNNING
||
2742 snd_pcm_oss_playback_ready(psubstream
)))
2743 mask
|= POLLOUT
| POLLWRNORM
;
2744 snd_pcm_stream_unlock_irq(psubstream
);
2746 if (csubstream
!= NULL
) {
2747 struct snd_pcm_runtime
*runtime
= csubstream
->runtime
;
2748 snd_pcm_state_t ostate
;
2749 poll_wait(file
, &runtime
->sleep
, wait
);
2750 snd_pcm_stream_lock_irq(csubstream
);
2751 if ((ostate
= runtime
->status
->state
) != SNDRV_PCM_STATE_RUNNING
||
2752 snd_pcm_oss_capture_ready(csubstream
))
2753 mask
|= POLLIN
| POLLRDNORM
;
2754 snd_pcm_stream_unlock_irq(csubstream
);
2755 if (ostate
!= SNDRV_PCM_STATE_RUNNING
&& runtime
->oss
.trigger
) {
2756 struct snd_pcm_oss_file ofile
;
2757 memset(&ofile
, 0, sizeof(ofile
));
2758 ofile
.streams
[SNDRV_PCM_STREAM_CAPTURE
] = pcm_oss_file
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
2759 runtime
->oss
.trigger
= 0;
2760 snd_pcm_oss_set_trigger(&ofile
, PCM_ENABLE_INPUT
);
2767 static int snd_pcm_oss_mmap(struct file
*file
, struct vm_area_struct
*area
)
2769 struct snd_pcm_oss_file
*pcm_oss_file
;
2770 struct snd_pcm_substream
*substream
= NULL
;
2771 struct snd_pcm_runtime
*runtime
;
2775 pr_debug("pcm_oss: mmap begin\n");
2777 pcm_oss_file
= file
->private_data
;
2778 switch ((area
->vm_flags
& (VM_READ
| VM_WRITE
))) {
2779 case VM_READ
| VM_WRITE
:
2780 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
2785 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
2788 substream
= pcm_oss_file
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
2793 /* set VM_READ access as well to fix memset() routines that do
2794 reads before writes (to improve performance) */
2795 area
->vm_flags
|= VM_READ
;
2796 if (substream
== NULL
)
2798 runtime
= substream
->runtime
;
2799 if (!(runtime
->info
& SNDRV_PCM_INFO_MMAP_VALID
))
2801 if (runtime
->info
& SNDRV_PCM_INFO_INTERLEAVED
)
2802 runtime
->access
= SNDRV_PCM_ACCESS_MMAP_INTERLEAVED
;
2806 if (runtime
->oss
.params
) {
2807 if ((err
= snd_pcm_oss_change_params(substream
)) < 0)
2810 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
2811 if (runtime
->oss
.plugin_first
!= NULL
)
2815 if (area
->vm_pgoff
!= 0)
2818 err
= snd_pcm_mmap_data(substream
, file
, area
);
2821 runtime
->oss
.mmap_bytes
= area
->vm_end
- area
->vm_start
;
2822 runtime
->silence_threshold
= 0;
2823 runtime
->silence_size
= 0;
2825 pr_debug("pcm_oss: mmap ok, bytes = 0x%x\n",
2826 runtime
->oss
.mmap_bytes
);
2828 /* In mmap mode we never stop */
2829 runtime
->stop_threshold
= runtime
->boundary
;
2834 #ifdef CONFIG_SND_VERBOSE_PROCFS
2839 static void snd_pcm_oss_proc_read(struct snd_info_entry
*entry
,
2840 struct snd_info_buffer
*buffer
)
2842 struct snd_pcm_str
*pstr
= entry
->private_data
;
2843 struct snd_pcm_oss_setup
*setup
= pstr
->oss
.setup_list
;
2844 mutex_lock(&pstr
->oss
.setup_mutex
);
2846 snd_iprintf(buffer
, "%s %u %u%s%s%s%s%s%s\n",
2850 setup
->disable
? " disable" : "",
2851 setup
->direct
? " direct" : "",
2852 setup
->block
? " block" : "",
2853 setup
->nonblock
? " non-block" : "",
2854 setup
->partialfrag
? " partial-frag" : "",
2855 setup
->nosilence
? " no-silence" : "");
2856 setup
= setup
->next
;
2858 mutex_unlock(&pstr
->oss
.setup_mutex
);
2861 static void snd_pcm_oss_proc_free_setup_list(struct snd_pcm_str
* pstr
)
2863 struct snd_pcm_oss_setup
*setup
, *setupn
;
2865 for (setup
= pstr
->oss
.setup_list
, pstr
->oss
.setup_list
= NULL
;
2866 setup
; setup
= setupn
) {
2867 setupn
= setup
->next
;
2868 kfree(setup
->task_name
);
2871 pstr
->oss
.setup_list
= NULL
;
2874 static void snd_pcm_oss_proc_write(struct snd_info_entry
*entry
,
2875 struct snd_info_buffer
*buffer
)
2877 struct snd_pcm_str
*pstr
= entry
->private_data
;
2878 char line
[128], str
[32], task_name
[32];
2881 struct snd_pcm_oss_setup
*setup
, *setup1
, template;
2883 while (!snd_info_get_line(buffer
, line
, sizeof(line
))) {
2884 mutex_lock(&pstr
->oss
.setup_mutex
);
2885 memset(&template, 0, sizeof(template));
2886 ptr
= snd_info_get_str(task_name
, line
, sizeof(task_name
));
2887 if (!strcmp(task_name
, "clear") || !strcmp(task_name
, "erase")) {
2888 snd_pcm_oss_proc_free_setup_list(pstr
);
2889 mutex_unlock(&pstr
->oss
.setup_mutex
);
2892 for (setup
= pstr
->oss
.setup_list
; setup
; setup
= setup
->next
) {
2893 if (!strcmp(setup
->task_name
, task_name
)) {
2898 ptr
= snd_info_get_str(str
, ptr
, sizeof(str
));
2899 template.periods
= simple_strtoul(str
, NULL
, 10);
2900 ptr
= snd_info_get_str(str
, ptr
, sizeof(str
));
2901 template.period_size
= simple_strtoul(str
, NULL
, 10);
2902 for (idx1
= 31; idx1
>= 0; idx1
--)
2903 if (template.period_size
& (1 << idx1
))
2905 for (idx1
--; idx1
>= 0; idx1
--)
2906 template.period_size
&= ~(1 << idx1
);
2908 ptr
= snd_info_get_str(str
, ptr
, sizeof(str
));
2909 if (!strcmp(str
, "disable")) {
2910 template.disable
= 1;
2911 } else if (!strcmp(str
, "direct")) {
2912 template.direct
= 1;
2913 } else if (!strcmp(str
, "block")) {
2915 } else if (!strcmp(str
, "non-block")) {
2916 template.nonblock
= 1;
2917 } else if (!strcmp(str
, "partial-frag")) {
2918 template.partialfrag
= 1;
2919 } else if (!strcmp(str
, "no-silence")) {
2920 template.nosilence
= 1;
2921 } else if (!strcmp(str
, "buggy-ptr")) {
2922 template.buggyptr
= 1;
2925 if (setup
== NULL
) {
2926 setup
= kmalloc(sizeof(*setup
), GFP_KERNEL
);
2928 buffer
->error
= -ENOMEM
;
2929 mutex_unlock(&pstr
->oss
.setup_mutex
);
2932 if (pstr
->oss
.setup_list
== NULL
)
2933 pstr
->oss
.setup_list
= setup
;
2935 for (setup1
= pstr
->oss
.setup_list
;
2936 setup1
->next
; setup1
= setup1
->next
);
2937 setup1
->next
= setup
;
2939 template.task_name
= kstrdup(task_name
, GFP_KERNEL
);
2940 if (! template.task_name
) {
2942 buffer
->error
= -ENOMEM
;
2943 mutex_unlock(&pstr
->oss
.setup_mutex
);
2948 mutex_unlock(&pstr
->oss
.setup_mutex
);
2952 static void snd_pcm_oss_proc_init(struct snd_pcm
*pcm
)
2955 for (stream
= 0; stream
< 2; ++stream
) {
2956 struct snd_info_entry
*entry
;
2957 struct snd_pcm_str
*pstr
= &pcm
->streams
[stream
];
2958 if (pstr
->substream_count
== 0)
2960 if ((entry
= snd_info_create_card_entry(pcm
->card
, "oss", pstr
->proc_root
)) != NULL
) {
2961 entry
->content
= SNDRV_INFO_CONTENT_TEXT
;
2962 entry
->mode
= S_IFREG
| S_IRUGO
| S_IWUSR
;
2963 entry
->c
.text
.read
= snd_pcm_oss_proc_read
;
2964 entry
->c
.text
.write
= snd_pcm_oss_proc_write
;
2965 entry
->private_data
= pstr
;
2966 if (snd_info_register(entry
) < 0) {
2967 snd_info_free_entry(entry
);
2971 pstr
->oss
.proc_entry
= entry
;
2975 static void snd_pcm_oss_proc_done(struct snd_pcm
*pcm
)
2978 for (stream
= 0; stream
< 2; ++stream
) {
2979 struct snd_pcm_str
*pstr
= &pcm
->streams
[stream
];
2980 snd_info_free_entry(pstr
->oss
.proc_entry
);
2981 pstr
->oss
.proc_entry
= NULL
;
2982 snd_pcm_oss_proc_free_setup_list(pstr
);
2985 #else /* !CONFIG_SND_VERBOSE_PROCFS */
2986 #define snd_pcm_oss_proc_init(pcm)
2987 #define snd_pcm_oss_proc_done(pcm)
2988 #endif /* CONFIG_SND_VERBOSE_PROCFS */
2994 static const struct file_operations snd_pcm_oss_f_reg
=
2996 .owner
= THIS_MODULE
,
2997 .read
= snd_pcm_oss_read
,
2998 .write
= snd_pcm_oss_write
,
2999 .open
= snd_pcm_oss_open
,
3000 .release
= snd_pcm_oss_release
,
3001 .llseek
= no_llseek
,
3002 .poll
= snd_pcm_oss_poll
,
3003 .unlocked_ioctl
= snd_pcm_oss_ioctl
,
3004 .compat_ioctl
= snd_pcm_oss_ioctl_compat
,
3005 .mmap
= snd_pcm_oss_mmap
,
3008 static void register_oss_dsp(struct snd_pcm
*pcm
, int index
)
3010 if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM
,
3011 pcm
->card
, index
, &snd_pcm_oss_f_reg
,
3013 pcm_err(pcm
, "unable to register OSS PCM device %i:%i\n",
3014 pcm
->card
->number
, pcm
->device
);
3018 static int snd_pcm_oss_register_minor(struct snd_pcm
*pcm
)
3021 if (dsp_map
[pcm
->card
->number
] == (int)pcm
->device
) {
3024 register_oss_dsp(pcm
, 0);
3025 duplex
= (pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream_count
> 0 &&
3026 pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream_count
&&
3027 !(pcm
->info_flags
& SNDRV_PCM_INFO_HALF_DUPLEX
));
3028 sprintf(name
, "%s%s", pcm
->name
, duplex
? " (DUPLEX)" : "");
3029 #ifdef SNDRV_OSS_INFO_DEV_AUDIO
3030 snd_oss_info_register(SNDRV_OSS_INFO_DEV_AUDIO
,
3035 pcm
->oss
.reg_mask
|= 1;
3037 if (adsp_map
[pcm
->card
->number
] == (int)pcm
->device
) {
3038 register_oss_dsp(pcm
, 1);
3040 pcm
->oss
.reg_mask
|= 2;
3044 snd_pcm_oss_proc_init(pcm
);
3049 static int snd_pcm_oss_disconnect_minor(struct snd_pcm
*pcm
)
3052 if (pcm
->oss
.reg_mask
& 1) {
3053 pcm
->oss
.reg_mask
&= ~1;
3054 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM
,
3057 if (pcm
->oss
.reg_mask
& 2) {
3058 pcm
->oss
.reg_mask
&= ~2;
3059 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM
,
3062 if (dsp_map
[pcm
->card
->number
] == (int)pcm
->device
) {
3063 #ifdef SNDRV_OSS_INFO_DEV_AUDIO
3064 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_AUDIO
, pcm
->card
->number
);
3072 static int snd_pcm_oss_unregister_minor(struct snd_pcm
*pcm
)
3074 snd_pcm_oss_disconnect_minor(pcm
);
3075 snd_pcm_oss_proc_done(pcm
);
3079 static struct snd_pcm_notify snd_pcm_oss_notify
=
3081 .n_register
= snd_pcm_oss_register_minor
,
3082 .n_disconnect
= snd_pcm_oss_disconnect_minor
,
3083 .n_unregister
= snd_pcm_oss_unregister_minor
,
3086 static int __init
alsa_pcm_oss_init(void)
3091 /* check device map table */
3092 for (i
= 0; i
< SNDRV_CARDS
; i
++) {
3093 if (dsp_map
[i
] < 0 || dsp_map
[i
] >= SNDRV_PCM_DEVICES
) {
3094 pr_err("ALSA: pcm_oss: invalid dsp_map[%d] = %d\n",
3098 if (adsp_map
[i
] < 0 || adsp_map
[i
] >= SNDRV_PCM_DEVICES
) {
3099 pr_err("ALSA: pcm_oss: invalid adsp_map[%d] = %d\n",
3104 if ((err
= snd_pcm_notify(&snd_pcm_oss_notify
, 0)) < 0)
3109 static void __exit
alsa_pcm_oss_exit(void)
3111 snd_pcm_notify(&snd_pcm_oss_notify
, 1);
3114 module_init(alsa_pcm_oss_init
)
3115 module_exit(alsa_pcm_oss_exit
)