CoCalc -- pcm

GitHub Repository: torvalds/linux
Path: blob/master/sound/core/oss/pcm_oss.c
²⁶⁴⁴² views
1
// SPDX-License-Identifier: GPL-2.0-or-later
2
/*
3
 *  Digital Audio (PCM) abstract layer / OSS compatible
4
 *  Copyright (c) by Jaroslav Kysela <[email protected]>
5
 */
6

7
#if 0
8
#define PLUGIN_DEBUG
9
#endif
10
#if 0
11
#define OSS_DEBUG
12
#endif
13

14
#include <linux/init.h>
15
#include <linux/slab.h>
16
#include <linux/sched/signal.h>
17
#include <linux/time.h>
18
#include <linux/vmalloc.h>
19
#include <linux/module.h>
20
#include <linux/math64.h>
21
#include <linux/string.h>
22
#include <linux/compat.h>
23
#include <sound/core.h>
24
#include <sound/minors.h>
25
#include <sound/pcm.h>
26
#include <sound/pcm_params.h>
27
#include "pcm_plugin.h"
28
#include <sound/info.h>
29
#include <linux/soundcard.h>
30
#include <sound/initval.h>
31
#include <sound/mixer_oss.h>
32

33
#define OSS_ALSAEMULVER		_SIOR ('M', 249, int)
34

35
static int dsp_map[SNDRV_CARDS];
36
static int adsp_map[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = 1};
37
static bool nonblock_open = 1;
38

39
MODULE_AUTHOR("Jaroslav Kysela <[email protected]>, Abramo Bagnara <[email protected]>");
40
MODULE_DESCRIPTION("PCM OSS emulation for ALSA.");
41
MODULE_LICENSE("GPL");
42
module_param_array(dsp_map, int, NULL, 0444);
43
MODULE_PARM_DESC(dsp_map, "PCM device number assigned to 1st OSS device.");
44
module_param_array(adsp_map, int, NULL, 0444);
45
MODULE_PARM_DESC(adsp_map, "PCM device number assigned to 2nd OSS device.");
46
module_param(nonblock_open, bool, 0644);
47
MODULE_PARM_DESC(nonblock_open, "Don't block opening busy PCM devices.");
48
MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM);
49
MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM1);
50

51
static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file *pcm_oss_file);
52
static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file *pcm_oss_file);
53
static int snd_pcm_oss_get_format(struct snd_pcm_oss_file *pcm_oss_file);
54

55
/*
56
 * helper functions to process hw_params
57
 */
58
static int snd_interval_refine_min(struct snd_interval *i, unsigned int min, int openmin)
59
{
60
	int changed = 0;
61
	if (i->min < min) {
62
		i->min = min;
63
		i->openmin = openmin;
64
		changed = 1;
65
	} else if (i->min == min && !i->openmin && openmin) {
66
		i->openmin = 1;
67
		changed = 1;
68
	}
69
	if (i->integer) {
70
		if (i->openmin) {
71
			i->min++;
72
			i->openmin = 0;
73
		}
74
	}
75
	if (snd_interval_checkempty(i)) {
76
		snd_interval_none(i);
77
		return -EINVAL;
78
	}
79
	return changed;
80
}
81

82
static int snd_interval_refine_max(struct snd_interval *i, unsigned int max, int openmax)
83
{
84
	int changed = 0;
85
	if (i->max > max) {
86
		i->max = max;
87
		i->openmax = openmax;
88
		changed = 1;
89
	} else if (i->max == max && !i->openmax && openmax) {
90
		i->openmax = 1;
91
		changed = 1;
92
	}
93
	if (i->integer) {
94
		if (i->openmax) {
95
			i->max--;
96
			i->openmax = 0;
97
		}
98
	}
99
	if (snd_interval_checkempty(i)) {
100
		snd_interval_none(i);
101
		return -EINVAL;
102
	}
103
	return changed;
104
}
105

106
static int snd_interval_refine_set(struct snd_interval *i, unsigned int val)
107
{
108
	struct snd_interval t;
109
	t.empty = 0;
110
	t.min = t.max = val;
111
	t.openmin = t.openmax = 0;
112
	t.integer = 1;
113
	return snd_interval_refine(i, &t);
114
}
115

116
/**
117
 * snd_pcm_hw_param_value_min
118
 * @params: the hw_params instance
119
 * @var: parameter to retrieve
120
 * @dir: pointer to the direction (-1,0,1) or NULL
121
 *
122
 * Return the minimum value for field PAR.
123
 */
124
static unsigned int
125
snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params,
126
			   snd_pcm_hw_param_t var, int *dir)
127
{
128
	if (hw_is_mask(var)) {
129
		if (dir)
130
			*dir = 0;
131
		return snd_mask_min(hw_param_mask_c(params, var));
132
	}
133
	if (hw_is_interval(var)) {
134
		const struct snd_interval *i = hw_param_interval_c(params, var);
135
		if (dir)
136
			*dir = i->openmin;
137
		return snd_interval_min(i);
138
	}
139
	return -EINVAL;
140
}
141

142
/**
143
 * snd_pcm_hw_param_value_max
144
 * @params: the hw_params instance
145
 * @var: parameter to retrieve
146
 * @dir: pointer to the direction (-1,0,1) or NULL
147
 *
148
 * Return the maximum value for field PAR.
149
 */
150
static int
151
snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params,
152
			   snd_pcm_hw_param_t var, int *dir)
153
{
154
	if (hw_is_mask(var)) {
155
		if (dir)
156
			*dir = 0;
157
		return snd_mask_max(hw_param_mask_c(params, var));
158
	}
159
	if (hw_is_interval(var)) {
160
		const struct snd_interval *i = hw_param_interval_c(params, var);
161
		if (dir)
162
			*dir = - (int) i->openmax;
163
		return snd_interval_max(i);
164
	}
165
	return -EINVAL;
166
}
167

168
static int _snd_pcm_hw_param_mask(struct snd_pcm_hw_params *params,
169
				  snd_pcm_hw_param_t var,
170
				  const struct snd_mask *val)
171
{
172
	int changed;
173
	changed = snd_mask_refine(hw_param_mask(params, var), val);
174
	if (changed > 0) {
175
		params->cmask |= 1 << var;
176
		params->rmask |= 1 << var;
177
	}
178
	return changed;
179
}
180

181
static int snd_pcm_hw_param_mask(struct snd_pcm_substream *pcm,
182
				 struct snd_pcm_hw_params *params,
183
				 snd_pcm_hw_param_t var,
184
				 const struct snd_mask *val)
185
{
186
	int changed = _snd_pcm_hw_param_mask(params, var, val);
187
	if (changed < 0)
188
		return changed;
189
	if (params->rmask) {
190
		int err = snd_pcm_hw_refine(pcm, params);
191
		if (err < 0)
192
			return err;
193
	}
194
	return 0;
195
}
196

197
static int _snd_pcm_hw_param_min(struct snd_pcm_hw_params *params,
198
				 snd_pcm_hw_param_t var, unsigned int val,
199
				 int dir)
200
{
201
	int changed;
202
	int open = 0;
203
	if (dir) {
204
		if (dir > 0) {
205
			open = 1;
206
		} else if (dir < 0) {
207
			if (val > 0) {
208
				open = 1;
209
				val--;
210
			}
211
		}
212
	}
213
	if (hw_is_mask(var))
214
		changed = snd_mask_refine_min(hw_param_mask(params, var),
215
					      val + !!open);
216
	else if (hw_is_interval(var))
217
		changed = snd_interval_refine_min(hw_param_interval(params, var),
218
						  val, open);
219
	else
220
		return -EINVAL;
221
	if (changed > 0) {
222
		params->cmask |= 1 << var;
223
		params->rmask |= 1 << var;
224
	}
225
	return changed;
226
}
227

228
/**
229
 * snd_pcm_hw_param_min
230
 * @pcm: PCM instance
231
 * @params: the hw_params instance
232
 * @var: parameter to retrieve
233
 * @val: minimal value
234
 * @dir: pointer to the direction (-1,0,1) or NULL
235
 *
236
 * Inside configuration space defined by PARAMS remove from PAR all 
237
 * values < VAL. Reduce configuration space accordingly.
238
 * Return new minimum or -EINVAL if the configuration space is empty
239
 */
240
static int snd_pcm_hw_param_min(struct snd_pcm_substream *pcm,
241
				struct snd_pcm_hw_params *params,
242
				snd_pcm_hw_param_t var, unsigned int val,
243
				int *dir)
244
{
245
	int changed = _snd_pcm_hw_param_min(params, var, val, dir ? *dir : 0);
246
	if (changed < 0)
247
		return changed;
248
	if (params->rmask) {
249
		int err = snd_pcm_hw_refine(pcm, params);
250
		if (err < 0)
251
			return err;
252
	}
253
	return snd_pcm_hw_param_value_min(params, var, dir);
254
}
255

256
static int _snd_pcm_hw_param_max(struct snd_pcm_hw_params *params,
257
				 snd_pcm_hw_param_t var, unsigned int val,
258
				 int dir)
259
{
260
	int changed;
261
	int open = 0;
262
	if (dir) {
263
		if (dir < 0) {
264
			open = 1;
265
		} else if (dir > 0) {
266
			open = 1;
267
			val++;
268
		}
269
	}
270
	if (hw_is_mask(var)) {
271
		if (val == 0 && open) {
272
			snd_mask_none(hw_param_mask(params, var));
273
			changed = -EINVAL;
274
		} else
275
			changed = snd_mask_refine_max(hw_param_mask(params, var),
276
						      val - !!open);
277
	} else if (hw_is_interval(var))
278
		changed = snd_interval_refine_max(hw_param_interval(params, var),
279
						  val, open);
280
	else
281
		return -EINVAL;
282
	if (changed > 0) {
283
		params->cmask |= 1 << var;
284
		params->rmask |= 1 << var;
285
	}
286
	return changed;
287
}
288

289
/**
290
 * snd_pcm_hw_param_max
291
 * @pcm: PCM instance
292
 * @params: the hw_params instance
293
 * @var: parameter to retrieve
294
 * @val: maximal value
295
 * @dir: pointer to the direction (-1,0,1) or NULL
296
 *
297
 * Inside configuration space defined by PARAMS remove from PAR all 
298
 *  values >= VAL + 1. Reduce configuration space accordingly.
299
 *  Return new maximum or -EINVAL if the configuration space is empty
300
 */
301
static int snd_pcm_hw_param_max(struct snd_pcm_substream *pcm,
302
				struct snd_pcm_hw_params *params,
303
				snd_pcm_hw_param_t var, unsigned int val,
304
				int *dir)
305
{
306
	int changed = _snd_pcm_hw_param_max(params, var, val, dir ? *dir : 0);
307
	if (changed < 0)
308
		return changed;
309
	if (params->rmask) {
310
		int err = snd_pcm_hw_refine(pcm, params);
311
		if (err < 0)
312
			return err;
313
	}
314
	return snd_pcm_hw_param_value_max(params, var, dir);
315
}
316

317
static int boundary_sub(int a, int adir,
318
			int b, int bdir,
319
			int *c, int *cdir)
320
{
321
	adir = adir < 0 ? -1 : (adir > 0 ? 1 : 0);
322
	bdir = bdir < 0 ? -1 : (bdir > 0 ? 1 : 0);
323
	*c = a - b;
324
	*cdir = adir - bdir;
325
	if (*cdir == -2) {
326
		(*c)--;
327
	} else if (*cdir == 2) {
328
		(*c)++;
329
	}
330
	return 0;
331
}
332

333
static int boundary_lt(unsigned int a, int adir,
334
		       unsigned int b, int bdir)
335
{
336
	if (adir < 0) {
337
		a--;
338
		adir = 1;
339
	} else if (adir > 0)
340
		adir = 1;
341
	if (bdir < 0) {
342
		b--;
343
		bdir = 1;
344
	} else if (bdir > 0)
345
		bdir = 1;
346
	return a < b || (a == b && adir < bdir);
347
}
348

349
/* Return 1 if min is nearer to best than max */
350
static int boundary_nearer(int min, int mindir,
351
			   int best, int bestdir,
352
			   int max, int maxdir)
353
{
354
	int dmin, dmindir;
355
	int dmax, dmaxdir;
356
	boundary_sub(best, bestdir, min, mindir, &dmin, &dmindir);
357
	boundary_sub(max, maxdir, best, bestdir, &dmax, &dmaxdir);
358
	return boundary_lt(dmin, dmindir, dmax, dmaxdir);
359
}
360

361
/**
362
 * snd_pcm_hw_param_near
363
 * @pcm: PCM instance
364
 * @params: the hw_params instance
365
 * @var: parameter to retrieve
366
 * @best: value to set
367
 * @dir: pointer to the direction (-1,0,1) or NULL
368
 *
369
 * Inside configuration space defined by PARAMS set PAR to the available value
370
 * nearest to VAL. Reduce configuration space accordingly.
371
 * This function cannot be called for SNDRV_PCM_HW_PARAM_ACCESS,
372
 * SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_SUBFORMAT.
373
 * Return the value found.
374
  */
375
static int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm,
376
				 struct snd_pcm_hw_params *params,
377
				 snd_pcm_hw_param_t var, unsigned int best,
378
				 int *dir)
379
{
380
	struct snd_pcm_hw_params *save __free(kfree) = NULL;
381
	int v;
382
	unsigned int saved_min;
383
	int last = 0;
384
	int min, max;
385
	int mindir, maxdir;
386
	int valdir = dir ? *dir : 0;
387
	/* FIXME */
388
	if (best > INT_MAX)
389
		best = INT_MAX;
390
	min = max = best;
391
	mindir = maxdir = valdir;
392
	if (maxdir > 0)
393
		maxdir = 0;
394
	else if (maxdir == 0)
395
		maxdir = -1;
396
	else {
397
		maxdir = 1;
398
		max--;
399
	}
400
	save = kmalloc(sizeof(*save), GFP_KERNEL);
401
	if (save == NULL)
402
		return -ENOMEM;
403
	*save = *params;
404
	saved_min = min;
405
	min = snd_pcm_hw_param_min(pcm, params, var, min, &mindir);
406
	if (min >= 0) {
407
		struct snd_pcm_hw_params *params1 __free(kfree) = NULL;
408
		if (max < 0)
409
			goto _end;
410
		if ((unsigned int)min == saved_min && mindir == valdir)
411
			goto _end;
412
		params1 = kmalloc(sizeof(*params1), GFP_KERNEL);
413
		if (params1 == NULL)
414
			return -ENOMEM;
415
		*params1 = *save;
416
		max = snd_pcm_hw_param_max(pcm, params1, var, max, &maxdir);
417
		if (max < 0)
418
			goto _end;
419
		if (boundary_nearer(max, maxdir, best, valdir, min, mindir)) {
420
			*params = *params1;
421
			last = 1;
422
		}
423
	} else {
424
		*params = *save;
425
		max = snd_pcm_hw_param_max(pcm, params, var, max, &maxdir);
426
		if (max < 0)
427
			return max;
428
		last = 1;
429
	}
430
 _end:
431
	if (last)
432
		v = snd_pcm_hw_param_last(pcm, params, var, dir);
433
	else
434
		v = snd_pcm_hw_param_first(pcm, params, var, dir);
435
	return v;
436
}
437

438
static int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params,
439
				 snd_pcm_hw_param_t var, unsigned int val,
440
				 int dir)
441
{
442
	int changed;
443
	if (hw_is_mask(var)) {
444
		struct snd_mask *m = hw_param_mask(params, var);
445
		if (val == 0 && dir < 0) {
446
			changed = -EINVAL;
447
			snd_mask_none(m);
448
		} else {
449
			if (dir > 0)
450
				val++;
451
			else if (dir < 0)
452
				val--;
453
			changed = snd_mask_refine_set(hw_param_mask(params, var), val);
454
		}
455
	} else if (hw_is_interval(var)) {
456
		struct snd_interval *i = hw_param_interval(params, var);
457
		if (val == 0 && dir < 0) {
458
			changed = -EINVAL;
459
			snd_interval_none(i);
460
		} else if (dir == 0)
461
			changed = snd_interval_refine_set(i, val);
462
		else {
463
			struct snd_interval t;
464
			t.openmin = 1;
465
			t.openmax = 1;
466
			t.empty = 0;
467
			t.integer = 0;
468
			if (dir < 0) {
469
				t.min = val - 1;
470
				t.max = val;
471
			} else {
472
				t.min = val;
473
				t.max = val+1;
474
			}
475
			changed = snd_interval_refine(i, &t);
476
		}
477
	} else
478
		return -EINVAL;
479
	if (changed > 0) {
480
		params->cmask |= 1 << var;
481
		params->rmask |= 1 << var;
482
	}
483
	return changed;
484
}
485

