pcm_compat.c 21.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 *   32bit -> 64bit ioctl wrapper for PCM API
 *   Copyright (c) by Takashi Iwai <tiwai@suse.de>
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 */

/* This file included from pcm_native.c */

#include <linux/compat.h>
24
#include <linux/slab.h>
L
Linus Torvalds 已提交
25

T
Takashi Iwai 已提交
26
static int snd_pcm_ioctl_delay_compat(struct snd_pcm_substream *substream,
L
Linus Torvalds 已提交
27 28 29
				      s32 __user *src)
{
	snd_pcm_sframes_t delay;
30
	int err;
L
Linus Torvalds 已提交
31

32 33 34
	err = snd_pcm_delay(substream, &delay);
	if (err)
		return err;
L
Linus Torvalds 已提交
35 36
	if (put_user(delay, src))
		return -EFAULT;
37
	return 0;
L
Linus Torvalds 已提交
38 39
}

T
Takashi Iwai 已提交
40
static int snd_pcm_ioctl_rewind_compat(struct snd_pcm_substream *substream,
L
Linus Torvalds 已提交
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
				       u32 __user *src)
{
	snd_pcm_uframes_t frames;
	int err;

	if (get_user(frames, src))
		return -EFAULT;
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
		err = snd_pcm_playback_rewind(substream, frames);
	else
		err = snd_pcm_capture_rewind(substream, frames);
	if (put_user(err, src))
		return -EFAULT;
	return err < 0 ? err : 0;
}

T
Takashi Iwai 已提交
57
static int snd_pcm_ioctl_forward_compat(struct snd_pcm_substream *substream,
L
Linus Torvalds 已提交
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
				       u32 __user *src)
{
	snd_pcm_uframes_t frames;
	int err;

	if (get_user(frames, src))
		return -EFAULT;
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
		err = snd_pcm_playback_forward(substream, frames);
	else
		err = snd_pcm_capture_forward(substream, frames);
	if (put_user(err, src))
		return -EFAULT;
	return err < 0 ? err : 0;
}

T
Takashi Iwai 已提交
74
struct snd_pcm_hw_params32 {
L
Linus Torvalds 已提交
75
	u32 flags;
T
Takashi Iwai 已提交
76 77 78 79
	struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; /* this must be identical */
	struct snd_mask mres[5];	/* reserved masks */
	struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
	struct snd_interval ires[9];	/* reserved intervals */
L
Linus Torvalds 已提交
80 81 82 83 84 85 86 87 88 89
	u32 rmask;
	u32 cmask;
	u32 info;
	u32 msbits;
	u32 rate_num;
	u32 rate_den;
	u32 fifo_size;
	unsigned char reserved[64];
};

T
Takashi Iwai 已提交
90
struct snd_pcm_sw_params32 {
L
Linus Torvalds 已提交
91 92 93 94 95 96 97 98 99 100
	s32 tstamp_mode;
	u32 period_step;
	u32 sleep_min;
	u32 avail_min;
	u32 xfer_align;
	u32 start_threshold;
	u32 stop_threshold;
	u32 silence_threshold;
	u32 silence_size;
	u32 boundary;
101 102 103
	u32 proto;
	u32 tstamp_type;
	unsigned char reserved[56];
L
Linus Torvalds 已提交
104 105
};

T
Takashi Iwai 已提交
106
/* recalcuate the boundary within 32bit */
T
Takashi Iwai 已提交
107
static snd_pcm_uframes_t recalculate_boundary(struct snd_pcm_runtime *runtime)
T
Takashi Iwai 已提交
108 109 110 111 112 113 114 115 116 117 118
{
	snd_pcm_uframes_t boundary;

	if (! runtime->buffer_size)
		return 0;
	boundary = runtime->buffer_size;
	while (boundary * 2 <= 0x7fffffffUL - runtime->buffer_size)
		boundary *= 2;
	return boundary;
}

T
Takashi Iwai 已提交
119 120
static int snd_pcm_ioctl_sw_params_compat(struct snd_pcm_substream *substream,
					  struct snd_pcm_sw_params32 __user *src)
