Linux Audio

Check our new training course

Loading...
v5.4
  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 *   32bit -> 64bit ioctl wrapper for PCM API
  4 *   Copyright (c) by Takashi Iwai <tiwai@suse.de>
  5 */
  6
  7/* This file included from pcm_native.c */
  8
  9#include <linux/compat.h>
 10#include <linux/slab.h>
 11
 12static int snd_pcm_ioctl_delay_compat(struct snd_pcm_substream *substream,
 13				      s32 __user *src)
 14{
 15	snd_pcm_sframes_t delay;
 16	int err;
 17
 18	err = snd_pcm_delay(substream, &delay);
 19	if (err)
 20		return err;
 21	if (put_user(delay, src))
 22		return -EFAULT;
 23	return 0;
 24}
 25
 26static int snd_pcm_ioctl_rewind_compat(struct snd_pcm_substream *substream,
 27				       u32 __user *src)
 28{
 29	snd_pcm_uframes_t frames;
 30	int err;
 31
 32	if (get_user(frames, src))
 33		return -EFAULT;
 34	err = snd_pcm_rewind(substream, frames);
 35	if (put_user(err, src))
 36		return -EFAULT;
 37	return err < 0 ? err : 0;
 38}
 39
 40static int snd_pcm_ioctl_forward_compat(struct snd_pcm_substream *substream,
 41				       u32 __user *src)
 42{
 43	snd_pcm_uframes_t frames;
 44	int err;
 45
 46	if (get_user(frames, src))
 47		return -EFAULT;
 48	err = snd_pcm_forward(substream, frames);
 49	if (put_user(err, src))
 50		return -EFAULT;
 51	return err < 0 ? err : 0;
 52}
 53
 54struct snd_pcm_hw_params32 {
 55	u32 flags;
 56	struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; /* this must be identical */
 57	struct snd_mask mres[5];	/* reserved masks */
 58	struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
 59	struct snd_interval ires[9];	/* reserved intervals */
 60	u32 rmask;
 61	u32 cmask;
 62	u32 info;
 63	u32 msbits;
 64	u32 rate_num;
 65	u32 rate_den;
 66	u32 fifo_size;
 67	unsigned char reserved[64];
 68};
 69
 70struct snd_pcm_sw_params32 {
 71	s32 tstamp_mode;
 72	u32 period_step;
 73	u32 sleep_min;
 74	u32 avail_min;
 75	u32 xfer_align;
 76	u32 start_threshold;
 77	u32 stop_threshold;
 78	u32 silence_threshold;
 79	u32 silence_size;
 80	u32 boundary;
 81	u32 proto;
 82	u32 tstamp_type;
 83	unsigned char reserved[56];
 84};
 85
 86/* recalcuate the boundary within 32bit */
 87static snd_pcm_uframes_t recalculate_boundary(struct snd_pcm_runtime *runtime)
 88{
 89	snd_pcm_uframes_t boundary;
 90
 91	if (! runtime->buffer_size)
 92		return 0;
 93	boundary = runtime->buffer_size;
 94	while (boundary * 2 <= 0x7fffffffUL - runtime->buffer_size)
 95		boundary *= 2;
 96	return boundary;
 97}
 98
 99static int snd_pcm_ioctl_sw_params_compat(struct snd_pcm_substream *substream,
100					  struct snd_pcm_sw_params32 __user *src)
101{
102	struct snd_pcm_sw_params params;
103	snd_pcm_uframes_t boundary;
104	int err;
105
106	memset(&params, 0, sizeof(params));
107	if (get_user(params.tstamp_mode, &src->tstamp_mode) ||
108	    get_user(params.period_step, &src->period_step) ||
109	    get_user(params.sleep_min, &src->sleep_min) ||
110	    get_user(params.avail_min, &src->avail_min) ||
111	    get_user(params.xfer_align, &src->xfer_align) ||
112	    get_user(params.start_threshold, &src->start_threshold) ||
113	    get_user(params.stop_threshold, &src->stop_threshold) ||
114	    get_user(params.silence_threshold, &src->silence_threshold) ||
115	    get_user(params.silence_size, &src->silence_size) ||
116	    get_user(params.tstamp_type, &src->tstamp_type) ||
117	    get_user(params.proto, &src->proto))
118		return -EFAULT;
119	/*
120	 * Check silent_size parameter.  Since we have 64bit boundary,
121	 * silence_size must be compared with the 32bit boundary.
122	 */
123	boundary = recalculate_boundary(substream->runtime);
124	if (boundary && params.silence_size >= boundary)
125		params.silence_size = substream->runtime->boundary;
126	err = snd_pcm_sw_params(substream, &params);
127	if (err < 0)
128		return err;
129	if (boundary && put_user(boundary, &src->boundary))
130		return -EFAULT;
131	return err;
132}
133
134struct snd_pcm_channel_info32 {
135	u32 channel;
136	u32 offset;
137	u32 first;
138	u32 step;
139};
140
141static int snd_pcm_ioctl_channel_info_compat(struct snd_pcm_substream *substream,
142					     struct snd_pcm_channel_info32 __user *src)
143{
144	struct snd_pcm_channel_info info;
145	int err;
146
147	if (get_user(info.channel, &src->channel) ||
148	    get_user(info.offset, &src->offset) ||
149	    get_user(info.first, &src->first) ||
150	    get_user(info.step, &src->step))
151		return -EFAULT;
152	err = snd_pcm_channel_info(substream, &info);
153	if (err < 0)
154		return err;
155	if (put_user(info.channel, &src->channel) ||
156	    put_user(info.offset, &src->offset) ||
157	    put_user(info.first, &src->first) ||
158	    put_user(info.step, &src->step))
159		return -EFAULT;
160	return err;
161}
162
163#ifdef CONFIG_X86_X32
164/* X32 ABI has the same struct as x86-64 for snd_pcm_channel_info */
165static int snd_pcm_channel_info_user(struct snd_pcm_substream *substream,
166				     struct snd_pcm_channel_info __user *src);
167#define snd_pcm_ioctl_channel_info_x32(s, p)	\
168	snd_pcm_channel_info_user(s, p)
169#endif /* CONFIG_X86_X32 */
170
171struct snd_pcm_status32 {
172	s32 state;
173	struct compat_timespec trigger_tstamp;
174	struct compat_timespec tstamp;
 
 
 
175	u32 appl_ptr;
176	u32 hw_ptr;
177	s32 delay;
178	u32 avail;
179	u32 avail_max;
180	u32 overrange;
181	s32 suspended_state;
182	u32 audio_tstamp_data;
183	struct compat_timespec audio_tstamp;
184	struct compat_timespec driver_tstamp;
 
 
185	u32 audio_tstamp_accuracy;
186	unsigned char reserved[52-2*sizeof(struct compat_timespec)];
187} __attribute__((packed));
188
189
190static int snd_pcm_status_user_compat(struct snd_pcm_substream *substream,
191				      struct snd_pcm_status32 __user *src,
192				      bool ext)
193{
194	struct snd_pcm_status status;
 
195	int err;
196
197	memset(&status, 0, sizeof(status));
 
198	/*
199	 * with extension, parameters are read/write,
200	 * get audio_tstamp_data from user,
201	 * ignore rest of status structure
202	 */
203	if (ext && get_user(status.audio_tstamp_data,
204				(u32 __user *)(&src->audio_tstamp_data)))
205		return -EFAULT;
206	err = snd_pcm_status(substream, &status);
207	if (err < 0)
208		return err;
209
210	if (clear_user(src, sizeof(*src)))
211		return -EFAULT;
212	if (put_user(status.state, &src->state) ||
213	    compat_put_timespec(&status.trigger_tstamp, &src->trigger_tstamp) ||
214	    compat_put_timespec(&status.tstamp, &src->tstamp) ||
215	    put_user(status.appl_ptr, &src->appl_ptr) ||
216	    put_user(status.hw_ptr, &src->hw_ptr) ||
217	    put_user(status.delay, &src->delay) ||
218	    put_user(status.avail, &src->avail) ||
219	    put_user(status.avail_max, &src->avail_max) ||
220	    put_user(status.overrange, &src->overrange) ||
221	    put_user(status.suspended_state, &src->suspended_state) ||
222	    put_user(status.audio_tstamp_data, &src->audio_tstamp_data) ||
223	    compat_put_timespec(&status.audio_tstamp, &src->audio_tstamp) ||
224	    compat_put_timespec(&status.driver_tstamp, &src->driver_tstamp) ||
225	    put_user(status.audio_tstamp_accuracy, &src->audio_tstamp_accuracy))
226		return -EFAULT;
227
228	return err;
229}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
230
231#ifdef CONFIG_X86_X32
232/* X32 ABI has 64bit timespec and 64bit alignment */
233struct snd_pcm_status_x32 {
234	s32 state;
235	u32 rsvd; /* alignment */
236	struct timespec trigger_tstamp;
237	struct timespec tstamp;
238	u32 appl_ptr;
239	u32 hw_ptr;
240	s32 delay;
241	u32 avail;
242	u32 avail_max;
243	u32 overrange;
244	s32 suspended_state;
245	u32 audio_tstamp_data;
246	struct timespec audio_tstamp;
247	struct timespec driver_tstamp;
248	u32 audio_tstamp_accuracy;
249	unsigned char reserved[52-2*sizeof(struct timespec)];
250} __packed;
251
252#define put_timespec(src, dst) copy_to_user(dst, src, sizeof(*dst))
253
254static int snd_pcm_status_user_x32(struct snd_pcm_substream *substream,
255				   struct snd_pcm_status_x32 __user *src,
256				   bool ext)
257{
258	struct snd_pcm_status status;
259	int err;
260
261	memset(&status, 0, sizeof(status));
262	/*
263	 * with extension, parameters are read/write,
264	 * get audio_tstamp_data from user,
265	 * ignore rest of status structure
266	 */
267	if (ext && get_user(status.audio_tstamp_data,
268				(u32 __user *)(&src->audio_tstamp_data)))
269		return -EFAULT;
270	err = snd_pcm_status(substream, &status);
271	if (err < 0)
272		return err;
273
274	if (clear_user(src, sizeof(*src)))
275		return -EFAULT;
276	if (put_user(status.state, &src->state) ||
277	    put_timespec(&status.trigger_tstamp, &src->trigger_tstamp) ||
278	    put_timespec(&status.tstamp, &src->tstamp) ||
279	    put_user(status.appl_ptr, &src->appl_ptr) ||
280	    put_user(status.hw_ptr, &src->hw_ptr) ||
281	    put_user(status.delay, &src->delay) ||
282	    put_user(status.avail, &src->avail) ||
283	    put_user(status.avail_max, &src->avail_max) ||
284	    put_user(status.overrange, &src->overrange) ||
285	    put_user(status.suspended_state, &src->suspended_state) ||
286	    put_user(status.audio_tstamp_data, &src->audio_tstamp_data) ||
287	    put_timespec(&status.audio_tstamp, &src->audio_tstamp) ||
288	    put_timespec(&status.driver_tstamp, &src->driver_tstamp) ||
289	    put_user(status.audio_tstamp_accuracy, &src->audio_tstamp_accuracy))
290		return -EFAULT;
291
292	return err;
293}
294#endif /* CONFIG_X86_X32 */
295
296/* both for HW_PARAMS and HW_REFINE */
297static int snd_pcm_ioctl_hw_params_compat(struct snd_pcm_substream *substream,
298					  int refine, 
299					  struct snd_pcm_hw_params32 __user *data32)
300{
301	struct snd_pcm_hw_params *data;
302	struct snd_pcm_runtime *runtime;
303	int err;
304
305	if (! (runtime = substream->runtime))
306		return -ENOTTY;
307
308	data = kmalloc(sizeof(*data), GFP_KERNEL);
309	if (!data)
310		return -ENOMEM;
311
312	/* only fifo_size (RO from userspace) is different, so just copy all */
313	if (copy_from_user(data, data32, sizeof(*data32))) {
314		err = -EFAULT;
315		goto error;
316	}
317
318	if (refine)
319		err = snd_pcm_hw_refine(substream, data);
320	else
321		err = snd_pcm_hw_params(substream, data);
322	if (err < 0)
323		goto error;
324	if (copy_to_user(data32, data, sizeof(*data32)) ||
325	    put_user(data->fifo_size, &data32->fifo_size)) {
326		err = -EFAULT;
327		goto error;
328	}
329
330	if (! refine) {
331		unsigned int new_boundary = recalculate_boundary(runtime);
332		if (new_boundary)
333			runtime->boundary = new_boundary;
334	}
335 error:
336	kfree(data);
337	return err;
338}
339
340
341/*
342 */
343struct snd_xferi32 {
344	s32 result;
345	u32 buf;
346	u32 frames;
347};
348
349static int snd_pcm_ioctl_xferi_compat(struct snd_pcm_substream *substream,
350				      int dir, struct snd_xferi32 __user *data32)
351{
352	compat_caddr_t buf;
353	u32 frames;
354	int err;
355
356	if (! substream->runtime)
357		return -ENOTTY;
358	if (substream->stream != dir)
359		return -EINVAL;
360	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN)
361		return -EBADFD;
362
363	if (get_user(buf, &data32->buf) ||
364	    get_user(frames, &data32->frames))
365		return -EFAULT;
366
367	if (dir == SNDRV_PCM_STREAM_PLAYBACK)
368		err = snd_pcm_lib_write(substream, compat_ptr(buf), frames);
369	else
370		err = snd_pcm_lib_read(substream, compat_ptr(buf), frames);
371	if (err < 0)
372		return err;
373	/* copy the result */
374	if (put_user(err, &data32->result))
375		return -EFAULT;
376	return 0;
377}
378
379
380/* snd_xfern needs remapping of bufs */
381struct snd_xfern32 {
382	s32 result;
383	u32 bufs;  /* this is void **; */
384	u32 frames;
385};
386
387/*
388 * xfern ioctl nees to copy (up to) 128 pointers on stack.
389 * although we may pass the copied pointers through f_op->ioctl, but the ioctl
390 * handler there expands again the same 128 pointers on stack, so it is better
391 * to handle the function (calling pcm_readv/writev) directly in this handler.
392 */
393static int snd_pcm_ioctl_xfern_compat(struct snd_pcm_substream *substream,
394				      int dir, struct snd_xfern32 __user *data32)
395{
396	compat_caddr_t buf;
397	compat_caddr_t __user *bufptr;
398	u32 frames;
399	void __user **bufs;
400	int err, ch, i;
401
402	if (! substream->runtime)
403		return -ENOTTY;
404	if (substream->stream != dir)
405		return -EINVAL;
406	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN)
407		return -EBADFD;
408
409	if ((ch = substream->runtime->channels) > 128)
410		return -EINVAL;
411	if (get_user(buf, &data32->bufs) ||
412	    get_user(frames, &data32->frames))
413		return -EFAULT;
414	bufptr = compat_ptr(buf);
415	bufs = kmalloc_array(ch, sizeof(void __user *), GFP_KERNEL);
416	if (bufs == NULL)
417		return -ENOMEM;
418	for (i = 0; i < ch; i++) {
419		u32 ptr;
420		if (get_user(ptr, bufptr)) {
421			kfree(bufs);
422			return -EFAULT;
423		}
424		bufs[i] = compat_ptr(ptr);
425		bufptr++;
426	}
427	if (dir == SNDRV_PCM_STREAM_PLAYBACK)
428		err = snd_pcm_lib_writev(substream, bufs, frames);
429	else
430		err = snd_pcm_lib_readv(substream, bufs, frames);
431	if (err >= 0) {
432		if (put_user(err, &data32->result))
433			err = -EFAULT;
434	}
435	kfree(bufs);
436	return err;
437}
438
439
440struct snd_pcm_mmap_status32 {
441	s32 state;
442	s32 pad1;
443	u32 hw_ptr;
444	struct compat_timespec tstamp;
445	s32 suspended_state;
446	struct compat_timespec audio_tstamp;
447} __attribute__((packed));
448
449struct snd_pcm_mmap_control32 {
450	u32 appl_ptr;
451	u32 avail_min;
452};
453
454struct snd_pcm_sync_ptr32 {
455	u32 flags;
456	union {
457		struct snd_pcm_mmap_status32 status;
458		unsigned char reserved[64];
459	} s;
460	union {
461		struct snd_pcm_mmap_control32 control;
462		unsigned char reserved[64];
463	} c;
464} __attribute__((packed));
465
466static int snd_pcm_ioctl_sync_ptr_compat(struct snd_pcm_substream *substream,
467					 struct snd_pcm_sync_ptr32 __user *src)
468{
469	struct snd_pcm_runtime *runtime = substream->runtime;
470	volatile struct snd_pcm_mmap_status *status;
471	volatile struct snd_pcm_mmap_control *control;
472	u32 sflags;
473	struct snd_pcm_mmap_control scontrol;
474	struct snd_pcm_mmap_status sstatus;
475	snd_pcm_uframes_t boundary;
476	int err;
477
478	if (snd_BUG_ON(!runtime))
479		return -EINVAL;
480
481	if (get_user(sflags, &src->flags) ||
482	    get_user(scontrol.appl_ptr, &src->c.control.appl_ptr) ||
483	    get_user(scontrol.avail_min, &src->c.control.avail_min))
484		return -EFAULT;
485	if (sflags & SNDRV_PCM_SYNC_PTR_HWSYNC) {
486		err = snd_pcm_hwsync(substream);
487		if (err < 0)
488			return err;
489	}
490	status = runtime->status;
491	control = runtime->control;
492	boundary = recalculate_boundary(runtime);
493	if (! boundary)
494		boundary = 0x7fffffff;
495	snd_pcm_stream_lock_irq(substream);
496	/* FIXME: we should consider the boundary for the sync from app */
497	if (!(sflags & SNDRV_PCM_SYNC_PTR_APPL))
498		control->appl_ptr = scontrol.appl_ptr;
499	else
500		scontrol.appl_ptr = control->appl_ptr % boundary;
501	if (!(sflags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN))
502		control->avail_min = scontrol.avail_min;
503	else
504		scontrol.avail_min = control->avail_min;
505	sstatus.state = status->state;
506	sstatus.hw_ptr = status->hw_ptr % boundary;
507	sstatus.tstamp = status->tstamp;
508	sstatus.suspended_state = status->suspended_state;
509	sstatus.audio_tstamp = status->audio_tstamp;
510	snd_pcm_stream_unlock_irq(substream);
511	if (put_user(sstatus.state, &src->s.status.state) ||
512	    put_user(sstatus.hw_ptr, &src->s.status.hw_ptr) ||
513	    compat_put_timespec(&sstatus.tstamp, &src->s.status.tstamp) ||
514	    put_user(sstatus.suspended_state, &src->s.status.suspended_state) ||
515	    compat_put_timespec(&sstatus.audio_tstamp,
516		    &src->s.status.audio_tstamp) ||
517	    put_user(scontrol.appl_ptr, &src->c.control.appl_ptr) ||
518	    put_user(scontrol.avail_min, &src->c.control.avail_min))
519		return -EFAULT;
520
521	return 0;
522}
523
524#ifdef CONFIG_X86_X32
525/* X32 ABI has 64bit timespec and 64bit alignment */
526struct snd_pcm_mmap_status_x32 {
527	s32 state;
528	s32 pad1;
529	u32 hw_ptr;
530	u32 pad2; /* alignment */
531	struct timespec tstamp;
532	s32 suspended_state;
 
533	s32 pad3;
534	struct timespec audio_tstamp;
 
535} __packed;
536
537struct snd_pcm_mmap_control_x32 {
538	u32 appl_ptr;
539	u32 avail_min;
540};
541
542struct snd_pcm_sync_ptr_x32 {
543	u32 flags;
544	u32 rsvd; /* alignment */
545	union {
546		struct snd_pcm_mmap_status_x32 status;
547		unsigned char reserved[64];
548	} s;
549	union {
550		struct snd_pcm_mmap_control_x32 control;
551		unsigned char reserved[64];
552	} c;
553} __packed;
554
555static int snd_pcm_ioctl_sync_ptr_x32(struct snd_pcm_substream *substream,
556				      struct snd_pcm_sync_ptr_x32 __user *src)
557{
558	struct snd_pcm_runtime *runtime = substream->runtime;
559	volatile struct snd_pcm_mmap_status *status;
560	volatile struct snd_pcm_mmap_control *control;
561	u32 sflags;
562	struct snd_pcm_mmap_control scontrol;
563	struct snd_pcm_mmap_status sstatus;
564	snd_pcm_uframes_t boundary;
565	int err;
566
567	if (snd_BUG_ON(!runtime))
568		return -EINVAL;
569
570	if (get_user(sflags, &src->flags) ||
571	    get_user(scontrol.appl_ptr, &src->c.control.appl_ptr) ||
572	    get_user(scontrol.avail_min, &src->c.control.avail_min))
573		return -EFAULT;
574	if (sflags & SNDRV_PCM_SYNC_PTR_HWSYNC) {
575		err = snd_pcm_hwsync(substream);
576		if (err < 0)
577			return err;
578	}
579	status = runtime->status;
580	control = runtime->control;
581	boundary = recalculate_boundary(runtime);
582	if (!boundary)
583		boundary = 0x7fffffff;
584	snd_pcm_stream_lock_irq(substream);
585	/* FIXME: we should consider the boundary for the sync from app */
586	if (!(sflags & SNDRV_PCM_SYNC_PTR_APPL))
587		control->appl_ptr = scontrol.appl_ptr;
588	else
589		scontrol.appl_ptr = control->appl_ptr % boundary;
590	if (!(sflags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN))
591		control->avail_min = scontrol.avail_min;
592	else
593		scontrol.avail_min = control->avail_min;
594	sstatus.state = status->state;
595	sstatus.hw_ptr = status->hw_ptr % boundary;
596	sstatus.tstamp = status->tstamp;
597	sstatus.suspended_state = status->suspended_state;
598	sstatus.audio_tstamp = status->audio_tstamp;
599	snd_pcm_stream_unlock_irq(substream);
600	if (put_user(sstatus.state, &src->s.status.state) ||
601	    put_user(sstatus.hw_ptr, &src->s.status.hw_ptr) ||
602	    put_timespec(&sstatus.tstamp, &src->s.status.tstamp) ||
 
603	    put_user(sstatus.suspended_state, &src->s.status.suspended_state) ||
604	    put_timespec(&sstatus.audio_tstamp, &src->s.status.audio_tstamp) ||
 
605	    put_user(scontrol.appl_ptr, &src->c.control.appl_ptr) ||
606	    put_user(scontrol.avail_min, &src->c.control.avail_min))
607		return -EFAULT;
608
609	return 0;
610}
611#endif /* CONFIG_X86_X32 */
612
613/*
614 */
615enum {
616	SNDRV_PCM_IOCTL_HW_REFINE32 = _IOWR('A', 0x10, struct snd_pcm_hw_params32),
617	SNDRV_PCM_IOCTL_HW_PARAMS32 = _IOWR('A', 0x11, struct snd_pcm_hw_params32),
618	SNDRV_PCM_IOCTL_SW_PARAMS32 = _IOWR('A', 0x13, struct snd_pcm_sw_params32),
619	SNDRV_PCM_IOCTL_STATUS32 = _IOR('A', 0x20, struct snd_pcm_status32),
620	SNDRV_PCM_IOCTL_STATUS_EXT32 = _IOWR('A', 0x24, struct snd_pcm_status32),
621	SNDRV_PCM_IOCTL_DELAY32 = _IOR('A', 0x21, s32),
622	SNDRV_PCM_IOCTL_CHANNEL_INFO32 = _IOR('A', 0x32, struct snd_pcm_channel_info32),
623	SNDRV_PCM_IOCTL_REWIND32 = _IOW('A', 0x46, u32),
624	SNDRV_PCM_IOCTL_FORWARD32 = _IOW('A', 0x49, u32),
625	SNDRV_PCM_IOCTL_WRITEI_FRAMES32 = _IOW('A', 0x50, struct snd_xferi32),
626	SNDRV_PCM_IOCTL_READI_FRAMES32 = _IOR('A', 0x51, struct snd_xferi32),
627	SNDRV_PCM_IOCTL_WRITEN_FRAMES32 = _IOW('A', 0x52, struct snd_xfern32),
628	SNDRV_PCM_IOCTL_READN_FRAMES32 = _IOR('A', 0x53, struct snd_xfern32),
629	SNDRV_PCM_IOCTL_SYNC_PTR32 = _IOWR('A', 0x23, struct snd_pcm_sync_ptr32),
 
630#ifdef CONFIG_X86_X32
631	SNDRV_PCM_IOCTL_CHANNEL_INFO_X32 = _IOR('A', 0x32, struct snd_pcm_channel_info),
632	SNDRV_PCM_IOCTL_STATUS_X32 = _IOR('A', 0x20, struct snd_pcm_status_x32),
633	SNDRV_PCM_IOCTL_STATUS_EXT_X32 = _IOWR('A', 0x24, struct snd_pcm_status_x32),
634	SNDRV_PCM_IOCTL_SYNC_PTR_X32 = _IOWR('A', 0x23, struct snd_pcm_sync_ptr_x32),
635#endif /* CONFIG_X86_X32 */
636};
637
638static long snd_pcm_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg)
639{
640	struct snd_pcm_file *pcm_file;
641	struct snd_pcm_substream *substream;
642	void __user *argp = compat_ptr(arg);
643
644	pcm_file = file->private_data;
645	if (! pcm_file)
646		return -ENOTTY;
647	substream = pcm_file->substream;
648	if (! substream)
649		return -ENOTTY;
650
651	/*
652	 * When PCM is used on 32bit mode, we need to disable
653	 * mmap of PCM status/control records because of the size
654	 * incompatibility.
655	 */
656	pcm_file->no_compat_mmap = 1;
657
658	switch (cmd) {
659	case SNDRV_PCM_IOCTL_PVERSION:
660	case SNDRV_PCM_IOCTL_INFO:
661	case SNDRV_PCM_IOCTL_TSTAMP:
662	case SNDRV_PCM_IOCTL_TTSTAMP:
663	case SNDRV_PCM_IOCTL_USER_PVERSION:
664	case SNDRV_PCM_IOCTL_HWSYNC:
665	case SNDRV_PCM_IOCTL_PREPARE:
666	case SNDRV_PCM_IOCTL_RESET:
667	case SNDRV_PCM_IOCTL_START:
668	case SNDRV_PCM_IOCTL_DROP:
669	case SNDRV_PCM_IOCTL_DRAIN:
670	case SNDRV_PCM_IOCTL_PAUSE:
671	case SNDRV_PCM_IOCTL_HW_FREE:
672	case SNDRV_PCM_IOCTL_RESUME:
673	case SNDRV_PCM_IOCTL_XRUN:
674	case SNDRV_PCM_IOCTL_LINK:
675	case SNDRV_PCM_IOCTL_UNLINK:
 
 
 
 
 
 
 
676		return snd_pcm_common_ioctl(file, substream, cmd, argp);
677	case SNDRV_PCM_IOCTL_HW_REFINE32:
678		return snd_pcm_ioctl_hw_params_compat(substream, 1, argp);
679	case SNDRV_PCM_IOCTL_HW_PARAMS32:
680		return snd_pcm_ioctl_hw_params_compat(substream, 0, argp);
681	case SNDRV_PCM_IOCTL_SW_PARAMS32:
682		return snd_pcm_ioctl_sw_params_compat(substream, argp);
683	case SNDRV_PCM_IOCTL_STATUS32:
684		return snd_pcm_status_user_compat(substream, argp, false);
685	case SNDRV_PCM_IOCTL_STATUS_EXT32:
686		return snd_pcm_status_user_compat(substream, argp, true);
687	case SNDRV_PCM_IOCTL_SYNC_PTR32:
688		return snd_pcm_ioctl_sync_ptr_compat(substream, argp);
689	case SNDRV_PCM_IOCTL_CHANNEL_INFO32:
690		return snd_pcm_ioctl_channel_info_compat(substream, argp);
691	case SNDRV_PCM_IOCTL_WRITEI_FRAMES32:
692		return snd_pcm_ioctl_xferi_compat(substream, SNDRV_PCM_STREAM_PLAYBACK, argp);
693	case SNDRV_PCM_IOCTL_READI_FRAMES32:
694		return snd_pcm_ioctl_xferi_compat(substream, SNDRV_PCM_STREAM_CAPTURE, argp);
695	case SNDRV_PCM_IOCTL_WRITEN_FRAMES32:
696		return snd_pcm_ioctl_xfern_compat(substream, SNDRV_PCM_STREAM_PLAYBACK, argp);
697	case SNDRV_PCM_IOCTL_READN_FRAMES32:
698		return snd_pcm_ioctl_xfern_compat(substream, SNDRV_PCM_STREAM_CAPTURE, argp);
699	case SNDRV_PCM_IOCTL_DELAY32:
700		return snd_pcm_ioctl_delay_compat(substream, argp);
701	case SNDRV_PCM_IOCTL_REWIND32:
702		return snd_pcm_ioctl_rewind_compat(substream, argp);
703	case SNDRV_PCM_IOCTL_FORWARD32:
704		return snd_pcm_ioctl_forward_compat(substream, argp);
 
 
 
 
705#ifdef CONFIG_X86_X32
706	case SNDRV_PCM_IOCTL_STATUS_X32:
707		return snd_pcm_status_user_x32(substream, argp, false);
708	case SNDRV_PCM_IOCTL_STATUS_EXT_X32:
709		return snd_pcm_status_user_x32(substream, argp, true);
710	case SNDRV_PCM_IOCTL_SYNC_PTR_X32:
711		return snd_pcm_ioctl_sync_ptr_x32(substream, argp);
712	case SNDRV_PCM_IOCTL_CHANNEL_INFO_X32:
713		return snd_pcm_ioctl_channel_info_x32(substream, argp);
714#endif /* CONFIG_X86_X32 */
715	}
716
717	return -ENOIOCTLCMD;
718}
v5.9
  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 *   32bit -> 64bit ioctl wrapper for PCM API
  4 *   Copyright (c) by Takashi Iwai <tiwai@suse.de>
  5 */
  6
  7/* This file included from pcm_native.c */
  8
  9#include <linux/compat.h>
 10#include <linux/slab.h>
 11
 12static int snd_pcm_ioctl_delay_compat(struct snd_pcm_substream *substream,
 13				      s32 __user *src)
 14{
 15	snd_pcm_sframes_t delay;
 16	int err;
 17
 18	err = snd_pcm_delay(substream, &delay);
 19	if (err)
 20		return err;
 21	if (put_user(delay, src))
 22		return -EFAULT;
 23	return 0;
 24}
 25
 26static int snd_pcm_ioctl_rewind_compat(struct snd_pcm_substream *substream,
 27				       u32 __user *src)
 28{
 29	snd_pcm_uframes_t frames;
 30	int err;
 31
 32	if (get_user(frames, src))
 33		return -EFAULT;
 34	err = snd_pcm_rewind(substream, frames);
 35	if (put_user(err, src))
 36		return -EFAULT;
 37	return err < 0 ? err : 0;
 38}
 39
 40static int snd_pcm_ioctl_forward_compat(struct snd_pcm_substream *substream,
 41				       u32 __user *src)
 42{
 43	snd_pcm_uframes_t frames;
 44	int err;
 45
 46	if (get_user(frames, src))
 47		return -EFAULT;
 48	err = snd_pcm_forward(substream, frames);
 49	if (put_user(err, src))
 50		return -EFAULT;
 51	return err < 0 ? err : 0;
 52}
 53
 54struct snd_pcm_hw_params32 {
 55	u32 flags;
 56	struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; /* this must be identical */
 57	struct snd_mask mres[5];	/* reserved masks */
 58	struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
 59	struct snd_interval ires[9];	/* reserved intervals */
 60	u32 rmask;
 61	u32 cmask;
 62	u32 info;
 63	u32 msbits;
 64	u32 rate_num;
 65	u32 rate_den;
 66	u32 fifo_size;
 67	unsigned char reserved[64];
 68};
 69
 70struct snd_pcm_sw_params32 {
 71	s32 tstamp_mode;
 72	u32 period_step;
 73	u32 sleep_min;
 74	u32 avail_min;
 75	u32 xfer_align;
 76	u32 start_threshold;
 77	u32 stop_threshold;
 78	u32 silence_threshold;
 79	u32 silence_size;
 80	u32 boundary;
 81	u32 proto;
 82	u32 tstamp_type;
 83	unsigned char reserved[56];
 84};
 85
 
 
 
 
 
 
 
 
 
 
 
 
 
 86static int snd_pcm_ioctl_sw_params_compat(struct snd_pcm_substream *substream,
 87					  struct snd_pcm_sw_params32 __user *src)
 88{
 89	struct snd_pcm_sw_params params;
 90	snd_pcm_uframes_t boundary;
 91	int err;
 92
 93	memset(&params, 0, sizeof(params));
 94	if (get_user(params.tstamp_mode, &src->tstamp_mode) ||
 95	    get_user(params.period_step, &src->period_step) ||
 96	    get_user(params.sleep_min, &src->sleep_min) ||
 97	    get_user(params.avail_min, &src->avail_min) ||
 98	    get_user(params.xfer_align, &src->xfer_align) ||
 99	    get_user(params.start_threshold, &src->start_threshold) ||
100	    get_user(params.stop_threshold, &src->stop_threshold) ||
101	    get_user(params.silence_threshold, &src->silence_threshold) ||
102	    get_user(params.silence_size, &src->silence_size) ||
103	    get_user(params.tstamp_type, &src->tstamp_type) ||
104	    get_user(params.proto, &src->proto))
105		return -EFAULT;
106	/*
107	 * Check silent_size parameter.  Since we have 64bit boundary,
108	 * silence_size must be compared with the 32bit boundary.
109	 */
110	boundary = recalculate_boundary(substream->runtime);
111	if (boundary && params.silence_size >= boundary)
112		params.silence_size = substream->runtime->boundary;
113	err = snd_pcm_sw_params(substream, &params);
114	if (err < 0)
115		return err;
116	if (boundary && put_user(boundary, &src->boundary))
117		return -EFAULT;
118	return err;
119}
120
121struct snd_pcm_channel_info32 {
122	u32 channel;
123	u32 offset;
124	u32 first;
125	u32 step;
126};
127
128static int snd_pcm_ioctl_channel_info_compat(struct snd_pcm_substream *substream,
129					     struct snd_pcm_channel_info32 __user *src)
130{
131	struct snd_pcm_channel_info info;
132	int err;
133
134	if (get_user(info.channel, &src->channel) ||
135	    get_user(info.offset, &src->offset) ||
136	    get_user(info.first, &src->first) ||
137	    get_user(info.step, &src->step))
138		return -EFAULT;
139	err = snd_pcm_channel_info(substream, &info);
140	if (err < 0)
141		return err;
142	if (put_user(info.channel, &src->channel) ||
143	    put_user(info.offset, &src->offset) ||
144	    put_user(info.first, &src->first) ||
145	    put_user(info.step, &src->step))
146		return -EFAULT;
147	return err;
148}
149
150#ifdef CONFIG_X86_X32
151/* X32 ABI has the same struct as x86-64 for snd_pcm_channel_info */
152static int snd_pcm_channel_info_user(struct snd_pcm_substream *substream,
153				     struct snd_pcm_channel_info __user *src);
154#define snd_pcm_ioctl_channel_info_x32(s, p)	\
155	snd_pcm_channel_info_user(s, p)
156#endif /* CONFIG_X86_X32 */
157
158struct compat_snd_pcm_status64 {
159	snd_pcm_state_t state;
160	u8 rsvd[4]; /* alignment */
161	s64 trigger_tstamp_sec;
162	s64 trigger_tstamp_nsec;
163	s64 tstamp_sec;
164	s64 tstamp_nsec;
165	u32 appl_ptr;
166	u32 hw_ptr;
167	s32 delay;
168	u32 avail;
169	u32 avail_max;
170	u32 overrange;
171	snd_pcm_state_t suspended_state;
172	u32 audio_tstamp_data;
173	s64 audio_tstamp_sec;
174	s64 audio_tstamp_nsec;
175	s64 driver_tstamp_sec;
176	s64 driver_tstamp_nsec;
177	u32 audio_tstamp_accuracy;
178	unsigned char reserved[52-4*sizeof(s64)];
179} __packed;
 
