[ALSA] Move OSS-specific hw_params helper to snd-pcm-oss module

Move EXPORT_SYMBOL()s to places adjacent to functions/variables.
Also move OSS-specific hw_params helper functions to pcm_oss.c.

Signed-off-by: Takashi Iwai <tiwai@suse.de>

diff --git a/include/sound/pcm.h b/include/sound/pcm.h
index 373425895faa30bd27db93d8d24e40209bcd4ed4..998bacefc8f81734aeabc64e180d237a894ee6d9 100644 (file)
--- a/include/sound/pcm.h
+++ b/include/sound/pcm.h
@@ -825,14 +825,6 @@ int snd_interval_ratnum(struct snd_interval *i,
 
 void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params);
 void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var);
-int snd_pcm_hw_param_near(struct snd_pcm_substream *substream, 
-                         struct snd_pcm_hw_params *params,
-                         snd_pcm_hw_param_t var, 
-                         unsigned int val, int *dir);
-int snd_pcm_hw_param_set(struct snd_pcm_substream *pcm,
-                        struct snd_pcm_hw_params *params,
-                        snd_pcm_hw_param_t var,
-                        unsigned int val, int dir);
 int snd_pcm_hw_params_choose(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params);
 
 int snd_pcm_hw_refine(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params);

diff --git a/include/sound/pcm_params.h b/include/sound/pcm_params.h
index e3bebd98e1cee11712384c543d970abdaa8ea33f..85cf1cf4f31a7a202e8e5faa91f992f3aa1a90ef 100644 (file)
--- a/include/sound/pcm_params.h
+++ b/include/sound/pcm_params.h
@@ -22,18 +22,14 @@
  *
  */
 
-extern int snd_pcm_hw_param_mask(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params,
-                                snd_pcm_hw_param_t var, const struct snd_mask *val);
-extern unsigned int snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params,
-                                              snd_pcm_hw_param_t var, int *dir);
-extern unsigned int snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params,
-                                              snd_pcm_hw_param_t var, int *dir);
-extern int _snd_pcm_hw_param_min(struct snd_pcm_hw_params *params,
-                                snd_pcm_hw_param_t var, unsigned int val, int dir);
-extern int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params *params,
-                                       snd_pcm_hw_param_t var);
-extern int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params,
-                                snd_pcm_hw_param_t var, unsigned int val, int dir);
+int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm, 
+                          struct snd_pcm_hw_params *params,
+                          snd_pcm_hw_param_t var, int *dir);
+int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm, 
+                         struct snd_pcm_hw_params *params,
+                         snd_pcm_hw_param_t var, int *dir);
+int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
+                          snd_pcm_hw_param_t var, int *dir);
 
 #define SNDRV_MASK_BITS        64      /* we use so far 64bits only */
 #define SNDRV_MASK_SIZE        (SNDRV_MASK_BITS / 32)

diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c
index ac990bf0b48f7ab11f5684d56b25fae795bd4d5e..0d2e232afe6c50ad64b268cd05abdb3affcfc0af 100644 (file)
--- a/sound/core/oss/pcm_oss.c
+++ b/sound/core/oss/pcm_oss.c
@@ -78,6 +78,487 @@ static inline void snd_leave_user(mm_segment_t fs)
        set_fs(fs);
 }
 
