CoCalc -- pcm_native.c

GitHub Repository: awilliam/linux-vfio
Path: blob/master/sound/core/pcm_native.c
¹⁰⁸¹⁴ views
1
/*
2
 *  Digital Audio (PCM) abstract layer
3
 *  Copyright (c) by Jaroslav Kysela <[email protected]>
4
 *
5
 *
6
 *   This program is free software; you can redistribute it and/or modify
7
 *   it under the terms of the GNU General Public License as published by
8
 *   the Free Software Foundation; either version 2 of the License, or
9
 *   (at your option) any later version.
10
 *
11
 *   This program is distributed in the hope that it will be useful,
12
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 *   GNU General Public License for more details.
15
 *
16
 *   You should have received a copy of the GNU General Public License
17
 *   along with this program; if not, write to the Free Software
18
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19
 *
20
 */
21

22
#include <linux/mm.h>
23
#include <linux/file.h>
24
#include <linux/slab.h>
25
#include <linux/time.h>
26
#include <linux/pm_qos_params.h>
27
#include <linux/uio.h>
28
#include <linux/dma-mapping.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
#if defined(CONFIG_MIPS) && defined(CONFIG_DMA_NONCOHERENT)
38
#include <dma-coherence.h>
39
#endif
40

41
/*
42
 *  Compatibility
43
 */
44

45
struct snd_pcm_hw_params_old {
46
	unsigned int flags;
47
	unsigned int masks[SNDRV_PCM_HW_PARAM_SUBFORMAT -
48
			   SNDRV_PCM_HW_PARAM_ACCESS + 1];
49
	struct snd_interval intervals[SNDRV_PCM_HW_PARAM_TICK_TIME -
50
					SNDRV_PCM_HW_PARAM_SAMPLE_BITS + 1];
51
	unsigned int rmask;
52
	unsigned int cmask;
53
	unsigned int info;
54
	unsigned int msbits;
55
	unsigned int rate_num;
56
	unsigned int rate_den;
57
	snd_pcm_uframes_t fifo_size;
58
	unsigned char reserved[64];
59
};
60

61
#ifdef CONFIG_SND_SUPPORT_OLD_API
62
#define SNDRV_PCM_IOCTL_HW_REFINE_OLD _IOWR('A', 0x10, struct snd_pcm_hw_params_old)
63
#define SNDRV_PCM_IOCTL_HW_PARAMS_OLD _IOWR('A', 0x11, struct snd_pcm_hw_params_old)
64

65
static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream,
66
				      struct snd_pcm_hw_params_old __user * _oparams);
67
static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream,
68
				      struct snd_pcm_hw_params_old __user * _oparams);
69
#endif
70
static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream);
71

72
/*
73
 *
74
 */
75

76
DEFINE_RWLOCK(snd_pcm_link_rwlock);
77
EXPORT_SYMBOL(snd_pcm_link_rwlock);
78

79
static DECLARE_RWSEM(snd_pcm_link_rwsem);
80

81
static inline mm_segment_t snd_enter_user(void)
82
{
83
	mm_segment_t fs = get_fs();
84
	set_fs(get_ds());
85
	return fs;
86
}
87

88
static inline void snd_leave_user(mm_segment_t fs)
89
{
90
	set_fs(fs);
91
}
92

93

94

95
int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info)
96
{
97
	struct snd_pcm_runtime *runtime;
98
	struct snd_pcm *pcm = substream->pcm;
99
	struct snd_pcm_str *pstr = substream->pstr;
100

101
	memset(info, 0, sizeof(*info));
102
	info->card = pcm->card->number;
103
	info->device = pcm->device;
104
	info->stream = substream->stream;
105
	info->subdevice = substream->number;
106
	strlcpy(info->id, pcm->id, sizeof(info->id));
107
	strlcpy(info->name, pcm->name, sizeof(info->name));
108
	info->dev_class = pcm->dev_class;
109
	info->dev_subclass = pcm->dev_subclass;
110
	info->subdevices_count = pstr->substream_count;
111
	info->subdevices_avail = pstr->substream_count - pstr->substream_opened;
112
	strlcpy(info->subname, substream->name, sizeof(info->subname));
113
	runtime = substream->runtime;
114
	/* AB: FIXME!!! This is definitely nonsense */
115
	if (runtime) {
116
		info->sync = runtime->sync;
117
		substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_INFO, info);
118
	}
119
	return 0;
120
}
121

122
int snd_pcm_info_user(struct snd_pcm_substream *substream,
123
		      struct snd_pcm_info __user * _info)
124
{
125
	struct snd_pcm_info *info;
126
	int err;
127

128
	info = kmalloc(sizeof(*info), GFP_KERNEL);
129
	if (! info)
130
		return -ENOMEM;
131
	err = snd_pcm_info(substream, info);
132
	if (err >= 0) {
133
		if (copy_to_user(_info, info, sizeof(*info)))
134
			err = -EFAULT;
135
	}
136
	kfree(info);
137
	return err;
138
}
139

140
#undef RULES_DEBUG
141

142
#ifdef RULES_DEBUG
143
#define HW_PARAM(v) [SNDRV_PCM_HW_PARAM_##v] = #v
144
static const char * const snd_pcm_hw_param_names[] = {
145
	HW_PARAM(ACCESS),
146
	HW_PARAM(FORMAT),
147
	HW_PARAM(SUBFORMAT),
148
	HW_PARAM(SAMPLE_BITS),
149
	HW_PARAM(FRAME_BITS),
150
	HW_PARAM(CHANNELS),
151
	HW_PARAM(RATE),
152
	HW_PARAM(PERIOD_TIME),
153
	HW_PARAM(PERIOD_SIZE),
154
	HW_PARAM(PERIOD_BYTES),
155
	HW_PARAM(PERIODS),
156
	HW_PARAM(BUFFER_TIME),
157
	HW_PARAM(BUFFER_SIZE),
158
	HW_PARAM(BUFFER_BYTES),
159
	HW_PARAM(TICK_TIME),
160
};
161
#endif
162

163
int snd_pcm_hw_refine(struct snd_pcm_substream *substream, 
164
		      struct snd_pcm_hw_params *params)
165
{
166
	unsigned int k;
167
	struct snd_pcm_hardware *hw;
168
	struct snd_interval *i = NULL;
169
	struct snd_mask *m = NULL;
170
	struct snd_pcm_hw_constraints *constrs = &substream->runtime->hw_constraints;
171
	unsigned int rstamps[constrs->rules_num];
172
	unsigned int vstamps[SNDRV_PCM_HW_PARAM_LAST_INTERVAL + 1];
173
	unsigned int stamp = 2;
174
	int changed, again;
175

176
	params->info = 0;
177
	params->fifo_size = 0;
178
	if (params->rmask & (1 << SNDRV_PCM_HW_PARAM_SAMPLE_BITS))
179
		params->msbits = 0;
180
	if (params->rmask & (1 << SNDRV_PCM_HW_PARAM_RATE)) {
181
		params->rate_num = 0;
182
		params->rate_den = 0;
183
	}
184

185
	for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++) {
186
		m = hw_param_mask(params, k);
187
		if (snd_mask_empty(m))
188
			return -EINVAL;
189
		if (!(params->rmask & (1 << k)))
190
			continue;
191
#ifdef RULES_DEBUG
192
		printk(KERN_DEBUG "%s = ", snd_pcm_hw_param_names[k]);
193
		printk("%04x%04x%04x%04x -> ", m->bits[3], m->bits[2], m->bits[1], m->bits[0]);
194
#endif
195
		changed = snd_mask_refine(m, constrs_mask(constrs, k));
196
#ifdef RULES_DEBUG
197
		printk("%04x%04x%04x%04x\n", m->bits[3], m->bits[2], m->bits[1], m->bits[0]);
198
#endif
199
		if (changed)
200
			params->cmask |= 1 << k;
201
		if (changed < 0)
202
			return changed;
203
	}
204

205
	for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++) {
206
		i = hw_param_interval(params, k);
207
		if (snd_interval_empty(i))
208
			return -EINVAL;
209
		if (!(params->rmask & (1 << k)))
210
			continue;
211
#ifdef RULES_DEBUG
212
		printk(KERN_DEBUG "%s = ", snd_pcm_hw_param_names[k]);
213
		if (i->empty)
214
			printk("empty");
215
		else
216
			printk("%c%u %u%c", 
217
			       i->openmin ? '(' : '[', i->min,
218
			       i->max, i->openmax ? ')' : ']');
219
		printk(" -> ");
220
#endif
221
		changed = snd_interval_refine(i, constrs_interval(constrs, k));
222
#ifdef RULES_DEBUG
223
		if (i->empty)
224
			printk("empty\n");
225
		else 
226
			printk("%c%u %u%c\n", 
227
			       i->openmin ? '(' : '[', i->min,
228
			       i->max, i->openmax ? ')' : ']');
229
#endif
230
		if (changed)
231
			params->cmask |= 1 << k;
232
		if (changed < 0)
233
			return changed;
234
	}
235

236
	for (k = 0; k < constrs->rules_num; k++)
237
		rstamps[k] = 0;
238
	for (k = 0; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++) 
239
		vstamps[k] = (params->rmask & (1 << k)) ? 1 : 0;
240
	do {
241
		again = 0;
242
		for (k = 0; k < constrs->rules_num; k++) {
243
			struct snd_pcm_hw_rule *r = &constrs->rules[k];
244
			unsigned int d;
245
			int doit = 0;
246
			if (r->cond && !(r->cond & params->flags))
247
				continue;
248
			for (d = 0; r->deps[d] >= 0; d++) {
249
				if (vstamps[r->deps[d]] > rstamps[k]) {
250
					doit = 1;
251
					break;
252
				}
253
			}
254
			if (!doit)
255
				continue;
256
#ifdef RULES_DEBUG
257
			printk(KERN_DEBUG "Rule %d [%p]: ", k, r->func);
258
			if (r->var >= 0) {
259
				printk("%s = ", snd_pcm_hw_param_names[r->var]);
260
				if (hw_is_mask(r->var)) {
261
					m = hw_param_mask(params, r->var);
262
					printk("%x", *m->bits);
263
				} else {
264
					i = hw_param_interval(params, r->var);
265
					if (i->empty)
266
						printk("empty");
267
					else
268
						printk("%c%u %u%c", 
269
						       i->openmin ? '(' : '[', i->min,
270
						       i->max, i->openmax ? ')' : ']');
271
				}
272
			}
273
#endif
274
			changed = r->func(params, r);
275
#ifdef RULES_DEBUG
276
			if (r->var >= 0) {
277
				printk(" -> ");
278
				if (hw_is_mask(r->var))
279
					printk("%x", *m->bits);
280
				else {
281
					if (i->empty)
282
						printk("empty");
283
					else
284
						printk("%c%u %u%c", 
285
						       i->openmin ? '(' : '[', i->min,
286
						       i->max, i->openmax ? ')' : ']');
287
				}
288
			}
289
			printk("\n");
290
#endif
291
			rstamps[k] = stamp;
292
			if (changed && r->var >= 0) {
293
				params->cmask |= (1 << r->var);
294
				vstamps[r->var] = stamp;
295
				again = 1;
296
			}
297
			if (changed < 0)
298
				return changed;
299
			stamp++;
300
		}
301
	} while (again);
302
	if (!params->msbits) {
303
		i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
304
		if (snd_interval_single(i))
305
			params->msbits = snd_interval_value(i);
306
	}
307

308
	if (!params->rate_den) {
309
		i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
310
		if (snd_interval_single(i)) {
311
			params->rate_num = snd_interval_value(i);
312
			params->rate_den = 1;
313
		}
314
	}
315

316
	hw = &substream->runtime->hw;
317
	if (!params->info)
318
		params->info = hw->info & ~SNDRV_PCM_INFO_FIFO_IN_FRAMES;
319
	if (!params->fifo_size) {
320
		m = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
321
		i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
322
		if (snd_mask_min(m) == snd_mask_max(m) &&
323
                    snd_interval_min(i) == snd_interval_max(i)) {
324
			changed = substream->ops->ioctl(substream,
325
					SNDRV_PCM_IOCTL1_FIFO_SIZE, params);
326
			if (changed < 0)
327
				return changed;
328
		}
329
	}
330
	params->rmask = 0;
331
	return 0;
332
}
333

334
EXPORT_SYMBOL(snd_pcm_hw_refine);
335

336
static int snd_pcm_hw_refine_user(struct snd_pcm_substream *substream,
337
				  struct snd_pcm_hw_params __user * _params)
338
{
339
	struct snd_pcm_hw_params *params;
340
	int err;
341

342
	params = memdup_user(_params, sizeof(*params));
343
	if (IS_ERR(params))
344
		return PTR_ERR(params);
345

346
	err = snd_pcm_hw_refine(substream, params);
347
	if (copy_to_user(_params, params, sizeof(*params))) {
348
		if (!err)
349
			err = -EFAULT;
350
	}
351

352
	kfree(params);
353
	return err;
354
}
355

356
static int period_to_usecs(struct snd_pcm_runtime *runtime)
357
{
358
	int usecs;
359

360
	if (! runtime->rate)
361
		return -1; /* invalid */
362

363
	/* take 75% of period time as the deadline */
364
	usecs = (750000 / runtime->rate) * runtime->period_size;
365
	usecs += ((750000 % runtime->rate) * runtime->period_size) /
366
		runtime->rate;
367

368
	return usecs;
369
}
370

371
static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
372
			     struct snd_pcm_hw_params *params)
373
{
374
	struct snd_pcm_runtime *runtime;
375
	int err, usecs;
376
	unsigned int bits;
377
	snd_pcm_uframes_t frames;
378

379
	if (PCM_RUNTIME_CHECK(substream))
380
		return -ENXIO;
381
	runtime = substream->runtime;
382
	snd_pcm_stream_lock_irq(substream);
383
	switch (runtime->status->state) {
384
	case SNDRV_PCM_STATE_OPEN:
385
	case SNDRV_PCM_STATE_SETUP:
386
	case SNDRV_PCM_STATE_PREPARED:
387
		break;
388
	default:
389
		snd_pcm_stream_unlock_irq(substream);
390
		return -EBADFD;
391
	}
392
	snd_pcm_stream_unlock_irq(substream);
393
#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
394
	if (!substream->oss.oss)
395
#endif
396
		if (atomic_read(&substream->mmap_count))
397
			return -EBADFD;
398

399
	params->rmask = ~0U;
400
	err = snd_pcm_hw_refine(substream, params);
401
	if (err < 0)
402
		goto _error;
403

404
	err = snd_pcm_hw_params_choose(substream, params);
405
	if (err < 0)
406
		goto _error;
407

408
	if (substream->ops->hw_params != NULL) {
409
		err = substream->ops->hw_params(substream, params);
410
		if (err < 0)
411
			goto _error;
412
	}
413

414
	runtime->access = params_access(params);
415
	runtime->format = params_format(params);
416
	runtime->subformat = params_subformat(params);
417
	runtime->channels = params_channels(params);
418
	runtime->rate = params_rate(params);
419
	runtime->period_size = params_period_size(params);
420
	runtime->periods = params_periods(params);
421
	runtime->buffer_size = params_buffer_size(params);
422
	runtime->info = params->info;
423
	runtime->rate_num = params->rate_num;
424
	runtime->rate_den = params->rate_den;
425
	runtime->no_period_wakeup =
426
			(params->info & SNDRV_PCM_INFO_NO_PERIOD_WAKEUP) &&
427
			(params->flags & SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP);
428

429
	bits = snd_pcm_format_physical_width(runtime->format);
430
	runtime->sample_bits = bits;
431
	bits *= runtime->channels;
432
	runtime->frame_bits = bits;
433
	frames = 1;
434
	while (bits % 8 != 0) {
435
		bits *= 2;
436
		frames *= 2;
437
	}
438
	runtime->byte_align = bits / 8;
439
	runtime->min_align = frames;
440

441
	/* Default sw params */
442
	runtime->tstamp_mode = SNDRV_PCM_TSTAMP_NONE;
443
	runtime->period_step = 1;
444
	runtime->control->avail_min = runtime->period_size;
445
	runtime->start_threshold = 1;
446
	runtime->stop_threshold = runtime->buffer_size;
447
	runtime->silence_threshold = 0;
448
	runtime->silence_size = 0;
449
	runtime->boundary = runtime->buffer_size;
450
	while (runtime->boundary * 2 <= LONG_MAX - runtime->buffer_size)
451
		runtime->boundary *= 2;
452

453
	snd_pcm_timer_resolution_change(substream);
454
	runtime->status->state = SNDRV_PCM_STATE_SETUP;
455

456
	if (pm_qos_request_active(&substream->latency_pm_qos_req))
457
		pm_qos_remove_request(&substream->latency_pm_qos_req);
458
	if ((usecs = period_to_usecs(runtime)) >= 0)
459
		pm_qos_add_request(&substream->latency_pm_qos_req,
460
				   PM_QOS_CPU_DMA_LATENCY, usecs);
461
	return 0;
462
 _error:
463
	/* hardware might be unusable from this time,
464
	   so we force application to retry to set
465
	   the correct hardware parameter settings */
466
	runtime->status->state = SNDRV_PCM_STATE_OPEN;
467
	if (substream->ops->hw_free != NULL)
468
		substream->ops->hw_free(substream);
469
	return err;
470
}
471

