Root/sound/core/pcm_native.c

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

Archive Download this file



interactive