+/*
+ * helper functions to process hw_params
+ */
+static int snd_interval_refine_min(struct snd_interval *i, unsigned int min, int openmin)
+{
+       int changed = 0;
+       if (i->min < min) {
+               i->min = min;
+               i->openmin = openmin;
+               changed = 1;
+       } else if (i->min == min && !i->openmin && openmin) {
+               i->openmin = 1;
+               changed = 1;
+       }
+       if (i->integer) {
+               if (i->openmin) {
+                       i->min++;
+                       i->openmin = 0;
+               }
+       }
+       if (snd_interval_checkempty(i)) {
+               snd_interval_none(i);
+               return -EINVAL;
+       }
+       return changed;
+}
+
+static int snd_interval_refine_max(struct snd_interval *i, unsigned int max, int openmax)
+{
+       int changed = 0;
+       if (i->max > max) {
+               i->max = max;
+               i->openmax = openmax;
+               changed = 1;
+       } else if (i->max == max && !i->openmax && openmax) {
+               i->openmax = 1;
+               changed = 1;
+       }
+       if (i->integer) {
+               if (i->openmax) {
+                       i->max--;
+                       i->openmax = 0;
+               }
+       }
+       if (snd_interval_checkempty(i)) {
+               snd_interval_none(i);
+               return -EINVAL;
+       }
+       return changed;
+}
+
+static int snd_interval_refine_set(struct snd_interval *i, unsigned int val)
+{
+       struct snd_interval t;
+       t.empty = 0;
+       t.min = t.max = val;
+       t.openmin = t.openmax = 0;
+       t.integer = 1;
+       return snd_interval_refine(i, &t);
+}
+
+/**
+ * snd_pcm_hw_param_value_min
+ * @params: the hw_params instance
+ * @var: parameter to retrieve
+ * @dir: pointer to the direction (-1,0,1) or NULL
+ *
+ * Return the minimum value for field PAR.
+ */
+static unsigned int
+snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params,
+                          snd_pcm_hw_param_t var, int *dir)
+{
+       if (hw_is_mask(var)) {
+               if (dir)
+                       *dir = 0;
+               return snd_mask_min(hw_param_mask_c(params, var));
+       }
+       if (hw_is_interval(var)) {
+               const struct snd_interval *i = hw_param_interval_c(params, var);
+               if (dir)
+                       *dir = i->openmin;
+               return snd_interval_min(i);
+       }
+       return -EINVAL;
+}
+
+/**
+ * snd_pcm_hw_param_value_max
+ * @params: the hw_params instance
+ * @var: parameter to retrieve
+ * @dir: pointer to the direction (-1,0,1) or NULL
+ *
+ * Return the maximum value for field PAR.
+ */
+static unsigned int
+snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params,
+                          snd_pcm_hw_param_t var, int *dir)
+{
+       if (hw_is_mask(var)) {
+               if (dir)
+                       *dir = 0;
+               return snd_mask_max(hw_param_mask_c(params, var));
+       }
+       if (hw_is_interval(var)) {
+               const struct snd_interval *i = hw_param_interval_c(params, var);
+               if (dir)
+                       *dir = - (int) i->openmax;
+               return snd_interval_max(i);
+       }
+       return -EINVAL;
+}
+
+static int _snd_pcm_hw_param_mask(struct snd_pcm_hw_params *params,
+                                 snd_pcm_hw_param_t var,
+                                 const struct snd_mask *val)
+{
+       int changed;
+       changed = snd_mask_refine(hw_param_mask(params, var), val);
+       if (changed) {
+               params->cmask |= 1 << var;
+               params->rmask |= 1 << var;
+       }
+       return changed;
+}
+
+static int snd_pcm_hw_param_mask(struct snd_pcm_substream *pcm,
+                                struct snd_pcm_hw_params *params,
+                                snd_pcm_hw_param_t var,
+                                const struct snd_mask *val)
+{
+       int changed = _snd_pcm_hw_param_mask(params, var, val);
+       if (changed < 0)
+               return changed;
+       if (params->rmask) {
+               int err = snd_pcm_hw_refine(pcm, params);
+               if (err < 0)
+                       return err;
+       }
+       return 0;
+}
+
+static int _snd_pcm_hw_param_min(struct snd_pcm_hw_params *params,
+                                snd_pcm_hw_param_t var, unsigned int val,
+                                int dir)
+{
+       int changed;
+       int open = 0;
+       if (dir) {
+               if (dir > 0) {
+                       open = 1;
+               } else if (dir < 0) {
+                       if (val > 0) {
+                               open = 1;
+                               val--;
+                       }
+               }
+       }
+       if (hw_is_mask(var))
+               changed = snd_mask_refine_min(hw_param_mask(params, var),
+                                             val + !!open);
+       else if (hw_is_interval(var))
+               changed = snd_interval_refine_min(hw_param_interval(params, var),
+                                                 val, open);
+       else
+               return -EINVAL;
+       if (changed) {
+               params->cmask |= 1 << var;
+               params->rmask |= 1 << var;
+       }
+       return changed;
+}
+
+/**
+ * snd_pcm_hw_param_min
+ * @pcm: PCM instance
+ * @params: the hw_params instance
+ * @var: parameter to retrieve
+ * @val: minimal value
+ * @dir: pointer to the direction (-1,0,1) or NULL
+ *
+ * Inside configuration space defined by PARAMS remove from PAR all 
+ * values < VAL. Reduce configuration space accordingly.
+ * Return new minimum or -EINVAL if the configuration space is empty
+ */
+static int snd_pcm_hw_param_min(struct snd_pcm_substream *pcm,
+                               struct snd_pcm_hw_params *params,
+                               snd_pcm_hw_param_t var, unsigned int val,
+                               int *dir)
+{
+       int changed = _snd_pcm_hw_param_min(params, var, val, dir ? *dir : 0);
+       if (changed < 0)
+               return changed;
+       if (params->rmask) {
+               int err = snd_pcm_hw_refine(pcm, params);
+               if (err < 0)
+                       return err;
+       }
+       return snd_pcm_hw_param_value_min(params, var, dir);
+}
+
+static int _snd_pcm_hw_param_max(struct snd_pcm_hw_params *params,
+                                snd_pcm_hw_param_t var, unsigned int val,
+                                int dir)
+{
+       int changed;
+       int open = 0;
+       if (dir) {
+               if (dir < 0) {
+                       open = 1;
+               } else if (dir > 0) {
+                       open = 1;
+                       val++;
+               }
+       }
+       if (hw_is_mask(var)) {
+               if (val == 0 && open) {
+                       snd_mask_none(hw_param_mask(params, var));
+                       changed = -EINVAL;
+               } else
+                       changed = snd_mask_refine_max(hw_param_mask(params, var),
+                                                     val - !!open);
+       } else if (hw_is_interval(var))
+               changed = snd_interval_refine_max(hw_param_interval(params, var),
+                                                 val, open);
+       else
+               return -EINVAL;
+       if (changed) {
+               params->cmask |= 1 << var;
+               params->rmask |= 1 << var;
+       }
+       return changed;
+}
+
+/**
+ * snd_pcm_hw_param_max
+ * @pcm: PCM instance
+ * @params: the hw_params instance
+ * @var: parameter to retrieve
+ * @val: maximal value
+ * @dir: pointer to the direction (-1,0,1) or NULL
+ *
+ * Inside configuration space defined by PARAMS remove from PAR all 
+ *  values >= VAL + 1. Reduce configuration space accordingly.
+ *  Return new maximum or -EINVAL if the configuration space is empty
+ */
+static int snd_pcm_hw_param_max(struct snd_pcm_substream *pcm,
+                               struct snd_pcm_hw_params *params,
+                               snd_pcm_hw_param_t var, unsigned int val,
+                               int *dir)
+{
+       int changed = _snd_pcm_hw_param_max(params, var, val, dir ? *dir : 0);
+       if (changed < 0)
+               return changed;
+       if (params->rmask) {
+               int err = snd_pcm_hw_refine(pcm, params);
+               if (err < 0)
+                       return err;
+       }
+       return snd_pcm_hw_param_value_max(params, var, dir);
+}
+
+static int boundary_sub(int a, int adir,
+                       int b, int bdir,
+                       int *c, int *cdir)
+{
+       adir = adir < 0 ? -1 : (adir > 0 ? 1 : 0);
+       bdir = bdir < 0 ? -1 : (bdir > 0 ? 1 : 0);
+       *c = a - b;
+       *cdir = adir - bdir;
+       if (*cdir == -2) {
+               (*c)--;
+       } else if (*cdir == 2) {
+               (*c)++;
+       }
+       return 0;
+}
+
+static int boundary_lt(unsigned int a, int adir,
+                      unsigned int b, int bdir)
+{
+       if (adir < 0) {
+               a--;
+               adir = 1;
+       } else if (adir > 0)
+               adir = 1;
+       if (bdir < 0) {
+               b--;
+               bdir = 1;
+       } else if (bdir > 0)
+               bdir = 1;
+       return a < b || (a == b && adir < bdir);
+}
+
+/* Return 1 if min is nearer to best than max */
+static int boundary_nearer(int min, int mindir,
+                          int best, int bestdir,
+                          int max, int maxdir)
+{
+       int dmin, dmindir;
+       int dmax, dmaxdir;
+       boundary_sub(best, bestdir, min, mindir, &dmin, &dmindir);
+       boundary_sub(max, maxdir, best, bestdir, &dmax, &dmaxdir);
+       return boundary_lt(dmin, dmindir, dmax, dmaxdir);
+}
+
+/**
+ * snd_pcm_hw_param_near
+ * @pcm: PCM instance
+ * @params: the hw_params instance
+ * @var: parameter to retrieve
+ * @best: value to set
+ * @dir: pointer to the direction (-1,0,1) or NULL
+ *
+ * Inside configuration space defined by PARAMS set PAR to the available value
+ * nearest to VAL. Reduce configuration space accordingly.
+ * This function cannot be called for SNDRV_PCM_HW_PARAM_ACCESS,
+ * SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_SUBFORMAT.
+ * Return the value found.
+  */
+static int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm,
+                                struct snd_pcm_hw_params *params,
+                                snd_pcm_hw_param_t var, unsigned int best,
+                                int *dir)
+{
+       struct snd_pcm_hw_params *save = NULL;
+       int v;
+       unsigned int saved_min;
+       int last = 0;
+       int min, max;
+       int mindir, maxdir;
+       int valdir = dir ? *dir : 0;
+       /* FIXME */
+       if (best > INT_MAX)
+               best = INT_MAX;
+       min = max = best;
+       mindir = maxdir = valdir;
+       if (maxdir > 0)
+               maxdir = 0;
+       else if (maxdir == 0)
+               maxdir = -1;
+       else {
+               maxdir = 1;
+               max--;
+       }
+       save = kmalloc(sizeof(*save), GFP_KERNEL);
+       if (save == NULL)
+               return -ENOMEM;
+       *save = *params;
+       saved_min = min;
+       min = snd_pcm_hw_param_min(pcm, params, var, min, &mindir);
+       if (min >= 0) {
+               struct snd_pcm_hw_params *params1;
+               if (max < 0)
+                       goto _end;
+               if ((unsigned int)min == saved_min && mindir == valdir)
+                       goto _end;
+               params1 = kmalloc(sizeof(*params1), GFP_KERNEL);
+               if (params1 == NULL) {
+                       kfree(save);
+                       return -ENOMEM;
+               }
+               *params1 = *save;
+               max = snd_pcm_hw_param_max(pcm, params1, var, max, &maxdir);
+               if (max < 0) {
+                       kfree(params1);
+                       goto _end;
+               }
+               if (boundary_nearer(max, maxdir, best, valdir, min, mindir)) {
+                       *params = *params1;
+                       last = 1;
+               }
+               kfree(params1);
+       } else {
+               *params = *save;
+               max = snd_pcm_hw_param_max(pcm, params, var, max, &maxdir);
+               snd_assert(max >= 0, return -EINVAL);
+               last = 1;
+       }
+ _end:
+       kfree(save);
+       if (last)
+               v = snd_pcm_hw_param_last(pcm, params, var, dir);
+       else
+               v = snd_pcm_hw_param_first(pcm, params, var, dir);
+       snd_assert(v >= 0, return -EINVAL);
+       return v;
+}
+
+static int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params,
+                                snd_pcm_hw_param_t var, unsigned int val,
+                                int dir)
+{
+       int changed;
+       if (hw_is_mask(var)) {
+               struct snd_mask *m = hw_param_mask(params, var);
+               if (val == 0 && dir < 0) {
+                       changed = -EINVAL;
+                       snd_mask_none(m);
+               } else {
+                       if (dir > 0)
+                               val++;
+                       else if (dir < 0)
+                               val--;
+                       changed = snd_mask_refine_set(hw_param_mask(params, var), val);
+               }
+       } else if (hw_is_interval(var)) {
+               struct snd_interval *i = hw_param_interval(params, var);
+               if (val == 0 && dir < 0) {
+                       changed = -EINVAL;
+                       snd_interval_none(i);
+               } else if (dir == 0)
+                       changed = snd_interval_refine_set(i, val);
+               else {
+                       struct snd_interval t;
+                       t.openmin = 1;
+                       t.openmax = 1;
+                       t.empty = 0;
+                       t.integer = 0;
+                       if (dir < 0) {
+                               t.min = val - 1;
+                               t.max = val;
+                       } else {
+                               t.min = val;
+                               t.max = val+1;
+                       }
+                       changed = snd_interval_refine(i, &t);
+               }
+       } else
+               return -EINVAL;
+       if (changed) {
+               params->cmask |= 1 << var;
+               params->rmask |= 1 << var;
+       }
+       return changed;
+}
+
+/**
+ * snd_pcm_hw_param_set
+ * @pcm: PCM instance
+ * @params: the hw_params instance
+ * @var: parameter to retrieve
+ * @val: value to set
+ * @dir: pointer to the direction (-1,0,1) or NULL
+ *
+ * Inside configuration space defined by PARAMS remove from PAR all 
+ * values != VAL. Reduce configuration space accordingly.
+ *  Return VAL or -EINVAL if the configuration space is empty
+ */
+static int snd_pcm_hw_param_set(struct snd_pcm_substream *pcm,
+                               struct snd_pcm_hw_params *params,
+                               snd_pcm_hw_param_t var, unsigned int val,
+                               int dir)
+{
+       int changed = _snd_pcm_hw_param_set(params, var, val, dir);
+       if (changed < 0)
+               return changed;
+       if (params->rmask) {
+               int err = snd_pcm_hw_refine(pcm, params);
+               if (err < 0)
+                       return err;
+       }
+       return snd_pcm_hw_param_value(params, var, NULL);
+}
+
+static int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params *params,
+                                       snd_pcm_hw_param_t var)
+{
+       int changed;
+       changed = snd_interval_setinteger(hw_param_interval(params, var));
+       if (changed) {
+               params->cmask |= 1 << var;
+               params->rmask |= 1 << var;
+       }
+       return changed;
+}
+       
+/*
+ * plugin
+ */
+
 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
 static int snd_pcm_oss_plugin_clear(struct snd_pcm_substream *substream)
 {

diff --git a/sound/core/pcm.c b/sound/core/pcm.c
index 84b00038236d49504e9a73b34234d964f2dc73fa..8c15c01907f4b4c76d936be562a32de84675e079 100644 (file)
--- a/sound/core/pcm.c
+++ b/sound/core/pcm.c
@@ -671,6 +671,8 @@ int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
        return 0;
 }                              
 