472
static int snd_pcm_hw_params_user(struct snd_pcm_substream *substream,
473
				  struct snd_pcm_hw_params __user * _params)
474
{
475
	struct snd_pcm_hw_params *params;
476
	int err;
477

478
	params = memdup_user(_params, sizeof(*params));
479
	if (IS_ERR(params))
480
		return PTR_ERR(params);
481

482
	err = snd_pcm_hw_params(substream, params);
483
	if (copy_to_user(_params, params, sizeof(*params))) {
484
		if (!err)
485
			err = -EFAULT;
486
	}
487

488
	kfree(params);
489
	return err;
490
}
491

492
static int snd_pcm_hw_free(struct snd_pcm_substream *substream)
493
{
494
	struct snd_pcm_runtime *runtime;
495
	int result = 0;
496

497
	if (PCM_RUNTIME_CHECK(substream))
498
		return -ENXIO;
499
	runtime = substream->runtime;
500
	snd_pcm_stream_lock_irq(substream);
501
	switch (runtime->status->state) {
502
	case SNDRV_PCM_STATE_SETUP:
503
	case SNDRV_PCM_STATE_PREPARED:
504
		break;
505
	default:
506
		snd_pcm_stream_unlock_irq(substream);
507
		return -EBADFD;
508
	}
509
	snd_pcm_stream_unlock_irq(substream);
510
	if (atomic_read(&substream->mmap_count))
511
		return -EBADFD;
512
	if (substream->ops->hw_free)
513
		result = substream->ops->hw_free(substream);
514
	runtime->status->state = SNDRV_PCM_STATE_OPEN;
515
	pm_qos_remove_request(&substream->latency_pm_qos_req);
516
	return result;
517
}
518

519
static int snd_pcm_sw_params(struct snd_pcm_substream *substream,
520
			     struct snd_pcm_sw_params *params)
521
{
522
	struct snd_pcm_runtime *runtime;
523
	int err;
524

525
	if (PCM_RUNTIME_CHECK(substream))
526
		return -ENXIO;
527
	runtime = substream->runtime;
528
	snd_pcm_stream_lock_irq(substream);
529
	if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
530
		snd_pcm_stream_unlock_irq(substream);
531
		return -EBADFD;
532
	}
533
	snd_pcm_stream_unlock_irq(substream);
534

535
	if (params->tstamp_mode > SNDRV_PCM_TSTAMP_LAST)
536
		return -EINVAL;
537
	if (params->avail_min == 0)
538
		return -EINVAL;
539
	if (params->silence_size >= runtime->boundary) {
540
		if (params->silence_threshold != 0)
541
			return -EINVAL;
542
	} else {
543
		if (params->silence_size > params->silence_threshold)
544
			return -EINVAL;
545
		if (params->silence_threshold > runtime->buffer_size)
546
			return -EINVAL;
547
	}
548
	err = 0;
549
	snd_pcm_stream_lock_irq(substream);
550
	runtime->tstamp_mode = params->tstamp_mode;
551
	runtime->period_step = params->period_step;
552
	runtime->control->avail_min = params->avail_min;
553
	runtime->start_threshold = params->start_threshold;
554
	runtime->stop_threshold = params->stop_threshold;
555
	runtime->silence_threshold = params->silence_threshold;
556
	runtime->silence_size = params->silence_size;
557
        params->boundary = runtime->boundary;
558
	if (snd_pcm_running(substream)) {
559
		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
560
		    runtime->silence_size > 0)
561
			snd_pcm_playback_silence(substream, ULONG_MAX);
562
		err = snd_pcm_update_state(substream, runtime);
563
	}
564
	snd_pcm_stream_unlock_irq(substream);
565
	return err;
566
}
567

568
static int snd_pcm_sw_params_user(struct snd_pcm_substream *substream,
569
				  struct snd_pcm_sw_params __user * _params)
570
{
571
	struct snd_pcm_sw_params params;
572
	int err;
573
	if (copy_from_user(&params, _params, sizeof(params)))
574
		return -EFAULT;
575
	err = snd_pcm_sw_params(substream, &params);
576
	if (copy_to_user(_params, &params, sizeof(params)))
577
		return -EFAULT;
578
	return err;
579
}
580

581
int snd_pcm_status(struct snd_pcm_substream *substream,
582
		   struct snd_pcm_status *status)
583
{
584
	struct snd_pcm_runtime *runtime = substream->runtime;
585

586
	snd_pcm_stream_lock_irq(substream);
587
	status->state = runtime->status->state;
588
	status->suspended_state = runtime->status->suspended_state;
589
	if (status->state == SNDRV_PCM_STATE_OPEN)
590
		goto _end;
591
	status->trigger_tstamp = runtime->trigger_tstamp;
592
	if (snd_pcm_running(substream)) {
593
		snd_pcm_update_hw_ptr(substream);
594
		if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE) {
595
			status->tstamp = runtime->status->tstamp;
596
			goto _tstamp_end;
597
		}
598
	}
599
	snd_pcm_gettime(runtime, &status->tstamp);
600
 _tstamp_end:
601
	status->appl_ptr = runtime->control->appl_ptr;
602
	status->hw_ptr = runtime->status->hw_ptr;
603
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
604
		status->avail = snd_pcm_playback_avail(runtime);
605
		if (runtime->status->state == SNDRV_PCM_STATE_RUNNING ||
606
		    runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
607
			status->delay = runtime->buffer_size - status->avail;
608
			status->delay += runtime->delay;
609
		} else
610
			status->delay = 0;
611
	} else {
612
		status->avail = snd_pcm_capture_avail(runtime);
613
		if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
614
			status->delay = status->avail + runtime->delay;
615
		else
616
			status->delay = 0;
617
	}
618
	status->avail_max = runtime->avail_max;
619
	status->overrange = runtime->overrange;
620
	runtime->avail_max = 0;
621
	runtime->overrange = 0;
622
 _end:
623
 	snd_pcm_stream_unlock_irq(substream);
624
	return 0;
625
}
626

627
static int snd_pcm_status_user(struct snd_pcm_substream *substream,
628
			       struct snd_pcm_status __user * _status)
629
{
630
	struct snd_pcm_status status;
631
	int res;
632
	
633
	memset(&status, 0, sizeof(status));
634
	res = snd_pcm_status(substream, &status);
635
	if (res < 0)
636
		return res;
637
	if (copy_to_user(_status, &status, sizeof(status)))
638
		return -EFAULT;
639
	return 0;
640
}
641

642
static int snd_pcm_channel_info(struct snd_pcm_substream *substream,
643
				struct snd_pcm_channel_info * info)
644
{
645
	struct snd_pcm_runtime *runtime;
646
	unsigned int channel;
647
	
648
	channel = info->channel;
649
	runtime = substream->runtime;
650
	snd_pcm_stream_lock_irq(substream);
651
	if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
652
		snd_pcm_stream_unlock_irq(substream);
653
		return -EBADFD;
654
	}
655
	snd_pcm_stream_unlock_irq(substream);
656
	if (channel >= runtime->channels)
657
		return -EINVAL;
658
	memset(info, 0, sizeof(*info));
659
	info->channel = channel;
660
	return substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_CHANNEL_INFO, info);
661
}
662

663
static int snd_pcm_channel_info_user(struct snd_pcm_substream *substream,
664
				     struct snd_pcm_channel_info __user * _info)
665
{
666
	struct snd_pcm_channel_info info;
667
	int res;
668
	
669
	if (copy_from_user(&info, _info, sizeof(info)))
670
		return -EFAULT;
671
	res = snd_pcm_channel_info(substream, &info);
672
	if (res < 0)
673
		return res;
674
	if (copy_to_user(_info, &info, sizeof(info)))
675
		return -EFAULT;
676
	return 0;
677
}
678

679
static void snd_pcm_trigger_tstamp(struct snd_pcm_substream *substream)
680
{
681
	struct snd_pcm_runtime *runtime = substream->runtime;
682
	if (runtime->trigger_master == NULL)
683
		return;
684
	if (runtime->trigger_master == substream) {
685
		snd_pcm_gettime(runtime, &runtime->trigger_tstamp);
686
	} else {
687
		snd_pcm_trigger_tstamp(runtime->trigger_master);
688
		runtime->trigger_tstamp = runtime->trigger_master->runtime->trigger_tstamp;
689
	}
690
	runtime->trigger_master = NULL;
691
}
692

693
struct action_ops {
694
	int (*pre_action)(struct snd_pcm_substream *substream, int state);
695
	int (*do_action)(struct snd_pcm_substream *substream, int state);
696
	void (*undo_action)(struct snd_pcm_substream *substream, int state);
697
	void (*post_action)(struct snd_pcm_substream *substream, int state);
698
};
699

700
/*
701
 *  this functions is core for handling of linked stream
702
 *  Note: the stream state might be changed also on failure
703
 *  Note2: call with calling stream lock + link lock
704
 */
705
static int snd_pcm_action_group(struct action_ops *ops,
706
				struct snd_pcm_substream *substream,
707
				int state, int do_lock)
708
{
709
	struct snd_pcm_substream *s = NULL;
710
	struct snd_pcm_substream *s1;
711
	int res = 0;
712

713
	snd_pcm_group_for_each_entry(s, substream) {
714
		if (do_lock && s != substream)
715
			spin_lock_nested(&s->self_group.lock,
716
					 SINGLE_DEPTH_NESTING);
717
		res = ops->pre_action(s, state);
718
		if (res < 0)
719
			goto _unlock;
720
	}
721
	snd_pcm_group_for_each_entry(s, substream) {
722
		res = ops->do_action(s, state);
723
		if (res < 0) {
724
			if (ops->undo_action) {
725
				snd_pcm_group_for_each_entry(s1, substream) {
726
					if (s1 == s) /* failed stream */
727
						break;
728
					ops->undo_action(s1, state);
729
				}
730
			}
731
			s = NULL; /* unlock all */
732
			goto _unlock;
733
		}
734
	}
735
	snd_pcm_group_for_each_entry(s, substream) {
736
		ops->post_action(s, state);
737
	}
738
 _unlock:
739
	if (do_lock) {
740
		/* unlock streams */
741
		snd_pcm_group_for_each_entry(s1, substream) {
742
			if (s1 != substream)
743
				spin_unlock(&s1->self_group.lock);
744
			if (s1 == s)	/* end */
745
				break;
746
		}
747
	}
748
	return res;
749
}
750

751
/*
752
 *  Note: call with stream lock
753
 */
754
static int snd_pcm_action_single(struct action_ops *ops,
755
				 struct snd_pcm_substream *substream,
756
				 int state)
757
{
758
	int res;
759
	
760
	res = ops->pre_action(substream, state);
761
	if (res < 0)
762
		return res;
763
	res = ops->do_action(substream, state);
764
	if (res == 0)
765
		ops->post_action(substream, state);
766
	else if (ops->undo_action)
767
		ops->undo_action(substream, state);
768
	return res;
769
}
770

771
/*
772
 *  Note: call with stream lock
773
 */
774
static int snd_pcm_action(struct action_ops *ops,
775
			  struct snd_pcm_substream *substream,
776
			  int state)
777
{
778
	int res;
779

780
	if (snd_pcm_stream_linked(substream)) {
781
		if (!spin_trylock(&substream->group->lock)) {
782
			spin_unlock(&substream->self_group.lock);
783
			spin_lock(&substream->group->lock);
784
			spin_lock(&substream->self_group.lock);
785
		}
786
		res = snd_pcm_action_group(ops, substream, state, 1);
787
		spin_unlock(&substream->group->lock);
788
	} else {
789
		res = snd_pcm_action_single(ops, substream, state);
790
	}
791
	return res;
792
}
793

794
/*
795
 *  Note: don't use any locks before
796
 */
797
static int snd_pcm_action_lock_irq(struct action_ops *ops,
798
				   struct snd_pcm_substream *substream,
799
				   int state)
800
{
801
	int res;
802

803
	read_lock_irq(&snd_pcm_link_rwlock);
804
	if (snd_pcm_stream_linked(substream)) {
805
		spin_lock(&substream->group->lock);
806
		spin_lock(&substream->self_group.lock);
807
		res = snd_pcm_action_group(ops, substream, state, 1);
808
		spin_unlock(&substream->self_group.lock);
809
		spin_unlock(&substream->group->lock);
810
	} else {
811
		spin_lock(&substream->self_group.lock);
812
		res = snd_pcm_action_single(ops, substream, state);
813
		spin_unlock(&substream->self_group.lock);
814
	}
815
	read_unlock_irq(&snd_pcm_link_rwlock);
816
	return res;
817
}
818

819
/*
820
 */
821
static int snd_pcm_action_nonatomic(struct action_ops *ops,
822
				    struct snd_pcm_substream *substream,
823
				    int state)
824
{
825
	int res;
826

827
	down_read(&snd_pcm_link_rwsem);
828
	if (snd_pcm_stream_linked(substream))
829
		res = snd_pcm_action_group(ops, substream, state, 0);
830
	else
831
		res = snd_pcm_action_single(ops, substream, state);
832
	up_read(&snd_pcm_link_rwsem);
833
	return res;
834
}
835

836
/*
837
 * start callbacks
838
 */
839
static int snd_pcm_pre_start(struct snd_pcm_substream *substream, int state)
840
{
841
	struct snd_pcm_runtime *runtime = substream->runtime;
842
	if (runtime->status->state != SNDRV_PCM_STATE_PREPARED)
843
		return -EBADFD;
844
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
845
	    !snd_pcm_playback_data(substream))
846
		return -EPIPE;
847
	runtime->trigger_master = substream;
848
	return 0;
849
}
850

851
static int snd_pcm_do_start(struct snd_pcm_substream *substream, int state)
852
{
853
	if (substream->runtime->trigger_master != substream)
854
		return 0;
855
	return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_START);
856
}
857

858
static void snd_pcm_undo_start(struct snd_pcm_substream *substream, int state)
859
{
860
	if (substream->runtime->trigger_master == substream)
861
		substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_STOP);
862
}
863

864
static void snd_pcm_post_start(struct snd_pcm_substream *substream, int state)
865
{
866
	struct snd_pcm_runtime *runtime = substream->runtime;
867
	snd_pcm_trigger_tstamp(substream);
868
	runtime->hw_ptr_jiffies = jiffies;
869
	runtime->hw_ptr_buffer_jiffies = (runtime->buffer_size * HZ) / 
870
							    runtime->rate;
871
	runtime->status->state = state;
872
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
873
	    runtime->silence_size > 0)
874
		snd_pcm_playback_silence(substream, ULONG_MAX);
875
	if (substream->timer)
876
		snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTART,
877
				 &runtime->trigger_tstamp);
878
}
879

880
static struct action_ops snd_pcm_action_start = {
881
	.pre_action = snd_pcm_pre_start,
882
	.do_action = snd_pcm_do_start,
883
	.undo_action = snd_pcm_undo_start,
884
	.post_action = snd_pcm_post_start
885
};
886

887
/**
888
 * snd_pcm_start - start all linked streams
889
 * @substream: the PCM substream instance
890
 */
891
int snd_pcm_start(struct snd_pcm_substream *substream)
892
{
893
	return snd_pcm_action(&snd_pcm_action_start, substream,
894
			      SNDRV_PCM_STATE_RUNNING);
895
}
896

897
/*
898
 * stop callbacks
899
 */
900
static int snd_pcm_pre_stop(struct snd_pcm_substream *substream, int state)
901
{
902
	struct snd_pcm_runtime *runtime = substream->runtime;
903
	if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
904
		return -EBADFD;
905
	runtime->trigger_master = substream;
906
	return 0;
907
}
908

909
static int snd_pcm_do_stop(struct snd_pcm_substream *substream, int state)
910
{
911
	if (substream->runtime->trigger_master == substream &&
912
	    snd_pcm_running(substream))
913
		substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_STOP);
914
	return 0; /* unconditonally stop all substreams */
915
}
916

917
static void snd_pcm_post_stop(struct snd_pcm_substream *substream, int state)
918
{
919
	struct snd_pcm_runtime *runtime = substream->runtime;
920
	if (runtime->status->state != state) {
921
		snd_pcm_trigger_tstamp(substream);
922
		if (substream->timer)
923
			snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTOP,
924
					 &runtime->trigger_tstamp);
925
		runtime->status->state = state;
926
	}
927
	wake_up(&runtime->sleep);
928
	wake_up(&runtime->tsleep);
