~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,24 +1,10 @@
	1	+// SPDX-License-Identifier: GPL-2.0-or-later
1	2	/*
2	3	* Digital Audio (PCM) abstract layer
3	4	* Copyright (c) by Jaroslav Kysela <perex@perex.cz>
4		- *
5		- *
6		- * This program is free software; you can redistribute it and/or modify
7		- * it under the terms of the GNU General Public License as published by
8		- * the Free Software Foundation; either version 2 of the License, or
9		- * (at your option) any later version.
10		- *
11		- * This program is distributed in the hope that it will be useful,
12		- * but WITHOUT ANY WARRANTY; without even the implied warranty of
13		- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14		- * GNU General Public License for more details.
15		- *
16		- * You should have received a copy of the GNU General Public License
17		- * along with this program; if not, write to the Free Software
18		- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19		- *
20	5	*/
21	6
	7	+#include <linux/compat.h>
22	8	#include <linux/mm.h>
23	9	#include <linux/module.h>
24	10	#include <linux/file.h>
..	..	@@ -28,6 +14,7 @@
28	14	#include <linux/pm_qos.h>
29	15	#include <linux/io.h>
30	16	#include <linux/dma-mapping.h>
	17	+#include <linux/vmalloc.h>
31	18	#include <sound/core.h>
32	19	#include <sound/control.h>
33	20	#include <sound/info.h>
..	..	@@ -85,71 +72,30 @@
85	72	*
86	73	*/
87	74
88		-static DEFINE_RWLOCK(snd_pcm_link_rwlock);
89	75	static DECLARE_RWSEM(snd_pcm_link_rwsem);
90	76
91		-/* Writer in rwsem may block readers even during its waiting in queue,
92		- * and this may lead to a deadlock when the code path takes read sem
93		- * twice (e.g. one in snd_pcm_action_nonatomic() and another in
94		- * snd_pcm_stream_lock()). As a (suboptimal) workaround, let writer to
95		- * sleep until all the readers are completed without blocking by writer.
96		- */
97		-static inline void down_write_nonfifo(struct rw_semaphore *lock)
	77	+void snd_pcm_group_init(struct snd_pcm_group *group)
98	78	{
99		- while (!down_write_trylock(lock))
100		- msleep(1);
	79	+ spin_lock_init(&group->lock);
	80	+ mutex_init(&group->mutex);
	81	+ INIT_LIST_HEAD(&group->substreams);
	82	+ refcount_set(&group->refs, 1);
101	83	}
102	84
103		-#define PCM_LOCK_DEFAULT 0
104		-#define PCM_LOCK_IRQ 1
105		-#define PCM_LOCK_IRQSAVE 2
106		-
107		-static unsigned long __snd_pcm_stream_lock_mode(struct snd_pcm_substream *substream,
108		- unsigned int mode)
109		-{
110		- unsigned long flags = 0;
111		- if (substream->pcm->nonatomic) {
112		- down_read_nested(&snd_pcm_link_rwsem, SINGLE_DEPTH_NESTING);
113		- mutex_lock(&substream->self_group.mutex);
114		- } else {
115		- switch (mode) {
116		- case PCM_LOCK_DEFAULT:
117		- read_lock(&snd_pcm_link_rwlock);
118		- break;
119		- case PCM_LOCK_IRQ:
120		- read_lock_irq(&snd_pcm_link_rwlock);
121		- break;
122		- case PCM_LOCK_IRQSAVE:
123		- read_lock_irqsave(&snd_pcm_link_rwlock, flags);
124		- break;
125		- }
126		- spin_lock(&substream->self_group.lock);
127		- }
128		- return flags;
	85	+/* define group lock helpers */
	86	+#define DEFINE_PCM_GROUP_LOCK(action, mutex_action) \
	87	+static void snd_pcm_group_ ## action(struct snd_pcm_group *group, bool nonatomic) \
	88	+{ \
	89	+ if (nonatomic) \
	90	+ mutex_ ## mutex_action(&group->mutex); \
	91	+ else \
	92	+ spin_ ## action(&group->lock); \
129	93	}
130	94
131		-static void __snd_pcm_stream_unlock_mode(struct snd_pcm_substream *substream,
132		- unsigned int mode, unsigned long flags)
133		-{
134		- if (substream->pcm->nonatomic) {
135		- mutex_unlock(&substream->self_group.mutex);
136		- up_read(&snd_pcm_link_rwsem);
137		- } else {
138		- spin_unlock(&substream->self_group.lock);
139		-
140		- switch (mode) {
141		- case PCM_LOCK_DEFAULT:
142		- read_unlock(&snd_pcm_link_rwlock);
143		- break;
144		- case PCM_LOCK_IRQ:
145		- read_unlock_irq(&snd_pcm_link_rwlock);
146		- break;
147		- case PCM_LOCK_IRQSAVE:
148		- read_unlock_irqrestore(&snd_pcm_link_rwlock, flags);
149		- break;
150		- }
151		- }
152		-}
	95	+DEFINE_PCM_GROUP_LOCK(lock, lock);
	96	+DEFINE_PCM_GROUP_LOCK(unlock, unlock);
	97	+DEFINE_PCM_GROUP_LOCK(lock_irq, lock);
	98	+DEFINE_PCM_GROUP_LOCK(unlock_irq, unlock);
153	99
154	100	/**
155	101	* snd_pcm_stream_lock - Lock the PCM stream
..	..	@@ -161,19 +107,19 @@
161	107	*/
162	108	void snd_pcm_stream_lock(struct snd_pcm_substream *substream)
163	109	{
164		- __snd_pcm_stream_lock_mode(substream, PCM_LOCK_DEFAULT);
	110	+ snd_pcm_group_lock(&substream->self_group, substream->pcm->nonatomic);
165	111	}
166	112	EXPORT_SYMBOL_GPL(snd_pcm_stream_lock);
167	113
168	114	/**
169		- * snd_pcm_stream_lock - Unlock the PCM stream
	115	+ * snd_pcm_stream_unlock - Unlock the PCM stream
170	116	* @substream: PCM substream
171	117	*
172	118	* This unlocks the PCM stream that has been locked via snd_pcm_stream_lock().
173	119	*/
174	120	void snd_pcm_stream_unlock(struct snd_pcm_substream *substream)
175	121	{
176		- __snd_pcm_stream_unlock_mode(substream, PCM_LOCK_DEFAULT, 0);
	122	+ snd_pcm_group_unlock(&substream->self_group, substream->pcm->nonatomic);
177	123	}
178	124	EXPORT_SYMBOL_GPL(snd_pcm_stream_unlock);
179	125
..	..	@@ -187,9 +133,20 @@
187	133	*/
188	134	void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream)
189	135	{
190		- __snd_pcm_stream_lock_mode(substream, PCM_LOCK_IRQ);
	136	+ snd_pcm_group_lock_irq(&substream->self_group,
	137	+ substream->pcm->nonatomic);
191	138	}
192	139	EXPORT_SYMBOL_GPL(snd_pcm_stream_lock_irq);
	140	+
	141	+static void snd_pcm_stream_lock_nested(struct snd_pcm_substream *substream)
	142	+{
	143	+ struct snd_pcm_group *group = &substream->self_group;
	144	+
	145	+ if (substream->pcm->nonatomic)
	146	+ mutex_lock_nested(&group->mutex, SINGLE_DEPTH_NESTING);
	147	+ else
	148	+ spin_lock_nested(&group->lock, SINGLE_DEPTH_NESTING);
	149	+}
193	150
194	151	/**
195	152	* snd_pcm_stream_unlock_irq - Unlock the PCM stream
..	..	@@ -199,13 +156,19 @@
199	156	*/
200	157	void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream)
201	158	{
202		- __snd_pcm_stream_unlock_mode(substream, PCM_LOCK_IRQ, 0);
	159	+ snd_pcm_group_unlock_irq(&substream->self_group,
	160	+ substream->pcm->nonatomic);
203	161	}
204	162	EXPORT_SYMBOL_GPL(snd_pcm_stream_unlock_irq);
205	163
206	164	unsigned long _snd_pcm_stream_lock_irqsave(struct snd_pcm_substream *substream)
207	165	{
208		- return __snd_pcm_stream_lock_mode(substream, PCM_LOCK_IRQSAVE);
	166	+ unsigned long flags = 0;
	167	+ if (substream->pcm->nonatomic)
	168	+ mutex_lock(&substream->self_group.mutex);
	169	+ else
	170	+ spin_lock_irqsave(&substream->self_group.lock, flags);
	171	+ return flags;
209	172	}
210	173	EXPORT_SYMBOL_GPL(_snd_pcm_stream_lock_irqsave);
211	174
..	..	@@ -219,9 +182,22 @@
219	182	void snd_pcm_stream_unlock_irqrestore(struct snd_pcm_substream *substream,
220	183	unsigned long flags)
221	184	{
222		- __snd_pcm_stream_unlock_mode(substream, PCM_LOCK_IRQSAVE, flags);
	185	+ if (substream->pcm->nonatomic)
	186	+ mutex_unlock(&substream->self_group.mutex);
	187	+ else
	188	+ spin_unlock_irqrestore(&substream->self_group.lock, flags);
223	189	}
224	190	EXPORT_SYMBOL_GPL(snd_pcm_stream_unlock_irqrestore);
	191	+
	192	+/* Run PCM ioctl ops */
	193	+static int snd_pcm_ops_ioctl(struct snd_pcm_substream *substream,
	194	+ unsigned cmd, void *arg)
	195	+{
	196	+ if (substream->ops->ioctl)
	197	+ return substream->ops->ioctl(substream, cmd, arg);
	198	+ else
	199	+ return snd_pcm_lib_ioctl(substream, cmd, arg);
	200	+}
225	201
226	202	int snd_pcm_info(struct snd_pcm_substream substream, struct snd_pcm_info info)
227	203	{
..	..	@@ -262,17 +238,29 @@
262	238	return err;
263	239	}
264	240
	241	+/* macro for simplified cast */
	242	+#define PARAM_MASK_BIT(b) (1U << (__force int)(b))
	243	+
265	244	static bool hw_support_mmap(struct snd_pcm_substream *substream)
266	245	{
267	246	if (!(substream->runtime->hw.info & SNDRV_PCM_INFO_MMAP))
268	247	return false;
269		- /* architecture supports dma_mmap_coherent()? */
270		-#if defined(CONFIG_ARCH_NO_COHERENT_DMA_MMAP) \|\| !defined(CONFIG_HAS_DMA)
271		- if (!substream->ops->mmap &&
272		- substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV)
273		- return false;
274		-#endif
275		- return true;
	248	+
	249	+ if (substream->ops->mmap \|\| substream->ops->page)
	250	+ return true;
	251	+
	252	+ switch (substream->dma_buffer.dev.type) {
	253	+ case SNDRV_DMA_TYPE_UNKNOWN:
	254	+ /* we can't know the device, so just assume that the driver does
	255	+ * everything right
	256	+ */
	257	+ return true;
	258	+ case SNDRV_DMA_TYPE_CONTINUOUS:
	259	+ case SNDRV_DMA_TYPE_VMALLOC:
	260	+ return true;
	261	+ default:
	262	+ return dma_can_mmap(substream->dma_buffer.dev.dev);
	263	+ }
276	264	}
277	265
278	266	static int constrain_mask_params(struct snd_pcm_substream *substream,
..	..	@@ -291,7 +279,7 @@
291	279	return -EINVAL;
292	280
293	281	/* This parameter is not requested to change by a caller. */
294		- if (!(params->rmask & (1 << k)))
	282	+ if (!(params->rmask & PARAM_MASK_BIT(k)))
295	283	continue;
296	284
297	285	if (trace_hw_mask_param_enabled())
..	..	@@ -305,7 +293,7 @@
305	293
306	294	/* Set corresponding flag so that the caller gets it. */
307	295	trace_hw_mask_param(substream, k, 0, &old_mask, m);
308		- params->cmask \|= 1 << k;
	296	+ params->cmask \|= PARAM_MASK_BIT(k);
309	297	}
310	298
311	299	return 0;
..	..	@@ -327,7 +315,7 @@
327	315	return -EINVAL;
328	316
329	317	/* This parameter is not requested to change by a caller. */
330		- if (!(params->rmask & (1 << k)))
	318	+ if (!(params->rmask & PARAM_MASK_BIT(k)))
