Merge tag 'sound-5.3-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai...
[sfrench/cifs-2.6.git] / sound / core / pcm_native.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  Digital Audio (PCM) abstract layer
4  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
5  */
6
7 #include <linux/mm.h>
8 #include <linux/module.h>
9 #include <linux/file.h>
10 #include <linux/slab.h>
11 #include <linux/sched/signal.h>
12 #include <linux/time.h>
13 #include <linux/pm_qos.h>
14 #include <linux/io.h>
15 #include <linux/dma-mapping.h>
16 #include <sound/core.h>
17 #include <sound/control.h>
18 #include <sound/info.h>
19 #include <sound/pcm.h>
20 #include <sound/pcm_params.h>
21 #include <sound/timer.h>
22 #include <sound/minors.h>
23 #include <linux/uio.h>
24 #include <linux/delay.h>
25
26 #include "pcm_local.h"
27
28 #ifdef CONFIG_SND_DEBUG
29 #define CREATE_TRACE_POINTS
30 #include "pcm_param_trace.h"
31 #else
32 #define trace_hw_mask_param_enabled()           0
33 #define trace_hw_interval_param_enabled()       0
34 #define trace_hw_mask_param(substream, type, index, prev, curr)
35 #define trace_hw_interval_param(substream, type, index, prev, curr)
36 #endif
37
38 /*
39  *  Compatibility
40  */
41
42 struct snd_pcm_hw_params_old {
43         unsigned int flags;
44         unsigned int masks[SNDRV_PCM_HW_PARAM_SUBFORMAT -
45                            SNDRV_PCM_HW_PARAM_ACCESS + 1];
46         struct snd_interval intervals[SNDRV_PCM_HW_PARAM_TICK_TIME -
47                                         SNDRV_PCM_HW_PARAM_SAMPLE_BITS + 1];
48         unsigned int rmask;
49         unsigned int cmask;
50         unsigned int info;
51         unsigned int msbits;
52         unsigned int rate_num;
53         unsigned int rate_den;
54         snd_pcm_uframes_t fifo_size;
55         unsigned char reserved[64];
56 };
57
58 #ifdef CONFIG_SND_SUPPORT_OLD_API
59 #define SNDRV_PCM_IOCTL_HW_REFINE_OLD _IOWR('A', 0x10, struct snd_pcm_hw_params_old)
60 #define SNDRV_PCM_IOCTL_HW_PARAMS_OLD _IOWR('A', 0x11, struct snd_pcm_hw_params_old)
61
62 static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream,
63                                       struct snd_pcm_hw_params_old __user * _oparams);
64 static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream,
65                                       struct snd_pcm_hw_params_old __user * _oparams);
66 #endif
67 static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream);
68
69 /*
70  *
71  */
72
73 static DECLARE_RWSEM(snd_pcm_link_rwsem);
74
75 void snd_pcm_group_init(struct snd_pcm_group *group)
76 {
77         spin_lock_init(&group->lock);
78         mutex_init(&group->mutex);
79         INIT_LIST_HEAD(&group->substreams);
80         refcount_set(&group->refs, 1);
81 }
82
83 /* define group lock helpers */
84 #define DEFINE_PCM_GROUP_LOCK(action, mutex_action) \
85 static void snd_pcm_group_ ## action(struct snd_pcm_group *group, bool nonatomic) \
86 { \
87         if (nonatomic) \
88                 mutex_ ## mutex_action(&group->mutex); \
89         else \
90                 spin_ ## action(&group->lock); \
91 }
92
93 DEFINE_PCM_GROUP_LOCK(lock, lock);
94 DEFINE_PCM_GROUP_LOCK(unlock, unlock);
95 DEFINE_PCM_GROUP_LOCK(lock_irq, lock);
96 DEFINE_PCM_GROUP_LOCK(unlock_irq, unlock);
97
98 /**
99  * snd_pcm_stream_lock - Lock the PCM stream
100  * @substream: PCM substream
101  *
102  * This locks the PCM stream's spinlock or mutex depending on the nonatomic
103  * flag of the given substream.  This also takes the global link rw lock
104  * (or rw sem), too, for avoiding the race with linked streams.
105  */
106 void snd_pcm_stream_lock(struct snd_pcm_substream *substream)
107 {
108         snd_pcm_group_lock(&substream->self_group, substream->pcm->nonatomic);
109 }
110 EXPORT_SYMBOL_GPL(snd_pcm_stream_lock);
111
112 /**
113  * snd_pcm_stream_lock - Unlock the PCM stream
114  * @substream: PCM substream
115  *
116  * This unlocks the PCM stream that has been locked via snd_pcm_stream_lock().
117  */
118 void snd_pcm_stream_unlock(struct snd_pcm_substream *substream)
119 {
120         snd_pcm_group_unlock(&substream->self_group, substream->pcm->nonatomic);
121 }
122 EXPORT_SYMBOL_GPL(snd_pcm_stream_unlock);
123
124 /**
125  * snd_pcm_stream_lock_irq - Lock the PCM stream
126  * @substream: PCM substream
127  *
128  * This locks the PCM stream like snd_pcm_stream_lock() and disables the local
129  * IRQ (only when nonatomic is false).  In nonatomic case, this is identical
130  * as snd_pcm_stream_lock().
131  */
132 void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream)
133 {
134         snd_pcm_group_lock_irq(&substream->self_group,
135                                substream->pcm->nonatomic);
136 }
137 EXPORT_SYMBOL_GPL(snd_pcm_stream_lock_irq);
138
139 /**
140  * snd_pcm_stream_unlock_irq - Unlock the PCM stream
141  * @substream: PCM substream
142  *
143  * This is a counter-part of snd_pcm_stream_lock_irq().
144  */
145 void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream)
146 {
147         snd_pcm_group_unlock_irq(&substream->self_group,
148                                  substream->pcm->nonatomic);
149 }
150 EXPORT_SYMBOL_GPL(snd_pcm_stream_unlock_irq);
151
152 unsigned long _snd_pcm_stream_lock_irqsave(struct snd_pcm_substream *substream)
153 {
154         unsigned long flags = 0;
155         if (substream->pcm->nonatomic)
156                 mutex_lock(&substream->self_group.mutex);
157         else
158                 spin_lock_irqsave(&substream->self_group.lock, flags);
159         return flags;
160 }
161 EXPORT_SYMBOL_GPL(_snd_pcm_stream_lock_irqsave);
162
163 /**
164  * snd_pcm_stream_unlock_irqrestore - Unlock the PCM stream
165  * @substream: PCM substream
166  * @flags: irq flags
167  *
168  * This is a counter-part of snd_pcm_stream_lock_irqsave().
169  */
170 void snd_pcm_stream_unlock_irqrestore(struct snd_pcm_substream *substream,
171                                       unsigned long flags)
172 {
173         if (substream->pcm->nonatomic)
174                 mutex_unlock(&substream->self_group.mutex);
175         else
176                 spin_unlock_irqrestore(&substream->self_group.lock, flags);
177 }
178 EXPORT_SYMBOL_GPL(snd_pcm_stream_unlock_irqrestore);
179
180 int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info)
181 {
182         struct snd_pcm *pcm = substream->pcm;
183         struct snd_pcm_str *pstr = substream->pstr;
184
185         memset(info, 0, sizeof(*info));
186         info->card = pcm->card->number;
187         info->device = pcm->device;
188         info->stream = substream->stream;
189         info->subdevice = substream->number;
190         strlcpy(info->id, pcm->id, sizeof(info->id));
191         strlcpy(info->name, pcm->name, sizeof(info->name));
192         info->dev_class = pcm->dev_class;
193         info->dev_subclass = pcm->dev_subclass;
194         info->subdevices_count = pstr->substream_count;
195         info->subdevices_avail = pstr->substream_count - pstr->substream_opened;
196         strlcpy(info->subname, substream->name, sizeof(info->subname));
197
198         return 0;
199 }
200
201 int snd_pcm_info_user(struct snd_pcm_substream *substream,
202                       struct snd_pcm_info __user * _info)
203 {
204         struct snd_pcm_info *info;
205         int err;
206
207         info = kmalloc(sizeof(*info), GFP_KERNEL);
208         if (! info)
209                 return -ENOMEM;
210         err = snd_pcm_info(substream, info);
211         if (err >= 0) {
212                 if (copy_to_user(_info, info, sizeof(*info)))
213                         err = -EFAULT;
214         }
215         kfree(info);
216         return err;
217 }
218
219 static bool hw_support_mmap(struct snd_pcm_substream *substream)
220 {
221         if (!(substream->runtime->hw.info & SNDRV_PCM_INFO_MMAP))
222                 return false;
223         /* architecture supports dma_mmap_coherent()? */
224 #if defined(CONFIG_ARCH_NO_COHERENT_DMA_MMAP) || !defined(CONFIG_HAS_DMA)
225         if (!substream->ops->mmap &&
226             substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV)
227                 return false;
228 #endif
229         return true;
230 }
231
232 static int constrain_mask_params(struct snd_pcm_substream *substream,
233                                  struct snd_pcm_hw_params *params)
234 {
235         struct snd_pcm_hw_constraints *constrs =
236                                         &substream->runtime->hw_constraints;
237         struct snd_mask *m;
238         unsigned int k;
239         struct snd_mask old_mask;
240         int changed;
241
242         for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++) {
243                 m = hw_param_mask(params, k);
244                 if (snd_mask_empty(m))
245                         return -EINVAL;
246
247                 /* This parameter is not requested to change by a caller. */
248                 if (!(params->rmask & (1 << k)))
249                         continue;
250
251                 if (trace_hw_mask_param_enabled())
252                         old_mask = *m;
253
254                 changed = snd_mask_refine(m, constrs_mask(constrs, k));
255                 if (changed < 0)
256                         return changed;
257                 if (changed == 0)
258                         continue;
259
260                 /* Set corresponding flag so that the caller gets it. */
261                 trace_hw_mask_param(substream, k, 0, &old_mask, m);
262                 params->cmask |= 1 << k;
263         }
264
265         return 0;
266 }
267
268 static int constrain_interval_params(struct snd_pcm_substream *substream,
269                                      struct snd_pcm_hw_params *params)
270 {
271         struct snd_pcm_hw_constraints *constrs =
272                                         &substream->runtime->hw_constraints;
273         struct snd_interval *i;
274         unsigned int k;
275         struct snd_interval old_interval;
276         int changed;
277
278         for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++) {
279                 i = hw_param_interval(params, k);
280                 if (snd_interval_empty(i))
281                         return -EINVAL;
282
283                 /* This parameter is not requested to change by a caller. */
284                 if (!(params->rmask & (1 << k)))
285                         continue;
286
287                 if (trace_hw_interval_param_enabled())
288                         old_interval = *i;
289
290                 changed = snd_interval_refine(i, constrs_interval(constrs, k));
291                 if (changed < 0)
292                         return changed;
293                 if (changed == 0)
294                         continue;
295
296                 /* Set corresponding flag so that the caller gets it. */
297                 trace_hw_interval_param(substream, k, 0, &old_interval, i);
298                 params->cmask |= 1 << k;
299         }
300
301         return 0;
302 }
303
304 static int constrain_params_by_rules(struct snd_pcm_substream *substream,
305                                      struct snd_pcm_hw_params *params)
306 {
307         struct snd_pcm_hw_constraints *constrs =
308                                         &substream->runtime->hw_constraints;
309         unsigned int k;
310         unsigned int *rstamps;
311         unsigned int vstamps[SNDRV_PCM_HW_PARAM_LAST_INTERVAL + 1];
312         unsigned int stamp;
313         struct snd_pcm_hw_rule *r;
314         unsigned int d;
315         struct snd_mask old_mask;
316         struct snd_interval old_interval;
317         bool again;
318         int changed, err = 0;
319
320         /*
321          * Each application of rule has own sequence number.
322          *
323          * Each member of 'rstamps' array represents the sequence number of
324          * recent application of corresponding rule.
325          */
326         rstamps = kcalloc(constrs->rules_num, sizeof(unsigned int), GFP_KERNEL);
327         if (!rstamps)
328                 return -ENOMEM;
329
330         /*
331          * Each member of 'vstamps' array represents the sequence number of
332          * recent application of rule in which corresponding parameters were
333          * changed.
334          *
335          * In initial state, elements corresponding to parameters requested by
336          * a caller is 1. For unrequested parameters, corresponding members
337          * have 0 so that the parameters are never changed anymore.
338          */
339         for (k = 0; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++)
340                 vstamps[k] = (params->rmask & (1 << k)) ? 1 : 0;
341
342         /* Due to the above design, actual sequence number starts at 2. */
343         stamp = 2;
344 retry:
345         /* Apply all rules in order. */
346         again = false;
347         for (k = 0; k < constrs->rules_num; k++) {
348                 r = &constrs->rules[k];
349
350                 /*
351                  * Check condition bits of this rule. When the rule has
352                  * some condition bits, parameter without the bits is
353                  * never processed. SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP
354                  * is an example of the condition bits.
355                  */
356                 if (r->cond && !(r->cond & params->flags))
357                         continue;
358
359                 /*
360                  * The 'deps' array includes maximum three dependencies
361                  * to SNDRV_PCM_HW_PARAM_XXXs for this rule. The fourth
362                  * member of this array is a sentinel and should be
363                  * negative value.
364                  *
365                  * This rule should be processed in this time when dependent
366                  * parameters were changed at former applications of the other
367                  * rules.
368                  */
369                 for (d = 0; r->deps[d] >= 0; d++) {
370                         if (vstamps[r->deps[d]] > rstamps[k])
371                                 break;
372                 }
373                 if (r->deps[d] < 0)
374                         continue;
375
376                 if (trace_hw_mask_param_enabled()) {
377                         if (hw_is_mask(r->var))
378                                 old_mask = *hw_param_mask(params, r->var);
379                 }
380                 if (trace_hw_interval_param_enabled()) {
381                         if (hw_is_interval(r->var))
382                                 old_interval = *hw_param_interval(params, r->var);
383                 }
384
385                 changed = r->func(params, r);
386                 if (changed < 0) {
387                         err = changed;
388                         goto out;
389                 }
390
391                 /*
392                  * When the parameter is changed, notify it to the caller
393                  * by corresponding returned bit, then preparing for next
394                  * iteration.
395                  */
396                 if (changed && r->var >= 0) {
397                         if (hw_is_mask(r->var)) {
398                                 trace_hw_mask_param(substream, r->var,
399                                         k + 1, &old_mask,
400                                         hw_param_mask(params, r->var));
401                         }
402                         if (hw_is_interval(r->var)) {
403                                 trace_hw_interval_param(substream, r->var,
404                                         k + 1, &old_interval,
405                                         hw_param_interval(params, r->var));
406                         }
407
408                         params->cmask |= (1 << r->var);
409                         vstamps[r->var] = stamp;
410                         again = true;
411                 }
412
413                 rstamps[k] = stamp++;
414         }
415
416         /* Iterate to evaluate all rules till no parameters are changed. */
417         if (again)
418                 goto retry;
419
420  out:
421         kfree(rstamps);
422         return err;
423 }
424
425 static int fixup_unreferenced_params(struct snd_pcm_substream *substream,
426                                      struct snd_pcm_hw_params *params)
427 {
428         const struct snd_interval *i;
429         const struct snd_mask *m;
430         int err;
431
432         if (!params->msbits) {
433                 i = hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
434                 if (snd_interval_single(i))
435                         params->msbits = snd_interval_value(i);
436         }
437
438         if (!params->rate_den) {
439                 i = hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_RATE);
440                 if (snd_interval_single(i)) {
441                         params->rate_num = snd_interval_value(i);
442                         params->rate_den = 1;
443                 }
444         }
445
446         if (!params->fifo_size) {
447                 m = hw_param_mask_c(params, SNDRV_PCM_HW_PARAM_FORMAT);
448                 i = hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_CHANNELS);
449                 if (snd_mask_single(m) && snd_interval_single(i)) {
450                         err = substream->ops->ioctl(substream,
451                                         SNDRV_PCM_IOCTL1_FIFO_SIZE, params);
452                         if (err < 0)
453                                 return err;
454                 }
455         }
456
457         if (!params->info) {
458                 params->info = substream->runtime->hw.info;
459                 params->info &= ~(SNDRV_PCM_INFO_FIFO_IN_FRAMES |
460                                   SNDRV_PCM_INFO_DRAIN_TRIGGER);
461                 if (!hw_support_mmap(substream))
462                         params->info &= ~(SNDRV_PCM_INFO_MMAP |
463                                           SNDRV_PCM_INFO_MMAP_VALID);
464         }
465
466         return 0;
467 }
468
469 int snd_pcm_hw_refine(struct snd_pcm_substream *substream,
470                       struct snd_pcm_hw_params *params)
471 {
472         int err;
473
474         params->info = 0;
475         params->fifo_size = 0;
476         if (params->rmask & (1 << SNDRV_PCM_HW_PARAM_SAMPLE_BITS))
477                 params->msbits = 0;
478         if (params->rmask & (1 << SNDRV_PCM_HW_PARAM_RATE)) {
479                 params->rate_num = 0;
480                 params->rate_den = 0;
481         }
482
483         err = constrain_mask_params(substream, params);
484         if (err < 0)
485                 return err;
486
487         err = constrain_interval_params(substream, params);
488         if (err < 0)
489                 return err;
490
491         err = constrain_params_by_rules(substream, params);
492         if (err < 0)
493                 return err;
494
495         params->rmask = 0;
496
497         return 0;
498 }
499 EXPORT_SYMBOL(snd_pcm_hw_refine);
500
501 static int snd_pcm_hw_refine_user(struct snd_pcm_substream *substream,
502                                   struct snd_pcm_hw_params __user * _params)
503 {
504         struct snd_pcm_hw_params *params;
505         int err;
506
507         params = memdup_user(_params, sizeof(*params));
508         if (IS_ERR(params))
509                 return PTR_ERR(params);
510
511         err = snd_pcm_hw_refine(substream, params);
512         if (err < 0)
513                 goto end;
514
515         err = fixup_unreferenced_params(substream, params);
516         if (err < 0)
517                 goto end;
518
519         if (copy_to_user(_params, params, sizeof(*params)))
520                 err = -EFAULT;
521 end:
522         kfree(params);
523         return err;
524 }
525
526 static int period_to_usecs(struct snd_pcm_runtime *runtime)
527 {
528         int usecs;
529
530         if (! runtime->rate)
531                 return -1; /* invalid */
532
533         /* take 75% of period time as the deadline */
534         usecs = (750000 / runtime->rate) * runtime->period_size;
535         usecs += ((750000 % runtime->rate) * runtime->period_size) /
536                 runtime->rate;
537
538         return usecs;
539 }
540
541 static void snd_pcm_set_state(struct snd_pcm_substream *substream, int state)
542 {
543         snd_pcm_stream_lock_irq(substream);
544         if (substream->runtime->status->state != SNDRV_PCM_STATE_DISCONNECTED)
545                 substream->runtime->status->state = state;
546         snd_pcm_stream_unlock_irq(substream);
547 }
548
549 static inline void snd_pcm_timer_notify(struct snd_pcm_substream *substream,
550                                         int event)
551 {
552 #ifdef CONFIG_SND_PCM_TIMER
553         if (substream->timer)
554                 snd_timer_notify(substream->timer, event,
555                                         &substream->runtime->trigger_tstamp);
556 #endif
557 }
558
559 /**
560  * snd_pcm_hw_param_choose - choose a configuration defined by @params
561  * @pcm: PCM instance
562  * @params: the hw_params instance
563  *
564  * Choose one configuration from configuration space defined by @params.
565  * The configuration chosen is that obtained fixing in this order:
566  * first access, first format, first subformat, min channels,
567  * min rate, min period time, max buffer size, min tick time
568  *
569  * Return: Zero if successful, or a negative error code on failure.
570  */
571 static int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm,
572                                     struct snd_pcm_hw_params *params)
573 {
574         static const int vars[] = {
575                 SNDRV_PCM_HW_PARAM_ACCESS,
576                 SNDRV_PCM_HW_PARAM_FORMAT,
577                 SNDRV_PCM_HW_PARAM_SUBFORMAT,
578                 SNDRV_PCM_HW_PARAM_CHANNELS,
579                 SNDRV_PCM_HW_PARAM_RATE,
580                 SNDRV_PCM_HW_PARAM_PERIOD_TIME,
581                 SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
582                 SNDRV_PCM_HW_PARAM_TICK_TIME,
583                 -1
584         };
585         const int *v;
586         struct snd_mask old_mask;
587         struct snd_interval old_interval;
588         int changed;
589
590         for (v = vars; *v != -1; v++) {
591                 /* Keep old parameter to trace. */
592                 if (trace_hw_mask_param_enabled()) {
593                         if (hw_is_mask(*v))
594                                 old_mask = *hw_param_mask(params, *v);
595                 }
596                 if (trace_hw_interval_param_enabled()) {
597                         if (hw_is_interval(*v))
598                                 old_interval = *hw_param_interval(params, *v);
599                 }
600                 if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE)
601                         changed = snd_pcm_hw_param_first(pcm, params, *v, NULL);
602                 else
603                         changed = snd_pcm_hw_param_last(pcm, params, *v, NULL);
604                 if (changed < 0)
605                         return changed;
606                 if (changed == 0)
607                         continue;
608
609                 /* Trace the changed parameter. */
610                 if (hw_is_mask(*v)) {
611                         trace_hw_mask_param(pcm, *v, 0, &old_mask,
612                                             hw_param_mask(params, *v));
613                 }
614                 if (hw_is_interval(*v)) {
615                         trace_hw_interval_param(pcm, *v, 0, &old_interval,
616                                                 hw_param_interval(params, *v));
617                 }
618         }
619
620         return 0;
621 }
622
623 static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
624                              struct snd_pcm_hw_params *params)
625 {
626         struct snd_pcm_runtime *runtime;
627         int err, usecs;
628         unsigned int bits;
629         snd_pcm_uframes_t frames;
630
631         if (PCM_RUNTIME_CHECK(substream))
632                 return -ENXIO;
633         runtime = substream->runtime;
634         snd_pcm_stream_lock_irq(substream);
635         switch (runtime->status->state) {
636         case SNDRV_PCM_STATE_OPEN:
637         case SNDRV_PCM_STATE_SETUP:
638         case SNDRV_PCM_STATE_PREPARED:
639                 break;
640         default:
641                 snd_pcm_stream_unlock_irq(substream);
642                 return -EBADFD;
643         }
644         snd_pcm_stream_unlock_irq(substream);
645 #if IS_ENABLED(CONFIG_SND_PCM_OSS)
646         if (!substream->oss.oss)
647 #endif
648                 if (atomic_read(&substream->mmap_count))
649                         return -EBADFD;
650
651         params->rmask = ~0U;
652         err = snd_pcm_hw_refine(substream, params);
653         if (err < 0)
654                 goto _error;
655
656         err = snd_pcm_hw_params_choose(substream, params);
657         if (err < 0)
658                 goto _error;
659
660         err = fixup_unreferenced_params(substream, params);
661         if (err < 0)
662                 goto _error;
663
664         if (substream->ops->hw_params != NULL) {
665                 err = substream->ops->hw_params(substream, params);
666                 if (err < 0)
667                         goto _error;
668         }
669
670         runtime->access = params_access(params);
671         runtime->format = params_format(params);
672         runtime->subformat = params_subformat(params);
673         runtime->channels = params_channels(params);
674         runtime->rate = params_rate(params);
675         runtime->period_size = params_period_size(params);
676         runtime->periods = params_periods(params);
677         runtime->buffer_size = params_buffer_size(params);
678         runtime->info = params->info;
679         runtime->rate_num = params->rate_num;
680         runtime->rate_den = params->rate_den;
681         runtime->no_period_wakeup =
682                         (params->info & SNDRV_PCM_INFO_NO_PERIOD_WAKEUP) &&
683                         (params->flags & SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP);
684
685         bits = snd_pcm_format_physical_width(runtime->format);
686         runtime->sample_bits = bits;
687         bits *= runtime->channels;
688         runtime->frame_bits = bits;
689         frames = 1;
690         while (bits % 8 != 0) {
691                 bits *= 2;
692                 frames *= 2;
693         }
694         runtime->byte_align = bits / 8;
695         runtime->min_align = frames;
696
697         /* Default sw params */
698         runtime->tstamp_mode = SNDRV_PCM_TSTAMP_NONE;
699         runtime->period_step = 1;
700         runtime->control->avail_min = runtime->period_size;
701         runtime->start_threshold = 1;
702         runtime->stop_threshold = runtime->buffer_size;
703         runtime->silence_threshold = 0;
704         runtime->silence_size = 0;
705         runtime->boundary = runtime->buffer_size;
706         while (runtime->boundary * 2 <= LONG_MAX - runtime->buffer_size)
707                 runtime->boundary *= 2;
708
709         snd_pcm_timer_resolution_change(substream);
710         snd_pcm_set_state(substream, SNDRV_PCM_STATE_SETUP);
711
712         if (pm_qos_request_active(&substream->latency_pm_qos_req))
713                 pm_qos_remove_request(&substream->latency_pm_qos_req);
714         if ((usecs = period_to_usecs(runtime)) >= 0)
715                 pm_qos_add_request(&substream->latency_pm_qos_req,
716                                    PM_QOS_CPU_DMA_LATENCY, usecs);
717         return 0;
718  _error:
719         /* hardware might be unusable from this time,
720            so we force application to retry to set
721            the correct hardware parameter settings */
722         snd_pcm_set_state(substream, SNDRV_PCM_STATE_OPEN);
723         if (substream->ops->hw_free != NULL)
724                 substream->ops->hw_free(substream);
725         return err;
726 }
727
728 static int snd_pcm_hw_params_user(struct snd_pcm_substream *substream,
729                                   struct snd_pcm_hw_params __user * _params)
730 {
731         struct snd_pcm_hw_params *params;
732         int err;
733
734         params = memdup_user(_params, sizeof(*params));
735         if (IS_ERR(params))
736                 return PTR_ERR(params);
737
738         err = snd_pcm_hw_params(substream, params);
739         if (err < 0)
740                 goto end;
741
742         if (copy_to_user(_params, params, sizeof(*params)))
743                 err = -EFAULT;
744 end:
745         kfree(params);
746         return err;
747 }
748
749 static int snd_pcm_hw_free(struct snd_pcm_substream *substream)
750 {
751         struct snd_pcm_runtime *runtime;
752         int result = 0;
753
754         if (PCM_RUNTIME_CHECK(substream))
755                 return -ENXIO;
756         runtime = substream->runtime;
757         snd_pcm_stream_lock_irq(substream);
758         switch (runtime->status->state) {
759         case SNDRV_PCM_STATE_SETUP:
760         case SNDRV_PCM_STATE_PREPARED:
761                 break;
762         default:
763                 snd_pcm_stream_unlock_irq(substream);
764                 return -EBADFD;
765         }
766         snd_pcm_stream_unlock_irq(substream);
767         if (atomic_read(&substream->mmap_count))
768                 return -EBADFD;
769         if (substream->ops->hw_free)
770                 result = substream->ops->hw_free(substream);
771         snd_pcm_set_state(substream, SNDRV_PCM_STATE_OPEN);
772         pm_qos_remove_request(&substream->latency_pm_qos_req);
773         return result;
774 }
775
776 static int snd_pcm_sw_params(struct snd_pcm_substream *substream,
777                              struct snd_pcm_sw_params *params)
778 {
779         struct snd_pcm_runtime *runtime;
780         int err;
781
782         if (PCM_RUNTIME_CHECK(substream))
783                 return -ENXIO;
784         runtime = substream->runtime;
785         snd_pcm_stream_lock_irq(substream);
786         if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
787                 snd_pcm_stream_unlock_irq(substream);
788                 return -EBADFD;
789         }
790         snd_pcm_stream_unlock_irq(substream);
791
792         if (params->tstamp_mode < 0 ||
793             params->tstamp_mode > SNDRV_PCM_TSTAMP_LAST)
794                 return -EINVAL;
795         if (params->proto >= SNDRV_PROTOCOL_VERSION(2, 0, 12) &&
796             params->tstamp_type > SNDRV_PCM_TSTAMP_TYPE_LAST)
797                 return -EINVAL;
798         if (params->avail_min == 0)
799                 return -EINVAL;
800         if (params->silence_size >= runtime->boundary) {
801                 if (params->silence_threshold != 0)
802                         return -EINVAL;
803         } else {
804                 if (params->silence_size > params->silence_threshold)
805                         return -EINVAL;
806                 if (params->silence_threshold > runtime->buffer_size)
807                         return -EINVAL;
808         }
809         err = 0;
810         snd_pcm_stream_lock_irq(substream);
811         runtime->tstamp_mode = params->tstamp_mode;
812         if (params->proto >= SNDRV_PROTOCOL_VERSION(2, 0, 12))
813                 runtime->tstamp_type = params->tstamp_type;
814         runtime->period_step = params->period_step;
815         runtime->control->avail_min = params->avail_min;
816         runtime->start_threshold = params->start_threshold;
817         runtime->stop_threshold = params->stop_threshold;
818         runtime->silence_threshold = params->silence_threshold;
819         runtime->silence_size = params->silence_size;
820         params->boundary = runtime->boundary;
821         if (snd_pcm_running(substream)) {
822                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
823                     runtime->silence_size > 0)
824                         snd_pcm_playback_silence(substream, ULONG_MAX);
825                 err = snd_pcm_update_state(substream, runtime);
826         }
827         snd_pcm_stream_unlock_irq(substream);
828         return err;
829 }
830
831 static int snd_pcm_sw_params_user(struct snd_pcm_substream *substream,
832                                   struct snd_pcm_sw_params __user * _params)
833 {
834         struct snd_pcm_sw_params params;
835         int err;
836         if (copy_from_user(&params, _params, sizeof(params)))
837                 return -EFAULT;
838         err = snd_pcm_sw_params(substream, &params);
839         if (copy_to_user(_params, &params, sizeof(params)))
840                 return -EFAULT;
841         return err;
842 }
843
844 static inline snd_pcm_uframes_t
845 snd_pcm_calc_delay(struct snd_pcm_substream *substream)
846 {
847         snd_pcm_uframes_t delay;
848
849         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
850                 delay = snd_pcm_playback_hw_avail(substream->runtime);
851         else
852                 delay = snd_pcm_capture_avail(substream->runtime);
853         return delay + substream->runtime->delay;
854 }
855
856 int snd_pcm_status(struct snd_pcm_substream *substream,
857                    struct snd_pcm_status *status)
858 {
859         struct snd_pcm_runtime *runtime = substream->runtime;
860
861         snd_pcm_stream_lock_irq(substream);
862
863         snd_pcm_unpack_audio_tstamp_config(status->audio_tstamp_data,
864                                         &runtime->audio_tstamp_config);
865
866         /* backwards compatible behavior */
867         if (runtime->audio_tstamp_config.type_requested ==
868                 SNDRV_PCM_AUDIO_TSTAMP_TYPE_COMPAT) {
869                 if (runtime->hw.info & SNDRV_PCM_INFO_HAS_WALL_CLOCK)
870                         runtime->audio_tstamp_config.type_requested =
871                                 SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK;
872                 else
873                         runtime->audio_tstamp_config.type_requested =
874                                 SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT;
875                 runtime->audio_tstamp_report.valid = 0;
876         } else
877                 runtime->audio_tstamp_report.valid = 1;
878
879         status->state = runtime->status->state;
880         status->suspended_state = runtime->status->suspended_state;
881         if (status->state == SNDRV_PCM_STATE_OPEN)
882                 goto _end;
883         status->trigger_tstamp = runtime->trigger_tstamp;
884         if (snd_pcm_running(substream)) {
885                 snd_pcm_update_hw_ptr(substream);
886                 if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE) {
887                         status->tstamp = runtime->status->tstamp;
888                         status->driver_tstamp = runtime->driver_tstamp;
889                         status->audio_tstamp =
890                                 runtime->status->audio_tstamp;
891                         if (runtime->audio_tstamp_report.valid == 1)
892                                 /* backwards compatibility, no report provided in COMPAT mode */
893                                 snd_pcm_pack_audio_tstamp_report(&status->audio_tstamp_data,
894                                                                 &status->audio_tstamp_accuracy,
895                                                                 &runtime->audio_tstamp_report);
896
897                         goto _tstamp_end;
898                 }
899         } else {
900                 /* get tstamp only in fallback mode and only if enabled */
901                 if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
902                         snd_pcm_gettime(runtime, &status->tstamp);
903         }
904  _tstamp_end:
905         status->appl_ptr = runtime->control->appl_ptr;
906         status->hw_ptr = runtime->status->hw_ptr;
907         status->avail = snd_pcm_avail(substream);
908         status->delay = snd_pcm_running(substream) ?
909                 snd_pcm_calc_delay(substream) : 0;
910         status->avail_max = runtime->avail_max;
911         status->overrange = runtime->overrange;
912         runtime->avail_max = 0;
913         runtime->overrange = 0;
914  _end:
915         snd_pcm_stream_unlock_irq(substream);
916         return 0;
917 }
918
919 static int snd_pcm_status_user(struct snd_pcm_substream *substream,
920                                struct snd_pcm_status __user * _status,
921                                bool ext)
922 {
923         struct snd_pcm_status status;
924         int res;
925
926         memset(&status, 0, sizeof(status));
927         /*
928          * with extension, parameters are read/write,
929          * get audio_tstamp_data from user,
930          * ignore rest of status structure
931          */
932         if (ext && get_user(status.audio_tstamp_data,
933                                 (u32 __user *)(&_status->audio_tstamp_data)))
934                 return -EFAULT;
935         res = snd_pcm_status(substream, &status);
936         if (res < 0)
937                 return res;
938         if (copy_to_user(_status, &status, sizeof(status)))
939                 return -EFAULT;
940         return 0;
941 }
942
943 static int snd_pcm_channel_info(struct snd_pcm_substream *substream,
944                                 struct snd_pcm_channel_info * info)
945 {
946         struct snd_pcm_runtime *runtime;
947         unsigned int channel;
948         
949         channel = info->channel;
950         runtime = substream->runtime;
951         snd_pcm_stream_lock_irq(substream);
952         if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
953                 snd_pcm_stream_unlock_irq(substream);
954                 return -EBADFD;
955         }
956         snd_pcm_stream_unlock_irq(substream);
957         if (channel >= runtime->channels)
958                 return -EINVAL;
959         memset(info, 0, sizeof(*info));
960         info->channel = channel;
961         return substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_CHANNEL_INFO, info);
962 }
963
964 static int snd_pcm_channel_info_user(struct snd_pcm_substream *substream,
965                                      struct snd_pcm_channel_info __user * _info)
966 {
967         struct snd_pcm_channel_info info;
968         int res;
969         
970         if (copy_from_user(&info, _info, sizeof(info)))
971                 return -EFAULT;
972         res = snd_pcm_channel_info(substream, &info);
973         if (res < 0)
974                 return res;
975         if (copy_to_user(_info, &info, sizeof(info)))
976                 return -EFAULT;
977         return 0;
978 }
979
980 static void snd_pcm_trigger_tstamp(struct snd_pcm_substream *substream)
981 {
982         struct snd_pcm_runtime *runtime = substream->runtime;
983         if (runtime->trigger_master == NULL)
984                 return;
985         if (runtime->trigger_master == substream) {
986                 if (!runtime->trigger_tstamp_latched)
987                         snd_pcm_gettime(runtime, &runtime->trigger_tstamp);
988         } else {
989                 snd_pcm_trigger_tstamp(runtime->trigger_master);
990                 runtime->trigger_tstamp = runtime->trigger_master->runtime->trigger_tstamp;
991         }
992         runtime->trigger_master = NULL;
993 }
994
995 struct action_ops {
996         int (*pre_action)(struct snd_pcm_substream *substream, int state);
997         int (*do_action)(struct snd_pcm_substream *substream, int state);
998         void (*undo_action)(struct snd_pcm_substream *substream, int state);
999         void (*post_action)(struct snd_pcm_substream *substream, int state);
1000 };
1001
1002 /*
1003  *  this functions is core for handling of linked stream
1004  *  Note: the stream state might be changed also on failure
1005  *  Note2: call with calling stream lock + link lock
1006  */
1007 static int snd_pcm_action_group(const struct action_ops *ops,
1008                                 struct snd_pcm_substream *substream,
1009                                 int state, int do_lock)
1010 {
1011         struct snd_pcm_substream *s = NULL;
1012         struct snd_pcm_substream *s1;
1013         int res = 0, depth = 1;
1014
1015         snd_pcm_group_for_each_entry(s, substream) {
1016                 if (do_lock && s != substream) {
1017                         if (s->pcm->nonatomic)
1018                                 mutex_lock_nested(&s->self_group.mutex, depth);
1019                         else
1020                                 spin_lock_nested(&s->self_group.lock, depth);
1021                         depth++;
1022                 }
1023                 res = ops->pre_action(s, state);
1024                 if (res < 0)
1025                         goto _unlock;
1026         }
1027         snd_pcm_group_for_each_entry(s, substream) {
1028                 res = ops->do_action(s, state);
1029                 if (res < 0) {
1030                         if (ops->undo_action) {
1031                                 snd_pcm_group_for_each_entry(s1, substream) {
1032                                         if (s1 == s) /* failed stream */
1033                                                 break;
1034                                         ops->undo_action(s1, state);
1035                                 }
1036                         }
1037                         s = NULL; /* unlock all */
1038                         goto _unlock;
1039                 }
1040         }
1041         snd_pcm_group_for_each_entry(s, substream) {
1042                 ops->post_action(s, state);
1043         }
1044  _unlock:
1045         if (do_lock) {
1046                 /* unlock streams */
1047                 snd_pcm_group_for_each_entry(s1, substream) {
1048                         if (s1 != substream) {
1049                                 if (s1->pcm->nonatomic)
1050                                         mutex_unlock(&s1->self_group.mutex);
1051                                 else
1052                                         spin_unlock(&s1->self_group.lock);
1053                         }
1054                         if (s1 == s)    /* end */
1055                                 break;
1056                 }
1057         }
1058         return res;
1059 }
1060
1061 /*
1062  *  Note: call with stream lock
1063  */
1064 static int snd_pcm_action_single(const struct action_ops *ops,
1065                                  struct snd_pcm_substream *substream,
1066                                  int state)
1067 {
1068         int res;
1069         
1070         res = ops->pre_action(substream, state);
1071         if (res < 0)
1072                 return res;
1073         res = ops->do_action(substream, state);
1074         if (res == 0)
1075                 ops->post_action(substream, state);
1076         else if (ops->undo_action)
1077                 ops->undo_action(substream, state);
1078         return res;
1079 }
1080
1081 static void snd_pcm_group_assign(struct snd_pcm_substream *substream,
1082                                  struct snd_pcm_group *new_group)
1083 {
1084         substream->group = new_group;
1085         list_move(&substream->link_list, &new_group->substreams);
1086 }
1087
1088 /*
1089  * Unref and unlock the group, but keep the stream lock;
1090  * when the group becomes empty and no longer referred, destroy itself
1091  */
1092 static void snd_pcm_group_unref(struct snd_pcm_group *group,
1093                                 struct snd_pcm_substream *substream)
1094 {
1095         bool do_free;
1096
1097         if (!group)
1098                 return;
1099         do_free = refcount_dec_and_test(&group->refs);
1100         snd_pcm_group_unlock(group, substream->pcm->nonatomic);
1101         if (do_free)
1102                 kfree(group);
1103 }
1104
1105 /*
1106  * Lock the group inside a stream lock and reference it;
1107  * return the locked group object, or NULL if not linked
1108  */
1109 static struct snd_pcm_group *
1110 snd_pcm_stream_group_ref(struct snd_pcm_substream *substream)
1111 {
1112         bool nonatomic = substream->pcm->nonatomic;
1113         struct snd_pcm_group *group;
1114         bool trylock;
1115
1116         for (;;) {
1117                 if (!snd_pcm_stream_linked(substream))
1118                         return NULL;
1119                 group = substream->group;
1120                 /* block freeing the group object */
1121                 refcount_inc(&group->refs);
1122
1123                 trylock = nonatomic ? mutex_trylock(&group->mutex) :
1124                         spin_trylock(&group->lock);
1125                 if (trylock)
1126                         break; /* OK */
1127
1128                 /* re-lock for avoiding ABBA deadlock */
1129                 snd_pcm_stream_unlock(substream);
1130                 snd_pcm_group_lock(group, nonatomic);
1131                 snd_pcm_stream_lock(substream);
1132
1133                 /* check the group again; the above opens a small race window */
1134                 if (substream->group == group)
1135                         break; /* OK */
1136                 /* group changed, try again */
1137                 snd_pcm_group_unref(group, substream);
1138         }
1139         return group;
1140 }
1141
1142 /*
1143  *  Note: call with stream lock
1144  */
1145 static int snd_pcm_action(const struct action_ops *ops,
1146                           struct snd_pcm_substream *substream,
1147                           int state)
1148 {
1149         struct snd_pcm_group *group;
1150         int res;
1151
1152         group = snd_pcm_stream_group_ref(substream);
1153         if (group)
1154                 res = snd_pcm_action_group(ops, substream, state, 1);
1155         else
1156                 res = snd_pcm_action_single(ops, substream, state);
1157         snd_pcm_group_unref(group, substream);
1158         return res;
1159 }
1160
1161 /*
1162  *  Note: don't use any locks before
1163  */
1164 static int snd_pcm_action_lock_irq(const struct action_ops *ops,
1165                                    struct snd_pcm_substream *substream,
1166                                    int state)
1167 {
1168         int res;
1169
1170         snd_pcm_stream_lock_irq(substream);
1171         res = snd_pcm_action(ops, substream, state);
1172         snd_pcm_stream_unlock_irq(substream);
1173         return res;
1174 }
1175
1176 /*
1177  */
1178 static int snd_pcm_action_nonatomic(const struct action_ops *ops,
1179                                     struct snd_pcm_substream *substream,
1180                                     int state)
1181 {
1182         int res;
1183
1184         /* Guarantee the group members won't change during non-atomic action */
1185         down_read(&snd_pcm_link_rwsem);
1186         if (snd_pcm_stream_linked(substream))
1187                 res = snd_pcm_action_group(ops, substream, state, 0);
1188         else
1189                 res = snd_pcm_action_single(ops, substream, state);
1190         up_read(&snd_pcm_link_rwsem);
1191         return res;
1192 }
1193
1194 /*
1195  * start callbacks
1196  */
1197 static int snd_pcm_pre_start(struct snd_pcm_substream *substream, int state)
1198 {
1199         struct snd_pcm_runtime *runtime = substream->runtime;
1200         if (runtime->status->state != SNDRV_PCM_STATE_PREPARED)
1201                 return -EBADFD;
1202         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
1203             !snd_pcm_playback_data(substream))
1204                 return -EPIPE;
1205         runtime->trigger_tstamp_latched = false;
1206         runtime->trigger_master = substream;
1207         return 0;
1208 }
1209
1210 static int snd_pcm_do_start(struct snd_pcm_substream *substream, int state)
1211 {
1212         if (substream->runtime->trigger_master != substream)
1213                 return 0;
1214         return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_START);
1215 }
1216
1217 static void snd_pcm_undo_start(struct snd_pcm_substream *substream, int state)
1218 {
1219         if (substream->runtime->trigger_master == substream)
1220                 substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_STOP);
1221 }
1222
1223 static void snd_pcm_post_start(struct snd_pcm_substream *substream, int state)
1224 {
1225         struct snd_pcm_runtime *runtime = substream->runtime;
1226         snd_pcm_trigger_tstamp(substream);
1227         runtime->hw_ptr_jiffies = jiffies;
1228         runtime->hw_ptr_buffer_jiffies = (runtime->buffer_size * HZ) / 
1229                                                             runtime->rate;
1230         runtime->status->state = state;
1231         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
1232             runtime->silence_size > 0)
1233                 snd_pcm_playback_silence(substream, ULONG_MAX);
1234         snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MSTART);
1235 }
1236
1237 static const struct action_ops snd_pcm_action_start = {
1238         .pre_action = snd_pcm_pre_start,
1239         .do_action = snd_pcm_do_start,
1240         .undo_action = snd_pcm_undo_start,
1241         .post_action = snd_pcm_post_start
1242 };
1243
1244 /**
1245  * snd_pcm_start - start all linked streams
1246  * @substream: the PCM substream instance
1247  *
1248  * Return: Zero if successful, or a negative error code.
1249  * The stream lock must be acquired before calling this function.
1250  */
1251 int snd_pcm_start(struct snd_pcm_substream *substream)
1252 {
1253         return snd_pcm_action(&snd_pcm_action_start, substream,
1254                               SNDRV_PCM_STATE_RUNNING);
1255 }
1256
1257 /* take the stream lock and start the streams */
1258 static int snd_pcm_start_lock_irq(struct snd_pcm_substream *substream)
1259 {
1260         return snd_pcm_action_lock_irq(&snd_pcm_action_start, substream,
1261                                        SNDRV_PCM_STATE_RUNNING);
1262 }
1263
1264 /*
1265  * stop callbacks
1266  */
1267 static int snd_pcm_pre_stop(struct snd_pcm_substream *substream, int state)
1268 {
1269         struct snd_pcm_runtime *runtime = substream->runtime;
1270         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
1271                 return -EBADFD;
1272         runtime->trigger_master = substream;
1273         return 0;
1274 }
1275
1276 static int snd_pcm_do_stop(struct snd_pcm_substream *substream, int state)
1277 {
1278         if (substream->runtime->trigger_master == substream &&
1279             snd_pcm_running(substream))
1280                 substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_STOP);
1281         return 0; /* unconditonally stop all substreams */
1282 }
1283
1284 static void snd_pcm_post_stop(struct snd_pcm_substream *substream, int state)
1285 {
1286         struct snd_pcm_runtime *runtime = substream->runtime;
1287         if (runtime->status->state != state) {
1288                 snd_pcm_trigger_tstamp(substream);
1289                 runtime->status->state = state;
1290                 snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MSTOP);
1291         }
1292         wake_up(&runtime->sleep);
1293         wake_up(&runtime->tsleep);
1294 }
1295
1296 static const struct action_ops snd_pcm_action_stop = {
1297         .pre_action = snd_pcm_pre_stop,
1298         .do_action = snd_pcm_do_stop,
1299         .post_action = snd_pcm_post_stop
1300 };
1301
1302 /**
1303  * snd_pcm_stop - try to stop all running streams in the substream group
1304  * @substream: the PCM substream instance
1305  * @state: PCM state after stopping the stream
1306  *
1307  * The state of each stream is then changed to the given state unconditionally.
1308  *
1309  * Return: Zero if successful, or a negative error code.
1310  */
1311 int snd_pcm_stop(struct snd_pcm_substream *substream, snd_pcm_state_t state)
1312 {
1313         return snd_pcm_action(&snd_pcm_action_stop, substream, state);
1314 }
1315 EXPORT_SYMBOL(snd_pcm_stop);
1316
1317 /**
1318  * snd_pcm_drain_done - stop the DMA only when the given stream is playback
1319  * @substream: the PCM substream
1320  *
1321  * After stopping, the state is changed to SETUP.
1322  * Unlike snd_pcm_stop(), this affects only the given stream.
1323  *
1324  * Return: Zero if succesful, or a negative error code.
1325  */
1326 int snd_pcm_drain_done(struct snd_pcm_substream *substream)
1327 {
1328         return snd_pcm_action_single(&snd_pcm_action_stop, substream,
1329                                      SNDRV_PCM_STATE_SETUP);
1330 }
1331
1332 /**
1333  * snd_pcm_stop_xrun - stop the running streams as XRUN
1334  * @substream: the PCM substream instance
1335  *
1336  * This stops the given running substream (and all linked substreams) as XRUN.
1337  * Unlike snd_pcm_stop(), this function takes the substream lock by itself.
1338  *
1339  * Return: Zero if successful, or a negative error code.
1340  */
1341 int snd_pcm_stop_xrun(struct snd_pcm_substream *substream)
1342 {
1343         unsigned long flags;
1344
1345         snd_pcm_stream_lock_irqsave(substream, flags);
1346         if (substream->runtime && snd_pcm_running(substream))
1347                 __snd_pcm_xrun(substream);
1348         snd_pcm_stream_unlock_irqrestore(substream, flags);
1349         return 0;
1350 }
1351 EXPORT_SYMBOL_GPL(snd_pcm_stop_xrun);
1352
1353 /*
1354  * pause callbacks
1355  */
1356 static int snd_pcm_pre_pause(struct snd_pcm_substream *substream, int push)
1357 {
1358         struct snd_pcm_runtime *runtime = substream->runtime;
1359         if (!(runtime->info & SNDRV_PCM_INFO_PAUSE))
1360                 return -ENOSYS;
1361         if (push) {
1362                 if (runtime->status->state != SNDRV_PCM_STATE_RUNNING)
1363                         return -EBADFD;
1364         } else if (runtime->status->state != SNDRV_PCM_STATE_PAUSED)
1365                 return -EBADFD;
1366         runtime->trigger_master = substream;
1367         return 0;
1368 }
1369
1370 static int snd_pcm_do_pause(struct snd_pcm_substream *substream, int push)
1371 {
1372         if (substream->runtime->trigger_master != substream)
1373                 return 0;
1374         /* some drivers might use hw_ptr to recover from the pause -
1375            update the hw_ptr now */
1376         if (push)
1377                 snd_pcm_update_hw_ptr(substream);
1378         /* The jiffies check in snd_pcm_update_hw_ptr*() is done by
1379          * a delta between the current jiffies, this gives a large enough
1380          * delta, effectively to skip the check once.
1381          */
1382         substream->runtime->hw_ptr_jiffies = jiffies - HZ * 1000;
1383         return substream->ops->trigger(substream,
1384                                        push ? SNDRV_PCM_TRIGGER_PAUSE_PUSH :
1385                                               SNDRV_PCM_TRIGGER_PAUSE_RELEASE);
1386 }
1387
1388 static void snd_pcm_undo_pause(struct snd_pcm_substream *substream, int push)
1389 {
1390         if (substream->runtime->trigger_master == substream)
1391                 substream->ops->trigger(substream,
1392                                         push ? SNDRV_PCM_TRIGGER_PAUSE_RELEASE :
1393                                         SNDRV_PCM_TRIGGER_PAUSE_PUSH);
1394 }
1395
1396 static void snd_pcm_post_pause(struct snd_pcm_substream *substream, int push)
1397 {
1398         struct snd_pcm_runtime *runtime = substream->runtime;
1399         snd_pcm_trigger_tstamp(substream);
1400         if (push) {
1401                 runtime->status->state = SNDRV_PCM_STATE_PAUSED;
1402                 snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MPAUSE);
1403                 wake_up(&runtime->sleep);
1404                 wake_up(&runtime->tsleep);
1405         } else {
1406                 runtime->status->state = SNDRV_PCM_STATE_RUNNING;
1407                 snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MCONTINUE);
1408         }
1409 }
1410
1411 static const struct action_ops snd_pcm_action_pause = {
1412         .pre_action = snd_pcm_pre_pause,
1413         .do_action = snd_pcm_do_pause,
1414         .undo_action = snd_pcm_undo_pause,
1415         .post_action = snd_pcm_post_pause
1416 };
1417
1418 /*
1419  * Push/release the pause for all linked streams.
1420  */
1421 static int snd_pcm_pause(struct snd_pcm_substream *substream, int push)
1422 {
1423         return snd_pcm_action(&snd_pcm_action_pause, substream, push);
1424 }
1425
1426 #ifdef CONFIG_PM
1427 /* suspend */
1428
1429 static int snd_pcm_pre_suspend(struct snd_pcm_substream *substream, int state)
1430 {
1431         struct snd_pcm_runtime *runtime = substream->runtime;
1432         switch (runtime->status->state) {
1433         case SNDRV_PCM_STATE_SUSPENDED:
1434                 return -EBUSY;
1435         /* unresumable PCM state; return -EBUSY for skipping suspend */
1436         case SNDRV_PCM_STATE_OPEN:
1437         case SNDRV_PCM_STATE_SETUP:
1438         case SNDRV_PCM_STATE_DISCONNECTED:
1439                 return -EBUSY;
1440         }
1441         runtime->trigger_master = substream;
1442         return 0;
1443 }
1444
1445 static int snd_pcm_do_suspend(struct snd_pcm_substream *substream, int state)
1446 {
1447         struct snd_pcm_runtime *runtime = substream->runtime;
1448         if (runtime->trigger_master != substream)
1449                 return 0;
1450         if (! snd_pcm_running(substream))
1451                 return 0;
1452         substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_SUSPEND);
1453         return 0; /* suspend unconditionally */
1454 }
1455
1456 static void snd_pcm_post_suspend(struct snd_pcm_substream *substream, int state)
1457 {
1458         struct snd_pcm_runtime *runtime = substream->runtime;
1459         snd_pcm_trigger_tstamp(substream);
1460         runtime->status->suspended_state = runtime->status->state;
1461         runtime->status->state = SNDRV_PCM_STATE_SUSPENDED;
1462         snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MSUSPEND);
1463         wake_up(&runtime->sleep);
1464         wake_up(&runtime->tsleep);
1465 }
1466
1467 static const struct action_ops snd_pcm_action_suspend = {
1468         .pre_action = snd_pcm_pre_suspend,
1469         .do_action = snd_pcm_do_suspend,
1470         .post_action = snd_pcm_post_suspend
1471 };
1472
1473 /*
1474  * snd_pcm_suspend - trigger SUSPEND to all linked streams
1475  * @substream: the PCM substream
1476  *
1477  * After this call, all streams are changed to SUSPENDED state.
1478  *
1479  * Return: Zero if successful, or a negative error code.
1480  */
1481 static int snd_pcm_suspend(struct snd_pcm_substream *substream)
1482 {
1483         int err;
1484         unsigned long flags;
1485
1486         snd_pcm_stream_lock_irqsave(substream, flags);
1487         err = snd_pcm_action(&snd_pcm_action_suspend, substream, 0);
1488         snd_pcm_stream_unlock_irqrestore(substream, flags);
1489         return err;
1490 }
1491
1492 /**
1493  * snd_pcm_suspend_all - trigger SUSPEND to all substreams in the given pcm
1494  * @pcm: the PCM instance
1495  *
1496  * After this call, all streams are changed to SUSPENDED state.
1497  *
1498  * Return: Zero if successful (or @pcm is %NULL), or a negative error code.
1499  */
1500 int snd_pcm_suspend_all(struct snd_pcm *pcm)
1501 {
1502         struct snd_pcm_substream *substream;
1503         int stream, err = 0;
1504
1505         if (! pcm)
1506                 return 0;
1507
1508         for (stream = 0; stream < 2; stream++) {
1509                 for (substream = pcm->streams[stream].substream;
1510                      substream; substream = substream->next) {
1511                         /* FIXME: the open/close code should lock this as well */
1512                         if (substream->runtime == NULL)
1513                                 continue;
1514
1515                         /*
1516                          * Skip BE dai link PCM's that are internal and may
1517                          * not have their substream ops set.
1518                          */
1519                         if (!substream->ops)
1520                                 continue;
1521
1522                         err = snd_pcm_suspend(substream);
1523                         if (err < 0 && err != -EBUSY)
1524                                 return err;
1525                 }
1526         }
1527         return 0;
1528 }
1529 EXPORT_SYMBOL(snd_pcm_suspend_all);
1530
1531 /* resume */
1532
1533 static int snd_pcm_pre_resume(struct snd_pcm_substream *substream, int state)
1534 {
1535         struct snd_pcm_runtime *runtime = substream->runtime;
1536         if (!(runtime->info & SNDRV_PCM_INFO_RESUME))
1537                 return -ENOSYS;
1538         runtime->trigger_master = substream;
1539         return 0;
1540 }
1541
1542 static int snd_pcm_do_resume(struct snd_pcm_substream *substream, int state)
1543 {
1544         struct snd_pcm_runtime *runtime = substream->runtime;
1545         if (runtime->trigger_master != substream)
1546                 return 0;
1547         /* DMA not running previously? */
1548         if (runtime->status->suspended_state != SNDRV_PCM_STATE_RUNNING &&
1549             (runtime->status->suspended_state != SNDRV_PCM_STATE_DRAINING ||
1550              substream->stream != SNDRV_PCM_STREAM_PLAYBACK))
1551                 return 0;
1552         return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_RESUME);
1553 }
1554
1555 static void snd_pcm_undo_resume(struct snd_pcm_substream *substream, int state)
1556 {
1557         if (substream->runtime->trigger_master == substream &&
1558             snd_pcm_running(substream))
1559                 substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_SUSPEND);
1560 }
1561
1562 static void snd_pcm_post_resume(struct snd_pcm_substream *substream, int state)
1563 {
1564         struct snd_pcm_runtime *runtime = substream->runtime;
1565         snd_pcm_trigger_tstamp(substream);
1566         runtime->status->state = runtime->status->suspended_state;
1567         snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MRESUME);
1568 }
1569
1570 static const struct action_ops snd_pcm_action_resume = {
1571         .pre_action = snd_pcm_pre_resume,
1572         .do_action = snd_pcm_do_resume,
1573         .undo_action = snd_pcm_undo_resume,
1574         .post_action = snd_pcm_post_resume
1575 };
1576
1577 static int snd_pcm_resume(struct snd_pcm_substream *substream)
1578 {
1579         return snd_pcm_action_lock_irq(&snd_pcm_action_resume, substream, 0);
1580 }
1581
1582 #else
1583
1584 static int snd_pcm_resume(struct snd_pcm_substream *substream)
1585 {
1586         return -ENOSYS;
1587 }
1588
1589 #endif /* CONFIG_PM */
1590
1591 /*
1592  * xrun ioctl
1593  *
1594  * Change the RUNNING stream(s) to XRUN state.
1595  */
1596 static int snd_pcm_xrun(struct snd_pcm_substream *substream)
1597 {
1598         struct snd_pcm_runtime *runtime = substream->runtime;
1599         int result;
1600
1601         snd_pcm_stream_lock_irq(substream);
1602         switch (runtime->status->state) {
1603         case SNDRV_PCM_STATE_XRUN:
1604                 result = 0;     /* already there */
1605                 break;
1606         case SNDRV_PCM_STATE_RUNNING:
1607                 __snd_pcm_xrun(substream);
1608                 result = 0;
1609                 break;
1610         default:
1611                 result = -EBADFD;
1612         }
1613         snd_pcm_stream_unlock_irq(substream);
1614         return result;
1615 }
1616
1617 /*
1618  * reset ioctl
1619  */
1620 static int snd_pcm_pre_reset(struct snd_pcm_substream *substream, int state)
1621 {
1622         struct snd_pcm_runtime *runtime = substream->runtime;
1623         switch (runtime->status->state) {
1624         case SNDRV_PCM_STATE_RUNNING:
1625         case SNDRV_PCM_STATE_PREPARED:
1626         case SNDRV_PCM_STATE_PAUSED:
1627         case SNDRV_PCM_STATE_SUSPENDED:
1628                 return 0;
1629         default:
1630                 return -EBADFD;
1631         }
1632 }
1633
1634 static int snd_pcm_do_reset(struct snd_pcm_substream *substream, int state)
1635 {
1636         struct snd_pcm_runtime *runtime = substream->runtime;
1637         int err = substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_RESET, NULL);
1638         if (err < 0)
1639                 return err;
1640         runtime->hw_ptr_base = 0;
1641         runtime->hw_ptr_interrupt = runtime->status->hw_ptr -
1642                 runtime->status->hw_ptr % runtime->period_size;
1643         runtime->silence_start = runtime->status->hw_ptr;
1644         runtime->silence_filled = 0;
1645         return 0;
1646 }
1647
1648 static void snd_pcm_post_reset(struct snd_pcm_substream *substream, int state)
1649 {
1650         struct snd_pcm_runtime *runtime = substream->runtime;
1651         runtime->control->appl_ptr = runtime->status->hw_ptr;
1652         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
1653             runtime->silence_size > 0)
1654                 snd_pcm_playback_silence(substream, ULONG_MAX);
1655 }
1656
1657 static const struct action_ops snd_pcm_action_reset = {
1658         .pre_action = snd_pcm_pre_reset,
1659         .do_action = snd_pcm_do_reset,
1660         .post_action = snd_pcm_post_reset
1661 };
1662
1663 static int snd_pcm_reset(struct snd_pcm_substream *substream)
1664 {
1665         return snd_pcm_action_nonatomic(&snd_pcm_action_reset, substream, 0);
1666 }
1667
1668 /*
1669  * prepare ioctl
1670  */
1671 /* we use the second argument for updating f_flags */
1672 static int snd_pcm_pre_prepare(struct snd_pcm_substream *substream,
1673                                int f_flags)
1674 {
1675         struct snd_pcm_runtime *runtime = substream->runtime;
1676         if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
1677             runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
1678                 return -EBADFD;
1679         if (snd_pcm_running(substream))
1680                 return -EBUSY;
1681         substream->f_flags = f_flags;
1682         return 0;
1683 }
1684
1685 static int snd_pcm_do_prepare(struct snd_pcm_substream *substream, int state)
1686 {
1687         int err;
1688         err = substream->ops->prepare(substream);
1689         if (err < 0)
1690                 return err;
1691         return snd_pcm_do_reset(substream, 0);
1692 }
1693
1694 static void snd_pcm_post_prepare(struct snd_pcm_substream *substream, int state)
1695 {
1696         struct snd_pcm_runtime *runtime = substream->runtime;
1697         runtime->control->appl_ptr = runtime->status->hw_ptr;
1698         snd_pcm_set_state(substream, SNDRV_PCM_STATE_PREPARED);
1699 }
1700
1701 static const struct action_ops snd_pcm_action_prepare = {
1702         .pre_action = snd_pcm_pre_prepare,
1703         .do_action = snd_pcm_do_prepare,
1704         .post_action = snd_pcm_post_prepare
1705 };
1706
1707 /**
1708  * snd_pcm_prepare - prepare the PCM substream to be triggerable
1709  * @substream: the PCM substream instance
1710  * @file: file to refer f_flags
1711  *
1712  * Return: Zero if successful, or a negative error code.
1713  */
1714 static int snd_pcm_prepare(struct snd_pcm_substream *substream,
1715                            struct file *file)
1716 {
1717         int f_flags;
1718
1719         if (file)
1720                 f_flags = file->f_flags;
1721         else
1722                 f_flags = substream->f_flags;
1723
1724         snd_pcm_stream_lock_irq(substream);
1725         switch (substream->runtime->status->state) {
1726         case SNDRV_PCM_STATE_PAUSED:
1727                 snd_pcm_pause(substream, 0);
1728                 /* fallthru */
1729         case SNDRV_PCM_STATE_SUSPENDED:
1730                 snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
1731                 break;
1732         }
1733         snd_pcm_stream_unlock_irq(substream);
1734
1735         return snd_pcm_action_nonatomic(&snd_pcm_action_prepare,
1736                                         substream, f_flags);
1737 }
1738
1739 /*
1740  * drain ioctl
1741  */
1742
1743 static int snd_pcm_pre_drain_init(struct snd_pcm_substream *substream, int state)
1744 {
1745         struct snd_pcm_runtime *runtime = substream->runtime;
1746         switch (runtime->status->state) {
1747         case SNDRV_PCM_STATE_OPEN:
1748         case SNDRV_PCM_STATE_DISCONNECTED:
1749         case SNDRV_PCM_STATE_SUSPENDED:
1750                 return -EBADFD;
1751         }
1752         runtime->trigger_master = substream;
1753         return 0;
1754 }
1755
1756 static int snd_pcm_do_drain_init(struct snd_pcm_substream *substream, int state)
1757 {
1758         struct snd_pcm_runtime *runtime = substream->runtime;
1759         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1760                 switch (runtime->status->state) {
1761                 case SNDRV_PCM_STATE_PREPARED:
1762                         /* start playback stream if possible */
1763                         if (! snd_pcm_playback_empty(substream)) {
1764                                 snd_pcm_do_start(substream, SNDRV_PCM_STATE_DRAINING);
1765                                 snd_pcm_post_start(substream, SNDRV_PCM_STATE_DRAINING);
1766                         } else {
1767                                 runtime->status->state = SNDRV_PCM_STATE_SETUP;
1768                         }
1769                         break;
1770                 case SNDRV_PCM_STATE_RUNNING:
1771                         runtime->status->state = SNDRV_PCM_STATE_DRAINING;
1772                         break;
1773                 case SNDRV_PCM_STATE_XRUN:
1774                         runtime->status->state = SNDRV_PCM_STATE_SETUP;
1775                         break;
1776                 default:
1777                         break;
1778                 }
1779         } else {
1780                 /* stop running stream */
1781                 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING) {
1782                         int new_state = snd_pcm_capture_avail(runtime) > 0 ?
1783                                 SNDRV_PCM_STATE_DRAINING : SNDRV_PCM_STATE_SETUP;
1784                         snd_pcm_do_stop(substream, new_state);
1785                         snd_pcm_post_stop(substream, new_state);
1786                 }
1787         }
1788
1789         if (runtime->status->state == SNDRV_PCM_STATE_DRAINING &&
1790             runtime->trigger_master == substream &&
1791             (runtime->hw.info & SNDRV_PCM_INFO_DRAIN_TRIGGER))
1792                 return substream->ops->trigger(substream,
1793                                                SNDRV_PCM_TRIGGER_DRAIN);
1794
1795         return 0;
1796 }
1797
1798 static void snd_pcm_post_drain_init(struct snd_pcm_substream *substream, int state)
1799 {
1800 }
1801
1802 static const struct action_ops snd_pcm_action_drain_init = {
1803         .pre_action = snd_pcm_pre_drain_init,
1804         .do_action = snd_pcm_do_drain_init,
1805         .post_action = snd_pcm_post_drain_init
1806 };
1807
1808 /*
1809  * Drain the stream(s).
1810  * When the substream is linked, sync until the draining of all playback streams
1811  * is finished.
1812  * After this call, all streams are supposed to be either SETUP or DRAINING
1813  * (capture only) state.
1814  */
1815 static int snd_pcm_drain(struct snd_pcm_substream *substream,
1816                          struct file *file)
1817 {
1818         struct snd_card *card;
1819         struct snd_pcm_runtime *runtime;
1820         struct snd_pcm_substream *s;
1821         struct snd_pcm_group *group;
1822         wait_queue_entry_t wait;
1823         int result = 0;
1824         int nonblock = 0;
1825
1826         card = substream->pcm->card;
1827         runtime = substream->runtime;
1828
1829         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
1830                 return -EBADFD;
1831
1832         if (file) {
1833                 if (file->f_flags & O_NONBLOCK)
1834                         nonblock = 1;
1835         } else if (substream->f_flags & O_NONBLOCK)
1836                 nonblock = 1;
1837
1838         snd_pcm_stream_lock_irq(substream);
1839         /* resume pause */
1840         if (runtime->status->state == SNDRV_PCM_STATE_PAUSED)
1841                 snd_pcm_pause(substream, 0);
1842
1843         /* pre-start/stop - all running streams are changed to DRAINING state */
1844         result = snd_pcm_action(&snd_pcm_action_drain_init, substream, 0);
1845         if (result < 0)
1846                 goto unlock;
1847         /* in non-blocking, we don't wait in ioctl but let caller poll */
1848         if (nonblock) {
1849                 result = -EAGAIN;
1850                 goto unlock;
1851         }
1852
1853         for (;;) {
1854                 long tout;
1855                 struct snd_pcm_runtime *to_check;
1856                 if (signal_pending(current)) {
1857                         result = -ERESTARTSYS;
1858                         break;
1859                 }
1860                 /* find a substream to drain */
1861                 to_check = NULL;
1862                 group = snd_pcm_stream_group_ref(substream);
1863                 snd_pcm_group_for_each_entry(s, substream) {
1864                         if (s->stream != SNDRV_PCM_STREAM_PLAYBACK)
1865                                 continue;
1866                         runtime = s->runtime;
1867                         if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
1868                                 to_check = runtime;
1869                                 break;
1870                         }
1871                 }
1872                 snd_pcm_group_unref(group, substream);
1873                 if (!to_check)
1874                         break; /* all drained */
1875                 init_waitqueue_entry(&wait, current);
1876                 set_current_state(TASK_INTERRUPTIBLE);
1877                 add_wait_queue(&to_check->sleep, &wait);
1878                 snd_pcm_stream_unlock_irq(substream);
1879                 if (runtime->no_period_wakeup)
1880                         tout = MAX_SCHEDULE_TIMEOUT;
1881                 else {
1882                         tout = 10;
1883                         if (runtime->rate) {
1884                                 long t = runtime->period_size * 2 / runtime->rate;
1885                                 tout = max(t, tout);
1886                         }
1887                         tout = msecs_to_jiffies(tout * 1000);
1888                 }
1889                 tout = schedule_timeout(tout);
1890
1891                 snd_pcm_stream_lock_irq(substream);
1892                 group = snd_pcm_stream_group_ref(substream);
1893                 snd_pcm_group_for_each_entry(s, substream) {
1894                         if (s->runtime == to_check) {
1895                                 remove_wait_queue(&to_check->sleep, &wait);
1896                                 break;
1897                         }
1898                 }
1899                 snd_pcm_group_unref(group, substream);
1900
1901                 if (card->shutdown) {
1902                         result = -ENODEV;
1903                         break;
1904                 }
1905                 if (tout == 0) {
1906                         if (substream->runtime->status->state == SNDRV_PCM_STATE_SUSPENDED)
1907                                 result = -ESTRPIPE;
1908                         else {
1909                                 dev_dbg(substream->pcm->card->dev,
1910                                         "playback drain error (DMA or IRQ trouble?)\n");
1911                                 snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
1912                                 result = -EIO;
1913                         }
1914                         break;
1915                 }
1916         }
1917
1918  unlock:
1919         snd_pcm_stream_unlock_irq(substream);
1920
1921         return result;
1922 }
1923
1924 /*
1925  * drop ioctl
1926  *
1927  * Immediately put all linked substreams into SETUP state.
1928  */
1929 static int snd_pcm_drop(struct snd_pcm_substream *substream)
1930 {
1931         struct snd_pcm_runtime *runtime;
1932         int result = 0;
1933         
1934         if (PCM_RUNTIME_CHECK(substream))
1935                 return -ENXIO;
1936         runtime = substream->runtime;
1937
1938         if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
1939             runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
1940                 return -EBADFD;
1941
1942         snd_pcm_stream_lock_irq(substream);
1943         /* resume pause */
1944         if (runtime->status->state == SNDRV_PCM_STATE_PAUSED)
1945                 snd_pcm_pause(substream, 0);
1946
1947         snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
1948         /* runtime->control->appl_ptr = runtime->status->hw_ptr; */
1949         snd_pcm_stream_unlock_irq(substream);
1950
1951         return result;
1952 }
1953
1954
1955 static bool is_pcm_file(struct file *file)
1956 {
1957         struct inode *inode = file_inode(file);
1958         struct snd_pcm *pcm;
1959         unsigned int minor;
1960
1961         if (!S_ISCHR(inode->i_mode) || imajor(inode) != snd_major)
1962                 return false;
1963         minor = iminor(inode);
1964         pcm = snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_PLAYBACK);
1965         if (!pcm)
1966                 pcm = snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_CAPTURE);
1967         if (!pcm)
1968                 return false;
1969         snd_card_unref(pcm->card);
1970         return true;
1971 }
1972
1973 /*
1974  * PCM link handling
1975  */
1976 static int snd_pcm_link(struct snd_pcm_substream *substream, int fd)
1977 {
1978         int res = 0;
1979         struct snd_pcm_file *pcm_file;
1980         struct snd_pcm_substream *substream1;
1981         struct snd_pcm_group *group, *target_group;
1982         bool nonatomic = substream->pcm->nonatomic;
1983         struct fd f = fdget(fd);
1984
1985         if (!f.file)
1986                 return -EBADFD;
1987         if (!is_pcm_file(f.file)) {
1988                 res = -EBADFD;
1989                 goto _badf;
1990         }
1991         pcm_file = f.file->private_data;
1992         substream1 = pcm_file->substream;
1993         group = kzalloc(sizeof(*group), GFP_KERNEL);
1994         if (!group) {
1995                 res = -ENOMEM;
1996                 goto _nolock;
1997         }
1998         snd_pcm_group_init(group);
1999
2000         down_write(&snd_pcm_link_rwsem);
2001         if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN ||
2002             substream->runtime->status->state != substream1->runtime->status->state ||
2003             substream->pcm->nonatomic != substream1->pcm->nonatomic) {
2004                 res = -EBADFD;
2005                 goto _end;
2006         }
2007         if (snd_pcm_stream_linked(substream1)) {
2008                 res = -EALREADY;
2009                 goto _end;
2010         }
2011
2012         snd_pcm_stream_lock_irq(substream);
2013         if (!snd_pcm_stream_linked(substream)) {
2014                 snd_pcm_group_assign(substream, group);
2015                 group = NULL; /* assigned, don't free this one below */
2016         }
2017         target_group = substream->group;
2018         snd_pcm_stream_unlock_irq(substream);
2019
2020         snd_pcm_group_lock_irq(target_group, nonatomic);
2021         snd_pcm_stream_lock(substream1);
2022         snd_pcm_group_assign(substream1, target_group);
2023         refcount_inc(&target_group->refs);
2024         snd_pcm_stream_unlock(substream1);
2025         snd_pcm_group_unlock_irq(target_group, nonatomic);
2026  _end:
2027         up_write(&snd_pcm_link_rwsem);
2028  _nolock:
2029         kfree(group);
2030  _badf:
2031         fdput(f);
2032         return res;
2033 }
2034
2035 static void relink_to_local(struct snd_pcm_substream *substream)
2036 {
2037         snd_pcm_stream_lock(substream);
2038         snd_pcm_group_assign(substream, &substream->self_group);
2039         snd_pcm_stream_unlock(substream);
2040 }
2041
2042 static int snd_pcm_unlink(struct snd_pcm_substream *substream)
2043 {
2044         struct snd_pcm_group *group;
2045         bool nonatomic = substream->pcm->nonatomic;
2046         bool do_free = false;
2047         int res = 0;
2048
2049         down_write(&snd_pcm_link_rwsem);
2050
2051         if (!snd_pcm_stream_linked(substream)) {
2052                 res = -EALREADY;
2053                 goto _end;
2054         }
2055
2056         group = substream->group;
2057         snd_pcm_group_lock_irq(group, nonatomic);
2058
2059         relink_to_local(substream);
2060         refcount_dec(&group->refs);
2061
2062         /* detach the last stream, too */
2063         if (list_is_singular(&group->substreams)) {
2064                 relink_to_local(list_first_entry(&group->substreams,
2065                                                  struct snd_pcm_substream,
2066                                                  link_list));
2067                 do_free = refcount_dec_and_test(&group->refs);
2068         }
2069
2070         snd_pcm_group_unlock_irq(group, nonatomic);
2071         if (do_free)
2072                 kfree(group);
2073
2074        _end:
2075         up_write(&snd_pcm_link_rwsem);
2076         return res;
2077 }
2078
2079 /*
2080  * hw configurator
2081  */
2082 static int snd_pcm_hw_rule_mul(struct snd_pcm_hw_params *params,
2083                                struct snd_pcm_hw_rule *rule)
2084 {
2085         struct snd_interval t;
2086         snd_interval_mul(hw_param_interval_c(params, rule->deps[0]),
2087                      hw_param_interval_c(params, rule->deps[1]), &t);
2088         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2089 }
2090
2091 static int snd_pcm_hw_rule_div(struct snd_pcm_hw_params *params,
2092                                struct snd_pcm_hw_rule *rule)
2093 {
2094         struct snd_interval t;
2095         snd_interval_div(hw_param_interval_c(params, rule->deps[0]),
2096                      hw_param_interval_c(params, rule->deps[1]), &t);
2097         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2098 }
2099
2100 static int snd_pcm_hw_rule_muldivk(struct snd_pcm_hw_params *params,
2101                                    struct snd_pcm_hw_rule *rule)
2102 {
2103         struct snd_interval t;
2104         snd_interval_muldivk(hw_param_interval_c(params, rule->deps[0]),
2105                          hw_param_interval_c(params, rule->deps[1]),
2106                          (unsigned long) rule->private, &t);
2107         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2108 }
2109
2110 static int snd_pcm_hw_rule_mulkdiv(struct snd_pcm_hw_params *params,
2111                                    struct snd_pcm_hw_rule *rule)
2112 {
2113         struct snd_interval t;
2114         snd_interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]),
2115                          (unsigned long) rule->private,
2116                          hw_param_interval_c(params, rule->deps[1]), &t);
2117         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2118 }
2119
2120 static int snd_pcm_hw_rule_format(struct snd_pcm_hw_params *params,
2121                                   struct snd_pcm_hw_rule *rule)
2122 {
2123         unsigned int k;
2124         const struct snd_interval *i =
2125                                 hw_param_interval_c(params, rule->deps[0]);
2126         struct snd_mask m;
2127         struct snd_mask *mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
2128         snd_mask_any(&m);
2129         for (k = 0; k <= SNDRV_PCM_FORMAT_LAST; ++k) {
2130                 int bits;
2131                 if (! snd_mask_test(mask, k))
2132                         continue;
2133                 bits = snd_pcm_format_physical_width(k);
2134                 if (bits <= 0)
2135                         continue; /* ignore invalid formats */
2136                 if ((unsigned)bits < i->min || (unsigned)bits > i->max)
2137                         snd_mask_reset(&m, k);
2138         }
2139         return snd_mask_refine(mask, &m);
2140 }
2141
2142 static int snd_pcm_hw_rule_sample_bits(struct snd_pcm_hw_params *params,
2143                                        struct snd_pcm_hw_rule *rule)
2144 {
2145         struct snd_interval t;
2146         unsigned int k;
2147         t.min = UINT_MAX;
2148         t.max = 0;
2149         t.openmin = 0;
2150         t.openmax = 0;
2151         for (k = 0; k <= SNDRV_PCM_FORMAT_LAST; ++k) {
2152                 int bits;
2153                 if (! snd_mask_test(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), k))
2154                         continue;
2155                 bits = snd_pcm_format_physical_width(k);
2156                 if (bits <= 0)
2157                         continue; /* ignore invalid formats */
2158                 if (t.min > (unsigned)bits)
2159                         t.min = bits;
2160                 if (t.max < (unsigned)bits)
2161                         t.max = bits;
2162         }
2163         t.integer = 1;
2164         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2165 }
2166
2167 #if SNDRV_PCM_RATE_5512 != 1 << 0 || SNDRV_PCM_RATE_192000 != 1 << 12
2168 #error "Change this table"
2169 #endif
2170
2171 static const unsigned int rates[] = {
2172         5512, 8000, 11025, 16000, 22050, 32000, 44100,
2173         48000, 64000, 88200, 96000, 176400, 192000
2174 };
2175
2176 const struct snd_pcm_hw_constraint_list snd_pcm_known_rates = {
2177         .count = ARRAY_SIZE(rates),
2178         .list = rates,
2179 };
2180
2181 static int snd_pcm_hw_rule_rate(struct snd_pcm_hw_params *params,
2182                                 struct snd_pcm_hw_rule *rule)
2183 {
2184         struct snd_pcm_hardware *hw = rule->private;
2185         return snd_interval_list(hw_param_interval(params, rule->var),
2186                                  snd_pcm_known_rates.count,
2187                                  snd_pcm_known_rates.list, hw->rates);
2188 }               
2189
2190 static int snd_pcm_hw_rule_buffer_bytes_max(struct snd_pcm_hw_params *params,
2191                                             struct snd_pcm_hw_rule *rule)
2192 {
2193         struct snd_interval t;
2194         struct snd_pcm_substream *substream = rule->private;
2195         t.min = 0;
2196         t.max = substream->buffer_bytes_max;
2197         t.openmin = 0;
2198         t.openmax = 0;
2199         t.integer = 1;
2200         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2201 }               
2202
2203 int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream)
2204 {
2205         struct snd_pcm_runtime *runtime = substream->runtime;
2206         struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
2207         int k, err;
2208
2209         for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++) {
2210                 snd_mask_any(constrs_mask(constrs, k));
2211         }
2212
2213         for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++) {
2214                 snd_interval_any(constrs_interval(constrs, k));
2215         }
2216
2217         snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_CHANNELS));
2218         snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_BUFFER_SIZE));
2219         snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_BUFFER_BYTES));
2220         snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_SAMPLE_BITS));
2221         snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_FRAME_BITS));
2222
2223         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
2224                                    snd_pcm_hw_rule_format, NULL,
2225                                    SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
2226         if (err < 0)
2227                 return err;
2228         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 
2229                                   snd_pcm_hw_rule_sample_bits, NULL,
2230                                   SNDRV_PCM_HW_PARAM_FORMAT, 
2231                                   SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
2232         if (err < 0)
2233                 return err;
2234         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 
2235                                   snd_pcm_hw_rule_div, NULL,
2236                                   SNDRV_PCM_HW_PARAM_FRAME_BITS, SNDRV_PCM_HW_PARAM_CHANNELS, -1);
2237         if (err < 0)
2238                 return err;
2239         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 
2240                                   snd_pcm_hw_rule_mul, NULL,
2241                                   SNDRV_PCM_HW_PARAM_SAMPLE_BITS, SNDRV_PCM_HW_PARAM_CHANNELS, -1);
2242         if (err < 0)
2243                 return err;
2244         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 
2245                                   snd_pcm_hw_rule_mulkdiv, (void*) 8,
2246                                   SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);
2247         if (err < 0)
2248                 return err;
2249         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 
2250                                   snd_pcm_hw_rule_mulkdiv, (void*) 8,
2251                                   SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, -1);
2252         if (err < 0)
2253                 return err;
2254         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 
2255                                   snd_pcm_hw_rule_div, NULL,
2256                                   SNDRV_PCM_HW_PARAM_FRAME_BITS, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
2257         if (err < 0)
2258                 return err;
2259         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 
2260                                   snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
2261                                   SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_PERIOD_TIME, -1);
2262         if (err < 0)
2263                 return err;
2264         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 
2265                                   snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
2266                                   SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_BUFFER_TIME, -1);
2267         if (err < 0)
2268                 return err;
2269         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS, 
2270                                   snd_pcm_hw_rule_div, NULL,
2271                                   SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);
2272         if (err < 0)
2273                 return err;
2274         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 
2275                                   snd_pcm_hw_rule_div, NULL,
2276                                   SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_PERIODS, -1);
2277         if (err < 0)
2278                 return err;
2279         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 
2280                                   snd_pcm_hw_rule_mulkdiv, (void*) 8,
2281                                   SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
2282         if (err < 0)
2283                 return err;
2284         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 
2285                                   snd_pcm_hw_rule_muldivk, (void*) 1000000,
2286                                   SNDRV_PCM_HW_PARAM_PERIOD_TIME, SNDRV_PCM_HW_PARAM_RATE, -1);
2287         if (err < 0)
2288                 return err;
2289         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 
2290                                   snd_pcm_hw_rule_mul, NULL,
2291                                   SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_PERIODS, -1);
2292         if (err < 0)
2293                 return err;
2294         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 
2295                                   snd_pcm_hw_rule_mulkdiv, (void*) 8,
2296                                   SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
2297         if (err < 0)
2298                 return err;
2299         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 
2300                                   snd_pcm_hw_rule_muldivk, (void*) 1000000,
2301                                   SNDRV_PCM_HW_PARAM_BUFFER_TIME, SNDRV_PCM_HW_PARAM_RATE, -1);
2302         if (err < 0)
2303                 return err;
2304         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 
2305                                   snd_pcm_hw_rule_muldivk, (void*) 8,
2306                                   SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
2307         if (err < 0)
2308                 return err;
2309         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 
2310                                   snd_pcm_hw_rule_muldivk, (void*) 8,
2311                                   SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
2312         if (err < 0)
2313                 return err;
2314         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 
2315                                   snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
2316                                   SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_RATE, -1);
2317         if (err < 0)
2318                 return err;
2319         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_TIME, 
2320                                   snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
2321                                   SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_RATE, -1);
2322         if (err < 0)
2323                 return err;
2324         return 0;
2325 }
2326
2327 int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
2328 {
2329         struct snd_pcm_runtime *runtime = substream->runtime;
2330         struct snd_pcm_hardware *hw = &runtime->hw;
2331         int err;
2332         unsigned int mask = 0;
2333
2334         if (hw->info & SNDRV_PCM_INFO_INTERLEAVED)
2335                 mask |= 1 << SNDRV_PCM_ACCESS_RW_INTERLEAVED;
2336         if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED)
2337                 mask |= 1 << SNDRV_PCM_ACCESS_RW_NONINTERLEAVED;
2338         if (hw_support_mmap(substream)) {
2339                 if (hw->info & SNDRV_PCM_INFO_INTERLEAVED)
2340                         mask |= 1 << SNDRV_PCM_ACCESS_MMAP_INTERLEAVED;
2341                 if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED)
2342                         mask |= 1 << SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED;
2343                 if (hw->info & SNDRV_PCM_INFO_COMPLEX)
2344                         mask |= 1 << SNDRV_PCM_ACCESS_MMAP_COMPLEX;
2345         }
2346         err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_ACCESS, mask);
2347         if (err < 0)
2348                 return err;
2349
2350         err = snd_pcm_hw_constraint_mask64(runtime, SNDRV_PCM_HW_PARAM_FORMAT, hw->formats);
2351         if (err < 0)
2352                 return err;
2353
2354         err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_SUBFORMAT, 1 << SNDRV_PCM_SUBFORMAT_STD);
2355         if (err < 0)
2356                 return err;
2357
2358         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_CHANNELS,
2359                                            hw->channels_min, hw->channels_max);
2360         if (err < 0)
2361                 return err;
2362
2363         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_RATE,
2364                                            hw->rate_min, hw->rate_max);
2365         if (err < 0)
2366                 return err;
2367
2368         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
2369                                            hw->period_bytes_min, hw->period_bytes_max);
2370         if (err < 0)
2371                 return err;
2372
2373         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIODS,
2374                                            hw->periods_min, hw->periods_max);
2375         if (err < 0)
2376                 return err;
2377
2378         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
2379                                            hw->period_bytes_min, hw->buffer_bytes_max);
2380         if (err < 0)
2381                 return err;
2382
2383         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 
2384                                   snd_pcm_hw_rule_buffer_bytes_max, substream,
2385                                   SNDRV_PCM_HW_PARAM_BUFFER_BYTES, -1);
2386         if (err < 0)
2387                 return err;
2388
2389         /* FIXME: remove */
2390         if (runtime->dma_bytes) {
2391                 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, runtime->dma_bytes);
2392                 if (err < 0)
2393                         return err;
2394         }
2395
2396         if (!(hw->rates & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))) {
2397                 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 
2398                                           snd_pcm_hw_rule_rate, hw,
2399                                           SNDRV_PCM_HW_PARAM_RATE, -1);
2400                 if (err < 0)
2401                         return err;
2402         }
2403
2404         /* FIXME: this belong to lowlevel */
2405         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
2406
2407         return 0;
2408 }
2409
2410 static void pcm_release_private(struct snd_pcm_substream *substream)
2411 {
2412         if (snd_pcm_stream_linked(substream))
2413                 snd_pcm_unlink(substream);
2414 }
2415
2416 void snd_pcm_release_substream(struct snd_pcm_substream *substream)
2417 {
2418         substream->ref_count--;
2419         if (substream->ref_count > 0)
2420                 return;
2421
2422         snd_pcm_drop(substream);
2423         if (substream->hw_opened) {
2424                 if (substream->ops->hw_free &&
2425                     substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
2426                         substream->ops->hw_free(substream);
2427                 substream->ops->close(substream);
2428                 substream->hw_opened = 0;
2429         }
2430         if (pm_qos_request_active(&substream->latency_pm_qos_req))
2431                 pm_qos_remove_request(&substream->latency_pm_qos_req);
2432         if (substream->pcm_release) {
2433                 substream->pcm_release(substream);
2434                 substream->pcm_release = NULL;
2435         }
2436         snd_pcm_detach_substream(substream);
2437 }
2438 EXPORT_SYMBOL(snd_pcm_release_substream);
2439
2440 int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
2441                            struct file *file,
2442                            struct snd_pcm_substream **rsubstream)
2443 {
2444         struct snd_pcm_substream *substream;
2445         int err;
2446
2447         err = snd_pcm_attach_substream(pcm, stream, file, &substream);
2448         if (err < 0)
2449                 return err;
2450         if (substream->ref_count > 1) {
2451                 *rsubstream = substream;
2452                 return 0;
2453         }
2454
2455         err = snd_pcm_hw_constraints_init(substream);
2456         if (err < 0) {
2457                 pcm_dbg(pcm, "snd_pcm_hw_constraints_init failed\n");
2458                 goto error;
2459         }
2460
2461         if ((err = substream->ops->open(substream)) < 0)
2462                 goto error;
2463
2464         substream->hw_opened = 1;
2465
2466         err = snd_pcm_hw_constraints_complete(substream);
2467         if (err < 0) {
2468                 pcm_dbg(pcm, "snd_pcm_hw_constraints_complete failed\n");
2469                 goto error;
2470         }
2471
2472         *rsubstream = substream;
2473         return 0;
2474
2475  error:
2476         snd_pcm_release_substream(substream);
2477         return err;
2478 }
2479 EXPORT_SYMBOL(snd_pcm_open_substream);
2480
2481 static int snd_pcm_open_file(struct file *file,
2482                              struct snd_pcm *pcm,
2483                              int stream)
2484 {
2485         struct snd_pcm_file *pcm_file;
2486         struct snd_pcm_substream *substream;
2487         int err;
2488
2489         err = snd_pcm_open_substream(pcm, stream, file, &substream);
2490         if (err < 0)
2491                 return err;
2492
2493         pcm_file = kzalloc(sizeof(*pcm_file), GFP_KERNEL);
2494         if (pcm_file == NULL) {
2495                 snd_pcm_release_substream(substream);
2496                 return -ENOMEM;
2497         }
2498         pcm_file->substream = substream;
2499         if (substream->ref_count == 1)
2500                 substream->pcm_release = pcm_release_private;
2501         file->private_data = pcm_file;
2502
2503         return 0;
2504 }
2505
2506 static int snd_pcm_playback_open(struct inode *inode, struct file *file)
2507 {
2508         struct snd_pcm *pcm;
2509         int err = nonseekable_open(inode, file);
2510         if (err < 0)
2511                 return err;
2512         pcm = snd_lookup_minor_data(iminor(inode),
2513                                     SNDRV_DEVICE_TYPE_PCM_PLAYBACK);
2514         err = snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_PLAYBACK);
2515         if (pcm)
2516                 snd_card_unref(pcm->card);
2517         return err;
2518 }
2519
2520 static int snd_pcm_capture_open(struct inode *inode, struct file *file)
2521 {
2522         struct snd_pcm *pcm;
2523         int err = nonseekable_open(inode, file);
2524         if (err < 0)
2525                 return err;
2526         pcm = snd_lookup_minor_data(iminor(inode),
2527                                     SNDRV_DEVICE_TYPE_PCM_CAPTURE);
2528         err = snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_CAPTURE);
2529         if (pcm)
2530                 snd_card_unref(pcm->card);
2531         return err;
2532 }
2533
2534 static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream)
2535 {
2536         int err;
2537         wait_queue_entry_t wait;
2538
2539         if (pcm == NULL) {
2540                 err = -ENODEV;
2541                 goto __error1;
2542         }
2543         err = snd_card_file_add(pcm->card, file);
2544         if (err < 0)
2545                 goto __error1;
2546         if (!try_module_get(pcm->card->module)) {
2547                 err = -EFAULT;
2548                 goto __error2;
2549         }
2550         init_waitqueue_entry(&wait, current);
2551         add_wait_queue(&pcm->open_wait, &wait);
2552         mutex_lock(&pcm->open_mutex);
2553         while (1) {
2554                 err = snd_pcm_open_file(file, pcm, stream);
2555                 if (err >= 0)
2556                         break;
2557                 if (err == -EAGAIN) {
2558                         if (file->f_flags & O_NONBLOCK) {
2559                                 err = -EBUSY;
2560                                 break;
2561                         }
2562                 } else
2563                         break;
2564                 set_current_state(TASK_INTERRUPTIBLE);
2565                 mutex_unlock(&pcm->open_mutex);
2566                 schedule();
2567                 mutex_lock(&pcm->open_mutex);
2568                 if (pcm->card->shutdown) {
2569                         err = -ENODEV;
2570                         break;
2571                 }
2572                 if (signal_pending(current)) {
2573                         err = -ERESTARTSYS;
2574                         break;
2575                 }
2576         }
2577         remove_wait_queue(&pcm->open_wait, &wait);
2578         mutex_unlock(&pcm->open_mutex);
2579         if (err < 0)
2580                 goto __error;
2581         return err;
2582
2583       __error:
2584         module_put(pcm->card->module);
2585       __error2:
2586         snd_card_file_remove(pcm->card, file);
2587       __error1:
2588         return err;
2589 }
2590
2591 static int snd_pcm_release(struct inode *inode, struct file *file)
2592 {
2593         struct snd_pcm *pcm;
2594         struct snd_pcm_substream *substream;
2595         struct snd_pcm_file *pcm_file;
2596
2597         pcm_file = file->private_data;
2598         substream = pcm_file->substream;
2599         if (snd_BUG_ON(!substream))
2600                 return -ENXIO;
2601         pcm = substream->pcm;
2602         mutex_lock(&pcm->open_mutex);
2603         snd_pcm_release_substream(substream);
2604         kfree(pcm_file);
2605         mutex_unlock(&pcm->open_mutex);
2606         wake_up(&pcm->open_wait);
2607         module_put(pcm->card->module);
2608         snd_card_file_remove(pcm->card, file);
2609         return 0;
2610 }
2611
2612 /* check and update PCM state; return 0 or a negative error
2613  * call this inside PCM lock
2614  */
2615 static int do_pcm_hwsync(struct snd_pcm_substream *substream)
2616 {
2617         switch (substream->runtime->status->state) {
2618         case SNDRV_PCM_STATE_DRAINING:
2619                 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
2620                         return -EBADFD;
2621                 /* Fall through */
2622         case SNDRV_PCM_STATE_RUNNING:
2623                 return snd_pcm_update_hw_ptr(substream);
2624         case SNDRV_PCM_STATE_PREPARED:
2625         case SNDRV_PCM_STATE_PAUSED:
2626                 return 0;
2627         case SNDRV_PCM_STATE_SUSPENDED:
2628                 return -ESTRPIPE;
2629         case SNDRV_PCM_STATE_XRUN:
2630                 return -EPIPE;
2631         default:
2632                 return -EBADFD;
2633         }
2634 }
2635
2636 /* increase the appl_ptr; returns the processed frames or a negative error */
2637 static snd_pcm_sframes_t forward_appl_ptr(struct snd_pcm_substream *substream,
2638                                           snd_pcm_uframes_t frames,
2639                                            snd_pcm_sframes_t avail)
2640 {
2641         struct snd_pcm_runtime *runtime = substream->runtime;
2642         snd_pcm_sframes_t appl_ptr;
2643         int ret;
2644
2645         if (avail <= 0)
2646                 return 0;
2647         if (frames > (snd_pcm_uframes_t)avail)
2648                 frames = avail;
2649         appl_ptr = runtime->control->appl_ptr + frames;
2650         if (appl_ptr >= (snd_pcm_sframes_t)runtime->boundary)
2651                 appl_ptr -= runtime->boundary;
2652         ret = pcm_lib_apply_appl_ptr(substream, appl_ptr);
2653         return ret < 0 ? ret : frames;
2654 }
2655
2656 /* decrease the appl_ptr; returns the processed frames or zero for error */
2657 static snd_pcm_sframes_t rewind_appl_ptr(struct snd_pcm_substream *substream,
2658                                          snd_pcm_uframes_t frames,
2659                                          snd_pcm_sframes_t avail)
2660 {
2661         struct snd_pcm_runtime *runtime = substream->runtime;
2662         snd_pcm_sframes_t appl_ptr;
2663         int ret;
2664
2665         if (avail <= 0)
2666                 return 0;
2667         if (frames > (snd_pcm_uframes_t)avail)
2668                 frames = avail;
2669         appl_ptr = runtime->control->appl_ptr - frames;
2670         if (appl_ptr < 0)
2671                 appl_ptr += runtime->boundary;
2672         ret = pcm_lib_apply_appl_ptr(substream, appl_ptr);
2673         /* NOTE: we return zero for errors because PulseAudio gets depressed
2674          * upon receiving an error from rewind ioctl and stops processing
2675          * any longer.  Returning zero means that no rewind is done, so
2676          * it's not absolutely wrong to answer like that.
2677          */
2678         return ret < 0 ? 0 : frames;
2679 }
2680
2681 static snd_pcm_sframes_t snd_pcm_rewind(struct snd_pcm_substream *substream,
2682                                         snd_pcm_uframes_t frames)
2683 {
2684         snd_pcm_sframes_t ret;
2685
2686         if (frames == 0)
2687                 return 0;
2688
2689         snd_pcm_stream_lock_irq(substream);
2690         ret = do_pcm_hwsync(substream);
2691         if (!ret)
2692                 ret = rewind_appl_ptr(substream, frames,
2693                                       snd_pcm_hw_avail(substream));
2694         snd_pcm_stream_unlock_irq(substream);
2695         return ret;
2696 }
2697
2698 static snd_pcm_sframes_t snd_pcm_forward(struct snd_pcm_substream *substream,
2699                                          snd_pcm_uframes_t frames)
2700 {
2701         snd_pcm_sframes_t ret;
2702
2703         if (frames == 0)
2704                 return 0;
2705
2706         snd_pcm_stream_lock_irq(substream);
2707         ret = do_pcm_hwsync(substream);
2708         if (!ret)
2709                 ret = forward_appl_ptr(substream, frames,
2710                                        snd_pcm_avail(substream));
2711         snd_pcm_stream_unlock_irq(substream);
2712         return ret;
2713 }
2714
2715 static int snd_pcm_hwsync(struct snd_pcm_substream *substream)
2716 {
2717         int err;
2718
2719         snd_pcm_stream_lock_irq(substream);
2720         err = do_pcm_hwsync(substream);
2721         snd_pcm_stream_unlock_irq(substream);
2722         return err;
2723 }
2724                 
2725 static int snd_pcm_delay(struct snd_pcm_substream *substream,
2726                          snd_pcm_sframes_t *delay)
2727 {
2728         int err;
2729         snd_pcm_sframes_t n = 0;
2730
2731         snd_pcm_stream_lock_irq(substream);
2732         err = do_pcm_hwsync(substream);
2733         if (!err)
2734                 n = snd_pcm_calc_delay(substream);
2735         snd_pcm_stream_unlock_irq(substream);
2736         if (!err)
2737                 *delay = n;
2738         return err;
2739 }
2740                 
2741 static int snd_pcm_sync_ptr(struct snd_pcm_substream *substream,
2742                             struct snd_pcm_sync_ptr __user *_sync_ptr)
2743 {
2744         struct snd_pcm_runtime *runtime = substream->runtime;
2745         struct snd_pcm_sync_ptr sync_ptr;
2746         volatile struct snd_pcm_mmap_status *status;
2747         volatile struct snd_pcm_mmap_control *control;
2748         int err;
2749
2750         memset(&sync_ptr, 0, sizeof(sync_ptr));
2751         if (get_user(sync_ptr.flags, (unsigned __user *)&(_sync_ptr->flags)))
2752                 return -EFAULT;
2753         if (copy_from_user(&sync_ptr.c.control, &(_sync_ptr->c.control), sizeof(struct snd_pcm_mmap_control)))
2754                 return -EFAULT; 
2755         status = runtime->status;
2756         control = runtime->control;
2757         if (sync_ptr.flags & SNDRV_PCM_SYNC_PTR_HWSYNC) {
2758                 err = snd_pcm_hwsync(substream);
2759                 if (err < 0)
2760                         return err;
2761         }
2762         snd_pcm_stream_lock_irq(substream);
2763         if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_APPL)) {
2764                 err = pcm_lib_apply_appl_ptr(substream,
2765                                              sync_ptr.c.control.appl_ptr);
2766                 if (err < 0) {
2767                         snd_pcm_stream_unlock_irq(substream);
2768                         return err;
2769                 }
2770         } else {
2771                 sync_ptr.c.control.appl_ptr = control->appl_ptr;
2772         }
2773         if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN))
2774                 control->avail_min = sync_ptr.c.control.avail_min;
2775         else
2776                 sync_ptr.c.control.avail_min = control->avail_min;
2777         sync_ptr.s.status.state = status->state;
2778         sync_ptr.s.status.hw_ptr = status->hw_ptr;
2779         sync_ptr.s.status.tstamp = status->tstamp;
2780         sync_ptr.s.status.suspended_state = status->suspended_state;
2781         sync_ptr.s.status.audio_tstamp = status->audio_tstamp;
2782         snd_pcm_stream_unlock_irq(substream);
2783         if (copy_to_user(_sync_ptr, &sync_ptr, sizeof(sync_ptr)))
2784                 return -EFAULT;
2785         return 0;
2786 }
2787
2788 static int snd_pcm_tstamp(struct snd_pcm_substream *substream, int __user *_arg)
2789 {
2790         struct snd_pcm_runtime *runtime = substream->runtime;
2791         int arg;
2792         
2793         if (get_user(arg, _arg))
2794                 return -EFAULT;
2795         if (arg < 0 || arg > SNDRV_PCM_TSTAMP_TYPE_LAST)
2796                 return -EINVAL;
2797         runtime->tstamp_type = arg;
2798         return 0;
2799 }
2800
2801 static int snd_pcm_xferi_frames_ioctl(struct snd_pcm_substream *substream,
2802                                       struct snd_xferi __user *_xferi)
2803 {
2804         struct snd_xferi xferi;
2805         struct snd_pcm_runtime *runtime = substream->runtime;
2806         snd_pcm_sframes_t result;
2807
2808         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2809                 return -EBADFD;
2810         if (put_user(0, &_xferi->result))
2811                 return -EFAULT;
2812         if (copy_from_user(&xferi, _xferi, sizeof(xferi)))
2813                 return -EFAULT;
2814         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
2815                 result = snd_pcm_lib_write(substream, xferi.buf, xferi.frames);
2816         else
2817                 result = snd_pcm_lib_read(substream, xferi.buf, xferi.frames);
2818         __put_user(result, &_xferi->result);
2819         return result < 0 ? result : 0;
2820 }
2821
2822 static int snd_pcm_xfern_frames_ioctl(struct snd_pcm_substream *substream,
2823                                       struct snd_xfern __user *_xfern)
2824 {
2825         struct snd_xfern xfern;
2826         struct snd_pcm_runtime *runtime = substream->runtime;
2827         void *bufs;
2828         snd_pcm_sframes_t result;
2829
2830         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2831                 return -EBADFD;
2832         if (runtime->channels > 128)
2833                 return -EINVAL;
2834         if (put_user(0, &_xfern->result))
2835                 return -EFAULT;
2836         if (copy_from_user(&xfern, _xfern, sizeof(xfern)))
2837                 return -EFAULT;
2838
2839         bufs = memdup_user(xfern.bufs, sizeof(void *) * runtime->channels);
2840         if (IS_ERR(bufs))
2841                 return PTR_ERR(bufs);
2842         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
2843                 result = snd_pcm_lib_writev(substream, bufs, xfern.frames);
2844         else
2845                 result = snd_pcm_lib_readv(substream, bufs, xfern.frames);
2846         kfree(bufs);
2847         __put_user(result, &_xfern->result);
2848         return result < 0 ? result : 0;
2849 }
2850
2851 static int snd_pcm_rewind_ioctl(struct snd_pcm_substream *substream,
2852                                 snd_pcm_uframes_t __user *_frames)
2853 {
2854         snd_pcm_uframes_t frames;
2855         snd_pcm_sframes_t result;
2856
2857         if (get_user(frames, _frames))
2858                 return -EFAULT;
2859         if (put_user(0, _frames))
2860                 return -EFAULT;
2861         result = snd_pcm_rewind(substream, frames);
2862         __put_user(result, _frames);
2863         return result < 0 ? result : 0;
2864 }
2865
2866 static int snd_pcm_forward_ioctl(struct snd_pcm_substream *substream,
2867                                  snd_pcm_uframes_t __user *_frames)
2868 {
2869         snd_pcm_uframes_t frames;
2870         snd_pcm_sframes_t result;
2871
2872         if (get_user(frames, _frames))
2873                 return -EFAULT;
2874         if (put_user(0, _frames))
2875                 return -EFAULT;
2876         result = snd_pcm_forward(substream, frames);
2877         __put_user(result, _frames);
2878         return result < 0 ? result : 0;
2879 }
2880
2881 static int snd_pcm_common_ioctl(struct file *file,
2882                                  struct snd_pcm_substream *substream,
2883                                  unsigned int cmd, void __user *arg)
2884 {
2885         struct snd_pcm_file *pcm_file = file->private_data;
2886         int res;
2887
2888         if (PCM_RUNTIME_CHECK(substream))
2889                 return -ENXIO;
2890
2891         res = snd_power_wait(substream->pcm->card, SNDRV_CTL_POWER_D0);
2892         if (res < 0)
2893                 return res;
2894
2895         switch (cmd) {
2896         case SNDRV_PCM_IOCTL_PVERSION:
2897                 return put_user(SNDRV_PCM_VERSION, (int __user *)arg) ? -EFAULT : 0;
2898         case SNDRV_PCM_IOCTL_INFO:
2899                 return snd_pcm_info_user(substream, arg);
2900         case SNDRV_PCM_IOCTL_TSTAMP:    /* just for compatibility */
2901                 return 0;
2902         case SNDRV_PCM_IOCTL_TTSTAMP:
2903                 return snd_pcm_tstamp(substream, arg);
2904         case SNDRV_PCM_IOCTL_USER_PVERSION:
2905                 if (get_user(pcm_file->user_pversion,
2906                              (unsigned int __user *)arg))
2907                         return -EFAULT;
2908                 return 0;
2909         case SNDRV_PCM_IOCTL_HW_REFINE:
2910                 return snd_pcm_hw_refine_user(substream, arg);
2911         case SNDRV_PCM_IOCTL_HW_PARAMS:
2912                 return snd_pcm_hw_params_user(substream, arg);
2913         case SNDRV_PCM_IOCTL_HW_FREE:
2914                 return snd_pcm_hw_free(substream);
2915         case SNDRV_PCM_IOCTL_SW_PARAMS:
2916                 return snd_pcm_sw_params_user(substream, arg);
2917         case SNDRV_PCM_IOCTL_STATUS:
2918                 return snd_pcm_status_user(substream, arg, false);
2919         case SNDRV_PCM_IOCTL_STATUS_EXT:
2920                 return snd_pcm_status_user(substream, arg, true);
2921         case SNDRV_PCM_IOCTL_CHANNEL_INFO:
2922                 return snd_pcm_channel_info_user(substream, arg);
2923         case SNDRV_PCM_IOCTL_PREPARE:
2924                 return snd_pcm_prepare(substream, file);
2925         case SNDRV_PCM_IOCTL_RESET:
2926                 return snd_pcm_reset(substream);
2927         case SNDRV_PCM_IOCTL_START:
2928                 return snd_pcm_start_lock_irq(substream);
2929         case SNDRV_PCM_IOCTL_LINK:
2930                 return snd_pcm_link(substream, (int)(unsigned long) arg);
2931         case SNDRV_PCM_IOCTL_UNLINK:
2932                 return snd_pcm_unlink(substream);
2933         case SNDRV_PCM_IOCTL_RESUME:
2934                 return snd_pcm_resume(substream);
2935         case SNDRV_PCM_IOCTL_XRUN:
2936                 return snd_pcm_xrun(substream);
2937         case SNDRV_PCM_IOCTL_HWSYNC:
2938                 return snd_pcm_hwsync(substream);
2939         case SNDRV_PCM_IOCTL_DELAY:
2940         {
2941                 snd_pcm_sframes_t delay;
2942                 snd_pcm_sframes_t __user *res = arg;
2943                 int err;
2944
2945                 err = snd_pcm_delay(substream, &delay);
2946                 if (err)
2947                         return err;
2948                 if (put_user(delay, res))
2949                         return -EFAULT;
2950                 return 0;
2951         }
2952         case SNDRV_PCM_IOCTL_SYNC_PTR:
2953                 return snd_pcm_sync_ptr(substream, arg);
2954 #ifdef CONFIG_SND_SUPPORT_OLD_API
2955         case SNDRV_PCM_IOCTL_HW_REFINE_OLD:
2956                 return snd_pcm_hw_refine_old_user(substream, arg);
2957         case SNDRV_PCM_IOCTL_HW_PARAMS_OLD:
2958                 return snd_pcm_hw_params_old_user(substream, arg);
2959 #endif
2960         case SNDRV_PCM_IOCTL_DRAIN:
2961                 return snd_pcm_drain(substream, file);
2962         case SNDRV_PCM_IOCTL_DROP:
2963                 return snd_pcm_drop(substream);
2964         case SNDRV_PCM_IOCTL_PAUSE:
2965                 return snd_pcm_action_lock_irq(&snd_pcm_action_pause,
2966                                                substream,
2967                                                (int)(unsigned long)arg);
2968         case SNDRV_PCM_IOCTL_WRITEI_FRAMES:
2969         case SNDRV_PCM_IOCTL_READI_FRAMES:
2970                 return snd_pcm_xferi_frames_ioctl(substream, arg);
2971         case SNDRV_PCM_IOCTL_WRITEN_FRAMES:
2972         case SNDRV_PCM_IOCTL_READN_FRAMES:
2973                 return snd_pcm_xfern_frames_ioctl(substream, arg);
2974         case SNDRV_PCM_IOCTL_REWIND:
2975                 return snd_pcm_rewind_ioctl(substream, arg);
2976         case SNDRV_PCM_IOCTL_FORWARD:
2977                 return snd_pcm_forward_ioctl(substream, arg);
2978         }
2979         pcm_dbg(substream->pcm, "unknown ioctl = 0x%x\n", cmd);
2980         return -ENOTTY;
2981 }
2982
2983 static long snd_pcm_ioctl(struct file *file, unsigned int cmd,
2984                           unsigned long arg)
2985 {
2986         struct snd_pcm_file *pcm_file;
2987
2988         pcm_file = file->private_data;
2989
2990         if (((cmd >> 8) & 0xff) != 'A')
2991                 return -ENOTTY;
2992
2993         return snd_pcm_common_ioctl(file, pcm_file->substream, cmd,
2994                                      (void __user *)arg);
2995 }
2996
2997 /**
2998  * snd_pcm_kernel_ioctl - Execute PCM ioctl in the kernel-space
2999  * @substream: PCM substream
3000  * @cmd: IOCTL cmd
3001  * @arg: IOCTL argument
3002  *
3003  * The function is provided primarily for OSS layer and USB gadget drivers,
3004  * and it allows only the limited set of ioctls (hw_params, sw_params,
3005  * prepare, start, drain, drop, forward).
3006  */
3007 int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream,
3008                          unsigned int cmd, void *arg)
3009 {
3010         snd_pcm_uframes_t *frames = arg;
3011         snd_pcm_sframes_t result;
3012         
3013         switch (cmd) {
3014         case SNDRV_PCM_IOCTL_FORWARD:
3015         {
3016                 /* provided only for OSS; capture-only and no value returned */
3017                 if (substream->stream != SNDRV_PCM_STREAM_CAPTURE)
3018                         return -EINVAL;
3019                 result = snd_pcm_forward(substream, *frames);
3020                 return result < 0 ? result : 0;
3021         }
3022         case SNDRV_PCM_IOCTL_HW_PARAMS:
3023                 return snd_pcm_hw_params(substream, arg);
3024         case SNDRV_PCM_IOCTL_SW_PARAMS:
3025                 return snd_pcm_sw_params(substream, arg);
3026         case SNDRV_PCM_IOCTL_PREPARE:
3027                 return snd_pcm_prepare(substream, NULL);
3028         case SNDRV_PCM_IOCTL_START:
3029                 return snd_pcm_start_lock_irq(substream);
3030         case SNDRV_PCM_IOCTL_DRAIN:
3031                 return snd_pcm_drain(substream, NULL);
3032         case SNDRV_PCM_IOCTL_DROP:
3033                 return snd_pcm_drop(substream);
3034         case SNDRV_PCM_IOCTL_DELAY:
3035                 return snd_pcm_delay(substream, frames);
3036         default:
3037                 return -EINVAL;
3038         }
3039 }
3040 EXPORT_SYMBOL(snd_pcm_kernel_ioctl);
3041
3042 static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count,
3043                             loff_t * offset)
3044 {
3045         struct snd_pcm_file *pcm_file;
3046         struct snd_pcm_substream *substream;
3047         struct snd_pcm_runtime *runtime;
3048         snd_pcm_sframes_t result;
3049
3050         pcm_file = file->private_data;
3051         substream = pcm_file->substream;
3052         if (PCM_RUNTIME_CHECK(substream))
3053                 return -ENXIO;
3054         runtime = substream->runtime;
3055         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3056                 return -EBADFD;
3057         if (!frame_aligned(runtime, count))
3058                 return -EINVAL;
3059         count = bytes_to_frames(runtime, count);
3060         result = snd_pcm_lib_read(substream, buf, count);
3061         if (result > 0)
3062                 result = frames_to_bytes(runtime, result);
3063         return result;
3064 }
3065
3066 static ssize_t snd_pcm_write(struct file *file, const char __user *buf,
3067                              size_t count, loff_t * offset)
3068 {
3069         struct snd_pcm_file *pcm_file;
3070         struct snd_pcm_substream *substream;
3071         struct snd_pcm_runtime *runtime;
3072         snd_pcm_sframes_t result;
3073
3074         pcm_file = file->private_data;
3075         substream = pcm_file->substream;
3076         if (PCM_RUNTIME_CHECK(substream))
3077                 return -ENXIO;
3078         runtime = substream->runtime;
3079         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3080                 return -EBADFD;
3081         if (!frame_aligned(runtime, count))
3082                 return -EINVAL;
3083         count = bytes_to_frames(runtime, count);
3084         result = snd_pcm_lib_write(substream, buf, count);
3085         if (result > 0)
3086                 result = frames_to_bytes(runtime, result);
3087         return result;
3088 }
3089
3090 static ssize_t snd_pcm_readv(struct kiocb *iocb, struct iov_iter *to)
3091 {
3092         struct snd_pcm_file *pcm_file;
3093         struct snd_pcm_substream *substream;
3094         struct snd_pcm_runtime *runtime;
3095         snd_pcm_sframes_t result;
3096         unsigned long i;
3097         void __user **bufs;
3098         snd_pcm_uframes_t frames;
3099
3100         pcm_file = iocb->ki_filp->private_data;
3101         substream = pcm_file->substream;
3102         if (PCM_RUNTIME_CHECK(substream))
3103                 return -ENXIO;
3104         runtime = substream->runtime;
3105         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3106                 return -EBADFD;
3107         if (!iter_is_iovec(to))
3108                 return -EINVAL;
3109         if (to->nr_segs > 1024 || to->nr_segs != runtime->channels)
3110                 return -EINVAL;
3111         if (!frame_aligned(runtime, to->iov->iov_len))
3112                 return -EINVAL;
3113         frames = bytes_to_samples(runtime, to->iov->iov_len);
3114         bufs = kmalloc_array(to->nr_segs, sizeof(void *), GFP_KERNEL);
3115         if (bufs == NULL)
3116                 return -ENOMEM;
3117         for (i = 0; i < to->nr_segs; ++i)
3118                 bufs[i] = to->iov[i].iov_base;
3119         result = snd_pcm_lib_readv(substream, bufs, frames);
3120         if (result > 0)
3121                 result = frames_to_bytes(runtime, result);
3122         kfree(bufs);
3123         return result;
3124 }
3125
3126 static ssize_t snd_pcm_writev(struct kiocb *iocb, struct iov_iter *from)
3127 {
3128         struct snd_pcm_file *pcm_file;
3129         struct snd_pcm_substream *substream;
3130         struct snd_pcm_runtime *runtime;
3131         snd_pcm_sframes_t result;
3132         unsigned long i;
3133         void __user **bufs;
3134         snd_pcm_uframes_t frames;
3135
3136         pcm_file = iocb->ki_filp->private_data;
3137         substream = pcm_file->substream;
3138         if (PCM_RUNTIME_CHECK(substream))
3139                 return -ENXIO;
3140         runtime = substream->runtime;
3141         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3142                 return -EBADFD;
3143         if (!iter_is_iovec(from))
3144                 return -EINVAL;
3145         if (from->nr_segs > 128 || from->nr_segs != runtime->channels ||
3146             !frame_aligned(runtime, from->iov->iov_len))
3147                 return -EINVAL;
3148         frames = bytes_to_samples(runtime, from->iov->iov_len);
3149         bufs = kmalloc_array(from->nr_segs, sizeof(void *), GFP_KERNEL);
3150         if (bufs == NULL)
3151                 return -ENOMEM;
3152         for (i = 0; i < from->nr_segs; ++i)
3153                 bufs[i] = from->iov[i].iov_base;
3154         result = snd_pcm_lib_writev(substream, bufs, frames);
3155         if (result > 0)
3156                 result = frames_to_bytes(runtime, result);
3157         kfree(bufs);
3158         return result;
3159 }
3160
3161 static __poll_t snd_pcm_poll(struct file *file, poll_table *wait)
3162 {
3163         struct snd_pcm_file *pcm_file;
3164         struct snd_pcm_substream *substream;
3165         struct snd_pcm_runtime *runtime;
3166         __poll_t mask, ok;
3167         snd_pcm_uframes_t avail;
3168
3169         pcm_file = file->private_data;
3170
3171         substream = pcm_file->substream;
3172         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
3173                 ok = EPOLLOUT | EPOLLWRNORM;
3174         else
3175                 ok = EPOLLIN | EPOLLRDNORM;
3176         if (PCM_RUNTIME_CHECK(substream))
3177                 return ok | EPOLLERR;
3178
3179         runtime = substream->runtime;
3180         poll_wait(file, &runtime->sleep, wait);
3181
3182         mask = 0;
3183         snd_pcm_stream_lock_irq(substream);
3184         avail = snd_pcm_avail(substream);
3185         switch (runtime->status->state) {
3186         case SNDRV_PCM_STATE_RUNNING:
3187         case SNDRV_PCM_STATE_PREPARED:
3188         case SNDRV_PCM_STATE_PAUSED:
3189                 if (avail >= runtime->control->avail_min)
3190                         mask = ok;
3191                 break;
3192         case SNDRV_PCM_STATE_DRAINING:
3193                 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
3194                         mask = ok;
3195                         if (!avail)
3196                                 mask |= EPOLLERR;
3197                 }
3198                 break;
3199         default:
3200                 mask = ok | EPOLLERR;
3201                 break;
3202         }
3203         snd_pcm_stream_unlock_irq(substream);
3204         return mask;
3205 }
3206
3207 /*
3208  * mmap support
3209  */
3210
3211 /*
3212  * Only on coherent architectures, we can mmap the status and the control records
3213  * for effcient data transfer.  On others, we have to use HWSYNC ioctl...
3214  */
3215 #if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA)
3216 /*
3217  * mmap status record
3218  */
3219 static vm_fault_t snd_pcm_mmap_status_fault(struct vm_fault *vmf)
3220 {
3221         struct snd_pcm_substream *substream = vmf->vma->vm_private_data;
3222         struct snd_pcm_runtime *runtime;
3223         
3224         if (substream == NULL)
3225                 return VM_FAULT_SIGBUS;
3226         runtime = substream->runtime;
3227         vmf->page = virt_to_page(runtime->status);
3228         get_page(vmf->page);
3229         return 0;
3230 }
3231
3232 static const struct vm_operations_struct snd_pcm_vm_ops_status =
3233 {
3234         .fault =        snd_pcm_mmap_status_fault,
3235 };
3236
3237 static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file,
3238