+EXPORT_SYMBOL(snd_pcm_new_stream);
+
 /**
  * snd_pcm_new - create a new PCM instance
  * @card: the card instance
@@ -730,6 +732,8 @@ int snd_pcm_new(struct snd_card *card, char *id, int device,
        return 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_new);
+
 static void snd_pcm_free_stream(struct snd_pcm_str * pstr)
 {
        struct snd_pcm_substream *substream, *substream_next;
@@ -1022,6 +1026,8 @@ int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree)
        return 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_notify);
+
 #ifdef CONFIG_PROC_FS
 /*
  *  Info interface
@@ -1099,33 +1105,3 @@ static void __exit alsa_pcm_exit(void)
 
 module_init(alsa_pcm_init)
 module_exit(alsa_pcm_exit)
-
-EXPORT_SYMBOL(snd_pcm_new);
-EXPORT_SYMBOL(snd_pcm_new_stream);
-EXPORT_SYMBOL(snd_pcm_notify);
-EXPORT_SYMBOL(snd_pcm_open_substream);
-EXPORT_SYMBOL(snd_pcm_release_substream);
-  /* pcm_native.c */
-EXPORT_SYMBOL(snd_pcm_link_rwlock);
-#ifdef CONFIG_PM
-EXPORT_SYMBOL(snd_pcm_suspend);
-EXPORT_SYMBOL(snd_pcm_suspend_all);
-#endif
-EXPORT_SYMBOL(snd_pcm_kernel_ioctl);
-EXPORT_SYMBOL(snd_pcm_mmap_data);
-#if SNDRV_PCM_INFO_MMAP_IOMEM
-EXPORT_SYMBOL(snd_pcm_lib_mmap_iomem);
-#endif
- /* pcm_misc.c */
-EXPORT_SYMBOL(snd_pcm_format_signed);
-EXPORT_SYMBOL(snd_pcm_format_unsigned);
-EXPORT_SYMBOL(snd_pcm_format_linear);
-EXPORT_SYMBOL(snd_pcm_format_little_endian);
-EXPORT_SYMBOL(snd_pcm_format_big_endian);
-EXPORT_SYMBOL(snd_pcm_format_width);
-EXPORT_SYMBOL(snd_pcm_format_physical_width);
-EXPORT_SYMBOL(snd_pcm_format_size);
-EXPORT_SYMBOL(snd_pcm_format_silence_64);
-EXPORT_SYMBOL(snd_pcm_format_set_silence);
-EXPORT_SYMBOL(snd_pcm_build_linear_format);
-EXPORT_SYMBOL(snd_pcm_limit_hw_rates);

diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index eedc6cb038bb172e36c3643dbf7d77031fafc0b0..786f88145ee8d1f11b7f49bb7fc185dd91134543 100644 (file)
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -289,6 +289,7 @@ void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops
                substream->ops = ops;
 }
 
+EXPORT_SYMBOL(snd_pcm_set_ops);
 
 /**
  * snd_pcm_sync - set the PCM sync id
@@ -306,13 +307,12 @@ void snd_pcm_set_sync(struct snd_pcm_substream *substream)
        runtime->sync.id32[3] = -1;
 }
 
+EXPORT_SYMBOL(snd_pcm_set_sync);
+
 /*
  *  Standard ioctl routine
  */
 