331	319	continue;
332	320
333	321	if (trace_hw_interval_param_enabled())
..	..	@@ -341,7 +329,7 @@
341	329
342	330	/* Set corresponding flag so that the caller gets it. */
343	331	trace_hw_interval_param(substream, k, 0, &old_interval, i);
344		- params->cmask \|= 1 << k;
	332	+ params->cmask \|= PARAM_MASK_BIT(k);
345	333	}
346	334
347	335	return 0;
..	..	@@ -383,7 +371,7 @@
383	371	* have 0 so that the parameters are never changed anymore.
384	372	*/
385	373	for (k = 0; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++)
386		- vstamps[k] = (params->rmask & (1 << k)) ? 1 : 0;
	374	+ vstamps[k] = (params->rmask & PARAM_MASK_BIT(k)) ? 1 : 0;
387	375
388	376	/* Due to the above design, actual sequence number starts at 2. */
389	377	stamp = 2;
..	..	@@ -451,7 +439,7 @@
451	439	hw_param_interval(params, r->var));
452	440	}
453	441
454		- params->cmask \|= (1 << r->var);
	442	+ params->cmask \|= PARAM_MASK_BIT(r->var);
455	443	vstamps[r->var] = stamp;
456	444	again = true;
457	445	}
..	..	@@ -493,8 +481,9 @@
493	481	m = hw_param_mask_c(params, SNDRV_PCM_HW_PARAM_FORMAT);
494	482	i = hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_CHANNELS);
495	483	if (snd_mask_single(m) && snd_interval_single(i)) {
496		- err = substream->ops->ioctl(substream,
497		- SNDRV_PCM_IOCTL1_FIFO_SIZE, params);
	484	+ err = snd_pcm_ops_ioctl(substream,
	485	+ SNDRV_PCM_IOCTL1_FIFO_SIZE,
	486	+ params);
498	487	if (err < 0)
499	488	return err;
500	489	}
..	..	@@ -519,9 +508,9 @@
519	508
520	509	params->info = 0;
521	510	params->fifo_size = 0;
522		- if (params->rmask & (1 << SNDRV_PCM_HW_PARAM_SAMPLE_BITS))
	511	+ if (params->rmask & PARAM_MASK_BIT(SNDRV_PCM_HW_PARAM_SAMPLE_BITS))
523	512	params->msbits = 0;
524		- if (params->rmask & (1 << SNDRV_PCM_HW_PARAM_RATE)) {
	513	+ if (params->rmask & PARAM_MASK_BIT(SNDRV_PCM_HW_PARAM_RATE)) {
525	514	params->rate_num = 0;
526	515	params->rate_den = 0;
527	516	}
..	..	@@ -584,7 +573,8 @@
584	573	return usecs;
585	574	}
586	575
587		-static void snd_pcm_set_state(struct snd_pcm_substream *substream, int state)
	576	+static void snd_pcm_set_state(struct snd_pcm_substream *substream,
	577	+ snd_pcm_state_t state)
588	578	{
589	579	snd_pcm_stream_lock_irq(substream);
590	580	if (substream->runtime->status->state != SNDRV_PCM_STATE_DISCONNECTED)
..	..	@@ -602,8 +592,19 @@
602	592	#endif
603	593	}
604	594
	595	+void snd_pcm_sync_stop(struct snd_pcm_substream *substream, bool sync_irq)
	596	+{
	597	+ if (substream->runtime && substream->runtime->stop_operating) {
	598	+ substream->runtime->stop_operating = false;
	599	+ if (substream->ops && substream->ops->sync_stop)
	600	+ substream->ops->sync_stop(substream);
	601	+ else if (sync_irq && substream->pcm->card->sync_irq > 0)
	602	+ synchronize_irq(substream->pcm->card->sync_irq);
	603	+ }
	604	+}
	605	+
605	606	/**
606		- * snd_pcm_hw_param_choose - choose a configuration defined by @params
	607	+ * snd_pcm_hw_params_choose - choose a configuration defined by @params
607	608	* @pcm: PCM instance
608	609	* @params: the hw_params instance
609	610	*
..	..	@@ -666,6 +667,30 @@
666	667	return 0;
667	668	}
668	669
	670	+/* acquire buffer_mutex; if it's in r/w operation, return -EBUSY, otherwise
	671	+ * block the further r/w operations
	672	+ */
	673	+static int snd_pcm_buffer_access_lock(struct snd_pcm_runtime *runtime)
	674	+{
	675	+ if (!atomic_dec_unless_positive(&runtime->buffer_accessing))
	676	+ return -EBUSY;
	677	+ mutex_lock(&runtime->buffer_mutex);
	678	+ return 0; /* keep buffer_mutex, unlocked by below */
	679	+}
	680	+
	681	+/* release buffer_mutex and clear r/w access flag */
	682	+static void snd_pcm_buffer_access_unlock(struct snd_pcm_runtime *runtime)
	683	+{
	684	+ mutex_unlock(&runtime->buffer_mutex);
	685	+ atomic_inc(&runtime->buffer_accessing);
	686	+}
	687	+
	688	+#if IS_ENABLED(CONFIG_SND_PCM_OSS)
	689	+#define is_oss_stream(substream) ((substream)->oss.oss)
	690	+#else
	691	+#define is_oss_stream(substream) false
	692	+#endif
	693	+
669	694	static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
670	695	struct snd_pcm_hw_params *params)
671	696	{
..	..	@@ -677,22 +702,27 @@
677	702	if (PCM_RUNTIME_CHECK(substream))
678	703	return -ENXIO;
679	704	runtime = substream->runtime;
	705	+ err = snd_pcm_buffer_access_lock(runtime);
	706	+ if (err < 0)
	707	+ return err;
680	708	snd_pcm_stream_lock_irq(substream);
681	709	switch (runtime->status->state) {
682	710	case SNDRV_PCM_STATE_OPEN:
683	711	case SNDRV_PCM_STATE_SETUP:
684	712	case SNDRV_PCM_STATE_PREPARED:
	713	+ if (!is_oss_stream(substream) &&
	714	+ atomic_read(&substream->mmap_count))
	715	+ err = -EBADFD;
685	716	break;
686	717	default:
687		- snd_pcm_stream_unlock_irq(substream);
688		- return -EBADFD;
	718	+ err = -EBADFD;
	719	+ break;
689	720	}
690	721	snd_pcm_stream_unlock_irq(substream);
691		-#if IS_ENABLED(CONFIG_SND_PCM_OSS)
692		- if (!substream->oss.oss)
693		-#endif
694		- if (atomic_read(&substream->mmap_count))
695		- return -EBADFD;
	722	+ if (err)
	723	+ goto unlock;
	724	+
	725	+ snd_pcm_sync_stop(substream, true);
696	726
697	727	params->rmask = ~0U;
698	728	err = snd_pcm_hw_refine(substream, params);
..	..	@@ -706,6 +736,14 @@
706	736	err = fixup_unreferenced_params(substream, params);
707	737	if (err < 0)
708	738	goto _error;
	739	+
	740	+ if (substream->managed_buffer_alloc) {
	741	+ err = snd_pcm_lib_malloc_pages(substream,
	742	+ params_buffer_bytes(params));
	743	+ if (err < 0)
	744	+ goto _error;
	745	+ runtime->buffer_changed = err > 0;
	746	+ }
709	747
710	748	if (substream->ops->hw_params != NULL) {
711	749	err = substream->ops->hw_params(substream, params);
..	..	@@ -764,19 +802,26 @@
764	802	snd_pcm_timer_resolution_change(substream);
765	803	snd_pcm_set_state(substream, SNDRV_PCM_STATE_SETUP);
766	804
767		- if (pm_qos_request_active(&substream->latency_pm_qos_req))
768		- pm_qos_remove_request(&substream->latency_pm_qos_req);
	805	+ if (cpu_latency_qos_request_active(&substream->latency_pm_qos_req))
	806	+ cpu_latency_qos_remove_request(&substream->latency_pm_qos_req);
769	807	if ((usecs = period_to_usecs(runtime)) >= 0)
770		- pm_qos_add_request(&substream->latency_pm_qos_req,
771		- PM_QOS_CPU_DMA_LATENCY, usecs);
772		- return 0;
	808	+ cpu_latency_qos_add_request(&substream->latency_pm_qos_req,
	809	+ usecs);
	810	+ err = 0;
773	811	_error:
774		- /* hardware might be unusable from this time,
775		- so we force application to retry to set
776		- the correct hardware parameter settings */
777		- snd_pcm_set_state(substream, SNDRV_PCM_STATE_OPEN);
778		- if (substream->ops->hw_free != NULL)
779		- substream->ops->hw_free(substream);
	812	+ if (err) {
	813	+ /* hardware might be unusable from this time,
	814	+ * so we force application to retry to set
	815	+ * the correct hardware parameter settings
	816	+ */
	817	+ snd_pcm_set_state(substream, SNDRV_PCM_STATE_OPEN);
	818	+ if (substream->ops->hw_free != NULL)
	819	+ substream->ops->hw_free(substream);
	820	+ if (substream->managed_buffer_alloc)
	821	+ snd_pcm_lib_free_pages(substream);
	822	+ }
	823	+ unlock:
	824	+ snd_pcm_buffer_access_unlock(runtime);
780	825	return err;
781	826	}
782	827
..	..	@@ -801,6 +846,18 @@
801	846	return err;
802	847	}
803	848
	849	+static int do_hw_free(struct snd_pcm_substream *substream)
	850	+{
	851	+ int result = 0;
	852	+
	853	+ snd_pcm_sync_stop(substream, true);
	854	+ if (substream->ops->hw_free)
	855	+ result = substream->ops->hw_free(substream);
	856	+ if (substream->managed_buffer_alloc)
	857	+ snd_pcm_lib_free_pages(substream);
	858	+ return result;
	859	+}
	860	+
804	861	static int snd_pcm_hw_free(struct snd_pcm_substream *substream)
805	862	{
806	863	struct snd_pcm_runtime *runtime;
..	..	@@ -809,22 +866,28 @@
809	866	if (PCM_RUNTIME_CHECK(substream))
810	867	return -ENXIO;
811	868	runtime = substream->runtime;
	869	+ result = snd_pcm_buffer_access_lock(runtime);
	870	+ if (result < 0)
	871	+ return result;
812	872	snd_pcm_stream_lock_irq(substream);
813	873	switch (runtime->status->state) {
814	874	case SNDRV_PCM_STATE_SETUP:
815	875	case SNDRV_PCM_STATE_PREPARED:
	876	+ if (atomic_read(&substream->mmap_count))
	877	+ result = -EBADFD;
816	878	break;
817	879	default:
818		- snd_pcm_stream_unlock_irq(substream);
819		- return -EBADFD;
	880	+ result = -EBADFD;
	881	+ break;
820	882	}
821	883	snd_pcm_stream_unlock_irq(substream);
822		- if (atomic_read(&substream->mmap_count))
823		- return -EBADFD;
824		- if (substream->ops->hw_free)
825		- result = substream->ops->hw_free(substream);
	884	+ if (result)
	885	+ goto unlock;
	886	+ result = do_hw_free(substream);
826	887	snd_pcm_set_state(substream, SNDRV_PCM_STATE_OPEN);
827		- pm_qos_remove_request(&substream->latency_pm_qos_req);
	888	+ cpu_latency_qos_remove_request(&substream->latency_pm_qos_req);
	889	+ unlock:
	890	+ snd_pcm_buffer_access_unlock(runtime);
828	891	return result;
829	892	}
830	893
..	..	@@ -908,8 +971,8 @@
908	971	return delay + substream->runtime->delay;
909	972	}
910	973
911		-int snd_pcm_status(struct snd_pcm_substream *substream,
912		- struct snd_pcm_status *status)
	974	+int snd_pcm_status64(struct snd_pcm_substream *substream,
	975	+ struct snd_pcm_status64 *status)
