Merge tag 'drm-fixes-2019-08-02' of git://anongit.freedesktop.org/drm/drm
[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                 add_wait_queue(&to_check->sleep, &wait);
1877                 snd_pcm_stream_unlock_irq(substream);
1878                 if (runtime->no_period_wakeup)
1879                         tout = MAX_SCHEDULE_TIMEOUT;
1880                 else {
1881                         tout = 10;
1882                         if (runtime->rate) {
1883                                 long t = runtime->period_size * 2 / runtime->rate;
1884                                 tout = max(t, tout);
1885                         }
1886                         tout = msecs_to_jiffies(tout * 1000);
1887                 }
1888                 tout = schedule_timeout_interruptible(tout);
1889
1890                 snd_pcm_stream_lock_irq(substream);
1891                 group = snd_pcm_stream_group_ref(substream);
1892                 snd_pcm_group_for_each_entry(s, substream) {
1893                         if (s->runtime == to_check) {
1894                                 remove_wait_queue(&to_check->sleep, &wait);
1895                                 break;
1896                         }
1897                 }
1898                 snd_pcm_group_unref(group, substream);
1899
1900                 if (card->shutdown) {
1901                         result = -ENODEV;
1902                         break;
1903                 }
1904                 if (tout == 0) {
1905                         if (substream->runtime->status->state == SNDRV_PCM_STATE_SUSPENDED)
1906                                 result = -ESTRPIPE;
1907                         else {
1908                                 dev_dbg(substream->pcm->card->dev,
1909                                         "playback drain error (DMA or IRQ trouble?)\n");
1910                                 snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
1911                                 result = -EIO;
1912                         }
1913                         break;
1914                 }
1915         }
1916
1917  unlock:
1918         snd_pcm_stream_unlock_irq(substream);
1919
1920         return result;
1921 }
1922
1923 /*
1924  * drop ioctl
1925  *
1926  * Immediately put all linked substreams into SETUP state.
1927  */
1928 static int snd_pcm_drop(struct snd_pcm_substream *substream)
1929 {
1930         struct snd_pcm_runtime *runtime;
1931         int result = 0;
1932         
1933         if (PCM_RUNTIME_CHECK(substream))
1934                 return -ENXIO;
1935         runtime = substream->runtime;
1936
1937         if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
1938             runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
1939                 return -EBADFD;
1940
1941         snd_pcm_stream_lock_irq(substream);
1942         /* resume pause */
1943         if (runtime->status->state == SNDRV_PCM_STATE_PAUSED)
1944                 snd_pcm_pause(substream, 0);
1945
1946         snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
1947         /* runtime->control->appl_ptr = runtime->status->hw_ptr; */
1948         snd_pcm_stream_unlock_irq(substream);
1949
1950         return result;
1951 }
1952
1953
1954 static bool is_pcm_file(struct file *file)
1955 {
1956         struct inode *inode = file_inode(file);
1957         struct snd_pcm *pcm;
1958         unsigned int minor;
1959
1960         if (!S_ISCHR(inode->i_mode) || imajor(inode) != snd_major)
1961                 return false;
1962         minor = iminor(inode);
1963         pcm = snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_PLAYBACK);
1964         if (!pcm)
1965                 pcm = snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_CAPTURE);
1966         if (!pcm)
1967                 return false;
1968         snd_card_unref(pcm->card);
1969         return true;
1970 }
1971
1972 /*
1973  * PCM link handling
1974  */
1975 static int snd_pcm_link(struct snd_pcm_substream *substream, int fd)
1976 {
1977         int res = 0;
1978         struct snd_pcm_file *pcm_file;
1979         struct snd_pcm_substream *substream1;
1980         struct snd_pcm_group *group, *target_group;
1981         bool nonatomic = substream->pcm->nonatomic;
1982         struct fd f = fdget(fd);
1983
1984         if (!f.file)
1985                 return -EBADFD;
1986         if (!is_pcm_file(f.file)) {
1987                 res = -EBADFD;
1988                 goto _badf;
1989         }
1990         pcm_file = f.file->private_data;
1991         substream1 = pcm_file->substream;
1992         group = kzalloc(sizeof(*group), GFP_KERNEL);
1993         if (!group) {
1994                 res = -ENOMEM;
1995                 goto _nolock;
1996         }
1997         snd_pcm_group_init(group);
1998
1999         down_write(&snd_pcm_link_rwsem);
2000         if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN ||
2001             substream->runtime->status->state != substream1->runtime->status->state ||
2002             substream->pcm->nonatomic != substream1->pcm->nonatomic) {
2003                 res = -EBADFD;
2004                 goto _end;
2005         }
2006         if (snd_pcm_stream_linked(substream1)) {
2007                 res = -EALREADY;
2008                 goto _end;
2009         }
2010
2011         snd_pcm_stream_lock_irq(substream);
2012         if (!snd_pcm_stream_linked(substream)) {
2013                 snd_pcm_group_assign(substream, group);
2014                 group = NULL; /* assigned, don't free this one below */
2015         }
2016         target_group = substream->group;
2017         snd_pcm_stream_unlock_irq(substream);
2018
2019         snd_pcm_group_lock_irq(target_group, nonatomic);
2020         snd_pcm_stream_lock(substream1);
2021         snd_pcm_group_assign(substream1, target_group);
2022         refcount_inc(&target_group->refs);
2023         snd_pcm_stream_unlock(substream1);
2024         snd_pcm_group_unlock_irq(target_group, nonatomic);
2025  _end:
2026         up_write(&snd_pcm_link_rwsem);
2027  _nolock:
2028         kfree(group);
2029  _badf:
2030         fdput(f);
2031         return res;
2032 }
2033
2034 static void relink_to_local(struct snd_pcm_substream *substream)
2035 {
2036         snd_pcm_stream_lock(substream);
2037         snd_pcm_group_assign(substream, &substream->self_group);
2038         snd_pcm_stream_unlock(substream);
2039 }
2040
2041 static int snd_pcm_unlink(struct snd_pcm_substream *substream)
2042 {
2043         struct snd_pcm_group *group;
2044         bool nonatomic = substream->pcm->nonatomic;
2045         bool do_free = false;
2046         int res = 0;
2047
2048         down_write(&snd_pcm_link_rwsem);
2049
2050         if (!snd_pcm_stream_linked(substream)) {
2051                 res = -EALREADY;
2052                 goto _end;
2053         }
2054
2055         group = substream->group;
2056         snd_pcm_group_lock_irq(group, nonatomic);
2057
2058         relink_to_local(substream);
2059         refcount_dec(&group->refs);
2060
2061         /* detach the last stream, too */
2062         if (list_is_singular(&group->substreams)) {
2063                 relink_to_local(list_first_entry(&group->substreams,
2064                                                  struct snd_pcm_substream,
2065                                                  link_list));
2066                 do_free = refcount_dec_and_test(&group->refs);
2067         }
2068
2069         snd_pcm_group_unlock_irq(group, nonatomic);
2070         if (do_free)
2071                 kfree(group);
2072
2073        _end:
2074         up_write(&snd_pcm_link_rwsem);
2075         return res;
2076 }
2077
2078 /*
2079  * hw configurator
2080  */
2081 static int snd_pcm_hw_rule_mul(struct snd_pcm_hw_params *params,
2082                                struct snd_pcm_hw_rule *rule)
2083 {
2084         struct snd_interval t;
2085         snd_interval_mul(hw_param_interval_c(params, rule->deps[0]),
2086                      hw_param_interval_c(params, rule->deps[1]), &t);
2087         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2088 }
2089
2090 static int snd_pcm_hw_rule_div(struct snd_pcm_hw_params *params,
2091                                struct snd_pcm_hw_rule *rule)
2092 {
2093         struct snd_interval t;
2094         snd_interval_div(hw_param_interval_c(params, rule->deps[0]),
2095                      hw_param_interval_c(params, rule->deps[1]), &t);
2096         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2097 }
2098
2099 static int snd_pcm_hw_rule_muldivk(struct snd_pcm_hw_params *params,
2100                                    struct snd_pcm_hw_rule *rule)
2101 {
2102         struct snd_interval t;
2103         snd_interval_muldivk(hw_param_interval_c(params, rule->deps[0]),
2104                          hw_param_interval_c(params, rule->deps[1]),
2105                          (unsigned long) rule->private, &t);
2106         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2107 }
2108
2109 static int snd_pcm_hw_rule_mulkdiv(struct snd_pcm_hw_params *params,
2110                                    struct snd_pcm_hw_rule *rule)
2111 {
2112         struct snd_interval t;
2113         snd_interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]),
2114                          (unsigned long) rule->private,
2115                          hw_param_interval_c(params, rule->deps[1]), &t);
2116         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2117 }
2118
2119 static int snd_pcm_hw_rule_format(struct snd_pcm_hw_params *params,
2120                                   struct snd_pcm_hw_rule *rule)
2121 {
2122         unsigned int k;
2123         const struct snd_interval *i =
2124                                 hw_param_interval_c(params, rule->deps[0]);
2125         struct snd_mask m;
2126         struct snd_mask *mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
2127         snd_mask_any(&m);
2128         for (k = 0; k <= SNDRV_PCM_FORMAT_LAST; ++k) {
2129                 int bits;
2130                 if (! snd_mask_test(mask, k))
2131                         continue;
2132                 bits = snd_pcm_format_physical_width(k);
2133                 if (bits <= 0)
2134                         continue; /* ignore invalid formats */
2135                 if ((unsigned)bits < i->min || (unsigned)bits > i->max)
2136                         snd_mask_reset(&m, k);
2137         }
2138         return snd_mask_refine(mask, &m);
2139 }
2140
2141 static int snd_pcm_hw_rule_sample_bits(struct snd_pcm_hw_params *params,
2142                                        struct snd_pcm_hw_rule *rule)
2143 {
2144         struct snd_interval t;
2145         unsigned int k;
2146         t.min = UINT_MAX;
2147         t.max = 0;
2148         t.openmin = 0;
2149         t.openmax = 0;
2150         for (k = 0; k <= SNDRV_PCM_FORMAT_LAST; ++k) {
2151                 int bits;
2152                 if (! snd_mask_test(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), k))
2153                         continue;
2154                 bits = snd_pcm_format_physical_width(k);
2155                 if (bits <= 0)
2156                         continue; /* ignore invalid formats */
2157                 if (t.min > (unsigned)bits)
2158                         t.min = bits;
2159                 if (t.max < (unsigned)bits)
2160                         t.max = bits;
2161         }
2162         t.integer = 1;
2163         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2164 }
2165
2166 #if SNDRV_PCM_RATE_5512 != 1 << 0 || SNDRV_PCM_RATE_192000 != 1 << 12
2167 #error "Change this table"
2168 #endif
2169
2170 static const unsigned int rates[] = {
2171         5512, 8000, 11025, 16000, 22050, 32000, 44100,
2172         48000, 64000, 88200, 96000, 176400, 192000
2173 };
2174
2175 const struct snd_pcm_hw_constraint_list snd_pcm_known_rates = {
2176         .count = ARRAY_SIZE(rates),
2177         .list = rates,
2178 };
2179
2180 static int snd_pcm_hw_rule_rate(struct snd_pcm_hw_params *params,
2181                                 struct snd_pcm_hw_rule *rule)
2182 {
2183         struct snd_pcm_hardware *hw = rule->private;
2184         return snd_interval_list(hw_param_interval(params, rule->var),
2185                                  snd_pcm_known_rates.count,
2186                                  snd_pcm_known_rates.list, hw->rates);
2187 }               
2188
2189 static int snd_pcm_hw_rule_buffer_bytes_max(struct snd_pcm_hw_params *params,
2190                                             struct snd_pcm_hw_rule *rule)
2191 {
2192         struct snd_interval t;
2193         struct snd_pcm_substream *substream = rule->private;
2194         t.min = 0;
2195         t.max = substream->buffer_bytes_max;
2196         t.openmin = 0;
2197         t.openmax = 0;
2198         t.integer = 1;
2199         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2200 }               
2201
2202 int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream)
2203 {
2204         struct snd_pcm_runtime *runtime = substream->runtime;
2205         struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
2206         int k, err;
2207
2208         for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++) {
2209                 snd_mask_any(constrs_mask(constrs, k));
2210         }
2211
2212         for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++) {
2213                 snd_interval_any(constrs_interval(constrs, k));
2214         }
2215
2216         snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_CHANNELS));
2217         snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_BUFFER_SIZE));
2218         snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_BUFFER_BYTES));
2219         snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_SAMPLE_BITS));
2220         snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_FRAME_BITS));
2221
2222         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
2223                                    snd_pcm_hw_rule_format, NULL,
2224                                    SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
2225         if (err < 0)
2226                 return err;
2227         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 
2228                                   snd_pcm_hw_rule_sample_bits, NULL,
2229                                   SNDRV_PCM_HW_PARAM_FORMAT, 
2230                                   SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
2231         if (err < 0)
2232                 return err;
2233         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 
2234                                   snd_pcm_hw_rule_div, NULL,
2235                                   SNDRV_PCM_HW_PARAM_FRAME_BITS, SNDRV_PCM_HW_PARAM_CHANNELS, -1);
2236         if (err < 0)
2237                 return err;
2238         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 
2239                                   snd_pcm_hw_rule_mul, NULL,
2240                                   SNDRV_PCM_HW_PARAM_SAMPLE_BITS, SNDRV_PCM_HW_PARAM_CHANNELS, -1);
2241         if (err < 0)
2242                 return err;
2243         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 
2244                                   snd_pcm_hw_rule_mulkdiv, (void*) 8,
2245                                   SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);
2246         if (err < 0)
2247                 return err;
2248         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 
2249                                   snd_pcm_hw_rule_mulkdiv, (void*) 8,
2250                                   SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, -1);
2251         if (err < 0)
2252                 return err;
2253         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 
2254                                   snd_pcm_hw_rule_div, NULL,
2255                                   SNDRV_PCM_HW_PARAM_FRAME_BITS, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
2256         if (err < 0)
2257                 return err;
2258         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 
2259                                   snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
2260                                   SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_PERIOD_TIME, -1);
2261         if (err < 0)
2262                 return err;
2263         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 
2264                                   snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
2265                                   SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_BUFFER_TIME, -1);
2266         if (err < 0)
2267                 return err;
2268         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS, 
2269                                   snd_pcm_hw_rule_div, NULL,
2270                                   SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);
2271         if (err < 0)
2272                 return err;
2273         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 
2274                                   snd_pcm_hw_rule_div, NULL,
2275                                   SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_PERIODS, -1);
2276         if (err < 0)
2277                 return err;
2278         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 
2279                                   snd_pcm_hw_rule_mulkdiv, (void*) 8,
2280                                   SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
2281         if (err < 0)
2282                 return err;
2283         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 
2284                                   snd_pcm_hw_rule_muldivk, (void*) 1000000,
2285                                   SNDRV_PCM_HW_PARAM_PERIOD_TIME, SNDRV_PCM_HW_PARAM_RATE, -1);
2286         if (err < 0)
2287                 return err;
2288         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 
2289                                   snd_pcm_hw_rule_mul, NULL,
2290                                   SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_PERIODS, -1);
2291         if (err < 0)
2292                 return err;
2293         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 
2294                                   snd_pcm_hw_rule_mulkdiv, (void*) 8,
2295                                   SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
2296         if (err < 0)
2297                 return err;
2298         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 
2299                                   snd_pcm_hw_rule_muldivk, (void*) 1000000,
2300                                   SNDRV_PCM_HW_PARAM_BUFFER_TIME, SNDRV_PCM_HW_PARAM_RATE, -1);
2301         if (err < 0)
2302                 return err;
2303         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 
2304                                   snd_pcm_hw_rule_muldivk, (void*) 8,
2305                                   SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
2306         if (err < 0)
2307                 return err;
2308         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 
2309                                   snd_pcm_hw_rule_muldivk, (void*) 8,
2310                                   SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
2311         if (err < 0)
2312                 return err;
2313         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 
2314                                   snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
2315                                   SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_RATE, -1);
2316         if (err < 0)
2317                 return err;
2318         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_TIME, 
2319                                   snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
2320                                   SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_RATE, -1);
2321         if (err < 0)
2322                 return err;
2323         return 0;
2324 }
2325
2326 int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
2327 {
2328         struct snd_pcm_runtime *runtime = substream->runtime;
2329         struct snd_pcm_hardware *hw = &runtime->hw;
2330         int err;
2331         unsigned int mask = 0;
2332
2333         if (hw->info & SNDRV_PCM_INFO_INTERLEAVED)
2334                 mask |= 1 << SNDRV_PCM_ACCESS_RW_INTERLEAVED;
2335         if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED)
2336                 mask |= 1 << SNDRV_PCM_ACCESS_RW_NONINTERLEAVED;
2337         if (hw_support_mmap(substream)) {
2338                 if (hw->info & SNDRV_PCM_INFO_INTERLEAVED)
2339                         mask |= 1 << SNDRV_PCM_ACCESS_MMAP_INTERLEAVED;
2340                 if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED)
2341                         mask |= 1 << SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED;
2342                 if (hw->info & SNDRV_PCM_INFO_COMPLEX)
2343                         mask |= 1 << SNDRV_PCM_ACCESS_MMAP_COMPLEX;
2344         }
2345         err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_ACCESS, mask);
2346         if (err < 0)
2347                 return err;
2348
2349         err = snd_pcm_hw_constraint_mask64(runtime, SNDRV_PCM_HW_PARAM_FORMAT, hw->formats);
2350         if (err < 0)
2351                 return err;
2352
2353         err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_SUBFORMAT, 1 << SNDRV_PCM_SUBFORMAT_STD);
2354         if (err < 0)
2355                 return err;
2356
2357         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_CHANNELS,
2358                                            hw->channels_min, hw->channels_max);
2359         if (err < 0)
2360                 return err;
2361
2362         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_RATE,
2363                                            hw->rate_min, hw->rate_max);
2364         if (err < 0)
2365                 return err;
2366
2367         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
2368                                            hw->period_bytes_min, hw->period_bytes_max);
2369         if (err < 0)
2370                 return err;
2371
2372         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIODS,
2373                                            hw->periods_min, hw->periods_max);
2374         if (err < 0)
2375                 return err;
2376
2377         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
2378                                            hw->period_bytes_min, hw->buffer_bytes_max);
2379         if (err < 0)
2380                 return err;
2381
2382         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 
2383                                   snd_pcm_hw_rule_buffer_bytes_max, substream,
2384                                   SNDRV_PCM_HW_PARAM_BUFFER_BYTES, -1);
2385         if (err < 0)
2386                 return err;
2387
2388         /* FIXME: remove */
2389         if (runtime->dma_bytes) {
2390                 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, runtime->dma_bytes);
2391                 if (err < 0)
2392                         return err;
2393         }
2394
2395         if (!(hw->rates & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))) {
2396                 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 
2397                                           snd_pcm_hw_rule_rate, hw,
2398                                           SNDRV_PCM_HW_PARAM_RATE, -1);
2399                 if (err < 0)
2400                         return err;
2401         }
2402
2403         /* FIXME: this belong to lowlevel */
2404         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
2405
2406         return 0;
2407 }
2408
2409 static void pcm_release_private(struct snd_pcm_substream *substream)
2410 {
2411         if (snd_pcm_stream_linked(substream))
2412                 snd_pcm_unlink(substream);
2413 }
2414
2415 void snd_pcm_release_substream(struct snd_pcm_substream *substream)
2416 {
2417         substream->ref_count--;
2418         if (substream->ref_count > 0)
2419                 return;
2420
2421         snd_pcm_drop(substream);
2422         if (substream->hw_opened) {
2423                 if (substream->ops->hw_free &&
2424                     substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
2425                         substream->ops->hw_free(substream);
2426                 substream->ops->close(substream);
2427                 substream->hw_opened = 0;
2428         }
2429         if (pm_qos_request_active(&substream->latency_pm_qos_req))
2430                 pm_qos_remove_request(&substream->latency_pm_qos_req);
2431         if (substream->pcm_release) {
2432                 substream->pcm_release(substream);
2433                 substream->pcm_release = NULL;
2434         }
2435         snd_pcm_detach_substream(substream);
2436 }
2437 EXPORT_SYMBOL(snd_pcm_release_substream);
2438
2439 int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
2440                            struct file *file,
2441                            struct snd_pcm_substream **rsubstream)
2442 {
2443         struct snd_pcm_substream *substream;
2444         int err;
2445
2446         err = snd_pcm_attach_substream(pcm, stream, file, &substream);
2447         if (err < 0)
2448                 return err;
2449         if (substream->ref_count > 1) {
2450                 *rsubstream = substream;
2451                 return 0;
2452         }
2453
2454         err = snd_pcm_hw_constraints_init(substream);
2455         if (err < 0) {
2456                 pcm_dbg(pcm, "snd_pcm_hw_constraints_init failed\n");
2457                 goto error;
2458         }
2459
2460         if ((err = substream->ops->open(substream)) < 0)
2461                 goto error;
2462
2463         substream->hw_opened = 1;
2464
2465         err = snd_pcm_hw_constraints_complete(substream);
2466         if (err < 0) {
2467                 pcm_dbg(pcm, "snd_pcm_hw_constraints_complete failed\n");
2468                 goto error;
2469         }
2470
2471         *rsubstream = substream;
2472         return 0;
2473
2474  error:
2475         snd_pcm_release_substream(substream);
2476         return err;
2477 }
2478 EXPORT_SYMBOL(snd_pcm_open_substream);
2479
2480 static int snd_pcm_open_file(struct file *file,
2481                              struct snd_pcm *pcm,
2482                              int stream)
2483 {
2484         struct snd_pcm_file *pcm_file;
2485         struct snd_pcm_substream *substream;
2486         int err;
2487
2488         err = snd_pcm_open_substream(pcm, stream, file, &substream);
2489         if (err < 0)
2490                 return err;
2491
2492         pcm_file = kzalloc(sizeof(*pcm_file), GFP_KERNEL);
2493         if (pcm_file == NULL) {
2494                 snd_pcm_release_substream(substream);
2495                 return -ENOMEM;
2496         }
2497         pcm_file->substream = substream;
2498         if (substream->ref_count == 1)
2499                 substream->pcm_release = pcm_release_private;
2500         file->private_data = pcm_file;
2501
2502         return 0;
2503 }
2504
2505 static int snd_pcm_playback_open(struct inode *inode, struct file *file)
2506 {
2507         struct snd_pcm *pcm;
2508         int err = nonseekable_open(inode, file);
2509         if (err < 0)
2510                 return err;
2511         pcm = snd_lookup_minor_data(iminor(inode),
2512                                     SNDRV_DEVICE_TYPE_PCM_PLAYBACK);
2513         err = snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_PLAYBACK);
2514         if (pcm)
2515                 snd_card_unref(pcm->card);
2516         return err;
2517 }
2518
2519 static int snd_pcm_capture_open(struct inode *inode, struct file *file)
2520 {
2521         struct snd_pcm *pcm;
2522         int err = nonseekable_open(inode, file);
2523         if (err < 0)
2524                 return err;
2525         pcm = snd_lookup_minor_data(iminor(inode),
2526                                     SNDRV_DEVICE_TYPE_PCM_CAPTURE);
2527         err = snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_CAPTURE);
2528         if (pcm)
2529                 snd_card_unref(pcm->card);
2530         return err;
2531 }
2532
2533 static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream)
2534 {
2535         int err;
2536         wait_queue_entry_t wait;
2537
2538         if (pcm == NULL) {
2539                 err = -ENODEV;
2540                 goto __error1;
2541         }
2542         err = snd_card_file_add(pcm->card, file);
2543         if (err < 0)
2544                 goto __error1;
2545         if (!try_module_get(pcm->card->module)) {
2546                 err = -EFAULT;
2547                 goto __error2;
2548         }
2549         init_waitqueue_entry(&wait, current);
2550         add_wait_queue(&pcm->open_wait, &wait);
2551         mutex_lock(&pcm->open_mutex);
2552         while (1) {
2553                 err = snd_pcm_open_file(file, pcm, stream);
2554                 if (err >= 0)
2555                         break;
2556                 if (err == -EAGAIN) {
2557                         if (file->f_flags & O_NONBLOCK) {
2558                                 err = -EBUSY;
2559                                 break;
2560                         }
2561                 } else
2562                         break;
2563                 set_current_state(TASK_INTERRUPTIBLE);
2564                 mutex_unlock(&pcm->open_mutex);
2565                 schedule();
2566                 mutex_lock(&pcm->open_mutex);
2567                 if (pcm->card->shutdown) {
2568                         err = -ENODEV;
2569                         break;
2570                 }
2571                 if (signal_pending(current)) {
2572                         err = -ERESTARTSYS;
2573                         break;
2574                 }
2575         }
2576         remove_wait_queue(&pcm->open_wait, &wait);
2577         mutex_unlock(&pcm->open_mutex);
2578         if (err < 0)
2579                 goto __error;
2580         return err;
2581
2582       __error:
2583         module_put(pcm->card->module);
2584       __error2:
2585         snd_card_file_remove(pcm->card, file);
2586       __error1:
2587         return err;
2588 }
2589
2590 static int snd_pcm_release(struct inode *inode, struct file *file)
2591 {
2592         struct snd_pcm *pcm;
2593         struct snd_pcm_substream *substream;
2594         struct snd_pcm_file *pcm_file;
2595
2596         pcm_file = file->private_data;
2597         substream = pcm_file->substream;
2598         if (snd_BUG_ON(!substream))
2599                 return -ENXIO;
2600         pcm = substream->pcm;
2601         mutex_lock(&pcm->open_mutex);
2602         snd_pcm_release_substream(substream);
2603         kfree(pcm_file);
2604         mutex_unlock(&pcm->open_mutex);
2605         wake_up(&pcm->open_wait);
2606         module_put(pcm->card->module);
2607         snd_card_file_remove(pcm->card, file);
2608         return 0;
2609 }
2610
2611 /* check and update PCM state; return 0 or a negative error
2612  * call this inside PCM lock
2613  */
2614 static int do_pcm_hwsync(struct snd_pcm_substream *substream)
2615 {
2616         switch (substream->runtime->status->state) {
2617         case SNDRV_PCM_STATE_DRAINING:
2618                 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
2619                         return -EBADFD;
2620                 /* Fall through */
2621         case SNDRV_PCM_STATE_RUNNING:
2622                 return snd_pcm_update_hw_ptr(substream);
2623         case SNDRV_PCM_STATE_PREPARED:
2624         case SNDRV_PCM_STATE_PAUSED:
2625                 return 0;
2626         case SNDRV_PCM_STATE_SUSPENDED:
2627                 return -ESTRPIPE;
2628         case SNDRV_PCM_STATE_XRUN:
2629                 return -EPIPE;
2630         default:
2631                 return -EBADFD;
2632         }
2633 }
2634
2635 /* increase the appl_ptr; returns the processed frames or a negative error */
2636 static snd_pcm_sframes_t forward_appl_ptr(struct snd_pcm_substream *substream,
2637                                           snd_pcm_uframes_t frames,
2638                                            snd_pcm_sframes_t avail)
2639 {
2640         struct snd_pcm_runtime *runtime = substream->runtime;
2641         snd_pcm_sframes_t appl_ptr;
2642         int ret;
2643
2644         if (avail <= 0)
2645                 return 0;
2646         if (frames > (snd_pcm_uframes_t)avail)
2647                 frames = avail;
2648         appl_ptr = runtime->control->appl_ptr + frames;
2649         if (appl_ptr >= (snd_pcm_sframes_t)runtime->boundary)
2650                 appl_ptr -= runtime->boundary;
2651         ret = pcm_lib_apply_appl_ptr(substream, appl_ptr);
2652         return ret < 0 ? ret : frames;
2653 }
2654
2655 /* decrease the appl_ptr; returns the processed frames or zero for error */
2656 static snd_pcm_sframes_t rewind_appl_ptr(struct snd_pcm_substream *substream,
2657                                          snd_pcm_uframes_t frames,
2658                                          snd_pcm_sframes_t avail)
2659 {
2660         struct snd_pcm_runtime *runtime = substream->runtime;
2661         snd_pcm_sframes_t appl_ptr;
2662         int ret;
2663
2664         if (avail <= 0)
2665                 return 0;
2666         if (frames > (snd_pcm_uframes_t)avail)
2667                 frames = avail;
2668         appl_ptr = runtime->control->appl_ptr - frames;
2669         if (appl_ptr < 0)
2670                 appl_ptr += runtime->boundary;
2671         ret = pcm_lib_apply_appl_ptr(substream, appl_ptr);
2672         /* NOTE: we return zero for errors because PulseAudio gets depressed
2673          * upon receiving an error from rewind ioctl and stops processing
2674          * any longer.  Returning zero means that no rewind is done, so
2675          * it's not absolutely wrong to answer like that.
2676          */
2677         return ret < 0 ? 0 : frames;
2678 }
2679
2680 static snd_pcm_sframes_t snd_pcm_rewind(struct snd_pcm_substream *substream,
2681                                         snd_pcm_uframes_t frames)
2682 {
2683         snd_pcm_sframes_t ret;
2684
2685         if (frames == 0)
2686                 return 0;
2687
2688         snd_pcm_stream_lock_irq(substream);
2689         ret = do_pcm_hwsync(substream);
2690         if (!ret)
2691                 ret = rewind_appl_ptr(substream, frames,
2692                                       snd_pcm_hw_avail(substream));
2693         snd_pcm_stream_unlock_irq(substream);
2694         return ret;
2695 }
2696
2697 static snd_pcm_sframes_t snd_pcm_forward(struct snd_pcm_substream *substream,
2698                                          snd_pcm_uframes_t frames)
2699 {
2700         snd_pcm_sframes_t ret;
2701
2702         if (frames == 0)
2703                 return 0;
2704
2705         snd_pcm_stream_lock_irq(substream);
2706         ret = do_pcm_hwsync(substream);
2707         if (!ret)
2708                 ret = forward_appl_ptr(substream, frames,
2709                                        snd_pcm_avail(substream));
2710         snd_pcm_stream_unlock_irq(substream);
2711         return ret;
2712 }
2713
2714 static int snd_pcm_hwsync(struct snd_pcm_substream *substream)
2715 {
2716         int err;
2717
2718         snd_pcm_stream_lock_irq(substream);
2719         err = do_pcm_hwsync(substream);
2720         snd_pcm_stream_unlock_irq(substream);
2721         return err;
2722 }
2723                 
2724 static int snd_pcm_delay(struct snd_pcm_substream *substream,
2725                          snd_pcm_sframes_t *delay)
2726 {
2727         int err;
2728         snd_pcm_sframes_t n = 0;
2729
2730         snd_pcm_stream_lock_irq(substream);
2731         err = do_pcm_hwsync(substream);
2732         if (!err)
2733                 n = snd_pcm_calc_delay(substream);
2734         snd_pcm_stream_unlock_irq(substream);
2735         if (!err)
2736                 *delay = n;
2737         return err;
2738 }
2739                 
2740 static int snd_pcm_sync_ptr(struct snd_pcm_substream *substream,
2741                             struct snd_pcm_sync_ptr __user *_sync_ptr)
2742 {
2743         struct snd_pcm_runtime *runtime = substream->runtime;
2744         struct snd_pcm_sync_ptr sync_ptr;
2745         volatile struct snd_pcm_mmap_status *status;
2746         volatile struct snd_pcm_mmap_control *control;
2747         int err;
2748
2749         memset(&sync_ptr, 0, sizeof(sync_ptr));
2750         if (get_user(sync_ptr.flags, (unsigned __user *)&(_sync_ptr->flags)))
2751                 return -EFAULT;
2752         if (copy_from_user(&sync_ptr.c.control, &(_sync_ptr->c.control), sizeof(struct snd_pcm_mmap_control)))
2753                 return -EFAULT; 
2754         status = runtime->status;
2755         control = runtime->control;
2756         if (sync_ptr.flags & SNDRV_PCM_SYNC_PTR_HWSYNC) {
2757                 err = snd_pcm_hwsync(substream);
2758                 if (err < 0)
2759                         return err;
2760         }
2761         snd_pcm_stream_lock_irq(substream);
2762         if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_APPL)) {
2763                 err = pcm_lib_apply_appl_ptr(substream,
2764                                              sync_ptr.c.control.appl_ptr);
2765                 if (err < 0) {
2766                         snd_pcm_stream_unlock_irq(substream);
2767                         return err;
2768                 }
2769         } else {
2770                 sync_ptr.c.control.appl_ptr = control->appl_ptr;
2771         }
2772         if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN))
2773                 control->avail_min = sync_ptr.c.control.avail_min;
2774         else
2775                 sync_ptr.c.control.avail_min = control->avail_min;
2776         sync_ptr.s.status.state = status->state;
2777         sync_ptr.s.status.hw_ptr = status->hw_ptr;
2778         sync_ptr.s.status.tstamp = status->tstamp;
2779         sync_ptr.s.status.suspended_state = status->suspended_state;
2780         sync_ptr.s.status.audio_tstamp = status->audio_tstamp;
2781         snd_pcm_stream_unlock_irq(substream);
2782         if (copy_to_user(_sync_ptr, &sync_ptr, sizeof(sync_ptr)))
2783                 return -EFAULT;
2784         return 0;
2785 }
2786
2787 static int snd_pcm_tstamp(struct snd_pcm_substream *substream, int __user *_arg)
2788 {
2789         struct snd_pcm_runtime *runtime = substream->runtime;
2790         int arg;
2791         
2792         if (get_user(arg, _arg))
2793                 return -EFAULT;
2794         if (arg < 0 || arg > SNDRV_PCM_TSTAMP_TYPE_LAST)
2795                 return -EINVAL;
2796         runtime->tstamp_type = arg;
2797         return 0;
2798 }
2799
2800 static int snd_pcm_xferi_frames_ioctl(struct snd_pcm_substream *substream,
2801                                       struct snd_xferi __user *_xferi)
2802 {
2803         struct snd_xferi xferi;
2804         struct snd_pcm_runtime *runtime = substream->runtime;
2805         snd_pcm_sframes_t result;
2806
2807         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2808                 return -EBADFD;
2809         if (put_user(0, &_xferi->result))
2810                 return -EFAULT;
2811         if (copy_from_user(&xferi, _xferi, sizeof(xferi)))
2812                 return -EFAULT;
2813         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
2814                 result = snd_pcm_lib_write(substream, xferi.buf, xferi.frames);
2815         else
2816                 result = snd_pcm_lib_read(substream, xferi.buf, xferi.frames);
2817         __put_user(result, &_xferi->result);
2818         return result < 0 ? result : 0;
2819 }
2820
2821 static int snd_pcm_xfern_frames_ioctl(struct snd_pcm_substream *substream,
2822                                       struct snd_xfern __user *_xfern)
2823 {
2824         struct snd_xfern xfern;
2825         struct snd_pcm_runtime *runtime = substream->runtime;
2826         void *bufs;
2827         snd_pcm_sframes_t result;
2828
2829         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2830                 return -EBADFD;
2831         if (runtime->channels > 128)
2832                 return -EINVAL;
2833         if (put_user(0, &_xfern->result))
2834                 return -EFAULT;
2835         if (copy_from_user(&xfern, _xfern, sizeof(xfern)))
2836                 return -EFAULT;
2837
2838         bufs = memdup_user(xfern.bufs, sizeof(void *) * runtime->channels);
2839         if (IS_ERR(bufs))
2840                 return PTR_ERR(bufs);
2841         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
2842                 result = snd_pcm_lib_writev(substream, bufs, xfern.frames);
2843         else
2844                 result = snd_pcm_lib_readv(substream, bufs, xfern.frames);
2845         kfree(bufs);
2846         __put_user(result, &_xfern->result);
2847         return result < 0 ? result : 0;
2848 }
2849
2850 static int snd_pcm_rewind_ioctl(struct snd_pcm_substream *substream,
2851                                 snd_pcm_uframes_t __user *_frames)
2852 {
2853         snd_pcm_uframes_t frames;
2854         snd_pcm_sframes_t result;
2855
2856         if (get_user(frames, _frames))
2857                 return -EFAULT;
2858         if (put_user(0, _frames))
2859                 return -EFAULT;
2860         result = snd_pcm_rewind(substream, frames);
2861         __put_user(result, _frames);
2862         return result < 0 ? result : 0;
2863 }
2864
2865 static int snd_pcm_forward_ioctl(struct snd_pcm_substream *substream,
2866                                  snd_pcm_uframes_t __user *_frames)
2867 {
2868         snd_pcm_uframes_t frames;
2869         snd_pcm_sframes_t result;
2870
2871         if (get_user(frames, _frames))
2872                 return -EFAULT;
2873         if (put_user(0, _frames))
2874                 return -EFAULT;
2875         result = snd_pcm_forward(substream, frames);
2876         __put_user(result, _frames);
2877         return result < 0 ? result : 0;
2878 }
2879
2880 static int snd_pcm_common_ioctl(struct file *file,
2881                                  struct snd_pcm_substream *substream,
2882                                  unsigned int cmd, void __user *arg)
2883 {
2884         struct snd_pcm_file *pcm_file = file->private_data;
2885         int res;
2886
2887         if (PCM_RUNTIME_CHECK(substream))
2888                 return -ENXIO;
2889
2890         res = snd_power_wait(substream->pcm->card, SNDRV_CTL_POWER_D0);
2891         if (res < 0)
2892                 return res;
2893
2894         switch (cmd) {
2895         case SNDRV_PCM_IOCTL_PVERSION:
2896                 return put_user(SNDRV_PCM_VERSION, (int __user *)arg) ? -EFAULT : 0;
2897         case SNDRV_PCM_IOCTL_INFO:
2898                 return snd_pcm_info_user(substream, arg);
2899         case SNDRV_PCM_IOCTL_TSTAMP:    /* just for compatibility */
2900                 return 0;
2901         case SNDRV_PCM_IOCTL_TTSTAMP:
2902                 return snd_pcm_tstamp(substream, arg);
2903         case SNDRV_PCM_IOCTL_USER_PVERSION:
2904                 if (get_user(pcm_file->user_pversion,
2905                              (unsigned int __user *)arg))
2906                         return -EFAULT;
2907                 return 0;
2908         case SNDRV_PCM_IOCTL_HW_REFINE:
2909                 return snd_pcm_hw_refine_user(substream, arg);
2910         case SNDRV_PCM_IOCTL_HW_PARAMS:
2911                 return snd_pcm_hw_params_user(substream, arg);
2912         case SNDRV_PCM_IOCTL_HW_FREE:
2913                 return snd_pcm_hw_free(substream);
2914         case SNDRV_PCM_IOCTL_SW_PARAMS:
2915                 return snd_pcm_sw_params_user(substream, arg);
2916         case SNDRV_PCM_IOCTL_STATUS:
2917                 return snd_pcm_status_user(substream, arg, false);
2918         case SNDRV_PCM_IOCTL_STATUS_EXT:
2919                 return snd_pcm_status_user(substream, arg, true);
2920         case SNDRV_PCM_IOCTL_CHANNEL_INFO:
2921                 return snd_pcm_channel_info_user(substream, arg);
2922         case SNDRV_PCM_IOCTL_PREPARE:
2923                 return snd_pcm_prepare(substream, file);
2924         case SNDRV_PCM_IOCTL_RESET:
2925                 return snd_pcm_reset(substream);
2926         case SNDRV_PCM_IOCTL_START:
2927                 return snd_pcm_start_lock_irq(substream);
2928         case SNDRV_PCM_IOCTL_LINK:
2929                 return snd_pcm_link(substream, (int)(unsigned long) arg);
2930         case SNDRV_PCM_IOCTL_UNLINK:
2931                 return snd_pcm_unlink(substream);
2932         case SNDRV_PCM_IOCTL_RESUME:
2933                 return snd_pcm_resume(substream);
2934         case SNDRV_PCM_IOCTL_XRUN:
2935                 return snd_pcm_xrun(substream);
2936         case SNDRV_PCM_IOCTL_HWSYNC:
2937                 return snd_pcm_hwsync(substream);
2938         case SNDRV_PCM_IOCTL_DELAY:
2939         {
2940                 snd_pcm_sframes_t delay;
2941                 snd_pcm_sframes_t __user *res = arg;
2942                 int err;
2943
2944                 err = snd_pcm_delay(substream, &delay);
2945                 if (err)
2946                         return err;
2947                 if (put_user(delay, res))
2948                         return -EFAULT;
2949                 return 0;
2950         }
2951         case SNDRV_PCM_IOCTL_SYNC_PTR:
2952                 return snd_pcm_sync_ptr(substream, arg);
2953 #ifdef CONFIG_SND_SUPPORT_OLD_API
2954         case SNDRV_PCM_IOCTL_HW_REFINE_OLD:
2955                 return snd_pcm_hw_refine_old_user(substream, arg);
2956         case SNDRV_PCM_IOCTL_HW_PARAMS_OLD:
2957                 return snd_pcm_hw_params_old_user(substream, arg);
2958 #endif
2959         case SNDRV_PCM_IOCTL_DRAIN:
2960                 return snd_pcm_drain(substream, file);
2961         case SNDRV_PCM_IOCTL_DROP:
2962                 return snd_pcm_drop(substream);
2963         case SNDRV_PCM_IOCTL_PAUSE:
2964                 return snd_pcm_action_lock_irq(&snd_pcm_action_pause,
2965                                                substream,
2966                                                (int)(unsigned long)arg);
2967         case SNDRV_PCM_IOCTL_WRITEI_FRAMES:
2968         case SNDRV_PCM_IOCTL_READI_FRAMES:
2969                 return snd_pcm_xferi_frames_ioctl(substream, arg);
2970         case SNDRV_PCM_IOCTL_WRITEN_FRAMES:
2971         case SNDRV_PCM_IOCTL_READN_FRAMES:
2972                 return snd_pcm_xfern_frames_ioctl(substream, arg);
2973         case SNDRV_PCM_IOCTL_REWIND:
2974                 return snd_pcm_rewind_ioctl(substream, arg);
2975         case SNDRV_PCM_IOCTL_FORWARD:
2976                 return snd_pcm_forward_ioctl(substream, arg);
2977         }
2978         pcm_dbg(substream->pcm, "unknown ioctl = 0x%x\n", cmd);
2979         return -ENOTTY;
2980 }
2981
2982 static long snd_pcm_ioctl(struct file *file, unsigned int cmd,
2983                           unsigned long arg)
2984 {
2985         struct snd_pcm_file *pcm_file;
2986
2987         pcm_file = file->private_data;
2988
2989         if (((cmd >> 8) & 0xff) != 'A')
2990                 return -ENOTTY;
2991
2992         return snd_pcm_common_ioctl(file, pcm_file->substream, cmd,
2993                                      (void __user *)arg);
2994 }
2995
2996 /**
2997  * snd_pcm_kernel_ioctl - Execute PCM ioctl in the kernel-space
2998  * @substream: PCM substream
2999  * @cmd: IOCTL cmd
3000  * @arg: IOCTL argument
3001  *
3002  * The function is provided primarily for OSS layer and USB gadget drivers,
3003  * and it allows only the limited set of ioctls (hw_params, sw_params,
3004  * prepare, start, drain, drop, forward).
3005  */
3006 int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream,
3007                          unsigned int cmd, void *arg)
3008 {
3009         snd_pcm_uframes_t *frames = arg;
3010         snd_pcm_sframes_t result;
3011         
3012         switch (cmd) {
3013         case SNDRV_PCM_IOCTL_FORWARD:
3014         {
3015                 /* provided only for OSS; capture-only and no value returned */
3016                 if (substream->stream != SNDRV_PCM_STREAM_CAPTURE)
3017                         return -EINVAL;
3018                 result = snd_pcm_forward(substream, *frames);
3019                 return result < 0 ? result : 0;
3020         }
3021         case SNDRV_PCM_IOCTL_HW_PARAMS:
3022                 return snd_pcm_hw_params(substream, arg);
3023         case SNDRV_PCM_IOCTL_SW_PARAMS:
3024                 return snd_pcm_sw_params(substream, arg);
3025         case SNDRV_PCM_IOCTL_PREPARE:
3026                 return snd_pcm_prepare(substream, NULL);
3027         case SNDRV_PCM_IOCTL_START:
3028                 return snd_pcm_start_lock_irq(substream);
3029         case SNDRV_PCM_IOCTL_DRAIN:
3030                 return snd_pcm_drain(substream, NULL);
3031         case SNDRV_PCM_IOCTL_DROP:
3032                 return snd_pcm_drop(substream);
3033         case SNDRV_PCM_IOCTL_DELAY:
3034                 return snd_pcm_delay(substream, frames);
3035         default:
3036                 return -EINVAL;
3037         }
3038 }
3039 EXPORT_SYMBOL(snd_pcm_kernel_ioctl);
3040
3041 static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count,
3042                             loff_t * offset)
3043 {
3044         struct snd_pcm_file *pcm_file;
3045         struct snd_pcm_substream *substream;
3046         struct snd_pcm_runtime *runtime;
3047         snd_pcm_sframes_t result;
3048
3049         pcm_file = file->private_data;
3050         substream = pcm_file->substream;
3051         if (PCM_RUNTIME_CHECK(substream))
3052                 return -ENXIO;
3053         runtime = substream->runtime;
3054         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3055                 return -EBADFD;
3056         if (!frame_aligned(runtime, count))
3057                 return -EINVAL;
3058         count = bytes_to_frames(runtime, count);
3059         result = snd_pcm_lib_read(substream, buf, count);
3060         if (result > 0)
3061                 result = frames_to_bytes(runtime, result);
3062         return result;
3063 }
3064
3065 static ssize_t snd_pcm_write(struct file *file, const char __user *buf,
3066                              size_t count, loff_t * offset)
3067 {
3068         struct snd_pcm_file *pcm_file;
3069         struct snd_pcm_substream *substream;
3070         struct snd_pcm_runtime *runtime;
3071         snd_pcm_sframes_t result;
3072
3073         pcm_file = file->private_data;
3074         substream = pcm_file->substream;
3075         if (PCM_RUNTIME_CHECK(substream))
3076                 return -ENXIO;
3077         runtime = substream->runtime;
3078         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3079                 return -EBADFD;
3080         if (!frame_aligned(runtime, count))
3081                 return -EINVAL;
3082         count = bytes_to_frames(runtime, count);
3083         result = snd_pcm_lib_write(substream, buf, count);
3084         if (result > 0)
3085                 result = frames_to_bytes(runtime, result);
3086         return result;
3087 }
3088
3089 static ssize_t snd_pcm_readv(struct kiocb *iocb, struct iov_iter *to)
3090 {
3091         struct snd_pcm_file *pcm_file;
3092         struct snd_pcm_substream *substream;
3093         struct snd_pcm_runtime *runtime;
3094         snd_pcm_sframes_t result;
3095         unsigned long i;
3096         void __user **bufs;
3097         snd_pcm_uframes_t frames;
3098
3099         pcm_file = iocb->ki_filp->private_data;
3100         substream = pcm_file->substream;
3101         if (PCM_RUNTIME_CHECK(substream))
3102                 return -ENXIO;
3103         runtime = substream->runtime;
3104         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3105                 return -EBADFD;
3106         if (!iter_is_iovec(to))
3107                 return -EINVAL;
3108         if (to->nr_segs > 1024 || to->nr_segs != runtime->channels)
3109                 return -EINVAL;
3110         if (!frame_aligned(runtime, to->iov->iov_len))
3111                 return -EINVAL;
3112         frames = bytes_to_samples(runtime, to->iov->iov_len);
3113         bufs = kmalloc_array(to->nr_segs, sizeof(void *), GFP_KERNEL);
3114         if (bufs == NULL)
3115                 return -ENOMEM;
3116         for (i = 0; i < to->nr_segs; ++i)
3117                 bufs[i] = to->iov[i].iov_base;
3118         result = snd_pcm_lib_readv(substream, bufs, frames);
3119         if (result > 0)
3120                 result = frames_to_bytes(runtime, result);
3121         kfree(bufs);
3122         return result;
3123 }
3124
3125 static ssize_t snd_pcm_writev(struct kiocb *iocb, struct iov_iter *from)
3126 {
3127         struct snd_pcm_file *pcm_file;
3128         struct snd_pcm_substream *substream;
3129         struct snd_pcm_runtime *runtime;
3130         snd_pcm_sframes_t result;
3131         unsigned long i;
3132         void __user **bufs;
3133         snd_pcm_uframes_t frames;
3134
3135         pcm_file = iocb->ki_filp->private_data;
3136         substream = pcm_file->substream;
3137         if (PCM_RUNTIME_CHECK(substream))
3138                 return -ENXIO;
3139         runtime = substream->runtime;
3140         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3141                 return -EBADFD;
3142         if (!iter_is_iovec(from))
3143                 return -EINVAL;
3144         if (from->nr_segs > 128 || from->nr_segs != runtime->channels ||
3145             !frame_aligned(runtime, from->iov->iov_len))
3146                 return -EINVAL;
3147         frames = bytes_to_samples(runtime, from->iov->iov_len);
3148         bufs = kmalloc_array(from->nr_segs, sizeof(void *), GFP_KERNEL);
3149         if (bufs == NULL)
3150                 return -ENOMEM;
3151         for (i = 0; i < from->nr_segs; ++i)
3152                 bufs[i] = from->iov[i].iov_base;
3153         result = snd_pcm_lib_writev(substream, bufs, frames);
3154         if (result > 0)
3155                 result = frames_to_bytes(runtime, result);
3156         kfree(bufs);
3157         return result;
3158 }
3159
3160 static __poll_t snd_pcm_poll(struct file *file, poll_table *wait)
3161 {
3162         struct snd_pcm_file *pcm_file;
3163         struct snd_pcm_substream *substream;
3164         struct snd_pcm_runtime *runtime;
3165         __poll_t mask, ok;
3166         snd_pcm_uframes_t avail;
3167
3168         pcm_file = file->private_data;
3169
3170         substream = pcm_file->substream;
3171         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
3172                 ok = EPOLLOUT | EPOLLWRNORM;
3173         else
3174                 ok = EPOLLIN | EPOLLRDNORM;
3175         if (PCM_RUNTIME_CHECK(substream))
3176                 return ok | EPOLLERR;
3177
3178         runtime = substream->runtime;
3179         poll_wait(file, &runtime->sleep, wait);
3180
3181         mask = 0;
3182         snd_pcm_stream_lock_irq(substream);
3183         avail = snd_pcm_avail(substream);
3184         switch (runtime->status->state) {
3185         case SNDRV_PCM_STATE_RUNNING:
3186         case SNDRV_PCM_STATE_PREPARED:
3187         case SNDRV_PCM_STATE_PAUSED:
3188                 if (avail >= runtime->control->avail_min)
3189                         mask = ok;
3190                 break;
3191         case SNDRV_PCM_STATE_DRAINING:
3192                 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
3193                         mask = ok;
3194                         if (!avail)
3195                                 mask |= EPOLLERR;
3196                 }
3197                 break;
3198         default:
3199                 mask = ok | EPOLLERR;
3200                 break;
3201         }
3202         snd_pcm_stream_unlock_irq(substream);
3203         return mask;
3204 }
3205
3206 /*
3207  * mmap support
3208  */
3209
3210 /*
3211  * Only on coherent architectures, we can mmap the status and the control records
3212  * for effcient data transfer.  On others, we have to use HWSYNC ioctl...
3213  */
3214 #if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA)
3215 /*
3216  * mmap status record
3217  */
3218 static vm_fault_t snd_pcm_mmap_status_fault(struct vm_fault *vmf)
3219 {
3220         struct snd_pcm_substream *substream = vmf->vma->vm_private_data;
3221         struct snd_pcm_runtime *runtime;
3222         
3223         if (substream == NULL)
3224                 return VM_FAULT_SIGBUS;
3225         runtime = substream->runtime;
3226         vmf->page = virt_to_page(runtime->status);
3227         get_page(vmf->page);
3228         return 0;
3229 }
3230
3231 static const struct vm_operations_struct snd_pcm_vm_ops_status =
3232 {
3233         .fault =        snd_pcm_mmap_status_fault,
3234 };
3235
3236 static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file,
3237                                struct vm_area_struct *area)
3238 {