486
/**
487
 * snd_pcm_hw_param_set
488
 * @pcm: PCM instance
489
 * @params: the hw_params instance
490
 * @var: parameter to retrieve
491
 * @val: value to set
492
 * @dir: pointer to the direction (-1,0,1) or NULL
493
 *
494
 * Inside configuration space defined by PARAMS remove from PAR all 
495
 * values != VAL. Reduce configuration space accordingly.
496
 *  Return VAL or -EINVAL if the configuration space is empty
497
 */
498
static int snd_pcm_hw_param_set(struct snd_pcm_substream *pcm,
499
				struct snd_pcm_hw_params *params,
500
				snd_pcm_hw_param_t var, unsigned int val,
501
				int dir)
502
{
503
	int changed = _snd_pcm_hw_param_set(params, var, val, dir);
504
	if (changed < 0)
505
		return changed;
506
	if (params->rmask) {
507
		int err = snd_pcm_hw_refine(pcm, params);
508
		if (err < 0)
509
			return err;
510
	}
511
	return snd_pcm_hw_param_value(params, var, NULL);
512
}
513

514
static int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params *params,
515
					snd_pcm_hw_param_t var)
516
{
517
	int changed;
518
	changed = snd_interval_setinteger(hw_param_interval(params, var));
519
	if (changed > 0) {
520
		params->cmask |= 1 << var;
521
		params->rmask |= 1 << var;
522
	}
523
	return changed;
524
}
525
	
526
/*
527
 * plugin
528
 */
529

530
#ifdef CONFIG_SND_PCM_OSS_PLUGINS
531
static int snd_pcm_oss_plugin_clear(struct snd_pcm_substream *substream)
532
{
533
	struct snd_pcm_runtime *runtime = substream->runtime;
534
	struct snd_pcm_plugin *plugin, *next;
535
	
536
	plugin = runtime->oss.plugin_first;
537
	while (plugin) {
538
		next = plugin->next;
539
		snd_pcm_plugin_free(plugin);
540
		plugin = next;
541
	}
542
	runtime->oss.plugin_first = runtime->oss.plugin_last = NULL;
543
	return 0;
544
}
545

546
static int snd_pcm_plugin_insert(struct snd_pcm_plugin *plugin)
547
{
548
	struct snd_pcm_runtime *runtime = plugin->plug->runtime;
549
	plugin->next = runtime->oss.plugin_first;
550
	plugin->prev = NULL;
551
	if (runtime->oss.plugin_first) {
552
		runtime->oss.plugin_first->prev = plugin;
553
		runtime->oss.plugin_first = plugin;
554
	} else {
555
		runtime->oss.plugin_last =
556
		runtime->oss.plugin_first = plugin;
557
	}
558
	return 0;
559
}
560

561
int snd_pcm_plugin_append(struct snd_pcm_plugin *plugin)
562
{
563
	struct snd_pcm_runtime *runtime = plugin->plug->runtime;
564
	plugin->next = NULL;
565
	plugin->prev = runtime->oss.plugin_last;
566
	if (runtime->oss.plugin_last) {
567
		runtime->oss.plugin_last->next = plugin;
568
		runtime->oss.plugin_last = plugin;
569
	} else {
570
		runtime->oss.plugin_last =
571
		runtime->oss.plugin_first = plugin;
572
	}
573
	return 0;
574
}
575
#endif /* CONFIG_SND_PCM_OSS_PLUGINS */
576

577
static long snd_pcm_oss_bytes(struct snd_pcm_substream *substream, long frames)
578
{
579
	struct snd_pcm_runtime *runtime = substream->runtime;
580
	long buffer_size = snd_pcm_lib_buffer_bytes(substream);
581
	long bytes = frames_to_bytes(runtime, frames);
582
	if (buffer_size == runtime->oss.buffer_bytes)
583
		return bytes;
584
#if BITS_PER_LONG >= 64
585
	return runtime->oss.buffer_bytes * bytes / buffer_size;
586
#else
587
	{
588
		u64 bsize = (u64)runtime->oss.buffer_bytes * (u64)bytes;
589
		return div_u64(bsize, buffer_size);
590
	}
591
#endif
592
}
593

594
static long snd_pcm_alsa_frames(struct snd_pcm_substream *substream, long bytes)
595
{
596
	struct snd_pcm_runtime *runtime = substream->runtime;
597
	long buffer_size = snd_pcm_lib_buffer_bytes(substream);
598
	if (buffer_size == runtime->oss.buffer_bytes)
599
		return bytes_to_frames(runtime, bytes);
600
	return bytes_to_frames(runtime, (buffer_size * bytes) / runtime->oss.buffer_bytes);
601
}
602

603
static inline
604
snd_pcm_uframes_t get_hw_ptr_period(struct snd_pcm_runtime *runtime)
605
{
606
	return runtime->hw_ptr_interrupt;
607
}
608

609
/* define extended formats in the recent OSS versions (if any) */
610
/* linear formats */
611
#define AFMT_S32_LE      0x00001000
612
#define AFMT_S32_BE      0x00002000
613
#define AFMT_S24_LE      0x00008000
614
#define AFMT_S24_BE      0x00010000
615
#define AFMT_S24_PACKED  0x00040000
616

617
/* other supported formats */
618
#define AFMT_FLOAT       0x00004000
619
#define AFMT_SPDIF_RAW   0x00020000
620

621
/* unsupported formats */
622
#define AFMT_AC3         0x00000400
623
#define AFMT_VORBIS      0x00000800
624

625
static snd_pcm_format_t snd_pcm_oss_format_from(int format)
626
{
627
	switch (format) {
628
	case AFMT_MU_LAW:	return SNDRV_PCM_FORMAT_MU_LAW;
629
	case AFMT_A_LAW:	return SNDRV_PCM_FORMAT_A_LAW;
630
	case AFMT_IMA_ADPCM:	return SNDRV_PCM_FORMAT_IMA_ADPCM;
631
	case AFMT_U8:		return SNDRV_PCM_FORMAT_U8;
632
	case AFMT_S16_LE:	return SNDRV_PCM_FORMAT_S16_LE;
633
	case AFMT_S16_BE:	return SNDRV_PCM_FORMAT_S16_BE;
634
	case AFMT_S8:		return SNDRV_PCM_FORMAT_S8;
635
	case AFMT_U16_LE:	return SNDRV_PCM_FORMAT_U16_LE;
636
	case AFMT_U16_BE:	return SNDRV_PCM_FORMAT_U16_BE;
637
	case AFMT_MPEG:		return SNDRV_PCM_FORMAT_MPEG;
638
	case AFMT_S32_LE:	return SNDRV_PCM_FORMAT_S32_LE;
639
	case AFMT_S32_BE:	return SNDRV_PCM_FORMAT_S32_BE;
640
	case AFMT_S24_LE:	return SNDRV_PCM_FORMAT_S24_LE;
641
	case AFMT_S24_BE:	return SNDRV_PCM_FORMAT_S24_BE;
642
	case AFMT_S24_PACKED:	return SNDRV_PCM_FORMAT_S24_3LE;
643
	case AFMT_FLOAT:	return SNDRV_PCM_FORMAT_FLOAT;
644
	case AFMT_SPDIF_RAW:	return SNDRV_PCM_FORMAT_IEC958_SUBFRAME;
645
	default:		return SNDRV_PCM_FORMAT_U8;
646
	}
647
}
648

649
static int snd_pcm_oss_format_to(snd_pcm_format_t format)
650
{
651
	switch (format) {
652
	case SNDRV_PCM_FORMAT_MU_LAW:	return AFMT_MU_LAW;
653
	case SNDRV_PCM_FORMAT_A_LAW:	return AFMT_A_LAW;
654
	case SNDRV_PCM_FORMAT_IMA_ADPCM:	return AFMT_IMA_ADPCM;
655
	case SNDRV_PCM_FORMAT_U8:		return AFMT_U8;
656
	case SNDRV_PCM_FORMAT_S16_LE:	return AFMT_S16_LE;
657
	case SNDRV_PCM_FORMAT_S16_BE:	return AFMT_S16_BE;
658
	case SNDRV_PCM_FORMAT_S8:		return AFMT_S8;
659
	case SNDRV_PCM_FORMAT_U16_LE:	return AFMT_U16_LE;
660
	case SNDRV_PCM_FORMAT_U16_BE:	return AFMT_U16_BE;
661
	case SNDRV_PCM_FORMAT_MPEG:		return AFMT_MPEG;
662
	case SNDRV_PCM_FORMAT_S32_LE:	return AFMT_S32_LE;
663
	case SNDRV_PCM_FORMAT_S32_BE:	return AFMT_S32_BE;
664
	case SNDRV_PCM_FORMAT_S24_LE:	return AFMT_S24_LE;
665
	case SNDRV_PCM_FORMAT_S24_BE:	return AFMT_S24_BE;
666
	case SNDRV_PCM_FORMAT_S24_3LE:	return AFMT_S24_PACKED;
667
	case SNDRV_PCM_FORMAT_FLOAT:	return AFMT_FLOAT;
668
	case SNDRV_PCM_FORMAT_IEC958_SUBFRAME: return AFMT_SPDIF_RAW;
669
	default:			return -EINVAL;
670
	}
671
}
672

673
static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream, 
674
				   struct snd_pcm_hw_params *oss_params,
675
				   struct snd_pcm_hw_params *slave_params)
676
{
677
	ssize_t s;
678
	ssize_t oss_buffer_size;
679
	ssize_t oss_period_size, oss_periods;
680
	ssize_t min_period_size, max_period_size;
681
	struct snd_pcm_runtime *runtime = substream->runtime;
682
	size_t oss_frame_size;
683

684
	oss_frame_size = snd_pcm_format_physical_width(params_format(oss_params)) *
685
			 params_channels(oss_params) / 8;
686

687
	oss_buffer_size = snd_pcm_hw_param_value_max(slave_params,
688
						     SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
689
						     NULL);
690
	if (oss_buffer_size <= 0)
691
		return -EINVAL;
692
	oss_buffer_size = snd_pcm_plug_client_size(substream,
693
						   oss_buffer_size * oss_frame_size);
694
	if (oss_buffer_size <= 0)
695
		return -EINVAL;
696
	oss_buffer_size = rounddown_pow_of_two(oss_buffer_size);
697
	if (atomic_read(&substream->mmap_count)) {
698
		if (oss_buffer_size > runtime->oss.mmap_bytes)
699
			oss_buffer_size = runtime->oss.mmap_bytes;
700
	}
701

702
	if (substream->oss.setup.period_size > 16)
703
		oss_period_size = substream->oss.setup.period_size;
704
	else if (runtime->oss.fragshift) {
705
		oss_period_size = 1 << runtime->oss.fragshift;
706
		if (oss_period_size > oss_buffer_size / 2)
707
			oss_period_size = oss_buffer_size / 2;
708
	} else {
709
		int sd;
710
		size_t bytes_per_sec = params_rate(oss_params) * snd_pcm_format_physical_width(params_format(oss_params)) * params_channels(oss_params) / 8;
711

712
		oss_period_size = oss_buffer_size;
713
		do {
714
			oss_period_size /= 2;
715
		} while (oss_period_size > bytes_per_sec);
716
		if (runtime->oss.subdivision == 0) {
717
			sd = 4;
718
			if (oss_period_size / sd > 4096)
719
				sd *= 2;
720
			if (oss_period_size / sd < 4096)
721
				sd = 1;
722
		} else
723
			sd = runtime->oss.subdivision;
724
		oss_period_size /= sd;
725
		if (oss_period_size < 16)
726
			oss_period_size = 16;
727
	}
728

729
	min_period_size = snd_pcm_plug_client_size(substream,
730
						   snd_pcm_hw_param_value_min(slave_params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, NULL));
731
	if (min_period_size > 0) {
732
		min_period_size *= oss_frame_size;
733
		min_period_size = roundup_pow_of_two(min_period_size);
734
		if (oss_period_size < min_period_size)
735
			oss_period_size = min_period_size;
736
	}
737

738
	max_period_size = snd_pcm_plug_client_size(substream,
739
						   snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, NULL));
740
	if (max_period_size > 0) {
741
		max_period_size *= oss_frame_size;
742
		max_period_size = rounddown_pow_of_two(max_period_size);
743
		if (oss_period_size > max_period_size)
744
			oss_period_size = max_period_size;
745
	}
746

747
	oss_periods = oss_buffer_size / oss_period_size;
748

749
	if (substream->oss.setup.periods > 1)
750
		oss_periods = substream->oss.setup.periods;
751

752
	s = snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_PERIODS, NULL);
753
	if (s > 0 && runtime->oss.maxfrags && s > runtime->oss.maxfrags)
754
		s = runtime->oss.maxfrags;
755
	if (oss_periods > s)
756
		oss_periods = s;
757

758
	s = snd_pcm_hw_param_value_min(slave_params, SNDRV_PCM_HW_PARAM_PERIODS, NULL);
759
	if (s < 2)
760
		s = 2;
761
	if (oss_periods < s)
762
		oss_periods = s;
763

764
	while (oss_period_size * oss_periods > oss_buffer_size)
765
		oss_period_size /= 2;
766

767
	if (oss_period_size < 16)
768
		return -EINVAL;
769

770
	/* don't allocate too large period; 1MB period must be enough */
771
	if (oss_period_size > 1024 * 1024)
772
		return -ENOMEM;
773

774
	runtime->oss.period_bytes = oss_period_size;
775
	runtime->oss.period_frames = 1;
776
	runtime->oss.periods = oss_periods;
777
	return 0;
778
}
779

780
static int choose_rate(struct snd_pcm_substream *substream,
781
		       struct snd_pcm_hw_params *params, unsigned int best_rate)
782
{
783
	const struct snd_interval *it;
784
	struct snd_pcm_hw_params *save __free(kfree) = NULL;
785
	unsigned int rate, prev;
786

787
	save = kmalloc(sizeof(*save), GFP_KERNEL);
788
	if (save == NULL)
789
		return -ENOMEM;
790
	*save = *params;
791
	it = hw_param_interval_c(save, SNDRV_PCM_HW_PARAM_RATE);
792

793
	/* try multiples of the best rate */
794
	rate = best_rate;
795
	for (;;) {
796
		if (it->max < rate || (it->max == rate && it->openmax))
797
			break;
798
		if (it->min < rate || (it->min == rate && !it->openmin)) {
799
			int ret;
800
			ret = snd_pcm_hw_param_set(substream, params,
801
						   SNDRV_PCM_HW_PARAM_RATE,
802
						   rate, 0);
803
			if (ret == (int)rate)
804
				return rate;
805
			*params = *save;
806
		}
807
		prev = rate;
808
		rate += best_rate;
809
		if (rate <= prev)
810
			break;
811
	}
812

813
	/* not found, use the nearest rate */
814
	return snd_pcm_hw_param_near(substream, params, SNDRV_PCM_HW_PARAM_RATE, best_rate, NULL);
815
}
816

817
/* parameter locking: returns immediately if tried during streaming */
818
static int lock_params(struct snd_pcm_runtime *runtime)
819
{
820
	if (mutex_lock_interruptible(&runtime->oss.params_lock))
821
		return -ERESTARTSYS;
822
	if (atomic_read(&runtime->oss.rw_ref)) {
823
		mutex_unlock(&runtime->oss.params_lock);
824
		return -EBUSY;
825
	}
826
	return 0;
827
}
828

829
static void unlock_params(struct snd_pcm_runtime *runtime)
830
{
831
	mutex_unlock(&runtime->oss.params_lock);
832
}
833

834
static void snd_pcm_oss_release_buffers(struct snd_pcm_substream *substream)
835
{
836
	struct snd_pcm_runtime *runtime = substream->runtime;
837

838
	kvfree(runtime->oss.buffer);
839
	runtime->oss.buffer = NULL;
840
#ifdef CONFIG_SND_PCM_OSS_PLUGINS
841
	snd_pcm_oss_plugin_clear(substream);
842
#endif
843
}
844

