pcm_compat.c

  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_ABI
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_ABI */
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_runtime *runtime;
239	int err;
240
241	runtime = substream->runtime;
242	if (!runtime)
243		return -ENOTTY;
244
245	struct snd_pcm_hw_params *data __free(kfree) =
246		kmalloc(sizeof(*data), GFP_KERNEL);
247	if (!data)
248		return -ENOMEM;
249
250	/* only fifo_size (RO from userspace) is different, so just copy all */
251	if (copy_from_user(data, data32, sizeof(*data32)))
252		return -EFAULT;
253
254	if (refine) {
255		err = snd_pcm_hw_refine(substream, data);
256		if (err < 0)
257			return err;
258		err = fixup_unreferenced_params(substream, data);
259	} else {
260		err = snd_pcm_hw_params(substream, data);
261	}
262	if (err < 0)
263		return err;
264	if (copy_to_user(data32, data, sizeof(*data32)) ||
265	    put_user(data->fifo_size, &data32->fifo_size))
266		return -EFAULT;
267
268	if (! refine) {
269		unsigned int new_boundary = recalculate_boundary(runtime);
270		if (new_boundary)
271			runtime->boundary = new_boundary;
272	}
273	return err;
274}
275
276
277/*
278 */
279struct snd_xferi32 {
280	s32 result;
281	u32 buf;
282	u32 frames;
283};
284
285static int snd_pcm_ioctl_xferi_compat(struct snd_pcm_substream *substream,
286				      int dir, struct snd_xferi32 __user *data32)
287{
288	compat_caddr_t buf;
289	u32 frames;
290	int err;
291
292	if (! substream->runtime)
293		return -ENOTTY;
294	if (substream->stream != dir)
295		return -EINVAL;
296	if (substream->runtime->state == SNDRV_PCM_STATE_OPEN)
297		return -EBADFD;
298
299	if (get_user(buf, &data32->buf) ||
300	    get_user(frames, &data32->frames))
301		return -EFAULT;
302
303	if (dir == SNDRV_PCM_STREAM_PLAYBACK)
304		err = snd_pcm_lib_write(substream, compat_ptr(buf), frames);
305	else
306		err = snd_pcm_lib_read(substream, compat_ptr(buf), frames);
307	if (err < 0)
308		return err;
309	/* copy the result */
310	if (put_user(err, &data32->result))
311		return -EFAULT;
312	return 0;
313}
314
315
316/* snd_xfern needs remapping of bufs */
317struct snd_xfern32 {
318	s32 result;
319	u32 bufs;  /* this is void **; */
320	u32 frames;
321};
322
323/*
324 * xfern ioctl nees to copy (up to) 128 pointers on stack.
325 * although we may pass the copied pointers through f_op->ioctl, but the ioctl
326 * handler there expands again the same 128 pointers on stack, so it is better
327 * to handle the function (calling pcm_readv/writev) directly in this handler.
328 */
329static int snd_pcm_ioctl_xfern_compat(struct snd_pcm_substream *substream,
330				      int dir, struct snd_xfern32 __user *data32)
331{
332	compat_caddr_t buf;
333	compat_caddr_t __user *bufptr;
334	u32 frames;
335	int err, ch, i;
336
337	if (! substream->runtime)
338		return -ENOTTY;
339	if (substream->stream != dir)
340		return -EINVAL;
341	if (substream->runtime->state == SNDRV_PCM_STATE_OPEN)
342		return -EBADFD;
343
344	ch = substream->runtime->channels;
345	if (ch > 128)
346		return -EINVAL;
347	if (get_user(buf, &data32->bufs) ||
348	    get_user(frames, &data32->frames))
349		return -EFAULT;
350	bufptr = compat_ptr(buf);
351
352	void __user **bufs __free(kfree) =
353		kmalloc_array(ch, sizeof(void __user *), GFP_KERNEL);
354	if (bufs == NULL)
355		return -ENOMEM;
356	for (i = 0; i < ch; i++) {
357		u32 ptr;
358		if (get_user(ptr, bufptr))
359			return -EFAULT;
360		bufs[i] = compat_ptr(ptr);
361		bufptr++;
362	}
363	if (dir == SNDRV_PCM_STREAM_PLAYBACK)
364		err = snd_pcm_lib_writev(substream, bufs, frames);
365	else
366		err = snd_pcm_lib_readv(substream, bufs, frames);
367	if (err >= 0) {
368		if (put_user(err, &data32->result))
369			return -EFAULT;
370	}
371	return err;
372}
373
374#ifdef CONFIG_X86_X32_ABI
375/* X32 ABI has 64bit timespec and 64bit alignment */
376struct snd_pcm_mmap_status_x32 {
377	snd_pcm_state_t state;
378	s32 pad1;
379	u32 hw_ptr;
380	u32 pad2; /* alignment */
381	struct __snd_timespec64 tstamp;
382	snd_pcm_state_t suspended_state;
383	s32 pad3;
384	struct __snd_timespec64 audio_tstamp;
385} __packed;
386
387struct snd_pcm_mmap_control_x32 {
388	u32 appl_ptr;
389	u32 avail_min;
390};
391
392struct snd_pcm_sync_ptr_x32 {
393	u32 flags;
394	u32 rsvd; /* alignment */
395	union {
396		struct snd_pcm_mmap_status_x32 status;
397		unsigned char reserved[64];
398	} s;
399	union {
400		struct snd_pcm_mmap_control_x32 control;
401		unsigned char reserved[64];
402	} c;
403} __packed;
404
405static int snd_pcm_ioctl_sync_ptr_x32(struct snd_pcm_substream *substream,
406				      struct snd_pcm_sync_ptr_x32 __user *src)
407{
408	struct snd_pcm_runtime *runtime = substream->runtime;
409	volatile struct snd_pcm_mmap_status *status;
410	volatile struct snd_pcm_mmap_control *control;
411	u32 sflags;
412	struct snd_pcm_mmap_control scontrol;
413	struct snd_pcm_mmap_status sstatus;
414	snd_pcm_uframes_t boundary;
415	int err;
416
417	if (snd_BUG_ON(!runtime))
418		return -EINVAL;
419
420	if (snd_pcm_sync_ptr_get_user(sflags, scontrol, src))
421		return -EFAULT;
422	if (sflags & SNDRV_PCM_SYNC_PTR_HWSYNC) {
423		err = snd_pcm_hwsync(substream);
424		if (err < 0)
425			return err;
426	}
427	status = runtime->status;
428	control = runtime->control;
429	boundary = recalculate_boundary(runtime);
430	if (!boundary)
431		boundary = 0x7fffffff;
432	scoped_guard(pcm_stream_lock_irq, substream) {
433		/* FIXME: we should consider the boundary for the sync from app */
434		if (!(sflags & SNDRV_PCM_SYNC_PTR_APPL))
435			control->appl_ptr = scontrol.appl_ptr;
436		else
437			scontrol.appl_ptr = control->appl_ptr % boundary;
438		if (!(sflags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN))
439			control->avail_min = scontrol.avail_min;
440		else
441			scontrol.avail_min = control->avail_min;
442		sstatus.state = status->state;
443		sstatus.hw_ptr = status->hw_ptr % boundary;
444		sstatus.tstamp = status->tstamp;
445		sstatus.suspended_state = status->suspended_state;
446		sstatus.audio_tstamp = status->audio_tstamp;
447	}
448	if (!(sflags & SNDRV_PCM_SYNC_PTR_APPL))
449		snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_DEVICE);
450	if (snd_pcm_sync_ptr_put_user(sstatus, scontrol, src))
451		return -EFAULT;
452
453	return 0;
454}
455#endif /* CONFIG_X86_X32_ABI */
456
457#ifdef __BIG_ENDIAN
458typedef char __pad_before_u32[4];
459typedef char __pad_after_u32[0];
460#else
461typedef char __pad_before_u32[0];
462typedef char __pad_after_u32[4];
463#endif
464
465/* PCM 2.0.15 API definition had a bug in mmap control; it puts the avail_min
466 * at the wrong offset due to a typo in padding type.
467 * The bug hits only 32bit.
468 * A workaround for incorrect read/write is needed only in 32bit compat mode.
469 */
470struct __snd_pcm_mmap_control64_buggy {
471	__pad_before_u32 __pad1;
472	__u32 appl_ptr;
473	__pad_before_u32 __pad2;	/* SiC! here is the bug */
474	__pad_before_u32 __pad3;
475	__u32 avail_min;
476	__pad_after_uframe __pad4;
477};
478
479static int snd_pcm_ioctl_sync_ptr_buggy(struct snd_pcm_substream *substream,
480					struct snd_pcm_sync_ptr __user *_sync_ptr)
481{
482	struct snd_pcm_runtime *runtime = substream->runtime;
483	struct snd_pcm_sync_ptr sync_ptr;
484	struct __snd_pcm_mmap_control64_buggy *sync_cp;
485	volatile struct snd_pcm_mmap_status *status;
486	volatile struct snd_pcm_mmap_control *control;
487	int err;
488
489	memset(&sync_ptr, 0, sizeof(sync_ptr));
490	sync_cp = (struct __snd_pcm_mmap_control64_buggy *)&sync_ptr.c.control;
491	if (get_user(sync_ptr.flags, (unsigned __user *)&(_sync_ptr->flags)))
492		return -EFAULT;
493	if (copy_from_user(sync_cp, &(_sync_ptr->c.control), sizeof(*sync_cp)))
494		return -EFAULT;
495	status = runtime->status;
496	control = runtime->control;
497	if (sync_ptr.flags & SNDRV_PCM_SYNC_PTR_HWSYNC) {
498		err = snd_pcm_hwsync(substream);
499		if (err < 0)
500			return err;
501	}
502	scoped_guard(pcm_stream_lock_irq, substream) {
503		if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_APPL)) {
504			err = pcm_lib_apply_appl_ptr(substream, sync_cp->appl_ptr);
505			if (err < 0)
506				return err;
507		} else {
508			sync_cp->appl_ptr = control->appl_ptr;
509		}
510		if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN))
511			control->avail_min = sync_cp->avail_min;
512		else
513			sync_cp->avail_min = control->avail_min;
514		sync_ptr.s.status.state = status->state;
515		sync_ptr.s.status.hw_ptr = status->hw_ptr;
516		sync_ptr.s.status.tstamp = status->tstamp;
517		sync_ptr.s.status.suspended_state = status->suspended_state;
518		sync_ptr.s.status.audio_tstamp = status->audio_tstamp;
519	}
520	if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_APPL))
521		snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_DEVICE);
522	if (copy_to_user(_sync_ptr, &sync_ptr, sizeof(sync_ptr)))
523		return -EFAULT;
524	return 0;
525}
526
527/*
528 */
529enum {
530	SNDRV_PCM_IOCTL_HW_REFINE32 = _IOWR('A', 0x10, struct snd_pcm_hw_params32),
531	SNDRV_PCM_IOCTL_HW_PARAMS32 = _IOWR('A', 0x11, struct snd_pcm_hw_params32),
532	SNDRV_PCM_IOCTL_SW_PARAMS32 = _IOWR('A', 0x13, struct snd_pcm_sw_params32),
533	SNDRV_PCM_IOCTL_STATUS_COMPAT32 = _IOR('A', 0x20, struct snd_pcm_status32),
534	SNDRV_PCM_IOCTL_STATUS_EXT_COMPAT32 = _IOWR('A', 0x24, struct snd_pcm_status32),
535	SNDRV_PCM_IOCTL_DELAY32 = _IOR('A', 0x21, s32),
536	SNDRV_PCM_IOCTL_CHANNEL_INFO32 = _IOR('A', 0x32, struct snd_pcm_channel_info32),
537	SNDRV_PCM_IOCTL_REWIND32 = _IOW('A', 0x46, u32),
538	SNDRV_PCM_IOCTL_FORWARD32 = _IOW('A', 0x49, u32),
539	SNDRV_PCM_IOCTL_WRITEI_FRAMES32 = _IOW('A', 0x50, struct snd_xferi32),
540	SNDRV_PCM_IOCTL_READI_FRAMES32 = _IOR('A', 0x51, struct snd_xferi32),
541	SNDRV_PCM_IOCTL_WRITEN_FRAMES32 = _IOW('A', 0x52, struct snd_xfern32),
542	SNDRV_PCM_IOCTL_READN_FRAMES32 = _IOR('A', 0x53, struct snd_xfern32),
543	SNDRV_PCM_IOCTL_STATUS_COMPAT64 = _IOR('A', 0x20, struct compat_snd_pcm_status64),
544	SNDRV_PCM_IOCTL_STATUS_EXT_COMPAT64 = _IOWR('A', 0x24, struct compat_snd_pcm_status64),
545#ifdef CONFIG_X86_X32_ABI
546	SNDRV_PCM_IOCTL_CHANNEL_INFO_X32 = _IOR('A', 0x32, struct snd_pcm_channel_info),
547	SNDRV_PCM_IOCTL_SYNC_PTR_X32 = _IOWR('A', 0x23, struct snd_pcm_sync_ptr_x32),
548#endif /* CONFIG_X86_X32_ABI */
549};
550
551static long snd_pcm_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg)
552{
553	struct snd_pcm_file *pcm_file;
554	struct snd_pcm_substream *substream;
555	void __user *argp = compat_ptr(arg);
556
557	pcm_file = file->private_data;
558	if (! pcm_file)
559		return -ENOTTY;
560	substream = pcm_file->substream;
561	if (! substream)
562		return -ENOTTY;
563
564	/*
565	 * When PCM is used on 32bit mode, we need to disable
566	 * mmap of the old PCM status/control records because
567	 * of the size incompatibility.
568	 */
569	pcm_file->no_compat_mmap = 1;
570
571	switch (cmd) {
572	case SNDRV_PCM_IOCTL_PVERSION:
573	case SNDRV_PCM_IOCTL_INFO:
574	case SNDRV_PCM_IOCTL_TSTAMP:
575	case SNDRV_PCM_IOCTL_TTSTAMP:
576	case SNDRV_PCM_IOCTL_USER_PVERSION:
577	case SNDRV_PCM_IOCTL_HWSYNC:
578	case SNDRV_PCM_IOCTL_PREPARE:
579	case SNDRV_PCM_IOCTL_RESET:
580	case SNDRV_PCM_IOCTL_START:
581	case SNDRV_PCM_IOCTL_DROP:
582	case SNDRV_PCM_IOCTL_DRAIN:
583	case SNDRV_PCM_IOCTL_PAUSE:
584	case SNDRV_PCM_IOCTL_HW_FREE:
585	case SNDRV_PCM_IOCTL_RESUME:
586	case SNDRV_PCM_IOCTL_XRUN:
587	case SNDRV_PCM_IOCTL_LINK:
588	case SNDRV_PCM_IOCTL_UNLINK:
589	case __SNDRV_PCM_IOCTL_SYNC_PTR32:
590		return snd_pcm_common_ioctl(file, substream, cmd, argp);
591	case __SNDRV_PCM_IOCTL_SYNC_PTR64:
592#ifdef CONFIG_X86_X32_ABI
593		if (in_x32_syscall())
594			return snd_pcm_ioctl_sync_ptr_x32(substream, argp);
595#endif /* CONFIG_X86_X32_ABI */
596		return snd_pcm_ioctl_sync_ptr_buggy(substream, argp);
597	case SNDRV_PCM_IOCTL_HW_REFINE32:
598		return snd_pcm_ioctl_hw_params_compat(substream, 1, argp);
599	case SNDRV_PCM_IOCTL_HW_PARAMS32:
600		return snd_pcm_ioctl_hw_params_compat(substream, 0, argp);
601	case SNDRV_PCM_IOCTL_SW_PARAMS32:
602		return snd_pcm_ioctl_sw_params_compat(substream, argp);
603	case SNDRV_PCM_IOCTL_STATUS_COMPAT32:
604		return snd_pcm_status_user32(substream, argp, false);
605	case SNDRV_PCM_IOCTL_STATUS_EXT_COMPAT32:
606		return snd_pcm_status_user32(substream, argp, true);
607	case SNDRV_PCM_IOCTL_CHANNEL_INFO32:
608		return snd_pcm_ioctl_channel_info_compat(substream, argp);
609	case SNDRV_PCM_IOCTL_WRITEI_FRAMES32:
610		return snd_pcm_ioctl_xferi_compat(substream, SNDRV_PCM_STREAM_PLAYBACK, argp);
611	case SNDRV_PCM_IOCTL_READI_FRAMES32:
612		return snd_pcm_ioctl_xferi_compat(substream, SNDRV_PCM_STREAM_CAPTURE, argp);
613	case SNDRV_PCM_IOCTL_WRITEN_FRAMES32:
614		return snd_pcm_ioctl_xfern_compat(substream, SNDRV_PCM_STREAM_PLAYBACK, argp);
615	case SNDRV_PCM_IOCTL_READN_FRAMES32:
616		return snd_pcm_ioctl_xfern_compat(substream, SNDRV_PCM_STREAM_CAPTURE, argp);
617	case SNDRV_PCM_IOCTL_DELAY32:
618		return snd_pcm_ioctl_delay_compat(substream, argp);
619	case SNDRV_PCM_IOCTL_REWIND32:
620		return snd_pcm_ioctl_rewind_compat(substream, argp);
621	case SNDRV_PCM_IOCTL_FORWARD32:
622		return snd_pcm_ioctl_forward_compat(substream, argp);
623	case SNDRV_PCM_IOCTL_STATUS_COMPAT64:
624		return snd_pcm_status_user_compat64(substream, argp, false);
625	case SNDRV_PCM_IOCTL_STATUS_EXT_COMPAT64:
626		return snd_pcm_status_user_compat64(substream, argp, true);
627#ifdef CONFIG_X86_X32_ABI
628	case SNDRV_PCM_IOCTL_CHANNEL_INFO_X32:
629		return snd_pcm_ioctl_channel_info_x32(substream, argp);
630#endif /* CONFIG_X86_X32_ABI */
631	}
632
633	return -ENOIOCTLCMD;
634}