-/* Code taken from alsa-lib */
-#define assert(a) snd_assert((a), return -EINVAL)
-
 static inline unsigned int div32(unsigned int a, unsigned int b, 
                                 unsigned int *r)
 {
@@ -369,56 +369,6 @@ static inline unsigned int muldiv32(unsigned int a, unsigned int b,
        return n;
 }
 
-static int snd_interval_refine_min(struct snd_interval *i, unsigned int min, int openmin)
-{
-       int changed = 0;
-       assert(!snd_interval_empty(i));
-       if (i->min < min) {
-               i->min = min;
-               i->openmin = openmin;
-               changed = 1;
-       } else if (i->min == min && !i->openmin && openmin) {
-               i->openmin = 1;
-               changed = 1;
-       }
-       if (i->integer) {
-               if (i->openmin) {
-                       i->min++;
-                       i->openmin = 0;
-               }
-       }
-       if (snd_interval_checkempty(i)) {
-               snd_interval_none(i);
-               return -EINVAL;
-       }
-       return changed;
-}
-
-static int snd_interval_refine_max(struct snd_interval *i, unsigned int max, int openmax)
-{
-       int changed = 0;
-       assert(!snd_interval_empty(i));
-       if (i->max > max) {
-               i->max = max;
-               i->openmax = openmax;
-               changed = 1;
-       } else if (i->max == max && !i->openmax && openmax) {
-               i->openmax = 1;
-               changed = 1;
-       }
-       if (i->integer) {
-               if (i->openmax) {
-                       i->max--;
-                       i->openmax = 0;
-               }
-       }
-       if (snd_interval_checkempty(i)) {
-               snd_interval_none(i);
-               return -EINVAL;
-       }
-       return changed;
-}
-
 /**
  * snd_interval_refine - refine the interval value of configurator
  * @i: the interval value to refine
@@ -433,7 +383,7 @@ static int snd_interval_refine_max(struct snd_interval *i, unsigned int max, int
 int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v)
 {
        int changed = 0;
-       assert(!snd_interval_empty(i));
+       snd_assert(!snd_interval_empty(i), return -EINVAL);
        if (i->min < v->min) {
                i->min = v->min;
                i->openmin = v->openmin;
@@ -472,9 +422,11 @@ int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v)
        return changed;
 }
 
+EXPORT_SYMBOL(snd_interval_refine);
+
 static int snd_interval_refine_first(struct snd_interval *i)
 {
-       assert(!snd_interval_empty(i));
+       snd_assert(!snd_interval_empty(i), return -EINVAL);
        if (snd_interval_single(i))
                return 0;
        i->max = i->min;
@@ -486,7 +438,7 @@ static int snd_interval_refine_first(struct snd_interval *i)
 
 static int snd_interval_refine_last(struct snd_interval *i)
 {
-       assert(!snd_interval_empty(i));
+       snd_assert(!snd_interval_empty(i), return -EINVAL);
        if (snd_interval_single(i))
                return 0;
        i->min = i->max;
@@ -496,16 +448,6 @@ static int snd_interval_refine_last(struct snd_interval *i)
        return 1;
 }
 
-static int snd_interval_refine_set(struct snd_interval *i, unsigned int val)
-{
-       struct snd_interval t;
-       t.empty = 0;
-       t.min = t.max = val;
-       t.openmin = t.openmax = 0;
-       t.integer = 1;
-       return snd_interval_refine(i, &t);
-}
-
 void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
 {
        if (a->empty || b->empty) {
@@ -621,7 +563,6 @@ void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,
        c->integer = 0;
 }
 
-#undef assert
 /* ---- */
 
 
@@ -727,6 +668,8 @@ int snd_interval_ratnum(struct snd_interval *i,
        return err;
 }
 
+EXPORT_SYMBOL(snd_interval_ratnum);
+
 /**
  * snd_interval_ratden - refine the interval value
  * @i: interval to refine
@@ -877,6 +820,8 @@ int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *
         return changed;
 }
 
+EXPORT_SYMBOL(snd_interval_list);
+
 static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned int step)
 {
        unsigned int n;
@@ -953,6 +898,8 @@ int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond,
        return 0;
 }                                  
 
+EXPORT_SYMBOL(snd_pcm_hw_rule_add);
+
 /**
  * snd_pcm_hw_constraint_mask
  * @runtime: PCM runtime instance
@@ -1007,6 +954,8 @@ int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_pa
        return snd_interval_setinteger(constrs_interval(constrs, var));
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_constraint_integer);
+
 /**
  * snd_pcm_hw_constraint_minmax
  * @runtime: PCM runtime instance
@@ -1028,6 +977,8 @@ int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_par
        return snd_interval_refine(constrs_interval(constrs, var), &t);
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_constraint_minmax);
+
 static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params,
                                struct snd_pcm_hw_rule *rule)
 {
@@ -1055,6 +1006,8 @@ int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,
                                   var, -1);
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_constraint_list);
+
 static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params,
                                   struct snd_pcm_hw_rule *rule)
 {
@@ -1087,6 +1040,8 @@ int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime,
                                   var, -1);
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_constraint_ratnums);
+
 static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params,
                                   struct snd_pcm_hw_rule *rule)
 {
@@ -1118,6 +1073,8 @@ int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime,
                                   var, -1);
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_constraint_ratdens);
+
 static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params,
                                  struct snd_pcm_hw_rule *rule)
 {
@@ -1149,6 +1106,8 @@ int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime,
                                    SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_constraint_msbits);
+
 static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params,
                                struct snd_pcm_hw_rule *rule)
 {
@@ -1173,6 +1132,8 @@ int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,
                                   var, -1);
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_constraint_step);
+
 static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
 {
        static int pow2_sizes[] = {
@@ -1200,6 +1161,8 @@ int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,
                                   var, -1);
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_constraint_pow2);
+
 /* To use the same code we have in alsa-lib */
 #define assert(i) snd_assert((i), return -EINVAL)
 #ifndef INT_MIN
@@ -1224,18 +1187,6 @@ static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params,
        snd_BUG();
 }
 
-#if 0
-/*
- * snd_pcm_hw_param_any
- */
-int snd_pcm_hw_param_any(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params,
-                        snd_pcm_hw_param_t var)
-{
-       _snd_pcm_hw_param_any(params, var);
-       return snd_pcm_hw_refine(pcm, params);
-}
-#endif  /*  0  */
-
 void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params)
 {
        unsigned int k;
@@ -1247,18 +1198,7 @@ void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params)
        params->info = ~0U;
 }
 
-#if 0
-/*
- * snd_pcm_hw_params_any
- *
- * Fill PARAMS with full configuration space boundaries
- */
-int snd_pcm_hw_params_any(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params)
-{
-       _snd_pcm_hw_params_any(params);
-       return snd_pcm_hw_refine(pcm, params);
-}
-#endif  /*  0  */
+EXPORT_SYMBOL(_snd_pcm_hw_params_any);
 
 /**
  * snd_pcm_hw_param_value
@@ -1269,8 +1209,8 @@ int snd_pcm_hw_params_any(struct snd_pcm_substream *pcm, struct snd_pcm_hw_param
  * Return the value for field PAR if it's fixed in configuration space 
  *  defined by PARAMS. Return -EINVAL otherwise
  */