L
Linus Torvalds 已提交
121
{
T
Takashi Iwai 已提交
122
	struct snd_pcm_sw_params params;
T
Takashi Iwai 已提交
123
	snd_pcm_uframes_t boundary;
L
Linus Torvalds 已提交
124 125 126 127 128 129 130 131 132 133 134
	int err;

	memset(&params, 0, sizeof(params));
	if (get_user(params.tstamp_mode, &src->tstamp_mode) ||
	    get_user(params.period_step, &src->period_step) ||
	    get_user(params.sleep_min, &src->sleep_min) ||
	    get_user(params.avail_min, &src->avail_min) ||
	    get_user(params.xfer_align, &src->xfer_align) ||
	    get_user(params.start_threshold, &src->start_threshold) ||
	    get_user(params.stop_threshold, &src->stop_threshold) ||
	    get_user(params.silence_threshold, &src->silence_threshold) ||
135 136 137
	    get_user(params.silence_size, &src->silence_size) ||
	    get_user(params.tstamp_type, &src->tstamp_type) ||
	    get_user(params.proto, &src->proto))
L
Linus Torvalds 已提交
138
		return -EFAULT;
T
Takashi Iwai 已提交
139 140 141 142 143 144 145
	/*
	 * Check silent_size parameter.  Since we have 64bit boundary,
	 * silence_size must be compared with the 32bit boundary.
	 */
	boundary = recalculate_boundary(substream->runtime);
	if (boundary && params.silence_size >= boundary)
		params.silence_size = substream->runtime->boundary;
L
Linus Torvalds 已提交
146 147 148
	err = snd_pcm_sw_params(substream, &params);
	if (err < 0)
		return err;
149
	if (boundary && put_user(boundary, &src->boundary))
L
Linus Torvalds 已提交
150 151 152 153
		return -EFAULT;
	return err;
}

T
Takashi Iwai 已提交
154
struct snd_pcm_channel_info32 {
L
Linus Torvalds 已提交
155 156 157 158 159 160
	u32 channel;
	u32 offset;
	u32 first;
	u32 step;
};

T
Takashi Iwai 已提交
161 162
static int snd_pcm_ioctl_channel_info_compat(struct snd_pcm_substream *substream,
					     struct snd_pcm_channel_info32 __user *src)
L
Linus Torvalds 已提交
163
{
T
Takashi Iwai 已提交
164
	struct snd_pcm_channel_info info;
L
Linus Torvalds 已提交
165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
	int err;

	if (get_user(info.channel, &src->channel) ||
	    get_user(info.offset, &src->offset) ||
	    get_user(info.first, &src->first) ||
	    get_user(info.step, &src->step))
		return -EFAULT;
	err = snd_pcm_channel_info(substream, &info);
	if (err < 0)
		return err;
	if (put_user(info.channel, &src->channel) ||
	    put_user(info.offset, &src->offset) ||
	    put_user(info.first, &src->first) ||
	    put_user(info.step, &src->step))
		return -EFAULT;
	return err;
}

T
Takashi Iwai 已提交
183 184 185 186 187 188 189 190
#ifdef CONFIG_X86_X32
/* X32 ABI has the same struct as x86-64 for snd_pcm_channel_info */
static int snd_pcm_channel_info_user(struct snd_pcm_substream *substream,
				     struct snd_pcm_channel_info __user *src);
#define snd_pcm_ioctl_channel_info_x32(s, p)	\
	snd_pcm_channel_info_user(s, p)
#endif /* CONFIG_X86_X32 */

T
Takashi Iwai 已提交
191
struct snd_pcm_status32 {
L
Linus Torvalds 已提交
192 193 194 195 196 197 198 199 200 201
	s32 state;
	struct compat_timespec trigger_tstamp;
	struct compat_timespec tstamp;
	u32 appl_ptr;
	u32 hw_ptr;
	s32 delay;
	u32 avail;
	u32 avail_max;
	u32 overrange;
	s32 suspended_state;
202
	u32 audio_tstamp_data;
203
	struct compat_timespec audio_tstamp;
204 205 206
	struct compat_timespec driver_tstamp;
	u32 audio_tstamp_accuracy;
	unsigned char reserved[52-2*sizeof(struct compat_timespec)];
L
Linus Torvalds 已提交
207 208 209
} __attribute__((packed));


T
Takashi Iwai 已提交
210
static int snd_pcm_status_user_compat(struct snd_pcm_substream *substream,
211 212
				      struct snd_pcm_status32 __user *src,
				      bool ext)