929
}
930

931
static struct action_ops snd_pcm_action_stop = {
932
	.pre_action = snd_pcm_pre_stop,
933
	.do_action = snd_pcm_do_stop,
934
	.post_action = snd_pcm_post_stop
935
};
936

937
/**
938
 * snd_pcm_stop - try to stop all running streams in the substream group
939
 * @substream: the PCM substream instance
940
 * @state: PCM state after stopping the stream
941
 *
942
 * The state of each stream is then changed to the given state unconditionally.
943
 */
944
int snd_pcm_stop(struct snd_pcm_substream *substream, snd_pcm_state_t state)
945
{
946
	return snd_pcm_action(&snd_pcm_action_stop, substream, state);
947
}
948

949
EXPORT_SYMBOL(snd_pcm_stop);
950

951
/**
952
 * snd_pcm_drain_done - stop the DMA only when the given stream is playback
953
 * @substream: the PCM substream
954
 *
955
 * After stopping, the state is changed to SETUP.
956
 * Unlike snd_pcm_stop(), this affects only the given stream.
957
 */
958
int snd_pcm_drain_done(struct snd_pcm_substream *substream)
959
{
960
	return snd_pcm_action_single(&snd_pcm_action_stop, substream,
961
				     SNDRV_PCM_STATE_SETUP);
962
}
963

964
/*
965
 * pause callbacks
966
 */
967
static int snd_pcm_pre_pause(struct snd_pcm_substream *substream, int push)
968
{
969
	struct snd_pcm_runtime *runtime = substream->runtime;
970
	if (!(runtime->info & SNDRV_PCM_INFO_PAUSE))
971
		return -ENOSYS;
972
	if (push) {
973
		if (runtime->status->state != SNDRV_PCM_STATE_RUNNING)
974
			return -EBADFD;
975
	} else if (runtime->status->state != SNDRV_PCM_STATE_PAUSED)
976
		return -EBADFD;
977
	runtime->trigger_master = substream;
978
	return 0;
979
}
980

981
static int snd_pcm_do_pause(struct snd_pcm_substream *substream, int push)
982
{
983
	if (substream->runtime->trigger_master != substream)
984
		return 0;
985
	/* some drivers might use hw_ptr to recover from the pause -
986
	   update the hw_ptr now */
987
	if (push)
988
		snd_pcm_update_hw_ptr(substream);
989
	/* The jiffies check in snd_pcm_update_hw_ptr*() is done by
990
	 * a delta between the current jiffies, this gives a large enough
991
	 * delta, effectively to skip the check once.
992
	 */
993
	substream->runtime->hw_ptr_jiffies = jiffies - HZ * 1000;
994
	return substream->ops->trigger(substream,
995
				       push ? SNDRV_PCM_TRIGGER_PAUSE_PUSH :
996
					      SNDRV_PCM_TRIGGER_PAUSE_RELEASE);
997
}
998

999
static void snd_pcm_undo_pause(struct snd_pcm_substream *substream, int push)
1000
{
1001
	if (substream->runtime->trigger_master == substream)
1002
		substream->ops->trigger(substream,
1003
					push ? SNDRV_PCM_TRIGGER_PAUSE_RELEASE :
1004
					SNDRV_PCM_TRIGGER_PAUSE_PUSH);
1005
}
1006

1007
static void snd_pcm_post_pause(struct snd_pcm_substream *substream, int push)
1008
{
1009
	struct snd_pcm_runtime *runtime = substream->runtime;
1010
	snd_pcm_trigger_tstamp(substream);
1011
	if (push) {
1012
		runtime->status->state = SNDRV_PCM_STATE_PAUSED;
1013
		if (substream->timer)
1014
			snd_timer_notify(substream->timer,
1015
					 SNDRV_TIMER_EVENT_MPAUSE,
1016
					 &runtime->trigger_tstamp);
1017
		wake_up(&runtime->sleep);
1018
		wake_up(&runtime->tsleep);
1019
	} else {
1020
		runtime->status->state = SNDRV_PCM_STATE_RUNNING;
1021
		if (substream->timer)
1022
			snd_timer_notify(substream->timer,
1023
					 SNDRV_TIMER_EVENT_MCONTINUE,
1024
					 &runtime->trigger_tstamp);
1025
	}
1026
}
1027

1028
static struct action_ops snd_pcm_action_pause = {
1029
	.pre_action = snd_pcm_pre_pause,
1030
	.do_action = snd_pcm_do_pause,
1031
	.undo_action = snd_pcm_undo_pause,
1032
	.post_action = snd_pcm_post_pause
1033
};
1034

1035
/*
1036
 * Push/release the pause for all linked streams.
1037
 */
1038
static int snd_pcm_pause(struct snd_pcm_substream *substream, int push)
1039
{
1040
	return snd_pcm_action(&snd_pcm_action_pause, substream, push);
1041
}
1042

1043
#ifdef CONFIG_PM
1044
/* suspend */
1045

1046
static int snd_pcm_pre_suspend(struct snd_pcm_substream *substream, int state)
1047
{
1048
	struct snd_pcm_runtime *runtime = substream->runtime;
1049
	if (runtime->status->state == SNDRV_PCM_STATE_SUSPENDED)
1050
		return -EBUSY;
1051
	runtime->trigger_master = substream;
1052
	return 0;
1053
}
1054

1055
static int snd_pcm_do_suspend(struct snd_pcm_substream *substream, int state)
1056
{
1057
	struct snd_pcm_runtime *runtime = substream->runtime;
1058
	if (runtime->trigger_master != substream)
1059
		return 0;
1060
	if (! snd_pcm_running(substream))
1061
		return 0;
1062
	substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_SUSPEND);
1063
	return 0; /* suspend unconditionally */
1064
}
1065

1066
static void snd_pcm_post_suspend(struct snd_pcm_substream *substream, int state)
1067
{
1068
	struct snd_pcm_runtime *runtime = substream->runtime;
1069
	snd_pcm_trigger_tstamp(substream);
1070
	if (substream->timer)
1071
		snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSUSPEND,
1072
				 &runtime->trigger_tstamp);
1073
	runtime->status->suspended_state = runtime->status->state;
1074
	runtime->status->state = SNDRV_PCM_STATE_SUSPENDED;
1075
	wake_up(&runtime->sleep);
1076
	wake_up(&runtime->tsleep);
1077
}
1078

1079
static struct action_ops snd_pcm_action_suspend = {
1080
	.pre_action = snd_pcm_pre_suspend,
1081
	.do_action = snd_pcm_do_suspend,
1082
	.post_action = snd_pcm_post_suspend
1083
};
1084

1085
/**
1086
 * snd_pcm_suspend - trigger SUSPEND to all linked streams
1087
 * @substream: the PCM substream
1088
 *
1089
 * After this call, all streams are changed to SUSPENDED state.
1090
 */
1091
int snd_pcm_suspend(struct snd_pcm_substream *substream)
1092
{
1093
	int err;
1094
	unsigned long flags;
1095

1096
	if (! substream)
1097
		return 0;
1098

1099
	snd_pcm_stream_lock_irqsave(substream, flags);
1100
	err = snd_pcm_action(&snd_pcm_action_suspend, substream, 0);
1101
	snd_pcm_stream_unlock_irqrestore(substream, flags);
1102
	return err;
1103
}
1104

1105
EXPORT_SYMBOL(snd_pcm_suspend);
1106

1107
/**
1108
 * snd_pcm_suspend_all - trigger SUSPEND to all substreams in the given pcm
1109
 * @pcm: the PCM instance
1110
 *
1111
 * After this call, all streams are changed to SUSPENDED state.
1112
 */
1113
int snd_pcm_suspend_all(struct snd_pcm *pcm)
1114
{
1115
	struct snd_pcm_substream *substream;
1116
	int stream, err = 0;
1117

1118
	if (! pcm)
1119
		return 0;
1120

1121
	for (stream = 0; stream < 2; stream++) {
1122
		for (substream = pcm->streams[stream].substream;
1123
		     substream; substream = substream->next) {
1124
			/* FIXME: the open/close code should lock this as well */
1125
			if (substream->runtime == NULL)
1126
				continue;
1127
			err = snd_pcm_suspend(substream);
1128
			if (err < 0 && err != -EBUSY)
1129
				return err;
1130
		}
1131
	}
1132
	return 0;
1133
}
1134

1135
EXPORT_SYMBOL(snd_pcm_suspend_all);
1136

1137
/* resume */
1138

1139
static int snd_pcm_pre_resume(struct snd_pcm_substream *substream, int state)
1140
{
1141
	struct snd_pcm_runtime *runtime = substream->runtime;
1142
	if (!(runtime->info & SNDRV_PCM_INFO_RESUME))
1143
		return -ENOSYS;
1144
	runtime->trigger_master = substream;
1145
	return 0;
1146
}
1147

1148
static int snd_pcm_do_resume(struct snd_pcm_substream *substream, int state)
1149
{
1150
	struct snd_pcm_runtime *runtime = substream->runtime;
1151
	if (runtime->trigger_master != substream)
1152
		return 0;
1153
	/* DMA not running previously? */
1154
	if (runtime->status->suspended_state != SNDRV_PCM_STATE_RUNNING &&
1155
	    (runtime->status->suspended_state != SNDRV_PCM_STATE_DRAINING ||
1156
	     substream->stream != SNDRV_PCM_STREAM_PLAYBACK))
1157
		return 0;
1158
	return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_RESUME);
1159
}
1160

1161
static void snd_pcm_undo_resume(struct snd_pcm_substream *substream, int state)
1162
{
1163
	if (substream->runtime->trigger_master == substream &&
1164
	    snd_pcm_running(substream))
1165
		substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_SUSPEND);
1166
}
1167

1168
static void snd_pcm_post_resume(struct snd_pcm_substream *substream, int state)
1169
{
1170
	struct snd_pcm_runtime *runtime = substream->runtime;
1171
	snd_pcm_trigger_tstamp(substream);
1172
	if (substream->timer)
1173
		snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MRESUME,
1174
				 &runtime->trigger_tstamp);
1175
	runtime->status->state = runtime->status->suspended_state;
1176
}
1177

1178
static struct action_ops snd_pcm_action_resume = {
1179
	.pre_action = snd_pcm_pre_resume,
1180
	.do_action = snd_pcm_do_resume,
1181
	.undo_action = snd_pcm_undo_resume,
1182
	.post_action = snd_pcm_post_resume
1183
};
1184

1185
static int snd_pcm_resume(struct snd_pcm_substream *substream)
1186
{
1187
	struct snd_card *card = substream->pcm->card;
1188
	int res;
1189

1190
	snd_power_lock(card);
1191
	if ((res = snd_power_wait(card, SNDRV_CTL_POWER_D0)) >= 0)
1192
		res = snd_pcm_action_lock_irq(&snd_pcm_action_resume, substream, 0);
1193
	snd_power_unlock(card);
1194
	return res;
1195
}
1196

1197
#else
1198

1199
static int snd_pcm_resume(struct snd_pcm_substream *substream)
1200
{
1201
	return -ENOSYS;
1202
}
1203

1204
#endif /* CONFIG_PM */
1205

1206
/*
1207
 * xrun ioctl
1208
 *
1209
 * Change the RUNNING stream(s) to XRUN state.
1210
 */
1211
static int snd_pcm_xrun(struct snd_pcm_substream *substream)
1212
{
1213
	struct snd_card *card = substream->pcm->card;
1214
	struct snd_pcm_runtime *runtime = substream->runtime;
1215
	int result;
1216

1217
	snd_power_lock(card);
1218
	if (runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
1219
		result = snd_power_wait(card, SNDRV_CTL_POWER_D0);
1220
		if (result < 0)
1221
			goto _unlock;
1222
	}
1223

1224
	snd_pcm_stream_lock_irq(substream);
1225
	switch (runtime->status->state) {
1226
	case SNDRV_PCM_STATE_XRUN:
1227
		result = 0;	/* already there */
1228
		break;
1229
	case SNDRV_PCM_STATE_RUNNING:
1230
		result = snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
1231
		break;
1232
	default:
1233
		result = -EBADFD;
1234
	}
1235
	snd_pcm_stream_unlock_irq(substream);
1236
 _unlock:
1237
	snd_power_unlock(card);
1238
	return result;
1239
}
1240

1241
/*
1242
 * reset ioctl
1243
 */
1244
static int snd_pcm_pre_reset(struct snd_pcm_substream *substream, int state)
1245
{
1246
	struct snd_pcm_runtime *runtime = substream->runtime;
1247
	switch (runtime->status->state) {
1248
	case SNDRV_PCM_STATE_RUNNING:
1249
	case SNDRV_PCM_STATE_PREPARED:
1250
	case SNDRV_PCM_STATE_PAUSED:
1251
	case SNDRV_PCM_STATE_SUSPENDED:
1252
		return 0;
1253
	default:
1254
		return -EBADFD;
1255
	}
1256
}
1257

1258
static int snd_pcm_do_reset(struct snd_pcm_substream *substream, int state)
1259
{
1260
	struct snd_pcm_runtime *runtime = substream->runtime;
1261
	int err = substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_RESET, NULL);
1262
	if (err < 0)
1263
		return err;
1264
	runtime->hw_ptr_base = 0;
1265
	runtime->hw_ptr_interrupt = runtime->status->hw_ptr -
1266
		runtime->status->hw_ptr % runtime->period_size;
1267
	runtime->silence_start = runtime->status->hw_ptr;
1268
	runtime->silence_filled = 0;
1269
	return 0;
1270
}
1271

1272
static void snd_pcm_post_reset(struct snd_pcm_substream *substream, int state)
1273
{
1274
	struct snd_pcm_runtime *runtime = substream->runtime;
1275
	runtime->control->appl_ptr = runtime->status->hw_ptr;
1276
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
1277
	    runtime->silence_size > 0)
1278
		snd_pcm_playback_silence(substream, ULONG_MAX);
1279
}
1280

1281
static struct action_ops snd_pcm_action_reset = {
1282
	.pre_action = snd_pcm_pre_reset,
1283
	.do_action = snd_pcm_do_reset,
1284
	.post_action = snd_pcm_post_reset
1285
};
1286

1287
static int snd_pcm_reset(struct snd_pcm_substream *substream)
1288
{
1289
	return snd_pcm_action_nonatomic(&snd_pcm_action_reset, substream, 0);
1290
}
1291

1292
/*
1293
 * prepare ioctl
1294
 */
1295
/* we use the second argument for updating f_flags */
1296
static int snd_pcm_pre_prepare(struct snd_pcm_substream *substream,
1297
			       int f_flags)
1298
{
1299
	struct snd_pcm_runtime *runtime = substream->runtime;
1300
	if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
1301
	    runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
1302
		return -EBADFD;
1303
	if (snd_pcm_running(substream))
1304
		return -EBUSY;
1305
	substream->f_flags = f_flags;
1306
	return 0;
1307
}
1308

1309
static int snd_pcm_do_prepare(struct snd_pcm_substream *substream, int state)
1310
{
1311
	int err;
1312
	err = substream->ops->prepare(substream);
1313
	if (err < 0)
1314
		return err;
1315
	return snd_pcm_do_reset(substream, 0);
1316
}
1317

1318
static void snd_pcm_post_prepare(struct snd_pcm_substream *substream, int state)
1319
{
1320
	struct snd_pcm_runtime *runtime = substream->runtime;
1321
	runtime->control->appl_ptr = runtime->status->hw_ptr;
1322
	runtime->status->state = SNDRV_PCM_STATE_PREPARED;
1323
}
1324

1325
static struct action_ops snd_pcm_action_prepare = {
1326
	.pre_action = snd_pcm_pre_prepare,
1327
	.do_action = snd_pcm_do_prepare,
1328
	.post_action = snd_pcm_post_prepare
1329
};
1330

1331
/**
1332
 * snd_pcm_prepare - prepare the PCM substream to be triggerable
1333
 * @substream: the PCM substream instance
1334
 * @file: file to refer f_flags
1335
 */
1336
static int snd_pcm_prepare(struct snd_pcm_substream *substream,
1337
			   struct file *file)
1338
{
1339
	int res;
1340
	struct snd_card *card = substream->pcm->card;
1341
	int f_flags;
1342

1343
	if (file)
1344
		f_flags = file->f_flags;
1345
	else
1346
		f_flags = substream->f_flags;
1347

1348
	snd_power_lock(card);
1349
	if ((res = snd_power_wait(card, SNDRV_CTL_POWER_D0)) >= 0)
1350
		res = snd_pcm_action_nonatomic(&snd_pcm_action_prepare,
1351
					       substream, f_flags);
1352
	snd_power_unlock(card);
1353
	return res;
1354
}
1355

1356
/*
1357
 * drain ioctl
1358
 */
1359

