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 data
= kmalloc(sizeof(*data
), GFP_KERNEL
);
262 /* only fifo_size (RO from userspace) is different, so just copy all */
263 if (copy_from_user(data
, data32
, sizeof(*data32
))) {
269 err
= snd_pcm_hw_refine(substream
, data
);
271 err
= snd_pcm_hw_params(substream
, data
);
274 if (copy_to_user(data32
, data
, sizeof(*data32
)) ||
275 put_user(data
->fifo_size
, &data32
->fifo_size
)) {
281 unsigned int new_boundary
= recalculate_boundary(runtime
);
283 runtime
->boundary
= new_boundary
;
299 static int snd_pcm_ioctl_xferi_compat(struct snd_pcm_substream
*substream
,
300 int dir
, struct snd_xferi32 __user
*data32
)
306 if (! substream
->runtime
)
308 if (substream
->stream
!= dir
)
310 if (substream
->runtime
->status
->state
== SNDRV_PCM_STATE_OPEN
)
313 if (get_user(buf
, &data32
->buf
) ||
314 get_user(frames
, &data32
->frames
))
317 if (dir
== SNDRV_PCM_STREAM_PLAYBACK
)
318 err
= snd_pcm_lib_write(substream
, compat_ptr(buf
), frames
);
320 err
= snd_pcm_lib_read(substream
, compat_ptr(buf
), frames
);
323 /* copy the result */
324 if (put_user(err
, &data32
->result
))
330 /* snd_xfern needs remapping of bufs */
333 u32 bufs
; /* this is void **; */
338 * xfern ioctl nees to copy (up to) 128 pointers on stack.
339 * although we may pass the copied pointers through f_op->ioctl, but the ioctl
340 * handler there expands again the same 128 pointers on stack, so it is better
341 * to handle the function (calling pcm_readv/writev) directly in this handler.
343 static int snd_pcm_ioctl_xfern_compat(struct snd_pcm_substream
*substream
,
344 int dir
, struct snd_xfern32 __user
*data32
)
347 compat_caddr_t __user
*bufptr
;
352 if (! substream
->runtime
)
354 if (substream
->stream
!= dir
)
357 if ((ch
= substream
->runtime
->channels
) > 128)
359 if (get_user(buf
, &data32
->bufs
) ||
360 get_user(frames
, &data32
->frames
))
362 bufptr
= compat_ptr(buf
);
363 bufs
= kmalloc(sizeof(void __user
*) * ch
, GFP_KERNEL
);
366 for (i
= 0; i
< ch
; i
++) {
368 if (get_user(ptr
, bufptr
)) {
372 bufs
[i
] = compat_ptr(ptr
);
375 if (dir
== SNDRV_PCM_STREAM_PLAYBACK
)
376 err
= snd_pcm_lib_writev(substream
, bufs
, frames
);
378 err
= snd_pcm_lib_readv(substream
, bufs
, frames
);
380 if (put_user(err
, &data32
->result
))
388 struct snd_pcm_mmap_status32
{
392 struct compat_timespec tstamp
;
394 struct compat_timespec audio_tstamp
;
395 } __attribute__((packed
));
397 struct snd_pcm_mmap_control32
{
402 struct snd_pcm_sync_ptr32
{
405 struct snd_pcm_mmap_status32 status
;
406 unsigned char reserved
[64];
409 struct snd_pcm_mmap_control32 control
;
410 unsigned char reserved
[64];
412 } __attribute__((packed
));
414 static int snd_pcm_ioctl_sync_ptr_compat(struct snd_pcm_substream
*substream
,
415 struct snd_pcm_sync_ptr32 __user
*src
)
417 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
418 volatile struct snd_pcm_mmap_status
*status
;
419 volatile struct snd_pcm_mmap_control
*control
;
421 struct snd_pcm_mmap_control scontrol
;
422 struct snd_pcm_mmap_status sstatus
;
423 snd_pcm_uframes_t boundary
;
426 if (snd_BUG_ON(!runtime
))
429 if (get_user(sflags
, &src
->flags
) ||
430 get_user(scontrol
.appl_ptr
, &src
->c
.control
.appl_ptr
) ||
431 get_user(scontrol
.avail_min
, &src
->c
.control
.avail_min
))
433 if (sflags
& SNDRV_PCM_SYNC_PTR_HWSYNC
) {
434 err
= snd_pcm_hwsync(substream
);
438 status
= runtime
->status
;
439 control
= runtime
->control
;
440 boundary
= recalculate_boundary(runtime
);
442 boundary
= 0x7fffffff;
443 snd_pcm_stream_lock_irq(substream
);
444 /* FIXME: we should consider the boundary for the sync from app */
445 if (!(sflags
& SNDRV_PCM_SYNC_PTR_APPL
))
446 control
->appl_ptr
= scontrol
.appl_ptr
;
448 scontrol
.appl_ptr
= control
->appl_ptr
% boundary
;
449 if (!(sflags
& SNDRV_PCM_SYNC_PTR_AVAIL_MIN
))
450 control
->avail_min
= scontrol
.avail_min
;
452 scontrol
.avail_min
= control
->avail_min
;
453 sstatus
.state
= status
->state
;
454 sstatus
.hw_ptr
= status
->hw_ptr
% boundary
;
455 sstatus
.tstamp
= status
->tstamp
;
456 sstatus
.suspended_state
= status
->suspended_state
;
457 sstatus
.audio_tstamp
= status
->audio_tstamp
;
458 snd_pcm_stream_unlock_irq(substream
);
459 if (put_user(sstatus
.state
, &src
->s
.status
.state
) ||
460 put_user(sstatus
.hw_ptr
, &src
->s
.status
.hw_ptr
) ||
461 compat_put_timespec(&sstatus
.tstamp
, &src
->s
.status
.tstamp
) ||
462 put_user(sstatus
.suspended_state
, &src
->s
.status
.suspended_state
) ||
463 compat_put_timespec(&sstatus
.audio_tstamp
,
464 &src
->s
.status
.audio_tstamp
) ||
465 put_user(scontrol
.appl_ptr
, &src
->c
.control
.appl_ptr
) ||
466 put_user(scontrol
.avail_min
, &src
->c
.control
.avail_min
))
476 SNDRV_PCM_IOCTL_HW_REFINE32
= _IOWR('A', 0x10, struct snd_pcm_hw_params32
),
477 SNDRV_PCM_IOCTL_HW_PARAMS32
= _IOWR('A', 0x11, struct snd_pcm_hw_params32
),
478 SNDRV_PCM_IOCTL_SW_PARAMS32
= _IOWR('A', 0x13, struct snd_pcm_sw_params32
),
479 SNDRV_PCM_IOCTL_STATUS32
= _IOR('A', 0x20, struct snd_pcm_status32
),
480 SNDRV_PCM_IOCTL_STATUS_EXT32
= _IOWR('A', 0x24, struct snd_pcm_status32
),
481 SNDRV_PCM_IOCTL_DELAY32
= _IOR('A', 0x21, s32
),
482 SNDRV_PCM_IOCTL_CHANNEL_INFO32
= _IOR('A', 0x32, struct snd_pcm_channel_info32
),
483 SNDRV_PCM_IOCTL_REWIND32
= _IOW('A', 0x46, u32
),
484 SNDRV_PCM_IOCTL_FORWARD32
= _IOW('A', 0x49, u32
),
485 SNDRV_PCM_IOCTL_WRITEI_FRAMES32
= _IOW('A', 0x50, struct snd_xferi32
),
486 SNDRV_PCM_IOCTL_READI_FRAMES32
= _IOR('A', 0x51, struct snd_xferi32
),
487 SNDRV_PCM_IOCTL_WRITEN_FRAMES32
= _IOW('A', 0x52, struct snd_xfern32
),
488 SNDRV_PCM_IOCTL_READN_FRAMES32
= _IOR('A', 0x53, struct snd_xfern32
),
489 SNDRV_PCM_IOCTL_SYNC_PTR32
= _IOWR('A', 0x23, struct snd_pcm_sync_ptr32
),
493 static long snd_pcm_ioctl_compat(struct file
*file
, unsigned int cmd
, unsigned long arg
)
495 struct snd_pcm_file
*pcm_file
;
496 struct snd_pcm_substream
*substream
;
497 void __user
*argp
= compat_ptr(arg
);
499 pcm_file
= file
->private_data
;
502 substream
= pcm_file
->substream
;
507 * When PCM is used on 32bit mode, we need to disable
508 * mmap of PCM status/control records because of the size
511 pcm_file
->no_compat_mmap
= 1;
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_HWSYNC
:
519 case SNDRV_PCM_IOCTL_PREPARE
:
520 case SNDRV_PCM_IOCTL_RESET
:
521 case SNDRV_PCM_IOCTL_START
:
522 case SNDRV_PCM_IOCTL_DROP
:
523 case SNDRV_PCM_IOCTL_DRAIN
:
524 case SNDRV_PCM_IOCTL_PAUSE
:
525 case SNDRV_PCM_IOCTL_HW_FREE
:
526 case SNDRV_PCM_IOCTL_RESUME
:
527 case SNDRV_PCM_IOCTL_XRUN
:
528 case SNDRV_PCM_IOCTL_LINK
:
529 case SNDRV_PCM_IOCTL_UNLINK
:
530 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
531 return snd_pcm_playback_ioctl1(file
, substream
, cmd
, argp
);
533 return snd_pcm_capture_ioctl1(file
, substream
, cmd
, argp
);
534 case SNDRV_PCM_IOCTL_HW_REFINE32
:
535 return snd_pcm_ioctl_hw_params_compat(substream
, 1, argp
);
536 case SNDRV_PCM_IOCTL_HW_PARAMS32
:
537 return snd_pcm_ioctl_hw_params_compat(substream
, 0, argp
);
538 case SNDRV_PCM_IOCTL_SW_PARAMS32
:
539 return snd_pcm_ioctl_sw_params_compat(substream
, argp
);
540 case SNDRV_PCM_IOCTL_STATUS32
:
541 return snd_pcm_status_user_compat(substream
, argp
, false);
542 case SNDRV_PCM_IOCTL_STATUS_EXT32
:
543 return snd_pcm_status_user_compat(substream
, argp
, true);
544 case SNDRV_PCM_IOCTL_SYNC_PTR32
:
545 return snd_pcm_ioctl_sync_ptr_compat(substream
, argp
);
546 case SNDRV_PCM_IOCTL_CHANNEL_INFO32
:
547 return snd_pcm_ioctl_channel_info_compat(substream
, argp
);
548 case SNDRV_PCM_IOCTL_WRITEI_FRAMES32
:
549 return snd_pcm_ioctl_xferi_compat(substream
, SNDRV_PCM_STREAM_PLAYBACK
, argp
);
550 case SNDRV_PCM_IOCTL_READI_FRAMES32
:
551 return snd_pcm_ioctl_xferi_compat(substream
, SNDRV_PCM_STREAM_CAPTURE
, argp
);
552 case SNDRV_PCM_IOCTL_WRITEN_FRAMES32
:
553 return snd_pcm_ioctl_xfern_compat(substream
, SNDRV_PCM_STREAM_PLAYBACK
, argp
);
554 case SNDRV_PCM_IOCTL_READN_FRAMES32
:
555 return snd_pcm_ioctl_xfern_compat(substream
, SNDRV_PCM_STREAM_CAPTURE
, argp
);
556 case SNDRV_PCM_IOCTL_DELAY32
:
557 return snd_pcm_ioctl_delay_compat(substream
, argp
);
558 case SNDRV_PCM_IOCTL_REWIND32
:
559 return snd_pcm_ioctl_rewind_compat(substream
, argp
);
560 case SNDRV_PCM_IOCTL_FORWARD32
:
561 return snd_pcm_ioctl_forward_compat(substream
, argp
);