L
Linus Torvalds 已提交
213
{
T
Takashi Iwai 已提交
214
	struct snd_pcm_status status;
L
Linus Torvalds 已提交
215 216
	int err;

217 218 219 220 221 222 223 224 225
	memset(&status, 0, sizeof(status));
	/*
	 * with extension, parameters are read/write,
	 * get audio_tstamp_data from user,
	 * ignore rest of status structure
	 */
	if (ext && get_user(status.audio_tstamp_data,
				(u32 __user *)(&src->audio_tstamp_data)))
		return -EFAULT;
L
Linus Torvalds 已提交
226 227 228 229
	err = snd_pcm_status(substream, &status);
	if (err < 0)
		return err;

230 231
	if (clear_user(src, sizeof(*src)))
		return -EFAULT;
L
Linus Torvalds 已提交
232
	if (put_user(status.state, &src->state) ||
233 234
	    compat_put_timespec(&status.trigger_tstamp, &src->trigger_tstamp) ||
	    compat_put_timespec(&status.tstamp, &src->tstamp) ||
L
Linus Torvalds 已提交
235 236 237 238 239 240
	    put_user(status.appl_ptr, &src->appl_ptr) ||
	    put_user(status.hw_ptr, &src->hw_ptr) ||
	    put_user(status.delay, &src->delay) ||
	    put_user(status.avail, &src->avail) ||
	    put_user(status.avail_max, &src->avail_max) ||
	    put_user(status.overrange, &src->overrange) ||
241
	    put_user(status.suspended_state, &src->suspended_state) ||
242 243 244 245
	    put_user(status.audio_tstamp_data, &src->audio_tstamp_data) ||
	    compat_put_timespec(&status.audio_tstamp, &src->audio_tstamp) ||
	    compat_put_timespec(&status.driver_tstamp, &src->driver_tstamp) ||
	    put_user(status.audio_tstamp_accuracy, &src->audio_tstamp_accuracy))
L
Linus Torvalds 已提交
246 247 248 249 250
		return -EFAULT;

	return err;
}

T
Takashi Iwai 已提交
251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
#ifdef CONFIG_X86_X32
/* X32 ABI has 64bit timespec and 64bit alignment */
struct snd_pcm_status_x32 {
	s32 state;
	u32 rsvd; /* alignment */
	struct timespec trigger_tstamp;
	struct timespec tstamp;
	u32 appl_ptr;
	u32 hw_ptr;
	s32 delay;
	u32 avail;
	u32 avail_max;
	u32 overrange;
	s32 suspended_state;
	u32 audio_tstamp_data;
	struct timespec audio_tstamp;
	struct timespec driver_tstamp;
	u32 audio_tstamp_accuracy;
	unsigned char reserved[52-2*sizeof(struct timespec)];
} __packed;

#define put_timespec(src, dst) copy_to_user(dst, src, sizeof(*dst))

static int snd_pcm_status_user_x32(struct snd_pcm_substream *substream,
				   struct snd_pcm_status_x32 __user *src,
				   bool ext)
{
	struct snd_pcm_status status;
	int err;

	memset(&status, 0, sizeof(status));
	/*
	 * with extension, parameters are read/write,
	 * get audio_tstamp_data from user,
	 * ignore rest of status structure
	 */
	if (ext && get_user(status.audio_tstamp_data,
				(u32 __user *)(&src->audio_tstamp_data)))
		return -EFAULT;
	err = snd_pcm_status(substream, &status);
	if (err < 0)
		return err;

	if (clear_user(src, sizeof(*src)))
		return -EFAULT;
	if (put_user(status.state, &src->state) ||
	    put_timespec(&status.trigger_tstamp, &src->trigger_tstamp) ||
	    put_timespec(&status.tstamp, &src->tstamp) ||
	    put_user(status.appl_ptr, &src->appl_ptr) ||
	    put_user(status.hw_ptr, &src->hw_ptr) ||
	    put_user(status.delay, &src->delay) ||
	    put_user(status.avail, &src->avail) ||
	    put_user(status.avail_max, &src->avail_max) ||
	    put_user(status.overrange, &src->overrange) ||
	    put_user(status.suspended_state, &src->suspended_state) ||
	    put_user(status.audio_tstamp_data, &src->audio_tstamp_data) ||
	    put_timespec(&status.audio_tstamp, &src->audio_tstamp) ||
	    put_timespec(&status.driver_tstamp, &src->driver_tstamp) ||
	    put_user(status.audio_tstamp_accuracy, &src->audio_tstamp_accuracy))
		return -EFAULT;

	return err;
}
#endif /* CONFIG_X86_X32 */