-static int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
-                                 snd_pcm_hw_param_t var, int *dir)
+int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
+                          snd_pcm_hw_param_t var, int *dir)
 {
        if (hw_is_mask(var)) {
                const struct snd_mask *mask = hw_param_mask_c(params, var);
@@ -1292,57 +1232,7 @@ static int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
        return -EINVAL;
 }
 
-/**
- * snd_pcm_hw_param_value_min
- * @params: the hw_params instance
- * @var: parameter to retrieve
- * @dir: pointer to the direction (-1,0,1) or NULL
- *
- * Return the minimum value for field PAR.
- */
-unsigned int snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params,
-                                       snd_pcm_hw_param_t var, int *dir)
-{
-       if (hw_is_mask(var)) {
-               if (dir)
-                       *dir = 0;
-               return snd_mask_min(hw_param_mask_c(params, var));
-       }
-       if (hw_is_interval(var)) {
-               const struct snd_interval *i = hw_param_interval_c(params, var);
-               if (dir)
-                       *dir = i->openmin;
-               return snd_interval_min(i);
-       }
-       assert(0);
-       return -EINVAL;
-}
-
-/**
- * snd_pcm_hw_param_value_max
- * @params: the hw_params instance
- * @var: parameter to retrieve
- * @dir: pointer to the direction (-1,0,1) or NULL
- *
- * Return the maximum value for field PAR.
- */
-unsigned int snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params,
-                                       snd_pcm_hw_param_t var, int *dir)
-{
-       if (hw_is_mask(var)) {
-               if (dir)
-                       *dir = 0;
-               return snd_mask_max(hw_param_mask_c(params, var));
-       }
-       if (hw_is_interval(var)) {
-               const struct snd_interval *i = hw_param_interval_c(params, var);
-               if (dir)
-                       *dir = - (int) i->openmax;
-               return snd_interval_max(i);
-       }
-       assert(0);
-       return -EINVAL;
-}
+EXPORT_SYMBOL(snd_pcm_hw_param_value);
 
 void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params,
                                snd_pcm_hw_param_t var)
@@ -1360,42 +1250,7 @@ void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params,
        }
 }
 
-int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params *params,
-                                snd_pcm_hw_param_t var)
-{
-       int changed;
-       assert(hw_is_interval(var));
-       changed = snd_interval_setinteger(hw_param_interval(params, var));
-       if (changed) {
-               params->cmask |= 1 << var;
-               params->rmask |= 1 << var;
-       }
-       return changed;
-}
-       
-#if 0
-/*
- * snd_pcm_hw_param_setinteger
- *
- * Inside configuration space defined by PARAMS remove from PAR all 
- * non integer values. Reduce configuration space accordingly.
- * Return -EINVAL if the configuration space is empty
- */
-int snd_pcm_hw_param_setinteger(struct snd_pcm_substream *pcm, 
-                               struct snd_pcm_hw_params *params,
-                               snd_pcm_hw_param_t var)
-{
-       int changed = _snd_pcm_hw_param_setinteger(params, var);
-       if (changed < 0)
-               return changed;
-       if (params->rmask) {
-               int err = snd_pcm_hw_refine(pcm, params);
-               if (err < 0)
-                       return err;
-       }
-       return 0;
-}
-#endif  /*  0  */
+EXPORT_SYMBOL(_snd_pcm_hw_param_setempty);
 
 static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params,
                                   snd_pcm_hw_param_t var)
@@ -1428,9 +1283,9 @@ static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params,
  * values > minimum. Reduce configuration space accordingly.
  * Return the minimum.
  */
-static int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm, 
-                                 struct snd_pcm_hw_params *params, 
-                                 snd_pcm_hw_param_t var, int *dir)
+int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm, 
+                          struct snd_pcm_hw_params *params, 
+                          snd_pcm_hw_param_t var, int *dir)
 {
        int changed = _snd_pcm_hw_param_first(params, var);
        if (changed < 0)
@@ -1442,6 +1297,8 @@ static int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm,
        return snd_pcm_hw_param_value(params, var, dir);
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_param_first);
+
 static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params,
                                  snd_pcm_hw_param_t var)
 {
@@ -1473,9 +1330,9 @@ static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params,
  * values < maximum. Reduce configuration space accordingly.
  * Return the maximum.
  */
-static int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm, 
-                                struct snd_pcm_hw_params *params,
-                                snd_pcm_hw_param_t var, int *dir)
+int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm, 
+                         struct snd_pcm_hw_params *params,
+                         snd_pcm_hw_param_t var, int *dir)
 {
        int changed = _snd_pcm_hw_param_last(params, var);
        if (changed < 0)
@@ -1487,367 +1344,7 @@ static int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm,
        return snd_pcm_hw_param_value(params, var, dir);
 }
 
