[ALSA] Remove xxx_t typedefs: PCM

Modules: PCM Midlevel

Remove xxx_t typedefs from the core PCM codes.

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

1 files changed, 159 insertions, 161 deletions

diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index 3dbf9bf2ac16..c58ec67d1cbf 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -39,9 +39,9 @@
  *
  * when runtime->silence_size >= runtime->boundary - fill processed area with silence immediately
  */
-void snd_pcm_playback_silence(snd_pcm_substream_t *substream, snd_pcm_uframes_t new_hw_ptr)
+void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
+        struct snd_pcm_runtime *runtime = substream->runtime;
         snd_pcm_uframes_t frames, ofs, transfer;
 
         if (runtime->silence_size < runtime->boundary) {
@@ -128,7 +128,7 @@ void snd_pcm_playback_silence(snd_pcm_substream_t *substream, snd_pcm_uframes_t
         }
 }
 
-static void xrun(snd_pcm_substream_t *substream)
+static void xrun(struct snd_pcm_substream *substream)
 {
         snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
 #ifdef CONFIG_SND_DEBUG
@@ -143,8 +143,8 @@ static void xrun(snd_pcm_substream_t *substream)
 #endif
 }
 
-static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(snd_pcm_substream_t *substream,
-                                                          snd_pcm_runtime_t *runtime)
+static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(struct snd_pcm_substream *substream,
+                                                          struct snd_pcm_runtime *runtime)
 {
         snd_pcm_uframes_t pos;
 
@@ -162,8 +162,8 @@ static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(snd_pcm_substream_t *s
         return pos;
 }
 
-static inline int snd_pcm_update_hw_ptr_post(snd_pcm_substream_t *substream,
-                                             snd_pcm_runtime_t *runtime)
+static inline int snd_pcm_update_hw_ptr_post(struct snd_pcm_substream *substream,
+                                             struct snd_pcm_runtime *runtime)
 {
         snd_pcm_uframes_t avail;
 
@@ -185,9 +185,9 @@ static inline int snd_pcm_update_hw_ptr_post(snd_pcm_substream_t *substream,
         return 0;
 }
 
-static inline int snd_pcm_update_hw_ptr_interrupt(snd_pcm_substream_t *substream)
+static inline int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
+        struct snd_pcm_runtime *runtime = substream->runtime;
         snd_pcm_uframes_t pos;
         snd_pcm_uframes_t new_hw_ptr, hw_ptr_interrupt;
         snd_pcm_sframes_t delta;
@@ -232,9 +232,9 @@ static inline int snd_pcm_update_hw_ptr_interrupt(snd_pcm_substream_t *substream
 }
 
 /* CAUTION: call it with irq disabled */
-int snd_pcm_update_hw_ptr(snd_pcm_substream_t *substream)
+int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
+        struct snd_pcm_runtime *runtime = substream->runtime;
         snd_pcm_uframes_t pos;
         snd_pcm_uframes_t old_hw_ptr, new_hw_ptr;
         snd_pcm_sframes_t delta;
@@ -281,10 +281,10 @@ int snd_pcm_update_hw_ptr(snd_pcm_substream_t *substream)
  *
  * Sets the given PCM operators to the pcm instance.
  */
-void snd_pcm_set_ops(snd_pcm_t *pcm, int direction, snd_pcm_ops_t *ops)
+void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops)
 {
-        snd_pcm_str_t *stream = &pcm->streams[direction];
-        snd_pcm_substream_t *substream;
+        struct snd_pcm_str *stream = &pcm->streams[direction];
+        struct snd_pcm_substream *substream;
         
         for (substream = stream->substream; substream != NULL; substream = substream->next)
                 substream->ops = ops;
@@ -297,9 +297,9 @@ void snd_pcm_set_ops(snd_pcm_t *pcm, int direction, snd_pcm_ops_t *ops)
  *
  * Sets the PCM sync identifier for the card.
  */
-void snd_pcm_set_sync(snd_pcm_substream_t * substream)
+void snd_pcm_set_sync(struct snd_pcm_substream *substream)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
+        struct snd_pcm_runtime *runtime = substream->runtime;
         
         runtime->sync.id32[0] = substream->pcm->card->number;
         runtime->sync.id32[1] = -1;
@@ -370,7 +370,7 @@ static inline unsigned int muldiv32(unsigned int a, unsigned int b,
         return n;
 }
 
-static int snd_interval_refine_min(snd_interval_t *i, unsigned int min, int openmin)
+static int snd_interval_refine_min(struct snd_interval *i, unsigned int min, int openmin)
 {
         int changed = 0;
         assert(!snd_interval_empty(i));
@@ -395,7 +395,7 @@ static int snd_interval_refine_min(snd_interval_t *i, unsigned int min, int open
         return changed;
 }
 
-static int snd_interval_refine_max(snd_interval_t *i, unsigned int max, int openmax)
+static int snd_interval_refine_max(struct snd_interval *i, unsigned int max, int openmax)
 {
         int changed = 0;
         assert(!snd_interval_empty(i));
@@ -431,7 +431,7 @@ static int snd_interval_refine_max(snd_interval_t *i, unsigned int max, int open
  *
  * Returns non-zero if the value is changed, zero if not changed.
  */
-int snd_interval_refine(snd_interval_t *i, const snd_interval_t *v)
+int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v)
 {
         int changed = 0;
         assert(!snd_interval_empty(i));
@@ -473,7 +473,7 @@ int snd_interval_refine(snd_interval_t *i, const snd_interval_t *v)
         return changed;
 }
 
-static int snd_interval_refine_first(snd_interval_t *i)
+static int snd_interval_refine_first(struct snd_interval *i)
 {
         assert(!snd_interval_empty(i));
         if (snd_interval_single(i))
@@ -485,7 +485,7 @@ static int snd_interval_refine_first(snd_interval_t *i)
         return 1;
 }
 
-static int snd_interval_refine_last(snd_interval_t *i)
+static int snd_interval_refine_last(struct snd_interval *i)
 {
         assert(!snd_interval_empty(i));
         if (snd_interval_single(i))
@@ -497,9 +497,9 @@ static int snd_interval_refine_last(snd_interval_t *i)
         return 1;
 }
 
-static int snd_interval_refine_set(snd_interval_t *i, unsigned int val)
+static int snd_interval_refine_set(struct snd_interval *i, unsigned int val)
 {
-        snd_interval_t t;
+        struct snd_interval t;
         t.empty = 0;
         t.min = t.max = val;
         t.openmin = t.openmax = 0;
@@ -507,7 +507,7 @@ static int snd_interval_refine_set(snd_interval_t *i, unsigned int val)
         return snd_interval_refine(i, &t);
 }
 
-void snd_interval_mul(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c)
+void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
 {
         if (a->empty || b->empty) {
                 snd_interval_none(c);
@@ -531,7 +531,7 @@ void snd_interval_mul(const snd_interval_t *a, const snd_interval_t *b, snd_inte
  *
  * Returns non-zero if the value is changed, zero if not changed.
  */
-void snd_interval_div(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c)
+void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
 {
         unsigned int r;
         if (a->empty || b->empty) {
@@ -566,8 +566,8 @@ void snd_interval_div(const snd_interval_t *a, const snd_interval_t *b, snd_inte
  *
  * Returns non-zero if the value is changed, zero if not changed.
  */
-void snd_interval_muldivk(const snd_interval_t *a, const snd_interval_t *b,
-                      unsigned int k, snd_interval_t *c)
+void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b,
+                      unsigned int k, struct snd_interval *c)
 {
         unsigned int r;
         if (a->empty || b->empty) {
@@ -597,8 +597,8 @@ void snd_interval_muldivk(const snd_interval_t *a, const snd_interval_t *b,
  *
  * Returns non-zero if the value is changed, zero if not changed.
  */
-void snd_interval_mulkdiv(const snd_interval_t *a, unsigned int k,
-                      const snd_interval_t *b, snd_interval_t *c)
+void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,
+                      const struct snd_interval *b, struct snd_interval *c)
 {
         unsigned int r;
         if (a->empty || b->empty) {
@@ -636,13 +636,13 @@ void snd_interval_mulkdiv(const snd_interval_t *a, unsigned int k,
  *
  * Returns non-zero if the value is changed, zero if not changed.
  */
-int snd_interval_ratnum(snd_interval_t *i,
-                    unsigned int rats_count, ratnum_t *rats,
-                    unsigned int *nump, unsigned int *denp)
+int snd_interval_ratnum(struct snd_interval *i,
+                        unsigned int rats_count, struct snd_ratnum *rats,
+                        unsigned int *nump, unsigned int *denp)
 {
         unsigned int best_num, best_diff, best_den;
         unsigned int k;
-        snd_interval_t t;
+        struct snd_interval t;
         int err;
 
         best_num = best_den = best_diff = 0;
@@ -731,20 +731,20 @@ int snd_interval_ratnum(snd_interval_t *i,
 /**
  * snd_interval_ratden - refine the interval value
  * @i: interval to refine
- * @rats_count: number of ratden_t
- * @rats: ratden_t array
+ * @rats_count: number of struct ratden
+ * @rats: struct ratden array
  * @nump: pointer to store the resultant numerator
  * @denp: pointer to store the resultant denominator
  *
  * Returns non-zero if the value is changed, zero if not changed.
  */
-static int snd_interval_ratden(snd_interval_t *i,
-                               unsigned int rats_count, ratden_t *rats,
+static int snd_interval_ratden(struct snd_interval *i,
+                               unsigned int rats_count, struct snd_ratden *rats,
                                unsigned int *nump, unsigned int *denp)
 {
         unsigned int best_num, best_diff, best_den;
         unsigned int k;
-        snd_interval_t t;
+        struct snd_interval t;
         int err;
 
         best_num = best_den = best_diff = 0;
@@ -837,7 +837,7 @@ static int snd_interval_ratden(snd_interval_t *i,
  *
  * Returns non-zero if the value is changed, zero if not changed.
  */
-int snd_interval_list(snd_interval_t *i, unsigned int count, unsigned int *list, unsigned int mask)
+int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *list, unsigned int mask)
 {
         unsigned int k;
         int changed = 0;
@@ -878,7 +878,7 @@ int snd_interval_list(snd_interval_t *i, unsigned int count, unsigned int *list,
         return changed;
 }
 
-static int snd_interval_step(snd_interval_t *i, unsigned int min, unsigned int step)
+static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned int step)
 {
         unsigned int n;
         int changed = 0;
@@ -912,18 +912,18 @@ static int snd_interval_step(snd_interval_t *i, unsigned int min, unsigned int s
  *
  * Returns zero if successful, or a negative error code on failure.
  */
-int snd_pcm_hw_rule_add(snd_pcm_runtime_t *runtime, unsigned int cond,
+int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond,
                         int var,
                         snd_pcm_hw_rule_func_t func, void *private,
                         int dep, ...)
 {
-        snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints;
-        snd_pcm_hw_rule_t *c;
+        struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
+        struct snd_pcm_hw_rule *c;
         unsigned int k;
         va_list args;
         va_start(args, dep);
         if (constrs->rules_num >= constrs->rules_all) {
-                snd_pcm_hw_rule_t *new;
+                struct snd_pcm_hw_rule *new;
                 unsigned int new_rules = constrs->rules_all + 16;
                 new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL);
                 if (!new)
@@ -962,11 +962,11 @@ int snd_pcm_hw_rule_add(snd_pcm_runtime_t *runtime, unsigned int cond,
  *
  * Apply the constraint of the given bitmap mask to a mask parameter.
  */
-int snd_pcm_hw_constraint_mask(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var,
+int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
                                u_int32_t mask)
 {
-        snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints;
-        snd_mask_t *maskp = constrs_mask(constrs, var);
+        struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
+        struct snd_mask *maskp = constrs_mask(constrs, var);
         *maskp->bits &= mask;
         memset(maskp->bits + 1, 0, (SNDRV_MASK_MAX-32) / 8); /* clear rest */
         if (*maskp->bits == 0)
@@ -982,11 +982,11 @@ int snd_pcm_hw_constraint_mask(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t va
  *
  * Apply the constraint of the given bitmap mask to a mask parameter.
  */
-int snd_pcm_hw_constraint_mask64(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var,
+int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
                                  u_int64_t mask)
 {
-        snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints;
-        snd_mask_t *maskp = constrs_mask(constrs, var);
+        struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
+        struct snd_mask *maskp = constrs_mask(constrs, var);
         maskp->bits[0] &= (u_int32_t)mask;
         maskp->bits[1] &= (u_int32_t)(mask >> 32);
         memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */
@@ -1002,9 +1002,9 @@ int snd_pcm_hw_constraint_mask64(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t
  *
  * Apply the constraint of integer to an interval parameter.
  */
-int snd_pcm_hw_constraint_integer(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var)
+int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var)
 {
-        snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints;
+        struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
         return snd_interval_setinteger(constrs_interval(constrs, var));
 }
 
@@ -1017,11 +1017,11 @@ int snd_pcm_hw_constraint_integer(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t
  * 
  * Apply the min/max range constraint to an interval parameter.
  */
-int snd_pcm_hw_constraint_minmax(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var,
+int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
                                  unsigned int min, unsigned int max)
 {
-        snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints;
-        snd_interval_t t;
+        struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
+        struct snd_interval t;
         t.min = min;
         t.max = max;
         t.openmin = t.openmax = 0;
@@ -1029,10 +1029,10 @@ int snd_pcm_hw_constraint_minmax(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t
         return snd_interval_refine(constrs_interval(constrs, var), &t);
 }
 
-static int snd_pcm_hw_rule_list(snd_pcm_hw_params_t *params,
-                                snd_pcm_hw_rule_t *rule)
+static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params,
+                                struct snd_pcm_hw_rule *rule)
 {
-        snd_pcm_hw_constraint_list_t *list = rule->private;
+        struct snd_pcm_hw_constraint_list *list = rule->private;
         return snd_interval_list(hw_param_interval(params, rule->var), list->count, list->list, list->mask);
 }               
 
@@ -1046,20 +1046,20 @@ static int snd_pcm_hw_rule_list(snd_pcm_hw_params_t *params,
  * 
  * Apply the list of constraints to an interval parameter.
  */
-int snd_pcm_hw_constraint_list(snd_pcm_runtime_t *runtime,
+int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,
                                unsigned int cond,
                                snd_pcm_hw_param_t var,
-                               snd_pcm_hw_constraint_list_t *l)
+                               struct snd_pcm_hw_constraint_list *l)
 {
         return snd_pcm_hw_rule_add(runtime, cond, var,
                                    snd_pcm_hw_rule_list, l,
                                    var, -1);
 }
 
-static int snd_pcm_hw_rule_ratnums(snd_pcm_hw_params_t *params,
-                                   snd_pcm_hw_rule_t *rule)
+static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params,
+                                   struct snd_pcm_hw_rule *rule)
 {
-        snd_pcm_hw_constraint_ratnums_t *r = rule->private;
+        struct snd_pcm_hw_constraint_ratnums *r = rule->private;
         unsigned int num = 0, den = 0;
         int err;
         err = snd_interval_ratnum(hw_param_interval(params, rule->var),
@@ -1076,22 +1076,22 @@ static int snd_pcm_hw_rule_ratnums(snd_pcm_hw_params_t *params,
  * @runtime: PCM runtime instance
  * @cond: condition bits
  * @var: hw_params variable to apply the ratnums constraint
- * @r: ratnums_t constriants
+ * @r: struct snd_ratnums constriants
  */
-int snd_pcm_hw_constraint_ratnums(snd_pcm_runtime_t *runtime, 
+int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, 
                                   unsigned int cond,
                                   snd_pcm_hw_param_t var,
-                                  snd_pcm_hw_constraint_ratnums_t *r)
+                                  struct snd_pcm_hw_constraint_ratnums *r)
 {
         return snd_pcm_hw_rule_add(runtime, cond, var,
                                    snd_pcm_hw_rule_ratnums, r,
                                    var, -1);
 }
 
-static int snd_pcm_hw_rule_ratdens(snd_pcm_hw_params_t *params,
-                                   snd_pcm_hw_rule_t *rule)
+static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params,
+                                   struct snd_pcm_hw_rule *rule)
 {
-        snd_pcm_hw_constraint_ratdens_t *r = rule->private;
+        struct snd_pcm_hw_constraint_ratdens *r = rule->private;
         unsigned int num = 0, den = 0;
         int err = snd_interval_ratden(hw_param_interval(params, rule->var),
                                   r->nrats, r->rats, &num, &den);
@@ -1107,25 +1107,25 @@ static int snd_pcm_hw_rule_ratdens(snd_pcm_hw_params_t *params,
  * @runtime: PCM runtime instance
  * @cond: condition bits
  * @var: hw_params variable to apply the ratdens constraint
- * @r: ratdens_t constriants
+ * @r: struct snd_ratdens constriants
  */
-int snd_pcm_hw_constraint_ratdens(snd_pcm_runtime_t *runtime, 
+int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, 
                                   unsigned int cond,
                                   snd_pcm_hw_param_t var,
-                                  snd_pcm_hw_constraint_ratdens_t *r)
+                                  struct snd_pcm_hw_constraint_ratdens *r)
 {
         return snd_pcm_hw_rule_add(runtime, cond, var,
                                    snd_pcm_hw_rule_ratdens, r,
                                    var, -1);
 }
 
-static int snd_pcm_hw_rule_msbits(snd_pcm_hw_params_t *params,
-                                  snd_pcm_hw_rule_t *rule)
+static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params,
+                                  struct snd_pcm_hw_rule *rule)
 {
         unsigned int l = (unsigned long) rule->private;
         int width = l & 0xffff;
         unsigned int msbits = l >> 16;
-        snd_interval_t *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
+        struct snd_interval *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
         if (snd_interval_single(i) && snd_interval_value(i) == width)
                 params->msbits = msbits;
         return 0;
@@ -1138,7 +1138,7 @@ static int snd_pcm_hw_rule_msbits(snd_pcm_hw_params_t *params,
  * @width: sample bits width
  * @msbits: msbits width
  */
-int snd_pcm_hw_constraint_msbits(snd_pcm_runtime_t *runtime, 
+int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, 
                                  unsigned int cond,
                                  unsigned int width,
                                  unsigned int msbits)
@@ -1150,8 +1150,8 @@ int snd_pcm_hw_constraint_msbits(snd_pcm_runtime_t *runtime,
                                     SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
 }
 
-static int snd_pcm_hw_rule_step(snd_pcm_hw_params_t *params,
-                                snd_pcm_hw_rule_t *rule)
+static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params,
+                                struct snd_pcm_hw_rule *rule)
 {
         unsigned long step = (unsigned long) rule->private;
         return snd_interval_step(hw_param_interval(params, rule->var), 0, step);
@@ -1164,7 +1164,7 @@ static int snd_pcm_hw_rule_step(snd_pcm_hw_params_t *params,
  * @var: hw_params variable to apply the step constraint
  * @step: step size
  */
-int snd_pcm_hw_constraint_step(snd_pcm_runtime_t *runtime,
+int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,
                                unsigned int cond,
                                snd_pcm_hw_param_t var,
                                unsigned long step)
@@ -1174,7 +1174,7 @@ int snd_pcm_hw_constraint_step(snd_pcm_runtime_t *runtime,
                                    var, -1);
 }
 
-static int snd_pcm_hw_rule_pow2(snd_pcm_hw_params_t *params, snd_pcm_hw_rule_t *rule)
+static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
 {
         static int pow2_sizes[] = {
                 1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7,
@@ -1192,7 +1192,7 @@ static int snd_pcm_hw_rule_pow2(snd_pcm_hw_params_t *params, snd_pcm_hw_rule_t *
  * @cond: condition bits
  * @var: hw_params variable to apply the power-of-2 constraint
  */
-int snd_pcm_hw_constraint_pow2(snd_pcm_runtime_t *runtime,
+int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,
                                unsigned int cond,
                                snd_pcm_hw_param_t var)
 {
@@ -1202,13 +1202,12 @@ int snd_pcm_hw_constraint_pow2(snd_pcm_runtime_t *runtime,
 }
 
 /* To use the same code we have in alsa-lib */
-#define snd_pcm_t snd_pcm_substream_t
 #define assert(i) snd_assert((i), return -EINVAL)
 #ifndef INT_MIN
 #define INT_MIN ((int)((unsigned int)INT_MAX+1))
 #endif
 
-static void _snd_pcm_hw_param_any(snd_pcm_hw_params_t *params,
+static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params,
                                   snd_pcm_hw_param_t var)
 {
         if (hw_is_mask(var)) {
@@ -1230,7 +1229,7 @@ static void _snd_pcm_hw_param_any(snd_pcm_hw_params_t *params,
 /*
  * snd_pcm_hw_param_any
  */
-int snd_pcm_hw_param_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
+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);
@@ -1238,7 +1237,7 @@ int snd_pcm_hw_param_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 }
 #endif  /*  0  */
 
-void _snd_pcm_hw_params_any(snd_pcm_hw_params_t *params)
+void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params)
 {
         unsigned int k;
         memset(params, 0, sizeof(*params));
@@ -1255,7 +1254,7 @@ void _snd_pcm_hw_params_any(snd_pcm_hw_params_t *params)
  *
  * Fill PARAMS with full configuration space boundaries
  */
-int snd_pcm_hw_params_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
+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);
@@ -1271,11 +1270,11 @@ int snd_pcm_hw_params_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
  * 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 snd_pcm_hw_params_t *params,
+static 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 snd_mask_t *mask = hw_param_mask_c(params, var);
+                const struct snd_mask *mask = hw_param_mask_c(params, var);
                 if (!snd_mask_single(mask))
                         return -EINVAL;
                 if (dir)
@@ -1283,7 +1282,7 @@ static int snd_pcm_hw_param_value(const snd_pcm_hw_params_t *params,
                 return snd_mask_value(mask);
         }
         if (hw_is_interval(var)) {
-                const snd_interval_t *i = hw_param_interval_c(params, var);
+                const struct snd_interval *i = hw_param_interval_c(params, var);
                 if (!snd_interval_single(i))
                         return -EINVAL;
                 if (dir)
@@ -1302,7 +1301,7 @@ static int snd_pcm_hw_param_value(const snd_pcm_hw_params_t *params,
  *
  * Return the minimum value for field PAR.
  */
-unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params,
+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)) {
@@ -1311,7 +1310,7 @@ unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params,
                 return snd_mask_min(hw_param_mask_c(params, var));
         }
         if (hw_is_interval(var)) {
-                const snd_interval_t *i = hw_param_interval_c(params, var);
+                const struct snd_interval *i = hw_param_interval_c(params, var);
                 if (dir)
                         *dir = i->openmin;
                 return snd_interval_min(i);
@@ -1328,7 +1327,7 @@ unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params,
  *
  * Return the maximum value for field PAR.
  */
-unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params,
+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)) {
@@ -1337,7 +1336,7 @@ unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params,
                 return snd_mask_max(hw_param_mask_c(params, var));
         }
         if (hw_is_interval(var)) {
-                const snd_interval_t *i = hw_param_interval_c(params, var);
+                const struct snd_interval *i = hw_param_interval_c(params, var);
                 if (dir)
                         *dir = - (int) i->openmax;
                 return snd_interval_max(i);
@@ -1346,7 +1345,7 @@ unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params,
         return -EINVAL;
 }
 
-void _snd_pcm_hw_param_setempty(snd_pcm_hw_params_t *params,
+void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params,
                                 snd_pcm_hw_param_t var)
 {
         if (hw_is_mask(var)) {
@@ -1362,7 +1361,7 @@ void _snd_pcm_hw_param_setempty(snd_pcm_hw_params_t *params,
         }
 }
 
-int _snd_pcm_hw_param_setinteger(snd_pcm_hw_params_t *params,
+int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params *params,
                                  snd_pcm_hw_param_t var)
 {
         int changed;
@@ -1383,8 +1382,8 @@ int _snd_pcm_hw_param_setinteger(snd_pcm_hw_params_t *params,
  * non integer values. Reduce configuration space accordingly.
  * Return -EINVAL if the configuration space is empty
  */
-int snd_pcm_hw_param_setinteger(snd_pcm_t *pcm, 
-                                snd_pcm_hw_params_t *params,
+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);
@@ -1399,7 +1398,7 @@ int snd_pcm_hw_param_setinteger(snd_pcm_t *pcm,
 }
 #endif  /*  0  */
 
-static int _snd_pcm_hw_param_first(snd_pcm_hw_params_t *params,
+static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params,
                                    snd_pcm_hw_param_t var)
 {
         int changed;
@@ -1430,8 +1429,8 @@ static int _snd_pcm_hw_param_first(snd_pcm_hw_params_t *params,
  * values > minimum. Reduce configuration space accordingly.
  * Return the minimum.
  */
-static int snd_pcm_hw_param_first(snd_pcm_t *pcm, 
-                                  snd_pcm_hw_params_t *params, 
+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 changed = _snd_pcm_hw_param_first(params, var);
@@ -1444,7 +1443,7 @@ static int snd_pcm_hw_param_first(snd_pcm_t *pcm,
         return snd_pcm_hw_param_value(params, var, dir);
 }
 
-static int _snd_pcm_hw_param_last(snd_pcm_hw_params_t *params,
+static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params,
                                   snd_pcm_hw_param_t var)
 {
         int changed;
@@ -1475,8 +1474,8 @@ static int _snd_pcm_hw_param_last(snd_pcm_hw_params_t *params,
  * values < maximum. Reduce configuration space accordingly.
  * Return the maximum.
  */
-static int snd_pcm_hw_param_last(snd_pcm_t *pcm, 
-                                 snd_pcm_hw_params_t *params,
+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 changed = _snd_pcm_hw_param_last(params, var);
@@ -1489,7 +1488,7 @@ static int snd_pcm_hw_param_last(snd_pcm_t *pcm,
         return snd_pcm_hw_param_value(params, var, dir);
 }
 
-int _snd_pcm_hw_param_min(snd_pcm_hw_params_t *params,
+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;
@@ -1531,7 +1530,7 @@ int _snd_pcm_hw_param_min(snd_pcm_hw_params_t *params,
  * values < VAL. Reduce configuration space accordingly.
  * Return new minimum or -EINVAL if the configuration space is empty
  */
-static int snd_pcm_hw_param_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
+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)
 {
@@ -1546,7 +1545,7 @@ static int snd_pcm_hw_param_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
         return snd_pcm_hw_param_value_min(params, var, dir);
 }
 
-static int _snd_pcm_hw_param_max(snd_pcm_hw_params_t *params,
+static int _snd_pcm_hw_param_max(struct snd_pcm_hw_params *params,
                                  snd_pcm_hw_param_t var, unsigned int val,
                                  int dir)
 {
@@ -1591,7 +1590,7 @@ static int _snd_pcm_hw_param_max(snd_pcm_hw_params_t *params,
  *  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(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
+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)
 {
@@ -1606,12 +1605,12 @@ static int snd_pcm_hw_param_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
         return snd_pcm_hw_param_value_max(params, var, dir);
 }
 
-int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params,
+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)) {
-                snd_mask_t *m = hw_param_mask(params, var);
+                struct snd_mask *m = hw_param_mask(params, var);
                 if (val == 0 && dir < 0) {
                         changed = -EINVAL;
                         snd_mask_none(m);
@@ -1623,14 +1622,14 @@ int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params,
                         changed = snd_mask_refine_set(hw_param_mask(params, var), val);
                 }
         } else if (hw_is_interval(var)) {
-                snd_interval_t *i = hw_param_interval(params, 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 {
-                        snd_interval_t t;
+                        struct snd_interval t;
                         t.openmin = 1;
                         t.openmax = 1;
                         t.empty = 0;
@@ -1667,7 +1666,7 @@ int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params,
  * values != VAL. Reduce configuration space accordingly.
  *  Return VAL or -EINVAL if the configuration space is empty
  */
-int snd_pcm_hw_param_set(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
+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);
@@ -1681,8 +1680,8 @@ int snd_pcm_hw_param_set(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
         return snd_pcm_hw_param_value(params, var, NULL);
 }
 
-static int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params,
-                                  snd_pcm_hw_param_t var, const snd_mask_t *val)
+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));
@@ -1708,8 +1707,8 @@ static int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params,
  * Return 0 on success or -EINVAL
  * if the configuration space is empty
  */
-int snd_pcm_hw_param_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
-                          snd_pcm_hw_param_t var, const snd_mask_t *val)
+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)
@@ -1784,10 +1783,10 @@ static int boundary_nearer(int min, int mindir,
  * SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_SUBFORMAT.
  * Return the value found.
   */
-int snd_pcm_hw_param_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
+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)
 {
-        snd_pcm_hw_params_t *save = NULL;
+        struct snd_pcm_hw_params *save = NULL;
         int v;
         unsigned int saved_min;
         int last = 0;
@@ -1814,7 +1813,7 @@ int snd_pcm_hw_param_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
         saved_min = min;
         min = snd_pcm_hw_param_min(pcm, params, var, min, &mindir);
         if (min >= 0) {
-                snd_pcm_hw_params_t *params1;
+                struct snd_pcm_hw_params *params1;
                 if (max < 0)
                         goto _end;
                 if ((unsigned int)min == saved_min && mindir == valdir)
@@ -1861,7 +1860,7 @@ int snd_pcm_hw_param_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
  * first access, first format, first subformat, min channels,
  * min rate, min period time, max buffer size, min tick time
  */
-int snd_pcm_hw_params_choose(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
+int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params)
 {
         int err;
 
@@ -1892,13 +1891,12 @@ int snd_pcm_hw_params_choose(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
         return 0;
 }
 
-#undef snd_pcm_t
 #undef assert
 
-static int snd_pcm_lib_ioctl_reset(snd_pcm_substream_t *substream,
+static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream,
                                    void *arg)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
+        struct snd_pcm_runtime *runtime = substream->runtime;
         unsigned long flags;
         snd_pcm_stream_lock_irqsave(substream, flags);
         if (snd_pcm_running(substream) &&
@@ -1910,11 +1908,11 @@ static int snd_pcm_lib_ioctl_reset(snd_pcm_substream_t *substream,
         return 0;
 }
 
-static int snd_pcm_lib_ioctl_channel_info(snd_pcm_substream_t *substream,
+static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream *substream,
                                           void *arg)
 {
-        snd_pcm_channel_info_t *info = arg;
-        snd_pcm_runtime_t *runtime = substream->runtime;
+        struct snd_pcm_channel_info *info = arg;
+        struct snd_pcm_runtime *runtime = substream->runtime;
         int width;
         if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) {
                 info->offset = -1;
@@ -1956,7 +1954,7 @@ static int snd_pcm_lib_ioctl_channel_info(snd_pcm_substream_t *substream,
  *
  * Returns zero if successful, or a negative error code on failure.
  */
-int snd_pcm_lib_ioctl(snd_pcm_substream_t *substream,
+int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
                       unsigned int cmd, void *arg)
 {
         switch (cmd) {
@@ -1974,10 +1972,10 @@ int snd_pcm_lib_ioctl(snd_pcm_substream_t *substream,
  *  Conditions
  */
 
-static void snd_pcm_system_tick_set(snd_pcm_substream_t *substream, 
+static void snd_pcm_system_tick_set(struct snd_pcm_substream *substream, 
                                     unsigned long ticks)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
+        struct snd_pcm_runtime *runtime = substream->runtime;
         if (ticks == 0)
                 del_timer(&runtime->tick_timer);
         else {
@@ -1988,14 +1986,14 @@ static void snd_pcm_system_tick_set(snd_pcm_substream_t *substream,
 }
 
 /* Temporary alias */
-void snd_pcm_tick_set(snd_pcm_substream_t *substream, unsigned long ticks)
+void snd_pcm_tick_set(struct snd_pcm_substream *substream, unsigned long ticks)
 {
         snd_pcm_system_tick_set(substream, ticks);
 }
 
-void snd_pcm_tick_prepare(snd_pcm_substream_t *substream)
+void snd_pcm_tick_prepare(struct snd_pcm_substream *substream)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
+        struct snd_pcm_runtime *runtime = substream->runtime;
         snd_pcm_uframes_t frames = ULONG_MAX;
         snd_pcm_uframes_t avail, dist;
         unsigned int ticks;
@@ -2046,9 +2044,9 @@ void snd_pcm_tick_prepare(snd_pcm_substream_t *substream)
         snd_pcm_tick_set(substream, (unsigned long) ticks);
 }
 
-void snd_pcm_tick_elapsed(snd_pcm_substream_t *substream)
+void snd_pcm_tick_elapsed(struct snd_pcm_substream *substream)
 {
-        snd_pcm_runtime_t *runtime;
+        struct snd_pcm_runtime *runtime;
         unsigned long flags;
         
         snd_assert(substream != NULL, return);
@@ -2076,9 +2074,9 @@ void snd_pcm_tick_elapsed(snd_pcm_substream_t *substream)
  * Even if more than one periods have elapsed since the last call, you
  * have to call this only once.
  */
-void snd_pcm_period_elapsed(snd_pcm_substream_t *substream)
+void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
 {
-        snd_pcm_runtime_t *runtime;
+        struct snd_pcm_runtime *runtime;
         unsigned long flags;
 
         snd_assert(substream != NULL, return);
@@ -2104,12 +2102,12 @@ void snd_pcm_period_elapsed(snd_pcm_substream_t *substream)
         kill_fasync(&runtime->fasync, SIGIO, POLL_IN);
 }
 
-static int snd_pcm_lib_write_transfer(snd_pcm_substream_t *substream,
+static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream,
                                       unsigned int hwoff,
                                       unsigned long data, unsigned int off,
                                       snd_pcm_uframes_t frames)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
+        struct snd_pcm_runtime *runtime = substream->runtime;
         int err;
         char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);
         if (substream->ops->copy) {
@@ -2124,17 +2122,17 @@ static int snd_pcm_lib_write_transfer(snd_pcm_substream_t *substream,
         return 0;
 }
  
-typedef int (*transfer_f)(snd_pcm_substream_t *substream, unsigned int hwoff,
+typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff,
                           unsigned long data, unsigned int off,
                           snd_pcm_uframes_t size);
 
-static snd_pcm_sframes_t snd_pcm_lib_write1(snd_pcm_substream_t *substream, 
+static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream, 
                                             unsigned long data,
                                             snd_pcm_uframes_t size,
                                             int nonblock,
                                             transfer_f transfer)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
+        struct snd_pcm_runtime *runtime = substream->runtime;
         snd_pcm_uframes_t xfer = 0;
         snd_pcm_uframes_t offset = 0;
         int err = 0;
@@ -2290,9 +2288,9 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(snd_pcm_substream_t *substream,
         return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
 }
 
-snd_pcm_sframes_t snd_pcm_lib_write(snd_pcm_substream_t *substream, const void __user *buf, snd_pcm_uframes_t size)
+snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size)
 {
-        snd_pcm_runtime_t *runtime;
+        struct snd_pcm_runtime *runtime;
         int nonblock;
 
         snd_assert(substream != NULL, return -ENXIO);
@@ -2306,7 +2304,7 @@ snd_pcm_sframes_t snd_pcm_lib_write(snd_pcm_substream_t *substream, const void _
         nonblock = !!(substream->ffile->f_flags & O_NONBLOCK);
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
         if (substream->oss.oss) {
-                snd_pcm_oss_setup_t *setup = substream->oss.setup;
+                struct snd_pcm_oss_setup *setup = substream->oss.setup;
                 if (setup != NULL) {
                         if (setup->nonblock)
                                 nonblock = 1;
@@ -2323,12 +2321,12 @@ snd_pcm_sframes_t snd_pcm_lib_write(snd_pcm_substream_t *substream, const void _
                                   snd_pcm_lib_write_transfer);
 }
 
-static int snd_pcm_lib_writev_transfer(snd_pcm_substream_t *substream,
+static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream,
                                        unsigned int hwoff,
                                        unsigned long data, unsigned int off,
                                        snd_pcm_uframes_t frames)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
+        struct snd_pcm_runtime *runtime = substream->runtime;
         int err;
         void __user **bufs = (void __user **)data;
         int channels = runtime->channels;
@@ -2363,11 +2361,11 @@ static int snd_pcm_lib_writev_transfer(snd_pcm_substream_t *substream,
         return 0;
 }
  
-snd_pcm_sframes_t snd_pcm_lib_writev(snd_pcm_substream_t *substream,
+snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,
                                      void __user **bufs,
                                      snd_pcm_uframes_t frames)
 {
-        snd_pcm_runtime_t *runtime;
+        struct snd_pcm_runtime *runtime;
         int nonblock;
 
         snd_assert(substream != NULL, return -ENXIO);
@@ -2381,7 +2379,7 @@ snd_pcm_sframes_t snd_pcm_lib_writev(snd_pcm_substream_t *substream,
         nonblock = !!(substream->ffile->f_flags & O_NONBLOCK);
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
         if (substream->oss.oss) {
-                snd_pcm_oss_setup_t *setup = substream->oss.setup;
+                struct snd_pcm_oss_setup *setup = substream->oss.setup;
                 if (setup != NULL) {
                         if (setup->nonblock)
                                 nonblock = 1;
@@ -2397,12 +2395,12 @@ snd_pcm_sframes_t snd_pcm_lib_writev(snd_pcm_substream_t *substream,
                                   nonblock, snd_pcm_lib_writev_transfer);
 }
 
-static int snd_pcm_lib_read_transfer(snd_pcm_substream_t *substream, 
+static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream, 
                                      unsigned int hwoff,
                                      unsigned long data, unsigned int off,
                                      snd_pcm_uframes_t frames)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
+        struct snd_pcm_runtime *runtime = substream->runtime;
         int err;
         char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);
         if (substream->ops->copy) {
@@ -2417,13 +2415,13 @@ static int snd_pcm_lib_read_transfer(snd_pcm_substream_t *substream,
         return 0;
 }
 
-static snd_pcm_sframes_t snd_pcm_lib_read1(snd_pcm_substream_t *substream,
+static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
                                            unsigned long data,
                                            snd_pcm_uframes_t size,
                                            int nonblock,
                                            transfer_f transfer)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
+        struct snd_pcm_runtime *runtime = substream->runtime;
         snd_pcm_uframes_t xfer = 0;
         snd_pcm_uframes_t offset = 0;
         int err = 0;
@@ -2587,9 +2585,9 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(snd_pcm_substream_t *substream,
         return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
 }
 
-snd_pcm_sframes_t snd_pcm_lib_read(snd_pcm_substream_t *substream, void __user *buf, snd_pcm_uframes_t size)
+snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __user *buf, snd_pcm_uframes_t size)
 {
-        snd_pcm_runtime_t *runtime;
+        struct snd_pcm_runtime *runtime;
         int nonblock;
         
         snd_assert(substream != NULL, return -ENXIO);
@@ -2603,7 +2601,7 @@ snd_pcm_sframes_t snd_pcm_lib_read(snd_pcm_substream_t *substream, void __user *
         nonblock = !!(substream->ffile->f_flags & O_NONBLOCK);
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
         if (substream->oss.oss) {
-                snd_pcm_oss_setup_t *setup = substream->oss.setup;
+                struct snd_pcm_oss_setup *setup = substream->oss.setup;
                 if (setup != NULL) {
                         if (setup->nonblock)
                                 nonblock = 1;
@@ -2617,12 +2615,12 @@ snd_pcm_sframes_t snd_pcm_lib_read(snd_pcm_substream_t *substream, void __user *
         return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer);
 }
 
-static int snd_pcm_lib_readv_transfer(snd_pcm_substream_t *substream,
+static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream,
                                       unsigned int hwoff,
                                       unsigned long data, unsigned int off,
                                       snd_pcm_uframes_t frames)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
+        struct snd_pcm_runtime *runtime = substream->runtime;
         int err;
         void __user **bufs = (void __user **)data;
         int channels = runtime->channels;
@@ -2654,11 +2652,11 @@ static int snd_pcm_lib_readv_transfer(snd_pcm_substream_t *substream,
         return 0;
 }
  
-snd_pcm_sframes_t snd_pcm_lib_readv(snd_pcm_substream_t *substream,
+snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,
                                     void __user **bufs,
                                     snd_pcm_uframes_t frames)
 {
-        snd_pcm_runtime_t *runtime;
+        struct snd_pcm_runtime *runtime;
         int nonblock;
 
         snd_assert(substream != NULL, return -ENXIO);
@@ -2672,7 +2670,7 @@ snd_pcm_sframes_t snd_pcm_lib_readv(snd_pcm_substream_t *substream,
         nonblock = !!(substream->ffile->f_flags & O_NONBLOCK);
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
         if (substream->oss.oss) {
-                snd_pcm_oss_setup_t *setup = substream->oss.setup;
+                struct snd_pcm_oss_setup *setup = substream->oss.setup;
                 if (setup != NULL) {
                         if (setup->nonblock)
                                 nonblock = 1;