L
Linus Torvalds 已提交
316
/* both for HW_PARAMS and HW_REFINE */
T
Takashi Iwai 已提交
317
static int snd_pcm_ioctl_hw_params_compat(struct snd_pcm_substream *substream,
L
Linus Torvalds 已提交
318
					  int refine, 
T
Takashi Iwai 已提交
319
					  struct snd_pcm_hw_params32 __user *data32)
L
Linus Torvalds 已提交
320
{
T
Takashi Iwai 已提交
321 322
	struct snd_pcm_hw_params *data;
	struct snd_pcm_runtime *runtime;
L
Linus Torvalds 已提交
323 324 325 326 327
	int err;

	if (! (runtime = substream->runtime))
		return -ENOTTY;

328 329 330 331 332 333 334 335 336
	data = kmalloc(sizeof(*data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	/* only fifo_size (RO from userspace) is different, so just copy all */
	if (copy_from_user(data, data32, sizeof(*data32))) {
		err = -EFAULT;
		goto error;
	}
L
Li Zefan 已提交
337

L
Linus Torvalds 已提交
338 339 340 341 342 343 344 345 346 347 348 349
	if (refine)
		err = snd_pcm_hw_refine(substream, data);
	else
		err = snd_pcm_hw_params(substream, data);
	if (err < 0)
		goto error;
	if (copy_to_user(data32, data, sizeof(*data32)) ||
	    put_user(data->fifo_size, &data32->fifo_size)) {
		err = -EFAULT;
		goto error;
	}

350 351 352 353 354
	if (! refine) {
		unsigned int new_boundary = recalculate_boundary(runtime);
		if (new_boundary)
			runtime->boundary = new_boundary;
	}
L
Linus Torvalds 已提交
355 356 357 358 359 360 361 362
 error:
	kfree(data);
	return err;
}


/*
 */
T
Takashi Iwai 已提交
363
struct snd_xferi32 {
L
Linus Torvalds 已提交
364 365 366 367 368
	s32 result;
	u32 buf;
	u32 frames;
};

T
Takashi Iwai 已提交
369 370
static int snd_pcm_ioctl_xferi_compat(struct snd_pcm_substream *substream,
				      int dir, struct snd_xferi32 __user *data32)
L
Linus Torvalds 已提交
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400
{
	compat_caddr_t buf;
	u32 frames;
	int err;

	if (! substream->runtime)
		return -ENOTTY;
	if (substream->stream != dir)
		return -EINVAL;
	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN)
		return -EBADFD;

	if (get_user(buf, &data32->buf) ||
	    get_user(frames, &data32->frames))
		return -EFAULT;

	if (dir == SNDRV_PCM_STREAM_PLAYBACK)
		err = snd_pcm_lib_write(substream, compat_ptr(buf), frames);
	else
		err = snd_pcm_lib_read(substream, compat_ptr(buf), frames);
	if (err < 0)
		return err;
	/* copy the result */
	if (put_user(err, &data32->result))
		return -EFAULT;
	return 0;
}


/* snd_xfern needs remapping of bufs */
T
Takashi Iwai 已提交
401
struct snd_xfern32 {
L
Linus Torvalds 已提交
402 403 404 405 406 407 408 409 410 411 412
	s32 result;
	u32 bufs;  /* this is void **; */
	u32 frames;
};

/*
 * xfern ioctl nees to copy (up to) 128 pointers on stack.
 * although we may pass the copied pointers through f_op->ioctl, but the ioctl
 * handler there expands again the same 128 pointers on stack, so it is better
 * to handle the function (calling pcm_readv/writev) directly in this handler.
 */
T
Takashi Iwai 已提交
413 414
static int snd_pcm_ioctl_xfern_compat(struct snd_pcm_substream *substream,
				      int dir, struct snd_xfern32 __user *data32)
L
Linus Torvalds 已提交
415 416 417 418 419 420 421 422 423 424 425
{
	compat_caddr_t buf;
	compat_caddr_t __user *bufptr;
	u32 frames;
	void __user **bufs;
	int err, ch, i;

	if (! substream->runtime)
		return -ENOTTY;
	if (substream->stream != dir)
		return -EINVAL;
426 427
	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN)
		return -EBADFD;
L
Linus Torvalds 已提交
428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443

	if ((ch = substream->runtime->channels) > 128)
		return -EINVAL;
	if (get_user(buf, &data32->bufs) ||
	    get_user(frames, &data32->frames))
		return -EFAULT;
	bufptr = compat_ptr(buf);
	bufs = kmalloc(sizeof(void __user *) * ch, GFP_KERNEL);
	if (bufs == NULL)
		return -ENOMEM;
	for (i = 0; i < ch; i++) {
		u32 ptr;
		if (get_user(ptr, bufptr)) {
			kfree(bufs);
			return -EFAULT;
		}
444
		bufs[i] = compat_ptr(ptr);
L
Linus Torvalds 已提交
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
		bufptr++;
	}
	if (dir == SNDRV_PCM_STREAM_PLAYBACK)
		err = snd_pcm_lib_writev(substream, bufs, frames);
	else
		err = snd_pcm_lib_readv(substream, bufs, frames);
	if (err >= 0) {
		if (put_user(err, &data32->result))
			err = -EFAULT;
	}
	kfree(bufs);
	return err;
}