845
/* call with params_lock held */
846
static int snd_pcm_oss_change_params_locked(struct snd_pcm_substream *substream)
847
{
848
	struct snd_pcm_runtime *runtime = substream->runtime;
849
	struct snd_pcm_hw_params *params, *sparams;
850
	struct snd_pcm_sw_params *sw_params;
851
	ssize_t oss_buffer_size, oss_period_size;
852
	size_t oss_frame_size;
853
	int err;
854
	int direct;
855
	snd_pcm_format_t format, sformat;
856
	int n;
857
	const struct snd_mask *sformat_mask;
858
	struct snd_mask mask;
859

860
	if (!runtime->oss.params)
861
		return 0;
862
	sw_params = kzalloc(sizeof(*sw_params), GFP_KERNEL);
863
	params = kmalloc(sizeof(*params), GFP_KERNEL);
864
	sparams = kmalloc(sizeof(*sparams), GFP_KERNEL);
865
	if (!sw_params || !params || !sparams) {
866
		err = -ENOMEM;
867
		goto failure;
868
	}
869

870
	if (atomic_read(&substream->mmap_count))
871
		direct = 1;
872
	else
873
		direct = substream->oss.setup.direct;
874

875
	_snd_pcm_hw_params_any(sparams);
876
	_snd_pcm_hw_param_setinteger(sparams, SNDRV_PCM_HW_PARAM_PERIODS);
877
	_snd_pcm_hw_param_min(sparams, SNDRV_PCM_HW_PARAM_PERIODS, 2, 0);
878
	snd_mask_none(&mask);
879
	if (atomic_read(&substream->mmap_count))
880
		snd_mask_set(&mask, (__force int)SNDRV_PCM_ACCESS_MMAP_INTERLEAVED);
881
	else {
882
		snd_mask_set(&mask, (__force int)SNDRV_PCM_ACCESS_RW_INTERLEAVED);
883
		if (!direct)
884
			snd_mask_set(&mask, (__force int)SNDRV_PCM_ACCESS_RW_NONINTERLEAVED);
885
	}
886
	err = snd_pcm_hw_param_mask(substream, sparams, SNDRV_PCM_HW_PARAM_ACCESS, &mask);
887
	if (err < 0) {
888
		pcm_dbg(substream->pcm, "No usable accesses\n");
889
		err = -EINVAL;
890
		goto failure;
891
	}
892

893
	err = choose_rate(substream, sparams, runtime->oss.rate);
894
	if (err < 0)
895
		goto failure;
896
	err = snd_pcm_hw_param_near(substream, sparams,
897
				    SNDRV_PCM_HW_PARAM_CHANNELS,
898
				    runtime->oss.channels, NULL);
899
	if (err < 0)
900
		goto failure;
901

902
	format = snd_pcm_oss_format_from(runtime->oss.format);
903

904
	sformat_mask = hw_param_mask_c(sparams, SNDRV_PCM_HW_PARAM_FORMAT);
905
	if (direct)
906
		sformat = format;
907
	else
908
		sformat = snd_pcm_plug_slave_format(format, sformat_mask);
909

910
	if ((__force int)sformat < 0 ||
911
	    !snd_mask_test_format(sformat_mask, sformat)) {
912
		pcm_for_each_format(sformat) {
913
			if (snd_mask_test_format(sformat_mask, sformat) &&
914
			    snd_pcm_oss_format_to(sformat) >= 0)
915
				goto format_found;
916
		}
917
		pcm_dbg(substream->pcm, "Cannot find a format!!!\n");
918
		err = -EINVAL;
919
		goto failure;
920
	}
921
 format_found:
922
	err = _snd_pcm_hw_param_set(sparams, SNDRV_PCM_HW_PARAM_FORMAT, (__force int)sformat, 0);
923
	if (err < 0)
924
		goto failure;
925

926
	if (direct) {
927
		memcpy(params, sparams, sizeof(*params));
928
	} else {
929
		_snd_pcm_hw_params_any(params);
930
		_snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_ACCESS,
931
				      (__force int)SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
932
		_snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_FORMAT,
933
				      (__force int)snd_pcm_oss_format_from(runtime->oss.format), 0);
934
		_snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_CHANNELS,
935
				      runtime->oss.channels, 0);
936
		_snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_RATE,
937
				      runtime->oss.rate, 0);
938
		pdprintf("client: access = %i, format = %i, channels = %i, rate = %i\n",
939
			 params_access(params), params_format(params),
940
			 params_channels(params), params_rate(params));
941
	}
942
	pdprintf("slave: access = %i, format = %i, channels = %i, rate = %i\n",
943
		 params_access(sparams), params_format(sparams),
944
		 params_channels(sparams), params_rate(sparams));
945

946
	oss_frame_size = snd_pcm_format_physical_width(params_format(params)) *
947
			 params_channels(params) / 8;
948

949
	err = snd_pcm_oss_period_size(substream, params, sparams);
950
	if (err < 0)
951
		goto failure;
952

953
	n = snd_pcm_plug_slave_size(substream, runtime->oss.period_bytes / oss_frame_size);
954
	err = snd_pcm_hw_param_near(substream, sparams, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, n, NULL);
955
	if (err < 0)
956
		goto failure;
957

958
	err = snd_pcm_hw_param_near(substream, sparams, SNDRV_PCM_HW_PARAM_PERIODS,
959
				     runtime->oss.periods, NULL);
960
	if (err < 0)
961
		goto failure;
962

963
	snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
964

965
	err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_HW_PARAMS, sparams);
966
	if (err < 0) {
967
		pcm_dbg(substream->pcm, "HW_PARAMS failed: %i\n", err);
968
		goto failure;
969
	}
970

971
#ifdef CONFIG_SND_PCM_OSS_PLUGINS
972
	snd_pcm_oss_plugin_clear(substream);
973
	if (!direct) {
974
		/* add necessary plugins */
975
		err = snd_pcm_plug_format_plugins(substream, params, sparams);
976
		if (err < 0) {
977
			pcm_dbg(substream->pcm,
978
				"snd_pcm_plug_format_plugins failed: %i\n", err);
979
			goto failure;
980
		}
981
		if (runtime->oss.plugin_first) {
982
			struct snd_pcm_plugin *plugin;
983
			err = snd_pcm_plugin_build_io(substream, sparams, &plugin);
984
			if (err < 0) {
985
				pcm_dbg(substream->pcm,
986
					"snd_pcm_plugin_build_io failed: %i\n", err);
987
				goto failure;
988
			}
989
			if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
990
				err = snd_pcm_plugin_append(plugin);
991
			} else {
992
				err = snd_pcm_plugin_insert(plugin);
993
			}
994
			if (err < 0)
995
				goto failure;
996
		}
997
	}
998
#endif
999

1000
	if (runtime->oss.trigger) {
1001
		sw_params->start_threshold = 1;
1002
	} else {
1003
		sw_params->start_threshold = runtime->boundary;
1004
	}
1005
	if (atomic_read(&substream->mmap_count) ||
1006
	    substream->stream == SNDRV_PCM_STREAM_CAPTURE)
1007
		sw_params->stop_threshold = runtime->boundary;
1008
	else
1009
		sw_params->stop_threshold = runtime->buffer_size;
1010
	sw_params->tstamp_mode = SNDRV_PCM_TSTAMP_NONE;
1011
	sw_params->period_step = 1;
1012
	sw_params->avail_min = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
1013
		1 : runtime->period_size;
1014
	if (atomic_read(&substream->mmap_count) ||
1015
	    substream->oss.setup.nosilence) {
1016
		sw_params->silence_threshold = 0;
1017
		sw_params->silence_size = 0;
1018
	} else {
1019
		snd_pcm_uframes_t frames;
1020
		frames = runtime->period_size + 16;
1021
		if (frames > runtime->buffer_size)
1022
			frames = runtime->buffer_size;
1023
		sw_params->silence_threshold = frames;
1024
		sw_params->silence_size = frames;
1025
	}
1026

1027
	err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_SW_PARAMS, sw_params);
1028
	if (err < 0) {
1029
		pcm_dbg(substream->pcm, "SW_PARAMS failed: %i\n", err);
1030
		goto failure;
1031
	}
1032

1033
	runtime->oss.periods = params_periods(sparams);
1034
	oss_period_size = snd_pcm_plug_client_size(substream, params_period_size(sparams));
1035
	if (oss_period_size < 0) {
1036
		err = -EINVAL;
1037
		goto failure;
1038
	}
1039
#ifdef CONFIG_SND_PCM_OSS_PLUGINS
1040
	if (runtime->oss.plugin_first) {
1041
		err = snd_pcm_plug_alloc(substream, oss_period_size);
1042
		if (err < 0)
1043
			goto failure;
1044
	}
1045
#endif
1046
	oss_period_size = array_size(oss_period_size, oss_frame_size);
1047
	oss_buffer_size = array_size(oss_period_size, runtime->oss.periods);
1048
	if (oss_buffer_size <= 0) {
1049
		err = -EINVAL;
1050
		goto failure;
1051
	}
1052

1053
	runtime->oss.period_bytes = oss_period_size;
1054
	runtime->oss.buffer_bytes = oss_buffer_size;
1055

1056
	pdprintf("oss: period bytes = %i, buffer bytes = %i\n",
1057
		 runtime->oss.period_bytes,
1058
		 runtime->oss.buffer_bytes);
1059
	pdprintf("slave: period_size = %i, buffer_size = %i\n",
1060
		 params_period_size(sparams),
1061
		 params_buffer_size(sparams));
1062

1063
	runtime->oss.format = snd_pcm_oss_format_to(params_format(params));
1064
	runtime->oss.channels = params_channels(params);
1065
	runtime->oss.rate = params_rate(params);
1066

1067
	kvfree(runtime->oss.buffer);
1068
	runtime->oss.buffer = kvzalloc(runtime->oss.period_bytes, GFP_KERNEL);
1069
	if (!runtime->oss.buffer) {
1070
		err = -ENOMEM;
1071
		goto failure;
1072
	}
1073

1074
	runtime->oss.params = 0;
1075
	runtime->oss.prepare = 1;
1076
	runtime->oss.buffer_used = 0;
1077
	snd_pcm_runtime_buffer_set_silence(runtime);
1078

1079
	runtime->oss.period_frames = snd_pcm_alsa_frames(substream, oss_period_size);
1080

1081
	err = 0;
1082
failure:
1083
	if (err)
1084
		snd_pcm_oss_release_buffers(substream);
1085
	kfree(sw_params);
1086
	kfree(params);
1087
	kfree(sparams);
1088
	return err;
1089
}
1090

1091
/* this one takes the lock by itself */
1092
static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream,
1093
				     bool trylock)
1094
{
1095
	struct snd_pcm_runtime *runtime = substream->runtime;
1096
	int err;
1097

1098
	if (trylock) {
1099
		if (!(mutex_trylock(&runtime->oss.params_lock)))
1100
			return -EAGAIN;
1101
	} else if (mutex_lock_interruptible(&runtime->oss.params_lock))
1102
		return -ERESTARTSYS;
1103

1104
	err = snd_pcm_oss_change_params_locked(substream);
1105
	mutex_unlock(&runtime->oss.params_lock);
1106
	return err;
1107
}
1108

1109
static int snd_pcm_oss_get_active_substream(struct snd_pcm_oss_file *pcm_oss_file, struct snd_pcm_substream **r_substream)
1110
{
1111
	int idx, err;
1112
	struct snd_pcm_substream *asubstream = NULL, *substream;
1113

1114
	for (idx = 0; idx < 2; idx++) {
1115
		substream = pcm_oss_file->streams[idx];
1116
		if (substream == NULL)
1117
			continue;
1118
		if (asubstream == NULL)
1119
			asubstream = substream;
1120
		if (substream->runtime->oss.params) {
1121
			err = snd_pcm_oss_change_params(substream, false);
1122
			if (err < 0)
1123
				return err;
1124
		}
1125
	}
1126
	if (!asubstream)
1127
		return -EIO;
1128
	if (r_substream)
1129
		*r_substream = asubstream;
1130
	return 0;
1131
}
1132

1133
/* call with params_lock held */
1134
/* NOTE: this always call PREPARE unconditionally no matter whether
1135
 * runtime->oss.prepare is set or not
1136
 */
1137
static int snd_pcm_oss_prepare(struct snd_pcm_substream *substream)
1138
{
1139
	int err;
1140
	struct snd_pcm_runtime *runtime = substream->runtime;
1141

1142
	err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_PREPARE, NULL);
1143
	if (err < 0) {
1144
		pcm_dbg(substream->pcm,
1145
			"snd_pcm_oss_prepare: SNDRV_PCM_IOCTL_PREPARE failed\n");
1146
		return err;
1147
	}
1148
	runtime->oss.prepare = 0;
1149
	runtime->oss.prev_hw_ptr_period = 0;
1150
	runtime->oss.period_ptr = 0;
1151
	runtime->oss.buffer_used = 0;
1152

1153
	return 0;
1154
}
1155

1156
static int snd_pcm_oss_make_ready(struct snd_pcm_substream *substream)
1157
{
1158
	struct snd_pcm_runtime *runtime;
1159
	int err;
1160

1161
	runtime = substream->runtime;
1162
	if (runtime->oss.params) {
1163
		err = snd_pcm_oss_change_params(substream, false);
1164
		if (err < 0)
1165
			return err;
1166
	}
1167
	if (runtime->oss.prepare) {
1168
		if (mutex_lock_interruptible(&runtime->oss.params_lock))
1169
			return -ERESTARTSYS;
1170
		err = snd_pcm_oss_prepare(substream);
1171
		mutex_unlock(&runtime->oss.params_lock);
1172
		if (err < 0)
1173
			return err;
1174
	}
1175
	return 0;
1176
}
1177

1178
/* call with params_lock held */
1179
static int snd_pcm_oss_make_ready_locked(struct snd_pcm_substream *substream)
1180
{
1181
	struct snd_pcm_runtime *runtime;
1182
	int err;
1183

1184
	runtime = substream->runtime;
1185
	if (runtime->oss.params) {
1186
		err = snd_pcm_oss_change_params_locked(substream);
1187
		if (err < 0)
1188
			return err;
1189
	}
1190
	if (runtime->oss.prepare) {
1191
		err = snd_pcm_oss_prepare(substream);
1192
		if (err < 0)
1193
			return err;
1194
	}
1195
	return 0;
1196
}
1197

1198
static int snd_pcm_oss_capture_position_fixup(struct snd_pcm_substream *substream, snd_pcm_sframes_t *delay)
1199
{
1200
	struct snd_pcm_runtime *runtime;
1201
	snd_pcm_uframes_t frames;
1202
	int err = 0;
1203

1204
	while (1) {
1205
		err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DELAY, delay);
1206
		if (err < 0)
1207
			break;
1208
		runtime = substream->runtime;
1209
		if (*delay <= (snd_pcm_sframes_t)runtime->buffer_size)
1210
			break;
1211
		/* in case of overrun, skip whole periods like OSS/Linux driver does */
1212
		/* until avail(delay) <= buffer_size */
1213
		frames = (*delay - runtime->buffer_size) + runtime->period_size - 1;
1214
		frames /= runtime->period_size;
1215
		frames *= runtime->period_size;
1216
		err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_FORWARD, &frames);
1217
		if (err < 0)
1218
			break;
1219
	}
1220
	return err;
1221
}
1222

1223
snd_pcm_sframes_t snd_pcm_oss_write3(struct snd_pcm_substream *substream, const char *ptr, snd_pcm_uframes_t frames, int in_kernel)
1224
{
1225
	struct snd_pcm_runtime *runtime = substream->runtime;
1226
	int ret;
1227
	while (1) {
1228
		if (runtime->state == SNDRV_PCM_STATE_XRUN ||
1229
		    runtime->state == SNDRV_PCM_STATE_SUSPENDED) {
1230
#ifdef OSS_DEBUG
1231
			pcm_dbg(substream->pcm,
1232
				"pcm_oss: write: recovering from %s\n",
1233
				runtime->state == SNDRV_PCM_STATE_XRUN ?
1234
				"XRUN" : "SUSPEND");
1235
#endif
1236
			ret = snd_pcm_oss_prepare(substream);
1237
			if (ret < 0)
1238
				break;
1239
		}
1240
		mutex_unlock(&runtime->oss.params_lock);
1241
		ret = __snd_pcm_lib_xfer(substream, (void *)ptr, true,
1242
					 frames, in_kernel);
1243
		mutex_lock(&runtime->oss.params_lock);
1244
		if (ret != -EPIPE && ret != -ESTRPIPE)
1245
			break;
1246
		/* test, if we can't store new data, because the stream */
1247
		/* has not been started */
1248
		if (runtime->state == SNDRV_PCM_STATE_PREPARED)
1249
			return -EAGAIN;
1250
	}
1251
	return ret;
1252
}
1253