1360
static int snd_pcm_pre_drain_init(struct snd_pcm_substream *substream, int state)
1361
{
1362
	substream->runtime->trigger_master = substream;
1363
	return 0;
1364
}
1365

1366
static int snd_pcm_do_drain_init(struct snd_pcm_substream *substream, int state)
1367
{
1368
	struct snd_pcm_runtime *runtime = substream->runtime;
1369
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1370
		switch (runtime->status->state) {
1371
		case SNDRV_PCM_STATE_PREPARED:
1372
			/* start playback stream if possible */
1373
			if (! snd_pcm_playback_empty(substream)) {
1374
				snd_pcm_do_start(substream, SNDRV_PCM_STATE_DRAINING);
1375
				snd_pcm_post_start(substream, SNDRV_PCM_STATE_DRAINING);
1376
			}
1377
			break;
1378
		case SNDRV_PCM_STATE_RUNNING:
1379
			runtime->status->state = SNDRV_PCM_STATE_DRAINING;
1380
			break;
1381
		default:
1382
			break;
1383
		}
1384
	} else {
1385
		/* stop running stream */
1386
		if (runtime->status->state == SNDRV_PCM_STATE_RUNNING) {
1387
			int new_state = snd_pcm_capture_avail(runtime) > 0 ?
1388
				SNDRV_PCM_STATE_DRAINING : SNDRV_PCM_STATE_SETUP;
1389
			snd_pcm_do_stop(substream, new_state);
1390
			snd_pcm_post_stop(substream, new_state);
1391
		}
1392
	}
1393
	return 0;
1394
}
1395

1396
static void snd_pcm_post_drain_init(struct snd_pcm_substream *substream, int state)
1397
{
1398
}
1399

1400
static struct action_ops snd_pcm_action_drain_init = {
1401
	.pre_action = snd_pcm_pre_drain_init,
1402
	.do_action = snd_pcm_do_drain_init,
1403
	.post_action = snd_pcm_post_drain_init
1404
};
1405

1406
static int snd_pcm_drop(struct snd_pcm_substream *substream);
1407

1408
/*
1409
 * Drain the stream(s).
1410
 * When the substream is linked, sync until the draining of all playback streams
1411
 * is finished.
1412
 * After this call, all streams are supposed to be either SETUP or DRAINING
1413
 * (capture only) state.
1414
 */
1415
static int snd_pcm_drain(struct snd_pcm_substream *substream,
1416
			 struct file *file)
1417
{
1418
	struct snd_card *card;
1419
	struct snd_pcm_runtime *runtime;
1420
	struct snd_pcm_substream *s;
1421
	wait_queue_t wait;
1422
	int result = 0;
1423
	int nonblock = 0;
1424

1425
	card = substream->pcm->card;
1426
	runtime = substream->runtime;
1427

1428
	if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
1429
		return -EBADFD;
1430

1431
	snd_power_lock(card);
1432
	if (runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
1433
		result = snd_power_wait(card, SNDRV_CTL_POWER_D0);
1434
		if (result < 0) {
1435
			snd_power_unlock(card);
1436
			return result;
1437
		}
1438
	}
1439

1440
	if (file) {
1441
		if (file->f_flags & O_NONBLOCK)
1442
			nonblock = 1;
1443
	} else if (substream->f_flags & O_NONBLOCK)
1444
		nonblock = 1;
1445

1446
	down_read(&snd_pcm_link_rwsem);
1447
	snd_pcm_stream_lock_irq(substream);
1448
	/* resume pause */
1449
	if (runtime->status->state == SNDRV_PCM_STATE_PAUSED)
1450
		snd_pcm_pause(substream, 0);
1451

1452
	/* pre-start/stop - all running streams are changed to DRAINING state */
1453
	result = snd_pcm_action(&snd_pcm_action_drain_init, substream, 0);
1454
	if (result < 0)
1455
		goto unlock;
1456
	/* in non-blocking, we don't wait in ioctl but let caller poll */
1457
	if (nonblock) {
1458
		result = -EAGAIN;
1459
		goto unlock;
1460
	}
1461

1462
	for (;;) {
1463
		long tout;
1464
		struct snd_pcm_runtime *to_check;
1465
		if (signal_pending(current)) {
1466
			result = -ERESTARTSYS;
1467
			break;
1468
		}
1469
		/* find a substream to drain */
1470
		to_check = NULL;
1471
		snd_pcm_group_for_each_entry(s, substream) {
1472
			if (s->stream != SNDRV_PCM_STREAM_PLAYBACK)
1473
				continue;
1474
			runtime = s->runtime;
1475
			if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
1476
				to_check = runtime;
1477
				break;
1478
			}
1479
		}
1480
		if (!to_check)
1481
			break; /* all drained */
1482
		init_waitqueue_entry(&wait, current);
1483
		add_wait_queue(&to_check->sleep, &wait);
1484
		snd_pcm_stream_unlock_irq(substream);
1485
		up_read(&snd_pcm_link_rwsem);
1486
		snd_power_unlock(card);
1487
		if (runtime->no_period_wakeup)
1488
			tout = MAX_SCHEDULE_TIMEOUT;
1489
		else {
1490
			tout = 10;
1491
			if (runtime->rate) {
1492
				long t = runtime->period_size * 2 / runtime->rate;
1493
				tout = max(t, tout);
1494
			}
1495
			tout = msecs_to_jiffies(tout * 1000);
1496
		}
1497
		tout = schedule_timeout_interruptible(tout);
1498
		snd_power_lock(card);
1499
		down_read(&snd_pcm_link_rwsem);
1500
		snd_pcm_stream_lock_irq(substream);
1501
		remove_wait_queue(&to_check->sleep, &wait);
1502
		if (tout == 0) {
1503
			if (substream->runtime->status->state == SNDRV_PCM_STATE_SUSPENDED)
1504
				result = -ESTRPIPE;
1505
			else {
1506
				snd_printd("playback drain error (DMA or IRQ trouble?)\n");
1507
				snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
1508
				result = -EIO;
1509
			}
1510
			break;
1511
		}
1512
	}
1513

1514
 unlock:
1515
	snd_pcm_stream_unlock_irq(substream);
1516
	up_read(&snd_pcm_link_rwsem);
1517
	snd_power_unlock(card);
1518

1519
	return result;
1520
}
1521

1522
/*
1523
 * drop ioctl
1524
 *
1525
 * Immediately put all linked substreams into SETUP state.
1526
 */
1527
static int snd_pcm_drop(struct snd_pcm_substream *substream)
1528
{
1529
	struct snd_pcm_runtime *runtime;
1530
	int result = 0;
1531
	
1532
	if (PCM_RUNTIME_CHECK(substream))
1533
		return -ENXIO;
1534
	runtime = substream->runtime;
1535

1536
	if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
1537
	    runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED ||
1538
	    runtime->status->state == SNDRV_PCM_STATE_SUSPENDED)
1539
		return -EBADFD;
1540

1541
	snd_pcm_stream_lock_irq(substream);
1542
	/* resume pause */
1543
	if (runtime->status->state == SNDRV_PCM_STATE_PAUSED)
1544
		snd_pcm_pause(substream, 0);
1545

1546
	snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
1547
	/* runtime->control->appl_ptr = runtime->status->hw_ptr; */
1548
	snd_pcm_stream_unlock_irq(substream);
1549

1550
	return result;
1551
}
1552

1553

1554
/* WARNING: Don't forget to fput back the file */
1555
static struct file *snd_pcm_file_fd(int fd)
1556
{
1557
	struct file *file;
1558
	struct inode *inode;
1559
	unsigned int minor;
1560

1561
	file = fget(fd);
1562
	if (!file)
1563
		return NULL;
1564
	inode = file->f_path.dentry->d_inode;
1565
	if (!S_ISCHR(inode->i_mode) ||
1566
	    imajor(inode) != snd_major) {
1567
		fput(file);
1568
		return NULL;
1569
	}
1570
	minor = iminor(inode);
1571
	if (!snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_PLAYBACK) &&
1572
	    !snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_CAPTURE)) {
1573
		fput(file);
1574
		return NULL;
1575
	}
1576
	return file;
1577
}
1578

1579
/*
1580
 * PCM link handling
1581
 */
1582
static int snd_pcm_link(struct snd_pcm_substream *substream, int fd)
1583
{
1584
	int res = 0;
1585
	struct file *file;
1586
	struct snd_pcm_file *pcm_file;
1587
	struct snd_pcm_substream *substream1;
1588

1589
	file = snd_pcm_file_fd(fd);
1590
	if (!file)
1591
		return -EBADFD;
1592
	pcm_file = file->private_data;
1593
	substream1 = pcm_file->substream;
1594
	down_write(&snd_pcm_link_rwsem);
1595
	write_lock_irq(&snd_pcm_link_rwlock);
1596
	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN ||
1597
	    substream->runtime->status->state != substream1->runtime->status->state) {
1598
		res = -EBADFD;
1599
		goto _end;
1600
	}
1601
	if (snd_pcm_stream_linked(substream1)) {
1602
		res = -EALREADY;
1603
		goto _end;
1604
	}
1605
	if (!snd_pcm_stream_linked(substream)) {
1606
		substream->group = kmalloc(sizeof(struct snd_pcm_group), GFP_ATOMIC);
1607
		if (substream->group == NULL) {
1608
			res = -ENOMEM;
1609
			goto _end;
1610
		}
1611
		spin_lock_init(&substream->group->lock);
1612
		INIT_LIST_HEAD(&substream->group->substreams);
1613
		list_add_tail(&substream->link_list, &substream->group->substreams);
1614
		substream->group->count = 1;
1615
	}
1616
	list_add_tail(&substream1->link_list, &substream->group->substreams);
1617
	substream->group->count++;
1618
	substream1->group = substream->group;
1619
 _end:
1620
	write_unlock_irq(&snd_pcm_link_rwlock);
1621
	up_write(&snd_pcm_link_rwsem);
1622
	fput(file);
1623
	return res;
1624
}
1625

1626
static void relink_to_local(struct snd_pcm_substream *substream)
1627
{
1628
	substream->group = &substream->self_group;
1629
	INIT_LIST_HEAD(&substream->self_group.substreams);
1630
	list_add_tail(&substream->link_list, &substream->self_group.substreams);
1631
}
1632

1633
static int snd_pcm_unlink(struct snd_pcm_substream *substream)
1634
{
1635
	struct snd_pcm_substream *s;
1636
	int res = 0;
1637

1638
	down_write(&snd_pcm_link_rwsem);
1639
	write_lock_irq(&snd_pcm_link_rwlock);
1640
	if (!snd_pcm_stream_linked(substream)) {
1641
		res = -EALREADY;
1642
		goto _end;
1643
	}
1644
	list_del(&substream->link_list);
1645
	substream->group->count--;
1646
	if (substream->group->count == 1) {	/* detach the last stream, too */
1647
		snd_pcm_group_for_each_entry(s, substream) {
1648
			relink_to_local(s);
1649
			break;
1650
		}
1651
		kfree(substream->group);
1652
	}
1653
	relink_to_local(substream);
1654
       _end:
1655
	write_unlock_irq(&snd_pcm_link_rwlock);
1656
	up_write(&snd_pcm_link_rwsem);
1657
	return res;
1658
}
1659

1660
/*
1661
 * hw configurator
1662
 */
1663
static int snd_pcm_hw_rule_mul(struct snd_pcm_hw_params *params,
1664
			       struct snd_pcm_hw_rule *rule)
1665
{
1666
	struct snd_interval t;
1667
	snd_interval_mul(hw_param_interval_c(params, rule->deps[0]),
1668
		     hw_param_interval_c(params, rule->deps[1]), &t);
1669
	return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1670
}
1671

1672
static int snd_pcm_hw_rule_div(struct snd_pcm_hw_params *params,
1673
			       struct snd_pcm_hw_rule *rule)
1674
{
1675
	struct snd_interval t;
1676
	snd_interval_div(hw_param_interval_c(params, rule->deps[0]),
1677
		     hw_param_interval_c(params, rule->deps[1]), &t);
1678
	return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1679
}
1680

1681
static int snd_pcm_hw_rule_muldivk(struct snd_pcm_hw_params *params,
1682
				   struct snd_pcm_hw_rule *rule)
1683
{
1684
	struct snd_interval t;
1685
	snd_interval_muldivk(hw_param_interval_c(params, rule->deps[0]),
1686
			 hw_param_interval_c(params, rule->deps[1]),
1687
			 (unsigned long) rule->private, &t);
1688
	return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1689
}
1690

1691
static int snd_pcm_hw_rule_mulkdiv(struct snd_pcm_hw_params *params,
1692
				   struct snd_pcm_hw_rule *rule)
1693
{
1694
	struct snd_interval t;
1695
	snd_interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]),
1696
			 (unsigned long) rule->private,
1697
			 hw_param_interval_c(params, rule->deps[1]), &t);
1698
	return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1699
}
1700

1701
static int snd_pcm_hw_rule_format(struct snd_pcm_hw_params *params,
1702
				  struct snd_pcm_hw_rule *rule)
1703
{
1704
	unsigned int k;
1705
	struct snd_interval *i = hw_param_interval(params, rule->deps[0]);
1706
	struct snd_mask m;
1707
	struct snd_mask *mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
1708
	snd_mask_any(&m);
1709
	for (k = 0; k <= SNDRV_PCM_FORMAT_LAST; ++k) {
1710
		int bits;
1711
		if (! snd_mask_test(mask, k))
1712
			continue;
1713
		bits = snd_pcm_format_physical_width(k);
1714
		if (bits <= 0)
1715
			continue; /* ignore invalid formats */
1716
		if ((unsigned)bits < i->min || (unsigned)bits > i->max)
1717
			snd_mask_reset(&m, k);
1718
	}
1719
	return snd_mask_refine(mask, &m);
1720
}
1721

1722
static int snd_pcm_hw_rule_sample_bits(struct snd_pcm_hw_params *params,
1723
				       struct snd_pcm_hw_rule *rule)
1724
{
1725
	struct snd_interval t;
1726
	unsigned int k;
1727
	t.min = UINT_MAX;
1728
	t.max = 0;
1729
	t.openmin = 0;
1730
	t.openmax = 0;
1731
	for (k = 0; k <= SNDRV_PCM_FORMAT_LAST; ++k) {
1732
		int bits;
1733
		if (! snd_mask_test(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), k))
1734
			continue;
1735
		bits = snd_pcm_format_physical_width(k);
1736
		if (bits <= 0)
1737
			continue; /* ignore invalid formats */
1738
		if (t.min > (unsigned)bits)
1739
			t.min = bits;
1740
		if (t.max < (unsigned)bits)
1741
			t.max = bits;
1742
	}
1743
	t.integer = 1;
1744
	return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1745
}
1746

1747
#if SNDRV_PCM_RATE_5512 != 1 << 0 || SNDRV_PCM_RATE_192000 != 1 << 12
1748
#error "Change this table"
1749
#endif
1750

1751
static unsigned int rates[] = { 5512, 8000, 11025, 16000, 22050, 32000, 44100,
1752
                                 48000, 64000, 88200, 96000, 176400, 192000 };
1753

1754
const struct snd_pcm_hw_constraint_list snd_pcm_known_rates = {
1755
	.count = ARRAY_SIZE(rates),
1756
	.list = rates,
1757
};
1758

1759
static int snd_pcm_hw_rule_rate(struct snd_pcm_hw_params *params,
1760
				struct snd_pcm_hw_rule *rule)
1761
{
1762
	struct snd_pcm_hardware *hw = rule->private;
1763
	return snd_interval_list(hw_param_interval(params, rule->var),
1764
				 snd_pcm_known_rates.count,
1765
				 snd_pcm_known_rates.list, hw->rates);
1766
}		
1767

1768
static int snd_pcm_hw_rule_buffer_bytes_max(struct snd_pcm_hw_params *params,
1769
					    struct snd_pcm_hw_rule *rule)
1770
{
1771
	struct snd_interval t;
1772
	struct snd_pcm_substream *substream = rule->private;
1773
	t.min = 0;
1774
	t.max = substream->buffer_bytes_max;
1775
	t.openmin = 0;
1776
	t.openmax = 0;
1777
	t.integer = 1;
1778
	return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1779
}		
1780

1781
int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream)
1782
{
1783
	struct snd_pcm_runtime *runtime = substream->runtime;
1784
	struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1785
	int k, err;
1786

1787
	for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++) {
1788
		snd_mask_any(constrs_mask(constrs, k));
1789
	}
1790

1791
	for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++) {
1792
		snd_interval_any(constrs_interval(constrs, k));
1793
	}
1794

1795
	snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_CHANNELS));
1796
	snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_BUFFER_SIZE));
1797
	snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_BUFFER_BYTES));
1798
	snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_SAMPLE_BITS));
1799
	snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_FRAME_BITS));
1800

1801
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
1802
				   snd_pcm_hw_rule_format, NULL,
1803
				   SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