-int _snd_pcm_hw_param_min(struct snd_pcm_hw_params *params,
-                         snd_pcm_hw_param_t var, unsigned int val, int dir)
-{
-       int changed;
-       int open = 0;
-       if (dir) {
-               if (dir > 0) {
-                       open = 1;
-               } else if (dir < 0) {
-                       if (val > 0) {
-                               open = 1;
-                               val--;
-                       }
-               }
-       }
-       if (hw_is_mask(var))
-               changed = snd_mask_refine_min(hw_param_mask(params, var), val + !!open);
-       else if (hw_is_interval(var))
-               changed = snd_interval_refine_min(hw_param_interval(params, var), val, open);
-       else {
-               assert(0);
-               return -EINVAL;
-       }
-       if (changed) {
-               params->cmask |= 1 << var;
-               params->rmask |= 1 << var;
-       }
-       return changed;
-}
-
-/**
- * snd_pcm_hw_param_min
- * @pcm: PCM instance
- * @params: the hw_params instance
- * @var: parameter to retrieve
- * @val: minimal value
- * @dir: pointer to the direction (-1,0,1) or NULL
- *
- * Inside configuration space defined by PARAMS remove from PAR all 
- * values < VAL. Reduce configuration space accordingly.
- * Return new minimum or -EINVAL if the configuration space is empty
- */
-static int snd_pcm_hw_param_min(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params,
-                               snd_pcm_hw_param_t var, unsigned int val,
-                               int *dir)
-{
-       int changed = _snd_pcm_hw_param_min(params, var, val, dir ? *dir : 0);
-       if (changed < 0)
-               return changed;
-       if (params->rmask) {
-               int err = snd_pcm_hw_refine(pcm, params);
-               if (err < 0)
-                       return err;
-       }
-       return snd_pcm_hw_param_value_min(params, var, dir);
-}
-
-static int _snd_pcm_hw_param_max(struct snd_pcm_hw_params *params,
-                                snd_pcm_hw_param_t var, unsigned int val,
-                                int dir)
-{
-       int changed;
-       int open = 0;
-       if (dir) {
-               if (dir < 0) {
-                       open = 1;
-               } else if (dir > 0) {
-                       open = 1;
-                       val++;
-               }
-       }
-       if (hw_is_mask(var)) {
-               if (val == 0 && open) {
-                       snd_mask_none(hw_param_mask(params, var));
-                       changed = -EINVAL;
-               } else
-                       changed = snd_mask_refine_max(hw_param_mask(params, var), val - !!open);
-       } else if (hw_is_interval(var))
-               changed = snd_interval_refine_max(hw_param_interval(params, var), val, open);
-       else {
-               assert(0);
-               return -EINVAL;
-       }
-       if (changed) {
-               params->cmask |= 1 << var;
-               params->rmask |= 1 << var;
-       }
-       return changed;
-}
-
-/**
- * snd_pcm_hw_param_max
- * @pcm: PCM instance
- * @params: the hw_params instance
- * @var: parameter to retrieve
- * @val: maximal value
- * @dir: pointer to the direction (-1,0,1) or NULL
- *
- * Inside configuration space defined by PARAMS remove from PAR all 
- *  values >= VAL + 1. Reduce configuration space accordingly.
- *  Return new maximum or -EINVAL if the configuration space is empty
- */
-static int snd_pcm_hw_param_max(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params,
-                               snd_pcm_hw_param_t var, unsigned int val,
-                               int *dir)
-{
-       int changed = _snd_pcm_hw_param_max(params, var, val, dir ? *dir : 0);
-       if (changed < 0)
-               return changed;
-       if (params->rmask) {
-               int err = snd_pcm_hw_refine(pcm, params);
-               if (err < 0)
-                       return err;
-       }
-       return snd_pcm_hw_param_value_max(params, var, dir);
-}
-
-int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params,
-                         snd_pcm_hw_param_t var, unsigned int val, int dir)
-{
-       int changed;
-       if (hw_is_mask(var)) {
-               struct snd_mask *m = hw_param_mask(params, var);
-               if (val == 0 && dir < 0) {
-                       changed = -EINVAL;
-                       snd_mask_none(m);
-               } else {
-                       if (dir > 0)
-                               val++;
-                       else if (dir < 0)
-                               val--;
-                       changed = snd_mask_refine_set(hw_param_mask(params, var), val);
-               }
-       } else if (hw_is_interval(var)) {
-               struct snd_interval *i = hw_param_interval(params, var);
-               if (val == 0 && dir < 0) {
-                       changed = -EINVAL;
-                       snd_interval_none(i);
-               } else if (dir == 0)
-                       changed = snd_interval_refine_set(i, val);
-               else {
-                       struct snd_interval t;
-                       t.openmin = 1;
-                       t.openmax = 1;
-                       t.empty = 0;
-                       t.integer = 0;
-                       if (dir < 0) {
-                               t.min = val - 1;
-                               t.max = val;
-                       } else {
-                               t.min = val;
-                               t.max = val+1;
-                       }
-                       changed = snd_interval_refine(i, &t);
-               }
-       } else {
-               assert(0);
-               return -EINVAL;
-       }
-       if (changed) {
-               params->cmask |= 1 << var;
-               params->rmask |= 1 << var;
-       }
-       return changed;
-}
-
-/**
- * snd_pcm_hw_param_set
- * @pcm: PCM instance
- * @params: the hw_params instance
- * @var: parameter to retrieve
- * @val: value to set
- * @dir: pointer to the direction (-1,0,1) or NULL
- *
- * Inside configuration space defined by PARAMS remove from PAR all 
- * values != VAL. Reduce configuration space accordingly.
- *  Return VAL or -EINVAL if the configuration space is empty
- */
-int snd_pcm_hw_param_set(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params,
-                        snd_pcm_hw_param_t var, unsigned int val, int dir)
-{
-       int changed = _snd_pcm_hw_param_set(params, var, val, dir);
-       if (changed < 0)
-               return changed;
-       if (params->rmask) {
-               int err = snd_pcm_hw_refine(pcm, params);
-               if (err < 0)
-                       return err;
-       }
-       return snd_pcm_hw_param_value(params, var, NULL);
-}
-
-static int _snd_pcm_hw_param_mask(struct snd_pcm_hw_params *params,
-                                 snd_pcm_hw_param_t var, const struct snd_mask *val)
-{
-       int changed;
-       assert(hw_is_mask(var));
-       changed = snd_mask_refine(hw_param_mask(params, var), val);
-       if (changed) {
-               params->cmask |= 1 << var;
-               params->rmask |= 1 << var;
-       }
-       return changed;
-}
-
-/**
- * snd_pcm_hw_param_mask
- * @pcm: PCM instance
- * @params: the hw_params instance
- * @var: parameter to retrieve
- * @val: mask to apply
- *
- * Inside configuration space defined by PARAMS remove from PAR all values
- * not contained in MASK. Reduce configuration space accordingly.
- * This function can be called only for SNDRV_PCM_HW_PARAM_ACCESS,
- * SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_SUBFORMAT.
- * Return 0 on success or -EINVAL
- * if the configuration space is empty
- */
-int snd_pcm_hw_param_mask(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params,
-                         snd_pcm_hw_param_t var, const struct snd_mask *val)
-{
-       int changed = _snd_pcm_hw_param_mask(params, var, val);
-       if (changed < 0)
-               return changed;
-       if (params->rmask) {
-               int err = snd_pcm_hw_refine(pcm, params);
-               if (err < 0)
-                       return err;
-       }
-       return 0;
-}
-
-static int boundary_sub(int a, int adir,
-                       int b, int bdir,
-                       int *c, int *cdir)
-{
-       adir = adir < 0 ? -1 : (adir > 0 ? 1 : 0);
-       bdir = bdir < 0 ? -1 : (bdir > 0 ? 1 : 0);
-       *c = a - b;
-       *cdir = adir - bdir;
-       if (*cdir == -2) {
-               assert(*c > INT_MIN);
-               (*c)--;
-       } else if (*cdir == 2) {
-               assert(*c < INT_MAX);
-               (*c)++;
-       }
-       return 0;
-}
-
-static int boundary_lt(unsigned int a, int adir,
-                      unsigned int b, int bdir)
-{
-       assert(a > 0 || adir >= 0);
-       assert(b > 0 || bdir >= 0);
-       if (adir < 0) {
-               a--;
-               adir = 1;
-       } else if (adir > 0)
-               adir = 1;
-       if (bdir < 0) {
-               b--;
-               bdir = 1;
-       } else if (bdir > 0)
-               bdir = 1;
-       return a < b || (a == b && adir < bdir);
-}
-
-/* Return 1 if min is nearer to best than max */
-static int boundary_nearer(int min, int mindir,
-                          int best, int bestdir,
-                          int max, int maxdir)
-{
-       int dmin, dmindir;
-       int dmax, dmaxdir;
-       boundary_sub(best, bestdir, min, mindir, &dmin, &dmindir);
-       boundary_sub(max, maxdir, best, bestdir, &dmax, &dmaxdir);
-       return boundary_lt(dmin, dmindir, dmax, dmaxdir);
-}
-
-/**
- * snd_pcm_hw_param_near
- * @pcm: PCM instance
- * @params: the hw_params instance
- * @var: parameter to retrieve
- * @best: value to set
- * @dir: pointer to the direction (-1,0,1) or NULL
- *
- * Inside configuration space defined by PARAMS set PAR to the available value
- * nearest to VAL. Reduce configuration space accordingly.
- * This function cannot be called for SNDRV_PCM_HW_PARAM_ACCESS,
- * SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_SUBFORMAT.
- * Return the value found.
-  */
-int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params,
-                         snd_pcm_hw_param_t var, unsigned int best, int *dir)
-{
-       struct snd_pcm_hw_params *save = NULL;
-       int v;
-       unsigned int saved_min;
-       int last = 0;
-       int min, max;
-       int mindir, maxdir;
-       int valdir = dir ? *dir : 0;
-       /* FIXME */
-       if (best > INT_MAX)
-               best = INT_MAX;
-       min = max = best;
-       mindir = maxdir = valdir;
-       if (maxdir > 0)
-               maxdir = 0;
-       else if (maxdir == 0)
-               maxdir = -1;
-       else {
-               maxdir = 1;
-               max--;
-       }
-       save = kmalloc(sizeof(*save), GFP_KERNEL);
-       if (save == NULL)
-               return -ENOMEM;
-       *save = *params;
-       saved_min = min;
-       min = snd_pcm_hw_param_min(pcm, params, var, min, &mindir);
-       if (min >= 0) {
-               struct snd_pcm_hw_params *params1;
-               if (max < 0)
-                       goto _end;
-               if ((unsigned int)min == saved_min && mindir == valdir)
-                       goto _end;
-               params1 = kmalloc(sizeof(*params1), GFP_KERNEL);
-               if (params1 == NULL) {
-                       kfree(save);
-                       return -ENOMEM;
-               }
-               *params1 = *save;
-               max = snd_pcm_hw_param_max(pcm, params1, var, max, &maxdir);
-               if (max < 0) {
-                       kfree(params1);
-                       goto _end;
-               }
-               if (boundary_nearer(max, maxdir, best, valdir, min, mindir)) {
-                       *params = *params1;
-                       last = 1;
-               }
-               kfree(params1);
-       } else {
-               *params = *save;
-               max = snd_pcm_hw_param_max(pcm, params, var, max, &maxdir);
-               assert(max >= 0);
-               last = 1;
-       }
- _end:
-       kfree(save);
-       if (last)
-               v = snd_pcm_hw_param_last(pcm, params, var, dir);
-       else
-               v = snd_pcm_hw_param_first(pcm, params, var, dir);
-       assert(v >= 0);
-       return v;
-}
+EXPORT_SYMBOL(snd_pcm_hw_param_last);
 
 /**
  * snd_pcm_hw_param_choose
@@ -1967,6 +1464,8 @@ int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
        return -ENXIO;
 }
 
+EXPORT_SYMBOL(snd_pcm_lib_ioctl);
+
 /*
  *  Conditions
  */