1254
snd_pcm_sframes_t snd_pcm_oss_read3(struct snd_pcm_substream *substream, char *ptr, snd_pcm_uframes_t frames, int in_kernel)
1255
{
1256
	struct snd_pcm_runtime *runtime = substream->runtime;
1257
	snd_pcm_sframes_t delay;
1258
	int ret;
1259
	while (1) {
1260
		if (runtime->state == SNDRV_PCM_STATE_XRUN ||
1261
		    runtime->state == SNDRV_PCM_STATE_SUSPENDED) {
1262
#ifdef OSS_DEBUG
1263
			pcm_dbg(substream->pcm,
1264
				"pcm_oss: read: recovering from %s\n",
1265
				runtime->state == SNDRV_PCM_STATE_XRUN ?
1266
				"XRUN" : "SUSPEND");
1267
#endif
1268
			ret = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DRAIN, NULL);
1269
			if (ret < 0)
1270
				break;
1271
		} else if (runtime->state == SNDRV_PCM_STATE_SETUP) {
1272
			ret = snd_pcm_oss_prepare(substream);
1273
			if (ret < 0)
1274
				break;
1275
		}
1276
		ret = snd_pcm_oss_capture_position_fixup(substream, &delay);
1277
		if (ret < 0)
1278
			break;
1279
		mutex_unlock(&runtime->oss.params_lock);
1280
		ret = __snd_pcm_lib_xfer(substream, (void *)ptr, true,
1281
					 frames, in_kernel);
1282
		mutex_lock(&runtime->oss.params_lock);
1283
		if (ret == -EPIPE) {
1284
			if (runtime->state == SNDRV_PCM_STATE_DRAINING) {
1285
				ret = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
1286
				if (ret < 0)
1287
					break;
1288
			}
1289
			continue;
1290
		}
1291
		if (ret != -ESTRPIPE)
1292
			break;
1293
	}
1294
	return ret;
1295
}
1296

1297
#ifdef CONFIG_SND_PCM_OSS_PLUGINS
1298
snd_pcm_sframes_t snd_pcm_oss_writev3(struct snd_pcm_substream *substream, void **bufs, snd_pcm_uframes_t frames)
1299
{
1300
	struct snd_pcm_runtime *runtime = substream->runtime;
1301
	int ret;
1302
	while (1) {
1303
		if (runtime->state == SNDRV_PCM_STATE_XRUN ||
1304
		    runtime->state == SNDRV_PCM_STATE_SUSPENDED) {
1305
#ifdef OSS_DEBUG
1306
			pcm_dbg(substream->pcm,
1307
				"pcm_oss: writev: recovering from %s\n",
1308
				runtime->state == SNDRV_PCM_STATE_XRUN ?
1309
				"XRUN" : "SUSPEND");
1310
#endif
1311
			ret = snd_pcm_oss_prepare(substream);
1312
			if (ret < 0)
1313
				break;
1314
		}
1315
		ret = snd_pcm_kernel_writev(substream, bufs, frames);
1316
		if (ret != -EPIPE && ret != -ESTRPIPE)
1317
			break;
1318

1319
		/* test, if we can't store new data, because the stream */
1320
		/* has not been started */
1321
		if (runtime->state == SNDRV_PCM_STATE_PREPARED)
1322
			return -EAGAIN;
1323
	}
1324
	return ret;
1325
}
1326
	
1327
snd_pcm_sframes_t snd_pcm_oss_readv3(struct snd_pcm_substream *substream, void **bufs, snd_pcm_uframes_t frames)
1328
{
1329
	struct snd_pcm_runtime *runtime = substream->runtime;
1330
	int ret;
1331
	while (1) {
1332
		if (runtime->state == SNDRV_PCM_STATE_XRUN ||
1333
		    runtime->state == SNDRV_PCM_STATE_SUSPENDED) {
1334
#ifdef OSS_DEBUG
1335
			pcm_dbg(substream->pcm,
1336
				"pcm_oss: readv: recovering from %s\n",
1337
				runtime->state == SNDRV_PCM_STATE_XRUN ?
1338
				"XRUN" : "SUSPEND");
1339
#endif
1340
			ret = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DRAIN, NULL);
1341
			if (ret < 0)
1342
				break;
1343
		} else if (runtime->state == SNDRV_PCM_STATE_SETUP) {
1344
			ret = snd_pcm_oss_prepare(substream);
1345
			if (ret < 0)
1346
				break;
1347
		}
1348
		ret = snd_pcm_kernel_readv(substream, bufs, frames);
1349
		if (ret != -EPIPE && ret != -ESTRPIPE)
1350
			break;
1351
	}
1352
	return ret;
1353
}
1354
#endif /* CONFIG_SND_PCM_OSS_PLUGINS */
1355

1356
static ssize_t snd_pcm_oss_write2(struct snd_pcm_substream *substream, const char *buf, size_t bytes, int in_kernel)
1357
{
1358
	struct snd_pcm_runtime *runtime = substream->runtime;
1359
	snd_pcm_sframes_t frames, frames1;
1360
#ifdef CONFIG_SND_PCM_OSS_PLUGINS
1361
	if (runtime->oss.plugin_first) {
1362
		struct snd_pcm_plugin_channel *channels;
1363
		size_t oss_frame_bytes = (runtime->oss.plugin_first->src_width * runtime->oss.plugin_first->src_format.channels) / 8;
1364
		if (!in_kernel) {
1365
			if (copy_from_user(runtime->oss.buffer, (const char __force __user *)buf, bytes))
1366
				return -EFAULT;
1367
			buf = runtime->oss.buffer;
1368
		}
1369
		frames = bytes / oss_frame_bytes;
1370
		frames1 = snd_pcm_plug_client_channels_buf(substream, (char *)buf, frames, &channels);
1371
		if (frames1 < 0)
1372
			return frames1;
1373
		frames1 = snd_pcm_plug_write_transfer(substream, channels, frames1);
1374
		if (frames1 <= 0)
1375
			return frames1;
1376
		bytes = frames1 * oss_frame_bytes;
1377
	} else
1378
#endif
1379
	{
1380
		frames = bytes_to_frames(runtime, bytes);
1381
		frames1 = snd_pcm_oss_write3(substream, buf, frames, in_kernel);
1382
		if (frames1 <= 0)
1383
			return frames1;
1384
		bytes = frames_to_bytes(runtime, frames1);
1385
	}
1386
	return bytes;
1387
}
1388

1389
static ssize_t snd_pcm_oss_write1(struct snd_pcm_substream *substream, const char __user *buf, size_t bytes)
1390
{
1391
	size_t xfer = 0;
1392
	ssize_t tmp = 0;
1393
	struct snd_pcm_runtime *runtime = substream->runtime;
1394

1395
	if (atomic_read(&substream->mmap_count))
1396
		return -ENXIO;
1397

1398
	atomic_inc(&runtime->oss.rw_ref);
1399
	while (bytes > 0) {
1400
		if (mutex_lock_interruptible(&runtime->oss.params_lock)) {
1401
			tmp = -ERESTARTSYS;
1402
			break;
1403
		}
1404
		tmp = snd_pcm_oss_make_ready_locked(substream);
1405
		if (tmp < 0)
1406
			goto err;
1407
		if (bytes < runtime->oss.period_bytes || runtime->oss.buffer_used > 0) {
1408
			tmp = bytes;
1409
			if (tmp + runtime->oss.buffer_used > runtime->oss.period_bytes)
1410
				tmp = runtime->oss.period_bytes - runtime->oss.buffer_used;
1411
			if (tmp > 0) {
1412
				if (copy_from_user(runtime->oss.buffer + runtime->oss.buffer_used, buf, tmp)) {
1413
					tmp = -EFAULT;
1414
					goto err;
1415
				}
1416
			}
1417
			runtime->oss.buffer_used += tmp;
1418
			buf += tmp;
1419
			bytes -= tmp;
1420
			xfer += tmp;
1421
			if (substream->oss.setup.partialfrag ||
1422
			    runtime->oss.buffer_used == runtime->oss.period_bytes) {
1423
				tmp = snd_pcm_oss_write2(substream, runtime->oss.buffer + runtime->oss.period_ptr, 
1424
							 runtime->oss.buffer_used - runtime->oss.period_ptr, 1);
1425
				if (tmp <= 0)
1426
					goto err;
1427
				runtime->oss.bytes += tmp;
1428
				runtime->oss.period_ptr += tmp;
1429
				runtime->oss.period_ptr %= runtime->oss.period_bytes;
1430
				if (runtime->oss.period_ptr == 0 ||
1431
				    runtime->oss.period_ptr == runtime->oss.buffer_used)
1432
					runtime->oss.buffer_used = 0;
1433
				else if ((substream->f_flags & O_NONBLOCK) != 0) {
1434
					tmp = -EAGAIN;
1435
					goto err;
1436
				}
1437
			}
1438
		} else {
1439
			tmp = snd_pcm_oss_write2(substream,
1440
						 (const char __force *)buf,
1441
						 runtime->oss.period_bytes, 0);
1442
			if (tmp <= 0)
1443
				goto err;
1444
			runtime->oss.bytes += tmp;
1445
			buf += tmp;
1446
			bytes -= tmp;
1447
			xfer += tmp;
1448
			if ((substream->f_flags & O_NONBLOCK) != 0 &&
1449
			    tmp != runtime->oss.period_bytes)
1450
				tmp = -EAGAIN;
1451
		}
1452
 err:
1453
		mutex_unlock(&runtime->oss.params_lock);
1454
		if (tmp < 0)
1455
			break;
1456
		if (signal_pending(current)) {
1457
			tmp = -ERESTARTSYS;
1458
			break;
1459
		}
1460
		tmp = 0;
1461
	}
1462
	atomic_dec(&runtime->oss.rw_ref);
1463
	return xfer > 0 ? (snd_pcm_sframes_t)xfer : tmp;
1464
}
1465

1466
static ssize_t snd_pcm_oss_read2(struct snd_pcm_substream *substream, char *buf, size_t bytes, int in_kernel)
1467
{
1468
	struct snd_pcm_runtime *runtime = substream->runtime;
1469
	snd_pcm_sframes_t frames, frames1;
1470
#ifdef CONFIG_SND_PCM_OSS_PLUGINS
1471
	char __user *final_dst = (char __force __user *)buf;
1472
	if (runtime->oss.plugin_first) {
1473
		struct snd_pcm_plugin_channel *channels;
1474
		size_t oss_frame_bytes = (runtime->oss.plugin_last->dst_width * runtime->oss.plugin_last->dst_format.channels) / 8;
1475
		if (!in_kernel)
1476
			buf = runtime->oss.buffer;
1477
		frames = bytes / oss_frame_bytes;
1478
		frames1 = snd_pcm_plug_client_channels_buf(substream, buf, frames, &channels);
1479
		if (frames1 < 0)
1480
			return frames1;
1481
		frames1 = snd_pcm_plug_read_transfer(substream, channels, frames1);
1482
		if (frames1 <= 0)
1483
			return frames1;
1484
		bytes = frames1 * oss_frame_bytes;
1485
		if (!in_kernel && copy_to_user(final_dst, buf, bytes))
1486
			return -EFAULT;
1487
	} else
1488
#endif
1489
	{
1490
		frames = bytes_to_frames(runtime, bytes);
1491
		frames1 = snd_pcm_oss_read3(substream, buf, frames, in_kernel);
1492
		if (frames1 <= 0)
1493
			return frames1;
1494
		bytes = frames_to_bytes(runtime, frames1);
1495
	}
1496
	return bytes;
1497
}
1498

1499
static ssize_t snd_pcm_oss_read1(struct snd_pcm_substream *substream, char __user *buf, size_t bytes)
1500
{
1501
	size_t xfer = 0;
1502
	ssize_t tmp = 0;
1503
	struct snd_pcm_runtime *runtime = substream->runtime;
1504

1505
	if (atomic_read(&substream->mmap_count))
1506
		return -ENXIO;
1507

1508
	atomic_inc(&runtime->oss.rw_ref);
1509
	while (bytes > 0) {
1510
		if (mutex_lock_interruptible(&runtime->oss.params_lock)) {
1511
			tmp = -ERESTARTSYS;
1512
			break;
1513
		}
1514
		tmp = snd_pcm_oss_make_ready_locked(substream);
1515
		if (tmp < 0)
1516
			goto err;
1517
		if (bytes < runtime->oss.period_bytes || runtime->oss.buffer_used > 0) {
1518
			if (runtime->oss.buffer_used == 0) {
1519
				tmp = snd_pcm_oss_read2(substream, runtime->oss.buffer, runtime->oss.period_bytes, 1);
1520
				if (tmp <= 0)
1521
					goto err;
1522
				runtime->oss.bytes += tmp;
1523
				runtime->oss.period_ptr = tmp;
1524
				runtime->oss.buffer_used = tmp;
1525
			}
1526
			tmp = bytes;
1527
			if ((size_t) tmp > runtime->oss.buffer_used)
1528
				tmp = runtime->oss.buffer_used;
1529
			if (copy_to_user(buf, runtime->oss.buffer + (runtime->oss.period_ptr - runtime->oss.buffer_used), tmp)) {
1530
				tmp = -EFAULT;
1531
				goto err;
1532
			}
1533
			buf += tmp;
1534
			bytes -= tmp;
1535
			xfer += tmp;
1536
			runtime->oss.buffer_used -= tmp;
1537
		} else {
1538
			tmp = snd_pcm_oss_read2(substream, (char __force *)buf,
1539
						runtime->oss.period_bytes, 0);
1540
			if (tmp <= 0)
1541
				goto err;
1542
			runtime->oss.bytes += tmp;
1543
			buf += tmp;
1544
			bytes -= tmp;
1545
			xfer += tmp;
1546
		}
1547
 err:
1548
		mutex_unlock(&runtime->oss.params_lock);
1549
		if (tmp < 0)
1550
			break;
1551
		if (signal_pending(current)) {
1552
			tmp = -ERESTARTSYS;
1553
			break;
1554
		}
1555
		tmp = 0;
1556
	}
1557
	atomic_dec(&runtime->oss.rw_ref);
1558
	return xfer > 0 ? (snd_pcm_sframes_t)xfer : tmp;
1559
}
1560

1561
static int snd_pcm_oss_reset(struct snd_pcm_oss_file *pcm_oss_file)
1562
{
1563
	struct snd_pcm_substream *substream;
1564
	struct snd_pcm_runtime *runtime;
1565
	int i;
1566

1567
	for (i = 0; i < 2; i++) { 
1568
		substream = pcm_oss_file->streams[i];
1569
		if (!substream)
1570
			continue;
1571
		runtime = substream->runtime;
1572
		snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
1573
		mutex_lock(&runtime->oss.params_lock);
1574
		runtime->oss.prepare = 1;
1575
		runtime->oss.buffer_used = 0;
1576
		runtime->oss.prev_hw_ptr_period = 0;
1577
		runtime->oss.period_ptr = 0;
1578
		mutex_unlock(&runtime->oss.params_lock);
1579
	}
1580
	return 0;
1581
}
1582

1583
static int snd_pcm_oss_post(struct snd_pcm_oss_file *pcm_oss_file)
1584
{
1585
	struct snd_pcm_substream *substream;
1586
	int err;
1587

1588
	substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
1589
	if (substream != NULL) {
1590
		err = snd_pcm_oss_make_ready(substream);
1591
		if (err < 0)
1592
			return err;
1593
		snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_START, NULL);
1594
	}
1595
	/* note: all errors from the start action are ignored */
1596
	/* OSS apps do not know, how to handle them */
1597
	return 0;
1598
}
1599