180
181static int snd_pcm_status_user_compat64(struct snd_pcm_substream *substream,
182					struct compat_snd_pcm_status64 __user *src,
183					bool ext)
184{
185	struct snd_pcm_status64 status;
186	struct compat_snd_pcm_status64 compat_status64;
187	int err;
188
189	memset(&status, 0, sizeof(status));
190	memset(&compat_status64, 0, sizeof(compat_status64));
191	/*
192	 * with extension, parameters are read/write,
193	 * get audio_tstamp_data from user,
194	 * ignore rest of status structure
195	 */
196	if (ext && get_user(status.audio_tstamp_data,
197				(u32 __user *)(&src->audio_tstamp_data)))
198		return -EFAULT;
199	err = snd_pcm_status64(substream, &status);
200	if (err < 0)
201		return err;
202
203	if (clear_user(src, sizeof(*src)))
204		return -EFAULT;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
205
206	compat_status64 = (struct compat_snd_pcm_status64) {
207		.state = status.state,
208		.trigger_tstamp_sec = status.trigger_tstamp_sec,
209		.trigger_tstamp_nsec = status.trigger_tstamp_nsec,
210		.tstamp_sec = status.tstamp_sec,
211		.tstamp_nsec = status.tstamp_nsec,
212		.appl_ptr = status.appl_ptr,
213		.hw_ptr = status.hw_ptr,
214		.delay = status.delay,
215		.avail = status.avail,
216		.avail_max = status.avail_max,
217		.overrange = status.overrange,
218		.suspended_state = status.suspended_state,
219		.audio_tstamp_data = status.audio_tstamp_data,
220		.audio_tstamp_sec = status.audio_tstamp_sec,
221		.audio_tstamp_nsec = status.audio_tstamp_nsec,
222		.driver_tstamp_sec = status.audio_tstamp_sec,
223		.driver_tstamp_nsec = status.audio_tstamp_nsec,
224		.audio_tstamp_accuracy = status.audio_tstamp_accuracy,
225	};
226
227	if (copy_to_user(src, &compat_status64, sizeof(compat_status64)))
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
228		return -EFAULT;
229
230	return err;
231}
 
