From nobody Wed Feb 11 09:19:14 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 635A7C77B7D for ; Wed, 10 May 2023 07:27:58 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235195AbjEJH15 (ORCPT ); Wed, 10 May 2023 03:27:57 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:51608 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229941AbjEJH1w (ORCPT ); Wed, 10 May 2023 03:27:52 -0400 Received: from mail-ej1-x62c.google.com (mail-ej1-x62c.google.com [IPv6:2a00:1450:4864:20::62c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id AF677269E for ; Wed, 10 May 2023 00:27:47 -0700 (PDT) Received: by mail-ej1-x62c.google.com with SMTP id a640c23a62f3a-94f9cd65b1aso174310866b.0 for ; Wed, 10 May 2023 00:27:47 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20221208; t=1683703666; x=1686295666; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:from:to:cc:subject:date:message-id:reply-to; bh=5bNmaOH8hOKe+FXV9PlkqBsS7yyFGYnM5fSqJc6Zg8M=; b=DADDkOfmdzlakx1m9/PHB5TvV7043KRI3nQbryC6PTQO+agp0OMGan2sxKWoRt29vu E/Xa/4Hj/rVnvPfF9bS3QKXFviPrfbs0TO6xQvI36EuyqFXTmc1HciyIx3IorJKf81OM GSv2N4uIIJFh6yvia3vzuYeFragM1B4+L9arMEck3tDQarptAUItVA2PdQAo4B7zidx6 EmrpGbz+QrUIdy30JtfQ0G3fME2WWqFmHo7ufr/TeGNQZdB0tgtBAH81ry574tF7qeoB 5a/XFs1o779kDbLR7WI9CgJxCT5KaMeaT1hs9VoSWSd7AirLpX8kfWYm+TPlKcZ93snp Z9Iw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1683703666; x=1686295666; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=5bNmaOH8hOKe+FXV9PlkqBsS7yyFGYnM5fSqJc6Zg8M=; b=j2YsUGZYWBvNm9BnuLt4Rv1N0IBKfN+xEZ4Ralg3EfkqPzujzwVw7OZifTjJLIXSas hObZh4pOoRNKYWLXGmvCb7aFjp3sOPqKHCM6ouXoVtyLBnEWN3Vv4aYkVPxMQtb3JfSo F1GjSIRaNoNIHpIFFsrNGjFSZ1PVfe3LKwxSGDPEQi0YJ3YL2uVOBR2HILb6LSby4xiJ Ue4FMa+9k5w+4cAdPwC5H682go8TOp6T+lqbzhhu+oxJf9GQFNIoVXAZT17b869cSeNV xVjkUMzv+eikueBeSaIH3ky8cfUCwB6OOyjn4hWlZZKpL5rNioT2wGS6GwHrXYEZzrFL QPJA== X-Gm-Message-State: AC+VfDxE73QT/mzApHf6lLuQys/BznJXUAystBj8Hu009g8BFAyfZ3EX erjXmOdkx5jmzhjfMgFg7Do= X-Google-Smtp-Source: ACHHUZ74x5zId9k1FmoJ6qedrP7LlwbyfJ1iMt9aHaEQxyIFsIu5WeFwJDOxoKGAsX4Uv+UvxO0jrw== X-Received: by 2002:a17:906:2252:b0:965:bc62:fe38 with SMTP id 18-20020a170906225200b00965bc62fe38mr14117843ejr.7.1683703665665; Wed, 10 May 2023 00:27:45 -0700 (PDT) Received: from ivan-HLYL-WXX9.. ([37.252.94.55]) by smtp.gmail.com with ESMTPSA id y10-20020a170906914a00b009663cf5dc3bsm2280209ejw.53.2023.05.10.00.27.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 10 May 2023 00:27:45 -0700 (PDT) From: Ivan Orlov To: perex@perex.cz, tiwai@suse.com, oswald.buddenhagen@gmx.de, axboe@kernel.dk, 42.hyeyoo@gmail.com, surenb@google.com Cc: Ivan Orlov , alsa-devel@alsa-project.org, linux-kernel@vger.kernel.org, skhan@linuxfoundation.org, himadrispandya@gmail.com, linux-kernel-mentees@lists.linuxfoundation.org Subject: [PATCH] ALSA: PCM: Fix codestyle issues in pcm_native.c Date: Wed, 10 May 2023 11:27:26 +0400 Message-Id: <20230510072726.435247-1-ivan.orlov0322@gmail.com> X-Mailer: git-send-email 2.34.1 MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" 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 --- 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 @@ =20 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_ACCE= SS + 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_p= arams_old) =20 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= ); =20 @@ -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); =20 @@ -164,6 +162,7 @@ EXPORT_SYMBOL_GPL(snd_pcm_stream_unlock_irq); unsigned long _snd_pcm_stream_lock_irqsave(struct snd_pcm_substream *subst= ream) { unsigned long flags =3D 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 =3D 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_DEPT= H_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_su= bstream *substream, EXPORT_SYMBOL_GPL(snd_pcm_stream_unlock_irqrestore); =20 /* 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; } =20 -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; =20 info =3D kmalloc(sizeof(*info), GFP_KERNEL); - if (! info) + if (!info) return -ENOMEM; err =3D snd_pcm_info(substream, info); if (err >=3D 0) { @@ -284,8 +279,7 @@ static bool hw_support_mmap(struct snd_pcm_substream *s= ubstream) static int constrain_mask_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params) { - struct snd_pcm_hw_constraints *constrs =3D - &substream->runtime->hw_constraints; + struct snd_pcm_hw_constraints *constrs =3D &substream->runtime->hw_constr= aints; 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_substre= am *substream, static int constrain_interval_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params) { - struct snd_pcm_hw_constraints *constrs =3D - &substream->runtime->hw_constraints; + struct snd_pcm_hw_constraints *constrs =3D &substream->runtime->hw_constr= aints; 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_sub= stream *substream, static int constrain_params_by_rules(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params) { - struct snd_pcm_hw_constraints *constrs =3D - &substream->runtime->hw_constraints; + struct snd_pcm_hw_constraints *constrs =3D &substream->runtime->hw_constr= aints; 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_s= ubstream *substream, */ if (changed && r->var >=3D 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)); } =20 params->cmask |=3D PARAM_MASK_BIT(r->var); @@ -509,18 +499,15 @@ static int fixup_unreferenced_params(struct snd_pcm_s= ubstream *substream, =20 if (!params->info) { params->info =3D substream->runtime->hw.info; - params->info &=3D ~(SNDRV_PCM_INFO_FIFO_IN_FRAMES | - SNDRV_PCM_INFO_DRAIN_TRIGGER); + params->info &=3D ~(SNDRV_PCM_INFO_FIFO_IN_FRAMES | SNDRV_PCM_INFO_DRAIN= _TRIGGER); if (!hw_support_mmap(substream)) - params->info &=3D ~(SNDRV_PCM_INFO_MMAP | - SNDRV_PCM_INFO_MMAP_VALID); + params->info &=3D ~(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID); } =20 return 0; } =20 -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; =20 @@ -552,7 +539,7 @@ int snd_pcm_hw_refine(struct snd_pcm_substream *substre= am, EXPORT_SYMBOL(snd_pcm_hw_refine); =20 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 *runt= ime) { int usecs; =20 - if (! runtime->rate) + if (!runtime->rate) return -1; /* invalid */ =20 /* take 75% of period time as the deadline */ @@ -591,8 +578,7 @@ static int period_to_usecs(struct snd_pcm_runtime *runt= ime) return usecs; } =20 -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 !=3D SNDRV_PCM_STATE_DISCONNECTED) @@ -600,13 +586,11 @@ static void snd_pcm_set_state(struct snd_pcm_substrea= m *substream, snd_pcm_stream_unlock_irq(substream); } =20 -static inline void snd_pcm_timer_notify(struct snd_pcm_substream *substrea= m, - int event) +static inline void snd_pcm_timer_notify(struct snd_pcm_substream *substrea= m, 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_t= stamp); #endif } =20 @@ -672,10 +656,8 @@ static int snd_pcm_hw_params_choose(struct snd_pcm_sub= stream *pcm, continue; =20 /* 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; =20 if (substream->managed_buffer_alloc) { - err =3D snd_pcm_lib_malloc_pages(substream, - params_buffer_bytes(params)); + err =3D snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params)); if (err < 0) goto _error; runtime->buffer_changed =3D err > 0; } =20 - if (substream->ops->hw_params !=3D NULL) { + if (substream->ops->hw_params) { err =3D 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 =3D params->info; runtime->rate_num =3D params->rate_num; runtime->rate_den =3D params->rate_den; - runtime->no_period_wakeup =3D - (params->info & SNDRV_PCM_INFO_NO_PERIOD_WAKEUP) && - (params->flags & SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP); + runtime->no_period_wakeup =3D (params->info & SNDRV_PCM_INFO_NO_PERIOD_WA= KEUP) && + (params->flags & SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP); =20 bits =3D snd_pcm_format_physical_width(runtime->format); runtime->sample_bits =3D 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 =3D period_to_usecs(runtime); if (usecs >=3D 0) - cpu_latency_qos_add_request(&substream->latency_pm_qos_req, - usecs); + cpu_latency_qos_add_request(&substream->latency_pm_qos_req, usecs); err =3D 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 !=3D 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, } =20 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 =3D params->stop_threshold; runtime->silence_threshold =3D params->silence_threshold; runtime->silence_size =3D params->silence_size; - params->boundary =3D runtime->boundary; + params->boundary =3D runtime->boundary; if (snd_pcm_running(substream)) { - if (substream->stream =3D=3D SNDRV_PCM_STREAM_PLAYBACK && - runtime->silence_size > 0) + if (substream->stream =3D=3D SNDRV_PCM_STREAM_PLAYBACK && runtime->silen= ce_size > 0) snd_pcm_playback_silence(substream, ULONG_MAX); err =3D snd_pcm_update_state(substream, runtime); } @@ -966,10 +944,11 @@ static int snd_pcm_sw_params(struct snd_pcm_substream= *substream, } =20 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 =3D snd_pcm_sw_params(substream, ¶ms); @@ -978,8 +957,7 @@ static int snd_pcm_sw_params_user(struct snd_pcm_substr= eam *substream, return err; } =20 -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_substrea= m *substream) { snd_pcm_uframes_t delay; =20 @@ -990,15 +968,14 @@ snd_pcm_calc_delay(struct snd_pcm_substream *substrea= m) return delay + substream->runtime->delay; } =20 -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_s= tatus64 *status) { struct snd_pcm_runtime *runtime =3D substream->runtime; =20 snd_pcm_stream_lock_irq(substream); =20 snd_pcm_unpack_audio_tstamp_config(status->audio_tstamp_data, - &runtime->audio_tstamp_config); + &runtime->audio_tstamp_config); =20 /* backwards compatible behavior */ if (runtime->audio_tstamp_config.type_requested =3D=3D @@ -1010,8 +987,9 @@ int snd_pcm_status64(struct snd_pcm_substream *substre= am, runtime->audio_tstamp_config.type_requested =3D SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT; runtime->audio_tstamp_report.valid =3D 0; - } else + } else { runtime->audio_tstamp_report.valid =3D 1; + } =20 status->state =3D runtime->state; status->suspended_state =3D runtime->suspended_state; @@ -1036,8 +1014,8 @@ int snd_pcm_status64(struct snd_pcm_substream *substr= eam, if (runtime->audio_tstamp_report.valid =3D=3D 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); =20 goto _tstamp_end; } @@ -1055,19 +1033,18 @@ int snd_pcm_status64(struct snd_pcm_substream *subs= tream, status->appl_ptr =3D runtime->control->appl_ptr; status->hw_ptr =3D runtime->status->hw_ptr; status->avail =3D snd_pcm_avail(substream); - status->delay =3D snd_pcm_running(substream) ? - snd_pcm_calc_delay(substream) : 0; + status->delay =3D snd_pcm_running(substream) ? snd_pcm_calc_delay(substre= am) : 0; status->avail_max =3D runtime->avail_max; status->overrange =3D runtime->overrange; runtime->avail_max =3D 0; runtime->overrange =3D 0; - _end: - snd_pcm_stream_unlock_irq(substream); +_end: + snd_pcm_stream_unlock_irq(substream); return 0; } =20 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_subst= ream *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->aud= io_tstamp_data)) return -EFAULT; res =3D snd_pcm_status64(substream, &status); if (res < 0) @@ -1091,7 +1067,7 @@ static int snd_pcm_status_user64(struct snd_pcm_subst= ream *substream, } =20 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_subst= ream *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->a= udio_tstamp_data)) return -EFAULT; res =3D snd_pcm_status64(substream, &status64); if (res < 0) @@ -1140,11 +1115,11 @@ static int snd_pcm_status_user32(struct snd_pcm_sub= stream *substream, } =20 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; -=09 + channel =3D info->channel; runtime =3D substream->runtime; snd_pcm_stream_lock_irq(substream); @@ -1161,11 +1136,11 @@ static int snd_pcm_channel_info(struct snd_pcm_subs= tream *substream, } =20 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; -=09 + if (copy_from_user(&info, _info, sizeof(info))) return -EFAULT; res =3D snd_pcm_channel_info(substream, &info); @@ -1179,7 +1154,8 @@ static int snd_pcm_channel_info_user(struct snd_pcm_s= ubstream *substream, static void snd_pcm_trigger_tstamp(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime =3D substream->runtime; - if (runtime->trigger_master =3D=3D NULL) + + if (!runtime->trigger_master) return; if (runtime->trigger_master =3D=3D substream) { if (!runtime->trigger_tstamp_latched) @@ -1191,17 +1167,13 @@ static void snd_pcm_trigger_tstamp(struct snd_pcm_s= ubstream *substream) runtime->trigger_master =3D NULL; } =20 -#define ACTION_ARG_IGNORE (__force snd_pcm_state_t)0 +#define ACTION_ARG_IGNORE ((__force snd_pcm_state_t)0) =20 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 st= ate); + int (*do_action)(struct snd_pcm_substream *substream, snd_pcm_state_t sta= te); + 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); }; =20 /* @@ -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_p= cm_substream *substream, + snd_pcm_state_t state, bool stream_lock) { struct snd_pcm_substream *s =3D 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; -=09 + res =3D ops->pre_action(substream, state); if (res < 0) return res; @@ -1297,8 +1267,7 @@ static void snd_pcm_group_assign(struct snd_pcm_subst= ream *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_pc= m_substream *substream) { bool do_free; =20 @@ -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_subst= ream *substream) { bool nonatomic =3D substream->pcm->nonatomic; struct snd_pcm_group *group; @@ -1328,8 +1296,7 @@ snd_pcm_stream_group_ref(struct snd_pcm_substream *su= bstream) /* block freeing the group object */ refcount_inc(&group->refs); =20 - trylock =3D nonatomic ? mutex_trylock(&group->mutex) : - spin_trylock(&group->lock); + trylock =3D nonatomic ? mutex_trylock(&group->mutex) : spin_trylock(&gro= up->lock); if (trylock) break; /* OK */ =20 @@ -1411,10 +1378,10 @@ static int snd_pcm_pre_start(struct snd_pcm_substre= am *substream, snd_pcm_state_t state) { struct snd_pcm_runtime *runtime =3D substream->runtime; + if (runtime->state !=3D SNDRV_PCM_STATE_PREPARED) return -EBADFD; - if (substream->stream =3D=3D SNDRV_PCM_STREAM_PLAYBACK && - !snd_pcm_playback_data(substream)) + if (substream->stream =3D=3D SNDRV_PCM_STREAM_PLAYBACK && !snd_pcm_playba= ck_data(substream)) return -EPIPE; runtime->trigger_tstamp_latched =3D false; runtime->trigger_master =3D substream; @@ -1448,13 +1415,12 @@ static void snd_pcm_post_start(struct snd_pcm_subst= ream *substream, snd_pcm_state_t state) { struct snd_pcm_runtime *runtime =3D substream->runtime; + snd_pcm_trigger_tstamp(substream); runtime->hw_ptr_jiffies =3D jiffies; - runtime->hw_ptr_buffer_jiffies =3D (runtime->buffer_size * HZ) /=20 - runtime->rate; + runtime->hw_ptr_buffer_jiffies =3D (runtime->buffer_size * HZ) / runtime-= >rate; __snd_pcm_set_state(runtime, state); - if (substream->stream =3D=3D SNDRV_PCM_STREAM_PLAYBACK && - runtime->silence_size > 0) + if (substream->stream =3D=3D SNDRV_PCM_STREAM_PLAYBACK && runtime->silenc= e_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= =3D { */ 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_R= UNNING); } =20 /* 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_PC= M_STATE_RUNNING); } =20 /* @@ -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 =3D substream->runtime; + if (runtime->state =3D=3D SNDRV_PCM_STATE_OPEN) return -EBADFD; runtime->trigger_master =3D 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 =3D=3D substream && - snd_pcm_running(substream)) { + if (substream->runtime->trigger_master =3D=3D substream && snd_pcm_runnin= g(substream)) { substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_STOP); substream->runtime->stop_operating =3D true; } @@ -1514,6 +1478,7 @@ static void snd_pcm_post_stop(struct snd_pcm_substrea= m *substream, snd_pcm_state_t state) { struct snd_pcm_runtime *runtime =3D substream->runtime; + if (runtime->state !=3D 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_S= TATE_SETUP); } =20 /** @@ -1583,19 +1547,20 @@ EXPORT_SYMBOL_GPL(snd_pcm_stop_xrun); /* * pause callbacks: pass boolean (to start pause or resume) as state argum= ent */ -#define pause_pushed(state) (__force bool)(state) +#define pause_pushed(state) ((__force bool)(state)) =20 -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 =3D substream->runtime; + if (!(runtime->info & SNDRV_PCM_INFO_PAUSE)) return -ENOSYS; if (pause_pushed(state)) { if (runtime->state !=3D SNDRV_PCM_STATE_RUNNING) return -EBADFD; - } else if (runtime->state !=3D SNDRV_PCM_STATE_PAUSED) + } else if (runtime->state !=3D SNDRV_PCM_STATE_PAUSED) { return -EBADFD; + } runtime->trigger_master =3D substream; return 0; } @@ -1605,8 +1570,7 @@ static int snd_pcm_do_pause(struct snd_pcm_substream = *substream, { if (substream->runtime->trigger_master !=3D 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 h= w_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_substrea= m *substream, * delta, effectively to skip the check once. */ substream->runtime->hw_ptr_jiffies =3D 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); } =20 -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_pc= m_state_t state) { if (substream->runtime->trigger_master =3D=3D 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); } =20 -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_pc= m_state_t state) { struct snd_pcm_runtime *runtime =3D 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= =3D { */ 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); } =20 -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, boo= l push) { return snd_pcm_action_lock_irq(&snd_pcm_action_pause, substream, (__force snd_pcm_state_t)push); } =20 #ifdef CONFIG_PM + /* suspend callback: state argument ignored */ =20 -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_pc= m_state_t state) { struct snd_pcm_runtime *runtime =3D 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_subst= ream *substream, return 0; } =20 -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 =3D substream->runtime; + if (runtime->trigger_master !=3D 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 =3D true; return 0; /* suspend unconditionally */ } =20 -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 =3D substream->runtime; + snd_pcm_trigger_tstamp(substream); runtime->suspended_state =3D runtime->state; runtime->status->suspended_state =3D runtime->suspended_state; @@ -1735,8 +1695,7 @@ static int snd_pcm_suspend(struct snd_pcm_substream *= substream) unsigned long flags; =20 snd_pcm_stream_lock_irqsave(substream, flags); - err =3D snd_pcm_action(&snd_pcm_action_suspend, substream, - ACTION_ARG_IGNORE); + err =3D snd_pcm_action(&snd_pcm_action_suspend, substream, ACTION_ARG_IGN= ORE); 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 =3D 0; =20 - if (! pcm) + if (!pcm) return 0; =20 for_each_pcm_substream(pcm, stream, substream) { @@ -1783,20 +1742,20 @@ EXPORT_SYMBOL(snd_pcm_suspend_all); =20 /* resume callbacks: state argument ignored */ =20 -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 =3D substream->runtime; + if (!(runtime->info & SNDRV_PCM_INFO_RESUME)) return -ENOSYS; runtime->trigger_master =3D substream; return 0; } =20 -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 =3D substream->runtime; + if (runtime->trigger_master !=3D substream) return 0; /* DMA not running previously? */ @@ -1807,18 +1766,16 @@ static int snd_pcm_do_resume(struct snd_pcm_substre= am *substream, return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_RESUME); } =20 -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_p= cm_state_t state) { - if (substream->runtime->trigger_master =3D=3D substream && - snd_pcm_running(substream)) + if (substream->runtime->trigger_master =3D=3D substream && snd_pcm_runnin= g(substream)) substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_SUSPEND); } =20 -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_p= cm_state_t state) { struct snd_pcm_runtime *runtime =3D 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 = =3D { =20 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); } =20 #else @@ -1876,10 +1832,10 @@ static int snd_pcm_xrun(struct snd_pcm_substream *s= ubstream) * 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 =3D 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_substre= am *substream, } } =20 -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_s= tate_t state) { struct snd_pcm_runtime *runtime =3D substream->runtime; - int err =3D snd_pcm_ops_ioctl(substream, SNDRV_PCM_IOCTL1_RESET, NULL); + int err; + + err =3D 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_substrea= m *substream, return 0; } =20 -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_pc= m_state_t state) { struct snd_pcm_runtime *runtime =3D substream->runtime; + snd_pcm_stream_lock_irq(substream); runtime->control->appl_ptr =3D runtime->status->hw_ptr; - if (substream->stream =3D=3D SNDRV_PCM_STREAM_PLAYBACK && - runtime->silence_size > 0) + if (substream->stream =3D=3D SNDRV_PCM_STREAM_PLAYBACK && runtime->silenc= e_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= =3D { =20 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); } =20 /* * 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_pc= m_state_t state) { struct snd_pcm_runtime *runtime =3D substream->runtime; int f_flags =3D (__force int)state; @@ -1951,10 +1905,10 @@ static int snd_pcm_pre_prepare(struct snd_pcm_subst= ream *substream, return 0; } =20 -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 =3D substream->ops->prepare(substream); if (err < 0) @@ -1962,10 +1916,10 @@ static int snd_pcm_do_prepare(struct snd_pcm_substr= eam *substream, return snd_pcm_do_reset(substream, state); } =20 -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 =3D substream->runtime; + runtime->control->appl_ptr =3D 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= =3D { * * 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 fil= e *file) { int f_flags; =20 @@ -2004,8 +1957,7 @@ static int snd_pcm_prepare(struct snd_pcm_substream *= substream, } snd_pcm_stream_unlock_irq(substream); =20 - 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); } =20 @@ -2014,10 +1966,10 @@ static int snd_pcm_prepare(struct snd_pcm_substream= *substream, */ =20 /* 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 =3D 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_su= bstream *substream, return 0; } =20 -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 =3D substream->runtime; + if (substream->stream =3D=3D 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_sub= stream *substream, } } =20 - if (runtime->state =3D=3D SNDRV_PCM_STATE_DRAINING && - runtime->trigger_master =3D=3D substream && - (runtime->hw.info & SNDRV_PCM_INFO_DRAIN_TRIGGER)) + if (runtime->state =3D=3D SNDRV_PCM_STATE_DRAINING && runtime->trigger_ma= ster =3D=3D substream && + runtime->hw.info & SNDRV_PCM_INFO_DRAIN_TRIGGER) return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_DRAIN); =20 return 0; } =20 -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, s= nd_pcm_state_t state) { } =20 @@ -2091,8 +2041,7 @@ static const struct action_ops snd_pcm_action_drain_i= nit =3D { * 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 *su= bstream, if (file) { if (file->f_flags & O_NONBLOCK) nonblock =3D 1; - } else if (substream->f_flags & O_NONBLOCK) + } else if (substream->f_flags & O_NONBLOCK) { nonblock =3D 1; + } =20 snd_pcm_stream_lock_irq(substream); /* resume pause */ @@ -2120,8 +2070,7 @@ static int snd_pcm_drain(struct snd_pcm_substream *su= bstream, snd_pcm_pause(substream, false); =20 /* pre-start/stop - all running streams are changed to DRAINING state */ - result =3D snd_pcm_action(&snd_pcm_action_drain_init, substream, - ACTION_ARG_IGNORE); + result =3D snd_pcm_action(&snd_pcm_action_drain_init, substream, ACTION_A= RG_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 *su= bstream, } =20 for (;;) { - long tout; + long tout, t; struct snd_pcm_runtime *to_check; + if (signal_pending(current)) { result =3D -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 =3D MAX_SCHEDULE_TIMEOUT; - else { + } else { tout =3D 100; if (runtime->rate) { - long t =3D runtime->buffer_size * 1100 / runtime->rate; + t =3D runtime->buffer_size * 1100 / runtime->rate; tout =3D max(t, tout); } tout =3D msecs_to_jiffies(tout); @@ -2183,9 +2133,9 @@ static int snd_pcm_drain(struct snd_pcm_substream *su= bstream, break; } if (tout =3D=3D 0) { - if (substream->runtime->state =3D=3D SNDRV_PCM_STATE_SUSPENDED) + if (substream->runtime->state =3D=3D SNDRV_PCM_STATE_SUSPENDED) { result =3D -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 *su= bstream, } } =20 - unlock: +unlock: snd_pcm_stream_unlock_irq(substream); =20 return result; @@ -2210,7 +2160,7 @@ static int snd_pcm_drop(struct snd_pcm_substream *sub= stream) { struct snd_pcm_runtime *runtime; int result =3D 0; -=09 + if (PCM_RUNTIME_CHECK(substream)) return -ENXIO; runtime =3D substream->runtime; @@ -2231,7 +2181,6 @@ static int snd_pcm_drop(struct snd_pcm_substream *sub= stream) return result; } =20 - static bool is_pcm_file(struct file *file) { struct inode *inode =3D file_inode(file); @@ -2347,8 +2296,7 @@ static int snd_pcm_unlink(struct snd_pcm_substream *s= ubstream) =20 /* 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_subs= tream, link_list)); do_free =3D refcount_dec_and_test(&group->refs); } @@ -2357,7 +2305,7 @@ static int snd_pcm_unlink(struct snd_pcm_substream *s= ubstream) if (do_free) kfree(group); =20 - _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 sn= d_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); } =20 -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 sn= d_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); } =20 -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, struc= t 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); } =20 -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, struc= t 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); } =20 -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 =3D - hw_param_interval_c(params, rule->deps[0]); + const struct snd_interval *i =3D hw_param_interval_c(params, rule->deps[0= ]); struct snd_mask m; struct snd_mask *mask =3D 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 =3D snd_pcm_format_physical_width(k); if (bits <=3D 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_p= cm_hw_params *params, t.openmax =3D 0; pcm_for_each_format(k) { int bits; + if (!snd_mask_test_format(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMA= T), k)) continue; bits =3D snd_pcm_format_physical_width(k); if (bits <=3D 0) continue; /* ignore invalid formats */ - if (t.min > (unsigned)bits) + if (t.min > (unsigned int)bits) t.min =3D bits; - if (t.max < (unsigned)bits) + if (t.max < (unsigned int)bits) t.max =3D bits; } t.integer =3D 1; @@ -2465,27 +2414,28 @@ const struct snd_pcm_hw_constraint_list snd_pcm_kno= wn_rates =3D { .list =3D rates, }; =20 -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 s= nd_pcm_hw_rule *rule) { struct snd_pcm_hardware *hw =3D rule->private; + return snd_interval_list(hw_param_interval(params, rule->var), snd_pcm_known_rates.count, snd_pcm_known_rates.list, hw->rates); -} =09 +} =20 static int snd_pcm_hw_rule_buffer_bytes_max(struct snd_pcm_hw_params *para= ms, struct snd_pcm_hw_rule *rule) { struct snd_interval t; struct snd_pcm_substream *substream =3D rule->private; + t.min =3D 0; t.max =3D substream->buffer_bytes_max; t.openmin =3D 0; t.openmax =3D 0; t.integer =3D 1; return snd_interval_refine(hw_param_interval(params, rule->var), &t); -} =09 +} =20 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_p= cm_substream *substream) struct snd_pcm_hw_constraints *constrs =3D &runtime->hw_constraints; int k, err; =20 - for (k =3D SNDRV_PCM_HW_PARAM_FIRST_MASK; k <=3D SNDRV_PCM_HW_PARAM_LAST_= MASK; k++) { + for (k =3D SNDRV_PCM_HW_PARAM_FIRST_MASK; k <=3D SNDRV_PCM_HW_PARAM_LAST_= MASK; k++) snd_mask_any(constrs_mask(constrs, k)); - } =20 - for (k =3D SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <=3D SNDRV_PCM_HW_PARAM_L= AST_INTERVAL; k++) { + for (k =3D SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <=3D SNDRV_PCM_HW_PARAM_L= AST_INTERVAL; k++) snd_interval_any(constrs_interval(constrs, k)); - } =20 snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_CHAN= NELS)); snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_BUFF= ER_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_FRAM= E_BITS)); =20 err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,=20 + err =3D 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,=20 + SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1); if (err < 0) return err; - err =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,=20 + err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS,=20 + err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS,=20 - snd_pcm_hw_rule_mulkdiv, (void*) 8, - SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1); + err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS,=20 - snd_pcm_hw_rule_mulkdiv, (void*) 8, - SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, -1); + err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,=20 + err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,=20 - snd_pcm_hw_rule_mulkdiv, (void*) 1000000, - SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_PERIOD_TIME, -1); + err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,=20 - snd_pcm_hw_rule_mulkdiv, (void*) 1000000, - SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_BUFFER_TIME, -1); + err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS,=20 + err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,=20 + err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,=20 - snd_pcm_hw_rule_mulkdiv, (void*) 8, - SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1); + err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,=20 - snd_pcm_hw_rule_muldivk, (void*) 1000000, + err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,=20 + err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,=20 - snd_pcm_hw_rule_mulkdiv, (void*) 8, - SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1); + err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,=20 - snd_pcm_hw_rule_muldivk, (void*) 1000000, + err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,=20 - snd_pcm_hw_rule_muldivk, (void*) 8, - SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1); + err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,=20 - snd_pcm_hw_rule_muldivk, (void*) 8, - SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1); + err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_TIME,=20 - snd_pcm_hw_rule_mulkdiv, (void*) 1000000, + err =3D 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 =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_TIME,=20 - snd_pcm_hw_rule_mulkdiv, (void*) 1000000, + err =3D 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 =3D 0; =20 - if (hw->info & SNDRV_PCM_INFO_INTERLEAVED) + if (hw->info & SNDRV_PCM_INFO_INTERLEAVED) mask |=3D PARAM_MASK_BIT(SNDRV_PCM_ACCESS_RW_INTERLEAVED); - if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED) + if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED) mask |=3D 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; =20 - err =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,=20 + err =3D 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 s= nd_pcm_substream *substream) =20 /* FIXME: remove */ if (runtime->dma_bytes) { - err =3D snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_= BYTES, 0, runtime->dma_bytes); + err =3D snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_= BYTES, + 0, runtime->dma_bytes); if (err < 0) return err; } =20 if (!(hw->rates & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))) { - err =3D snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,=20 + err =3D 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_substre= am *substream) } EXPORT_SYMBOL(snd_pcm_release_substream); =20 -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 *f= ile, struct snd_pcm_substream **rsubstream) { struct snd_pcm_substream *substream; @@ -2760,8 +2720,7 @@ int snd_pcm_open_substream(struct snd_pcm *pcm, int s= tream, /* 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_syn= c) substream->runtime->hw.info |=3D SNDRV_PCM_INFO_EXPLICIT_SYNC; =20 *rsubstream =3D substream; @@ -2773,9 +2732,7 @@ int snd_pcm_open_substream(struct snd_pcm *pcm, int s= tream, } EXPORT_SYMBOL(snd_pcm_open_substream); =20 -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 s= tream) { 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; =20 pcm_file =3D kzalloc(sizeof(*pcm_file), GFP_KERNEL); - if (pcm_file =3D=3D NULL) { + if (!pcm_file) { snd_pcm_release_substream(substream); return -ENOMEM; } @@ -2802,10 +2759,10 @@ static int snd_pcm_playback_open(struct inode *inod= e, struct file *file) { struct snd_pcm *pcm; int err =3D nonseekable_open(inode, file); + if (err < 0) return err; - pcm =3D snd_lookup_minor_data(iminor(inode), - SNDRV_DEVICE_TYPE_PCM_PLAYBACK); + pcm =3D snd_lookup_minor_data(iminor(inode), SNDRV_DEVICE_TYPE_PCM_PLAYBA= CK); err =3D 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 =3D nonseekable_open(inode, file); + if (err < 0) return err; - pcm =3D snd_lookup_minor_data(iminor(inode), - SNDRV_DEVICE_TYPE_PCM_CAPTURE); + pcm =3D snd_lookup_minor_data(iminor(inode), SNDRV_DEVICE_TYPE_PCM_CAPTUR= E); err =3D 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; =20 - if (pcm =3D=3D NULL) { + if (!pcm) { err =3D -ENODEV; goto __error1; } @@ -2854,8 +2811,9 @@ static int snd_pcm_open(struct file *file, struct snd= _pcm *pcm, int stream) err =3D -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 s= nd_pcm *pcm, int stream) goto __error; return err; =20 - __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; } =20 static int snd_pcm_release(struct inode *inode, struct file *file) @@ -2935,7 +2893,7 @@ static int do_pcm_hwsync(struct snd_pcm_substream *su= bstream) /* increase the appl_ptr; returns the processed frames or a negative error= */ static snd_pcm_sframes_t forward_appl_ptr(struct snd_pcm_substream *substr= eam, snd_pcm_uframes_t frames, - snd_pcm_sframes_t avail) + snd_pcm_sframes_t avail) { struct snd_pcm_runtime *runtime =3D substream->runtime; snd_pcm_sframes_t appl_ptr; @@ -2988,8 +2946,7 @@ static snd_pcm_sframes_t snd_pcm_rewind(struct snd_pc= m_substream *substream, snd_pcm_stream_lock_irq(substream); ret =3D do_pcm_hwsync(substream); if (!ret) - ret =3D rewind_appl_ptr(substream, frames, - snd_pcm_hw_avail(substream)); + ret =3D rewind_appl_ptr(substream, frames, snd_pcm_hw_avail(substream)); snd_pcm_stream_unlock_irq(substream); if (ret >=3D 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 =3D do_pcm_hwsync(substream); if (!ret) - ret =3D forward_appl_ptr(substream, frames, - snd_pcm_avail(substream)); + ret =3D forward_appl_ptr(substream, frames, snd_pcm_avail(substream)); snd_pcm_stream_unlock_irq(substream); if (ret >=3D 0) snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_DEVICE); return ret; } =20 -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_sfra= mes_t *delay) { int err; =20 @@ -3029,7 +2984,7 @@ static int snd_pcm_delay(struct snd_pcm_substream *su= bstream, =20 return err; } - =09 + 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_substrea= m *substream, int err; =20 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(s= truct snd_pcm_mmap_control))) - return -EFAULT;=09 status =3D runtime->status; control =3D 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 =3D pcm_lib_apply_appl_ptr(substream, - sync_ptr.c.control.appl_ptr); + err =3D 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; =20 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; =20 /* recalcuate the boundary within 32bit */ static snd_pcm_uframes_t recalculate_boundary(struct snd_pcm_runtime *runt= ime) { snd_pcm_uframes_t boundary; =20 - if (! runtime->buffer_size) + if (!runtime->buffer_size) return 0; boundary =3D runtime->buffer_size; while (boundary * 2 <=3D 0x7fffffffUL - runtime->buffer_size) @@ -3152,19 +3107,19 @@ static int snd_pcm_ioctl_sync_ptr_compat(struct snd= _pcm_substream *substream, status =3D runtime->status; control =3D runtime->control; boundary =3D recalculate_boundary(runtime); - if (! boundary) + if (!boundary) boundary =3D 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 =3D pcm_lib_apply_appl_ptr(substream, - scontrol.appl_ptr); + err =3D 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 =3D control->appl_ptr % boundary; + } if (!(sflags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN)) control->avail_min =3D scontrol.avail_min; else @@ -3190,13 +3145,14 @@ static int snd_pcm_ioctl_sync_ptr_compat(struct snd= _pcm_substream *substream, =20 return 0; } + #define __SNDRV_PCM_IOCTL_SYNC_PTR32 _IOWR('A', 0x23, struct snd_pcm_sync_= ptr32) =20 static int snd_pcm_tstamp(struct snd_pcm_substream *substream, int __user = *_arg) { struct snd_pcm_runtime *runtime =3D substream->runtime; int arg; -=09 + 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_subst= ream *substream, } =20 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 =3D 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; } =20 -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 lo= ng arg) { struct snd_pcm_file *pcm_file; =20 @@ -3408,8 +3362,7 @@ static long snd_pcm_ioctl(struct file *file, unsigned= int cmd, if (((cmd >> 8) & 0xff) !=3D 'A') return -ENOTTY; =20 - 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); } =20 /** @@ -3424,12 +3377,11 @@ static long snd_pcm_ioctl(struct file *file, unsign= ed 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 =3D arg; snd_pcm_sframes_t result; -=09 + if (substream->runtime->state =3D=3D SNDRV_PCM_STATE_DISCONNECTED) return -EBADFD; =20 @@ -3462,8 +3414,7 @@ int snd_pcm_kernel_ioctl(struct snd_pcm_substream *su= bstream, } EXPORT_SYMBOL(snd_pcm_kernel_ioctl); =20 -static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t co= unt, - loff_t * offset) +static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t co= unt, 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, } =20 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, stru= ct iov_iter *to) return -EINVAL; frames =3D bytes_to_samples(runtime, iov->iov_len); bufs =3D kmalloc_array(to->nr_segs, sizeof(void *), GFP_KERNEL); - if (bufs =3D=3D NULL) + if (!bufs) return -ENOMEM; for (i =3D 0; i < to->nr_segs; ++i) { bufs[i] =3D iov->iov_base; @@ -3578,7 +3529,7 @@ static ssize_t snd_pcm_writev(struct kiocb *iocb, str= uct iov_iter *from) return -EINVAL; frames =3D bytes_to_samples(runtime, iov->iov_len); bufs =3D kmalloc_array(from->nr_segs, sizeof(void *), GFP_KERNEL); - if (bufs =3D=3D NULL) + if (!bufs) return -ENOMEM; for (i =3D 0; i < from->nr_segs; ++i) { bufs[i] =3D 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 =3D vmf->vma->vm_private_data; struct snd_pcm_runtime *runtime; -=09 - if (substream =3D=3D NULL) + + if (!substream) return VM_FAULT_SIGBUS; runtime =3D substream->runtime; vmf->page =3D virt_to_page(runtime->status); @@ -3665,8 +3616,7 @@ static vm_fault_t snd_pcm_mmap_status_fault(struct vm= _fault *vmf) return 0; } =20 -static const struct vm_operations_struct snd_pcm_vm_ops_status =3D -{ +static const struct vm_operations_struct snd_pcm_vm_ops_status =3D { .fault =3D snd_pcm_mmap_status_fault, }; =20 @@ -3674,6 +3624,7 @@ static int snd_pcm_mmap_status(struct snd_pcm_substre= am *substream, struct file struct vm_area_struct *area) { long size; + if (!(area->vm_flags & VM_READ)) return -EINVAL; size =3D area->vm_end - area->vm_start; @@ -3681,8 +3632,7 @@ static int snd_pcm_mmap_status(struct snd_pcm_substre= am *substream, struct file return -EINVAL; area->vm_ops =3D &snd_pcm_vm_ops_status; area->vm_private_data =3D 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); =20 return 0; } @@ -3694,8 +3644,8 @@ static vm_fault_t snd_pcm_mmap_control_fault(struct v= m_fault *vmf) { struct snd_pcm_substream *substream =3D vmf->vma->vm_private_data; struct snd_pcm_runtime *runtime; -=09 - if (substream =3D=3D NULL) + + if (!substream) return VM_FAULT_SIGBUS; runtime =3D substream->runtime; vmf->page =3D virt_to_page(runtime->control); @@ -3703,8 +3653,7 @@ static vm_fault_t snd_pcm_mmap_control_fault(struct v= m_fault *vmf) return 0; } =20 -static const struct vm_operations_struct snd_pcm_vm_ops_control =3D -{ +static const struct vm_operations_struct snd_pcm_vm_ops_control =3D { .fault =3D snd_pcm_mmap_control_fault, }; =20 @@ -3712,6 +3661,7 @@ static int snd_pcm_mmap_control(struct snd_pcm_substr= eam *substream, struct file struct vm_area_struct *area) { long size; + if (!(area->vm_flags & VM_READ)) return -EINVAL; size =3D area->vm_end - area->vm_start; @@ -3769,11 +3719,13 @@ static int snd_pcm_mmap_status(struct snd_pcm_subst= ream *substream, struct file { return -ENXIO; } + static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struc= t file *file, struct vm_area_struct *area) { return -ENXIO; } + #endif /* coherent mmap */ =20 /* @@ -3784,10 +3736,10 @@ static vm_fault_t snd_pcm_mmap_data_fault(struct vm= _fault *vmf) struct snd_pcm_substream *substream =3D vmf->vma->vm_private_data; struct snd_pcm_runtime *runtime; unsigned long offset; - struct page * page; + struct page *page; size_t dma_bytes; -=09 - if (substream =3D=3D NULL) + + if (!substream) return VM_FAULT_SIGBUS; runtime =3D substream->runtime; offset =3D vmf->pgoff << PAGE_SHIFT; @@ -3884,7 +3836,7 @@ int snd_pcm_mmap_data(struct snd_pcm_substream *subst= ream, struct file *file, int err; =20 if (substream->stream =3D=3D 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); =20 static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area) { - struct snd_pcm_file * pcm_file; - struct snd_pcm_substream *substream;=09 + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream; unsigned long offset; -=09 + pcm_file =3D file->private_data; substream =3D 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; } =20 -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; =20 @@ -3985,8 +3937,8 @@ static int snd_pcm_fasync(int fd, struct file * file,= int on) */ =20 #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)) =20 static void snd_pcm_hw_convert_from_old_params(struct snd_pcm_hw_params *p= arams, struct snd_pcm_hw_params_old *oparams) @@ -4027,7 +3979,7 @@ static void snd_pcm_hw_convert_to_old_params(struct s= nd_pcm_hw_params_old *opara } =20 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 =3D NULL; @@ -4062,7 +4014,7 @@ static int snd_pcm_hw_refine_old_user(struct snd_pcm_= substream *substream, } =20 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 =3D NULL; @@ -4095,10 +4047,8 @@ static int snd_pcm_hw_params_old_user(struct snd_pcm= _substream *substream, #endif /* CONFIG_SND_SUPPORT_OLD_API */ =20 #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 =3D file->private_data; @@ -4133,7 +4083,7 @@ const struct file_operations snd_pcm_f_ops[2] =3D { .llseek =3D no_llseek, .poll =3D snd_pcm_poll, .unlocked_ioctl =3D snd_pcm_ioctl, - .compat_ioctl =3D snd_pcm_ioctl_compat, + .compat_ioctl =3D snd_pcm_ioctl_compat, .mmap =3D snd_pcm_mmap, .fasync =3D snd_pcm_fasync, .get_unmapped_area =3D snd_pcm_get_unmapped_area, @@ -4147,7 +4097,7 @@ const struct file_operations snd_pcm_f_ops[2] =3D { .llseek =3D no_llseek, .poll =3D snd_pcm_poll, .unlocked_ioctl =3D snd_pcm_ioctl, - .compat_ioctl =3D snd_pcm_ioctl_compat, + .compat_ioctl =3D snd_pcm_ioctl_compat, .mmap =3D snd_pcm_mmap, .fasync =3D snd_pcm_fasync, .get_unmapped_area =3D snd_pcm_get_unmapped_area, --=20 2.34.1