1600
static int snd_pcm_oss_sync1(struct snd_pcm_substream *substream, size_t size)
1601
{
1602
	struct snd_pcm_runtime *runtime;
1603
	ssize_t result = 0;
1604
	snd_pcm_state_t state;
1605
	long res;
1606
	wait_queue_entry_t wait;
1607

1608
	runtime = substream->runtime;
1609
	init_waitqueue_entry(&wait, current);
1610
	add_wait_queue(&runtime->sleep, &wait);
1611
#ifdef OSS_DEBUG
1612
	pcm_dbg(substream->pcm, "sync1: size = %li\n", size);
1613
#endif
1614
	while (1) {
1615
		result = snd_pcm_oss_write2(substream, runtime->oss.buffer, size, 1);
1616
		if (result > 0) {
1617
			runtime->oss.buffer_used = 0;
1618
			result = 0;
1619
			break;
1620
		}
1621
		if (result != 0 && result != -EAGAIN)
1622
			break;
1623
		result = 0;
1624
		set_current_state(TASK_INTERRUPTIBLE);
1625
		scoped_guard(pcm_stream_lock_irq, substream)
1626
			state = runtime->state;
1627
		if (state != SNDRV_PCM_STATE_RUNNING) {
1628
			set_current_state(TASK_RUNNING);
1629
			break;
1630
		}
1631
		res = schedule_timeout(10 * HZ);
1632
		if (signal_pending(current)) {
1633
			result = -ERESTARTSYS;
1634
			break;
1635
		}
1636
		if (res == 0) {
1637
			pcm_err(substream->pcm,
1638
				"OSS sync error - DMA timeout\n");
1639
			result = -EIO;
1640
			break;
1641
		}
1642
	}
1643
	remove_wait_queue(&runtime->sleep, &wait);
1644
	return result;
1645
}
1646

1647
static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
1648
{
1649
	int err = 0;
1650
	unsigned int saved_f_flags;
1651
	struct snd_pcm_substream *substream;
1652
	struct snd_pcm_runtime *runtime;
1653
	snd_pcm_format_t format;
1654
	unsigned long width;
1655
	size_t size;
1656

1657
	substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
1658
	if (substream != NULL) {
1659
		runtime = substream->runtime;
1660
		if (atomic_read(&substream->mmap_count))
1661
			goto __direct;
1662
		atomic_inc(&runtime->oss.rw_ref);
1663
		if (mutex_lock_interruptible(&runtime->oss.params_lock)) {
1664
			atomic_dec(&runtime->oss.rw_ref);
1665
			return -ERESTARTSYS;
1666
		}
1667
		err = snd_pcm_oss_make_ready_locked(substream);
1668
		if (err < 0)
1669
			goto unlock;
1670
		format = snd_pcm_oss_format_from(runtime->oss.format);
1671
		width = snd_pcm_format_physical_width(format);
1672
		if (runtime->oss.buffer_used > 0) {
1673
#ifdef OSS_DEBUG
1674
			pcm_dbg(substream->pcm, "sync: buffer_used\n");
1675
#endif
1676
			size = (8 * (runtime->oss.period_bytes - runtime->oss.buffer_used) + 7) / width;
1677
			snd_pcm_format_set_silence(format,
1678
						   runtime->oss.buffer + runtime->oss.buffer_used,
1679
						   size);
1680
			err = snd_pcm_oss_sync1(substream, runtime->oss.period_bytes);
1681
			if (err < 0)
1682
				goto unlock;
1683
		} else if (runtime->oss.period_ptr > 0) {
1684
#ifdef OSS_DEBUG
1685
			pcm_dbg(substream->pcm, "sync: period_ptr\n");
1686
#endif
1687
			size = runtime->oss.period_bytes - runtime->oss.period_ptr;
1688
			snd_pcm_format_set_silence(format,
1689
						   runtime->oss.buffer,
1690
						   size * 8 / width);
1691
			err = snd_pcm_oss_sync1(substream, size);
1692
			if (err < 0)
1693
				goto unlock;
1694
		}
1695
		/*
1696
		 * The ALSA's period might be a bit large than OSS one.
1697
		 * Fill the remain portion of ALSA period with zeros.
1698
		 */
1699
		size = runtime->control->appl_ptr % runtime->period_size;
1700
		if (size > 0) {
1701
			size = runtime->period_size - size;
1702
			if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED)
1703
				snd_pcm_lib_write(substream, NULL, size);
1704
			else if (runtime->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
1705
				snd_pcm_lib_writev(substream, NULL, size);
1706
		}
1707
unlock:
1708
		mutex_unlock(&runtime->oss.params_lock);
1709
		atomic_dec(&runtime->oss.rw_ref);
1710
		if (err < 0)
1711
			return err;
1712
		/*
1713
		 * finish sync: drain the buffer
1714
		 */
1715
	      __direct:
1716
		saved_f_flags = substream->f_flags;
1717
		substream->f_flags &= ~O_NONBLOCK;
1718
		err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DRAIN, NULL);
1719
		substream->f_flags = saved_f_flags;
1720
		if (err < 0)
1721
			return err;
1722
		mutex_lock(&runtime->oss.params_lock);
1723
		runtime->oss.prepare = 1;
1724
		mutex_unlock(&runtime->oss.params_lock);
1725
	}
1726

1727
	substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
1728
	if (substream != NULL) {
1729
		err = snd_pcm_oss_make_ready(substream);
1730
		if (err < 0)
1731
			return err;
1732
		runtime = substream->runtime;
1733
		err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
1734
		if (err < 0)
1735
			return err;
1736
		mutex_lock(&runtime->oss.params_lock);
1737
		runtime->oss.buffer_used = 0;
1738
		runtime->oss.prepare = 1;
1739
		mutex_unlock(&runtime->oss.params_lock);
1740
	}
1741
	return 0;
1742
}
1743

1744
static int snd_pcm_oss_set_rate(struct snd_pcm_oss_file *pcm_oss_file, int rate)
1745
{
1746
	int idx;
1747

1748
	for (idx = 1; idx >= 0; --idx) {
1749
		struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
1750
		struct snd_pcm_runtime *runtime;
1751
		int err;
1752

1753
		if (substream == NULL)
1754
			continue;
1755
		runtime = substream->runtime;
1756
		if (rate < 1000)
1757
			rate = 1000;
1758
		else if (rate > 192000)
1759
			rate = 192000;
1760
		err = lock_params(runtime);
1761
		if (err < 0)
1762
			return err;
1763
		if (runtime->oss.rate != rate) {
1764
			runtime->oss.params = 1;
1765
			runtime->oss.rate = rate;
1766
		}
1767
		unlock_params(runtime);
1768
	}
1769
	return snd_pcm_oss_get_rate(pcm_oss_file);
1770
}
1771

1772
static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file *pcm_oss_file)
1773
{
1774
	struct snd_pcm_substream *substream;
1775
	int err;
1776
	
1777
	err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream);
1778
	if (err < 0)
1779
		return err;
1780
	return substream->runtime->oss.rate;
1781
}
1782

1783
static int snd_pcm_oss_set_channels(struct snd_pcm_oss_file *pcm_oss_file, unsigned int channels)
1784
{
1785
	int idx;
1786
	if (channels < 1)
1787
		channels = 1;
1788
	if (channels > 128)
1789
		return -EINVAL;
1790
	for (idx = 1; idx >= 0; --idx) {
1791
		struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
1792
		struct snd_pcm_runtime *runtime;
1793
		int err;
1794

1795
		if (substream == NULL)
1796
			continue;
1797
		runtime = substream->runtime;
1798
		err = lock_params(runtime);
1799
		if (err < 0)
1800
			return err;
1801
		if (runtime->oss.channels != channels) {
1802
			runtime->oss.params = 1;
1803
			runtime->oss.channels = channels;
1804
		}
1805
		unlock_params(runtime);
1806
	}
1807
	return snd_pcm_oss_get_channels(pcm_oss_file);
1808
}
1809

1810
static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file *pcm_oss_file)
1811
{
1812
	struct snd_pcm_substream *substream;
1813
	int err;
1814
	
1815
	err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream);
1816
	if (err < 0)
1817
		return err;
1818
	return substream->runtime->oss.channels;
1819
}
1820

1821
static int snd_pcm_oss_get_block_size(struct snd_pcm_oss_file *pcm_oss_file)
1822
{
1823
	struct snd_pcm_substream *substream;
1824
	int err;
1825
	
1826
	err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream);
1827
	if (err < 0)
1828
		return err;
1829
	return substream->runtime->oss.period_bytes;
1830
}
1831

1832
static int snd_pcm_oss_get_formats(struct snd_pcm_oss_file *pcm_oss_file)
1833
{
1834
	struct snd_pcm_substream *substream;
1835
	int err;
1836
	int direct;
1837
	struct snd_pcm_hw_params *params __free(kfree) = NULL;
1838
	unsigned int formats = 0;
1839
	const struct snd_mask *format_mask;
1840
	int fmt;
1841

1842
	err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream);
1843
	if (err < 0)
1844
		return err;
1845
	if (atomic_read(&substream->mmap_count))
1846
		direct = 1;
1847
	else
1848
		direct = substream->oss.setup.direct;
1849
	if (!direct)
1850
		return AFMT_MU_LAW | AFMT_U8 |
1851
		       AFMT_S16_LE | AFMT_S16_BE |
1852
		       AFMT_S8 | AFMT_U16_LE |
1853
		       AFMT_U16_BE |
1854
			AFMT_S32_LE | AFMT_S32_BE |
1855
			AFMT_S24_LE | AFMT_S24_BE |
1856
			AFMT_S24_PACKED;
1857
	params = kmalloc(sizeof(*params), GFP_KERNEL);
1858
	if (!params)
1859
		return -ENOMEM;
1860
	_snd_pcm_hw_params_any(params);
1861
	err = snd_pcm_hw_refine(substream, params);
1862
	if (err < 0)
1863
		return err;
1864
	format_mask = hw_param_mask_c(params, SNDRV_PCM_HW_PARAM_FORMAT);
1865
	for (fmt = 0; fmt < 32; ++fmt) {
1866
		if (snd_mask_test(format_mask, fmt)) {
1867
			int f = snd_pcm_oss_format_to((__force snd_pcm_format_t)fmt);
1868
			if (f >= 0)
1869
				formats |= f;
1870
		}
1871
	}
1872

1873
	return formats;
1874
}
1875

1876
static int snd_pcm_oss_set_format(struct snd_pcm_oss_file *pcm_oss_file, int format)
1877
{
1878
	int formats, idx;
1879
	int err;
1880
	
1881
	if (format != AFMT_QUERY) {
1882
		formats = snd_pcm_oss_get_formats(pcm_oss_file);
1883
		if (formats < 0)
1884
			return formats;
1885
		if (!(formats & format))
1886
			format = AFMT_U8;
1887
		for (idx = 1; idx >= 0; --idx) {
1888
			struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
1889
			struct snd_pcm_runtime *runtime;
1890
			if (substream == NULL)
1891
				continue;
1892
			runtime = substream->runtime;
1893
			err = lock_params(runtime);
1894
			if (err < 0)
1895
				return err;
1896
			if (runtime->oss.format != format) {
1897
				runtime->oss.params = 1;
1898
				runtime->oss.format = format;
1899
			}
1900
			unlock_params(runtime);
1901
		}
1902
	}
1903
	return snd_pcm_oss_get_format(pcm_oss_file);
1904
}
1905

1906
static int snd_pcm_oss_get_format(struct snd_pcm_oss_file *pcm_oss_file)
1907
{
1908
	struct snd_pcm_substream *substream;
1909
	int err;
1910
	
1911
	err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream);
1912
	if (err < 0)
1913
		return err;
1914
	return substream->runtime->oss.format;
1915
}
1916

1917
static int snd_pcm_oss_set_subdivide1(struct snd_pcm_substream *substream, int subdivide)
1918
{
1919
	struct snd_pcm_runtime *runtime;
1920

1921
	runtime = substream->runtime;
1922
	if (subdivide == 0) {
1923
		subdivide = runtime->oss.subdivision;
1924
		if (subdivide == 0)
1925
			subdivide = 1;
1926
		return subdivide;
1927
	}
1928
	if (runtime->oss.subdivision || runtime->oss.fragshift)
1929
		return -EINVAL;
1930
	if (subdivide != 1 && subdivide != 2 && subdivide != 4 &&
1931
	    subdivide != 8 && subdivide != 16)
1932
		return -EINVAL;
1933
	runtime->oss.subdivision = subdivide;
1934
	runtime->oss.params = 1;
1935
	return subdivide;
1936
}
1937

1938
static int snd_pcm_oss_set_subdivide(struct snd_pcm_oss_file *pcm_oss_file, int subdivide)
1939
{
1940
	int err = -EINVAL, idx;
1941

1942
	for (idx = 1; idx >= 0; --idx) {
1943
		struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
1944
		struct snd_pcm_runtime *runtime;
1945

1946
		if (substream == NULL)
1947
			continue;
1948
		runtime = substream->runtime;
1949
		err = lock_params(runtime);
1950
		if (err < 0)
1951
			return err;
1952
		err = snd_pcm_oss_set_subdivide1(substream, subdivide);
1953
		unlock_params(runtime);
1954
		if (err < 0)
1955
			return err;
1956
	}
1957
	return err;
1958
}
1959

1960
static int snd_pcm_oss_set_fragment1(struct snd_pcm_substream *substream, unsigned int val)
1961
{
1962
	struct snd_pcm_runtime *runtime;
1963
	int fragshift;
1964

1965
	runtime = substream->runtime;
1966
	if (runtime->oss.subdivision || runtime->oss.fragshift)
1967
		return -EINVAL;
1968
	fragshift = val & 0xffff;
1969
	if (fragshift >= 25) /* should be large enough */
1970
		return -EINVAL;
1971
	runtime->oss.fragshift = fragshift;
1972
	runtime->oss.maxfrags = (val >> 16) & 0xffff;
1973
	if (runtime->oss.fragshift < 4)		/* < 16 */
1974
		runtime->oss.fragshift = 4;
1975
	if (runtime->oss.maxfrags < 2)
1976
		runtime->oss.maxfrags = 2;
1977
	runtime->oss.params = 1;
1978
	return 0;
1979
}
1980

1981
static int snd_pcm_oss_set_fragment(struct snd_pcm_oss_file *pcm_oss_file, unsigned int val)
1982
{
1983
	int err = -EINVAL, idx;
1984

1985
	for (idx = 1; idx >= 0; --idx) {
1986
		struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
1987
		struct snd_pcm_runtime *runtime;
1988

1989
		if (substream == NULL)
1990
			continue;
1991
		runtime = substream->runtime;
1992
		err = lock_params(runtime);
1993
		if (err < 0)
1994
			return err;
1995
		err = snd_pcm_oss_set_fragment1(substream, val);
1996
		unlock_params(runtime);
1997
		if (err < 0)
1998
			return err;
1999
	}
2000
	return err;
2001
}
2002

2003
static int snd_pcm_oss_nonblock(struct file * file)
2004
{
2005
	spin_lock(&file->f_lock);
2006
	file->f_flags |= O_NONBLOCK;
2007
	spin_unlock(&file->f_lock);
2008
	return 0;
2009
}
2010

2011
static int snd_pcm_oss_get_caps1(struct snd_pcm_substream *substream, int res)
2012
{
2013

2014
	if (substream == NULL) {
2015
		res &= ~DSP_CAP_DUPLEX;
2016
		return res;
2017
	}
2018
#ifdef DSP_CAP_MULTI
2019
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
2020
		if (substream->pstr->substream_count > 1)
2021
			res |= DSP_CAP_MULTI;
2022
#endif
2023
	/* DSP_CAP_REALTIME is set all times: */
2024
	/* all ALSA drivers can return actual pointer in ring buffer */
2025
#if defined(DSP_CAP_REALTIME) && 0
2026
	{
2027
		struct snd_pcm_runtime *runtime = substream->runtime;
2028
		if (runtime->info & (SNDRV_PCM_INFO_BLOCK_TRANSFER|SNDRV_PCM_INFO_BATCH))
2029
			res &= ~DSP_CAP_REALTIME;
2030
	}
2031
#endif
2032
	return res;
2033
}
2034

2035
static int snd_pcm_oss_get_caps(struct snd_pcm_oss_file *pcm_oss_file)
2036
{
2037
	int result, idx;
2038
	
2039
	result = DSP_CAP_TRIGGER | DSP_CAP_MMAP	| DSP_CAP_DUPLEX | DSP_CAP_REALTIME;
2040
	for (idx = 0; idx < 2; idx++) {
2041
		struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
2042
		result = snd_pcm_oss_get_caps1(substream, result);
2043
	}
2044
	result |= 0x0001;	/* revision - same as SB AWE 64 */
2045
	return result;
2046
}
2047

