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
	guard(spinlock)(&file->f_lock);
2006
	file->f_flags |= O_NONBLOCK;
2007
	return 0;
2008
}
2009

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2458

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2865
	return mask;
2866
}
2867

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

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

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

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

2937
	return 0;
2938
}
2939

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

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

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

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

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

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

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

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

3096
/*
3097
 *  ENTRY functions
3098
 */
3099

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

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

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

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

3151
	return 0;
3152
}
3153

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

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

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

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

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

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

3220
module_init(alsa_pcm_oss_init)
3221
module_exit(alsa_pcm_oss_exit)
3222

3223
Product

Resources

Company
