summaryrefslogtreecommitdiffstats
path: root/sound/core/pcm_lib.c
diff options
context:
space:
mode:
Diffstat (limited to 'sound/core/pcm_lib.c')
-rw-r--r--sound/core/pcm_lib.c327
1 files changed, 162 insertions, 165 deletions
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index 3dbf9bf2ac16..eeba2f060955 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) {
@@ -56,9 +56,8 @@ void snd_pcm_playback_silence(snd_pcm_substream_t *substream, snd_pcm_uframes_t
runtime->silence_filled = 0;
runtime->silence_start = runtime->control->appl_ptr;
}
- if (runtime->silence_filled == runtime->buffer_size)
+ if (runtime->silence_filled >= runtime->buffer_size)
return;
- snd_assert(runtime->silence_filled <= runtime->buffer_size, return);
noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled;
if (noise_dist >= (snd_pcm_sframes_t) runtime->silence_threshold)
return;
@@ -128,7 +127,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 +142,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 +161,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 +184,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 +231,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 +280,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 +296,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 +369,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 +394,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 +430,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 +472,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 +484,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 +496,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 +506,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 +530,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 +565,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 +596,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 +635,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 +730,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 +836,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 +877,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 +911,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 +961,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 +981,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 +1001,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 +1016,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 +1028,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 +1045,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 +1075,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 +1106,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 +1137,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 +1149,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 +1163,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 +1173,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 +1191,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 +1201,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 +1228,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 +1236,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 +1253,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 +1269,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 +1281,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 +1300,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 +1309,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 +1326,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 +1335,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 +1344,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 +1360,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 +1381,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 +1397,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 +1428,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 +1442,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 +1473,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 +1487,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 +1529,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 +1544,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 +1589,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 +1604,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 +1621,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 +1665,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 +1679,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 +1706,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 +1782,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 +1812,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 +1859,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 +1890,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 +1907,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 +1953,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 +1971,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 +1985,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;
@@ -2008,8 +2005,8 @@ void snd_pcm_tick_prepare(snd_pcm_substream_t *substream)
runtime->silence_filled < runtime->buffer_size) {
snd_pcm_sframes_t noise_dist;
noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled;
- snd_assert(noise_dist <= (snd_pcm_sframes_t)runtime->silence_threshold, );
- frames = noise_dist - runtime->silence_threshold;
+ if (noise_dist > (snd_pcm_sframes_t)runtime->silence_threshold)
+ frames = noise_dist - runtime->silence_threshold;
}
avail = snd_pcm_playback_avail(runtime);
} else {
@@ -2046,9 +2043,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 +2073,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 +2101,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 +2121,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 +2287,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 +2303,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 +2320,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 +2360,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 +2378,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 +2394,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 +2414,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 +2584,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 +2600,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 +2614,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 +2651,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 +2669,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;
OpenPOWER on IntegriCloud