2048
static void snd_pcm_oss_simulate_fill(struct snd_pcm_substream *substream,
2049
				      snd_pcm_uframes_t hw_ptr)
2050
{
2051
	struct snd_pcm_runtime *runtime = substream->runtime;
2052
	snd_pcm_uframes_t appl_ptr;
2053
	appl_ptr = hw_ptr + runtime->buffer_size;
2054
	appl_ptr %= runtime->boundary;
2055
	runtime->control->appl_ptr = appl_ptr;
2056
}
2057

2058
static int snd_pcm_oss_set_trigger(struct snd_pcm_oss_file *pcm_oss_file, int trigger)
2059
{
2060
	struct snd_pcm_runtime *runtime;
2061
	struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL;
2062
	int err, cmd;
2063

2064
#ifdef OSS_DEBUG
2065
	pr_debug("pcm_oss: trigger = 0x%x\n", trigger);
2066
#endif
2067
	
2068
	psubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
2069
	csubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
2070

2071
	if (psubstream) {
2072
		err = snd_pcm_oss_make_ready(psubstream);
2073
		if (err < 0)
2074
			return err;
2075
	}
2076
	if (csubstream) {
2077
		err = snd_pcm_oss_make_ready(csubstream);
2078
		if (err < 0)
2079
			return err;
2080
	}
2081
      	if (psubstream) {
2082
      		runtime = psubstream->runtime;
2083
		cmd = 0;
2084
		if (mutex_lock_interruptible(&runtime->oss.params_lock))
2085
			return -ERESTARTSYS;
2086
		if (trigger & PCM_ENABLE_OUTPUT) {
2087
			if (runtime->oss.trigger)
2088
				goto _skip1;
2089
			if (atomic_read(&psubstream->mmap_count))
2090
				snd_pcm_oss_simulate_fill(psubstream,
2091
						get_hw_ptr_period(runtime));
2092
			runtime->oss.trigger = 1;
2093
			runtime->start_threshold = 1;
2094
			cmd = SNDRV_PCM_IOCTL_START;
2095
		} else {
2096
			if (!runtime->oss.trigger)
2097
				goto _skip1;
2098
			runtime->oss.trigger = 0;
2099
			runtime->start_threshold = runtime->boundary;
2100
			cmd = SNDRV_PCM_IOCTL_DROP;
2101
			runtime->oss.prepare = 1;
2102
		}
2103
 _skip1:
2104
		mutex_unlock(&runtime->oss.params_lock);
2105
		if (cmd) {
2106
			err = snd_pcm_kernel_ioctl(psubstream, cmd, NULL);
2107
			if (err < 0)
2108
				return err;
2109
		}
2110
	}
2111
	if (csubstream) {
2112
      		runtime = csubstream->runtime;
2113
		cmd = 0;
2114
		if (mutex_lock_interruptible(&runtime->oss.params_lock))
2115
			return -ERESTARTSYS;
2116
		if (trigger & PCM_ENABLE_INPUT) {
2117
			if (runtime->oss.trigger)
2118
				goto _skip2;
2119
			runtime->oss.trigger = 1;
2120
			runtime->start_threshold = 1;
2121
			cmd = SNDRV_PCM_IOCTL_START;
2122
		} else {
2123
			if (!runtime->oss.trigger)
2124
				goto _skip2;
2125
			runtime->oss.trigger = 0;
2126
			runtime->start_threshold = runtime->boundary;
2127
			cmd = SNDRV_PCM_IOCTL_DROP;
2128
			runtime->oss.prepare = 1;
2129
		}
2130
 _skip2:
2131
		mutex_unlock(&runtime->oss.params_lock);
2132
		if (cmd) {
2133
			err = snd_pcm_kernel_ioctl(csubstream, cmd, NULL);
2134
			if (err < 0)
2135
				return err;
2136
		}
2137
	}
2138
	return 0;
2139
}
2140

2141
static int snd_pcm_oss_get_trigger(struct snd_pcm_oss_file *pcm_oss_file)
2142
{
2143
	struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL;
2144
	int result = 0;
2145

2146
	psubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
2147
	csubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
2148
	if (psubstream && psubstream->runtime && psubstream->runtime->oss.trigger)
2149
		result |= PCM_ENABLE_OUTPUT;
2150
	if (csubstream && csubstream->runtime && csubstream->runtime->oss.trigger)
2151
		result |= PCM_ENABLE_INPUT;
2152
	return result;
2153
}
2154

2155
static int snd_pcm_oss_get_odelay(struct snd_pcm_oss_file *pcm_oss_file)
2156
{
2157
	struct snd_pcm_substream *substream;
2158
	struct snd_pcm_runtime *runtime;
2159
	snd_pcm_sframes_t delay;
2160
	int err;
2161

2162
	substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
2163
	if (substream == NULL)
2164
		return -EINVAL;
2165
	err = snd_pcm_oss_make_ready(substream);
2166
	if (err < 0)
2167
		return err;
2168
	runtime = substream->runtime;
2169
	if (runtime->oss.params || runtime->oss.prepare)
2170
		return 0;
2171
	err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DELAY, &delay);
2172
	if (err == -EPIPE)
2173
		delay = 0;	/* hack for broken OSS applications */
2174
	else if (err < 0)
2175
		return err;
2176
	return snd_pcm_oss_bytes(substream, delay);
2177
}
2178

2179
static int snd_pcm_oss_get_ptr(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct count_info __user * _info)
2180
{	
2181
	struct snd_pcm_substream *substream;
2182
	struct snd_pcm_runtime *runtime;
2183
	snd_pcm_sframes_t delay;
2184
	int fixup;
2185
	struct count_info info;
2186
	int err;
2187

2188
	if (_info == NULL)
2189
		return -EFAULT;
2190
	substream = pcm_oss_file->streams[stream];
2191
	if (substream == NULL)
2192
		return -EINVAL;
2193
	err = snd_pcm_oss_make_ready(substream);
2194
	if (err < 0)
2195
		return err;
2196
	runtime = substream->runtime;
2197
	if (runtime->oss.params || runtime->oss.prepare) {
2198
		memset(&info, 0, sizeof(info));
2199
		if (copy_to_user(_info, &info, sizeof(info)))
2200
			return -EFAULT;
2201
		return 0;
2202
	}
2203
	if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
2204
		err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DELAY, &delay);
2205
		if (err == -EPIPE || err == -ESTRPIPE || (! err && delay < 0)) {
2206
			err = 0;
2207
			delay = 0;
2208
			fixup = 0;
2209
		} else {
2210
			fixup = runtime->oss.buffer_used;
2211
		}
2212
	} else {
2213
		err = snd_pcm_oss_capture_position_fixup(substream, &delay);
2214
		fixup = -runtime->oss.buffer_used;
2215
	}
2216
	if (err < 0)
2217
		return err;
2218
	info.ptr = snd_pcm_oss_bytes(substream, runtime->status->hw_ptr % runtime->buffer_size);
2219
	if (atomic_read(&substream->mmap_count)) {
2220
		snd_pcm_sframes_t n;
2221
		delay = get_hw_ptr_period(runtime);
2222
		n = delay - runtime->oss.prev_hw_ptr_period;
2223
		if (n < 0)
2224
			n += runtime->boundary;
2225
		info.blocks = n / runtime->period_size;
2226
		runtime->oss.prev_hw_ptr_period = delay;
2227
		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
2228
			snd_pcm_oss_simulate_fill(substream, delay);
2229
		info.bytes = snd_pcm_oss_bytes(substream, runtime->status->hw_ptr) & INT_MAX;
2230
	} else {
2231
		delay = snd_pcm_oss_bytes(substream, delay);
2232
		if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
2233
			if (substream->oss.setup.buggyptr)
2234
				info.blocks = (runtime->oss.buffer_bytes - delay - fixup) / runtime->oss.period_bytes;
2235
			else
2236
				info.blocks = (delay + fixup) / runtime->oss.period_bytes;
2237
			info.bytes = (runtime->oss.bytes - delay) & INT_MAX;
2238
		} else {
2239
			delay += fixup;
2240
			info.blocks = delay / runtime->oss.period_bytes;
2241
			info.bytes = (runtime->oss.bytes + delay) & INT_MAX;
2242
		}
2243
	}
2244
	if (copy_to_user(_info, &info, sizeof(info)))
2245
		return -EFAULT;
2246
	return 0;
2247
}
2248

2249
static int snd_pcm_oss_get_space(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct audio_buf_info __user *_info)
2250
{
2251
	struct snd_pcm_substream *substream;
2252
	struct snd_pcm_runtime *runtime;
2253
	snd_pcm_sframes_t avail;
2254
	int fixup;
2255
	struct audio_buf_info info;
2256
	int err;
2257

2258
	if (_info == NULL)
2259
		return -EFAULT;
2260
	substream = pcm_oss_file->streams[stream];
2261
	if (substream == NULL)
2262
		return -EINVAL;
2263
	runtime = substream->runtime;
2264

2265
	if (runtime->oss.params) {
2266
		err = snd_pcm_oss_change_params(substream, false);
2267
		if (err < 0)
2268
			return err;
2269
	}
2270

2271
	info.fragsize = runtime->oss.period_bytes;
2272
	info.fragstotal = runtime->periods;
2273
	if (runtime->oss.prepare) {
2274
		if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
2275
			info.bytes = runtime->oss.period_bytes * runtime->oss.periods;
2276
			info.fragments = runtime->oss.periods;
2277
		} else {
2278
			info.bytes = 0;
2279
			info.fragments = 0;
2280
		}
2281
	} else {
2282
		if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
2283
			err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DELAY, &avail);
2284
			if (err == -EPIPE || err == -ESTRPIPE || (! err && avail < 0)) {
2285
				avail = runtime->buffer_size;
2286
				err = 0;
2287
				fixup = 0;
2288
			} else {
2289
				avail = runtime->buffer_size - avail;
2290
				fixup = -runtime->oss.buffer_used;
2291
			}
2292
		} else {
2293
			err = snd_pcm_oss_capture_position_fixup(substream, &avail);
2294
			fixup = runtime->oss.buffer_used;
2295
		}
2296
		if (err < 0)
2297
			return err;
2298
		info.bytes = snd_pcm_oss_bytes(substream, avail) + fixup;
2299
		info.fragments = info.bytes / runtime->oss.period_bytes;
2300
	}
2301

2302
#ifdef OSS_DEBUG
2303
	pcm_dbg(substream->pcm,
2304
		"pcm_oss: space: bytes = %i, fragments = %i, fragstotal = %i, fragsize = %i\n",
2305
		info.bytes, info.fragments, info.fragstotal, info.fragsize);
2306
#endif
2307
	if (copy_to_user(_info, &info, sizeof(info)))
2308
		return -EFAULT;
2309
	return 0;
2310
}
2311

2312
static int snd_pcm_oss_get_mapbuf(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct buffmem_desc __user * _info)
2313
{
2314
	// it won't be probably implemented
2315
	// pr_debug("TODO: snd_pcm_oss_get_mapbuf\n");
2316
	return -EINVAL;
2317
}
2318

2319
static const char *strip_task_path(const char *path)
2320
{
2321
	const char *ptr, *ptrl = NULL;
2322
	for (ptr = path; *ptr; ptr++) {
2323
		if (*ptr == '/')
2324
			ptrl = ptr + 1;
2325
	}
2326
	return ptrl;
2327
}
2328

2329
static void snd_pcm_oss_look_for_setup(struct snd_pcm *pcm, int stream,
2330
				      const char *task_name,
2331
				      struct snd_pcm_oss_setup *rsetup)
2332
{
2333
	struct snd_pcm_oss_setup *setup;
2334

2335
	guard(mutex)(&pcm->streams[stream].oss.setup_mutex);
2336
	do {
2337
		for (setup = pcm->streams[stream].oss.setup_list; setup;
2338
		     setup = setup->next) {
2339
			if (!strcmp(setup->task_name, task_name))
2340
				goto out;
2341
		}
2342
	} while ((task_name = strip_task_path(task_name)) != NULL);
2343
 out:
2344
	if (setup)
2345
		*rsetup = *setup;
2346
}
2347

2348
static void snd_pcm_oss_release_substream(struct snd_pcm_substream *substream)
2349
{
2350
	snd_pcm_oss_release_buffers(substream);
2351
	substream->oss.oss = 0;
2352
}
2353

2354
static void snd_pcm_oss_init_substream(struct snd_pcm_substream *substream,
2355
				       struct snd_pcm_oss_setup *setup,
2356
				       int minor)
2357
{
2358
	struct snd_pcm_runtime *runtime;
2359

2360
	substream->oss.oss = 1;
2361
	substream->oss.setup = *setup;
2362
	if (setup->nonblock)
2363
		substream->f_flags |= O_NONBLOCK;
2364
	else if (setup->block)
2365
		substream->f_flags &= ~O_NONBLOCK;
2366
	runtime = substream->runtime;
2367
	runtime->oss.params = 1;
2368
	runtime->oss.trigger = 1;
2369
	runtime->oss.rate = 8000;
2370
	mutex_init(&runtime->oss.params_lock);
2371
	switch (SNDRV_MINOR_OSS_DEVICE(minor)) {
2372
	case SNDRV_MINOR_OSS_PCM_8:
2373
		runtime->oss.format = AFMT_U8;
2374
		break;
2375
	case SNDRV_MINOR_OSS_PCM_16:
2376
		runtime->oss.format = AFMT_S16_LE;
2377
		break;
2378
	default:
2379
		runtime->oss.format = AFMT_MU_LAW;
2380
	}
2381
	runtime->oss.channels = 1;
2382
	runtime->oss.fragshift = 0;
2383
	runtime->oss.maxfrags = 0;
2384
	runtime->oss.subdivision = 0;
2385
	substream->pcm_release = snd_pcm_oss_release_substream;
2386
	atomic_set(&runtime->oss.rw_ref, 0);
2387
}
2388

2389
static int snd_pcm_oss_release_file(struct snd_pcm_oss_file *pcm_oss_file)
2390
{
2391
	int cidx;
2392
	if (!pcm_oss_file)
2393
		return 0;
2394
	for (cidx = 0; cidx < 2; ++cidx) {
2395
		struct snd_pcm_substream *substream = pcm_oss_file->streams[cidx];
2396
		if (substream)
2397
			snd_pcm_release_substream(substream);
2398
	}
2399
	kfree(pcm_oss_file);
2400
	return 0;
2401
}
2402

2403
static int snd_pcm_oss_open_file(struct file *file,
2404
				 struct snd_pcm *pcm,
2405
				 struct snd_pcm_oss_file **rpcm_oss_file,
2406
				 int minor,
2407
				 struct snd_pcm_oss_setup *setup)
2408
{
2409
	int idx, err;
2410
	struct snd_pcm_oss_file *pcm_oss_file;
2411
	struct snd_pcm_substream *substream;
2412
	fmode_t f_mode = file->f_mode;
2413

2414
	if (rpcm_oss_file)
2415
		*rpcm_oss_file = NULL;
2416

2417
	pcm_oss_file = kzalloc(sizeof(*pcm_oss_file), GFP_KERNEL);
2418
	if (pcm_oss_file == NULL)
2419
		return -ENOMEM;
2420

2421
	if ((f_mode & (FMODE_WRITE|FMODE_READ)) == (FMODE_WRITE|FMODE_READ) &&
2422
	    (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX))
2423
		f_mode = FMODE_WRITE;
2424

2425
	file->f_flags &= ~O_APPEND;
2426
	for (idx = 0; idx < 2; idx++) {
2427
		if (setup[idx].disable)
2428
			continue;
2429
		if (! pcm->streams[idx].substream_count)
2430
			continue; /* no matching substream */
2431
		if (idx == SNDRV_PCM_STREAM_PLAYBACK) {
2432
			if (! (f_mode & FMODE_WRITE))
2433
				continue;
2434
		} else {
2435
			if (! (f_mode & FMODE_READ))
2436
				continue;
2437
		}
2438
		err = snd_pcm_open_substream(pcm, idx, file, &substream);
2439
		if (err < 0) {
2440
			snd_pcm_oss_release_file(pcm_oss_file);
2441
			return err;
2442
		}
2443

2444
		pcm_oss_file->streams[idx] = substream;
2445
		snd_pcm_oss_init_substream(substream, &setup[idx], minor);
2446
	}
2447
	
2448
	if (!pcm_oss_file->streams[0] && !pcm_oss_file->streams[1]) {
2449
		snd_pcm_oss_release_file(pcm_oss_file);
2450
		return -EINVAL;
2451
	}
2452

2453
	file->private_data = pcm_oss_file;
2454
	if (rpcm_oss_file)
2455
		*rpcm_oss_file = pcm_oss_file;
2456
	return 0;
2457
}
2458