1804
	if (err < 0)
1805
		return err;
1806
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 
1807
				  snd_pcm_hw_rule_sample_bits, NULL,
1808
				  SNDRV_PCM_HW_PARAM_FORMAT, 
1809
				  SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
1810
	if (err < 0)
1811
		return err;
1812
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 
1813
				  snd_pcm_hw_rule_div, NULL,
1814
				  SNDRV_PCM_HW_PARAM_FRAME_BITS, SNDRV_PCM_HW_PARAM_CHANNELS, -1);
1815
	if (err < 0)
1816
		return err;
1817
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 
1818
				  snd_pcm_hw_rule_mul, NULL,
1819
				  SNDRV_PCM_HW_PARAM_SAMPLE_BITS, SNDRV_PCM_HW_PARAM_CHANNELS, -1);
1820
	if (err < 0)
1821
		return err;
1822
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 
1823
				  snd_pcm_hw_rule_mulkdiv, (void*) 8,
1824
				  SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);
1825
	if (err < 0)
1826
		return err;
1827
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 
1828
				  snd_pcm_hw_rule_mulkdiv, (void*) 8,
1829
				  SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, -1);
1830
	if (err < 0)
1831
		return err;
1832
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 
1833
				  snd_pcm_hw_rule_div, NULL,
1834
				  SNDRV_PCM_HW_PARAM_FRAME_BITS, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
1835
	if (err < 0)
1836
		return err;
1837
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 
1838
				  snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
1839
				  SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_PERIOD_TIME, -1);
1840
	if (err < 0)
1841
		return err;
1842
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 
1843
				  snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
1844
				  SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_BUFFER_TIME, -1);
1845
	if (err < 0)
1846
		return err;
1847
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS, 
1848
				  snd_pcm_hw_rule_div, NULL,
1849
				  SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);
1850
	if (err < 0)
1851
		return err;
1852
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 
1853
				  snd_pcm_hw_rule_div, NULL,
1854
				  SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_PERIODS, -1);
1855
	if (err < 0)
1856
		return err;
1857
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 
1858
				  snd_pcm_hw_rule_mulkdiv, (void*) 8,
1859
				  SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
1860
	if (err < 0)
1861
		return err;
1862
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 
1863
				  snd_pcm_hw_rule_muldivk, (void*) 1000000,
1864
				  SNDRV_PCM_HW_PARAM_PERIOD_TIME, SNDRV_PCM_HW_PARAM_RATE, -1);
1865
	if (err < 0)
1866
		return err;
1867
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 
1868
				  snd_pcm_hw_rule_mul, NULL,
1869
				  SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_PERIODS, -1);
1870
	if (err < 0)
1871
		return err;
1872
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 
1873
				  snd_pcm_hw_rule_mulkdiv, (void*) 8,
1874
				  SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
1875
	if (err < 0)
1876
		return err;
1877
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 
1878
				  snd_pcm_hw_rule_muldivk, (void*) 1000000,
1879
				  SNDRV_PCM_HW_PARAM_BUFFER_TIME, SNDRV_PCM_HW_PARAM_RATE, -1);
1880
	if (err < 0)
1881
		return err;
1882
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 
1883
				  snd_pcm_hw_rule_muldivk, (void*) 8,
1884
				  SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
1885
	if (err < 0)
1886
		return err;
1887
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 
1888
				  snd_pcm_hw_rule_muldivk, (void*) 8,
1889
				  SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
1890
	if (err < 0)
1891
		return err;
1892
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 
1893
				  snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
1894
				  SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_RATE, -1);
1895
	if (err < 0)
1896
		return err;
1897
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_TIME, 
1898
				  snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
1899
				  SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_RATE, -1);
1900
	if (err < 0)
1901
		return err;
1902
	return 0;
1903
}
1904

1905
int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
1906
{
1907
	struct snd_pcm_runtime *runtime = substream->runtime;
1908
	struct snd_pcm_hardware *hw = &runtime->hw;
1909
	int err;
1910
	unsigned int mask = 0;
1911

1912
        if (hw->info & SNDRV_PCM_INFO_INTERLEAVED)
1913
		mask |= 1 << SNDRV_PCM_ACCESS_RW_INTERLEAVED;
1914
        if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED)
1915
		mask |= 1 << SNDRV_PCM_ACCESS_RW_NONINTERLEAVED;
1916
	if (hw->info & SNDRV_PCM_INFO_MMAP) {
1917
		if (hw->info & SNDRV_PCM_INFO_INTERLEAVED)
1918
			mask |= 1 << SNDRV_PCM_ACCESS_MMAP_INTERLEAVED;
1919
		if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED)
1920
			mask |= 1 << SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED;
1921
		if (hw->info & SNDRV_PCM_INFO_COMPLEX)
1922
			mask |= 1 << SNDRV_PCM_ACCESS_MMAP_COMPLEX;
1923
	}
1924
	err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_ACCESS, mask);
1925
	if (err < 0)
1926
		return err;
1927

1928
	err = snd_pcm_hw_constraint_mask64(runtime, SNDRV_PCM_HW_PARAM_FORMAT, hw->formats);
1929
	if (err < 0)
1930
		return err;
1931

1932
	err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_SUBFORMAT, 1 << SNDRV_PCM_SUBFORMAT_STD);
1933
	if (err < 0)
1934
		return err;
1935

1936
	err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_CHANNELS,
1937
					   hw->channels_min, hw->channels_max);
1938
	if (err < 0)
1939
		return err;
1940

1941
	err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_RATE,
1942
					   hw->rate_min, hw->rate_max);
1943
	if (err < 0)
1944
		return err;
1945

1946
	err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
1947
					   hw->period_bytes_min, hw->period_bytes_max);
1948
	if (err < 0)
1949
		return err;
1950

1951
	err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIODS,
1952
					   hw->periods_min, hw->periods_max);
1953
	if (err < 0)
1954
		return err;
1955

1956
	err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
1957
					   hw->period_bytes_min, hw->buffer_bytes_max);
1958
	if (err < 0)
1959
		return err;
1960

1961
	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 
1962
				  snd_pcm_hw_rule_buffer_bytes_max, substream,
1963
				  SNDRV_PCM_HW_PARAM_BUFFER_BYTES, -1);
1964
	if (err < 0)
1965
		return err;
1966

1967
	/* FIXME: remove */
1968
	if (runtime->dma_bytes) {
1969
		err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, runtime->dma_bytes);
1970
		if (err < 0)
1971
			return -EINVAL;
1972
	}
1973

1974
	if (!(hw->rates & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))) {
1975
		err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 
1976
					  snd_pcm_hw_rule_rate, hw,
1977
					  SNDRV_PCM_HW_PARAM_RATE, -1);
1978
		if (err < 0)
1979
			return err;
1980
	}
1981

1982
	/* FIXME: this belong to lowlevel */
1983
	snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
1984

1985
	return 0;
1986
}
1987

1988
static void pcm_release_private(struct snd_pcm_substream *substream)
1989
{
1990
	snd_pcm_unlink(substream);
1991
}
1992

1993
void snd_pcm_release_substream(struct snd_pcm_substream *substream)
1994
{
1995
	substream->ref_count--;
1996
	if (substream->ref_count > 0)
1997
		return;
1998

1999
	snd_pcm_drop(substream);
2000
	if (substream->hw_opened) {
2001
		if (substream->ops->hw_free != NULL)
2002
			substream->ops->hw_free(substream);
2003
		substream->ops->close(substream);
2004
		substream->hw_opened = 0;
2005
	}
2006
	if (pm_qos_request_active(&substream->latency_pm_qos_req))
2007
		pm_qos_remove_request(&substream->latency_pm_qos_req);
2008
	if (substream->pcm_release) {
2009
		substream->pcm_release(substream);
2010
		substream->pcm_release = NULL;
2011
	}
2012
	snd_pcm_detach_substream(substream);
2013
}
2014

2015
EXPORT_SYMBOL(snd_pcm_release_substream);
2016

2017
int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
2018
			   struct file *file,
2019
			   struct snd_pcm_substream **rsubstream)
2020
{
2021
	struct snd_pcm_substream *substream;
2022
	int err;
2023

2024
	err = snd_pcm_attach_substream(pcm, stream, file, &substream);
2025
	if (err < 0)
2026
		return err;
2027
	if (substream->ref_count > 1) {
2028
		*rsubstream = substream;
2029
		return 0;
2030
	}
2031

2032
	err = snd_pcm_hw_constraints_init(substream);
2033
	if (err < 0) {
2034
		snd_printd("snd_pcm_hw_constraints_init failed\n");
2035
		goto error;
2036
	}
2037

2038
	if ((err = substream->ops->open(substream)) < 0)
2039
		goto error;
2040

2041
	substream->hw_opened = 1;
2042

2043
	err = snd_pcm_hw_constraints_complete(substream);
2044
	if (err < 0) {
2045
		snd_printd("snd_pcm_hw_constraints_complete failed\n");
2046
		goto error;
2047
	}
2048

2049
	*rsubstream = substream;
2050
	return 0;
2051

2052
 error:
2053
	snd_pcm_release_substream(substream);
2054
	return err;
2055
}
2056

2057
EXPORT_SYMBOL(snd_pcm_open_substream);
2058

2059
static int snd_pcm_open_file(struct file *file,
2060
			     struct snd_pcm *pcm,
2061
			     int stream,
2062
			     struct snd_pcm_file **rpcm_file)
2063
{
2064
	struct snd_pcm_file *pcm_file;
2065
	struct snd_pcm_substream *substream;
2066
	int err;
2067

2068
	if (rpcm_file)
2069
		*rpcm_file = NULL;
2070

2071
	err = snd_pcm_open_substream(pcm, stream, file, &substream);
2072
	if (err < 0)
2073
		return err;
2074

2075
	pcm_file = kzalloc(sizeof(*pcm_file), GFP_KERNEL);
2076
	if (pcm_file == NULL) {
2077
		snd_pcm_release_substream(substream);
2078
		return -ENOMEM;
2079
	}
2080
	pcm_file->substream = substream;
2081
	if (substream->ref_count == 1) {
2082
		substream->file = pcm_file;
2083
		substream->pcm_release = pcm_release_private;
2084
	}
2085
	file->private_data = pcm_file;
2086
	if (rpcm_file)
2087
		*rpcm_file = pcm_file;
2088
	return 0;
2089
}
2090

2091
static int snd_pcm_playback_open(struct inode *inode, struct file *file)
2092
{
2093
	struct snd_pcm *pcm;
2094
	int err = nonseekable_open(inode, file);
2095
	if (err < 0)
2096
		return err;
2097
	pcm = snd_lookup_minor_data(iminor(inode),
2098
				    SNDRV_DEVICE_TYPE_PCM_PLAYBACK);
2099
	return snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_PLAYBACK);
2100
}
2101

2102
static int snd_pcm_capture_open(struct inode *inode, struct file *file)
2103
{
2104
	struct snd_pcm *pcm;
2105
	int err = nonseekable_open(inode, file);
2106
	if (err < 0)
2107
		return err;
2108
	pcm = snd_lookup_minor_data(iminor(inode),
2109
				    SNDRV_DEVICE_TYPE_PCM_CAPTURE);
2110
	return snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_CAPTURE);
2111
}
2112

2113
static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream)
2114
{
2115
	int err;
2116
	struct snd_pcm_file *pcm_file;
2117
	wait_queue_t wait;
2118

2119
	if (pcm == NULL) {
2120
		err = -ENODEV;
2121
		goto __error1;
2122
	}
2123
	err = snd_card_file_add(pcm->card, file);
2124
	if (err < 0)
2125
		goto __error1;
2126
	if (!try_module_get(pcm->card->module)) {
2127
		err = -EFAULT;
2128
		goto __error2;
2129
	}
2130
	init_waitqueue_entry(&wait, current);
2131
	add_wait_queue(&pcm->open_wait, &wait);
2132
	mutex_lock(&pcm->open_mutex);
2133
	while (1) {
2134
		err = snd_pcm_open_file(file, pcm, stream, &pcm_file);
2135
		if (err >= 0)
2136
			break;
2137
		if (err == -EAGAIN) {
2138
			if (file->f_flags & O_NONBLOCK) {
2139
				err = -EBUSY;
2140
				break;
2141
			}
2142
		} else
2143
			break;
2144
		set_current_state(TASK_INTERRUPTIBLE);
2145
		mutex_unlock(&pcm->open_mutex);
2146
		schedule();
2147
		mutex_lock(&pcm->open_mutex);
2148
		if (signal_pending(current)) {
2149
			err = -ERESTARTSYS;
2150
			break;
2151
		}
2152
	}
2153
	remove_wait_queue(&pcm->open_wait, &wait);
2154
	mutex_unlock(&pcm->open_mutex);
2155
	if (err < 0)
2156
		goto __error;
2157
	return err;
2158

2159
      __error:
2160
	module_put(pcm->card->module);
2161
      __error2:
2162
      	snd_card_file_remove(pcm->card, file);
2163
      __error1:
2164
      	return err;
2165
}
2166

2167
static int snd_pcm_release(struct inode *inode, struct file *file)
2168
{
2169
	struct snd_pcm *pcm;
2170
	struct snd_pcm_substream *substream;
2171
	struct snd_pcm_file *pcm_file;
2172

2173
	pcm_file = file->private_data;
2174
	substream = pcm_file->substream;
2175
	if (snd_BUG_ON(!substream))
2176
		return -ENXIO;
2177
	pcm = substream->pcm;
2178
	mutex_lock(&pcm->open_mutex);
2179
	snd_pcm_release_substream(substream);
2180
	kfree(pcm_file);
2181
	mutex_unlock(&pcm->open_mutex);
2182
	wake_up(&pcm->open_wait);
2183
	module_put(pcm->card->module);
2184
	snd_card_file_remove(pcm->card, file);
2185
	return 0;
2186
}
2187

2188
static snd_pcm_sframes_t snd_pcm_playback_rewind(struct snd_pcm_substream *substream,
2189
						 snd_pcm_uframes_t frames)
2190
{
2191
	struct snd_pcm_runtime *runtime = substream->runtime;
2192
	snd_pcm_sframes_t appl_ptr;
2193
	snd_pcm_sframes_t ret;
2194
	snd_pcm_sframes_t hw_avail;
2195

2196
	if (frames == 0)
2197
		return 0;
2198

2199
	snd_pcm_stream_lock_irq(substream);
2200
	switch (runtime->status->state) {
2201
	case SNDRV_PCM_STATE_PREPARED:
2202
		break;
2203
	case SNDRV_PCM_STATE_DRAINING:
2204
	case SNDRV_PCM_STATE_RUNNING:
2205
		if (snd_pcm_update_hw_ptr(substream) >= 0)
2206
			break;
2207
		/* Fall through */
2208
	case SNDRV_PCM_STATE_XRUN:
2209
		ret = -EPIPE;
2210
		goto __end;
2211
	case SNDRV_PCM_STATE_SUSPENDED:
2212
		ret = -ESTRPIPE;
2213
		goto __end;
2214
	default:
2215
		ret = -EBADFD;
2216
		goto __end;
2217
	}
2218

2219
	hw_avail = snd_pcm_playback_hw_avail(runtime);
2220
	if (hw_avail <= 0) {
2221
		ret = 0;
2222
		goto __end;
2223
	}
2224
	if (frames > (snd_pcm_uframes_t)hw_avail)
2225
		frames = hw_avail;
2226
	appl_ptr = runtime->control->appl_ptr - frames;
2227
	if (appl_ptr < 0)
2228
		appl_ptr += runtime->boundary;
2229
	runtime->control->appl_ptr = appl_ptr;
2230
	ret = frames;
2231
 __end:
2232
	snd_pcm_stream_unlock_irq(substream);
2233
	return ret;
2234
}
2235

2236
static snd_pcm_sframes_t snd_pcm_capture_rewind(struct snd_pcm_substream *substream,
2237
						snd_pcm_uframes_t frames)
2238
{
2239
	struct snd_pcm_runtime *runtime = substream->runtime;
2240
	snd_pcm_sframes_t appl_ptr;
2241
	snd_pcm_sframes_t ret;
2242
	snd_pcm_sframes_t hw_avail;
2243

2244
	if (frames == 0)
2245
		return 0;
2246

2247
	snd_pcm_stream_lock_irq(substream);
2248
	switch (runtime->status->state) {
2249
	case SNDRV_PCM_STATE_PREPARED:
2250
	case SNDRV_PCM_STATE_DRAINING:
2251
		break;
2252
	case SNDRV_PCM_STATE_RUNNING:
2253
		if (snd_pcm_update_hw_ptr(substream) >= 0)
2254
			break;
2255
		/* Fall through */
2256
	case SNDRV_PCM_STATE_XRUN:
2257
		ret = -EPIPE;
2258
		goto __end;
2259
	case SNDRV_PCM_STATE_SUSPENDED:
2260
		ret = -ESTRPIPE;
2261
		goto __end;
2262
	default:
2263
		ret = -EBADFD;
2264
		goto __end;
2265
	}
2266

2267
	hw_avail = snd_pcm_capture_hw_avail(runtime);
2268
	if (hw_avail <= 0) {
2269
		ret = 0;
2270
		goto __end;
2271
	}
2272
	if (frames > (snd_pcm_uframes_t)hw_avail)
2273
		frames = hw_avail;
2274
	appl_ptr = runtime->control->appl_ptr - frames;
2275
	if (appl_ptr < 0)
2276
		appl_ptr += runtime->boundary;
2277
	runtime->control->appl_ptr = appl_ptr;
2278
	ret = frames;
2279
 __end:
2280
	snd_pcm_stream_unlock_irq(substream);
2281
	return ret;
2282
}
2283