913	976	{
914	977	struct snd_pcm_runtime *runtime = substream->runtime;
915	978
..	..	@@ -935,14 +998,22 @@
935	998	status->suspended_state = runtime->status->suspended_state;
936	999	if (status->state == SNDRV_PCM_STATE_OPEN)
937	1000	goto _end;
938		- status->trigger_tstamp = runtime->trigger_tstamp;
	1001	+ status->trigger_tstamp_sec = runtime->trigger_tstamp.tv_sec;
	1002	+ status->trigger_tstamp_nsec = runtime->trigger_tstamp.tv_nsec;
939	1003	if (snd_pcm_running(substream)) {
940	1004	snd_pcm_update_hw_ptr(substream);
941	1005	if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE) {
942		- status->tstamp = runtime->status->tstamp;
943		- status->driver_tstamp = runtime->driver_tstamp;
944		- status->audio_tstamp =
945		- runtime->status->audio_tstamp;
	1006	+ status->tstamp_sec = runtime->status->tstamp.tv_sec;
	1007	+ status->tstamp_nsec =
	1008	+ runtime->status->tstamp.tv_nsec;
	1009	+ status->driver_tstamp_sec =
	1010	+ runtime->driver_tstamp.tv_sec;
	1011	+ status->driver_tstamp_nsec =
	1012	+ runtime->driver_tstamp.tv_nsec;
	1013	+ status->audio_tstamp_sec =
	1014	+ runtime->status->audio_tstamp.tv_sec;
	1015	+ status->audio_tstamp_nsec =
	1016	+ runtime->status->audio_tstamp.tv_nsec;
946	1017	if (runtime->audio_tstamp_report.valid == 1)
947	1018	/* backwards compatibility, no report provided in COMPAT mode */
948	1019	snd_pcm_pack_audio_tstamp_report(&status->audio_tstamp_data,
..	..	@@ -953,8 +1024,13 @@
953	1024	}
954	1025	} else {
955	1026	/* get tstamp only in fallback mode and only if enabled */
956		- if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
957		- snd_pcm_gettime(runtime, &status->tstamp);
	1027	+ if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE) {
	1028	+ struct timespec64 tstamp;
	1029	+
	1030	+ snd_pcm_gettime(runtime, &tstamp);
	1031	+ status->tstamp_sec = tstamp.tv_sec;
	1032	+ status->tstamp_nsec = tstamp.tv_nsec;
	1033	+ }
958	1034	}
959	1035	_tstamp_end:
960	1036	status->appl_ptr = runtime->control->appl_ptr;
..	..	@@ -971,11 +1047,11 @@
971	1047	return 0;
972	1048	}
973	1049
974		-static int snd_pcm_status_user(struct snd_pcm_substream *substream,
975		- struct snd_pcm_status __user * _status,
976		- bool ext)
	1050	+static int snd_pcm_status_user64(struct snd_pcm_substream *substream,
	1051	+ struct snd_pcm_status64 __user * _status,
	1052	+ bool ext)
977	1053	{
978		- struct snd_pcm_status status;
	1054	+ struct snd_pcm_status64 status;
979	1055	int res;
980	1056
981	1057	memset(&status, 0, sizeof(status));
..	..	@@ -987,11 +1063,60 @@
987	1063	if (ext && get_user(status.audio_tstamp_data,
988	1064	(u32 __user *)(&_status->audio_tstamp_data)))
989	1065	return -EFAULT;
990		- res = snd_pcm_status(substream, &status);
	1066	+ res = snd_pcm_status64(substream, &status);
991	1067	if (res < 0)
992	1068	return res;
993	1069	if (copy_to_user(_status, &status, sizeof(status)))
994	1070	return -EFAULT;
	1071	+ return 0;
	1072	+}
	1073	+
	1074	+static int snd_pcm_status_user32(struct snd_pcm_substream *substream,
	1075	+ struct snd_pcm_status32 __user * _status,
	1076	+ bool ext)
	1077	+{
	1078	+ struct snd_pcm_status64 status64;
	1079	+ struct snd_pcm_status32 status32;
	1080	+ int res;
	1081	+
	1082	+ memset(&status64, 0, sizeof(status64));
	1083	+ memset(&status32, 0, sizeof(status32));
	1084	+ /*
	1085	+ * with extension, parameters are read/write,
	1086	+ * get audio_tstamp_data from user,
	1087	+ * ignore rest of status structure
	1088	+ */
	1089	+ if (ext && get_user(status64.audio_tstamp_data,
	1090	+ (u32 __user *)(&_status->audio_tstamp_data)))
	1091	+ return -EFAULT;
	1092	+ res = snd_pcm_status64(substream, &status64);
	1093	+ if (res < 0)
	1094	+ return res;
	1095	+
	1096	+ status32 = (struct snd_pcm_status32) {
	1097	+ .state = status64.state,
	1098	+ .trigger_tstamp_sec = status64.trigger_tstamp_sec,
	1099	+ .trigger_tstamp_nsec = status64.trigger_tstamp_nsec,
	1100	+ .tstamp_sec = status64.tstamp_sec,
	1101	+ .tstamp_nsec = status64.tstamp_nsec,
	1102	+ .appl_ptr = status64.appl_ptr,
	1103	+ .hw_ptr = status64.hw_ptr,
	1104	+ .delay = status64.delay,
	1105	+ .avail = status64.avail,
	1106	+ .avail_max = status64.avail_max,
	1107	+ .overrange = status64.overrange,
	1108	+ .suspended_state = status64.suspended_state,
	1109	+ .audio_tstamp_data = status64.audio_tstamp_data,
	1110	+ .audio_tstamp_sec = status64.audio_tstamp_sec,
	1111	+ .audio_tstamp_nsec = status64.audio_tstamp_nsec,
	1112	+ .driver_tstamp_sec = status64.audio_tstamp_sec,
	1113	+ .driver_tstamp_nsec = status64.audio_tstamp_nsec,
	1114	+ .audio_tstamp_accuracy = status64.audio_tstamp_accuracy,
	1115	+ };
	1116	+
	1117	+ if (copy_to_user(_status, &status32, sizeof(status32)))
	1118	+ return -EFAULT;
	1119	+
995	1120	return 0;
996	1121	}
997	1122
..	..	@@ -1013,7 +1138,7 @@
1013	1138	return -EINVAL;
1014	1139	memset(info, 0, sizeof(*info));
1015	1140	info->channel = channel;
1016		- return substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_CHANNEL_INFO, info);
	1141	+ return snd_pcm_ops_ioctl(substream, SNDRV_PCM_IOCTL1_CHANNEL_INFO, info);
1017	1142	}
1018	1143
1019	1144	static int snd_pcm_channel_info_user(struct snd_pcm_substream *substream,
..	..	@@ -1047,11 +1172,17 @@
1047	1172	runtime->trigger_master = NULL;
1048	1173	}
1049	1174
	1175	+#define ACTION_ARG_IGNORE (__force snd_pcm_state_t)0
	1176	+
1050	1177	struct action_ops {
1051		- int (pre_action)(struct snd_pcm_substream substream, int state);
1052		- int (do_action)(struct snd_pcm_substream substream, int state);
1053		- void (undo_action)(struct snd_pcm_substream substream, int state);
1054		- void (post_action)(struct snd_pcm_substream substream, int state);
	1178	+ int (pre_action)(struct snd_pcm_substream substream,
	1179	+ snd_pcm_state_t state);
	1180	+ int (do_action)(struct snd_pcm_substream substream,
	1181	+ snd_pcm_state_t state);
	1182	+ void (undo_action)(struct snd_pcm_substream substream,
	1183	+ snd_pcm_state_t state);
	1184	+ void (post_action)(struct snd_pcm_substream substream,
	1185	+ snd_pcm_state_t state);
1055	1186	};
1056	1187
1057	1188	/*
..	..	@@ -1061,15 +1192,18 @@
1061	1192	*/
1062	1193	static int snd_pcm_action_group(const struct action_ops *ops,
1063	1194	struct snd_pcm_substream *substream,
1064		- int state, int do_lock)
	1195	+ snd_pcm_state_t state,
	1196	+ bool stream_lock)