232
233/* both for HW_PARAMS and HW_REFINE */
234static int snd_pcm_ioctl_hw_params_compat(struct snd_pcm_substream *substream,
235					  int refine, 
236					  struct snd_pcm_hw_params32 __user *data32)
237{
238	struct snd_pcm_hw_params *data;
239	struct snd_pcm_runtime *runtime;
240	int err;
241
242	if (! (runtime = substream->runtime))
243		return -ENOTTY;
244
245	data = kmalloc(sizeof(*data), GFP_KERNEL);
246	if (!data)
247		return -ENOMEM;
248
249	/* only fifo_size (RO from userspace) is different, so just copy all */
250	if (copy_from_user(data, data32, sizeof(*data32))) {
251		err = -EFAULT;
252		goto error;
253	}
254
255	if (refine)
256		err = snd_pcm_hw_refine(substream, data);
257	else
258		err = snd_pcm_hw_params(substream, data);
259	if (err < 0)
260		goto error;
261	if (copy_to_user(data32, data, sizeof(*data32)) ||
262	    put_user(data->fifo_size, &data32->fifo_size)) {
263		err = -EFAULT;
264		goto error;
265	}
266
267	if (! refine) {
268		unsigned int new_boundary = recalculate_boundary(runtime);
269		if (new_boundary)
270			runtime->boundary = new_boundary;
271	}
272 error:
273	kfree(data);
274	return err;
275}
276
277
278/*
279 */
280struct snd_xferi32 {
281	s32 result;
282	u32 buf;
283	u32 frames;
284};
285
286static int snd_pcm_ioctl_xferi_compat(struct snd_pcm_substream *substream,
287				      int dir, struct snd_xferi32 __user *data32)
288{
289	compat_caddr_t buf;
290	u32 frames;
291	int err;
292
293	if (! substream->runtime)
294		return -ENOTTY;
295	if (substream->stream != dir)
296		return -EINVAL;
297	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN)
298		return -EBADFD;
299
300	if (get_user(buf, &data32->buf) ||
301	    get_user(frames, &data32->frames))
302		return -EFAULT;
303
304	if (dir == SNDRV_PCM_STREAM_PLAYBACK)
305		err = snd_pcm_lib_write(substream, compat_ptr(buf), frames);
306	else
307		err = snd_pcm_lib_read(substream, compat_ptr(buf), frames);
308	if (err < 0)
309		return err;
310	/* copy the result */
311	if (put_user(err, &data32->result))
312		return -EFAULT;
313	return 0;
314}
315
316
317/* snd_xfern needs remapping of bufs */
318struct snd_xfern32 {
319	s32 result;
320	u32 bufs;  /* this is void **; */
321	u32 frames;
322};
323
324/*
325 * xfern ioctl nees to copy (up to) 128 pointers on stack.
326 * although we may pass the copied pointers through f_op->ioctl, but the ioctl
327 * handler there expands again the same 128 pointers on stack, so it is better
328 * to handle the function (calling pcm_readv/writev) directly in this handler.
329 */
330static int snd_pcm_ioctl_xfern_compat(struct snd_pcm_substream *substream,
331				      int dir, struct snd_xfern32 __user *data32)
332{
333	compat_caddr_t buf;
334	compat_caddr_t __user *bufptr;
335	u32 frames;
336	void __user **bufs;
337	int err, ch, i;
338
339	if (! substream->runtime)
340		return -ENOTTY;
341	if (substream->stream != dir)
342		return -EINVAL;
343	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN)
344		return -EBADFD;
345
346	if ((ch = substream->runtime->channels) > 128)
347		return -EINVAL;
348	if (get_user(buf, &data32->bufs) ||
349	    get_user(frames, &data32->frames))
350		return -EFAULT;
351	bufptr = compat_ptr(buf);
352	bufs = kmalloc_array(ch, sizeof(void __user *), GFP_KERNEL);
353	if (bufs == NULL)
354		return -ENOMEM;
355	for (i = 0; i < ch; i++) {
356		u32 ptr;
357		if (get_user(ptr, bufptr)) {
358			kfree(bufs);
359			return -EFAULT;
360		}
361		bufs[i] = compat_ptr(ptr);
362		bufptr++;
363	}
364	if (dir == SNDRV_PCM_STREAM_PLAYBACK)
365		err = snd_pcm_lib_writev(substream, bufs, frames);
366	else
367		err = snd_pcm_lib_readv(substream, bufs, frames);
368	if (err >= 0) {
369		if (put_user(err, &data32->result))
370			err = -EFAULT;
371	}
372	kfree(bufs);
373	return err;
374}
375
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
376#ifdef CONFIG_X86_X32
377/* X32 ABI has 64bit timespec and 64bit alignment */
378struct snd_pcm_mmap_status_x32 {
379	snd_pcm_state_t state;
380	s32 pad1;
381	u32 hw_ptr;
382	u32 pad2; /* alignment */
383	s64 tstamp_sec;
384	s64 tstamp_nsec;
385	snd_pcm_state_t suspended_state;
386	s32 pad3;
387	s64 audio_tstamp_sec;
388	s64 audio_tstamp_nsec;
389} __packed;
390
391struct snd_pcm_mmap_control_x32 {
392	u32 appl_ptr;
393	u32 avail_min;
394};
395
396struct snd_pcm_sync_ptr_x32 {
397	u32 flags;
398	u32 rsvd; /* alignment */
399	union {
400		struct snd_pcm_mmap_status_x32 status;
401		unsigned char reserved[64];
402	} s;
403	union {
404		struct snd_pcm_mmap_control_x32 control;
405		unsigned char reserved[64];
406	} c;
407} __packed;
408
409static int snd_pcm_ioctl_sync_ptr_x32(struct snd_pcm_substream *substream,
410				      struct snd_pcm_sync_ptr_x32 __user *src)
411{
412	struct snd_pcm_runtime *runtime = substream->runtime;
413	volatile struct snd_pcm_mmap_status *status;
414	volatile struct snd_pcm_mmap_control *control;
415	u32 sflags;
416	struct snd_pcm_mmap_control scontrol;
417	struct snd_pcm_mmap_status sstatus;
418	snd_pcm_uframes_t boundary;
419	int err;
420
421	if (snd_BUG_ON(!runtime))
422		return -EINVAL;
423
424	if (get_user(sflags, &src->flags) ||
425	    get_user(scontrol.appl_ptr, &src->c.control.appl_ptr) ||
426	    get_user(scontrol.avail_min, &src->c.control.avail_min))
427		return -EFAULT;
428	if (sflags & SNDRV_PCM_SYNC_PTR_HWSYNC) {
429		err = snd_pcm_hwsync(substream);
430		if (err < 0)
431			return err;
432	}
433	status = runtime->status;
434	control = runtime->control;
435	boundary = recalculate_boundary(runtime);
436	if (!boundary)
437		boundary = 0x7fffffff;
438	snd_pcm_stream_lock_irq(substream);
439	/* FIXME: we should consider the boundary for the sync from app */
440	if (!(sflags & SNDRV_PCM_SYNC_PTR_APPL))
441		control->appl_ptr = scontrol.appl_ptr;
442	else
443		scontrol.appl_ptr = control->appl_ptr % boundary;
444	if (!(sflags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN))
445		control->avail_min = scontrol.avail_min;
446	else
447		scontrol.avail_min = control->avail_min;
448	sstatus.state = status->state;
449	sstatus.hw_ptr = status->hw_ptr % boundary;
450	sstatus.tstamp = status->tstamp;
451	sstatus.suspended_state = status->suspended_state;
452	sstatus.audio_tstamp = status->audio_tstamp;
453	snd_pcm_stream_unlock_irq(substream);
454	if (put_user(sstatus.state, &src->s.status.state) ||
455	    put_user(sstatus.hw_ptr, &src->s.status.hw_ptr) ||
456	    put_user(sstatus.tstamp.tv_sec, &src->s.status.tstamp_sec) ||
457	    put_user(sstatus.tstamp.tv_nsec, &src->s.status.tstamp_nsec) ||
458	    put_user(sstatus.suspended_state, &src->s.status.suspended_state) ||
459	    put_user(sstatus.audio_tstamp.tv_sec, &src->s.status.audio_tstamp_sec) ||
460	    put_user(sstatus.audio_tstamp.tv_nsec, &src->s.status.audio_tstamp_nsec) ||
461	    put_user(scontrol.appl_ptr, &src->c.control.appl_ptr) ||
462	    put_user(scontrol.avail_min, &src->c.control.avail_min))
463		return -EFAULT;
464
465	return 0;
466}
467#endif /* CONFIG_X86_X32 */
468
469/*
470 */
471enum {
472	SNDRV_PCM_IOCTL_HW_REFINE32 = _IOWR('A', 0x10, struct snd_pcm_hw_params32),
473	SNDRV_PCM_IOCTL_HW_PARAMS32 = _IOWR('A', 0x11, struct snd_pcm_hw_params32),
474	SNDRV_PCM_IOCTL_SW_PARAMS32 = _IOWR('A', 0x13, struct snd_pcm_sw_params32),
475	SNDRV_PCM_IOCTL_STATUS_COMPAT32 = _IOR('A', 0x20, struct snd_pcm_status32),
476	SNDRV_PCM_IOCTL_STATUS_EXT_COMPAT32 = _IOWR('A', 0x24, struct snd_pcm_status32),
477	SNDRV_PCM_IOCTL_DELAY32 = _IOR('A', 0x21, s32),
478	SNDRV_PCM_IOCTL_CHANNEL_INFO32 = _IOR('A', 0x32, struct snd_pcm_channel_info32),
479	SNDRV_PCM_IOCTL_REWIND32 = _IOW('A', 0x46, u32),
480	SNDRV_PCM_IOCTL_FORWARD32 = _IOW('A', 0x49, u32),
481	SNDRV_PCM_IOCTL_WRITEI_FRAMES32 = _IOW('A', 0x50, struct snd_xferi32),
482	SNDRV_PCM_IOCTL_READI_FRAMES32 = _IOR('A', 0x51, struct snd_xferi32),
483	SNDRV_PCM_IOCTL_WRITEN_FRAMES32 = _IOW('A', 0x52, struct snd_xfern32),
484	SNDRV_PCM_IOCTL_READN_FRAMES32 = _IOR('A', 0x53, struct snd_xfern32),
485	SNDRV_PCM_IOCTL_STATUS_COMPAT64 = _IOR('A', 0x20, struct compat_snd_pcm_status64),
486	SNDRV_PCM_IOCTL_STATUS_EXT_COMPAT64 = _IOWR('A', 0x24, struct compat_snd_pcm_status64),
487#ifdef CONFIG_X86_X32
488	SNDRV_PCM_IOCTL_CHANNEL_INFO_X32 = _IOR('A', 0x32, struct snd_pcm_channel_info),
 
 
489	SNDRV_PCM_IOCTL_SYNC_PTR_X32 = _IOWR('A', 0x23, struct snd_pcm_sync_ptr_x32),
490#endif /* CONFIG_X86_X32 */
491};
492
493static long snd_pcm_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg)
494{
495	struct snd_pcm_file *pcm_file;
496	struct snd_pcm_substream *substream;
497	void __user *argp = compat_ptr(arg);
498
499	pcm_file = file->private_data;
500	if (! pcm_file)
501		return -ENOTTY;
502	substream = pcm_file->substream;
503	if (! substream)
504		return -ENOTTY;
505
506	/*
507	 * When PCM is used on 32bit mode, we need to disable
508	 * mmap of the old PCM status/control records because
509	 * of the size incompatibility.
510	 */
511	pcm_file->no_compat_mmap = 1;
512
513	switch (cmd) {
514	case SNDRV_PCM_IOCTL_PVERSION:
515	case SNDRV_PCM_IOCTL_INFO:
516	case SNDRV_PCM_IOCTL_TSTAMP:
517	case SNDRV_PCM_IOCTL_TTSTAMP:
518	case SNDRV_PCM_IOCTL_USER_PVERSION:
519	case SNDRV_PCM_IOCTL_HWSYNC:
520	case SNDRV_PCM_IOCTL_PREPARE:
521	case SNDRV_PCM_IOCTL_RESET:
522	case SNDRV_PCM_IOCTL_START:
523	case SNDRV_PCM_IOCTL_DROP:
524	case SNDRV_PCM_IOCTL_DRAIN:
525	case SNDRV_PCM_IOCTL_PAUSE:
526	case SNDRV_PCM_IOCTL_HW_FREE:
527	case SNDRV_PCM_IOCTL_RESUME:
528	case SNDRV_PCM_IOCTL_XRUN:
529	case SNDRV_PCM_IOCTL_LINK:
530	case SNDRV_PCM_IOCTL_UNLINK:
531	case __SNDRV_PCM_IOCTL_SYNC_PTR32:
532		return snd_pcm_common_ioctl(file, substream, cmd, argp);
533	case __SNDRV_PCM_IOCTL_SYNC_PTR64:
534#ifdef CONFIG_X86_X32
535		if (in_x32_syscall())
536			return snd_pcm_ioctl_sync_ptr_x32(substream, argp);
537#endif /* CONFIG_X86_X32 */
538		return snd_pcm_common_ioctl(file, substream, cmd, argp);
539	case SNDRV_PCM_IOCTL_HW_REFINE32:
540		return snd_pcm_ioctl_hw_params_compat(substream, 1, argp);
541	case SNDRV_PCM_IOCTL_HW_PARAMS32:
542		return snd_pcm_ioctl_hw_params_compat(substream, 0, argp);
543	case SNDRV_PCM_IOCTL_SW_PARAMS32:
544		return snd_pcm_ioctl_sw_params_compat(substream, argp);
545	case SNDRV_PCM_IOCTL_STATUS_COMPAT32:
546		return snd_pcm_status_user32(substream, argp, false);
547	case SNDRV_PCM_IOCTL_STATUS_EXT_COMPAT32:
548		return snd_pcm_status_user32(substream, argp, true);
 
 
549	case SNDRV_PCM_IOCTL_CHANNEL_INFO32:
550		return snd_pcm_ioctl_channel_info_compat(substream, argp);
551	case SNDRV_PCM_IOCTL_WRITEI_FRAMES32:
552		return snd_pcm_ioctl_xferi_compat(substream, SNDRV_PCM_STREAM_PLAYBACK, argp);
553	case SNDRV_PCM_IOCTL_READI_FRAMES32:
554		return snd_pcm_ioctl_xferi_compat(substream, SNDRV_PCM_STREAM_CAPTURE, argp);
555	case SNDRV_PCM_IOCTL_WRITEN_FRAMES32:
556		return snd_pcm_ioctl_xfern_compat(substream, SNDRV_PCM_STREAM_PLAYBACK, argp);
557	case SNDRV_PCM_IOCTL_READN_FRAMES32:
558		return snd_pcm_ioctl_xfern_compat(substream, SNDRV_PCM_STREAM_CAPTURE, argp);
559	case SNDRV_PCM_IOCTL_DELAY32:
560		return snd_pcm_ioctl_delay_compat(substream, argp);
561	case SNDRV_PCM_IOCTL_REWIND32:
562		return snd_pcm_ioctl_rewind_compat(substream, argp);
563	case SNDRV_PCM_IOCTL_FORWARD32:
564		return snd_pcm_ioctl_forward_compat(substream, argp);
565	case SNDRV_PCM_IOCTL_STATUS_COMPAT64:
566		return snd_pcm_status_user_compat64(substream, argp, false);
567	case SNDRV_PCM_IOCTL_STATUS_EXT_COMPAT64:
568		return snd_pcm_status_user_compat64(substream, argp, true);
569#ifdef CONFIG_X86_X32
 
 
 
 
 
 
570	case SNDRV_PCM_IOCTL_CHANNEL_INFO_X32:
571		return snd_pcm_ioctl_channel_info_x32(substream, argp);
572#endif /* CONFIG_X86_X32 */
573	}
574
575	return -ENOIOCTLCMD;
576}