2284
static snd_pcm_sframes_t snd_pcm_playback_forward(struct snd_pcm_substream *substream,
2285
						  snd_pcm_uframes_t frames)
2286
{
2287
	struct snd_pcm_runtime *runtime = substream->runtime;
2288
	snd_pcm_sframes_t appl_ptr;
2289
	snd_pcm_sframes_t ret;
2290
	snd_pcm_sframes_t avail;
2291

2292
	if (frames == 0)
2293
		return 0;
2294

2295
	snd_pcm_stream_lock_irq(substream);
2296
	switch (runtime->status->state) {
2297
	case SNDRV_PCM_STATE_PREPARED:
2298
	case SNDRV_PCM_STATE_PAUSED:
2299
		break;
2300
	case SNDRV_PCM_STATE_DRAINING:
2301
	case SNDRV_PCM_STATE_RUNNING:
2302
		if (snd_pcm_update_hw_ptr(substream) >= 0)
2303
			break;
2304
		/* Fall through */
2305
	case SNDRV_PCM_STATE_XRUN:
2306
		ret = -EPIPE;
2307
		goto __end;
2308
	case SNDRV_PCM_STATE_SUSPENDED:
2309
		ret = -ESTRPIPE;
2310
		goto __end;
2311
	default:
2312
		ret = -EBADFD;
2313
		goto __end;
2314
	}
2315

2316
	avail = snd_pcm_playback_avail(runtime);
2317
	if (avail <= 0) {
2318
		ret = 0;
2319
		goto __end;
2320
	}
2321
	if (frames > (snd_pcm_uframes_t)avail)
2322
		frames = avail;
2323
	appl_ptr = runtime->control->appl_ptr + frames;
2324
	if (appl_ptr >= (snd_pcm_sframes_t)runtime->boundary)
2325
		appl_ptr -= runtime->boundary;
2326
	runtime->control->appl_ptr = appl_ptr;
2327
	ret = frames;
2328
 __end:
2329
	snd_pcm_stream_unlock_irq(substream);
2330
	return ret;
2331
}
2332

2333
static snd_pcm_sframes_t snd_pcm_capture_forward(struct snd_pcm_substream *substream,
2334
						 snd_pcm_uframes_t frames)
2335
{
2336
	struct snd_pcm_runtime *runtime = substream->runtime;
2337
	snd_pcm_sframes_t appl_ptr;
2338
	snd_pcm_sframes_t ret;
2339
	snd_pcm_sframes_t avail;
2340

2341
	if (frames == 0)
2342
		return 0;
2343

2344
	snd_pcm_stream_lock_irq(substream);
2345
	switch (runtime->status->state) {
2346
	case SNDRV_PCM_STATE_PREPARED:
2347
	case SNDRV_PCM_STATE_DRAINING:
2348
	case SNDRV_PCM_STATE_PAUSED:
2349
		break;
2350
	case SNDRV_PCM_STATE_RUNNING:
2351
		if (snd_pcm_update_hw_ptr(substream) >= 0)
2352
			break;
2353
		/* Fall through */
2354
	case SNDRV_PCM_STATE_XRUN:
2355
		ret = -EPIPE;
2356
		goto __end;
2357
	case SNDRV_PCM_STATE_SUSPENDED:
2358
		ret = -ESTRPIPE;
2359
		goto __end;
2360
	default:
2361
		ret = -EBADFD;
2362
		goto __end;
2363
	}
2364

2365
	avail = snd_pcm_capture_avail(runtime);
2366
	if (avail <= 0) {
2367
		ret = 0;
2368
		goto __end;
2369
	}
2370
	if (frames > (snd_pcm_uframes_t)avail)
2371
		frames = avail;
2372
	appl_ptr = runtime->control->appl_ptr + frames;
2373
	if (appl_ptr >= (snd_pcm_sframes_t)runtime->boundary)
2374
		appl_ptr -= runtime->boundary;
2375
	runtime->control->appl_ptr = appl_ptr;
2376
	ret = frames;
2377
 __end:
2378
	snd_pcm_stream_unlock_irq(substream);
2379
	return ret;
2380
}
2381

2382
static int snd_pcm_hwsync(struct snd_pcm_substream *substream)
2383
{
2384
	struct snd_pcm_runtime *runtime = substream->runtime;
2385
	int err;
2386

2387
	snd_pcm_stream_lock_irq(substream);
2388
	switch (runtime->status->state) {
2389
	case SNDRV_PCM_STATE_DRAINING:
2390
		if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
2391
			goto __badfd;
2392
	case SNDRV_PCM_STATE_RUNNING:
2393
		if ((err = snd_pcm_update_hw_ptr(substream)) < 0)
2394
			break;
2395
		/* Fall through */
2396
	case SNDRV_PCM_STATE_PREPARED:
2397
	case SNDRV_PCM_STATE_SUSPENDED:
2398
		err = 0;
2399
		break;
2400
	case SNDRV_PCM_STATE_XRUN:
2401
		err = -EPIPE;
2402
		break;
2403
	default:
2404
	      __badfd:
2405
		err = -EBADFD;
2406
		break;
2407
	}
2408
	snd_pcm_stream_unlock_irq(substream);
2409
	return err;
2410
}
2411
		
2412
static int snd_pcm_delay(struct snd_pcm_substream *substream,
2413
			 snd_pcm_sframes_t __user *res)
2414
{
2415
	struct snd_pcm_runtime *runtime = substream->runtime;
2416
	int err;
2417
	snd_pcm_sframes_t n = 0;
2418

2419
	snd_pcm_stream_lock_irq(substream);
2420
	switch (runtime->status->state) {
2421
	case SNDRV_PCM_STATE_DRAINING:
2422
		if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
2423
			goto __badfd;
2424
	case SNDRV_PCM_STATE_RUNNING:
2425
		if ((err = snd_pcm_update_hw_ptr(substream)) < 0)
2426
			break;
2427
		/* Fall through */
2428
	case SNDRV_PCM_STATE_PREPARED:
2429
	case SNDRV_PCM_STATE_SUSPENDED:
2430
		err = 0;
2431
		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
2432
			n = snd_pcm_playback_hw_avail(runtime);
2433
		else
2434
			n = snd_pcm_capture_avail(runtime);
2435
		n += runtime->delay;
2436
		break;
2437
	case SNDRV_PCM_STATE_XRUN:
2438
		err = -EPIPE;
2439
		break;
2440
	default:
2441
	      __badfd:
2442
		err = -EBADFD;
2443
		break;
2444
	}
2445
	snd_pcm_stream_unlock_irq(substream);
2446
	if (!err)
2447
		if (put_user(n, res))
2448
			err = -EFAULT;
2449
	return err;
2450
}
2451
		
2452
static int snd_pcm_sync_ptr(struct snd_pcm_substream *substream,
2453
			    struct snd_pcm_sync_ptr __user *_sync_ptr)
2454
{
2455
	struct snd_pcm_runtime *runtime = substream->runtime;
2456
	struct snd_pcm_sync_ptr sync_ptr;
2457
	volatile struct snd_pcm_mmap_status *status;
2458
	volatile struct snd_pcm_mmap_control *control;
2459
	int err;
2460

2461
	memset(&sync_ptr, 0, sizeof(sync_ptr));
2462
	if (get_user(sync_ptr.flags, (unsigned __user *)&(_sync_ptr->flags)))
2463
		return -EFAULT;
2464
	if (copy_from_user(&sync_ptr.c.control, &(_sync_ptr->c.control), sizeof(struct snd_pcm_mmap_control)))
2465
		return -EFAULT;	
2466
	status = runtime->status;
2467
	control = runtime->control;
2468
	if (sync_ptr.flags & SNDRV_PCM_SYNC_PTR_HWSYNC) {
2469
		err = snd_pcm_hwsync(substream);
2470
		if (err < 0)
2471
			return err;
2472
	}
2473
	snd_pcm_stream_lock_irq(substream);
2474
	if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_APPL))
2475
		control->appl_ptr = sync_ptr.c.control.appl_ptr;
2476
	else
2477
		sync_ptr.c.control.appl_ptr = control->appl_ptr;
2478
	if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN))
2479
		control->avail_min = sync_ptr.c.control.avail_min;
2480
	else
2481
		sync_ptr.c.control.avail_min = control->avail_min;
2482
	sync_ptr.s.status.state = status->state;
2483
	sync_ptr.s.status.hw_ptr = status->hw_ptr;
2484
	sync_ptr.s.status.tstamp = status->tstamp;
2485
	sync_ptr.s.status.suspended_state = status->suspended_state;
2486
	snd_pcm_stream_unlock_irq(substream);
2487
	if (copy_to_user(_sync_ptr, &sync_ptr, sizeof(sync_ptr)))
2488
		return -EFAULT;
2489
	return 0;
2490
}
2491

2492
static int snd_pcm_tstamp(struct snd_pcm_substream *substream, int __user *_arg)
2493
{
2494
	struct snd_pcm_runtime *runtime = substream->runtime;
2495
	int arg;
2496
	
2497
	if (get_user(arg, _arg))
2498
		return -EFAULT;
2499
	if (arg < 0 || arg > SNDRV_PCM_TSTAMP_TYPE_LAST)
2500
		return -EINVAL;
2501
	runtime->tstamp_type = SNDRV_PCM_TSTAMP_TYPE_GETTIMEOFDAY;
2502
	if (arg == SNDRV_PCM_TSTAMP_TYPE_MONOTONIC)
2503
		runtime->tstamp_type = SNDRV_PCM_TSTAMP_TYPE_MONOTONIC;
2504
	return 0;
2505
}
2506
		
2507
static int snd_pcm_common_ioctl1(struct file *file,
2508
				 struct snd_pcm_substream *substream,
2509
				 unsigned int cmd, void __user *arg)
2510
{
2511
	switch (cmd) {
2512
	case SNDRV_PCM_IOCTL_PVERSION:
2513
		return put_user(SNDRV_PCM_VERSION, (int __user *)arg) ? -EFAULT : 0;
2514
	case SNDRV_PCM_IOCTL_INFO:
2515
		return snd_pcm_info_user(substream, arg);
2516
	case SNDRV_PCM_IOCTL_TSTAMP:	/* just for compatibility */
2517
		return 0;
2518
	case SNDRV_PCM_IOCTL_TTSTAMP:
2519
		return snd_pcm_tstamp(substream, arg);
2520
	case SNDRV_PCM_IOCTL_HW_REFINE:
2521
		return snd_pcm_hw_refine_user(substream, arg);
2522
	case SNDRV_PCM_IOCTL_HW_PARAMS:
2523
		return snd_pcm_hw_params_user(substream, arg);
2524
	case SNDRV_PCM_IOCTL_HW_FREE:
2525
		return snd_pcm_hw_free(substream);
2526
	case SNDRV_PCM_IOCTL_SW_PARAMS:
2527
		return snd_pcm_sw_params_user(substream, arg);
2528
	case SNDRV_PCM_IOCTL_STATUS:
2529
		return snd_pcm_status_user(substream, arg);
2530
	case SNDRV_PCM_IOCTL_CHANNEL_INFO:
2531
		return snd_pcm_channel_info_user(substream, arg);
2532
	case SNDRV_PCM_IOCTL_PREPARE:
2533
		return snd_pcm_prepare(substream, file);
2534
	case SNDRV_PCM_IOCTL_RESET:
2535
		return snd_pcm_reset(substream);
2536
	case SNDRV_PCM_IOCTL_START:
2537
		return snd_pcm_action_lock_irq(&snd_pcm_action_start, substream, SNDRV_PCM_STATE_RUNNING);
2538
	case SNDRV_PCM_IOCTL_LINK:
2539
		return snd_pcm_link(substream, (int)(unsigned long) arg);
2540
	case SNDRV_PCM_IOCTL_UNLINK:
2541
		return snd_pcm_unlink(substream);
2542
	case SNDRV_PCM_IOCTL_RESUME:
2543
		return snd_pcm_resume(substream);
2544
	case SNDRV_PCM_IOCTL_XRUN:
2545
		return snd_pcm_xrun(substream);
2546
	case SNDRV_PCM_IOCTL_HWSYNC:
2547
		return snd_pcm_hwsync(substream);
2548
	case SNDRV_PCM_IOCTL_DELAY:
2549
		return snd_pcm_delay(substream, arg);
2550
	case SNDRV_PCM_IOCTL_SYNC_PTR:
2551
		return snd_pcm_sync_ptr(substream, arg);
2552
#ifdef CONFIG_SND_SUPPORT_OLD_API
2553
	case SNDRV_PCM_IOCTL_HW_REFINE_OLD:
2554
		return snd_pcm_hw_refine_old_user(substream, arg);
2555
	case SNDRV_PCM_IOCTL_HW_PARAMS_OLD:
2556
		return snd_pcm_hw_params_old_user(substream, arg);
2557
#endif
2558
	case SNDRV_PCM_IOCTL_DRAIN:
2559
		return snd_pcm_drain(substream, file);
2560
	case SNDRV_PCM_IOCTL_DROP:
2561
		return snd_pcm_drop(substream);
2562
	case SNDRV_PCM_IOCTL_PAUSE:
2563
	{
2564
		int res;
2565
		snd_pcm_stream_lock_irq(substream);
2566
		res = snd_pcm_pause(substream, (int)(unsigned long)arg);
2567
		snd_pcm_stream_unlock_irq(substream);
2568
		return res;
2569
	}
2570
	}
2571
	snd_printd("unknown ioctl = 0x%x\n", cmd);
2572
	return -ENOTTY;
2573
}
2574

2575
static int snd_pcm_playback_ioctl1(struct file *file,
2576
				   struct snd_pcm_substream *substream,
2577
				   unsigned int cmd, void __user *arg)
2578
{
2579
	if (snd_BUG_ON(!substream))
2580
		return -ENXIO;
2581
	if (snd_BUG_ON(substream->stream != SNDRV_PCM_STREAM_PLAYBACK))
2582
		return -EINVAL;
2583
	switch (cmd) {
2584
	case SNDRV_PCM_IOCTL_WRITEI_FRAMES:
2585
	{
2586
		struct snd_xferi xferi;
2587
		struct snd_xferi __user *_xferi = arg;
2588
		struct snd_pcm_runtime *runtime = substream->runtime;
2589
		snd_pcm_sframes_t result;
2590
		if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2591
			return -EBADFD;
2592
		if (put_user(0, &_xferi->result))
2593
			return -EFAULT;
2594
		if (copy_from_user(&xferi, _xferi, sizeof(xferi)))
2595
			return -EFAULT;
2596
		result = snd_pcm_lib_write(substream, xferi.buf, xferi.frames);
2597
		__put_user(result, &_xferi->result);
2598
		return result < 0 ? result : 0;
2599
	}
2600
	case SNDRV_PCM_IOCTL_WRITEN_FRAMES:
2601
	{
2602
		struct snd_xfern xfern;
2603
		struct snd_xfern __user *_xfern = arg;
2604
		struct snd_pcm_runtime *runtime = substream->runtime;
2605
		void __user **bufs;
2606
		snd_pcm_sframes_t result;
2607
		if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2608
			return -EBADFD;
2609
		if (runtime->channels > 128)
2610
			return -EINVAL;
2611
		if (put_user(0, &_xfern->result))
2612
			return -EFAULT;
2613
		if (copy_from_user(&xfern, _xfern, sizeof(xfern)))
2614
			return -EFAULT;
2615

2616
		bufs = memdup_user(xfern.bufs,
2617
				   sizeof(void *) * runtime->channels);
2618
		if (IS_ERR(bufs))
2619
			return PTR_ERR(bufs);
2620
		result = snd_pcm_lib_writev(substream, bufs, xfern.frames);
2621
		kfree(bufs);
2622
		__put_user(result, &_xfern->result);
2623
		return result < 0 ? result : 0;
2624
	}
2625
	case SNDRV_PCM_IOCTL_REWIND:
2626
	{
2627
		snd_pcm_uframes_t frames;
2628
		snd_pcm_uframes_t __user *_frames = arg;
2629
		snd_pcm_sframes_t result;
2630
		if (get_user(frames, _frames))
2631
			return -EFAULT;
2632
		if (put_user(0, _frames))
2633
			return -EFAULT;
2634
		result = snd_pcm_playback_rewind(substream, frames);
2635
		__put_user(result, _frames);
2636
		return result < 0 ? result : 0;
2637
	}
2638
	case SNDRV_PCM_IOCTL_FORWARD:
2639
	{
2640
		snd_pcm_uframes_t frames;
2641
		snd_pcm_uframes_t __user *_frames = arg;
2642
		snd_pcm_sframes_t result;
2643
		if (get_user(frames, _frames))
2644
			return -EFAULT;
2645
		if (put_user(0, _frames))
2646
			return -EFAULT;
2647
		result = snd_pcm_playback_forward(substream, frames);
2648
		__put_user(result, _frames);
2649
		return result < 0 ? result : 0;
2650
	}
2651
	}
2652
	return snd_pcm_common_ioctl1(file, substream, cmd, arg);
2653
}
2654