1065	1197	{
1066	1198	struct snd_pcm_substream *s = NULL;
1067	1199	struct snd_pcm_substream *s1;
1068	1200	int res = 0, depth = 1;
1069	1201
1070	1202	snd_pcm_group_for_each_entry(s, substream) {
1071		- if (do_lock && s != substream) {
1072		- if (s->pcm->nonatomic)
	1203	+ if (s != substream) {
	1204	+ if (!stream_lock)
	1205	+ mutex_lock_nested(&s->runtime->buffer_mutex, depth);
	1206	+ else if (s->pcm->nonatomic)
1073	1207	mutex_lock_nested(&s->self_group.mutex, depth);
1074	1208	else
1075	1209	spin_lock_nested(&s->self_group.lock, depth);
..	..	@@ -1097,18 +1231,18 @@
1097	1231	ops->post_action(s, state);
1098	1232	}
1099	1233	_unlock:
1100		- if (do_lock) {
1101		- /* unlock streams */
1102		- snd_pcm_group_for_each_entry(s1, substream) {
1103		- if (s1 != substream) {
1104		- if (s1->pcm->nonatomic)
1105		- mutex_unlock(&s1->self_group.mutex);
1106		- else
1107		- spin_unlock(&s1->self_group.lock);
1108		- }
1109		- if (s1 == s) /* end */
1110		- break;
	1234	+ /* unlock streams */
	1235	+ snd_pcm_group_for_each_entry(s1, substream) {
	1236	+ if (s1 != substream) {
	1237	+ if (!stream_lock)
	1238	+ mutex_unlock(&s1->runtime->buffer_mutex);
	1239	+ else if (s1->pcm->nonatomic)
	1240	+ mutex_unlock(&s1->self_group.mutex);
	1241	+ else
	1242	+ spin_unlock(&s1->self_group.lock);
1111	1243	}
	1244	+ if (s1 == s) /* end */
	1245	+ break;
1112	1246	}
1113	1247	return res;
1114	1248	}
..	..	@@ -1118,7 +1252,7 @@
1118	1252	*/
1119	1253	static int snd_pcm_action_single(const struct action_ops *ops,
1120	1254	struct snd_pcm_substream *substream,
1121		- int state)
	1255	+ snd_pcm_state_t state)
1122	1256	{
1123	1257	int res;
1124	1258
..	..	@@ -1133,35 +1267,83 @@
1133	1267	return res;
1134	1268	}
1135	1269
	1270	+static void snd_pcm_group_assign(struct snd_pcm_substream *substream,
	1271	+ struct snd_pcm_group *new_group)
	1272	+{
	1273	+ substream->group = new_group;
	1274	+ list_move(&substream->link_list, &new_group->substreams);
	1275	+}
	1276	+
	1277	+/*
	1278	+ * Unref and unlock the group, but keep the stream lock;
	1279	+ * when the group becomes empty and no longer referred, destroy itself
	1280	+ */
	1281	+static void snd_pcm_group_unref(struct snd_pcm_group *group,
	1282	+ struct snd_pcm_substream *substream)
	1283	+{
	1284	+ bool do_free;
	1285	+
	1286	+ if (!group)
	1287	+ return;
	1288	+ do_free = refcount_dec_and_test(&group->refs);
	1289	+ snd_pcm_group_unlock(group, substream->pcm->nonatomic);
	1290	+ if (do_free)
	1291	+ kfree(group);
	1292	+}
	1293	+
	1294	+/*
	1295	+ * Lock the group inside a stream lock and reference it;
	1296	+ * return the locked group object, or NULL if not linked
	1297	+ */
	1298	+static struct snd_pcm_group *
	1299	+snd_pcm_stream_group_ref(struct snd_pcm_substream *substream)
	1300	+{
	1301	+ bool nonatomic = substream->pcm->nonatomic;
	1302	+ struct snd_pcm_group *group;
	1303	+ bool trylock;
	1304	+
	1305	+ for (;;) {
	1306	+ if (!snd_pcm_stream_linked(substream))
	1307	+ return NULL;
	1308	+ group = substream->group;
	1309	+ /* block freeing the group object */
	1310	+ refcount_inc(&group->refs);
	1311	+
	1312	+ trylock = nonatomic ? mutex_trylock(&group->mutex) :
	1313	+ spin_trylock(&group->lock);
	1314	+ if (trylock)
	1315	+ break; /* OK */
	1316	+
	1317	+ /* re-lock for avoiding ABBA deadlock */
	1318	+ snd_pcm_stream_unlock(substream);
	1319	+ snd_pcm_group_lock(group, nonatomic);
	1320	+ snd_pcm_stream_lock(substream);
	1321	+
	1322	+ /* check the group again; the above opens a small race window */
	1323	+ if (substream->group == group)
	1324	+ break; /* OK */
	1325	+ /* group changed, try again */
	1326	+ snd_pcm_group_unref(group, substream);
	1327	+ }
	1328	+ return group;
	1329	+}
	1330	+
1136	1331	/*
1137	1332	* Note: call with stream lock
1138	1333	*/
1139	1334	static int snd_pcm_action(const struct action_ops *ops,
1140	1335	struct snd_pcm_substream *substream,
1141		- int state)
	1336	+ snd_pcm_state_t state)
1142	1337	{
	1338	+ struct snd_pcm_group *group;
1143	1339	int res;
1144	1340
1145		- if (!snd_pcm_stream_linked(substream))
1146		- return snd_pcm_action_single(ops, substream, state);
1147		-
1148		- if (substream->pcm->nonatomic) {
1149		- if (!mutex_trylock(&substream->group->mutex)) {
1150		- mutex_unlock(&substream->self_group.mutex);
1151		- mutex_lock(&substream->group->mutex);
1152		- mutex_lock(&substream->self_group.mutex);
1153		- }
1154		- res = snd_pcm_action_group(ops, substream, state, 1);
1155		- mutex_unlock(&substream->group->mutex);
1156		- } else {
1157		- if (!spin_trylock(&substream->group->lock)) {
1158		- spin_unlock(&substream->self_group.lock);
1159		- spin_lock(&substream->group->lock);
1160		- spin_lock(&substream->self_group.lock);
1161		- }
1162		- res = snd_pcm_action_group(ops, substream, state, 1);
1163		- spin_unlock(&substream->group->lock);
1164		- }
	1341	+ group = snd_pcm_stream_group_ref(substream);
	1342	+ if (group)
	1343	+ res = snd_pcm_action_group(ops, substream, state, true);
	1344	+ else
	1345	+ res = snd_pcm_action_single(ops, substream, state);
	1346	+ snd_pcm_group_unref(group, substream);
1165	1347	return res;
1166	1348	}
1167	1349
..	..	@@ -1170,7 +1352,7 @@
1170	1352	*/
1171	1353	static int snd_pcm_action_lock_irq(const struct action_ops *ops,
1172	1354	struct snd_pcm_substream *substream,
1173		- int state)
	1355	+ snd_pcm_state_t state)
1174	1356	{
1175	1357	int res;
1176	1358
..	..	@@ -1184,15 +1366,21 @@
1184	1366	*/
1185	1367	static int snd_pcm_action_nonatomic(const struct action_ops *ops,
1186	1368	struct snd_pcm_substream *substream,
1187		- int state)
	1369	+ snd_pcm_state_t state)
1188	1370	{
1189	1371	int res;
1190	1372
	1373	+ /* Guarantee the group members won't change during non-atomic action */
1191	1374	down_read(&snd_pcm_link_rwsem);
	1375	+ res = snd_pcm_buffer_access_lock(substream->runtime);
	1376	+ if (res < 0)
	1377	+ goto unlock;
1192	1378	if (snd_pcm_stream_linked(substream))
1193		- res = snd_pcm_action_group(ops, substream, state, 0);
	1379	+ res = snd_pcm_action_group(ops, substream, state, false);
1194	1380	else
1195	1381	res = snd_pcm_action_single(ops, substream, state);
	1382	+ snd_pcm_buffer_access_unlock(substream->runtime);
	1383	+ unlock:
1196	1384	up_read(&snd_pcm_link_rwsem);
1197	1385	return res;
1198	1386	}
..	..	@@ -1200,7 +1388,8 @@
1200	1388	/*
1201	1389	* start callbacks
1202	1390	*/
1203		-static int snd_pcm_pre_start(struct snd_pcm_substream *substream, int state)
	1391	+static int snd_pcm_pre_start(struct snd_pcm_substream *substream,
	1392	+ snd_pcm_state_t state)
1204	1393	{
1205	1394	struct snd_pcm_runtime *runtime = substream->runtime;
1206	1395	if (runtime->status->state != SNDRV_PCM_STATE_PREPARED)
..	..	@@ -1213,20 +1402,23 @@
1213	1402	return 0;
1214	1403	}
1215	1404
1216		-static int snd_pcm_do_start(struct snd_pcm_substream *substream, int state)
	1405	+static int snd_pcm_do_start(struct snd_pcm_substream *substream,
	1406	+ snd_pcm_state_t state)
1217	1407	{
1218	1408	if (substream->runtime->trigger_master != substream)
1219	1409	return 0;
1220	1410	return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_START);
1221	1411	}
1222	1412
1223		-static void snd_pcm_undo_start(struct snd_pcm_substream *substream, int state)
	1413	+static void snd_pcm_undo_start(struct snd_pcm_substream *substream,
	1414	+ snd_pcm_state_t state)
1224	1415	{
1225	1416	if (substream->runtime->trigger_master == substream)
1226	1417	substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_STOP);
1227	1418	}
1228	1419
1229		-static void snd_pcm_post_start(struct snd_pcm_substream *substream, int state)
	1420	+static void snd_pcm_post_start(struct snd_pcm_substream *substream,
	1421	+ snd_pcm_state_t state)
1230	1422	{
1231	1423	struct snd_pcm_runtime *runtime = substream->runtime;
1232	1424	snd_pcm_trigger_tstamp(substream);
..	..	@@ -1270,7 +1462,8 @@
1270	1462	/*
1271	1463	* stop callbacks
1272	1464	*/
1273		-static int snd_pcm_pre_stop(struct snd_pcm_substream *substream, int state)
	1465	+static int snd_pcm_pre_stop(struct snd_pcm_substream *substream,
	1466	+ snd_pcm_state_t state)
1274	1467	{
1275	1468	struct snd_pcm_runtime *runtime = substream->runtime;
1276	1469	if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
..	..	@@ -1279,15 +1472,19 @@
1279	1472	return 0;
1280	1473	}
1281	1474
1282		-static int snd_pcm_do_stop(struct snd_pcm_substream *substream, int state)
	1475	+static int snd_pcm_do_stop(struct snd_pcm_substream *substream,
	1476	+ snd_pcm_state_t state)
1283	1477	{
1284	1478	if (substream->runtime->trigger_master == substream &&
1285		- snd_pcm_running(substream))
	1479	+ snd_pcm_running(substream)) {
1286	1480	substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_STOP);
	1481	+ substream->runtime->stop_operating = true;
	1482	+ }
1287	1483	return 0; /* unconditonally stop all substreams */
1288	1484	}
1289	1485
1290		-static void snd_pcm_post_stop(struct snd_pcm_substream *substream, int state)
	1486	+static void snd_pcm_post_stop(struct snd_pcm_substream *substream,
	1487	+ snd_pcm_state_t state)