@@ -2101,6 +1600,8 @@ void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
        kill_fasync(&runtime->fasync, SIGIO, POLL_IN);
 }
 
+EXPORT_SYMBOL(snd_pcm_period_elapsed);
+
 static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream,
                                      unsigned int hwoff,
                                      unsigned long data, unsigned int off,
@@ -2308,6 +1809,8 @@ snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const v
                                  snd_pcm_lib_write_transfer);
 }
 
+EXPORT_SYMBOL(snd_pcm_lib_write);
+
 static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream,
                                       unsigned int hwoff,
                                       unsigned long data, unsigned int off,
@@ -2370,6 +1873,8 @@ snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,
                                  nonblock, snd_pcm_lib_writev_transfer);
 }
 
+EXPORT_SYMBOL(snd_pcm_lib_writev);
+
 static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream, 
                                     unsigned int hwoff,
                                     unsigned long data, unsigned int off,
@@ -2578,6 +2083,8 @@ snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __u
        return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer);
 }
 
+EXPORT_SYMBOL(snd_pcm_lib_read);
+
 static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream,
                                      unsigned int hwoff,
                                      unsigned long data, unsigned int off,
@@ -2635,52 +2142,4 @@ snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,
        return snd_pcm_lib_read1(substream, (unsigned long)bufs, frames, nonblock, snd_pcm_lib_readv_transfer);
 }
 
-/*
- *  Exported symbols
- */
-
-EXPORT_SYMBOL(snd_interval_refine);
-EXPORT_SYMBOL(snd_interval_list);
-EXPORT_SYMBOL(snd_interval_ratnum);
-EXPORT_SYMBOL(_snd_pcm_hw_params_any);
-EXPORT_SYMBOL(_snd_pcm_hw_param_min);
-EXPORT_SYMBOL(_snd_pcm_hw_param_set);
-EXPORT_SYMBOL(_snd_pcm_hw_param_setempty);
-EXPORT_SYMBOL(_snd_pcm_hw_param_setinteger);
-EXPORT_SYMBOL(snd_pcm_hw_param_value_min);
-EXPORT_SYMBOL(snd_pcm_hw_param_value_max);
-EXPORT_SYMBOL(snd_pcm_hw_param_mask);
-EXPORT_SYMBOL(snd_pcm_hw_param_first);
-EXPORT_SYMBOL(snd_pcm_hw_param_last);
-EXPORT_SYMBOL(snd_pcm_hw_param_near);
-EXPORT_SYMBOL(snd_pcm_hw_param_set);
-EXPORT_SYMBOL(snd_pcm_hw_refine);
-EXPORT_SYMBOL(snd_pcm_hw_constraints_init);
-EXPORT_SYMBOL(snd_pcm_hw_constraints_complete);
-EXPORT_SYMBOL(snd_pcm_hw_constraint_list);
-EXPORT_SYMBOL(snd_pcm_hw_constraint_step);
-EXPORT_SYMBOL(snd_pcm_hw_constraint_ratnums);
-EXPORT_SYMBOL(snd_pcm_hw_constraint_ratdens);
-EXPORT_SYMBOL(snd_pcm_hw_constraint_msbits);
-EXPORT_SYMBOL(snd_pcm_hw_constraint_minmax);
-EXPORT_SYMBOL(snd_pcm_hw_constraint_integer);
-EXPORT_SYMBOL(snd_pcm_hw_constraint_pow2);
-EXPORT_SYMBOL(snd_pcm_hw_rule_add);
-EXPORT_SYMBOL(snd_pcm_set_ops);
-EXPORT_SYMBOL(snd_pcm_set_sync);
-EXPORT_SYMBOL(snd_pcm_lib_ioctl);
-EXPORT_SYMBOL(snd_pcm_stop);
-EXPORT_SYMBOL(snd_pcm_period_elapsed);
-EXPORT_SYMBOL(snd_pcm_lib_write);
-EXPORT_SYMBOL(snd_pcm_lib_read);
-EXPORT_SYMBOL(snd_pcm_lib_writev);
 EXPORT_SYMBOL(snd_pcm_lib_readv);
-EXPORT_SYMBOL(snd_pcm_lib_buffer_bytes);
-EXPORT_SYMBOL(snd_pcm_lib_period_bytes);
-/* pcm_memory.c */
-EXPORT_SYMBOL(snd_pcm_lib_preallocate_free_for_all);
-EXPORT_SYMBOL(snd_pcm_lib_preallocate_pages);
-EXPORT_SYMBOL(snd_pcm_lib_preallocate_pages_for_all);
-EXPORT_SYMBOL(snd_pcm_sgbuf_ops_page);
-EXPORT_SYMBOL(snd_pcm_lib_malloc_pages);
-EXPORT_SYMBOL(snd_pcm_lib_free_pages);

diff --git a/sound/core/pcm_memory.c b/sound/core/pcm_memory.c
index 428f8c169ee15406a7ad6c3d2bd8b90cba5b75f6..eb56167d3bb4fd374eca159fba8e626e195d1007 100644 (file)
--- a/sound/core/pcm_memory.c
+++ b/sound/core/pcm_memory.c
@@ -126,6 +126,8 @@ int snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm)
        return 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_lib_preallocate_free_for_all);
+
 #ifdef CONFIG_SND_VERBOSE_PROCFS
 /*
  * read callback for prealloc proc file
@@ -253,6 +255,8 @@ int snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream,
        return snd_pcm_lib_preallocate_pages1(substream, size, max);
 }
 
+EXPORT_SYMBOL(snd_pcm_lib_preallocate_pages);
+
 /**
  * snd_pcm_lib_preallocate_pages_for_all - pre-allocation for continous memory type (all substreams)
  * @pcm: the pcm instance
@@ -280,6 +284,8 @@ int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
        return 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_lib_preallocate_pages_for_all);
+
 /**
  * snd_pcm_sgbuf_ops_page - get the page struct at the given offset
  * @substream: the pcm substream instance
@@ -298,6 +304,8 @@ struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigne
        return sgbuf->page_table[idx];
 }
 
+EXPORT_SYMBOL(snd_pcm_sgbuf_ops_page);
+
 /**
  * snd_pcm_lib_malloc_pages - allocate the DMA buffer
  * @substream: the substream to allocate the DMA buffer to
@@ -349,6 +357,8 @@ int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size)
        return 1;                       /* area was changed */
 }
 
