2 * 32bit -> 64bit ioctl wrapper for PCM API
3 * Copyright (c) by Takashi Iwai <tiwai@suse.de>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 /* This file included from pcm_native.c */
23 #include <linux/compat.h>
24 #include <linux/slab.h>
26 static int snd_pcm_ioctl_delay_compat(struct snd_pcm_substream
*substream
,
29 snd_pcm_sframes_t delay
;
33 fs
= snd_enter_user();
34 err
= snd_pcm_delay(substream
, &delay
);
38 if (put_user(delay
, src
))
43 static int snd_pcm_ioctl_rewind_compat(struct snd_pcm_substream
*substream
,
46 snd_pcm_uframes_t frames
;
49 if (get_user(frames
, src
))
51 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
52 err
= snd_pcm_playback_rewind(substream
, frames
);
54 err
= snd_pcm_capture_rewind(substream
, frames
);
55 if (put_user(err
, src
))
57 return err
< 0 ? err
: 0;
60 static int snd_pcm_ioctl_forward_compat(struct snd_pcm_substream
*substream
,
63 snd_pcm_uframes_t frames
;
66 if (get_user(frames
, src
))
68 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
69 err
= snd_pcm_playback_forward(substream
, frames
);
71 err
= snd_pcm_capture_forward(substream
, frames
);
72 if (put_user(err
, src
))
74 return err
< 0 ? err
: 0;
77 struct snd_pcm_hw_params32
{
79 struct snd_mask masks
[SNDRV_PCM_HW_PARAM_LAST_MASK
- SNDRV_PCM_HW_PARAM_FIRST_MASK
+ 1]; /* this must be identical */
80 struct snd_mask mres
[5]; /* reserved masks */
81 struct snd_interval intervals
[SNDRV_PCM_HW_PARAM_LAST_INTERVAL
- SNDRV_PCM_HW_PARAM_FIRST_INTERVAL
+ 1];
82 struct snd_interval ires
[9]; /* reserved intervals */
90 unsigned char reserved
[64];
93 struct snd_pcm_sw_params32
{
101 u32 silence_threshold
;
106 unsigned char reserved
[56];
109 /* recalcuate the boundary within 32bit */
110 static snd_pcm_uframes_t
recalculate_boundary(struct snd_pcm_runtime
*runtime
)
112 snd_pcm_uframes_t boundary
;
114 if (! runtime
->buffer_size
)
116 boundary
= runtime
->buffer_size
;
117 while (boundary
* 2 <= 0x7fffffffUL
- runtime
->buffer_size
)
122 static int snd_pcm_ioctl_sw_params_compat(struct snd_pcm_substream
*substream
,
123 struct snd_pcm_sw_params32 __user
*src
)
125 struct snd_pcm_sw_params params
;
126 snd_pcm_uframes_t boundary
;
129 memset(¶ms
, 0, sizeof(params
));
130 if (get_user(params
.tstamp_mode
, &src
->tstamp_mode
) ||
131 get_user(params
.period_step
, &src
->period_step
) ||
132 get_user(params
.sleep_min
, &src
->sleep_min
) ||
133 get_user(params
.avail_min
, &src
->avail_min
) ||
134 get_user(params
.xfer_align
, &src
->xfer_align
) ||
135 get_user(params
.start_threshold
, &src
->start_threshold
) ||
136 get_user(params
.stop_threshold
, &src
->stop_threshold
) ||
137 get_user(params
.silence_threshold
, &src
->silence_threshold
) ||
138 get_user(params
.silence_size
, &src
->silence_size
) ||
139 get_user(params
.tstamp_type
, &src
->tstamp_type
) ||
140 get_user(params
.proto
, &src
->proto
))
143 * Check silent_size parameter. Since we have 64bit boundary,
144 * silence_size must be compared with the 32bit boundary.
146 boundary
= recalculate_boundary(substream
->runtime
);
147 if (boundary
&& params
.silence_size
>= boundary
)
148 params
.silence_size
= substream
->runtime
->boundary
;
149 err
= snd_pcm_sw_params(substream
, ¶ms
);
152 if (boundary
&& put_user(boundary
, &src
->boundary
))
157 struct snd_pcm_channel_info32
{
164 static int snd_pcm_ioctl_channel_info_compat(struct snd_pcm_substream
*substream
,
165 struct snd_pcm_channel_info32 __user
*src
)
167 struct snd_pcm_channel_info info
;
170 if (get_user(info
.channel
, &src
->channel
) ||
171 get_user(info
.offset
, &src
->offset
) ||
172 get_user(info
.first
, &src
->first
) ||
173 get_user(info
.step
, &src
->step
))
175 err
= snd_pcm_channel_info(substream
, &info
);
178 if (put_user(info
.channel
, &src
->channel
) ||
179 put_user(info
.offset
, &src
->offset
) ||
180 put_user(info
.first
, &src
->first
) ||
181 put_user(info
.step
, &src
->step
))
186 struct snd_pcm_status32
{
188 struct compat_timespec trigger_tstamp
;
189 struct compat_timespec tstamp
;
197 u32 audio_tstamp_data
;
198 struct compat_timespec audio_tstamp
;
199 struct compat_timespec driver_tstamp
;
200 u32 audio_tstamp_accuracy
;
201 unsigned char reserved
[52-2*sizeof(struct compat_timespec
)];
202 } __attribute__((packed
));
205 static int snd_pcm_status_user_compat(struct snd_pcm_substream
*substream
,
206 struct snd_pcm_status32 __user
*src
,
209 struct snd_pcm_status status
;
212 memset(&status
, 0, sizeof(status
));
214 * with extension, parameters are read/write,
215 * get audio_tstamp_data from user,
216 * ignore rest of status structure
218 if (ext
&& get_user(status
.audio_tstamp_data
,
219 (u32 __user
*)(&src
->audio_tstamp_data
)))
221 err
= snd_pcm_status(substream
, &status
);
225 if (clear_user(src
, sizeof(*src
)))
227 if (put_user(status
.state
, &src
->state
) ||
228 compat_put_timespec(&status
.trigger_tstamp
, &src
->trigger_tstamp
) ||
229 compat_put_timespec(&status
.tstamp
, &src
->tstamp
) ||
230 put_user(status
.appl_ptr
, &src
->appl_ptr
) ||
231 put_user(status
.hw_ptr
, &src
->hw_ptr
) ||
232 put_user(status
.delay
, &src
->delay
) ||
233 put_user(status
.avail
, &src
->avail
) ||
234 put_user(status
.avail_max
, &src
->avail_max
) ||
235 put_user(status
.overrange
, &src
->overrange
) ||
236 put_user(status
.suspended_state
, &src
->suspended_state
) ||
237 put_user(status
.audio_tstamp_data
, &src
->audio_tstamp_data
) ||
238 compat_put_timespec(&status
.audio_tstamp
, &src
->audio_tstamp
) ||
239 compat_put_timespec(&status
.driver_tstamp
, &src
->driver_tstamp
) ||
240 put_user(status
.audio_tstamp_accuracy
, &src
->audio_tstamp_accuracy
))
246 /* both for HW_PARAMS and HW_REFINE */
247 static int snd_pcm_ioctl_hw_params_compat(struct snd_pcm_substream
*substream
,
249 struct snd_pcm_hw_params32 __user
*data32
)
251 struct snd_pcm_hw_params
*data
;
252 struct snd_pcm_runtime
*runtime
;
255 if (! (runtime
= substream
->runtime
))
258 /* only fifo_size is different, so just copy all */
259 data
= memdup_user(data32
, sizeof(*data32
));
261 return PTR_ERR(data
);
264 err
= snd_pcm_hw_refine(substream
, data
);
266 err
= snd_pcm_hw_params(substream
, data
);
269 if (copy_to_user(data32
, data
, sizeof(*data32
)) ||
270 put_user(data
->fifo_size
, &data32
->fifo_size
)) {
276 unsigned int new_boundary
= recalculate_boundary(runtime
);
278 runtime
->boundary
= new_boundary
;
294 static int snd_pcm_ioctl_xferi_compat(struct snd_pcm_substream
*substream
,
295 int dir
, struct snd_xferi32 __user
*data32
)
301 if (! substream
->runtime
)
303 if (substream
->stream
!= dir
)
305 if (substream
->runtime
->status
->state
== SNDRV_PCM_STATE_OPEN
)
308 if (get_user(buf
, &data32
->buf
) ||
309 get_user(frames
, &data32
->frames
))
312 if (dir
== SNDRV_PCM_STREAM_PLAYBACK
)
313 err
= snd_pcm_lib_write(substream
, compat_ptr(buf
), frames
);
315 err
= snd_pcm_lib_read(substream
, compat_ptr(buf
), frames
);
318 /* copy the result */
319 if (put_user(err
, &data32
->result
))
325 /* snd_xfern needs remapping of bufs */
328 u32 bufs
; /* this is void **; */
333 * xfern ioctl nees to copy (up to) 128 pointers on stack.
334 * although we may pass the copied pointers through f_op->ioctl, but the ioctl
335 * handler there expands again the same 128 pointers on stack, so it is better
336 * to handle the function (calling pcm_readv/writev) directly in this handler.
338 static int snd_pcm_ioctl_xfern_compat(struct snd_pcm_substream
*substream
,
339 int dir
, struct snd_xfern32 __user
*data32
)
342 compat_caddr_t __user
*bufptr
;
347 if (! substream
->runtime
)
349 if (substream
->stream
!= dir
)
352 if ((ch
= substream
->runtime
->channels
) > 128)
354 if (get_user(buf
, &data32
->bufs
) ||
355 get_user(frames
, &data32
->frames
))
357 bufptr
= compat_ptr(buf
);
358 bufs
= kmalloc(sizeof(void __user
*) * ch
, GFP_KERNEL
);
361 for (i
= 0; i
< ch
; i
++) {
363 if (get_user(ptr
, bufptr
)) {
367 bufs
[i
] = compat_ptr(ptr
);
370 if (dir
== SNDRV_PCM_STREAM_PLAYBACK
)
371 err
= snd_pcm_lib_writev(substream
, bufs
, frames
);
373 err
= snd_pcm_lib_readv(substream
, bufs
, frames
);
375 if (put_user(err
, &data32
->result
))
383 struct snd_pcm_mmap_status32
{
387 struct compat_timespec tstamp
;
389 struct compat_timespec audio_tstamp
;
390 } __attribute__((packed
));
392 struct snd_pcm_mmap_control32
{
397 struct snd_pcm_sync_ptr32
{
400 struct snd_pcm_mmap_status32 status
;
401 unsigned char reserved
[64];
404 struct snd_pcm_mmap_control32 control
;
405 unsigned char reserved
[64];
407 } __attribute__((packed
));
409 static int snd_pcm_ioctl_sync_ptr_compat(struct snd_pcm_substream
*substream
,
410 struct snd_pcm_sync_ptr32 __user
*src
)
412 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
413 volatile struct snd_pcm_mmap_status
*status
;
414 volatile struct snd_pcm_mmap_control
*control
;
416 struct snd_pcm_mmap_control scontrol
;
417 struct snd_pcm_mmap_status sstatus
;
418 snd_pcm_uframes_t boundary
;
421 if (snd_BUG_ON(!runtime
))
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
))
428 if (sflags
& SNDRV_PCM_SYNC_PTR_HWSYNC
) {
429 err
= snd_pcm_hwsync(substream
);
433 status
= runtime
->status
;
434 control
= runtime
->control
;
435 boundary
= recalculate_boundary(runtime
);
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
;
443 scontrol
.appl_ptr
= control
->appl_ptr
% boundary
;
444 if (!(sflags
& SNDRV_PCM_SYNC_PTR_AVAIL_MIN
))
445 control
->avail_min
= scontrol
.avail_min
;
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 compat_put_timespec(&sstatus
.tstamp
, &src
->s
.status
.tstamp
) ||
457 put_user(sstatus
.suspended_state
, &src
->s
.status
.suspended_state
) ||
458 compat_put_timespec(&sstatus
.audio_tstamp
,
459 &src
->s
.status
.audio_tstamp
) ||
460 put_user(scontrol
.appl_ptr
, &src
->c
.control
.appl_ptr
) ||
461 put_user(scontrol
.avail_min
, &src
->c
.control
.avail_min
))
471 SNDRV_PCM_IOCTL_HW_REFINE32
= _IOWR('A', 0x10, struct snd_pcm_hw_params32
),
472 SNDRV_PCM_IOCTL_HW_PARAMS32
= _IOWR('A', 0x11, struct snd_pcm_hw_params32
),
473 SNDRV_PCM_IOCTL_SW_PARAMS32
= _IOWR('A', 0x13, struct snd_pcm_sw_params32
),
474 SNDRV_PCM_IOCTL_STATUS32
= _IOR('A', 0x20, struct snd_pcm_status32
),
475 SNDRV_PCM_IOCTL_STATUS_EXT32
= _IOWR('A', 0x24, struct snd_pcm_status32
),
476 SNDRV_PCM_IOCTL_DELAY32
= _IOR('A', 0x21, s32
),
477 SNDRV_PCM_IOCTL_CHANNEL_INFO32
= _IOR('A', 0x32, struct snd_pcm_channel_info32
),
478 SNDRV_PCM_IOCTL_REWIND32
= _IOW('A', 0x46, u32
),
479 SNDRV_PCM_IOCTL_FORWARD32
= _IOW('A', 0x49, u32
),
480 SNDRV_PCM_IOCTL_WRITEI_FRAMES32
= _IOW('A', 0x50, struct snd_xferi32
),
481 SNDRV_PCM_IOCTL_READI_FRAMES32
= _IOR('A', 0x51, struct snd_xferi32
),
482 SNDRV_PCM_IOCTL_WRITEN_FRAMES32
= _IOW('A', 0x52, struct snd_xfern32
),
483 SNDRV_PCM_IOCTL_READN_FRAMES32
= _IOR('A', 0x53, struct snd_xfern32
),
484 SNDRV_PCM_IOCTL_SYNC_PTR32
= _IOWR('A', 0x23, struct snd_pcm_sync_ptr32
),
488 static long snd_pcm_ioctl_compat(struct file
*file
, unsigned int cmd
, unsigned long arg
)
490 struct snd_pcm_file
*pcm_file
;
491 struct snd_pcm_substream
*substream
;
492 void __user
*argp
= compat_ptr(arg
);
494 pcm_file
= file
->private_data
;
497 substream
= pcm_file
->substream
;
502 * When PCM is used on 32bit mode, we need to disable
503 * mmap of PCM status/control records because of the size
506 pcm_file
->no_compat_mmap
= 1;
509 case SNDRV_PCM_IOCTL_PVERSION
:
510 case SNDRV_PCM_IOCTL_INFO
:
511 case SNDRV_PCM_IOCTL_TSTAMP
:
512 case SNDRV_PCM_IOCTL_TTSTAMP
:
513 case SNDRV_PCM_IOCTL_HWSYNC
:
514 case SNDRV_PCM_IOCTL_PREPARE
:
515 case SNDRV_PCM_IOCTL_RESET
:
516 case SNDRV_PCM_IOCTL_START
:
517 case SNDRV_PCM_IOCTL_DROP
:
518 case SNDRV_PCM_IOCTL_DRAIN
:
519 case SNDRV_PCM_IOCTL_PAUSE
:
520 case SNDRV_PCM_IOCTL_HW_FREE
:
521 case SNDRV_PCM_IOCTL_RESUME
:
522 case SNDRV_PCM_IOCTL_XRUN
:
523 case SNDRV_PCM_IOCTL_LINK
:
524 case SNDRV_PCM_IOCTL_UNLINK
:
525 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
526 return snd_pcm_playback_ioctl1(file
, substream
, cmd
, argp
);
528 return snd_pcm_capture_ioctl1(file
, substream
, cmd
, argp
);
529 case SNDRV_PCM_IOCTL_HW_REFINE32
:
530 return snd_pcm_ioctl_hw_params_compat(substream
, 1, argp
);
531 case SNDRV_PCM_IOCTL_HW_PARAMS32
:
532 return snd_pcm_ioctl_hw_params_compat(substream
, 0, argp
);
533 case SNDRV_PCM_IOCTL_SW_PARAMS32
:
534 return snd_pcm_ioctl_sw_params_compat(substream
, argp
);
535 case SNDRV_PCM_IOCTL_STATUS32
:
536 return snd_pcm_status_user_compat(substream
, argp
, false);
537 case SNDRV_PCM_IOCTL_STATUS_EXT32
:
538 return snd_pcm_status_user_compat(substream
, argp
, true);
539 case SNDRV_PCM_IOCTL_SYNC_PTR32
:
540 return snd_pcm_ioctl_sync_ptr_compat(substream
, argp
);
541 case SNDRV_PCM_IOCTL_CHANNEL_INFO32
:
542 return snd_pcm_ioctl_channel_info_compat(substream
, argp
);
543 case SNDRV_PCM_IOCTL_WRITEI_FRAMES32
:
544 return snd_pcm_ioctl_xferi_compat(substream
, SNDRV_PCM_STREAM_PLAYBACK
, argp
);
545 case SNDRV_PCM_IOCTL_READI_FRAMES32
:
546 return snd_pcm_ioctl_xferi_compat(substream
, SNDRV_PCM_STREAM_CAPTURE
, argp
);
547 case SNDRV_PCM_IOCTL_WRITEN_FRAMES32
:
548 return snd_pcm_ioctl_xfern_compat(substream
, SNDRV_PCM_STREAM_PLAYBACK
, argp
);
549 case SNDRV_PCM_IOCTL_READN_FRAMES32
:
550 return snd_pcm_ioctl_xfern_compat(substream
, SNDRV_PCM_STREAM_CAPTURE
, argp
);
551 case SNDRV_PCM_IOCTL_DELAY32
:
552 return snd_pcm_ioctl_delay_compat(substream
, argp
);
553 case SNDRV_PCM_IOCTL_REWIND32
:
554 return snd_pcm_ioctl_rewind_compat(substream
, argp
);
555 case SNDRV_PCM_IOCTL_FORWARD32
:
556 return snd_pcm_ioctl_forward_compat(substream
, argp
);