1291	1488	{
1292	1489	struct snd_pcm_runtime *runtime = substream->runtime;
1293	1490	if (runtime->status->state != state) {
..	..	@@ -1357,14 +1554,17 @@
1357	1554	EXPORT_SYMBOL_GPL(snd_pcm_stop_xrun);
1358	1555
1359	1556	/*
1360		- * pause callbacks
	1557	+ * pause callbacks: pass boolean (to start pause or resume) as state argument
1361	1558	*/
1362		-static int snd_pcm_pre_pause(struct snd_pcm_substream *substream, int push)
	1559	+#define pause_pushed(state) (__force bool)(state)
	1560	+
	1561	+static int snd_pcm_pre_pause(struct snd_pcm_substream *substream,
	1562	+ snd_pcm_state_t state)
1363	1563	{
1364	1564	struct snd_pcm_runtime *runtime = substream->runtime;
1365	1565	if (!(runtime->info & SNDRV_PCM_INFO_PAUSE))
1366	1566	return -ENOSYS;
1367		- if (push) {
	1567	+ if (pause_pushed(state)) {
1368	1568	if (runtime->status->state != SNDRV_PCM_STATE_RUNNING)
1369	1569	return -EBADFD;
1370	1570	} else if (runtime->status->state != SNDRV_PCM_STATE_PAUSED)
..	..	@@ -1373,13 +1573,14 @@
1373	1573	return 0;
1374	1574	}
1375	1575
1376		-static int snd_pcm_do_pause(struct snd_pcm_substream *substream, int push)
	1576	+static int snd_pcm_do_pause(struct snd_pcm_substream *substream,
	1577	+ snd_pcm_state_t state)
1377	1578	{
1378	1579	if (substream->runtime->trigger_master != substream)
1379	1580	return 0;
1380	1581	/* some drivers might use hw_ptr to recover from the pause -
1381	1582	update the hw_ptr now */
1382		- if (push)
	1583	+ if (pause_pushed(state))
1383	1584	snd_pcm_update_hw_ptr(substream);
1384	1585	/* The jiffies check in snd_pcm_update_hw_ptr*() is done by
1385	1586	* a delta between the current jiffies, this gives a large enough
..	..	@@ -1387,23 +1588,27 @@
1387	1588	*/
1388	1589	substream->runtime->hw_ptr_jiffies = jiffies - HZ * 1000;
1389	1590	return substream->ops->trigger(substream,
1390		- push ? SNDRV_PCM_TRIGGER_PAUSE_PUSH :
1391		- SNDRV_PCM_TRIGGER_PAUSE_RELEASE);
	1591	+ pause_pushed(state) ?
	1592	+ SNDRV_PCM_TRIGGER_PAUSE_PUSH :
	1593	+ SNDRV_PCM_TRIGGER_PAUSE_RELEASE);
1392	1594	}
1393	1595
1394		-static void snd_pcm_undo_pause(struct snd_pcm_substream *substream, int push)
	1596	+static void snd_pcm_undo_pause(struct snd_pcm_substream *substream,
	1597	+ snd_pcm_state_t state)
1395	1598	{
1396	1599	if (substream->runtime->trigger_master == substream)
1397	1600	substream->ops->trigger(substream,
1398		- push ? SNDRV_PCM_TRIGGER_PAUSE_RELEASE :
	1601	+ pause_pushed(state) ?
	1602	+ SNDRV_PCM_TRIGGER_PAUSE_RELEASE :
1399	1603	SNDRV_PCM_TRIGGER_PAUSE_PUSH);
1400	1604	}
1401	1605
1402		-static void snd_pcm_post_pause(struct snd_pcm_substream *substream, int push)
	1606	+static void snd_pcm_post_pause(struct snd_pcm_substream *substream,
	1607	+ snd_pcm_state_t state)
1403	1608	{
1404	1609	struct snd_pcm_runtime *runtime = substream->runtime;
1405	1610	snd_pcm_trigger_tstamp(substream);
1406		- if (push) {
	1611	+ if (pause_pushed(state)) {
1407	1612	runtime->status->state = SNDRV_PCM_STATE_PAUSED;
1408	1613	snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MPAUSE);
1409	1614	wake_up(&runtime->sleep);
..	..	@@ -1424,15 +1629,24 @@
1424	1629	/*
1425	1630	* Push/release the pause for all linked streams.
1426	1631	*/
1427		-static int snd_pcm_pause(struct snd_pcm_substream *substream, int push)
	1632	+static int snd_pcm_pause(struct snd_pcm_substream *substream, bool push)
1428	1633	{
1429		- return snd_pcm_action(&snd_pcm_action_pause, substream, push);
	1634	+ return snd_pcm_action(&snd_pcm_action_pause, substream,
	1635	+ (__force snd_pcm_state_t)push);
	1636	+}
	1637	+
	1638	+static int snd_pcm_pause_lock_irq(struct snd_pcm_substream *substream,
	1639	+ bool push)
	1640	+{
	1641	+ return snd_pcm_action_lock_irq(&snd_pcm_action_pause, substream,
	1642	+ (__force snd_pcm_state_t)push);
1430	1643	}
1431	1644
1432	1645	#ifdef CONFIG_PM
1433		-/* suspend */
	1646	+/* suspend callback: state argument ignored */
1434	1647
1435		-static int snd_pcm_pre_suspend(struct snd_pcm_substream *substream, int state)
	1648	+static int snd_pcm_pre_suspend(struct snd_pcm_substream *substream,
	1649	+ snd_pcm_state_t state)
1436	1650	{
1437	1651	struct snd_pcm_runtime *runtime = substream->runtime;
1438	1652	switch (runtime->status->state) {
..	..	@@ -1448,7 +1662,8 @@
1448	1662	return 0;
1449	1663	}
1450	1664
1451		-static int snd_pcm_do_suspend(struct snd_pcm_substream *substream, int state)
	1665	+static int snd_pcm_do_suspend(struct snd_pcm_substream *substream,
	1666	+ snd_pcm_state_t state)
1452	1667	{
1453	1668	struct snd_pcm_runtime *runtime = substream->runtime;
1454	1669	if (runtime->trigger_master != substream)
..	..	@@ -1456,10 +1671,12 @@
1456	1671	if (! snd_pcm_running(substream))
1457	1672	return 0;
1458	1673	substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_SUSPEND);
	1674	+ runtime->stop_operating = true;
1459	1675	return 0; /* suspend unconditionally */
1460	1676	}
1461	1677
1462		-static void snd_pcm_post_suspend(struct snd_pcm_substream *substream, int state)
	1678	+static void snd_pcm_post_suspend(struct snd_pcm_substream *substream,
	1679	+ snd_pcm_state_t state)
1463	1680	{
1464	1681	struct snd_pcm_runtime *runtime = substream->runtime;
1465	1682	snd_pcm_trigger_tstamp(substream);
..	..	@@ -1476,29 +1693,25 @@
1476	1693	.post_action = snd_pcm_post_suspend
1477	1694	};
1478	1695
1479		-/**
	1696	+/*
1480	1697	* snd_pcm_suspend - trigger SUSPEND to all linked streams
1481	1698	* @substream: the PCM substream
1482	1699	*
1483	1700	* After this call, all streams are changed to SUSPENDED state.
1484	1701	*
1485		- * Return: Zero if successful (or @substream is %NULL), or a negative error
1486		- * code.
	1702	+ * Return: Zero if successful, or a negative error code.
1487	1703	*/
1488		-int snd_pcm_suspend(struct snd_pcm_substream *substream)
	1704	+static int snd_pcm_suspend(struct snd_pcm_substream *substream)
1489	1705	{
1490	1706	int err;
1491	1707	unsigned long flags;
1492	1708
1493		- if (! substream)
1494		- return 0;
1495		-
1496	1709	snd_pcm_stream_lock_irqsave(substream, flags);
1497		- err = snd_pcm_action(&snd_pcm_action_suspend, substream, 0);
	1710	+ err = snd_pcm_action(&snd_pcm_action_suspend, substream,
	1711	+ ACTION_ARG_IGNORE);
1498	1712	snd_pcm_stream_unlock_irqrestore(substream, flags);
1499	1713	return err;
1500	1714	}
1501		-EXPORT_SYMBOL(snd_pcm_suspend);
1502	1715
1503	1716	/**
1504	1717	* snd_pcm_suspend_all - trigger SUSPEND to all substreams in the given pcm
..	..	@@ -1535,13 +1748,20 @@
1535	1748	return err;
1536	1749	}
1537	1750	}
	1751	+
	1752	+ for (stream = 0; stream < 2; stream++)
	1753	+ for (substream = pcm->streams[stream].substream;
	1754	+ substream; substream = substream->next)
	1755	+ snd_pcm_sync_stop(substream, false);
	1756	+
1538	1757	return 0;
1539	1758	}
1540	1759	EXPORT_SYMBOL(snd_pcm_suspend_all);
1541	1760
1542		-/* resume */
	1761	+/* resume callbacks: state argument ignored */
1543	1762
1544		-static int snd_pcm_pre_resume(struct snd_pcm_substream *substream, int state)
	1763	+static int snd_pcm_pre_resume(struct snd_pcm_substream *substream,
	1764	+ snd_pcm_state_t state)
1545	1765	{
1546	1766	struct snd_pcm_runtime *runtime = substream->runtime;
1547	1767	if (!(runtime->info & SNDRV_PCM_INFO_RESUME))
..	..	@@ -1550,7 +1770,8 @@
1550	1770	return 0;
1551	1771	}
1552	1772
1553		-static int snd_pcm_do_resume(struct snd_pcm_substream *substream, int state)
	1773	+static int snd_pcm_do_resume(struct snd_pcm_substream *substream,
	1774	+ snd_pcm_state_t state)
1554	1775	{
1555	1776	struct snd_pcm_runtime *runtime = substream->runtime;
1556	1777	if (runtime->trigger_master != substream)
..	..	@@ -1563,14 +1784,16 @@
1563	1784	return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_RESUME);
1564	1785	}
1565	1786
1566		-static void snd_pcm_undo_resume(struct snd_pcm_substream *substream, int state)
	1787	+static void snd_pcm_undo_resume(struct snd_pcm_substream *substream,
	1788	+ snd_pcm_state_t state)
1567	1789	{
1568	1790	if (substream->runtime->trigger_master == substream &&
1569	1791	snd_pcm_running(substream))
1570	1792	substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_SUSPEND);
1571	1793	}
1572	1794
1573		-static void snd_pcm_post_resume(struct snd_pcm_substream *substream, int state)
	1795	+static void snd_pcm_post_resume(struct snd_pcm_substream *substream,
	1796	+ snd_pcm_state_t state)
1574	1797	{
1575	1798	struct snd_pcm_runtime *runtime = substream->runtime;
1576	1799	snd_pcm_trigger_tstamp(substream);
..	..	@@ -1587,7 +1810,8 @@
1587	1810
1588	1811	static int snd_pcm_resume(struct snd_pcm_substream *substream)
1589	1812	{
1590		- return snd_pcm_action_lock_irq(&snd_pcm_action_resume, substream, 0);
	1813	+ return snd_pcm_action_lock_irq(&snd_pcm_action_resume, substream,
	1814	+ ACTION_ARG_IGNORE);
1591	1815	}
1592	1816
1593	1817	#else
..	..	@@ -1628,7 +1852,9 @@
1628	1852	/*
1629	1853	* reset ioctl
1630	1854	*/
1631		-static int snd_pcm_pre_reset(struct snd_pcm_substream *substream, int state)
	1855	+/* reset callbacks: state argument ignored */
	1856	+static int snd_pcm_pre_reset(struct snd_pcm_substream *substream,
	1857	+ snd_pcm_state_t state)
1632	1858	{
1633	1859	struct snd_pcm_runtime *runtime = substream->runtime;
1634	1860	switch (runtime->status->state) {
..	..	@@ -1642,27 +1868,33 @@
1642	1868	}
1643	1869	}
1644	1870
1645		-static int snd_pcm_do_reset(struct snd_pcm_substream *substream, int state)
	1871	+static int snd_pcm_do_reset(struct snd_pcm_substream *substream,
	1872	+ snd_pcm_state_t state)
1646	1873	{
1647	1874	struct snd_pcm_runtime *runtime = substream->runtime;
1648		- int err = substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_RESET, NULL);
	1875	+ int err = snd_pcm_ops_ioctl(substream, SNDRV_PCM_IOCTL1_RESET, NULL);
1649	1876	if (err < 0)
1650	1877	return err;
	1878	+ snd_pcm_stream_lock_irq(substream);
1651	1879	runtime->hw_ptr_base = 0;
1652	1880	runtime->hw_ptr_interrupt = runtime->status->hw_ptr -
1653	1881	runtime->status->hw_ptr % runtime->period_size;
1654	1882	runtime->silence_start = runtime->status->hw_ptr;
1655	1883	runtime->silence_filled = 0;
	1884	+ snd_pcm_stream_unlock_irq(substream);
1656	1885	return 0;
1657	1886	}
1658	1887
1659		-static void snd_pcm_post_reset(struct snd_pcm_substream *substream, int state)
	1888	+static void snd_pcm_post_reset(struct snd_pcm_substream *substream,
	1889	+ snd_pcm_state_t state)
1660	1890	{
1661	1891	struct snd_pcm_runtime *runtime = substream->runtime;
	1892	+ snd_pcm_stream_lock_irq(substream);
1662	1893	runtime->control->appl_ptr = runtime->status->hw_ptr;
1663	1894	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
1664	1895	runtime->silence_size > 0)
1665	1896	snd_pcm_playback_silence(substream, ULONG_MAX);
	1897	+ snd_pcm_stream_unlock_irq(substream);
1666	1898	}
1667	1899
1668	1900	static const struct action_ops snd_pcm_action_reset = {
..	..	@@ -1673,17 +1905,20 @@
1673	1905
1674	1906	static int snd_pcm_reset(struct snd_pcm_substream *substream)
1675	1907	{
1676		- return snd_pcm_action_nonatomic(&snd_pcm_action_reset, substream, 0);
	1908	+ return snd_pcm_action_nonatomic(&snd_pcm_action_reset, substream,
	1909	+ ACTION_ARG_IGNORE);
1677	1910	}
1678	1911
1679	1912	/*
1680	1913	* prepare ioctl
1681	1914	*/
1682		-/* we use the second argument for updating f_flags */
	1915	+/* pass f_flags as state argument */
1683	1916	static int snd_pcm_pre_prepare(struct snd_pcm_substream *substream,
1684		- int f_flags)
	1917	+ snd_pcm_state_t state)
1685	1918	{
1686	1919	struct snd_pcm_runtime *runtime = substream->runtime;
	1920	+ int f_flags = (__force int)state;
	1921	+
1687	1922	if (runtime->status->state == SNDRV_PCM_STATE_OPEN \|\|
1688	1923	runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
1689	1924	return -EBADFD;
..	..	@@ -1693,16 +1928,19 @@
1693	1928	return 0;
1694	1929	}
1695	1930
1696		-static int snd_pcm_do_prepare(struct snd_pcm_substream *substream, int state)
	1931	+static int snd_pcm_do_prepare(struct snd_pcm_substream *substream,
	1932	+ snd_pcm_state_t state)
1697	1933	{
1698	1934	int err;
	1935	+ snd_pcm_sync_stop(substream, true);
1699	1936	err = substream->ops->prepare(substream);
1700	1937	if (err < 0)
1701	1938	return err;
1702		- return snd_pcm_do_reset(substream, 0);
	1939	+ return snd_pcm_do_reset(substream, state);
1703	1940	}
1704	1941
1705		-static void snd_pcm_post_prepare(struct snd_pcm_substream *substream, int state)
	1942	+static void snd_pcm_post_prepare(struct snd_pcm_substream *substream,
	1943	+ snd_pcm_state_t state)
1706	1944	{
1707	1945	struct snd_pcm_runtime *runtime = substream->runtime;
1708	1946	runtime->control->appl_ptr = runtime->status->hw_ptr;
..	..	@@ -1735,8 +1973,8 @@
1735	1973	snd_pcm_stream_lock_irq(substream);
1736	1974	switch (substream->runtime->status->state) {
1737	1975	case SNDRV_PCM_STATE_PAUSED:
1738		- snd_pcm_pause(substream, 0);
1739		- /* fallthru */
	1976	+ snd_pcm_pause(substream, false);
	1977	+ fallthrough;
1740	1978	case SNDRV_PCM_STATE_SUSPENDED:
1741	1979	snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
1742	1980	break;
..	..	@@ -1744,14 +1982,17 @@
1744	1982	snd_pcm_stream_unlock_irq(substream);
1745	1983
1746	1984	return snd_pcm_action_nonatomic(&snd_pcm_action_prepare,
1747		- substream, f_flags);
	1985	+ substream,
	1986	+ (__force snd_pcm_state_t)f_flags);
1748	1987	}
1749	1988
1750	1989	/*
1751	1990	* drain ioctl
1752	1991	*/
1753	1992
1754		-static int snd_pcm_pre_drain_init(struct snd_pcm_substream *substream, int state)
	1993	+/* drain init callbacks: state argument ignored */
	1994	+static int snd_pcm_pre_drain_init(struct snd_pcm_substream *substream,
	1995	+ snd_pcm_state_t state)
1755	1996	{
1756	1997	struct snd_pcm_runtime *runtime = substream->runtime;
1757	1998	switch (runtime->status->state) {
..	..	@@ -1764,7 +2005,8 @@
1764	2005	return 0;
1765	2006	}
1766	2007
1767		-static int snd_pcm_do_drain_init(struct snd_pcm_substream *substream, int state)
	2008	+static int snd_pcm_do_drain_init(struct snd_pcm_substream *substream,
	2009	+ snd_pcm_state_t state)
1768	2010	{
1769	2011	struct snd_pcm_runtime *runtime = substream->runtime;
1770	2012	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
..	..	@@ -1790,7 +2032,9 @@
1790	2032	} else {
1791	2033	/* stop running stream */
1792	2034	if (runtime->status->state == SNDRV_PCM_STATE_RUNNING) {
1793		- int new_state = snd_pcm_capture_avail(runtime) > 0 ?
	2035	+ snd_pcm_state_t new_state;
	2036	+
	2037	+ new_state = snd_pcm_capture_avail(runtime) > 0 ?
1794	2038	SNDRV_PCM_STATE_DRAINING : SNDRV_PCM_STATE_SETUP;
1795	2039	snd_pcm_do_stop(substream, new_state);
1796	2040	snd_pcm_post_stop(substream, new_state);
..	..	@@ -1806,7 +2050,8 @@
1806	2050	return 0;
1807	2051	}
1808	2052
1809		-static void snd_pcm_post_drain_init(struct snd_pcm_substream *substream, int state)
	2053	+static void snd_pcm_post_drain_init(struct snd_pcm_substream *substream,
	2054	+ snd_pcm_state_t state)
1810	2055	{
1811	2056	}
1812	2057
..	..	@@ -1815,8 +2060,6 @@
1815	2060	.do_action = snd_pcm_do_drain_init,
1816	2061	.post_action = snd_pcm_post_drain_init
1817	2062	};
1818		-
1819		-static int snd_pcm_drop(struct snd_pcm_substream *substream);
1820	2063
1821	2064	/*
1822	2065	* Drain the stream(s).
..	..	@@ -1831,6 +2074,7 @@
1831	2074	struct snd_card *card;
1832	2075	struct snd_pcm_runtime *runtime;
1833	2076	struct snd_pcm_substream *s;
	2077	+ struct snd_pcm_group *group;
1834	2078	wait_queue_entry_t wait;
1835	2079	int result = 0;
1836	2080	int nonblock = 0;
..	..	@@ -1847,14 +2091,14 @@
1847	2091	} else if (substream->f_flags & O_NONBLOCK)
1848	2092	nonblock = 1;
1849	2093
1850		- down_read(&snd_pcm_link_rwsem);
1851	2094	snd_pcm_stream_lock_irq(substream);
1852	2095	/* resume pause */
1853	2096	if (runtime->status->state == SNDRV_PCM_STATE_PAUSED)
1854		- snd_pcm_pause(substream, 0);
	2097	+ snd_pcm_pause(substream, false);
1855	2098
1856	2099	/* pre-start/stop - all running streams are changed to DRAINING state */
1857		- result = snd_pcm_action(&snd_pcm_action_drain_init, substream, 0);
	2100	+ result = snd_pcm_action(&snd_pcm_action_drain_init, substream,
	2101	+ ACTION_ARG_IGNORE);
1858	2102	if (result < 0)
1859	2103	goto unlock;
1860	2104	/* in non-blocking, we don't wait in ioctl but let caller poll */
..	..	@@ -1872,6 +2116,7 @@
1872	2116	}
1873	2117	/* find a substream to drain */
1874	2118	to_check = NULL;
	2119	+ group = snd_pcm_stream_group_ref(substream);
1875	2120	snd_pcm_group_for_each_entry(s, substream) {
1876	2121	if (s->stream != SNDRV_PCM_STREAM_PLAYBACK)
1877	2122	continue;
..	..	@@ -1881,12 +2126,13 @@
1881	2126	break;
1882	2127	}
1883	2128	}
	2129	+ snd_pcm_group_unref(group, substream);
1884	2130	if (!to_check)
1885	2131	break; /* all drained */
1886	2132	init_waitqueue_entry(&wait, current);
	2133	+ set_current_state(TASK_INTERRUPTIBLE);
1887	2134	add_wait_queue(&to_check->sleep, &wait);
1888	2135	snd_pcm_stream_unlock_irq(substream);
1889		- up_read(&snd_pcm_link_rwsem);
1890	2136	if (runtime->no_period_wakeup)
1891	2137	tout = MAX_SCHEDULE_TIMEOUT;
1892	2138	else {
..	..	@@ -1897,10 +2143,18 @@
1897	2143	}
1898	2144	tout = msecs_to_jiffies(tout * 1000);
1899	2145	}
1900		- tout = schedule_timeout_interruptible(tout);
1901		- down_read(&snd_pcm_link_rwsem);
	2146	+ tout = schedule_timeout(tout);
	2147	+