T
Takashi Iwai 已提交
460
struct snd_pcm_mmap_status32 {
L
Linus Torvalds 已提交
461 462 463 464 465
	s32 state;
	s32 pad1;
	u32 hw_ptr;
	struct compat_timespec tstamp;
	s32 suspended_state;
466
	struct compat_timespec audio_tstamp;
L
Linus Torvalds 已提交
467 468
} __attribute__((packed));

T
Takashi Iwai 已提交
469
struct snd_pcm_mmap_control32 {
L
Linus Torvalds 已提交
470 471 472 473
	u32 appl_ptr;
	u32 avail_min;
};

T
Takashi Iwai 已提交
474
struct snd_pcm_sync_ptr32 {
L
Linus Torvalds 已提交
475 476
	u32 flags;
	union {
T
Takashi Iwai 已提交
477
		struct snd_pcm_mmap_status32 status;
L
Linus Torvalds 已提交
478 479 480
		unsigned char reserved[64];
	} s;
	union {
T
Takashi Iwai 已提交
481
		struct snd_pcm_mmap_control32 control;
L
Linus Torvalds 已提交
482 483 484 485
		unsigned char reserved[64];
	} c;
} __attribute__((packed));

T
Takashi Iwai 已提交
486 487
static int snd_pcm_ioctl_sync_ptr_compat(struct snd_pcm_substream *substream,
					 struct snd_pcm_sync_ptr32 __user *src)
L
Linus Torvalds 已提交
488
{
T
Takashi Iwai 已提交
489 490 491
	struct snd_pcm_runtime *runtime = substream->runtime;
	volatile struct snd_pcm_mmap_status *status;
	volatile struct snd_pcm_mmap_control *control;
L
Linus Torvalds 已提交
492
	u32 sflags;
T
Takashi Iwai 已提交
493 494
	struct snd_pcm_mmap_control scontrol;
	struct snd_pcm_mmap_status sstatus;
T
Takashi Iwai 已提交
495
	snd_pcm_uframes_t boundary;
L
Linus Torvalds 已提交
496 497
	int err;

498 499
	if (snd_BUG_ON(!runtime))
		return -EINVAL;
L
Linus Torvalds 已提交
500 501 502 503 504 505 506 507 508 509 510 511

	if (get_user(sflags, &src->flags) ||
	    get_user(scontrol.appl_ptr, &src->c.control.appl_ptr) ||
	    get_user(scontrol.avail_min, &src->c.control.avail_min))
		return -EFAULT;
	if (sflags & SNDRV_PCM_SYNC_PTR_HWSYNC) {
		err = snd_pcm_hwsync(substream);
		if (err < 0)
			return err;
	}
	status = runtime->status;
	control = runtime->control;
T
Takashi Iwai 已提交
512
	boundary = recalculate_boundary(runtime);
513 514
	if (! boundary)
		boundary = 0x7fffffff;
L
Linus Torvalds 已提交
515
	snd_pcm_stream_lock_irq(substream);
T
Takashi Iwai 已提交
516
	/* FIXME: we should consider the boundary for the sync from app */
L
Linus Torvalds 已提交
517 518 519
	if (!(sflags & SNDRV_PCM_SYNC_PTR_APPL))
		control->appl_ptr = scontrol.appl_ptr;
	else
T
Takashi Iwai 已提交
520
		scontrol.appl_ptr = control->appl_ptr % boundary;
L
Linus Torvalds 已提交
521 522 523 524 525
	if (!(sflags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN))
		control->avail_min = scontrol.avail_min;
	else
		scontrol.avail_min = control->avail_min;
	sstatus.state = status->state;
T
Takashi Iwai 已提交
526
	sstatus.hw_ptr = status->hw_ptr % boundary;
L
Linus Torvalds 已提交
527 528
	sstatus.tstamp = status->tstamp;
	sstatus.suspended_state = status->suspended_state;
529
	sstatus.audio_tstamp = status->audio_tstamp;
L
Linus Torvalds 已提交
530 531 532
	snd_pcm_stream_unlock_irq(substream);
	if (put_user(sstatus.state, &src->s.status.state) ||
	    put_user(sstatus.hw_ptr, &src->s.status.hw_ptr) ||
533
	    compat_put_timespec(&sstatus.tstamp, &src->s.status.tstamp) ||
L
Linus Torvalds 已提交
534
	    put_user(sstatus.suspended_state, &src->s.status.suspended_state) ||
535 536
	    compat_put_timespec(&sstatus.audio_tstamp,
		    &src->s.status.audio_tstamp) ||
L
Linus Torvalds 已提交
537 538 539 540 541 542 543
	    put_user(scontrol.appl_ptr, &src->c.control.appl_ptr) ||
	    put_user(scontrol.avail_min, &src->c.control.avail_min))
		return -EFAULT;

	return 0;
}