+EXPORT_SYMBOL(snd_pcm_lib_malloc_pages);
+
 /**
  * snd_pcm_lib_free_pages - release the allocated DMA buffer.
  * @substream: the substream to release the DMA buffer
@@ -374,3 +384,5 @@ int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream)
        snd_pcm_set_runtime_buffer(substream, NULL);
        return 0;
 }
+
+EXPORT_SYMBOL(snd_pcm_lib_free_pages);

diff --git a/sound/core/pcm_misc.c b/sound/core/pcm_misc.c
index 593c77f4d181bcfe0fb55d0e5e0349ec3fdc90ba..0019c59a779d25a0cc772826d03a0de2f3d75957 100644 (file)
--- a/sound/core/pcm_misc.c
+++ b/sound/core/pcm_misc.c
@@ -207,6 +207,8 @@ int snd_pcm_format_signed(snd_pcm_format_t format)
        return val;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_signed);
+
 /**
  * snd_pcm_format_unsigned - Check the PCM format is unsigned linear
  * @format: the format to check
@@ -224,6 +226,8 @@ int snd_pcm_format_unsigned(snd_pcm_format_t format)
        return !val;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_unsigned);
+
 /**
  * snd_pcm_format_linear - Check the PCM format is linear
  * @format: the format to check
@@ -235,6 +239,8 @@ int snd_pcm_format_linear(snd_pcm_format_t format)
        return snd_pcm_format_signed(format) >= 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_linear);
+
 /**
  * snd_pcm_format_little_endian - Check the PCM format is little-endian
  * @format: the format to check
@@ -252,6 +258,8 @@ int snd_pcm_format_little_endian(snd_pcm_format_t format)
        return val;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_little_endian);
+
 /**
  * snd_pcm_format_big_endian - Check the PCM format is big-endian
  * @format: the format to check
@@ -269,6 +277,8 @@ int snd_pcm_format_big_endian(snd_pcm_format_t format)
        return !val;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_big_endian);
+
 /**
  * snd_pcm_format_width - return the bit-width of the format
  * @format: the format to check
@@ -286,6 +296,8 @@ int snd_pcm_format_width(snd_pcm_format_t format)
        return val;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_width);
+
 /**
  * snd_pcm_format_physical_width - return the physical bit-width of the format
  * @format: the format to check
@@ -303,6 +315,8 @@ int snd_pcm_format_physical_width(snd_pcm_format_t format)
        return val;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_physical_width);
+
 /**
  * snd_pcm_format_size - return the byte size of samples on the given format
  * @format: the format to check
@@ -318,6 +332,8 @@ ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples)
        return samples * phys_width / 8;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_size);
+
 /**
  * snd_pcm_format_silence_64 - return the silent data in 8 bytes array
  * @format: the format to check
@@ -333,6 +349,8 @@ const unsigned char *snd_pcm_format_silence_64(snd_pcm_format_t format)
        return pcm_formats[format].silence;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_silence_64);
+
 /**
  * snd_pcm_format_set_silence - set the silence data on the buffer
  * @format: the PCM format
@@ -402,6 +420,8 @@ int snd_pcm_format_set_silence(snd_pcm_format_t format, void *data, unsigned int
        return 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_set_silence);
+
 /* [width][unsigned][bigendian] */
 static int linear_formats[4][2][2] = {
        {{ SNDRV_PCM_FORMAT_S8, SNDRV_PCM_FORMAT_S8},
@@ -432,6 +452,8 @@ snd_pcm_format_t snd_pcm_build_linear_format(int width, int unsignd, int big_end
        return linear_formats[width][!!unsignd][!!big_endian];
 }
 
+EXPORT_SYMBOL(snd_pcm_build_linear_format);
+
 /**
  * snd_pcm_limit_hw_rates - determine rate_min/rate_max fields
  * @runtime: the runtime instance
@@ -463,3 +485,5 @@ int snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime)
        }
        return 0;
 }
+
+EXPORT_SYMBOL(snd_pcm_limit_hw_rates);

diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index 0860c5a84502f6f67451cdea60a566b639fdbf9b..7b5729c4b213dc82a8fe703a9a58bc4d4903464d 100644 (file)
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -71,8 +71,9 @@ static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream);
  */
 
 DEFINE_RWLOCK(snd_pcm_link_rwlock);
-static DECLARE_RWSEM(snd_pcm_link_rwsem);
+EXPORT_SYMBOL(snd_pcm_link_rwlock);
 
+static DECLARE_RWSEM(snd_pcm_link_rwsem);
 
 static inline mm_segment_t snd_enter_user(void)
 {
@@ -319,6 +320,8 @@ int snd_pcm_hw_refine(struct snd_pcm_substream *substream,
        return 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_refine);
+
 static int snd_pcm_hw_refine_user(struct snd_pcm_substream *substream,
                                  struct snd_pcm_hw_params __user * _params)
 {
@@ -936,6 +939,8 @@ int snd_pcm_stop(struct snd_pcm_substream *substream, int state)
        return snd_pcm_action(&snd_pcm_action_stop, substream, state);
 }
 
+EXPORT_SYMBOL(snd_pcm_stop);
+
 /**
  * snd_pcm_drain_done
  * @substream: the PCM substream
@@ -1085,6 +1090,8 @@ int snd_pcm_suspend(struct snd_pcm_substream *substream)
        return err;
 }
 
+EXPORT_SYMBOL(snd_pcm_suspend);
+
 /**
  * snd_pcm_suspend_all
  * @pcm: the PCM instance
@@ -1114,6 +1121,8 @@ int snd_pcm_suspend_all(struct snd_pcm *pcm)
        return 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_suspend_all);
+
 /* resume */
 
 static int snd_pcm_pre_resume(struct snd_pcm_substream *substream, int state)
@@ -2020,6 +2029,8 @@ void snd_pcm_release_substream(struct snd_pcm_substream *substream)
        snd_pcm_detach_substream(substream);
 }
 
+EXPORT_SYMBOL(snd_pcm_release_substream);
+
 int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
                           struct file *file,
                           struct snd_pcm_substream **rsubstream)
@@ -2056,6 +2067,8 @@ int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
        return err;
 }
 
+EXPORT_SYMBOL(snd_pcm_open_substream);
+
 static int snd_pcm_open_file(struct file *file,
                             struct snd_pcm *pcm,
                             int stream,
@@ -2768,6 +2781,8 @@ int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream,
        return result;
 }
 
+EXPORT_SYMBOL(snd_pcm_kernel_ioctl);
+
 static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count,
                            loff_t * offset)
 {
@@ -3169,6 +3184,8 @@ int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream,
        atomic_inc(&substream->runtime->mmap_count);
        return 0;
 }
+
+EXPORT_SYMBOL(snd_pcm_lib_mmap_iomem);
 #endif /* SNDRV_PCM_INFO_MMAP */
 
 /*
@@ -3212,6 +3229,8 @@ int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file,
                return snd_pcm_default_mmap(substream, area);
 }
 
+EXPORT_SYMBOL(snd_pcm_mmap_data);
+
 static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area)
 {
        struct snd_pcm_file * pcm_file;