1902	2148	snd_pcm_stream_lock_irq(substream);
1903		- remove_wait_queue(&to_check->sleep, &wait);
	2149	+ group = snd_pcm_stream_group_ref(substream);
	2150	+ snd_pcm_group_for_each_entry(s, substream) {
	2151	+ if (s->runtime == to_check) {
	2152	+ remove_wait_queue(&to_check->sleep, &wait);
	2153	+ break;
	2154	+ }
	2155	+ }
	2156	+ snd_pcm_group_unref(group, substream);
	2157	+
1904	2158	if (card->shutdown) {
1905	2159	result = -ENODEV;
1906	2160	break;
..	..	@@ -1920,7 +2174,6 @@
1920	2174
1921	2175	unlock:
1922	2176	snd_pcm_stream_unlock_irq(substream);
1923		- up_read(&snd_pcm_link_rwsem);
1924	2177
1925	2178	return result;
1926	2179	}
..	..	@@ -1946,7 +2199,7 @@
1946	2199	snd_pcm_stream_lock_irq(substream);
1947	2200	/* resume pause */
1948	2201	if (runtime->status->state == SNDRV_PCM_STATE_PAUSED)
1949		- snd_pcm_pause(substream, 0);
	2202	+ snd_pcm_pause(substream, false);
1950	2203
1951	2204	snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
1952	2205	/* runtime->control->appl_ptr = runtime->status->hw_ptr; */
..	..	@@ -1959,13 +2212,19 @@
1959	2212	static bool is_pcm_file(struct file *file)
1960	2213	{
1961	2214	struct inode *inode = file_inode(file);
	2215	+ struct snd_pcm *pcm;
1962	2216	unsigned int minor;
1963	2217
1964	2218	if (!S_ISCHR(inode->i_mode) \|\| imajor(inode) != snd_major)
1965	2219	return false;
1966	2220	minor = iminor(inode);
1967		- return snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_PLAYBACK) \|\|
1968		- snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_CAPTURE);
	2221	+ pcm = snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_PLAYBACK);
	2222	+ if (!pcm)
	2223	+ pcm = snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_CAPTURE);
	2224	+ if (!pcm)
	2225	+ return false;
	2226	+ snd_card_unref(pcm->card);
	2227	+ return true;
1969	2228	}
1970	2229
1971	2230	/*
..	..	@@ -1976,7 +2235,8 @@
1976	2235	int res = 0;
1977	2236	struct snd_pcm_file *pcm_file;
1978	2237	struct snd_pcm_substream *substream1;
1979		- struct snd_pcm_group *group;
	2238	+ struct snd_pcm_group group, target_group;
	2239	+ bool nonatomic = substream->pcm->nonatomic;
1980	2240	struct fd f = fdget(fd);
1981	2241
1982	2242	if (!f.file)
..	..	@@ -1987,18 +2247,20 @@
1987	2247	}
1988	2248	pcm_file = f.file->private_data;
1989	2249	substream1 = pcm_file->substream;
	2250	+
1990	2251	if (substream == substream1) {
1991	2252	res = -EINVAL;
1992	2253	goto _badf;
1993	2254	}
1994	2255
1995		- group = kmalloc(sizeof(*group), GFP_KERNEL);
	2256	+ group = kzalloc(sizeof(*group), GFP_KERNEL);
1996	2257	if (!group) {
1997	2258	res = -ENOMEM;
1998	2259	goto _nolock;
1999	2260	}
2000		- down_write_nonfifo(&snd_pcm_link_rwsem);
2001		- write_lock_irq(&snd_pcm_link_rwlock);
	2261	+ snd_pcm_group_init(group);
	2262	+
	2263	+ down_write(&snd_pcm_link_rwsem);
2002	2264	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN \|\|
2003	2265	substream->runtime->status->state != substream1->runtime->status->state \|\|
2004	2266	substream->pcm->nonatomic != substream1->pcm->nonatomic) {
..	..	@@ -2009,23 +2271,24 @@
2009	2271	res = -EALREADY;
2010	2272	goto _end;
2011	2273	}
	2274	+
	2275	+ snd_pcm_stream_lock_irq(substream);
2012	2276	if (!snd_pcm_stream_linked(substream)) {
2013		- substream->group = group;
2014		- group = NULL;
2015		- spin_lock_init(&substream->group->lock);
2016		- mutex_init(&substream->group->mutex);
2017		- INIT_LIST_HEAD(&substream->group->substreams);
2018		- list_add_tail(&substream->link_list, &substream->group->substreams);
2019		- substream->group->count = 1;
	2277	+ snd_pcm_group_assign(substream, group);
	2278	+ group = NULL; /* assigned, don't free this one below */
2020	2279	}
2021		- list_add_tail(&substream1->link_list, &substream->group->substreams);
2022		- substream->group->count++;
2023		- substream1->group = substream->group;
	2280	+ target_group = substream->group;
	2281	+ snd_pcm_stream_unlock_irq(substream);
	2282	+
	2283	+ snd_pcm_group_lock_irq(target_group, nonatomic);
	2284	+ snd_pcm_stream_lock_nested(substream1);
	2285	+ snd_pcm_group_assign(substream1, target_group);
	2286	+ refcount_inc(&target_group->refs);
	2287	+ snd_pcm_stream_unlock(substream1);
	2288	+ snd_pcm_group_unlock_irq(target_group, nonatomic);