T
Takashi Iwai 已提交
544 545 546 547 548 549 550 551 552
#ifdef CONFIG_X86_X32
/* X32 ABI has 64bit timespec and 64bit alignment */
struct snd_pcm_mmap_status_x32 {
	s32 state;
	s32 pad1;
	u32 hw_ptr;
	u32 pad2; /* alignment */
	struct timespec tstamp;
	s32 suspended_state;
553
	s32 pad3;
T
Takashi Iwai 已提交
554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631
	struct timespec audio_tstamp;
} __packed;

struct snd_pcm_mmap_control_x32 {
	u32 appl_ptr;
	u32 avail_min;
};

struct snd_pcm_sync_ptr_x32 {
	u32 flags;
	u32 rsvd; /* alignment */
	union {
		struct snd_pcm_mmap_status_x32 status;
		unsigned char reserved[64];
	} s;
	union {
		struct snd_pcm_mmap_control_x32 control;
		unsigned char reserved[64];
	} c;
} __packed;

static int snd_pcm_ioctl_sync_ptr_x32(struct snd_pcm_substream *substream,
				      struct snd_pcm_sync_ptr_x32 __user *src)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	volatile struct snd_pcm_mmap_status *status;
	volatile struct snd_pcm_mmap_control *control;
	u32 sflags;
	struct snd_pcm_mmap_control scontrol;
	struct snd_pcm_mmap_status sstatus;
	snd_pcm_uframes_t boundary;
	int err;

	if (snd_BUG_ON(!runtime))
		return -EINVAL;

	if (get_user(sflags, &src->flags) ||
	    get_user(scontrol.appl_ptr, &src->c.control.appl_ptr) ||
	    get_user(scontrol.avail_min, &src->c.control.avail_min))
		return -EFAULT;
	if (sflags & SNDRV_PCM_SYNC_PTR_HWSYNC) {
		err = snd_pcm_hwsync(substream);
		if (err < 0)
			return err;
	}
	status = runtime->status;
	control = runtime->control;
	boundary = recalculate_boundary(runtime);
	if (!boundary)
		boundary = 0x7fffffff;
	snd_pcm_stream_lock_irq(substream);
	/* FIXME: we should consider the boundary for the sync from app */
	if (!(sflags & SNDRV_PCM_SYNC_PTR_APPL))
		control->appl_ptr = scontrol.appl_ptr;
	else
		scontrol.appl_ptr = control->appl_ptr % boundary;
	if (!(sflags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN))
		control->avail_min = scontrol.avail_min;
	else
		scontrol.avail_min = control->avail_min;
	sstatus.state = status->state;
	sstatus.hw_ptr = status->hw_ptr % boundary;
	sstatus.tstamp = status->tstamp;
	sstatus.suspended_state = status->suspended_state;
	sstatus.audio_tstamp = status->audio_tstamp;
	snd_pcm_stream_unlock_irq(substream);
	if (put_user(sstatus.state, &src->s.status.state) ||
	    put_user(sstatus.hw_ptr, &src->s.status.hw_ptr) ||
	    put_timespec(&sstatus.tstamp, &src->s.status.tstamp) ||
	    put_user(sstatus.suspended_state, &src->s.status.suspended_state) ||
	    put_timespec(&sstatus.audio_tstamp, &src->s.status.audio_tstamp) ||
	    put_user(scontrol.appl_ptr, &src->c.control.appl_ptr) ||
	    put_user(scontrol.avail_min, &src->c.control.avail_min))
		return -EFAULT;

	return 0;
}
#endif /* CONFIG_X86_X32 */
L
Linus Torvalds 已提交
632 633 634 635