2655
static int snd_pcm_capture_ioctl1(struct file *file,
2656
				  struct snd_pcm_substream *substream,
2657
				  unsigned int cmd, void __user *arg)
2658
{
2659
	if (snd_BUG_ON(!substream))
2660
		return -ENXIO;
2661
	if (snd_BUG_ON(substream->stream != SNDRV_PCM_STREAM_CAPTURE))
2662
		return -EINVAL;
2663
	switch (cmd) {
2664
	case SNDRV_PCM_IOCTL_READI_FRAMES:
2665
	{
2666
		struct snd_xferi xferi;
2667
		struct snd_xferi __user *_xferi = arg;
2668
		struct snd_pcm_runtime *runtime = substream->runtime;
2669
		snd_pcm_sframes_t result;
2670
		if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2671
			return -EBADFD;
2672
		if (put_user(0, &_xferi->result))
2673
			return -EFAULT;
2674
		if (copy_from_user(&xferi, _xferi, sizeof(xferi)))
2675
			return -EFAULT;
2676
		result = snd_pcm_lib_read(substream, xferi.buf, xferi.frames);
2677
		__put_user(result, &_xferi->result);
2678
		return result < 0 ? result : 0;
2679
	}
2680
	case SNDRV_PCM_IOCTL_READN_FRAMES:
2681
	{
2682
		struct snd_xfern xfern;
2683
		struct snd_xfern __user *_xfern = arg;
2684
		struct snd_pcm_runtime *runtime = substream->runtime;
2685
		void *bufs;
2686
		snd_pcm_sframes_t result;
2687
		if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2688
			return -EBADFD;
2689
		if (runtime->channels > 128)
2690
			return -EINVAL;
2691
		if (put_user(0, &_xfern->result))
2692
			return -EFAULT;
2693
		if (copy_from_user(&xfern, _xfern, sizeof(xfern)))
2694
			return -EFAULT;
2695

2696
		bufs = memdup_user(xfern.bufs,
2697
				   sizeof(void *) * runtime->channels);
2698
		if (IS_ERR(bufs))
2699
			return PTR_ERR(bufs);
2700
		result = snd_pcm_lib_readv(substream, bufs, xfern.frames);
2701
		kfree(bufs);
2702
		__put_user(result, &_xfern->result);
2703
		return result < 0 ? result : 0;
2704
	}
2705
	case SNDRV_PCM_IOCTL_REWIND:
2706
	{
2707
		snd_pcm_uframes_t frames;
2708
		snd_pcm_uframes_t __user *_frames = arg;
2709
		snd_pcm_sframes_t result;
2710
		if (get_user(frames, _frames))
2711
			return -EFAULT;
2712
		if (put_user(0, _frames))
2713
			return -EFAULT;
2714
		result = snd_pcm_capture_rewind(substream, frames);
2715
		__put_user(result, _frames);
2716
		return result < 0 ? result : 0;
2717
	}
2718
	case SNDRV_PCM_IOCTL_FORWARD:
2719
	{
2720
		snd_pcm_uframes_t frames;
2721
		snd_pcm_uframes_t __user *_frames = arg;
2722
		snd_pcm_sframes_t result;
2723
		if (get_user(frames, _frames))
2724
			return -EFAULT;
2725
		if (put_user(0, _frames))
2726
			return -EFAULT;
2727
		result = snd_pcm_capture_forward(substream, frames);
2728
		__put_user(result, _frames);
2729
		return result < 0 ? result : 0;
2730
	}
2731
	}
2732
	return snd_pcm_common_ioctl1(file, substream, cmd, arg);
2733
}
2734

2735
static long snd_pcm_playback_ioctl(struct file *file, unsigned int cmd,
2736
				   unsigned long arg)
2737
{
2738
	struct snd_pcm_file *pcm_file;
2739

2740
	pcm_file = file->private_data;
2741

2742
	if (((cmd >> 8) & 0xff) != 'A')
2743
		return -ENOTTY;
2744

2745
	return snd_pcm_playback_ioctl1(file, pcm_file->substream, cmd,
2746
				       (void __user *)arg);
2747
}
2748

2749
static long snd_pcm_capture_ioctl(struct file *file, unsigned int cmd,
2750
				  unsigned long arg)
2751
{
2752
	struct snd_pcm_file *pcm_file;
2753

2754
	pcm_file = file->private_data;
2755

2756
	if (((cmd >> 8) & 0xff) != 'A')
2757
		return -ENOTTY;
2758

2759
	return snd_pcm_capture_ioctl1(file, pcm_file->substream, cmd,
2760
				      (void __user *)arg);
2761
}
2762

2763
int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream,
2764
			 unsigned int cmd, void *arg)
2765
{
2766
	mm_segment_t fs;
2767
	int result;
2768
	
2769
	fs = snd_enter_user();
2770
	switch (substream->stream) {
2771
	case SNDRV_PCM_STREAM_PLAYBACK:
2772
		result = snd_pcm_playback_ioctl1(NULL, substream, cmd,
2773
						 (void __user *)arg);
2774
		break;
2775
	case SNDRV_PCM_STREAM_CAPTURE:
2776
		result = snd_pcm_capture_ioctl1(NULL, substream, cmd,
2777
						(void __user *)arg);
2778
		break;
2779
	default:
2780
		result = -EINVAL;
2781
		break;
2782
	}
2783
	snd_leave_user(fs);
2784
	return result;
2785
}
2786

2787
EXPORT_SYMBOL(snd_pcm_kernel_ioctl);
2788

2789
static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count,
2790
			    loff_t * offset)
2791
{
2792
	struct snd_pcm_file *pcm_file;
2793
	struct snd_pcm_substream *substream;
2794
	struct snd_pcm_runtime *runtime;
2795
	snd_pcm_sframes_t result;
2796

2797
	pcm_file = file->private_data;
2798
	substream = pcm_file->substream;
2799
	if (PCM_RUNTIME_CHECK(substream))
2800
		return -ENXIO;
2801
	runtime = substream->runtime;
2802
	if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2803
		return -EBADFD;
2804
	if (!frame_aligned(runtime, count))
2805
		return -EINVAL;
2806
	count = bytes_to_frames(runtime, count);
2807
	result = snd_pcm_lib_read(substream, buf, count);
2808
	if (result > 0)
2809
		result = frames_to_bytes(runtime, result);
2810
	return result;
2811
}
2812

2813
static ssize_t snd_pcm_write(struct file *file, const char __user *buf,
2814
			     size_t count, loff_t * offset)
2815
{
2816
	struct snd_pcm_file *pcm_file;
2817
	struct snd_pcm_substream *substream;
2818
	struct snd_pcm_runtime *runtime;
2819
	snd_pcm_sframes_t result;
2820

2821
	pcm_file = file->private_data;
2822
	substream = pcm_file->substream;
2823
	if (PCM_RUNTIME_CHECK(substream))
2824
		return -ENXIO;
2825
	runtime = substream->runtime;
2826
	if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2827
		return -EBADFD;
2828
	if (!frame_aligned(runtime, count))
2829
		return -EINVAL;
2830
	count = bytes_to_frames(runtime, count);
2831
	result = snd_pcm_lib_write(substream, buf, count);
2832
	if (result > 0)
2833
		result = frames_to_bytes(runtime, result);
2834
	return result;
2835
}
2836

2837
static ssize_t snd_pcm_aio_read(struct kiocb *iocb, const struct iovec *iov,
2838
			     unsigned long nr_segs, loff_t pos)
2839

2840
{
2841
	struct snd_pcm_file *pcm_file;
2842
	struct snd_pcm_substream *substream;
2843
	struct snd_pcm_runtime *runtime;
2844
	snd_pcm_sframes_t result;
2845
	unsigned long i;
2846
	void __user **bufs;
2847
	snd_pcm_uframes_t frames;
2848

2849
	pcm_file = iocb->ki_filp->private_data;
2850
	substream = pcm_file->substream;
2851
	if (PCM_RUNTIME_CHECK(substream))
2852
		return -ENXIO;
2853
	runtime = substream->runtime;
2854
	if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2855
		return -EBADFD;
2856
	if (nr_segs > 1024 || nr_segs != runtime->channels)
2857
		return -EINVAL;
2858
	if (!frame_aligned(runtime, iov->iov_len))
2859
		return -EINVAL;
2860
	frames = bytes_to_samples(runtime, iov->iov_len);
2861
	bufs = kmalloc(sizeof(void *) * nr_segs, GFP_KERNEL);
2862
	if (bufs == NULL)
2863
		return -ENOMEM;
2864
	for (i = 0; i < nr_segs; ++i)
2865
		bufs[i] = iov[i].iov_base;
2866
	result = snd_pcm_lib_readv(substream, bufs, frames);
2867
	if (result > 0)
2868
		result = frames_to_bytes(runtime, result);
2869
	kfree(bufs);
2870
	return result;
2871
}
2872

2873
static ssize_t snd_pcm_aio_write(struct kiocb *iocb, const struct iovec *iov,
2874
			      unsigned long nr_segs, loff_t pos)
2875
{
2876
	struct snd_pcm_file *pcm_file;
2877
	struct snd_pcm_substream *substream;
2878
	struct snd_pcm_runtime *runtime;
2879
	snd_pcm_sframes_t result;
2880
	unsigned long i;
2881
	void __user **bufs;
2882
	snd_pcm_uframes_t frames;
2883

2884
	pcm_file = iocb->ki_filp->private_data;
2885
	substream = pcm_file->substream;
2886
	if (PCM_RUNTIME_CHECK(substream))
2887
		return -ENXIO;
2888
	runtime = substream->runtime;
2889
	if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2890
		return -EBADFD;
2891
	if (nr_segs > 128 || nr_segs != runtime->channels ||
2892
	    !frame_aligned(runtime, iov->iov_len))
2893
		return -EINVAL;
2894
	frames = bytes_to_samples(runtime, iov->iov_len);
2895
	bufs = kmalloc(sizeof(void *) * nr_segs, GFP_KERNEL);
2896
	if (bufs == NULL)
2897
		return -ENOMEM;
2898
	for (i = 0; i < nr_segs; ++i)
2899
		bufs[i] = iov[i].iov_base;
2900
	result = snd_pcm_lib_writev(substream, bufs, frames);
2901
	if (result > 0)
2902
		result = frames_to_bytes(runtime, result);
2903
	kfree(bufs);
2904
	return result;
2905
}
2906

2907
static unsigned int snd_pcm_playback_poll(struct file *file, poll_table * wait)
2908
{
2909
	struct snd_pcm_file *pcm_file;
2910
	struct snd_pcm_substream *substream;
2911
	struct snd_pcm_runtime *runtime;
2912
        unsigned int mask;
2913
	snd_pcm_uframes_t avail;
2914

2915
	pcm_file = file->private_data;
2916

2917
	substream = pcm_file->substream;
2918
	if (PCM_RUNTIME_CHECK(substream))
2919
		return -ENXIO;
2920
	runtime = substream->runtime;
2921

2922
	poll_wait(file, &runtime->sleep, wait);
2923

2924
	snd_pcm_stream_lock_irq(substream);
2925
	avail = snd_pcm_playback_avail(runtime);
2926
	switch (runtime->status->state) {
2927
	case SNDRV_PCM_STATE_RUNNING:
2928
	case SNDRV_PCM_STATE_PREPARED:
2929
	case SNDRV_PCM_STATE_PAUSED:
2930
		if (avail >= runtime->control->avail_min) {
2931
			mask = POLLOUT | POLLWRNORM;
2932
			break;
2933
		}
2934
		/* Fall through */
2935
	case SNDRV_PCM_STATE_DRAINING:
2936
		mask = 0;
2937
		break;
2938
	default:
2939
		mask = POLLOUT | POLLWRNORM | POLLERR;
2940
		break;
2941
	}
2942
	snd_pcm_stream_unlock_irq(substream);
2943
	return mask;
2944
}
2945

2946
static unsigned int snd_pcm_capture_poll(struct file *file, poll_table * wait)
2947
{
2948
	struct snd_pcm_file *pcm_file;
2949
	struct snd_pcm_substream *substream;
2950
	struct snd_pcm_runtime *runtime;
2951
        unsigned int mask;
2952
	snd_pcm_uframes_t avail;
2953

2954
	pcm_file = file->private_data;
2955

2956
	substream = pcm_file->substream;
2957
	if (PCM_RUNTIME_CHECK(substream))
2958
		return -ENXIO;
2959
	runtime = substream->runtime;
2960

2961
	poll_wait(file, &runtime->sleep, wait);
2962

2963
	snd_pcm_stream_lock_irq(substream);
2964
	avail = snd_pcm_capture_avail(runtime);
2965
	switch (runtime->status->state) {
2966
	case SNDRV_PCM_STATE_RUNNING:
2967
	case SNDRV_PCM_STATE_PREPARED:
2968
	case SNDRV_PCM_STATE_PAUSED:
2969
		if (avail >= runtime->control->avail_min) {
2970
			mask = POLLIN | POLLRDNORM;
2971
			break;
2972
		}
2973
		mask = 0;
2974
		break;
2975
	case SNDRV_PCM_STATE_DRAINING:
2976
		if (avail > 0) {
2977
			mask = POLLIN | POLLRDNORM;
2978
			break;
2979
		}
2980
		/* Fall through */
2981
	default:
2982
		mask = POLLIN | POLLRDNORM | POLLERR;
2983
		break;
2984
	}
2985
	snd_pcm_stream_unlock_irq(substream);
2986
	return mask;
2987
}
2988

2989
/*
2990
 * mmap support
2991
 */
2992

2993
/*
2994
 * Only on coherent architectures, we can mmap the status and the control records
2995
 * for effcient data transfer.  On others, we have to use HWSYNC ioctl...
2996
 */
2997
#if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA)
2998
/*
2999
 * mmap status record
3000
 */
3001
static int snd_pcm_mmap_status_fault(struct vm_area_struct *area,
3002
						struct vm_fault *vmf)
3003
{
3004
	struct snd_pcm_substream *substream = area->vm_private_data;
3005
	struct snd_pcm_runtime *runtime;
3006
	
3007
	if (substream == NULL)
3008
		return VM_FAULT_SIGBUS;
3009
	runtime = substream->runtime;
3010
	vmf->page = virt_to_page(runtime->status);
3011
	get_page(vmf->page);
3012
	return 0;
3013
}
3014

3015
static const struct vm_operations_struct snd_pcm_vm_ops_status =
3016
{
3017
	.fault =	snd_pcm_mmap_status_fault,
3018
};
3019

3020
static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file,
3021
			       struct vm_area_struct *area)
3022
{
3023
	long size;
3024
	if (!(area->vm_flags & VM_READ))
3025
		return -EINVAL;
3026
	size = area->vm_end - area->vm_start;
3027
	if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)))
3028
		return -EINVAL;
3029
	area->vm_ops = &snd_pcm_vm_ops_status;
3030
	area->vm_private_data = substream;
3031
	area->vm_flags |= VM_RESERVED;
3032
	return 0;
3033
}
3034

3035
/*
3036
 * mmap control record
3037
 */
3038
static int snd_pcm_mmap_control_fault(struct vm_area_struct *area,
3039
						struct vm_fault *vmf)
3040
{
3041
	struct snd_pcm_substream *substream = area->vm_private_data;
3042
	struct snd_pcm_runtime *runtime;
3043
	
3044
	if (substream == NULL)
3045
		return VM_FAULT_SIGBUS;
3046
	runtime = substream->runtime;
3047
	vmf->page = virt_to_page(runtime->control);
3048
	get_page(vmf->page);
3049
	return 0;
3050
}
3051

3052
static const struct vm_operations_struct snd_pcm_vm_ops_control =
3053
{
3054
	.fault =	snd_pcm_mmap_control_fault,
3055
};
3056

3057
static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file,
3058
				struct vm_area_struct *area)