2024	2289	_end:
2025		- write_unlock_irq(&snd_pcm_link_rwlock);
2026	2290	up_write(&snd_pcm_link_rwsem);
2027	2291	_nolock:
2028		- snd_card_unref(substream1->pcm->card);
2029	2292	kfree(group);
2030	2293	_badf:
2031	2294	fdput(f);
..	..	@@ -2034,34 +2297,44 @@
2034	2297
2035	2298	static void relink_to_local(struct snd_pcm_substream *substream)
2036	2299	{
2037		- substream->group = &substream->self_group;
2038		- INIT_LIST_HEAD(&substream->self_group.substreams);
2039		- list_add_tail(&substream->link_list, &substream->self_group.substreams);
	2300	+ snd_pcm_stream_lock_nested(substream);
	2301	+ snd_pcm_group_assign(substream, &substream->self_group);
	2302	+ snd_pcm_stream_unlock(substream);
2040	2303	}
2041	2304
2042	2305	static int snd_pcm_unlink(struct snd_pcm_substream *substream)
2043	2306	{
2044		- struct snd_pcm_substream *s;
	2307	+ struct snd_pcm_group *group;
	2308	+ bool nonatomic = substream->pcm->nonatomic;
	2309	+ bool do_free = false;
2045	2310	int res = 0;
2046	2311
2047		- down_write_nonfifo(&snd_pcm_link_rwsem);
2048		- write_lock_irq(&snd_pcm_link_rwlock);
	2312	+ down_write(&snd_pcm_link_rwsem);
	2313	+
2049	2314	if (!snd_pcm_stream_linked(substream)) {
2050	2315	res = -EALREADY;
2051	2316	goto _end;
2052	2317	}
2053		- list_del(&substream->link_list);
2054		- substream->group->count--;
2055		- if (substream->group->count == 1) { /* detach the last stream, too */
2056		- snd_pcm_group_for_each_entry(s, substream) {
2057		- relink_to_local(s);
2058		- break;
2059		- }
2060		- kfree(substream->group);
2061		- }
	2318	+
	2319	+ group = substream->group;
	2320	+ snd_pcm_group_lock_irq(group, nonatomic);
	2321	+
2062	2322	relink_to_local(substream);
	2323	+ refcount_dec(&group->refs);
	2324	+
	2325	+ /* detach the last stream, too */
	2326	+ if (list_is_singular(&group->substreams)) {
	2327	+ relink_to_local(list_first_entry(&group->substreams,
	2328	+ struct snd_pcm_substream,
	2329	+ link_list));
	2330	+ do_free = refcount_dec_and_test(&group->refs);
	2331	+ }
	2332	+
	2333	+ snd_pcm_group_unlock_irq(group, nonatomic);
	2334	+ if (do_free)
	2335	+ kfree(group);
	2336	+
2063	2337	_end:
2064		- write_unlock_irq(&snd_pcm_link_rwlock);
2065	2338	up_write(&snd_pcm_link_rwsem);
2066	2339	return res;
2067	2340	}
..	..	@@ -2110,21 +2383,21 @@
2110	2383	static int snd_pcm_hw_rule_format(struct snd_pcm_hw_params *params,
2111	2384	struct snd_pcm_hw_rule *rule)
2112	2385	{
2113		- unsigned int k;
	2386	+ snd_pcm_format_t k;
2114	2387	const struct snd_interval *i =
2115	2388	hw_param_interval_c(params, rule->deps[0]);
2116	2389	struct snd_mask m;
2117	2390	struct snd_mask *mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
2118	2391	snd_mask_any(&m);
2119		- for (k = 0; k <= SNDRV_PCM_FORMAT_LAST; ++k) {
	2392	+ pcm_for_each_format(k) {
2120	2393	int bits;
2121		- if (! snd_mask_test(mask, k))
	2394	+ if (!snd_mask_test_format(mask, k))
2122	2395	continue;
2123	2396	bits = snd_pcm_format_physical_width(k);
2124	2397	if (bits <= 0)
2125	2398	continue; /* ignore invalid formats */
2126	2399	if ((unsigned)bits < i->min \|\| (unsigned)bits > i->max)
2127		- snd_mask_reset(&m, k);
	2400	+ snd_mask_reset(&m, (__force unsigned)k);
2128	2401	}
2129	2402	return snd_mask_refine(mask, &m);
2130	2403	}
..	..	@@ -2133,14 +2406,15 @@
2133	2406	struct snd_pcm_hw_rule *rule)
2134	2407	{
2135	2408	struct snd_interval t;
2136		- unsigned int k;
	2409	+ snd_pcm_format_t k;
	2410	+
2137	2411	t.min = UINT_MAX;
2138	2412	t.max = 0;
2139	2413	t.openmin = 0;
2140	2414	t.openmax = 0;
2141		- for (k = 0; k <= SNDRV_PCM_FORMAT_LAST; ++k) {
	2415	+ pcm_for_each_format(k) {
2142	2416	int bits;
2143		- if (! snd_mask_test(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), k))
	2417	+ if (!snd_mask_test_format(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), k))
2144	2418	continue;
2145	2419	bits = snd_pcm_format_physical_width(k);
2146	2420	if (bits <= 0)
..	..	@@ -2190,7 +2464,7 @@
2190	2464	return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2191	2465	}
2192	2466
2193		-int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream)
	2467	+static int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream)
2194	2468	{
2195	2469	struct snd_pcm_runtime *runtime = substream->runtime;
2196	2470	struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
..	..	@@ -2314,7 +2588,7 @@
2314	2588	return 0;
2315	2589	}
2316	2590
2317		-int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
	2591	+static int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
2318	2592	{
2319	2593	struct snd_pcm_runtime *runtime = substream->runtime;
2320	2594	struct snd_pcm_hardware *hw = &runtime->hw;
..	..	@@ -2322,16 +2596,16 @@
2322	2596	unsigned int mask = 0;
2323	2597
2324	2598	if (hw->info & SNDRV_PCM_INFO_INTERLEAVED)
2325		- mask \|= 1 << SNDRV_PCM_ACCESS_RW_INTERLEAVED;
	2599	+ mask \|= PARAM_MASK_BIT(SNDRV_PCM_ACCESS_RW_INTERLEAVED);
2326	2600	if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED)
2327		- mask \|= 1 << SNDRV_PCM_ACCESS_RW_NONINTERLEAVED;
	2601	+ mask \|= PARAM_MASK_BIT(SNDRV_PCM_ACCESS_RW_NONINTERLEAVED);
2328	2602	if (hw_support_mmap(substream)) {
2329	2603	if (hw->info & SNDRV_PCM_INFO_INTERLEAVED)
2330		- mask \|= 1 << SNDRV_PCM_ACCESS_MMAP_INTERLEAVED;
	2604	+ mask \|= PARAM_MASK_BIT(SNDRV_PCM_ACCESS_MMAP_INTERLEAVED);
2331	2605	if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED)
2332		- mask \|= 1 << SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED;
	2606	+ mask \|= PARAM_MASK_BIT(SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED);
2333	2607	if (hw->info & SNDRV_PCM_INFO_COMPLEX)
2334		- mask \|= 1 << SNDRV_PCM_ACCESS_MMAP_COMPLEX;
	2608	+ mask \|= PARAM_MASK_BIT(SNDRV_PCM_ACCESS_MMAP_COMPLEX);
2335	2609	}
2336	2610	err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_ACCESS, mask);
2337	2611	if (err < 0)
..	..	@@ -2341,7 +2615,8 @@
2341	2615	if (err < 0)
2342	2616	return err;
2343	2617
2344		- err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_SUBFORMAT, 1 << SNDRV_PCM_SUBFORMAT_STD);
	2618	+ err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_SUBFORMAT,
	2619	+ PARAM_MASK_BIT(SNDRV_PCM_SUBFORMAT_STD));
2345	2620	if (err < 0)
2346	2621	return err;
2347	2622
..	..	@@ -2411,14 +2686,13 @@
2411	2686
2412	2687	snd_pcm_drop(substream);
2413	2688	if (substream->hw_opened) {
2414		- if (substream->ops->hw_free &&
2415		- substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
2416		- substream->ops->hw_free(substream);
	2689	+ if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
	2690	+ do_hw_free(substream);
2417	2691	substream->ops->close(substream);
2418	2692	substream->hw_opened = 0;
2419	2693	}
2420		- if (pm_qos_request_active(&substream->latency_pm_qos_req))
2421		- pm_qos_remove_request(&substream->latency_pm_qos_req);
	2694	+ if (cpu_latency_qos_request_active(&substream->latency_pm_qos_req))
	2695	+ cpu_latency_qos_remove_request(&substream->latency_pm_qos_req);
2422	2696	if (substream->pcm_release) {
2423	2697	substream->pcm_release(substream);
2424	2698	substream->pcm_release = NULL;
..	..	@@ -2486,10 +2760,8 @@
2486	2760	return -ENOMEM;
2487	2761	}
2488	2762	pcm_file->substream = substream;
2489		- if (substream->ref_count == 1) {
2490		- substream->file = pcm_file;
	2763	+ if (substream->ref_count == 1)
2491	2764	substream->pcm_release = pcm_release_private;
2492		- }
2493	2765	file->private_data = pcm_file;
2494	2766
2495	2767	return 0;
..	..	@@ -2610,7 +2882,7 @@
2610	2882	case SNDRV_PCM_STATE_DRAINING:
2611	2883	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
2612	2884	return -EBADFD;
2613		- /* Fall through */
	2885	+ fallthrough;
2614	2886	case SNDRV_PCM_STATE_RUNNING:
2615	2887	return snd_pcm_update_hw_ptr(substream);
2616	2888	case SNDRV_PCM_STATE_PREPARED:
..	..	@@ -2738,7 +3010,6 @@
2738	3010	volatile struct snd_pcm_mmap_status *status;
2739	3011	volatile struct snd_pcm_mmap_control *control;
2740	3012	int err;
2741		- snd_pcm_uframes_t hw_avail;
2742	3013
2743	3014	memset(&sync_ptr, 0, sizeof(sync_ptr));
2744	3015	if (get_user(sync_ptr.flags, (unsigned __user *)&(_sync_ptr->flags)))
..	..	@@ -2767,16 +3038,6 @@
2767	3038	control->avail_min = sync_ptr.c.control.avail_min;
2768	3039	else
2769	3040	sync_ptr.c.control.avail_min = control->avail_min;
2770		-
2771		- if (runtime->render_flag & SNDRV_NON_DMA_MODE) {
2772		- hw_avail = snd_pcm_playback_hw_avail(runtime);
2773		- if ((hw_avail >= runtime->start_threshold)
2774		- && (runtime->render_flag &
2775		- SNDRV_RENDER_STOPPED)) {
2776		- if (substream->ops->restart)
2777		- substream->ops->restart(substream);
2778		- }
2779		- }
2780	3041	sync_ptr.s.status.state = status->state;
2781	3042	sync_ptr.s.status.hw_ptr = status->hw_ptr;
2782	3043	sync_ptr.s.status.tstamp = status->tstamp;
..	..	@@ -2787,6 +3048,112 @@
2787	3048	return -EFAULT;
2788	3049	return 0;
2789	3050	}
	3051	+
	3052	+struct snd_pcm_mmap_status32 {
	3053	+ snd_pcm_state_t state;
	3054	+ s32 pad1;
	3055	+ u32 hw_ptr;
	3056	+ s32 tstamp_sec;
	3057	+ s32 tstamp_nsec;
	3058	+ snd_pcm_state_t suspended_state;
	3059	+ s32 audio_tstamp_sec;
	3060	+ s32 audio_tstamp_nsec;
	3061	+} __attribute__((packed));
	3062	+
	3063	+struct snd_pcm_mmap_control32 {
	3064	+ u32 appl_ptr;
	3065	+ u32 avail_min;
	3066	+};
	3067	+
	3068	+struct snd_pcm_sync_ptr32 {
	3069	+ u32 flags;
	3070	+ union {
	3071	+ struct snd_pcm_mmap_status32 status;
	3072	+ unsigned char reserved[64];
	3073	+ } s;
	3074	+ union {
	3075	+ struct snd_pcm_mmap_control32 control;
	3076	+ unsigned char reserved[64];
	3077	+ } c;
	3078	+} __attribute__((packed));
	3079	+
	3080	+/* recalcuate the boundary within 32bit */
	3081	+static snd_pcm_uframes_t recalculate_boundary(struct snd_pcm_runtime *runtime)
	3082	+{
	3083	+ snd_pcm_uframes_t boundary;
	3084	+
	3085	+ if (! runtime->buffer_size)
	3086	+ return 0;
	3087	+ boundary = runtime->buffer_size;
	3088	+ while (boundary * 2 <= 0x7fffffffUL - runtime->buffer_size)
	3089	+ boundary *= 2;
	3090	+ return boundary;
	3091	+}
	3092	+
	3093	+static int snd_pcm_ioctl_sync_ptr_compat(struct snd_pcm_substream *substream,
	3094	+ struct snd_pcm_sync_ptr32 __user *src)
	3095	+{
	3096	+ struct snd_pcm_runtime *runtime = substream->runtime;
	3097	+ volatile struct snd_pcm_mmap_status *status;
	3098	+ volatile struct snd_pcm_mmap_control *control;
	3099	+ u32 sflags;
	3100	+ struct snd_pcm_mmap_control scontrol;
	3101	+ struct snd_pcm_mmap_status sstatus;
	3102	+ snd_pcm_uframes_t boundary;
	3103	+ int err;
	3104	+
	3105	+ if (snd_BUG_ON(!runtime))
	3106	+ return -EINVAL;
	3107	+
	3108	+ if (get_user(sflags, &src->flags) \|\|
	3109	+ get_user(scontrol.appl_ptr, &src->c.control.appl_ptr) \|\|
	3110	+ get_user(scontrol.avail_min, &src->c.control.avail_min))
	3111	+ return -EFAULT;
	3112	+ if (sflags & SNDRV_PCM_SYNC_PTR_HWSYNC) {
	3113	+ err = snd_pcm_hwsync(substream);
	3114	+ if (err < 0)
	3115	+ return err;
	3116	+ }
	3117	+ status = runtime->status;
	3118	+ control = runtime->control;
	3119	+ boundary = recalculate_boundary(runtime);
	3120	+ if (! boundary)
	3121	+ boundary = 0x7fffffff;
	3122	+ snd_pcm_stream_lock_irq(substream);
	3123	+ /* FIXME: we should consider the boundary for the sync from app */
	3124	+ if (!(sflags & SNDRV_PCM_SYNC_PTR_APPL)) {
	3125	+ err = pcm_lib_apply_appl_ptr(substream,
	3126	+ scontrol.appl_ptr);
	3127	+ if (err < 0) {
	3128	+ snd_pcm_stream_unlock_irq(substream);
	3129	+ return err;
	3130	+ }
	3131	+ } else
	3132	+ scontrol.appl_ptr = control->appl_ptr % boundary;
	3133	+ if (!(sflags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN))
	3134	+ control->avail_min = scontrol.avail_min;
	3135	+ else
	3136	+ scontrol.avail_min = control->avail_min;
	3137	+ sstatus.state = status->state;
	3138	+ sstatus.hw_ptr = status->hw_ptr % boundary;
	3139	+ sstatus.tstamp = status->tstamp;
	3140	+ sstatus.suspended_state = status->suspended_state;
	3141	+ sstatus.audio_tstamp = status->audio_tstamp;
	3142	+ snd_pcm_stream_unlock_irq(substream);
	3143	+ if (put_user(sstatus.state, &src->s.status.state) \|\|
	3144	+ put_user(sstatus.hw_ptr, &src->s.status.hw_ptr) \|\|
	3145	+ put_user(sstatus.tstamp.tv_sec, &src->s.status.tstamp_sec) \|\|
	3146	+ put_user(sstatus.tstamp.tv_nsec, &src->s.status.tstamp_nsec) \|\|
	3147	+ put_user(sstatus.suspended_state, &src->s.status.suspended_state) \|\|
	3148	+ put_user(sstatus.audio_tstamp.tv_sec, &src->s.status.audio_tstamp_sec) \|\|
	3149	+ put_user(sstatus.audio_tstamp.tv_nsec, &src->s.status.audio_tstamp_nsec) \|\|
	3150	+ put_user(scontrol.appl_ptr, &src->c.control.appl_ptr) \|\|
	3151	+ put_user(scontrol.avail_min, &src->c.control.avail_min))
	3152	+ return -EFAULT;
	3153	+
	3154	+ return 0;
	3155	+}
	3156	+#define __SNDRV_PCM_IOCTL_SYNC_PTR32 _IOWR('A', 0x23, struct snd_pcm_sync_ptr32)
