Fix some obvious codestyle issues in the pcm_native.c file. Some of them
were found by checkpatch with --strict option, and the others by just
looking at the code. These issues include incorrect placement of brackets,
trailing and starting spaces, wrong alignment of function arguments,
incorrect multiline comments, using __attribute__((packed)) instead of just
"__packed", comparison with null instead of using "!". Also, today we have
100 columns per line available, and I tried to reformat the file
considering this.
Signed-off-by: Ivan Orlov <ivan.orlov0322@xxxxxxxxx>
---
sound/core/pcm_native.c | 696 +++++++++++++++++++---------------------
1 file changed, 323 insertions(+), 373 deletions(-)
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index 39a65d1415ab..4a8d2e825b1d 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -43,10 +43,9 @@
struct snd_pcm_hw_params_old {
unsigned int flags;
- unsigned int masks[SNDRV_PCM_HW_PARAM_SUBFORMAT -
- SNDRV_PCM_HW_PARAM_ACCESS + 1];
+ unsigned int masks[SNDRV_PCM_HW_PARAM_SUBFORMAT - SNDRV_PCM_HW_PARAM_ACCESS + 1];
struct snd_interval intervals[SNDRV_PCM_HW_PARAM_TICK_TIME -
- SNDRV_PCM_HW_PARAM_SAMPLE_BITS + 1];
+ SNDRV_PCM_HW_PARAM_SAMPLE_BITS + 1];
unsigned int rmask;
unsigned int cmask;
unsigned int info;
@@ -62,9 +61,9 @@ struct snd_pcm_hw_params_old {
#define SNDRV_PCM_IOCTL_HW_PARAMS_OLD _IOWR('A', 0x11, struct snd_pcm_hw_params_old)
static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream,
- struct snd_pcm_hw_params_old __user * _oparams);
+ struct snd_pcm_hw_params_old __user *_oparams);
static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream,
- struct snd_pcm_hw_params_old __user * _oparams);
+ struct snd_pcm_hw_params_old __user *_oparams);
#endif
static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream);
@@ -133,8 +132,7 @@ EXPORT_SYMBOL_GPL(snd_pcm_stream_unlock);
*/
void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream)
{
- snd_pcm_group_lock_irq(&substream->self_group,
- substream->pcm->nonatomic);
+ snd_pcm_group_lock_irq(&substream->self_group, substream->pcm->nonatomic);
}
EXPORT_SYMBOL_GPL(snd_pcm_stream_lock_irq);
@@ -164,6 +162,7 @@ EXPORT_SYMBOL_GPL(snd_pcm_stream_unlock_irq);
unsigned long _snd_pcm_stream_lock_irqsave(struct snd_pcm_substream *substream)
{
unsigned long flags = 0;
+
if (substream->pcm->nonatomic)
mutex_lock(&substream->self_group.mutex);
else
@@ -175,12 +174,11 @@ EXPORT_SYMBOL_GPL(_snd_pcm_stream_lock_irqsave);
unsigned long _snd_pcm_stream_lock_irqsave_nested(struct snd_pcm_substream *substream)
{
unsigned long flags = 0;
+
if (substream->pcm->nonatomic)
- mutex_lock_nested(&substream->self_group.mutex,
- SINGLE_DEPTH_NESTING);
+ mutex_lock_nested(&substream->self_group.mutex, SINGLE_DEPTH_NESTING);
else
- spin_lock_irqsave_nested(&substream->self_group.lock, flags,
- SINGLE_DEPTH_NESTING);
+ spin_lock_irqsave_nested(&substream->self_group.lock, flags, SINGLE_DEPTH_NESTING);
return flags;
}
EXPORT_SYMBOL_GPL(_snd_pcm_stream_lock_irqsave_nested);
@@ -192,8 +190,7 @@ EXPORT_SYMBOL_GPL(_snd_pcm_stream_lock_irqsave_nested);
*
* This is a counter-part of snd_pcm_stream_lock_irqsave().
*/
-void snd_pcm_stream_unlock_irqrestore(struct snd_pcm_substream *substream,
- unsigned long flags)
+void snd_pcm_stream_unlock_irqrestore(struct snd_pcm_substream *substream, unsigned long flags)
{
if (substream->pcm->nonatomic)
mutex_unlock(&substream->self_group.mutex);
@@ -203,8 +200,7 @@ void snd_pcm_stream_unlock_irqrestore(struct snd_pcm_substream *substream,
EXPORT_SYMBOL_GPL(snd_pcm_stream_unlock_irqrestore);
/* Run PCM ioctl ops */
-static int snd_pcm_ops_ioctl(struct snd_pcm_substream *substream,
- unsigned cmd, void *arg)
+static int snd_pcm_ops_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg)
{
if (substream->ops->ioctl)
return substream->ops->ioctl(substream, cmd, arg);
@@ -233,14 +229,13 @@ int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info)
return 0;
}
-int snd_pcm_info_user(struct snd_pcm_substream *substream,
- struct snd_pcm_info __user * _info)
+int snd_pcm_info_user(struct snd_pcm_substream *substream, struct snd_pcm_info __user *_info)
{
struct snd_pcm_info *info;
int err;
info = kmalloc(sizeof(*info), GFP_KERNEL);
- if (! info)
+ if (!info)
return -ENOMEM;
err = snd_pcm_info(substream, info);
if (err >= 0) {
@@ -284,8 +279,7 @@ static bool hw_support_mmap(struct snd_pcm_substream *substream)
static int constrain_mask_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params)
{
- struct snd_pcm_hw_constraints *constrs =
- &substream->runtime->hw_constraints;
+ struct snd_pcm_hw_constraints *constrs = &substream->runtime->hw_constraints;
struct snd_mask *m;
unsigned int k;
struct snd_mask old_mask __maybe_unused;
@@ -320,8 +314,7 @@ static int constrain_mask_params(struct snd_pcm_substream *substream,
static int constrain_interval_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params)
{
- struct snd_pcm_hw_constraints *constrs =
- &substream->runtime->hw_constraints;
+ struct snd_pcm_hw_constraints *constrs = &substream->runtime->hw_constraints;
struct snd_interval *i;
unsigned int k;
struct snd_interval old_interval __maybe_unused;
@@ -356,8 +349,7 @@ static int constrain_interval_params(struct snd_pcm_substream *substream,
static int constrain_params_by_rules(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params)
{
- struct snd_pcm_hw_constraints *constrs =
- &substream->runtime->hw_constraints;
+ struct snd_pcm_hw_constraints *constrs = &substream->runtime->hw_constraints;
unsigned int k;
unsigned int *rstamps;
unsigned int vstamps[SNDRV_PCM_HW_PARAM_LAST_INTERVAL + 1];
@@ -447,14 +439,12 @@ static int constrain_params_by_rules(struct snd_pcm_substream *substream,
*/
if (changed && r->var >= 0) {
if (hw_is_mask(r->var)) {
- trace_hw_mask_param(substream, r->var,
- k + 1, &old_mask,
- hw_param_mask(params, r->var));
+ trace_hw_mask_param(substream, r->var, k + 1, &old_mask,
+ hw_param_mask(params, r->var));
}
if (hw_is_interval(r->var)) {
- trace_hw_interval_param(substream, r->var,
- k + 1, &old_interval,
- hw_param_interval(params, r->var));
+ trace_hw_interval_param(substream, r->var, k + 1, &old_interval,
+ hw_param_interval(params, r->var));
}
params->cmask |= PARAM_MASK_BIT(r->var);
@@ -509,18 +499,15 @@ static int fixup_unreferenced_params(struct snd_pcm_substream *substream,
if (!params->info) {
params->info = substream->runtime->hw.info;
- params->info &= ~(SNDRV_PCM_INFO_FIFO_IN_FRAMES |
- SNDRV_PCM_INFO_DRAIN_TRIGGER);
+ params->info &= ~(SNDRV_PCM_INFO_FIFO_IN_FRAMES | SNDRV_PCM_INFO_DRAIN_TRIGGER);
if (!hw_support_mmap(substream))
- params->info &= ~(SNDRV_PCM_INFO_MMAP |
- SNDRV_PCM_INFO_MMAP_VALID);
+ params->info &= ~(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID);
}
return 0;
}
-int snd_pcm_hw_refine(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)
{
int err;
@@ -552,7 +539,7 @@ int snd_pcm_hw_refine(struct snd_pcm_substream *substream,
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)
+ struct snd_pcm_hw_params __user *_params)
{
struct snd_pcm_hw_params *params;
int err;
@@ -580,7 +567,7 @@ static int period_to_usecs(struct snd_pcm_runtime *runtime)
{
int usecs;
- if (! runtime->rate)
+ if (!runtime->rate)
return -1; /* invalid */
/* take 75% of period time as the deadline */
@@ -591,8 +578,7 @@ static int period_to_usecs(struct snd_pcm_runtime *runtime)
return usecs;
}
-static void snd_pcm_set_state(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static void snd_pcm_set_state(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
snd_pcm_stream_lock_irq(substream);
if (substream->runtime->state != SNDRV_PCM_STATE_DISCONNECTED)
@@ -600,13 +586,11 @@ static void snd_pcm_set_state(struct snd_pcm_substream *substream,
snd_pcm_stream_unlock_irq(substream);
}
-static inline void snd_pcm_timer_notify(struct snd_pcm_substream *substream,
- int event)
+static inline void snd_pcm_timer_notify(struct snd_pcm_substream *substream, int event)
{
#ifdef CONFIG_SND_PCM_TIMER
if (substream->timer)
- snd_timer_notify(substream->timer, event,
- &substream->runtime->trigger_tstamp);
+ snd_timer_notify(substream->timer, event, &substream->runtime->trigger_tstamp);
#endif
}
@@ -672,10 +656,8 @@ static int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm,
continue;
/* Trace the changed parameter. */
- if (hw_is_mask(*v)) {
- trace_hw_mask_param(pcm, *v, 0, &old_mask,
- hw_param_mask(params, *v));
- }
+ if (hw_is_mask(*v))
+ trace_hw_mask_param(pcm, *v, 0, &old_mask, hw_param_mask(params, *v));
if (hw_is_interval(*v)) {
trace_hw_interval_param(pcm, *v, 0, &old_interval,
hw_param_interval(params, *v));
@@ -756,14 +738,13 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
goto _error;
if (substream->managed_buffer_alloc) {
- err = snd_pcm_lib_malloc_pages(substream,
- params_buffer_bytes(params));
+ err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
if (err < 0)
goto _error;
runtime->buffer_changed = err > 0;
}
- if (substream->ops->hw_params != NULL) {
+ if (substream->ops->hw_params) {
err = substream->ops->hw_params(substream, params);
if (err < 0)
goto _error;
@@ -780,9 +761,8 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
runtime->info = params->info;
runtime->rate_num = params->rate_num;
runtime->rate_den = params->rate_den;
- runtime->no_period_wakeup =
- (params->info & SNDRV_PCM_INFO_NO_PERIOD_WAKEUP) &&
- (params->flags & SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP);
+ runtime->no_period_wakeup = (params->info & SNDRV_PCM_INFO_NO_PERIOD_WAKEUP) &&
+ (params->flags & SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP);
bits = snd_pcm_format_physical_width(runtime->format);
runtime->sample_bits = bits;
@@ -824,8 +804,7 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
cpu_latency_qos_remove_request(&substream->latency_pm_qos_req);
usecs = period_to_usecs(runtime);
if (usecs >= 0)
- cpu_latency_qos_add_request(&substream->latency_pm_qos_req,
- usecs);
+ cpu_latency_qos_add_request(&substream->latency_pm_qos_req, usecs);
err = 0;
_error:
if (err) {
@@ -834,7 +813,7 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
* the correct hardware parameter settings
*/
snd_pcm_set_state(substream, SNDRV_PCM_STATE_OPEN);
- if (substream->ops->hw_free != NULL)
+ if (substream->ops->hw_free)
substream->ops->hw_free(substream);
if (substream->managed_buffer_alloc)
snd_pcm_lib_free_pages(substream);
@@ -845,7 +824,7 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
}
static int snd_pcm_hw_params_user(struct snd_pcm_substream *substream,
- struct snd_pcm_hw_params __user * _params)
+ struct snd_pcm_hw_params __user *_params)
{
struct snd_pcm_hw_params *params;
int err;
@@ -954,10 +933,9 @@ static int snd_pcm_sw_params(struct snd_pcm_substream *substream,
runtime->stop_threshold = params->stop_threshold;
runtime->silence_threshold = params->silence_threshold;
runtime->silence_size = params->silence_size;
- params->boundary = runtime->boundary;
+ params->boundary = runtime->boundary;
if (snd_pcm_running(substream)) {
- if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
- runtime->silence_size > 0)
+ if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && runtime->silence_size > 0)
snd_pcm_playback_silence(substream, ULONG_MAX);
err = snd_pcm_update_state(substream, runtime);
}
@@ -966,10 +944,11 @@ static int snd_pcm_sw_params(struct snd_pcm_substream *substream,
}
static int snd_pcm_sw_params_user(struct snd_pcm_substream *substream,
- struct snd_pcm_sw_params __user * _params)
+ struct snd_pcm_sw_params __user *_params)
{
struct snd_pcm_sw_params params;
int err;
+
if (copy_from_user(¶ms, _params, sizeof(params)))
return -EFAULT;
err = snd_pcm_sw_params(substream, ¶ms);
@@ -978,8 +957,7 @@ static int snd_pcm_sw_params_user(struct snd_pcm_substream *substream,
return err;
}
-static inline snd_pcm_uframes_t
-snd_pcm_calc_delay(struct snd_pcm_substream *substream)
+static inline snd_pcm_uframes_t snd_pcm_calc_delay(struct snd_pcm_substream *substream)
{
snd_pcm_uframes_t delay;
@@ -990,15 +968,14 @@ snd_pcm_calc_delay(struct snd_pcm_substream *substream)
return delay + substream->runtime->delay;
}
-int snd_pcm_status64(struct snd_pcm_substream *substream,
- struct snd_pcm_status64 *status)
+int snd_pcm_status64(struct snd_pcm_substream *substream, struct snd_pcm_status64 *status)
{
struct snd_pcm_runtime *runtime = substream->runtime;
snd_pcm_stream_lock_irq(substream);
snd_pcm_unpack_audio_tstamp_config(status->audio_tstamp_data,
- &runtime->audio_tstamp_config);
+ &runtime->audio_tstamp_config);
/* backwards compatible behavior */
if (runtime->audio_tstamp_config.type_requested ==
@@ -1010,8 +987,9 @@ int snd_pcm_status64(struct snd_pcm_substream *substream,
runtime->audio_tstamp_config.type_requested =
SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT;
runtime->audio_tstamp_report.valid = 0;
- } else
+ } else {
runtime->audio_tstamp_report.valid = 1;
+ }
status->state = runtime->state;
status->suspended_state = runtime->suspended_state;
@@ -1036,8 +1014,8 @@ int snd_pcm_status64(struct snd_pcm_substream *substream,
if (runtime->audio_tstamp_report.valid == 1)
/* backwards compatibility, no report provided in COMPAT mode */
snd_pcm_pack_audio_tstamp_report(&status->audio_tstamp_data,
- &status->audio_tstamp_accuracy,
- &runtime->audio_tstamp_report);
+ &status->audio_tstamp_accuracy,
+ &runtime->audio_tstamp_report);
goto _tstamp_end;
}
@@ -1055,19 +1033,18 @@ int snd_pcm_status64(struct snd_pcm_substream *substream,
status->appl_ptr = runtime->control->appl_ptr;
status->hw_ptr = runtime->status->hw_ptr;
status->avail = snd_pcm_avail(substream);
- status->delay = snd_pcm_running(substream) ?
- snd_pcm_calc_delay(substream) : 0;
+ status->delay = snd_pcm_running(substream) ? snd_pcm_calc_delay(substream) : 0;
status->avail_max = runtime->avail_max;
status->overrange = runtime->overrange;
runtime->avail_max = 0;
runtime->overrange = 0;
- _end:
- snd_pcm_stream_unlock_irq(substream);
+_end:
+ snd_pcm_stream_unlock_irq(substream);
return 0;
}
static int snd_pcm_status_user64(struct snd_pcm_substream *substream,
- struct snd_pcm_status64 __user * _status,
+ struct snd_pcm_status64 __user *_status,
bool ext)
{
struct snd_pcm_status64 status;
@@ -1079,8 +1056,7 @@ static int snd_pcm_status_user64(struct snd_pcm_substream *substream,
* get audio_tstamp_data from user,
* ignore rest of status structure
*/
- if (ext && get_user(status.audio_tstamp_data,
- (u32 __user *)(&_status->audio_tstamp_data)))
+ if (ext && get_user(status.audio_tstamp_data, (u32 __user *)&_status->audio_tstamp_data))
return -EFAULT;
res = snd_pcm_status64(substream, &status);
if (res < 0)
@@ -1091,7 +1067,7 @@ static int snd_pcm_status_user64(struct snd_pcm_substream *substream,
}
static int snd_pcm_status_user32(struct snd_pcm_substream *substream,
- struct snd_pcm_status32 __user * _status,
+ struct snd_pcm_status32 __user *_status,
bool ext)
{
struct snd_pcm_status64 status64;
@@ -1105,8 +1081,7 @@ static int snd_pcm_status_user32(struct snd_pcm_substream *substream,
* get audio_tstamp_data from user,
* ignore rest of status structure
*/
- if (ext && get_user(status64.audio_tstamp_data,
- (u32 __user *)(&_status->audio_tstamp_data)))
+ if (ext && get_user(status64.audio_tstamp_data, (u32 __user *)&_status->audio_tstamp_data))
return -EFAULT;
res = snd_pcm_status64(substream, &status64);
if (res < 0)
@@ -1140,11 +1115,11 @@ static int snd_pcm_status_user32(struct snd_pcm_substream *substream,
}
static int snd_pcm_channel_info(struct snd_pcm_substream *substream,
- struct snd_pcm_channel_info * info)
+ struct snd_pcm_channel_info *info)
{
struct snd_pcm_runtime *runtime;
unsigned int channel;
-
+
channel = info->channel;
runtime = substream->runtime;
snd_pcm_stream_lock_irq(substream);
@@ -1161,11 +1136,11 @@ static int snd_pcm_channel_info(struct snd_pcm_substream *substream,
}
static int snd_pcm_channel_info_user(struct snd_pcm_substream *substream,
- struct snd_pcm_channel_info __user * _info)
+ struct snd_pcm_channel_info __user *_info)
{
struct snd_pcm_channel_info info;
int res;
-
+
if (copy_from_user(&info, _info, sizeof(info)))
return -EFAULT;
res = snd_pcm_channel_info(substream, &info);
@@ -1179,7 +1154,8 @@ static int snd_pcm_channel_info_user(struct snd_pcm_substream *substream,
static void snd_pcm_trigger_tstamp(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
- if (runtime->trigger_master == NULL)
+
+ if (!runtime->trigger_master)
return;
if (runtime->trigger_master == substream) {
if (!runtime->trigger_tstamp_latched)
@@ -1191,17 +1167,13 @@ static void snd_pcm_trigger_tstamp(struct snd_pcm_substream *substream)
runtime->trigger_master = NULL;
}
-#define ACTION_ARG_IGNORE (__force snd_pcm_state_t)0
+#define ACTION_ARG_IGNORE ((__force snd_pcm_state_t)0)
struct action_ops {
- int (*pre_action)(struct snd_pcm_substream *substream,
- snd_pcm_state_t state);
- int (*do_action)(struct snd_pcm_substream *substream,
- snd_pcm_state_t state);
- void (*undo_action)(struct snd_pcm_substream *substream,
- snd_pcm_state_t state);
- void (*post_action)(struct snd_pcm_substream *substream,
- snd_pcm_state_t state);
+ int (*pre_action)(struct snd_pcm_substream *substream, snd_pcm_state_t state);
+ int (*do_action)(struct snd_pcm_substream *substream, snd_pcm_state_t state);
+ void (*undo_action)(struct snd_pcm_substream *substream, snd_pcm_state_t state);
+ void (*post_action)(struct snd_pcm_substream *substream, snd_pcm_state_t state);
};
/*
@@ -1209,10 +1181,8 @@ struct action_ops {
* Note: the stream state might be changed also on failure
* Note2: call with calling stream lock + link lock
*/
-static int snd_pcm_action_group(const struct action_ops *ops,
- struct snd_pcm_substream *substream,
- snd_pcm_state_t state,
- bool stream_lock)
+static int snd_pcm_action_group(const struct action_ops *ops, struct snd_pcm_substream *substream,
+ snd_pcm_state_t state, bool stream_lock)
{
struct snd_pcm_substream *s = NULL;
struct snd_pcm_substream *s1;
@@ -1274,7 +1244,7 @@ static int snd_pcm_action_single(const struct action_ops *ops,
snd_pcm_state_t state)
{
int res;
-
+
res = ops->pre_action(substream, state);
if (res < 0)
return res;
@@ -1297,8 +1267,7 @@ static void snd_pcm_group_assign(struct snd_pcm_substream *substream,
* Unref and unlock the group, but keep the stream lock;
* when the group becomes empty and no longer referred, destroy itself
*/
-static void snd_pcm_group_unref(struct snd_pcm_group *group,
- struct snd_pcm_substream *substream)
+static void snd_pcm_group_unref(struct snd_pcm_group *group, struct snd_pcm_substream *substream)
{
bool do_free;
@@ -1314,8 +1283,7 @@ static void snd_pcm_group_unref(struct snd_pcm_group *group,
* Lock the group inside a stream lock and reference it;
* return the locked group object, or NULL if not linked
*/
-static struct snd_pcm_group *
-snd_pcm_stream_group_ref(struct snd_pcm_substream *substream)
+static struct snd_pcm_group *snd_pcm_stream_group_ref(struct snd_pcm_substream *substream)
{
bool nonatomic = substream->pcm->nonatomic;
struct snd_pcm_group *group;
@@ -1328,8 +1296,7 @@ snd_pcm_stream_group_ref(struct snd_pcm_substream *substream)
/* block freeing the group object */
refcount_inc(&group->refs);
- trylock = nonatomic ? mutex_trylock(&group->mutex) :
- spin_trylock(&group->lock);
+ trylock = nonatomic ? mutex_trylock(&group->mutex) : spin_trylock(&group->lock);
if (trylock)
break; /* OK */
@@ -1411,10 +1378,10 @@ static int snd_pcm_pre_start(struct snd_pcm_substream *substream,
snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
+
if (runtime->state != SNDRV_PCM_STATE_PREPARED)
return -EBADFD;
- if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
- !snd_pcm_playback_data(substream))
+ if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && !snd_pcm_playback_data(substream))
return -EPIPE;
runtime->trigger_tstamp_latched = false;
runtime->trigger_master = substream;
@@ -1448,13 +1415,12 @@ static void snd_pcm_post_start(struct snd_pcm_substream *substream,
snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
+
snd_pcm_trigger_tstamp(substream);
runtime->hw_ptr_jiffies = jiffies;
- runtime->hw_ptr_buffer_jiffies = (runtime->buffer_size * HZ) /
- runtime->rate;
+ runtime->hw_ptr_buffer_jiffies = (runtime->buffer_size * HZ) / runtime->rate;
__snd_pcm_set_state(runtime, state);
- if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
- runtime->silence_size > 0)
+ if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && runtime->silence_size > 0)
snd_pcm_playback_silence(substream, ULONG_MAX);
snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MSTART);
}
@@ -1475,15 +1441,13 @@ static const struct action_ops snd_pcm_action_start = {
*/
int snd_pcm_start(struct snd_pcm_substream *substream)
{
- return snd_pcm_action(&snd_pcm_action_start, substream,
- SNDRV_PCM_STATE_RUNNING);
+ return snd_pcm_action(&snd_pcm_action_start, substream, SNDRV_PCM_STATE_RUNNING);
}
/* take the stream lock and start the streams */
static int snd_pcm_start_lock_irq(struct snd_pcm_substream *substream)
{
- return snd_pcm_action_lock_irq(&snd_pcm_action_start, substream,
- SNDRV_PCM_STATE_RUNNING);
+ return snd_pcm_action_lock_irq(&snd_pcm_action_start, substream, SNDRV_PCM_STATE_RUNNING);
}
/*
@@ -1493,6 +1457,7 @@ static int snd_pcm_pre_stop(struct snd_pcm_substream *substream,
snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
+
if (runtime->state == SNDRV_PCM_STATE_OPEN)
return -EBADFD;
runtime->trigger_master = substream;
@@ -1502,8 +1467,7 @@ static int snd_pcm_pre_stop(struct snd_pcm_substream *substream,
static int snd_pcm_do_stop(struct snd_pcm_substream *substream,
snd_pcm_state_t state)
{
- if (substream->runtime->trigger_master == substream &&
- snd_pcm_running(substream)) {
+ if (substream->runtime->trigger_master == substream && snd_pcm_running(substream)) {
substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_STOP);
substream->runtime->stop_operating = true;
}
@@ -1514,6 +1478,7 @@ static void snd_pcm_post_stop(struct snd_pcm_substream *substream,
snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
+
if (runtime->state != state) {
snd_pcm_trigger_tstamp(substream);
__snd_pcm_set_state(runtime, state);
@@ -1555,8 +1520,7 @@ EXPORT_SYMBOL(snd_pcm_stop);
*/
int snd_pcm_drain_done(struct snd_pcm_substream *substream)
{
- return snd_pcm_action_single(&snd_pcm_action_stop, substream,
- SNDRV_PCM_STATE_SETUP);
+ return snd_pcm_action_single(&snd_pcm_action_stop, substream, SNDRV_PCM_STATE_SETUP);
}
/**
@@ -1583,19 +1547,20 @@ EXPORT_SYMBOL_GPL(snd_pcm_stop_xrun);
/*
* pause callbacks: pass boolean (to start pause or resume) as state argument
*/
-#define pause_pushed(state) (__force bool)(state)
+#define pause_pushed(state) ((__force bool)(state))
-static int snd_pcm_pre_pause(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static int snd_pcm_pre_pause(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
+
if (!(runtime->info & SNDRV_PCM_INFO_PAUSE))
return -ENOSYS;
if (pause_pushed(state)) {
if (runtime->state != SNDRV_PCM_STATE_RUNNING)
return -EBADFD;
- } else if (runtime->state != SNDRV_PCM_STATE_PAUSED)
+ } else if (runtime->state != SNDRV_PCM_STATE_PAUSED) {
return -EBADFD;
+ }
runtime->trigger_master = substream;
return 0;
}
@@ -1605,8 +1570,7 @@ static int snd_pcm_do_pause(struct snd_pcm_substream *substream,
{
if (substream->runtime->trigger_master != substream)
return 0;
- /* some drivers might use hw_ptr to recover from the pause -
- update the hw_ptr now */
+ // some drivers might use hw_ptr to recover from the pause - update the hw_ptr now
if (pause_pushed(state))
snd_pcm_update_hw_ptr(substream);
/* The jiffies check in snd_pcm_update_hw_ptr*() is done by
@@ -1614,26 +1578,23 @@ static int snd_pcm_do_pause(struct snd_pcm_substream *substream,
* delta, effectively to skip the check once.
*/
substream->runtime->hw_ptr_jiffies = jiffies - HZ * 1000;
- return substream->ops->trigger(substream,
- pause_pushed(state) ?
+ return substream->ops->trigger(substream, pause_pushed(state) ?
SNDRV_PCM_TRIGGER_PAUSE_PUSH :
SNDRV_PCM_TRIGGER_PAUSE_RELEASE);
}
-static void snd_pcm_undo_pause(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static void snd_pcm_undo_pause(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
if (substream->runtime->trigger_master == substream)
- substream->ops->trigger(substream,
- pause_pushed(state) ?
+ substream->ops->trigger(substream, pause_pushed(state) ?
SNDRV_PCM_TRIGGER_PAUSE_RELEASE :
SNDRV_PCM_TRIGGER_PAUSE_PUSH);
}
-static void snd_pcm_post_pause(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static void snd_pcm_post_pause(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
+
snd_pcm_trigger_tstamp(substream);
if (pause_pushed(state)) {
__snd_pcm_set_state(runtime, SNDRV_PCM_STATE_PAUSED);
@@ -1658,24 +1619,23 @@ static const struct action_ops snd_pcm_action_pause = {
*/
static int snd_pcm_pause(struct snd_pcm_substream *substream, bool push)
{
- return snd_pcm_action(&snd_pcm_action_pause, substream,
- (__force snd_pcm_state_t)push);
+ return snd_pcm_action(&snd_pcm_action_pause, substream, (__force snd_pcm_state_t)push);
}
-static int snd_pcm_pause_lock_irq(struct snd_pcm_substream *substream,
- bool push)
+static int snd_pcm_pause_lock_irq(struct snd_pcm_substream *substream, bool push)
{
return snd_pcm_action_lock_irq(&snd_pcm_action_pause, substream,
(__force snd_pcm_state_t)push);
}
#ifdef CONFIG_PM
+
/* suspend callback: state argument ignored */
-static int snd_pcm_pre_suspend(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static int snd_pcm_pre_suspend(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
+
switch (runtime->state) {
case SNDRV_PCM_STATE_SUSPENDED:
return -EBUSY;
@@ -1689,23 +1649,23 @@ static int snd_pcm_pre_suspend(struct snd_pcm_substream *substream,
return 0;
}
-static int snd_pcm_do_suspend(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static int snd_pcm_do_suspend(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
+
if (runtime->trigger_master != substream)
return 0;
- if (! snd_pcm_running(substream))
+ if (!snd_pcm_running(substream))
return 0;
substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_SUSPEND);
runtime->stop_operating = true;
return 0; /* suspend unconditionally */
}
-static void snd_pcm_post_suspend(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static void snd_pcm_post_suspend(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
+
snd_pcm_trigger_tstamp(substream);
runtime->suspended_state = runtime->state;
runtime->status->suspended_state = runtime->suspended_state;
@@ -1735,8 +1695,7 @@ static int snd_pcm_suspend(struct snd_pcm_substream *substream)
unsigned long flags;
snd_pcm_stream_lock_irqsave(substream, flags);
- err = snd_pcm_action(&snd_pcm_action_suspend, substream,
- ACTION_ARG_IGNORE);
+ err = snd_pcm_action(&snd_pcm_action_suspend, substream, ACTION_ARG_IGNORE);
snd_pcm_stream_unlock_irqrestore(substream, flags);
return err;
}
@@ -1754,7 +1713,7 @@ int snd_pcm_suspend_all(struct snd_pcm *pcm)
struct snd_pcm_substream *substream;
int stream, err = 0;
- if (! pcm)
+ if (!pcm)
return 0;
for_each_pcm_substream(pcm, stream, substream) {
@@ -1783,20 +1742,20 @@ EXPORT_SYMBOL(snd_pcm_suspend_all);
/* resume callbacks: state argument ignored */
-static int snd_pcm_pre_resume(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static int snd_pcm_pre_resume(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
+
if (!(runtime->info & SNDRV_PCM_INFO_RESUME))
return -ENOSYS;
runtime->trigger_master = substream;
return 0;
}
-static int snd_pcm_do_resume(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static int snd_pcm_do_resume(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
+
if (runtime->trigger_master != substream)
return 0;
/* DMA not running previously? */
@@ -1807,18 +1766,16 @@ static int snd_pcm_do_resume(struct snd_pcm_substream *substream,
return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_RESUME);
}
-static void snd_pcm_undo_resume(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static void snd_pcm_undo_resume(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
- if (substream->runtime->trigger_master == substream &&
- snd_pcm_running(substream))
+ if (substream->runtime->trigger_master == substream && snd_pcm_running(substream))
substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_SUSPEND);
}
-static void snd_pcm_post_resume(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static void snd_pcm_post_resume(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
+
snd_pcm_trigger_tstamp(substream);
__snd_pcm_set_state(runtime, runtime->suspended_state);
snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MRESUME);
@@ -1833,8 +1790,7 @@ static const struct action_ops snd_pcm_action_resume = {
static int snd_pcm_resume(struct snd_pcm_substream *substream)
{
- return snd_pcm_action_lock_irq(&snd_pcm_action_resume, substream,
- ACTION_ARG_IGNORE);
+ return snd_pcm_action_lock_irq(&snd_pcm_action_resume, substream, ACTION_ARG_IGNORE);
}
#else
@@ -1876,10 +1832,10 @@ static int snd_pcm_xrun(struct snd_pcm_substream *substream)
* reset ioctl
*/
/* reset callbacks: state argument ignored */
-static int snd_pcm_pre_reset(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static int snd_pcm_pre_reset(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
+
switch (runtime->state) {
case SNDRV_PCM_STATE_RUNNING:
case SNDRV_PCM_STATE_PREPARED:
@@ -1891,11 +1847,12 @@ static int snd_pcm_pre_reset(struct snd_pcm_substream *substream,
}
}
-static int snd_pcm_do_reset(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static int snd_pcm_do_reset(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
- int err = snd_pcm_ops_ioctl(substream, SNDRV_PCM_IOCTL1_RESET, NULL);
+ int err;
+
+ err = snd_pcm_ops_ioctl(substream, SNDRV_PCM_IOCTL1_RESET, NULL);
if (err < 0)
return err;
snd_pcm_stream_lock_irq(substream);
@@ -1908,14 +1865,13 @@ static int snd_pcm_do_reset(struct snd_pcm_substream *substream,
return 0;
}
-static void snd_pcm_post_reset(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static void snd_pcm_post_reset(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
+
snd_pcm_stream_lock_irq(substream);
runtime->control->appl_ptr = runtime->status->hw_ptr;
- if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
- runtime->silence_size > 0)
+ if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && runtime->silence_size > 0)
snd_pcm_playback_silence(substream, ULONG_MAX);
snd_pcm_stream_unlock_irq(substream);
}
@@ -1928,16 +1884,14 @@ static const struct action_ops snd_pcm_action_reset = {
static int snd_pcm_reset(struct snd_pcm_substream *substream)
{
- return snd_pcm_action_nonatomic(&snd_pcm_action_reset, substream,
- ACTION_ARG_IGNORE);
+ return snd_pcm_action_nonatomic(&snd_pcm_action_reset, substream, ACTION_ARG_IGNORE);
}
/*
* prepare ioctl
*/
/* pass f_flags as state argument */
-static int snd_pcm_pre_prepare(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static int snd_pcm_pre_prepare(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
int f_flags = (__force int)state;
@@ -1951,10 +1905,10 @@ static int snd_pcm_pre_prepare(struct snd_pcm_substream *substream,
return 0;
}
-static int snd_pcm_do_prepare(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static int snd_pcm_do_prepare(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
int err;
+
snd_pcm_sync_stop(substream, true);
err = substream->ops->prepare(substream);
if (err < 0)
@@ -1962,10 +1916,10 @@ static int snd_pcm_do_prepare(struct snd_pcm_substream *substream,
return snd_pcm_do_reset(substream, state);
}
-static void snd_pcm_post_prepare(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static void snd_pcm_post_prepare(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
+
runtime->control->appl_ptr = runtime->status->hw_ptr;
snd_pcm_set_state(substream, SNDRV_PCM_STATE_PREPARED);
}
@@ -1983,8 +1937,7 @@ static const struct action_ops snd_pcm_action_prepare = {
*
* Return: Zero if successful, or a negative error code.
*/
-static int snd_pcm_prepare(struct snd_pcm_substream *substream,
- struct file *file)
+static int snd_pcm_prepare(struct snd_pcm_substream *substream, struct file *file)
{
int f_flags;
@@ -2004,8 +1957,7 @@ static int snd_pcm_prepare(struct snd_pcm_substream *substream,
}
snd_pcm_stream_unlock_irq(substream);
- return snd_pcm_action_nonatomic(&snd_pcm_action_prepare,
- substream,
+ return snd_pcm_action_nonatomic(&snd_pcm_action_prepare, substream,
(__force snd_pcm_state_t)f_flags);
}
@@ -2014,10 +1966,10 @@ static int snd_pcm_prepare(struct snd_pcm_substream *substream,
*/
/* drain init callbacks: state argument ignored */
-static int snd_pcm_pre_drain_init(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static int snd_pcm_pre_drain_init(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
+
switch (runtime->state) {
case SNDRV_PCM_STATE_OPEN:
case SNDRV_PCM_STATE_DISCONNECTED:
@@ -2028,15 +1980,15 @@ static int snd_pcm_pre_drain_init(struct snd_pcm_substream *substream,
return 0;
}
-static int snd_pcm_do_drain_init(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static int snd_pcm_do_drain_init(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
struct snd_pcm_runtime *runtime = substream->runtime;
+
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
switch (runtime->state) {
case SNDRV_PCM_STATE_PREPARED:
/* start playback stream if possible */
- if (! snd_pcm_playback_empty(substream)) {
+ if (!snd_pcm_playback_empty(substream)) {
snd_pcm_do_start(substream, SNDRV_PCM_STATE_DRAINING);
snd_pcm_post_start(substream, SNDRV_PCM_STATE_DRAINING);
} else {
@@ -2064,17 +2016,15 @@ static int snd_pcm_do_drain_init(struct snd_pcm_substream *substream,
}
}
- if (runtime->state == SNDRV_PCM_STATE_DRAINING &&
- runtime->trigger_master == substream &&
- (runtime->hw.info & SNDRV_PCM_INFO_DRAIN_TRIGGER))
+ if (runtime->state == SNDRV_PCM_STATE_DRAINING && runtime->trigger_master == substream &&
+ runtime->hw.info & SNDRV_PCM_INFO_DRAIN_TRIGGER)
return substream->ops->trigger(substream,
SNDRV_PCM_TRIGGER_DRAIN);
return 0;
}
-static void snd_pcm_post_drain_init(struct snd_pcm_substream *substream,
- snd_pcm_state_t state)
+static void snd_pcm_post_drain_init(struct snd_pcm_substream *substream, snd_pcm_state_t state)
{
}
@@ -2091,8 +2041,7 @@ static const struct action_ops snd_pcm_action_drain_init = {
* After this call, all streams are supposed to be either SETUP or DRAINING
* (capture only) state.
*/
-static int snd_pcm_drain(struct snd_pcm_substream *substream,
- struct file *file)
+static int snd_pcm_drain(struct snd_pcm_substream *substream, struct file *file)
{
struct snd_card *card;
struct snd_pcm_runtime *runtime;
@@ -2111,8 +2060,9 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream,
if (file) {
if (file->f_flags & O_NONBLOCK)
nonblock = 1;
- } else if (substream->f_flags & O_NONBLOCK)
+ } else if (substream->f_flags & O_NONBLOCK) {
nonblock = 1;
+ }
snd_pcm_stream_lock_irq(substream);
/* resume pause */
@@ -2120,8 +2070,7 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream,
snd_pcm_pause(substream, false);
/* pre-start/stop - all running streams are changed to DRAINING state */
- result = snd_pcm_action(&snd_pcm_action_drain_init, substream,
- ACTION_ARG_IGNORE);
+ result = snd_pcm_action(&snd_pcm_action_drain_init, substream, ACTION_ARG_IGNORE);
if (result < 0)
goto unlock;
/* in non-blocking, we don't wait in ioctl but let caller poll */
@@ -2131,8 +2080,9 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream,
}
for (;;) {
- long tout;
+ long tout, t;
struct snd_pcm_runtime *to_check;
+
if (signal_pending(current)) {
result = -ERESTARTSYS;
break;
@@ -2156,12 +2106,12 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream,
set_current_state(TASK_INTERRUPTIBLE);
add_wait_queue(&to_check->sleep, &wait);
snd_pcm_stream_unlock_irq(substream);
- if (runtime->no_period_wakeup)
+ if (runtime->no_period_wakeup) {
tout = MAX_SCHEDULE_TIMEOUT;
- else {
+ } else {
tout = 100;
if (runtime->rate) {
- long t = runtime->buffer_size * 1100 / runtime->rate;
+ t = runtime->buffer_size * 1100 / runtime->rate;
tout = max(t, tout);
}
tout = msecs_to_jiffies(tout);
@@ -2183,9 +2133,9 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream,
break;
}
if (tout == 0) {
- if (substream->runtime->state == SNDRV_PCM_STATE_SUSPENDED)
+ if (substream->runtime->state == SNDRV_PCM_STATE_SUSPENDED) {
result = -ESTRPIPE;
- else {
+ } else {
dev_dbg(substream->pcm->card->dev,
"playback drain timeout (DMA or IRQ trouble?)\n");
snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
@@ -2195,7 +2145,7 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream,
}
}
- unlock:
+unlock:
snd_pcm_stream_unlock_irq(substream);
return result;
@@ -2210,7 +2160,7 @@ static int snd_pcm_drop(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime;
int result = 0;
-
+
if (PCM_RUNTIME_CHECK(substream))
return -ENXIO;
runtime = substream->runtime;
@@ -2231,7 +2181,6 @@ static int snd_pcm_drop(struct snd_pcm_substream *substream)
return result;
}
-
static bool is_pcm_file(struct file *file)
{
struct inode *inode = file_inode(file);
@@ -2347,8 +2296,7 @@ static int snd_pcm_unlink(struct snd_pcm_substream *substream)
/* detach the last stream, too */
if (list_is_singular(&group->substreams)) {
- relink_to_local(list_first_entry(&group->substreams,
- struct snd_pcm_substream,
+ relink_to_local(list_first_entry(&group->substreams, struct snd_pcm_substream,
link_list));
do_free = refcount_dec_and_test(&group->refs);
}
@@ -2357,7 +2305,7 @@ static int snd_pcm_unlink(struct snd_pcm_substream *substream)
if (do_free)
kfree(group);
- _end:
+_end:
up_write(&snd_pcm_link_rwsem);
return res;
}
@@ -2365,62 +2313,62 @@ static int snd_pcm_unlink(struct snd_pcm_substream *substream)
/*
* hw configurator
*/
-static int snd_pcm_hw_rule_mul(struct snd_pcm_hw_params *params,
- struct snd_pcm_hw_rule *rule)
+static int snd_pcm_hw_rule_mul(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
{
struct snd_interval t;
+
snd_interval_mul(hw_param_interval_c(params, rule->deps[0]),
- hw_param_interval_c(params, rule->deps[1]), &t);
+ hw_param_interval_c(params, rule->deps[1]), &t);
return snd_interval_refine(hw_param_interval(params, rule->var), &t);
}
-static int snd_pcm_hw_rule_div(struct snd_pcm_hw_params *params,
- struct snd_pcm_hw_rule *rule)
+static int snd_pcm_hw_rule_div(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
{
struct snd_interval t;
+
snd_interval_div(hw_param_interval_c(params, rule->deps[0]),
- hw_param_interval_c(params, rule->deps[1]), &t);
+ hw_param_interval_c(params, rule->deps[1]), &t);
return snd_interval_refine(hw_param_interval(params, rule->var), &t);
}
-static int snd_pcm_hw_rule_muldivk(struct snd_pcm_hw_params *params,
- struct snd_pcm_hw_rule *rule)
+static int snd_pcm_hw_rule_muldivk(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
{
struct snd_interval t;
+
snd_interval_muldivk(hw_param_interval_c(params, rule->deps[0]),
- hw_param_interval_c(params, rule->deps[1]),
- (unsigned long) rule->private, &t);
+ hw_param_interval_c(params, rule->deps[1]),
+ (unsigned long)rule->private, &t);
return snd_interval_refine(hw_param_interval(params, rule->var), &t);
}
-static int snd_pcm_hw_rule_mulkdiv(struct snd_pcm_hw_params *params,
- struct snd_pcm_hw_rule *rule)
+static int snd_pcm_hw_rule_mulkdiv(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
{
struct snd_interval t;
+
snd_interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]),
- (unsigned long) rule->private,
- hw_param_interval_c(params, rule->deps[1]), &t);
+ (unsigned long)rule->private,
+ hw_param_interval_c(params, rule->deps[1]), &t);
return snd_interval_refine(hw_param_interval(params, rule->var), &t);
}
-static int snd_pcm_hw_rule_format(struct snd_pcm_hw_params *params,
- struct snd_pcm_hw_rule *rule)
+static int snd_pcm_hw_rule_format(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
{
snd_pcm_format_t k;
- const struct snd_interval *i =
- hw_param_interval_c(params, rule->deps[0]);
+ const struct snd_interval *i = hw_param_interval_c(params, rule->deps[0]);
struct snd_mask m;
struct snd_mask *mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
+
snd_mask_any(&m);
pcm_for_each_format(k) {
int bits;
+
if (!snd_mask_test_format(mask, k))
continue;
bits = snd_pcm_format_physical_width(k);
if (bits <= 0)
continue; /* ignore invalid formats */
- if ((unsigned)bits < i->min || (unsigned)bits > i->max)
- snd_mask_reset(&m, (__force unsigned)k);
+ if ((unsigned int)bits < i->min || (unsigned int)bits > i->max)
+ snd_mask_reset(&m, (__force unsigned int)k);
}
return snd_mask_refine(mask, &m);
}
@@ -2437,14 +2385,15 @@ static int snd_pcm_hw_rule_sample_bits(struct snd_pcm_hw_params *params,
t.openmax = 0;
pcm_for_each_format(k) {
int bits;
+
if (!snd_mask_test_format(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), k))
continue;
bits = snd_pcm_format_physical_width(k);
if (bits <= 0)
continue; /* ignore invalid formats */
- if (t.min > (unsigned)bits)
+ if (t.min > (unsigned int)bits)
t.min = bits;
- if (t.max < (unsigned)bits)
+ if (t.max < (unsigned int)bits)
t.max = bits;
}
t.integer = 1;
@@ -2465,27 +2414,28 @@ const struct snd_pcm_hw_constraint_list snd_pcm_known_rates = {
.list = rates,
};
-static int snd_pcm_hw_rule_rate(struct snd_pcm_hw_params *params,
- struct snd_pcm_hw_rule *rule)
+static int snd_pcm_hw_rule_rate(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
{
struct snd_pcm_hardware *hw = rule->private;
+
return snd_interval_list(hw_param_interval(params, rule->var),
snd_pcm_known_rates.count,
snd_pcm_known_rates.list, hw->rates);
-}
+}
static int snd_pcm_hw_rule_buffer_bytes_max(struct snd_pcm_hw_params *params,
struct snd_pcm_hw_rule *rule)
{
struct snd_interval t;
struct snd_pcm_substream *substream = rule->private;
+
t.min = 0;
t.max = substream->buffer_bytes_max;
t.openmin = 0;
t.openmax = 0;
t.integer = 1;
return snd_interval_refine(hw_param_interval(params, rule->var), &t);
-}
+}
static int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream)
{
@@ -2493,13 +2443,11 @@ static int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream)
struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
int k, err;
- for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++) {
+ for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++)
snd_mask_any(constrs_mask(constrs, k));
- }
- for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++) {
+ for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++)
snd_interval_any(constrs_interval(constrs, k));
- }
snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_CHANNELS));
snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_BUFFER_SIZE));
@@ -2508,103 +2456,115 @@ static int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream)
snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_FRAME_BITS));
err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
- snd_pcm_hw_rule_format, NULL,
+ snd_pcm_hw_rule_format, NULL,
SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
snd_pcm_hw_rule_sample_bits, NULL,
- SNDRV_PCM_HW_PARAM_FORMAT,
+ SNDRV_PCM_HW_PARAM_FORMAT,
SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
snd_pcm_hw_rule_div, NULL,
- SNDRV_PCM_HW_PARAM_FRAME_BITS, SNDRV_PCM_HW_PARAM_CHANNELS, -1);
+ SNDRV_PCM_HW_PARAM_FRAME_BITS,
+ SNDRV_PCM_HW_PARAM_CHANNELS, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS,
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS,
snd_pcm_hw_rule_mul, NULL,
- SNDRV_PCM_HW_PARAM_SAMPLE_BITS, SNDRV_PCM_HW_PARAM_CHANNELS, -1);
+ SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
+ SNDRV_PCM_HW_PARAM_CHANNELS, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS,
- snd_pcm_hw_rule_mulkdiv, (void*) 8,
- SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS,
+ snd_pcm_hw_rule_mulkdiv, (void *)8,
+ SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
+ SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS,
- snd_pcm_hw_rule_mulkdiv, (void*) 8,
- SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, -1);
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS,
+ snd_pcm_hw_rule_mulkdiv, (void *)8,
+ SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
+ SNDRV_PCM_HW_PARAM_BUFFER_SIZE, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
snd_pcm_hw_rule_div, NULL,
- SNDRV_PCM_HW_PARAM_FRAME_BITS, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
+ SNDRV_PCM_HW_PARAM_FRAME_BITS,
+ SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
- snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
- SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_PERIOD_TIME, -1);
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
+ snd_pcm_hw_rule_mulkdiv, (void *)1000000,
+ SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
+ SNDRV_PCM_HW_PARAM_PERIOD_TIME, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
- snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
- SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_BUFFER_TIME, -1);
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
+ snd_pcm_hw_rule_mulkdiv, (void *)1000000,
+ SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
+ SNDRV_PCM_HW_PARAM_BUFFER_TIME, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS,
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS,
snd_pcm_hw_rule_div, NULL,
- SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);
+ SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
+ SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
snd_pcm_hw_rule_div, NULL,
SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_PERIODS, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
- snd_pcm_hw_rule_mulkdiv, (void*) 8,
- SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
+ snd_pcm_hw_rule_mulkdiv, (void *)8,
+ SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
+ SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
- snd_pcm_hw_rule_muldivk, (void*) 1000000,
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
+ snd_pcm_hw_rule_muldivk, (void *)1000000,
SNDRV_PCM_HW_PARAM_PERIOD_TIME, SNDRV_PCM_HW_PARAM_RATE, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
snd_pcm_hw_rule_mul, NULL,
SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_PERIODS, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
- snd_pcm_hw_rule_mulkdiv, (void*) 8,
- SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
+ snd_pcm_hw_rule_mulkdiv, (void *)8,
+ SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
+ SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
- snd_pcm_hw_rule_muldivk, (void*) 1000000,
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
+ snd_pcm_hw_rule_muldivk, (void *)1000000,
SNDRV_PCM_HW_PARAM_BUFFER_TIME, SNDRV_PCM_HW_PARAM_RATE, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
- snd_pcm_hw_rule_muldivk, (void*) 8,
- SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
+ snd_pcm_hw_rule_muldivk, (void *)8,
+ SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
+ SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
- snd_pcm_hw_rule_muldivk, (void*) 8,
- SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
+ snd_pcm_hw_rule_muldivk, (void *)8,
+ SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
+ SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_TIME,
- snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_TIME,
+ snd_pcm_hw_rule_mulkdiv, (void *)1000000,
SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_RATE, -1);
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_TIME,
- snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_TIME,
+ snd_pcm_hw_rule_mulkdiv, (void *)1000000,
SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_RATE, -1);
if (err < 0)
return err;
@@ -2618,9 +2578,9 @@ static int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
int err;
unsigned int mask = 0;
- if (hw->info & SNDRV_PCM_INFO_INTERLEAVED)
+ if (hw->info & SNDRV_PCM_INFO_INTERLEAVED)
mask |= PARAM_MASK_BIT(SNDRV_PCM_ACCESS_RW_INTERLEAVED);
- if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED)
+ if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED)
mask |= PARAM_MASK_BIT(SNDRV_PCM_ACCESS_RW_NONINTERLEAVED);
if (hw_support_mmap(substream)) {
if (hw->info & SNDRV_PCM_INFO_INTERLEAVED)
@@ -2668,7 +2628,7 @@ static int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
if (err < 0)
return err;
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
snd_pcm_hw_rule_buffer_bytes_max, substream,
SNDRV_PCM_HW_PARAM_BUFFER_BYTES, -1);
if (err < 0)
@@ -2676,13 +2636,14 @@ static int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
/* FIXME: remove */
if (runtime->dma_bytes) {
- err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, runtime->dma_bytes);
+ err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
+ 0, runtime->dma_bytes);
if (err < 0)
return err;
}
if (!(hw->rates & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))) {
- err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
+ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
snd_pcm_hw_rule_rate, hw,
SNDRV_PCM_HW_PARAM_RATE, -1);
if (err < 0)
@@ -2724,8 +2685,7 @@ void snd_pcm_release_substream(struct snd_pcm_substream *substream)
}
EXPORT_SYMBOL(snd_pcm_release_substream);
-int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
- struct file *file,
+int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, struct file *file,
struct snd_pcm_substream **rsubstream)
{
struct snd_pcm_substream *substream;
@@ -2760,8 +2720,7 @@ int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
/* automatically set EXPLICIT_SYNC flag in the managed mode whenever
* the DMA buffer requires it
*/
- if (substream->managed_buffer_alloc &&
- substream->dma_buffer.dev.need_sync)
+ if (substream->managed_buffer_alloc && substream->dma_buffer.dev.need_sync)
substream->runtime->hw.info |= SNDRV_PCM_INFO_EXPLICIT_SYNC;
*rsubstream = substream;
@@ -2773,9 +2732,7 @@ int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
}
EXPORT_SYMBOL(snd_pcm_open_substream);
-static int snd_pcm_open_file(struct file *file,
- struct snd_pcm *pcm,
- int stream)
+static int snd_pcm_open_file(struct file *file, struct snd_pcm *pcm, int stream)
{
struct snd_pcm_file *pcm_file;
struct snd_pcm_substream *substream;
@@ -2786,7 +2743,7 @@ static int snd_pcm_open_file(struct file *file,
return err;
pcm_file = kzalloc(sizeof(*pcm_file), GFP_KERNEL);
- if (pcm_file == NULL) {
+ if (!pcm_file) {
snd_pcm_release_substream(substream);
return -ENOMEM;
}
@@ -2802,10 +2759,10 @@ static int snd_pcm_playback_open(struct inode *inode, struct file *file)
{
struct snd_pcm *pcm;
int err = nonseekable_open(inode, file);
+
if (err < 0)
return err;
- pcm = snd_lookup_minor_data(iminor(inode),
- SNDRV_DEVICE_TYPE_PCM_PLAYBACK);
+ pcm = snd_lookup_minor_data(iminor(inode), SNDRV_DEVICE_TYPE_PCM_PLAYBACK);
err = snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_PLAYBACK);
if (pcm)
snd_card_unref(pcm->card);
@@ -2816,10 +2773,10 @@ static int snd_pcm_capture_open(struct inode *inode, struct file *file)
{
struct snd_pcm *pcm;
int err = nonseekable_open(inode, file);
+
if (err < 0)
return err;
- pcm = snd_lookup_minor_data(iminor(inode),
- SNDRV_DEVICE_TYPE_PCM_CAPTURE);
+ pcm = snd_lookup_minor_data(iminor(inode), SNDRV_DEVICE_TYPE_PCM_CAPTURE);
err = snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_CAPTURE);
if (pcm)
snd_card_unref(pcm->card);
@@ -2831,7 +2788,7 @@ static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream)
int err;
wait_queue_entry_t wait;
- if (pcm == NULL) {
+ if (!pcm) {
err = -ENODEV;
goto __error1;
}
@@ -2854,8 +2811,9 @@ static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream)
err = -EBUSY;
break;
}
- } else
+ } else {
break;
+ }
set_current_state(TASK_INTERRUPTIBLE);
mutex_unlock(&pcm->open_mutex);
schedule();
@@ -2875,12 +2833,12 @@ static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream)
goto __error;
return err;
- __error:
+__error:
module_put(pcm->card->module);
- __error2:
- snd_card_file_remove(pcm->card, file);
- __error1:
- return err;
+__error2:
+ snd_card_file_remove(pcm->card, file);
+__error1:
+ return err;
}
static int snd_pcm_release(struct inode *inode, struct file *file)
@@ -2935,7 +2893,7 @@ static int do_pcm_hwsync(struct snd_pcm_substream *substream)
/* increase the appl_ptr; returns the processed frames or a negative error */
static snd_pcm_sframes_t forward_appl_ptr(struct snd_pcm_substream *substream,
snd_pcm_uframes_t frames,
- snd_pcm_sframes_t avail)
+ snd_pcm_sframes_t avail)
{
struct snd_pcm_runtime *runtime = substream->runtime;
snd_pcm_sframes_t appl_ptr;
@@ -2988,8 +2946,7 @@ static snd_pcm_sframes_t snd_pcm_rewind(struct snd_pcm_substream *substream,
snd_pcm_stream_lock_irq(substream);
ret = do_pcm_hwsync(substream);
if (!ret)
- ret = rewind_appl_ptr(substream, frames,
- snd_pcm_hw_avail(substream));
+ ret = rewind_appl_ptr(substream, frames, snd_pcm_hw_avail(substream));
snd_pcm_stream_unlock_irq(substream);
if (ret >= 0)
snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_DEVICE);
@@ -3007,16 +2964,14 @@ static snd_pcm_sframes_t snd_pcm_forward(struct snd_pcm_substream *substream,
snd_pcm_stream_lock_irq(substream);
ret = do_pcm_hwsync(substream);
if (!ret)
- ret = forward_appl_ptr(substream, frames,
- snd_pcm_avail(substream));
+ ret = forward_appl_ptr(substream, frames, snd_pcm_avail(substream));
snd_pcm_stream_unlock_irq(substream);
if (ret >= 0)
snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_DEVICE);
return ret;
}
-static int snd_pcm_delay(struct snd_pcm_substream *substream,
- snd_pcm_sframes_t *delay)
+static int snd_pcm_delay(struct snd_pcm_substream *substream, snd_pcm_sframes_t *delay)
{
int err;
@@ -3029,7 +2984,7 @@ static int snd_pcm_delay(struct snd_pcm_substream *substream,
return err;
}
-
+
static inline int snd_pcm_hwsync(struct snd_pcm_substream *substream)
{
return snd_pcm_delay(substream, NULL);
@@ -3045,10 +3000,11 @@ static int snd_pcm_sync_ptr(struct snd_pcm_substream *substream,
int err;
memset(&sync_ptr, 0, sizeof(sync_ptr));
- if (get_user(sync_ptr.flags, (unsigned __user *)&(_sync_ptr->flags)))
+ if (get_user(sync_ptr.flags, (unsigned __user *)&_sync_ptr->flags))
+ return -EFAULT;
+ if (copy_from_user(&sync_ptr.c.control, &_sync_ptr->c.control,
+ sizeof(struct snd_pcm_mmap_control)))
return -EFAULT;
- if (copy_from_user(&sync_ptr.c.control, &(_sync_ptr->c.control), sizeof(struct snd_pcm_mmap_control)))
- return -EFAULT;
status = runtime->status;
control = runtime->control;
if (sync_ptr.flags & SNDRV_PCM_SYNC_PTR_HWSYNC) {
@@ -3058,8 +3014,7 @@ static int snd_pcm_sync_ptr(struct snd_pcm_substream *substream,
}
snd_pcm_stream_lock_irq(substream);
if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_APPL)) {
- err = pcm_lib_apply_appl_ptr(substream,
- sync_ptr.c.control.appl_ptr);
+ err = pcm_lib_apply_appl_ptr(substream, sync_ptr.c.control.appl_ptr);
if (err < 0) {
snd_pcm_stream_unlock_irq(substream);
return err;
@@ -3093,7 +3048,7 @@ struct snd_pcm_mmap_status32 {
snd_pcm_state_t suspended_state;
s32 audio_tstamp_sec;
s32 audio_tstamp_nsec;
-} __attribute__((packed));
+} __packed;
struct snd_pcm_mmap_control32 {
u32 appl_ptr;
@@ -3110,14 +3065,14 @@ struct snd_pcm_sync_ptr32 {
struct snd_pcm_mmap_control32 control;
unsigned char reserved[64];
} c;
-} __attribute__((packed));
+} __packed;
/* recalcuate the boundary within 32bit */
static snd_pcm_uframes_t recalculate_boundary(struct snd_pcm_runtime *runtime)
{
snd_pcm_uframes_t boundary;
- if (! runtime->buffer_size)
+ if (!runtime->buffer_size)
return 0;
boundary = runtime->buffer_size;
while (boundary * 2 <= 0x7fffffffUL - runtime->buffer_size)
@@ -3152,19 +3107,19 @@ static int snd_pcm_ioctl_sync_ptr_compat(struct snd_pcm_substream *substream,
status = runtime->status;
control = runtime->control;
boundary = recalculate_boundary(runtime);
- if (! boundary)
+ if (!boundary)
boundary = 0x7fffffff;
snd_pcm_stream_lock_irq(substream);
/* FIXME: we should consider the boundary for the sync from app */
if (!(sflags & SNDRV_PCM_SYNC_PTR_APPL)) {
- err = pcm_lib_apply_appl_ptr(substream,
- scontrol.appl_ptr);
+ err = pcm_lib_apply_appl_ptr(substream, scontrol.appl_ptr);
if (err < 0) {
snd_pcm_stream_unlock_irq(substream);
return err;
}
- } else
+ } else {
scontrol.appl_ptr = control->appl_ptr % boundary;
+ }
if (!(sflags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN))
control->avail_min = scontrol.avail_min;
else
@@ -3190,13 +3145,14 @@ static int snd_pcm_ioctl_sync_ptr_compat(struct snd_pcm_substream *substream,
return 0;
}
+
#define __SNDRV_PCM_IOCTL_SYNC_PTR32 _IOWR('A', 0x23, struct snd_pcm_sync_ptr32)
static int snd_pcm_tstamp(struct snd_pcm_substream *substream, int __user *_arg)
{
struct snd_pcm_runtime *runtime = substream->runtime;
int arg;
-
+
if (get_user(arg, _arg))
return -EFAULT;
if (arg < 0 || arg > SNDRV_PCM_TSTAMP_TYPE_LAST)
@@ -3290,8 +3246,8 @@ static int snd_pcm_forward_ioctl(struct snd_pcm_substream *substream,
}
static int snd_pcm_common_ioctl(struct file *file,
- struct snd_pcm_substream *substream,
- unsigned int cmd, void __user *arg)
+ struct snd_pcm_substream *substream,
+ unsigned int cmd, void __user *arg)
{
struct snd_pcm_file *pcm_file = file->private_data;
int res;
@@ -3316,8 +3272,7 @@ static int snd_pcm_common_ioctl(struct file *file,
case SNDRV_PCM_IOCTL_TTSTAMP:
return snd_pcm_tstamp(substream, arg);
case SNDRV_PCM_IOCTL_USER_PVERSION:
- if (get_user(pcm_file->user_pversion,
- (unsigned int __user *)arg))
+ if (get_user(pcm_file->user_pversion, (unsigned int __user *)arg))
return -EFAULT;
return 0;
case SNDRV_PCM_IOCTL_HW_REFINE:
@@ -3345,7 +3300,7 @@ static int snd_pcm_common_ioctl(struct file *file,
case SNDRV_PCM_IOCTL_START:
return snd_pcm_start_lock_irq(substream);
case SNDRV_PCM_IOCTL_LINK:
- return snd_pcm_link(substream, (int)(unsigned long) arg);
+ return snd_pcm_link(substream, (int)(unsigned long)arg);
case SNDRV_PCM_IOCTL_UNLINK:
return snd_pcm_unlink(substream);
case SNDRV_PCM_IOCTL_RESUME:
@@ -3398,8 +3353,7 @@ static int snd_pcm_common_ioctl(struct file *file,
return -ENOTTY;
}
-static long snd_pcm_ioctl(struct file *file, unsigned int cmd,
- unsigned long arg)
+static long snd_pcm_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct snd_pcm_file *pcm_file;
@@ -3408,8 +3362,7 @@ static long snd_pcm_ioctl(struct file *file, unsigned int cmd,
if (((cmd >> 8) & 0xff) != 'A')
return -ENOTTY;
- return snd_pcm_common_ioctl(file, pcm_file->substream, cmd,
- (void __user *)arg);
+ return snd_pcm_common_ioctl(file, pcm_file->substream, cmd, (void __user *)arg);
}
/**
@@ -3424,12 +3377,11 @@ static long snd_pcm_ioctl(struct file *file, unsigned int cmd,
*
* Return: zero if successful, or a negative error code
*/
-int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream,
- unsigned int cmd, void *arg)
+int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg)
{
snd_pcm_uframes_t *frames = arg;
snd_pcm_sframes_t result;
-
+
if (substream->runtime->state == SNDRV_PCM_STATE_DISCONNECTED)
return -EBADFD;
@@ -3462,8 +3414,7 @@ int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream,
}
EXPORT_SYMBOL(snd_pcm_kernel_ioctl);
-static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count,
- loff_t * offset)
+static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
{
struct snd_pcm_file *pcm_file;
struct snd_pcm_substream *substream;
@@ -3488,7 +3439,7 @@ static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count,
}
static ssize_t snd_pcm_write(struct file *file, const char __user *buf,
- size_t count, loff_t * offset)
+ size_t count, loff_t *offset)
{
struct snd_pcm_file *pcm_file;
struct snd_pcm_substream *substream;
@@ -3539,7 +3490,7 @@ static ssize_t snd_pcm_readv(struct kiocb *iocb, struct iov_iter *to)
return -EINVAL;
frames = bytes_to_samples(runtime, iov->iov_len);
bufs = kmalloc_array(to->nr_segs, sizeof(void *), GFP_KERNEL);
- if (bufs == NULL)
+ if (!bufs)
return -ENOMEM;
for (i = 0; i < to->nr_segs; ++i) {
bufs[i] = iov->iov_base;
@@ -3578,7 +3529,7 @@ static ssize_t snd_pcm_writev(struct kiocb *iocb, struct iov_iter *from)
return -EINVAL;
frames = bytes_to_samples(runtime, iov->iov_len);
bufs = kmalloc_array(from->nr_segs, sizeof(void *), GFP_KERNEL);
- if (bufs == NULL)
+ if (!bufs)
return -ENOMEM;
for (i = 0; i < from->nr_segs; ++i) {
bufs[i] = iov->iov_base;
@@ -3656,8 +3607,8 @@ static vm_fault_t snd_pcm_mmap_status_fault(struct vm_fault *vmf)
{
struct snd_pcm_substream *substream = vmf->vma->vm_private_data;
struct snd_pcm_runtime *runtime;
-
- if (substream == NULL)
+
+ if (!substream)
return VM_FAULT_SIGBUS;
runtime = substream->runtime;
vmf->page = virt_to_page(runtime->status);
@@ -3665,8 +3616,7 @@ static vm_fault_t snd_pcm_mmap_status_fault(struct vm_fault *vmf)
return 0;
}
-static const struct vm_operations_struct snd_pcm_vm_ops_status =
-{
+static const struct vm_operations_struct snd_pcm_vm_ops_status = {
.fault = snd_pcm_mmap_status_fault,
};
@@ -3674,6 +3624,7 @@ static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file
struct vm_area_struct *area)
{
long size;
+
if (!(area->vm_flags & VM_READ))
return -EINVAL;
size = area->vm_end - area->vm_start;
@@ -3681,8 +3632,7 @@ static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file
return -EINVAL;
area->vm_ops = &snd_pcm_vm_ops_status;
area->vm_private_data = substream;
- vm_flags_mod(area, VM_DONTEXPAND | VM_DONTDUMP,
- VM_WRITE | VM_MAYWRITE);
+ vm_flags_mod(area, VM_DONTEXPAND | VM_DONTDUMP, VM_WRITE | VM_MAYWRITE);
return 0;
}
@@ -3694,8 +3644,8 @@ static vm_fault_t snd_pcm_mmap_control_fault(struct vm_fault *vmf)
{
struct snd_pcm_substream *substream = vmf->vma->vm_private_data;
struct snd_pcm_runtime *runtime;
-
- if (substream == NULL)
+
+ if (!substream)
return VM_FAULT_SIGBUS;
runtime = substream->runtime;
vmf->page = virt_to_page(runtime->control);
@@ -3703,8 +3653,7 @@ static vm_fault_t snd_pcm_mmap_control_fault(struct vm_fault *vmf)
return 0;
}
-static const struct vm_operations_struct snd_pcm_vm_ops_control =
-{
+static const struct vm_operations_struct snd_pcm_vm_ops_control = {
.fault = snd_pcm_mmap_control_fault,
};
@@ -3712,6 +3661,7 @@ static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file
struct vm_area_struct *area)
{
long size;
+
if (!(area->vm_flags & VM_READ))
return -EINVAL;
size = area->vm_end - area->vm_start;
@@ -3769,11 +3719,13 @@ static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file
{
return -ENXIO;
}
+
static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file,
struct vm_area_struct *area)
{
return -ENXIO;
}
+
#endif /* coherent mmap */
/*
@@ -3784,10 +3736,10 @@ static vm_fault_t snd_pcm_mmap_data_fault(struct vm_fault *vmf)
struct snd_pcm_substream *substream = vmf->vma->vm_private_data;
struct snd_pcm_runtime *runtime;
unsigned long offset;
- struct page * page;
+ struct page *page;
size_t dma_bytes;
-
- if (substream == NULL)
+
+ if (!substream)
return VM_FAULT_SIGBUS;
runtime = substream->runtime;
offset = vmf->pgoff << PAGE_SHIFT;
@@ -3884,7 +3836,7 @@ int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file,
int err;
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
- if (!(area->vm_flags & (VM_WRITE|VM_READ)))
+ if (!(area->vm_flags & (VM_WRITE | VM_READ)))
return -EINVAL;
} else {
if (!(area->vm_flags & VM_READ))
@@ -3920,10 +3872,10 @@ 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;
- struct snd_pcm_substream *substream;
+ struct snd_pcm_file *pcm_file;
+ struct snd_pcm_substream *substream;
unsigned long offset;
-
+
pcm_file = file->private_data;
substream = pcm_file->substream;
if (PCM_RUNTIME_CHECK(substream))
@@ -3955,9 +3907,9 @@ static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area)
return 0;
}
-static int snd_pcm_fasync(int fd, struct file * file, int on)
+static int snd_pcm_fasync(int fd, struct file *file, int on)
{
- struct snd_pcm_file * pcm_file;
+ struct snd_pcm_file *pcm_file;
struct snd_pcm_substream *substream;
struct snd_pcm_runtime *runtime;
@@ -3985,8 +3937,8 @@ static int snd_pcm_fasync(int fd, struct file * file, int on)
*/
#ifdef CONFIG_SND_SUPPORT_OLD_API
-#define __OLD_TO_NEW_MASK(x) ((x&7)|((x&0x07fffff8)<<5))
-#define __NEW_TO_OLD_MASK(x) ((x&7)|((x&0xffffff00)>>5))
+#define __OLD_TO_NEW_MASK(x) ((x & 7) | ((x & 0x07fffff8) << 5))
+#define __NEW_TO_OLD_MASK(x) ((x & 7) | ((x & 0xffffff00) >> 5))
static void snd_pcm_hw_convert_from_old_params(struct snd_pcm_hw_params *params,
struct snd_pcm_hw_params_old *oparams)
@@ -4027,7 +3979,7 @@ static void snd_pcm_hw_convert_to_old_params(struct snd_pcm_hw_params_old *opara
}
static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream,
- struct snd_pcm_hw_params_old __user * _oparams)
+ struct snd_pcm_hw_params_old __user *_oparams)
{
struct snd_pcm_hw_params *params;
struct snd_pcm_hw_params_old *oparams = NULL;
@@ -4062,7 +4014,7 @@ static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream,
}
static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream,
- struct snd_pcm_hw_params_old __user * _oparams)
+ struct snd_pcm_hw_params_old __user *_oparams)
{
struct snd_pcm_hw_params *params;
struct snd_pcm_hw_params_old *oparams = NULL;
@@ -4095,10 +4047,8 @@ static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream,
#endif /* CONFIG_SND_SUPPORT_OLD_API */
#ifndef CONFIG_MMU
-static unsigned long snd_pcm_get_unmapped_area(struct file *file,
- unsigned long addr,
- unsigned long len,
- unsigned long pgoff,
+static unsigned long snd_pcm_get_unmapped_area(struct file *file, unsigned long addr,
+ unsigned long len, unsigned long pgoff,
unsigned long flags)
{
struct snd_pcm_file *pcm_file = file->private_data;
@@ -4133,7 +4083,7 @@ const struct file_operations snd_pcm_f_ops[2] = {
.llseek = no_llseek,
.poll = snd_pcm_poll,
.unlocked_ioctl = snd_pcm_ioctl,
- .compat_ioctl = snd_pcm_ioctl_compat,
+ .compat_ioctl = snd_pcm_ioctl_compat,
.mmap = snd_pcm_mmap,
.fasync = snd_pcm_fasync,
.get_unmapped_area = snd_pcm_get_unmapped_area,
@@ -4147,7 +4097,7 @@ const struct file_operations snd_pcm_f_ops[2] = {
.llseek = no_llseek,
.poll = snd_pcm_poll,
.unlocked_ioctl = snd_pcm_ioctl,
- .compat_ioctl = snd_pcm_ioctl_compat,
+ .compat_ioctl = snd_pcm_ioctl_compat,
.mmap = snd_pcm_mmap,
.fasync = snd_pcm_fasync,
.get_unmapped_area = snd_pcm_get_unmapped_area,
--
2.34.1