/*
 */
enum {
T
Takashi Iwai 已提交
636 637 638 639
	SNDRV_PCM_IOCTL_HW_REFINE32 = _IOWR('A', 0x10, struct snd_pcm_hw_params32),
	SNDRV_PCM_IOCTL_HW_PARAMS32 = _IOWR('A', 0x11, struct snd_pcm_hw_params32),
	SNDRV_PCM_IOCTL_SW_PARAMS32 = _IOWR('A', 0x13, struct snd_pcm_sw_params32),
	SNDRV_PCM_IOCTL_STATUS32 = _IOR('A', 0x20, struct snd_pcm_status32),
640
	SNDRV_PCM_IOCTL_STATUS_EXT32 = _IOWR('A', 0x24, struct snd_pcm_status32),
L
Linus Torvalds 已提交
641
	SNDRV_PCM_IOCTL_DELAY32 = _IOR('A', 0x21, s32),
T
Takashi Iwai 已提交
642
	SNDRV_PCM_IOCTL_CHANNEL_INFO32 = _IOR('A', 0x32, struct snd_pcm_channel_info32),
L
Linus Torvalds 已提交
643 644
	SNDRV_PCM_IOCTL_REWIND32 = _IOW('A', 0x46, u32),
	SNDRV_PCM_IOCTL_FORWARD32 = _IOW('A', 0x49, u32),
T
Takashi Iwai 已提交
645 646 647 648 649
	SNDRV_PCM_IOCTL_WRITEI_FRAMES32 = _IOW('A', 0x50, struct snd_xferi32),
	SNDRV_PCM_IOCTL_READI_FRAMES32 = _IOR('A', 0x51, struct snd_xferi32),
	SNDRV_PCM_IOCTL_WRITEN_FRAMES32 = _IOW('A', 0x52, struct snd_xfern32),
	SNDRV_PCM_IOCTL_READN_FRAMES32 = _IOR('A', 0x53, struct snd_xfern32),
	SNDRV_PCM_IOCTL_SYNC_PTR32 = _IOWR('A', 0x23, struct snd_pcm_sync_ptr32),
T
Takashi Iwai 已提交
650 651 652 653 654 655
#ifdef CONFIG_X86_X32
	SNDRV_PCM_IOCTL_CHANNEL_INFO_X32 = _IOR('A', 0x32, struct snd_pcm_channel_info),
	SNDRV_PCM_IOCTL_STATUS_X32 = _IOR('A', 0x20, struct snd_pcm_status_x32),
	SNDRV_PCM_IOCTL_STATUS_EXT_X32 = _IOWR('A', 0x24, struct snd_pcm_status_x32),
	SNDRV_PCM_IOCTL_SYNC_PTR_X32 = _IOWR('A', 0x23, struct snd_pcm_sync_ptr_x32),
#endif /* CONFIG_X86_X32 */
L
Linus Torvalds 已提交
656 657 658 659
};