2459

2460
static int snd_task_name(struct task_struct *task, char *name, size_t size)
2461
{
2462
	unsigned int idx;
2463

2464
	if (snd_BUG_ON(!task || !name || size < 2))
2465
		return -EINVAL;
2466
	for (idx = 0; idx < sizeof(task->comm) && idx + 1 < size; idx++)
2467
		name[idx] = task->comm[idx];
2468
	name[idx] = '\0';
2469
	return 0;
2470
}
2471

2472
static int snd_pcm_oss_open(struct inode *inode, struct file *file)
2473
{
2474
	int err;
2475
	char task_name[32];
2476
	struct snd_pcm *pcm;
2477
	struct snd_pcm_oss_file *pcm_oss_file;
2478
	struct snd_pcm_oss_setup setup[2];
2479
	int nonblock;
2480
	wait_queue_entry_t wait;
2481

2482
	err = nonseekable_open(inode, file);
2483
	if (err < 0)
2484
		return err;
2485

2486
	pcm = snd_lookup_oss_minor_data(iminor(inode),
2487
					SNDRV_OSS_DEVICE_TYPE_PCM);
2488
	if (pcm == NULL) {
2489
		err = -ENODEV;
2490
		goto __error1;
2491
	}
2492
	err = snd_card_file_add(pcm->card, file);
2493
	if (err < 0)
2494
		goto __error1;
2495
	if (!try_module_get(pcm->card->module)) {
2496
		err = -EFAULT;
2497
		goto __error2;
2498
	}
2499
	if (snd_task_name(current, task_name, sizeof(task_name)) < 0) {
2500
		err = -EFAULT;
2501
		goto __error;
2502
	}
2503
	memset(setup, 0, sizeof(setup));
2504
	if (file->f_mode & FMODE_WRITE)
2505
		snd_pcm_oss_look_for_setup(pcm, SNDRV_PCM_STREAM_PLAYBACK,
2506
					   task_name, &setup[0]);
2507
	if (file->f_mode & FMODE_READ)
2508
		snd_pcm_oss_look_for_setup(pcm, SNDRV_PCM_STREAM_CAPTURE,
2509
					   task_name, &setup[1]);
2510

2511
	nonblock = !!(file->f_flags & O_NONBLOCK);
2512
	if (!nonblock)
2513
		nonblock = nonblock_open;
2514

2515
	init_waitqueue_entry(&wait, current);
2516
	add_wait_queue(&pcm->open_wait, &wait);
2517
	mutex_lock(&pcm->open_mutex);
2518
	while (1) {
2519
		err = snd_pcm_oss_open_file(file, pcm, &pcm_oss_file,
2520
					    iminor(inode), setup);
2521
		if (err >= 0)
2522
			break;
2523
		if (err == -EAGAIN) {
2524
			if (nonblock) {
2525
				err = -EBUSY;
2526
				break;
2527
			}
2528
		} else
2529
			break;
2530
		set_current_state(TASK_INTERRUPTIBLE);
2531
		mutex_unlock(&pcm->open_mutex);
2532
		schedule();
2533
		mutex_lock(&pcm->open_mutex);
2534
		if (pcm->card->shutdown) {
2535
			err = -ENODEV;
2536
			break;
2537
		}
2538
		if (signal_pending(current)) {
2539
			err = -ERESTARTSYS;
2540
			break;
2541
		}
2542
	}
2543
	remove_wait_queue(&pcm->open_wait, &wait);
2544
	mutex_unlock(&pcm->open_mutex);
2545
	if (err < 0)
2546
		goto __error;
2547
	snd_card_unref(pcm->card);
2548
	return err;
2549

2550
      __error:
2551
     	module_put(pcm->card->module);
2552
      __error2:
2553
      	snd_card_file_remove(pcm->card, file);
2554
      __error1:
2555
	if (pcm)
2556
		snd_card_unref(pcm->card);
2557
	return err;
2558
}
2559

2560
static int snd_pcm_oss_release(struct inode *inode, struct file *file)
2561
{
2562
	struct snd_pcm *pcm;
2563
	struct snd_pcm_substream *substream;
2564
	struct snd_pcm_oss_file *pcm_oss_file;
2565

2566
	pcm_oss_file = file->private_data;
2567
	substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
2568
	if (substream == NULL)
2569
		substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
2570
	if (snd_BUG_ON(!substream))
2571
		return -ENXIO;
2572
	pcm = substream->pcm;
2573
	if (!pcm->card->shutdown)
2574
		snd_pcm_oss_sync(pcm_oss_file);
2575
	mutex_lock(&pcm->open_mutex);
2576
	snd_pcm_oss_release_file(pcm_oss_file);
2577
	mutex_unlock(&pcm->open_mutex);
2578
	wake_up(&pcm->open_wait);
2579
	module_put(pcm->card->module);
2580
	snd_card_file_remove(pcm->card, file);
2581
	return 0;
2582
}
2583

2584
static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2585
{
2586
	struct snd_pcm_oss_file *pcm_oss_file;
2587
	int __user *p = (int __user *)arg;
2588
	int res;
2589

2590
	pcm_oss_file = file->private_data;
2591
	if (cmd == OSS_GETVERSION)
2592
		return put_user(SNDRV_OSS_VERSION, p);
2593
	if (cmd == OSS_ALSAEMULVER)
2594
		return put_user(1, p);
2595
#if IS_REACHABLE(CONFIG_SND_MIXER_OSS)
2596
	if (((cmd >> 8) & 0xff) == 'M')	{	/* mixer ioctl - for OSS compatibility */
2597
		struct snd_pcm_substream *substream;
2598
		int idx;
2599
		for (idx = 0; idx < 2; ++idx) {
2600
			substream = pcm_oss_file->streams[idx];
2601
			if (substream != NULL)
2602
				break;
2603
		}
2604
		if (snd_BUG_ON(idx >= 2))
2605
			return -ENXIO;
2606
		return snd_mixer_oss_ioctl_card(substream->pcm->card, cmd, arg);
2607
	}
2608
#endif
2609
	if (((cmd >> 8) & 0xff) != 'P')
2610
		return -EINVAL;
2611
#ifdef OSS_DEBUG
2612
	pr_debug("pcm_oss: ioctl = 0x%x\n", cmd);
2613
#endif
2614
	switch (cmd) {
2615
	case SNDCTL_DSP_RESET:
2616
		return snd_pcm_oss_reset(pcm_oss_file);
2617
	case SNDCTL_DSP_SYNC:
2618
		return snd_pcm_oss_sync(pcm_oss_file);
2619
	case SNDCTL_DSP_SPEED:
2620
		if (get_user(res, p))
2621
			return -EFAULT;
2622
		res = snd_pcm_oss_set_rate(pcm_oss_file, res);
2623
		if (res < 0)
2624
			return res;
2625
		return put_user(res, p);
2626
	case SOUND_PCM_READ_RATE:
2627
		res = snd_pcm_oss_get_rate(pcm_oss_file);
2628
		if (res < 0)
2629
			return res;
2630
		return put_user(res, p);
2631
	case SNDCTL_DSP_STEREO:
2632
		if (get_user(res, p))
2633
			return -EFAULT;
2634
		res = res > 0 ? 2 : 1;
2635
		res = snd_pcm_oss_set_channels(pcm_oss_file, res);
2636
		if (res < 0)
2637
			return res;
2638
		return put_user(--res, p);
2639
	case SNDCTL_DSP_GETBLKSIZE:
2640
		res = snd_pcm_oss_get_block_size(pcm_oss_file);
2641
		if (res < 0)
2642
			return res;
2643
		return put_user(res, p);
2644
	case SNDCTL_DSP_SETFMT:
2645
		if (get_user(res, p))
2646
			return -EFAULT;
2647
		res = snd_pcm_oss_set_format(pcm_oss_file, res);
2648
		if (res < 0)
2649
			return res;
2650
		return put_user(res, p);
2651
	case SOUND_PCM_READ_BITS:
2652
		res = snd_pcm_oss_get_format(pcm_oss_file);
2653
		if (res < 0)
2654
			return res;
2655
		return put_user(res, p);
2656
	case SNDCTL_DSP_CHANNELS:
2657
		if (get_user(res, p))
2658
			return -EFAULT;
2659
		res = snd_pcm_oss_set_channels(pcm_oss_file, res);
2660
		if (res < 0)
2661
			return res;
2662
		return put_user(res, p);
2663
	case SOUND_PCM_READ_CHANNELS:
2664
		res = snd_pcm_oss_get_channels(pcm_oss_file);
2665
		if (res < 0)
2666
			return res;
2667
		return put_user(res, p);
2668
	case SOUND_PCM_WRITE_FILTER:
2669
	case SOUND_PCM_READ_FILTER:
2670
		return -EIO;
2671
	case SNDCTL_DSP_POST:
2672
		return snd_pcm_oss_post(pcm_oss_file);
2673
	case SNDCTL_DSP_SUBDIVIDE:
2674
		if (get_user(res, p))
2675
			return -EFAULT;
2676
		res = snd_pcm_oss_set_subdivide(pcm_oss_file, res);
2677
		if (res < 0)
2678
			return res;
2679
		return put_user(res, p);
2680
	case SNDCTL_DSP_SETFRAGMENT:
2681
		if (get_user(res, p))
2682
			return -EFAULT;
2683
		return snd_pcm_oss_set_fragment(pcm_oss_file, res);
2684
	case SNDCTL_DSP_GETFMTS:
2685
		res = snd_pcm_oss_get_formats(pcm_oss_file);
2686
		if (res < 0)
2687
			return res;
2688
		return put_user(res, p);
2689
	case SNDCTL_DSP_GETOSPACE:
2690
	case SNDCTL_DSP_GETISPACE:
2691
		return snd_pcm_oss_get_space(pcm_oss_file,
2692
			cmd == SNDCTL_DSP_GETISPACE ?
2693
				SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK,
2694
			(struct audio_buf_info __user *) arg);
2695
	case SNDCTL_DSP_NONBLOCK:
2696
		return snd_pcm_oss_nonblock(file);
2697
	case SNDCTL_DSP_GETCAPS:
2698
		res = snd_pcm_oss_get_caps(pcm_oss_file);
2699
		if (res < 0)
2700
			return res;
2701
		return put_user(res, p);
2702
	case SNDCTL_DSP_GETTRIGGER:
2703
		res = snd_pcm_oss_get_trigger(pcm_oss_file);
2704
		if (res < 0)
2705
			return res;
2706
		return put_user(res, p);
2707
	case SNDCTL_DSP_SETTRIGGER:
2708
		if (get_user(res, p))
2709
			return -EFAULT;
2710
		return snd_pcm_oss_set_trigger(pcm_oss_file, res);
2711
	case SNDCTL_DSP_GETIPTR:
2712
	case SNDCTL_DSP_GETOPTR:
2713
		return snd_pcm_oss_get_ptr(pcm_oss_file,
2714
			cmd == SNDCTL_DSP_GETIPTR ?
2715
				SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK,
2716
			(struct count_info __user *) arg);
2717
	case SNDCTL_DSP_MAPINBUF:
2718
	case SNDCTL_DSP_MAPOUTBUF:
2719
		return snd_pcm_oss_get_mapbuf(pcm_oss_file,
2720
			cmd == SNDCTL_DSP_MAPINBUF ?
2721
				SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK,
2722
			(struct buffmem_desc __user *) arg);
2723
	case SNDCTL_DSP_SETSYNCRO:
2724
		/* stop DMA now.. */
2725
		return 0;
2726
	case SNDCTL_DSP_SETDUPLEX:
2727
		if (snd_pcm_oss_get_caps(pcm_oss_file) & DSP_CAP_DUPLEX)
2728
			return 0;
2729
		return -EIO;
2730
	case SNDCTL_DSP_GETODELAY:
2731
		res = snd_pcm_oss_get_odelay(pcm_oss_file);
2732
		if (res < 0) {
2733
			/* it's for sure, some broken apps don't check for error codes */
2734
			put_user(0, p);
2735
			return res;
2736
		}
2737
		return put_user(res, p);
2738
	case SNDCTL_DSP_PROFILE:
2739
		return 0;	/* silently ignore */
2740
	default:
2741
		pr_debug("pcm_oss: unknown command = 0x%x\n", cmd);
2742
	}
2743
	return -EINVAL;
2744
}
2745

2746
#ifdef CONFIG_COMPAT
2747
/* all compatible */
2748
static long snd_pcm_oss_ioctl_compat(struct file *file, unsigned int cmd,
2749
				     unsigned long arg)
2750
{
2751
	/*
2752
	 * Everything is compatbile except SNDCTL_DSP_MAPINBUF/SNDCTL_DSP_MAPOUTBUF,
2753
	 * which are not implemented for the native case either
2754
	 */
2755
	return snd_pcm_oss_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
2756
}
2757
#else
2758
#define snd_pcm_oss_ioctl_compat	NULL
2759
#endif
2760

2761
static ssize_t snd_pcm_oss_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
2762
{
2763
	struct snd_pcm_oss_file *pcm_oss_file;
2764
	struct snd_pcm_substream *substream;
2765

2766
	pcm_oss_file = file->private_data;
2767
	substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
2768
	if (substream == NULL)
2769
		return -ENXIO;
2770
	substream->f_flags = file->f_flags & O_NONBLOCK;
2771
#ifndef OSS_DEBUG
2772
	return snd_pcm_oss_read1(substream, buf, count);
2773
#else
2774
	{
2775
		ssize_t res = snd_pcm_oss_read1(substream, buf, count);
2776
		pcm_dbg(substream->pcm,
2777
			"pcm_oss: read %li bytes (returned %li bytes)\n",
2778
			(long)count, (long)res);
2779
		return res;
2780
	}
2781
#endif
2782
}
2783

2784
static ssize_t snd_pcm_oss_write(struct file *file, const char __user *buf, size_t count, loff_t *offset)
2785
{
2786
	struct snd_pcm_oss_file *pcm_oss_file;
2787
	struct snd_pcm_substream *substream;
2788
	long result;
2789

2790
	pcm_oss_file = file->private_data;
2791
	substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
2792
	if (substream == NULL)
2793
		return -ENXIO;
2794
	substream->f_flags = file->f_flags & O_NONBLOCK;
2795
	result = snd_pcm_oss_write1(substream, buf, count);
2796
#ifdef OSS_DEBUG
2797
	pcm_dbg(substream->pcm, "pcm_oss: write %li bytes (wrote %li bytes)\n",
2798
	       (long)count, (long)result);
2799
#endif
2800
	return result;
2801
}
2802

2803
static int snd_pcm_oss_playback_ready(struct snd_pcm_substream *substream)
2804
{
2805
	struct snd_pcm_runtime *runtime = substream->runtime;
2806
	if (atomic_read(&substream->mmap_count))
2807
		return runtime->oss.prev_hw_ptr_period !=
2808
						get_hw_ptr_period(runtime);
2809
	else
2810
		return snd_pcm_playback_avail(runtime) >=
2811
						runtime->oss.period_frames;
2812
}
2813

2814
static int snd_pcm_oss_capture_ready(struct snd_pcm_substream *substream)
2815
{
2816
	struct snd_pcm_runtime *runtime = substream->runtime;
2817
	if (atomic_read(&substream->mmap_count))
2818
		return runtime->oss.prev_hw_ptr_period !=
2819
						get_hw_ptr_period(runtime);
2820
	else
2821
		return snd_pcm_capture_avail(runtime) >=
2822
						runtime->oss.period_frames;
2823
}
2824