3059
{
3060
	long size;
3061
	if (!(area->vm_flags & VM_READ))
3062
		return -EINVAL;
3063
	size = area->vm_end - area->vm_start;
3064
	if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)))
3065
		return -EINVAL;
3066
	area->vm_ops = &snd_pcm_vm_ops_control;
3067
	area->vm_private_data = substream;
3068
	area->vm_flags |= VM_RESERVED;
3069
	return 0;
3070
}
3071
#else /* ! coherent mmap */
3072
/*
3073
 * don't support mmap for status and control records.
3074
 */
3075
static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file,
3076
			       struct vm_area_struct *area)
3077
{
3078
	return -ENXIO;
3079
}
3080
static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file,
3081
				struct vm_area_struct *area)
3082
{
3083
	return -ENXIO;
3084
}
3085
#endif /* coherent mmap */
3086

3087
static inline struct page *
3088
snd_pcm_default_page_ops(struct snd_pcm_substream *substream, unsigned long ofs)
3089
{
3090
	void *vaddr = substream->runtime->dma_area + ofs;
3091
#if defined(CONFIG_MIPS) && defined(CONFIG_DMA_NONCOHERENT)
3092
	if (substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV)
3093
		return virt_to_page(CAC_ADDR(vaddr));
3094
#endif
3095
#if defined(CONFIG_PPC32) && defined(CONFIG_NOT_COHERENT_CACHE)
3096
	if (substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV) {
3097
		dma_addr_t addr = substream->runtime->dma_addr + ofs;
3098
		addr -= get_dma_offset(substream->dma_buffer.dev.dev);
3099
		/* assume dma_handle set via pfn_to_phys() in
3100
		 * mm/dma-noncoherent.c
3101
		 */
3102
		return pfn_to_page(addr >> PAGE_SHIFT);
3103
	}
3104
#endif
3105
	return virt_to_page(vaddr);
3106
}
3107

3108
/*
3109
 * fault callback for mmapping a RAM page
3110
 */
3111
static int snd_pcm_mmap_data_fault(struct vm_area_struct *area,
3112
						struct vm_fault *vmf)
3113
{
3114
	struct snd_pcm_substream *substream = area->vm_private_data;
3115
	struct snd_pcm_runtime *runtime;
3116
	unsigned long offset;
3117
	struct page * page;
3118
	size_t dma_bytes;
3119
	
3120
	if (substream == NULL)
3121
		return VM_FAULT_SIGBUS;
3122
	runtime = substream->runtime;
3123
	offset = vmf->pgoff << PAGE_SHIFT;
3124
	dma_bytes = PAGE_ALIGN(runtime->dma_bytes);
3125
	if (offset > dma_bytes - PAGE_SIZE)
3126
		return VM_FAULT_SIGBUS;
3127
	if (substream->ops->page)
3128
		page = substream->ops->page(substream, offset);
3129
	else
3130
		page = snd_pcm_default_page_ops(substream, offset);
3131
	if (!page)
3132
		return VM_FAULT_SIGBUS;
3133
	get_page(page);
3134
	vmf->page = page;
3135
	return 0;
3136
}
3137

3138
static const struct vm_operations_struct snd_pcm_vm_ops_data = {
3139
	.open =		snd_pcm_mmap_data_open,
3140
	.close =	snd_pcm_mmap_data_close,
3141
};
3142

3143
static const struct vm_operations_struct snd_pcm_vm_ops_data_fault = {
3144
	.open =		snd_pcm_mmap_data_open,
3145
	.close =	snd_pcm_mmap_data_close,
3146
	.fault =	snd_pcm_mmap_data_fault,
3147
};
3148

3149
#ifndef ARCH_HAS_DMA_MMAP_COHERENT
3150
/* This should be defined / handled globally! */
3151
#ifdef CONFIG_ARM
3152
#define ARCH_HAS_DMA_MMAP_COHERENT
3153
#endif
3154
#endif
3155

3156
/*
3157
 * mmap the DMA buffer on RAM
3158
 */
3159
static int snd_pcm_default_mmap(struct snd_pcm_substream *substream,
3160
				struct vm_area_struct *area)
3161
{
3162
	area->vm_flags |= VM_RESERVED;
3163
#ifdef ARCH_HAS_DMA_MMAP_COHERENT
3164
	if (!substream->ops->page &&
3165
	    substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV)
3166
		return dma_mmap_coherent(substream->dma_buffer.dev.dev,
3167
					 area,
3168
					 substream->runtime->dma_area,
3169
					 substream->runtime->dma_addr,
3170
					 area->vm_end - area->vm_start);
3171
#elif defined(CONFIG_MIPS) && defined(CONFIG_DMA_NONCOHERENT)
3172
	if (substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV &&
3173
	    !plat_device_is_coherent(substream->dma_buffer.dev.dev))
3174
		area->vm_page_prot = pgprot_noncached(area->vm_page_prot);
3175
#endif /* ARCH_HAS_DMA_MMAP_COHERENT */
3176
	/* mmap with fault handler */
3177
	area->vm_ops = &snd_pcm_vm_ops_data_fault;
3178
	return 0;
3179
}
3180

3181
/*
3182
 * mmap the DMA buffer on I/O memory area
3183
 */
3184
#if SNDRV_PCM_INFO_MMAP_IOMEM
3185
int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream,
3186
			   struct vm_area_struct *area)
3187
{
3188
	long size;
3189
	unsigned long offset;
3190

3191
	area->vm_page_prot = pgprot_noncached(area->vm_page_prot);
3192
	area->vm_flags |= VM_IO;
3193
	size = area->vm_end - area->vm_start;
3194
	offset = area->vm_pgoff << PAGE_SHIFT;
3195
	if (io_remap_pfn_range(area, area->vm_start,
3196
				(substream->runtime->dma_addr + offset) >> PAGE_SHIFT,
3197
				size, area->vm_page_prot))
3198
		return -EAGAIN;
3199
	return 0;
3200
}
3201

3202
EXPORT_SYMBOL(snd_pcm_lib_mmap_iomem);
3203
#endif /* SNDRV_PCM_INFO_MMAP */
3204

3205
/*
3206
 * mmap DMA buffer
3207
 */
3208
int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file,
3209
		      struct vm_area_struct *area)
3210
{
3211
	struct snd_pcm_runtime *runtime;
3212
	long size;
3213
	unsigned long offset;
3214
	size_t dma_bytes;
3215
	int err;
3216

3217
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
3218
		if (!(area->vm_flags & (VM_WRITE|VM_READ)))
3219
			return -EINVAL;
3220
	} else {
3221
		if (!(area->vm_flags & VM_READ))
3222
			return -EINVAL;
3223
	}
3224
	runtime = substream->runtime;
3225
	if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3226
		return -EBADFD;
3227
	if (!(runtime->info & SNDRV_PCM_INFO_MMAP))
3228
		return -ENXIO;
3229
	if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED ||
3230
	    runtime->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
3231
		return -EINVAL;
3232
	size = area->vm_end - area->vm_start;
3233
	offset = area->vm_pgoff << PAGE_SHIFT;
3234
	dma_bytes = PAGE_ALIGN(runtime->dma_bytes);
3235
	if ((size_t)size > dma_bytes)
3236
		return -EINVAL;
3237
	if (offset > dma_bytes - size)
3238
		return -EINVAL;
3239

3240
	area->vm_ops = &snd_pcm_vm_ops_data;
3241
	area->vm_private_data = substream;
3242
	if (substream->ops->mmap)
3243
		err = substream->ops->mmap(substream, area);
3244
	else
3245
		err = snd_pcm_default_mmap(substream, area);
3246
	if (!err)
3247
		atomic_inc(&substream->mmap_count);
3248
	return err;
3249
}
3250

3251
EXPORT_SYMBOL(snd_pcm_mmap_data);
3252

3253
static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area)
3254
{
3255
	struct snd_pcm_file * pcm_file;
3256
	struct snd_pcm_substream *substream;	
3257
	unsigned long offset;
3258
	
3259
	pcm_file = file->private_data;
3260
	substream = pcm_file->substream;
3261
	if (PCM_RUNTIME_CHECK(substream))
3262
		return -ENXIO;
3263

3264
	offset = area->vm_pgoff << PAGE_SHIFT;
3265
	switch (offset) {
3266
	case SNDRV_PCM_MMAP_OFFSET_STATUS:
3267
		if (pcm_file->no_compat_mmap)
3268
			return -ENXIO;
3269
		return snd_pcm_mmap_status(substream, file, area);
3270
	case SNDRV_PCM_MMAP_OFFSET_CONTROL:
3271
		if (pcm_file->no_compat_mmap)
3272
			return -ENXIO;
3273
		return snd_pcm_mmap_control(substream, file, area);
3274
	default:
3275
		return snd_pcm_mmap_data(substream, file, area);
3276
	}
3277
	return 0;
3278
}
3279

3280
static int snd_pcm_fasync(int fd, struct file * file, int on)
3281
{
3282
	struct snd_pcm_file * pcm_file;
3283
	struct snd_pcm_substream *substream;
3284
	struct snd_pcm_runtime *runtime;
3285

3286
	pcm_file = file->private_data;
3287
	substream = pcm_file->substream;
3288
	if (PCM_RUNTIME_CHECK(substream))
3289
		return -ENXIO;
3290
	runtime = substream->runtime;
3291
	return fasync_helper(fd, file, on, &runtime->fasync);
3292
}
3293

3294
/*
3295
 * ioctl32 compat
3296
 */
3297
#ifdef CONFIG_COMPAT
3298
#include "pcm_compat.c"
3299
#else
3300
#define snd_pcm_ioctl_compat	NULL
3301
#endif
3302

3303
/*
3304
 *  To be removed helpers to keep binary compatibility
3305
 */
3306

3307
#ifdef CONFIG_SND_SUPPORT_OLD_API
3308
#define __OLD_TO_NEW_MASK(x) ((x&7)|((x&0x07fffff8)<<5))
3309
#define __NEW_TO_OLD_MASK(x) ((x&7)|((x&0xffffff00)>>5))
3310

3311
static void snd_pcm_hw_convert_from_old_params(struct snd_pcm_hw_params *params,
3312
					       struct snd_pcm_hw_params_old *oparams)
3313
{
3314
	unsigned int i;
3315

3316
	memset(params, 0, sizeof(*params));
3317
	params->flags = oparams->flags;
3318
	for (i = 0; i < ARRAY_SIZE(oparams->masks); i++)
3319
		params->masks[i].bits[0] = oparams->masks[i];
3320
	memcpy(params->intervals, oparams->intervals, sizeof(oparams->intervals));
3321
	params->rmask = __OLD_TO_NEW_MASK(oparams->rmask);
3322
	params->cmask = __OLD_TO_NEW_MASK(oparams->cmask);
3323
	params->info = oparams->info;
3324
	params->msbits = oparams->msbits;
3325
	params->rate_num = oparams->rate_num;
3326
	params->rate_den = oparams->rate_den;
3327
	params->fifo_size = oparams->fifo_size;
3328
}
3329

3330
static void snd_pcm_hw_convert_to_old_params(struct snd_pcm_hw_params_old *oparams,
3331
					     struct snd_pcm_hw_params *params)
3332
{
3333
	unsigned int i;
3334

3335
	memset(oparams, 0, sizeof(*oparams));
3336
	oparams->flags = params->flags;
3337
	for (i = 0; i < ARRAY_SIZE(oparams->masks); i++)
3338
		oparams->masks[i] = params->masks[i].bits[0];
3339
	memcpy(oparams->intervals, params->intervals, sizeof(oparams->intervals));
3340
	oparams->rmask = __NEW_TO_OLD_MASK(params->rmask);
3341
	oparams->cmask = __NEW_TO_OLD_MASK(params->cmask);
3342
	oparams->info = params->info;
3343
	oparams->msbits = params->msbits;
3344
	oparams->rate_num = params->rate_num;
3345
	oparams->rate_den = params->rate_den;
3346
	oparams->fifo_size = params->fifo_size;
3347
}
3348

3349
static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream,
3350
				      struct snd_pcm_hw_params_old __user * _oparams)
3351
{
3352
	struct snd_pcm_hw_params *params;
3353
	struct snd_pcm_hw_params_old *oparams = NULL;
3354
	int err;
3355

3356
	params = kmalloc(sizeof(*params), GFP_KERNEL);
3357
	if (!params)
3358
		return -ENOMEM;
3359

3360
	oparams = memdup_user(_oparams, sizeof(*oparams));
3361
	if (IS_ERR(oparams)) {
3362
		err = PTR_ERR(oparams);
3363
		goto out;
3364
	}
3365
	snd_pcm_hw_convert_from_old_params(params, oparams);
3366
	err = snd_pcm_hw_refine(substream, params);
3367
	snd_pcm_hw_convert_to_old_params(oparams, params);
3368
	if (copy_to_user(_oparams, oparams, sizeof(*oparams))) {
3369
		if (!err)
3370
			err = -EFAULT;
3371
	}
3372

3373
	kfree(oparams);
3374
out:
3375
	kfree(params);
3376
	return err;
3377
}
3378

3379
static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream,
3380
				      struct snd_pcm_hw_params_old __user * _oparams)
3381
{
3382
	struct snd_pcm_hw_params *params;
3383
	struct snd_pcm_hw_params_old *oparams = NULL;
3384
	int err;
3385

3386
	params = kmalloc(sizeof(*params), GFP_KERNEL);
3387
	if (!params)
3388
		return -ENOMEM;
3389

3390
	oparams = memdup_user(_oparams, sizeof(*oparams));
3391
	if (IS_ERR(oparams)) {
3392
		err = PTR_ERR(oparams);
3393
		goto out;
3394
	}
3395
	snd_pcm_hw_convert_from_old_params(params, oparams);
3396
	err = snd_pcm_hw_params(substream, params);
3397
	snd_pcm_hw_convert_to_old_params(oparams, params);
3398
	if (copy_to_user(_oparams, oparams, sizeof(*oparams))) {
3399
		if (!err)
3400
			err = -EFAULT;
3401
	}
3402

3403
	kfree(oparams);
3404
out:
3405
	kfree(params);
3406
	return err;
3407
}
3408
#endif /* CONFIG_SND_SUPPORT_OLD_API */
3409

3410
#ifndef CONFIG_MMU
3411
static unsigned long snd_pcm_get_unmapped_area(struct file *file,
3412
					       unsigned long addr,
3413
					       unsigned long len,
3414
					       unsigned long pgoff,
3415
					       unsigned long flags)
3416
{
3417
	struct snd_pcm_file *pcm_file = file->private_data;
3418
	struct snd_pcm_substream *substream = pcm_file->substream;
3419
	struct snd_pcm_runtime *runtime = substream->runtime;
3420
	unsigned long offset = pgoff << PAGE_SHIFT;
3421

3422
	switch (offset) {
3423
	case SNDRV_PCM_MMAP_OFFSET_STATUS:
3424
		return (unsigned long)runtime->status;
3425
	case SNDRV_PCM_MMAP_OFFSET_CONTROL:
3426
		return (unsigned long)runtime->control;
3427
	default:
3428
		return (unsigned long)runtime->dma_area + offset;
3429
	}
3430
}
3431
#else
3432
# define snd_pcm_get_unmapped_area NULL
3433
#endif
3434

3435
/*
3436
 *  Register section
3437
 */
3438

3439
const struct file_operations snd_pcm_f_ops[2] = {
3440
	{
3441
		.owner =		THIS_MODULE,
3442
		.write =		snd_pcm_write,
3443
		.aio_write =		snd_pcm_aio_write,
3444
		.open =			snd_pcm_playback_open,
3445
		.release =		snd_pcm_release,
3446
		.llseek =		no_llseek,
3447
		.poll =			snd_pcm_playback_poll,
3448
		.unlocked_ioctl =	snd_pcm_playback_ioctl,
3449
		.compat_ioctl = 	snd_pcm_ioctl_compat,
3450
		.mmap =			snd_pcm_mmap,
3451
		.fasync =		snd_pcm_fasync,
3452
		.get_unmapped_area =	snd_pcm_get_unmapped_area,
3453
	},
3454
	{
3455
		.owner =		THIS_MODULE,
3456
		.read =			snd_pcm_read,
3457
		.aio_read =		snd_pcm_aio_read,
3458
		.open =			snd_pcm_capture_open,
3459
		.release =		snd_pcm_release,
3460
		.llseek =		no_llseek,
3461
		.poll =			snd_pcm_capture_poll,
3462
		.unlocked_ioctl =	snd_pcm_capture_ioctl,
3463
		.compat_ioctl = 	snd_pcm_ioctl_compat,
3464
		.mmap =			snd_pcm_mmap,
3465
		.fasync =		snd_pcm_fasync,
3466
		.get_unmapped_area =	snd_pcm_get_unmapped_area,
3467
	}
3468
};
3469

3470
Product

Resources

Company