static long snd_pcm_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg)
{
T
Takashi Iwai 已提交
660 661
	struct snd_pcm_file *pcm_file;
	struct snd_pcm_substream *substream;
L
Linus Torvalds 已提交
662 663 664 665 666 667 668 669 670 671 672 673 674 675
	void __user *argp = compat_ptr(arg);

	pcm_file = file->private_data;
	if (! pcm_file)
		return -ENOTTY;
	substream = pcm_file->substream;
	if (! substream)
		return -ENOTTY;

	/*
	 * When PCM is used on 32bit mode, we need to disable
	 * mmap of PCM status/control records because of the size
	 * incompatibility.
	 */
676
	pcm_file->no_compat_mmap = 1;
L
Linus Torvalds 已提交
677 678 679 680

	switch (cmd) {
	case SNDRV_PCM_IOCTL_PVERSION:
	case SNDRV_PCM_IOCTL_INFO:
681
	case SNDRV_PCM_IOCTL_TSTAMP:
682
	case SNDRV_PCM_IOCTL_TTSTAMP:
683
	case SNDRV_PCM_IOCTL_USER_PVERSION:
L
Linus Torvalds 已提交
684 685 686 687 688 689 690 691 692 693 694 695
	case SNDRV_PCM_IOCTL_HWSYNC:
	case SNDRV_PCM_IOCTL_PREPARE:
	case SNDRV_PCM_IOCTL_RESET:
	case SNDRV_PCM_IOCTL_START:
	case SNDRV_PCM_IOCTL_DROP:
	case SNDRV_PCM_IOCTL_DRAIN:
	case SNDRV_PCM_IOCTL_PAUSE:
	case SNDRV_PCM_IOCTL_HW_FREE:
	case SNDRV_PCM_IOCTL_RESUME:
	case SNDRV_PCM_IOCTL_XRUN:
	case SNDRV_PCM_IOCTL_LINK:
	case SNDRV_PCM_IOCTL_UNLINK:
696
		return snd_pcm_common_ioctl(file, substream, cmd, argp);
L
Linus Torvalds 已提交
697 698 699 700 701 702 703
	case SNDRV_PCM_IOCTL_HW_REFINE32:
		return snd_pcm_ioctl_hw_params_compat(substream, 1, argp);
	case SNDRV_PCM_IOCTL_HW_PARAMS32:
		return snd_pcm_ioctl_hw_params_compat(substream, 0, argp);
	case SNDRV_PCM_IOCTL_SW_PARAMS32:
		return snd_pcm_ioctl_sw_params_compat(substream, argp);
	case SNDRV_PCM_IOCTL_STATUS32:
704 705 706
		return snd_pcm_status_user_compat(substream, argp, false);
	case SNDRV_PCM_IOCTL_STATUS_EXT32:
		return snd_pcm_status_user_compat(substream, argp, true);
L
Linus Torvalds 已提交
707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724
	case SNDRV_PCM_IOCTL_SYNC_PTR32:
		return snd_pcm_ioctl_sync_ptr_compat(substream, argp);
	case SNDRV_PCM_IOCTL_CHANNEL_INFO32:
		return snd_pcm_ioctl_channel_info_compat(substream, argp);
	case SNDRV_PCM_IOCTL_WRITEI_FRAMES32:
		return snd_pcm_ioctl_xferi_compat(substream, SNDRV_PCM_STREAM_PLAYBACK, argp);
	case SNDRV_PCM_IOCTL_READI_FRAMES32:
		return snd_pcm_ioctl_xferi_compat(substream, SNDRV_PCM_STREAM_CAPTURE, argp);
	case SNDRV_PCM_IOCTL_WRITEN_FRAMES32:
		return snd_pcm_ioctl_xfern_compat(substream, SNDRV_PCM_STREAM_PLAYBACK, argp);
	case SNDRV_PCM_IOCTL_READN_FRAMES32:
		return snd_pcm_ioctl_xfern_compat(substream, SNDRV_PCM_STREAM_CAPTURE, argp);
	case SNDRV_PCM_IOCTL_DELAY32:
		return snd_pcm_ioctl_delay_compat(substream, argp);
	case SNDRV_PCM_IOCTL_REWIND32:
		return snd_pcm_ioctl_rewind_compat(substream, argp);
	case SNDRV_PCM_IOCTL_FORWARD32:
		return snd_pcm_ioctl_forward_compat(substream, argp);
T
Takashi Iwai 已提交
725 726 727 728 729 730 731 732 733 734
#ifdef CONFIG_X86_X32
	case SNDRV_PCM_IOCTL_STATUS_X32:
		return snd_pcm_status_user_x32(substream, argp, false);
	case SNDRV_PCM_IOCTL_STATUS_EXT_X32:
		return snd_pcm_status_user_x32(substream, argp, true);
	case SNDRV_PCM_IOCTL_SYNC_PTR_X32:
		return snd_pcm_ioctl_sync_ptr_x32(substream, argp);
	case SNDRV_PCM_IOCTL_CHANNEL_INFO_X32:
		return snd_pcm_ioctl_channel_info_x32(substream, argp);
#endif /* CONFIG_X86_X32 */
L
Linus Torvalds 已提交
735 736 737 738
	}

	return -ENOIOCTLCMD;
}