2825
static __poll_t snd_pcm_oss_poll(struct file *file, poll_table * wait)
2826
{
2827
	struct snd_pcm_oss_file *pcm_oss_file;
2828
	__poll_t mask;
2829
	struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL;
2830
	
2831
	pcm_oss_file = file->private_data;
2832

2833
	psubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
2834
	csubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
2835

2836
	mask = 0;
2837
	if (psubstream != NULL) {
2838
		struct snd_pcm_runtime *runtime = psubstream->runtime;
2839
		poll_wait(file, &runtime->sleep, wait);
2840
		scoped_guard(pcm_stream_lock_irq, psubstream) {
2841
			if (runtime->state != SNDRV_PCM_STATE_DRAINING &&
2842
			    (runtime->state != SNDRV_PCM_STATE_RUNNING ||
2843
			     snd_pcm_oss_playback_ready(psubstream)))
2844
				mask |= EPOLLOUT | EPOLLWRNORM;
2845
		}
2846
	}
2847
	if (csubstream != NULL) {
2848
		struct snd_pcm_runtime *runtime = csubstream->runtime;
2849
		snd_pcm_state_t ostate;
2850
		poll_wait(file, &runtime->sleep, wait);
2851
		scoped_guard(pcm_stream_lock_irq, csubstream) {
2852
			ostate = runtime->state;
2853
			if (ostate != SNDRV_PCM_STATE_RUNNING ||
2854
			    snd_pcm_oss_capture_ready(csubstream))
2855
				mask |= EPOLLIN | EPOLLRDNORM;
2856
		}
2857
		if (ostate != SNDRV_PCM_STATE_RUNNING && runtime->oss.trigger) {
2858
			struct snd_pcm_oss_file ofile;
2859
			memset(&ofile, 0, sizeof(ofile));
2860
			ofile.streams[SNDRV_PCM_STREAM_CAPTURE] = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
2861
			runtime->oss.trigger = 0;
2862
			snd_pcm_oss_set_trigger(&ofile, PCM_ENABLE_INPUT);
2863
		}
2864
	}
2865

2866
	return mask;
2867
}
2868

2869
static int snd_pcm_oss_mmap(struct file *file, struct vm_area_struct *area)
2870
{
2871
	struct snd_pcm_oss_file *pcm_oss_file;
2872
	struct snd_pcm_substream *substream = NULL;
2873
	struct snd_pcm_runtime *runtime;
2874
	int err;
2875

2876
#ifdef OSS_DEBUG
2877
	pr_debug("pcm_oss: mmap begin\n");
2878
#endif
2879
	pcm_oss_file = file->private_data;
2880
	switch ((area->vm_flags & (VM_READ | VM_WRITE))) {
2881
	case VM_READ | VM_WRITE:
2882
		substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
2883
		if (substream)
2884
			break;
2885
		fallthrough;
2886
	case VM_READ:
2887
		substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
2888
		break;
2889
	case VM_WRITE:
2890
		substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
2891
		break;
2892
	default:
2893
		return -EINVAL;
2894
	}
2895
	/* set VM_READ access as well to fix memset() routines that do
2896
	   reads before writes (to improve performance) */
2897
	vm_flags_set(area, VM_READ);
2898
	if (substream == NULL)
2899
		return -ENXIO;
2900
	runtime = substream->runtime;
2901
	if (!(runtime->info & SNDRV_PCM_INFO_MMAP_VALID))
2902
		return -EIO;
2903
	if (runtime->info & SNDRV_PCM_INFO_INTERLEAVED)
2904
		runtime->access = SNDRV_PCM_ACCESS_MMAP_INTERLEAVED;
2905
	else
2906
		return -EIO;
2907
	
2908
	if (runtime->oss.params) {
2909
		/* use mutex_trylock() for params_lock for avoiding a deadlock
2910
		 * between mmap_lock and params_lock taken by
2911
		 * copy_from/to_user() in snd_pcm_oss_write/read()
2912
		 */
2913
		err = snd_pcm_oss_change_params(substream, true);
2914
		if (err < 0)
2915
			return err;
2916
	}
2917
#ifdef CONFIG_SND_PCM_OSS_PLUGINS
2918
	if (runtime->oss.plugin_first != NULL)
2919
		return -EIO;
2920
#endif
2921

2922
	if (area->vm_pgoff != 0)
2923
		return -EINVAL;
2924

2925
	err = snd_pcm_mmap_data(substream, file, area);
2926
	if (err < 0)
2927
		return err;
2928
	runtime->oss.mmap_bytes = area->vm_end - area->vm_start;
2929
	runtime->silence_threshold = 0;
2930
	runtime->silence_size = 0;
2931
#ifdef OSS_DEBUG
2932
	pr_debug("pcm_oss: mmap ok, bytes = 0x%x\n",
2933
	       runtime->oss.mmap_bytes);
2934
#endif
2935
	/* In mmap mode we never stop */
2936
	runtime->stop_threshold = runtime->boundary;
2937

2938
	return 0;
2939
}
2940

2941
#ifdef CONFIG_SND_VERBOSE_PROCFS
2942
/*
2943
 *  /proc interface
2944
 */
2945

2946
static void snd_pcm_oss_proc_read(struct snd_info_entry *entry,
2947
				  struct snd_info_buffer *buffer)
2948
{
2949
	struct snd_pcm_str *pstr = entry->private_data;
2950
	struct snd_pcm_oss_setup *setup = pstr->oss.setup_list;
2951
	guard(mutex)(&pstr->oss.setup_mutex);
2952
	while (setup) {
2953
		snd_iprintf(buffer, "%s %u %u%s%s%s%s%s%s\n",
2954
			    setup->task_name,
2955
			    setup->periods,
2956
			    setup->period_size,
2957
			    setup->disable ? " disable" : "",
2958
			    setup->direct ? " direct" : "",
2959
			    setup->block ? " block" : "",
2960
			    setup->nonblock ? " non-block" : "",
2961
			    setup->partialfrag ? " partial-frag" : "",
2962
			    setup->nosilence ? " no-silence" : "");
2963
		setup = setup->next;
2964
	}
2965
}
2966

2967
static void snd_pcm_oss_proc_free_setup_list(struct snd_pcm_str * pstr)
2968
{
2969
	struct snd_pcm_oss_setup *setup, *setupn;
2970

2971
	for (setup = pstr->oss.setup_list, pstr->oss.setup_list = NULL;
2972
	     setup; setup = setupn) {
2973
		setupn = setup->next;
2974
		kfree(setup->task_name);
2975
		kfree(setup);
2976
	}
2977
	pstr->oss.setup_list = NULL;
2978
}
2979

2980
static void snd_pcm_oss_proc_write(struct snd_info_entry *entry,
2981
				   struct snd_info_buffer *buffer)
2982
{
2983
	struct snd_pcm_str *pstr = entry->private_data;
2984
	char line[128], str[32], task_name[32];
2985
	const char *ptr;
2986
	int idx1;
2987
	struct snd_pcm_oss_setup *setup, *setup1, template;
2988

2989
	while (!snd_info_get_line(buffer, line, sizeof(line))) {
2990
		guard(mutex)(&pstr->oss.setup_mutex);
2991
		memset(&template, 0, sizeof(template));
2992
		ptr = snd_info_get_str(task_name, line, sizeof(task_name));
2993
		if (!strcmp(task_name, "clear") || !strcmp(task_name, "erase")) {
2994
			snd_pcm_oss_proc_free_setup_list(pstr);
2995
			continue;
2996
		}
2997
		for (setup = pstr->oss.setup_list; setup; setup = setup->next) {
2998
			if (!strcmp(setup->task_name, task_name)) {
2999
				template = *setup;
3000
				break;
3001
			}
3002
		}
3003
		ptr = snd_info_get_str(str, ptr, sizeof(str));
3004
		template.periods = simple_strtoul(str, NULL, 10);
3005
		ptr = snd_info_get_str(str, ptr, sizeof(str));
3006
		template.period_size = simple_strtoul(str, NULL, 10);
3007
		for (idx1 = 31; idx1 >= 0; idx1--)
3008
			if (template.period_size & (1 << idx1))
3009
				break;
3010
		for (idx1--; idx1 >= 0; idx1--)
3011
			template.period_size &= ~(1 << idx1);
3012
		do {
3013
			ptr = snd_info_get_str(str, ptr, sizeof(str));
3014
			if (!strcmp(str, "disable")) {
3015
				template.disable = 1;
3016
			} else if (!strcmp(str, "direct")) {
3017
				template.direct = 1;
3018
			} else if (!strcmp(str, "block")) {
3019
				template.block = 1;
3020
			} else if (!strcmp(str, "non-block")) {
3021
				template.nonblock = 1;
3022
			} else if (!strcmp(str, "partial-frag")) {
3023
				template.partialfrag = 1;
3024
			} else if (!strcmp(str, "no-silence")) {
3025
				template.nosilence = 1;
3026
			} else if (!strcmp(str, "buggy-ptr")) {
3027
				template.buggyptr = 1;
3028
			}
3029
		} while (*str);
3030
		if (setup == NULL) {
3031
			setup = kmalloc(sizeof(*setup), GFP_KERNEL);
3032
			if (! setup) {
3033
				buffer->error = -ENOMEM;
3034
				return;
3035
			}
3036
			if (pstr->oss.setup_list == NULL)
3037
				pstr->oss.setup_list = setup;
3038
			else {
3039
				for (setup1 = pstr->oss.setup_list;
3040
				     setup1->next; setup1 = setup1->next);
3041
				setup1->next = setup;
3042
			}
3043
			template.task_name = kstrdup(task_name, GFP_KERNEL);
3044
			if (! template.task_name) {
3045
				kfree(setup);
3046
				buffer->error = -ENOMEM;
3047
				return;
3048
			}
3049
		}
3050
		*setup = template;
3051
	}
3052
}
3053

3054
static void snd_pcm_oss_proc_init(struct snd_pcm *pcm)
3055
{
3056
	int stream;
3057
	for (stream = 0; stream < 2; ++stream) {
3058
		struct snd_info_entry *entry;
3059
		struct snd_pcm_str *pstr = &pcm->streams[stream];
3060
		if (pstr->substream_count == 0)
3061
			continue;
3062
		entry = snd_info_create_card_entry(pcm->card, "oss", pstr->proc_root);
3063
		if (entry) {
3064
			entry->content = SNDRV_INFO_CONTENT_TEXT;
3065
			entry->mode = S_IFREG | 0644;
3066
			entry->c.text.read = snd_pcm_oss_proc_read;
3067
			entry->c.text.write = snd_pcm_oss_proc_write;
3068
			entry->private_data = pstr;
3069
			if (snd_info_register(entry) < 0) {
3070
				snd_info_free_entry(entry);
3071
				entry = NULL;
3072
			}
3073
		}
3074
		pstr->oss.proc_entry = entry;
3075
	}
3076
}
3077

3078
static void snd_pcm_oss_proc_done(struct snd_pcm *pcm)
3079
{
3080
	int stream;
3081
	for (stream = 0; stream < 2; ++stream) {
3082
		struct snd_pcm_str *pstr = &pcm->streams[stream];
3083
		snd_info_free_entry(pstr->oss.proc_entry);
3084
		pstr->oss.proc_entry = NULL;
3085
		snd_pcm_oss_proc_free_setup_list(pstr);
3086
	}
3087
}
3088
#else /* !CONFIG_SND_VERBOSE_PROCFS */
3089
static inline void snd_pcm_oss_proc_init(struct snd_pcm *pcm)
3090
{
3091
}
3092
static inline void snd_pcm_oss_proc_done(struct snd_pcm *pcm)
3093
{
3094
}
3095
#endif /* CONFIG_SND_VERBOSE_PROCFS */
3096

3097
/*
3098
 *  ENTRY functions
3099
 */
3100

3101
static const struct file_operations snd_pcm_oss_f_reg =
3102
{
3103
	.owner =	THIS_MODULE,
3104
	.read =		snd_pcm_oss_read,
3105
	.write =	snd_pcm_oss_write,
3106
	.open =		snd_pcm_oss_open,
3107
	.release =	snd_pcm_oss_release,
3108
	.poll =		snd_pcm_oss_poll,
3109
	.unlocked_ioctl =	snd_pcm_oss_ioctl,
3110
	.compat_ioctl =	snd_pcm_oss_ioctl_compat,
3111
	.mmap =		snd_pcm_oss_mmap,
3112
};
3113

3114
static void register_oss_dsp(struct snd_pcm *pcm, int index)
3115
{
3116
	if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM,
3117
				    pcm->card, index, &snd_pcm_oss_f_reg,
3118
				    pcm) < 0) {
3119
		pcm_err(pcm, "unable to register OSS PCM device %i:%i\n",
3120
			   pcm->card->number, pcm->device);
3121
	}
3122
}
3123

3124
static int snd_pcm_oss_register_minor(struct snd_pcm *pcm)
3125
{
3126
	pcm->oss.reg = 0;
3127
	if (dsp_map[pcm->card->number] == (int)pcm->device) {
3128
		char name[128];
3129
		int duplex;
3130
		register_oss_dsp(pcm, 0);
3131
		duplex = (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream_count > 0 && 
3132
			      pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count && 
3133
			      !(pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX));
3134
		sprintf(name, "%s%s", pcm->name, duplex ? " (DUPLEX)" : "");
3135
#ifdef SNDRV_OSS_INFO_DEV_AUDIO
3136
		snd_oss_info_register(SNDRV_OSS_INFO_DEV_AUDIO,
3137
				      pcm->card->number,
3138
				      name);
3139
#endif
3140
		pcm->oss.reg++;
3141
		pcm->oss.reg_mask |= 1;
3142
	}
3143
	if (adsp_map[pcm->card->number] == (int)pcm->device) {
3144
		register_oss_dsp(pcm, 1);
3145
		pcm->oss.reg++;
3146
		pcm->oss.reg_mask |= 2;
3147
	}
3148

3149
	if (pcm->oss.reg)
3150
		snd_pcm_oss_proc_init(pcm);
3151

3152
	return 0;
3153
}
3154

3155
static int snd_pcm_oss_disconnect_minor(struct snd_pcm *pcm)
3156
{
3157
	if (pcm->oss.reg) {
3158
		if (pcm->oss.reg_mask & 1) {
3159
			pcm->oss.reg_mask &= ~1;
3160
			snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM,
3161
						  pcm->card, 0);
3162
		}
3163
		if (pcm->oss.reg_mask & 2) {
3164
			pcm->oss.reg_mask &= ~2;
3165
			snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM,
3166
						  pcm->card, 1);
3167
		}
3168
		if (dsp_map[pcm->card->number] == (int)pcm->device) {
3169
#ifdef SNDRV_OSS_INFO_DEV_AUDIO
3170
			snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_AUDIO, pcm->card->number);
3171
#endif
3172
		}
3173
		pcm->oss.reg = 0;
3174
	}
3175
	return 0;
3176
}
3177

3178
static int snd_pcm_oss_unregister_minor(struct snd_pcm *pcm)
3179
{
3180
	snd_pcm_oss_disconnect_minor(pcm);
3181
	snd_pcm_oss_proc_done(pcm);
3182
	return 0;
3183
}
3184

3185
static struct snd_pcm_notify snd_pcm_oss_notify =
3186
{
3187
	.n_register =	snd_pcm_oss_register_minor,
3188
	.n_disconnect = snd_pcm_oss_disconnect_minor,
3189
	.n_unregister =	snd_pcm_oss_unregister_minor,
3190
};
3191

3192
static int __init alsa_pcm_oss_init(void)
3193
{
3194
	int i;
3195
	int err;
3196

3197
	/* check device map table */
3198
	for (i = 0; i < SNDRV_CARDS; i++) {
3199
		if (dsp_map[i] < 0 || dsp_map[i] >= SNDRV_PCM_DEVICES) {
3200
			pr_err("ALSA: pcm_oss: invalid dsp_map[%d] = %d\n",
3201
				   i, dsp_map[i]);
3202
			dsp_map[i] = 0;
3203
		}
3204
		if (adsp_map[i] < 0 || adsp_map[i] >= SNDRV_PCM_DEVICES) {
3205
			pr_err("ALSA: pcm_oss: invalid adsp_map[%d] = %d\n",
3206
				   i, adsp_map[i]);
3207
			adsp_map[i] = 1;
3208
		}
3209
	}
3210
	err = snd_pcm_notify(&snd_pcm_oss_notify, 0);
3211
	if (err < 0)
3212
		return err;
3213
	return 0;
3214
}
3215

3216
static void __exit alsa_pcm_oss_exit(void)
3217
{
3218
	snd_pcm_notify(&snd_pcm_oss_notify, 1);
3219
}
3220

3221
module_init(alsa_pcm_oss_init)
3222
module_exit(alsa_pcm_oss_exit)
3223

3224
Product

Resources

Company