2790	3157
2791	3158	static int snd_pcm_tstamp(struct snd_pcm_substream substream, int __user _arg)
2792	3159	{
..	..	@@ -2818,7 +3185,8 @@
2818	3185	result = snd_pcm_lib_write(substream, xferi.buf, xferi.frames);
2819	3186	else
2820	3187	result = snd_pcm_lib_read(substream, xferi.buf, xferi.frames);
2821		- __put_user(result, &_xferi->result);
	3188	+ if (put_user(result, &_xferi->result))
	3189	+ return -EFAULT;
2822	3190	return result < 0 ? result : 0;
2823	3191	}
2824	3192
..	..	@@ -2847,7 +3215,8 @@
2847	3215	else
2848	3216	result = snd_pcm_lib_readv(substream, bufs, xfern.frames);
2849	3217	kfree(bufs);
2850		- __put_user(result, &_xfern->result);
	3218	+ if (put_user(result, &_xfern->result))
	3219	+ return -EFAULT;
2851	3220	return result < 0 ? result : 0;
2852	3221	}
2853	3222
..	..	@@ -2862,7 +3231,8 @@
2862	3231	if (put_user(0, _frames))
2863	3232	return -EFAULT;
2864	3233	result = snd_pcm_rewind(substream, frames);
2865		- __put_user(result, _frames);
	3234	+ if (put_user(result, _frames))
	3235	+ return -EFAULT;
2866	3236	return result < 0 ? result : 0;
2867	3237	}
2868	3238
..	..	@@ -2877,7 +3247,8 @@
2877	3247	if (put_user(0, _frames))
2878	3248	return -EFAULT;
2879	3249	result = snd_pcm_forward(substream, frames);
2880		- __put_user(result, _frames);
	3250	+ if (put_user(result, _frames))
	3251	+ return -EFAULT;
2881	3252	return result < 0 ? result : 0;
2882	3253	}
2883	3254
..	..	@@ -2917,10 +3288,14 @@
2917	3288	return snd_pcm_hw_free(substream);
2918	3289	case SNDRV_PCM_IOCTL_SW_PARAMS:
2919	3290	return snd_pcm_sw_params_user(substream, arg);
2920		- case SNDRV_PCM_IOCTL_STATUS:
2921		- return snd_pcm_status_user(substream, arg, false);
2922		- case SNDRV_PCM_IOCTL_STATUS_EXT:
2923		- return snd_pcm_status_user(substream, arg, true);
	3291	+ case SNDRV_PCM_IOCTL_STATUS32:
	3292	+ return snd_pcm_status_user32(substream, arg, false);
	3293	+ case SNDRV_PCM_IOCTL_STATUS_EXT32:
	3294	+ return snd_pcm_status_user32(substream, arg, true);
	3295	+ case SNDRV_PCM_IOCTL_STATUS64:
	3296	+ return snd_pcm_status_user64(substream, arg, false);
	3297	+ case SNDRV_PCM_IOCTL_STATUS_EXT64:
	3298	+ return snd_pcm_status_user64(substream, arg, true);
2924	3299	case SNDRV_PCM_IOCTL_CHANNEL_INFO:
2925	3300	return snd_pcm_channel_info_user(substream, arg);
2926	3301	case SNDRV_PCM_IOCTL_PREPARE:
..	..	@@ -2952,7 +3327,9 @@
2952	3327	return -EFAULT;
2953	3328	return 0;
2954	3329	}
2955		- case SNDRV_PCM_IOCTL_SYNC_PTR:
	3330	+ case __SNDRV_PCM_IOCTL_SYNC_PTR32:
	3331	+ return snd_pcm_ioctl_sync_ptr_compat(substream, arg);
	3332	+ case __SNDRV_PCM_IOCTL_SYNC_PTR64:
2956	3333	return snd_pcm_sync_ptr(substream, arg);
2957	3334	#ifdef CONFIG_SND_SUPPORT_OLD_API
2958	3335	case SNDRV_PCM_IOCTL_HW_REFINE_OLD:
..	..	@@ -2965,9 +3342,7 @@
2965	3342	case SNDRV_PCM_IOCTL_DROP:
2966	3343	return snd_pcm_drop(substream);
2967	3344	case SNDRV_PCM_IOCTL_PAUSE:
2968		- return snd_pcm_action_lock_irq(&snd_pcm_action_pause,
2969		- substream,
2970		- (int)(unsigned long)arg);
	3345	+ return snd_pcm_pause_lock_irq(substream, (unsigned long)arg);
2971	3346	case SNDRV_PCM_IOCTL_WRITEI_FRAMES:
2972	3347	case SNDRV_PCM_IOCTL_READI_FRAMES:
2973	3348	return snd_pcm_xferi_frames_ioctl(substream, arg);
..	..	@@ -3290,8 +3665,6 @@
3290	3665
3291	3666	static bool pcm_status_mmap_allowed(struct snd_pcm_file *pcm_file)
3292	3667	{
3293		- if (pcm_file->no_compat_mmap)
3294		- return false;
3295	3668	/* See pcm_control_mmap_allowed() below.
3296	3669	* Since older alsa-lib requires both status and control mmaps to be
3297	3670	* coupled, we have to disable the status mmap for old alsa-lib, too.
..	..	@@ -3338,7 +3711,18 @@
3338	3711	snd_pcm_default_page_ops(struct snd_pcm_substream *substream, unsigned long ofs)
3339	3712	{
3340	3713	void *vaddr = substream->runtime->dma_area + ofs;
3341		- return virt_to_page(vaddr);
	3714	+
	3715	+ switch (substream->dma_buffer.dev.type) {
	3716	+#ifdef CONFIG_SND_DMA_SGBUF
	3717	+ case SNDRV_DMA_TYPE_DEV_SG:
	3718	+ case SNDRV_DMA_TYPE_DEV_UC_SG:
	3719	+ return snd_pcm_sgbuf_ops_page(substream, ofs);
	3720	+#endif /* CONFIG_SND_DMA_SGBUF */
	3721	+ case SNDRV_DMA_TYPE_VMALLOC:
	3722	+ return vmalloc_to_page(vaddr);
	3723	+ default:
	3724	+ return virt_to_page(vaddr);
	3725	+ }
3342	3726	}
3343	3727
3344	3728	/*
..	..	@@ -3405,15 +3789,14 @@
3405	3789	area->vm_end - area->vm_start, area->vm_page_prot);
3406	3790	}
3407	3791	#endif /* CONFIG_GENERIC_ALLOCATOR */
3408		-#ifndef CONFIG_X86 /* for avoiding warnings arch/x86/mm/pat.c */
3409	3792	if (IS_ENABLED(CONFIG_HAS_DMA) && !substream->ops->page &&
3410		- substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV)
	3793	+ (substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV \|\|
	3794	+ substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV_UC))
3411	3795	return dma_mmap_coherent(substream->dma_buffer.dev.dev,
3412	3796	area,
3413	3797	substream->runtime->dma_area,
3414	3798	substream->runtime->dma_addr,
3415	3799	substream->runtime->dma_bytes);
3416		-#endif /* CONFIG_X86 */
3417	3800	/* mmap with fault handler */
3418	3801	area->vm_ops = &snd_pcm_vm_ops_data_fault;
3419	3802	return 0;
..	..	@@ -3504,11 +3887,19 @@
3504	3887
3505	3888	offset = area->vm_pgoff << PAGE_SHIFT;
3506	3889	switch (offset) {
3507		- case SNDRV_PCM_MMAP_OFFSET_STATUS:
	3890	+ case SNDRV_PCM_MMAP_OFFSET_STATUS_OLD:
	3891	+ if (pcm_file->no_compat_mmap \|\| !IS_ENABLED(CONFIG_64BIT))
	3892	+ return -ENXIO;
	3893	+ fallthrough;
	3894	+ case SNDRV_PCM_MMAP_OFFSET_STATUS_NEW:
3508	3895	if (!pcm_status_mmap_allowed(pcm_file))
3509	3896	return -ENXIO;
3510	3897	return snd_pcm_mmap_status(substream, file, area);
3511		- case SNDRV_PCM_MMAP_OFFSET_CONTROL:
	3898	+ case SNDRV_PCM_MMAP_OFFSET_CONTROL_OLD:
	3899	+ if (pcm_file->no_compat_mmap \|\| !IS_ENABLED(CONFIG_64BIT))
	3900	+ return -ENXIO;
	3901	+ fallthrough;
	3902	+ case SNDRV_PCM_MMAP_OFFSET_CONTROL_NEW:
3512	3903	if (!pcm_control_mmap_allowed(pcm_file))
3513	3904	return -ENXIO;
3514	3905	return snd_pcm_mmap_control(substream, file, area);
..	..	@@ -3668,9 +4059,9 @@
3668	4059	unsigned long offset = pgoff << PAGE_SHIFT;
3669	4060
3670	4061	switch (offset) {
3671		- case SNDRV_PCM_MMAP_OFFSET_STATUS:
	4062	+ case SNDRV_PCM_MMAP_OFFSET_STATUS_NEW:
3672	4063	return (unsigned long)runtime->status;
3673		- case SNDRV_PCM_MMAP_OFFSET_CONTROL:
	4064	+ case SNDRV_PCM_MMAP_OFFSET_CONTROL_NEW:
3674	4065	return (unsigned long)runtime->control;
3675	4066	default:
3676	4067	return (unsigned long)runtime->dma_area + offset;