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