sound/core/ioctl32/pcm32.c

   1 /*
   2  *   32bit -> 64bit ioctl wrapper for PCM API
   3  *   Copyright (c) by Takashi Iwai <tiwai@suse.de>
   4  *
   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.
   9  *
  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.
  14  *
  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
  18  *
  19  */
  20
  21 #include <sound/driver.h>
  22 #include <linux/time.h>
  23 #include <linux/slab.h>
  24 #include <linux/compat.h>
  25 #include <sound/core.h>
  26 #include <sound/pcm.h>
  27 #include "ioctl32.h"
  28
  29
  30 /* wrapper for sndrv_pcm_[us]frames */
  31 struct sndrv_pcm_sframes_str {
  32         sndrv_pcm_sframes_t val;
  33 };
  34 struct sndrv_pcm_sframes_str32 {
  35         s32 val;
  36 };
  37 struct sndrv_pcm_uframes_str {
  38         sndrv_pcm_uframes_t val;
  39 };
  40 struct sndrv_pcm_uframes_str32 {
  41         u32 val;
  42 };
  43
  44 #define CVT_sndrv_pcm_sframes_str() { COPY(val); }
  45 #define CVT_sndrv_pcm_uframes_str() { COPY(val); }
  46
  47
  48 struct sndrv_interval32 {
  49         u32 min, max;
  50         unsigned int openmin:1,
  51                      openmax:1,
  52                      integer:1,
  53                      empty:1;
  54 };
  55
  56 struct sndrv_pcm_hw_params32 {
  57         u32 flags;
  58         struct sndrv_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; /* this must be identical */
  59         struct sndrv_mask mres[5];      /* reserved masks */
  60         struct sndrv_interval32 intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
  61         struct sndrv_interval ires[9];  /* reserved intervals */
  62         u32 rmask;
  63         u32 cmask;
  64         u32 info;
  65         u32 msbits;
  66         u32 rate_num;
  67         u32 rate_den;
  68         u32 fifo_size;
  69         unsigned char reserved[64];
  70 } __attribute__((packed));
  71
  72 #define numberof(array) ARRAY_SIZE(array)
  73
  74 #define CVT_sndrv_pcm_hw_params()\
  75 {\
  76         unsigned int i;\
  77         COPY(flags);\
  78         for (i = 0; i < numberof(dst->masks); i++)\
  79                 COPY(masks[i]);\
  80         for (i = 0; i < numberof(dst->intervals); i++) {\
  81                 COPY(intervals[i].min);\
  82                 COPY(intervals[i].max);\
  83                 COPY(intervals[i].openmin);\
  84                 COPY(intervals[i].openmax);\
  85                 COPY(intervals[i].integer);\
  86                 COPY(intervals[i].empty);\
  87         }\
  88         COPY(rmask);\
  89         COPY(cmask);\
  90         COPY(info);\
  91         COPY(msbits);\
  92         COPY(rate_num);\
  93         COPY(rate_den);\
  94         COPY(fifo_size);\
  95 }
  96
  97 struct sndrv_pcm_sw_params32 {
  98         s32 tstamp_mode;
  99         u32 period_step;
 100         u32 sleep_min;
 101         u32 avail_min;
 102         u32 xfer_align;
 103         u32 start_threshold;
 104         u32 stop_threshold;
 105         u32 silence_threshold;
 106         u32 silence_size;
 107         u32 boundary;
 108         unsigned char reserved[64];
 109 } __attribute__((packed));
 110
 111 #define CVT_sndrv_pcm_sw_params()\
 112 {\
 113         COPY(tstamp_mode);\
 114         COPY(period_step);\
 115         COPY(sleep_min);\
 116         COPY(avail_min);\
 117         COPY(xfer_align);\
 118         COPY(start_threshold);\
 119         COPY(stop_threshold);\
 120         COPY(silence_threshold);\
 121         COPY(silence_size);\
 122         COPY(boundary);\
 123 }
 124
 125 struct sndrv_pcm_channel_info32 {
 126         u32 channel;
 127         u32 offset;
 128         u32 first;
 129         u32 step;
 130 } __attribute__((packed));
 131
 132 #define CVT_sndrv_pcm_channel_info()\
 133 {\
 134         COPY(channel);\
 135         COPY(offset);\
 136         COPY(first);\
 137         COPY(step);\
 138 }
 139
 140 struct sndrv_pcm_status32 {
 141         s32 state;
 142         struct compat_timespec trigger_tstamp;
 143         struct compat_timespec tstamp;
 144         u32 appl_ptr;
 145         u32 hw_ptr;
 146         s32 delay;
 147         u32 avail;
 148         u32 avail_max;
 149         u32 overrange;
 150         s32 suspended_state;
 151         unsigned char reserved[60];
 152 } __attribute__((packed));
 153
 154 #define CVT_sndrv_pcm_status()\
 155 {\
 156         COPY(state);\
 157         COPY(trigger_tstamp.tv_sec);\
 158         COPY(trigger_tstamp.tv_nsec);\
 159         COPY(tstamp.tv_sec);\
 160         COPY(tstamp.tv_nsec);\
 161         COPY(appl_ptr);\
 162         COPY(hw_ptr);\
 163         COPY(delay);\
 164         COPY(avail);\
 165         COPY(avail_max);\
 166         COPY(overrange);\
 167         COPY(suspended_state);\
 168 }
 169
 170 DEFINE_ALSA_IOCTL(pcm_uframes_str);
 171 DEFINE_ALSA_IOCTL(pcm_sframes_str);
 172 DEFINE_ALSA_IOCTL_BIG(pcm_hw_params);
 173 DEFINE_ALSA_IOCTL(pcm_sw_params);
 174 DEFINE_ALSA_IOCTL(pcm_channel_info);
 175 DEFINE_ALSA_IOCTL(pcm_status);
 176
 177 /*
 178  */
 179 struct sndrv_xferi32 {
 180         s32 result;
 181         u32 buf;
 182         u32 frames;
 183 } __attribute__((packed));
 184
 185 static int _snd_ioctl32_xferi(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file, unsigned int native_ctl)
 186 {
 187         struct sndrv_xferi32 data32;
 188         struct sndrv_xferi data;
 189         mm_segment_t oldseg;
 190         int err;
 191
 192         if (copy_from_user(&data32, (void __user *)arg, sizeof(data32)))
 193                 return -EFAULT;
 194         memset(&data, 0, sizeof(data));
 195         data.result = data32.result;
 196         data.buf = compat_ptr(data32.buf);
 197         data.frames = data32.frames;
 198         oldseg = get_fs();
 199         set_fs(KERNEL_DS);
 200         err = file->f_op->ioctl(file->f_dentry->d_inode, file, native_ctl, (unsigned long)&data);
 201         set_fs(oldseg);
 202         if (err < 0)
 203                 return err;
 204         /* copy the result */
 205         data32.result = data.result;
 206         if (copy_to_user((void __user *)arg, &data32, sizeof(data32)))
 207                 return -EFAULT;
 208         return 0;
 209 }
 210
 211
 212 /* snd_xfern needs remapping of bufs */
 213 struct sndrv_xfern32 {
 214         s32 result;
 215         u32 bufs;  /* this is void **; */
 216         u32 frames;
 217 } __attribute__((packed));
 218
 219 /*
 220  * xfern ioctl nees to copy (up to) 128 pointers on stack.
 221  * although we may pass the copied pointers through f_op->ioctl, but the ioctl
 222  * handler there expands again the same 128 pointers on stack, so it is better
 223  * to handle the function (calling pcm_readv/writev) directly in this handler.
 224  */
 225 static int _snd_ioctl32_xfern(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file, unsigned int native_ctl)
 226 {
 227         snd_pcm_file_t *pcm_file;
 228         snd_pcm_substream_t *substream;
 229         struct sndrv_xfern32 data32;
 230         struct sndrv_xfern32 __user *srcptr = (void __user *)arg;
 231         void __user **bufs = NULL;
 232         int err = 0, ch, i;
 233         u32 __user *bufptr;
 234         mm_segment_t oldseg;
 235
 236         /* FIXME: need to check whether fop->ioctl is sane */
 237
 238         pcm_file = file->private_data;
 239         substream = pcm_file->substream;
 240         snd_assert(substream != NULL && substream->runtime, return -ENXIO);
 241
 242         /* check validty of the command */
 243         switch (native_ctl) {
 244         case SNDRV_PCM_IOCTL_WRITEN_FRAMES:
 245                 if (substream->stream  != SNDRV_PCM_STREAM_PLAYBACK)
 246                         return -EINVAL;
 247                 if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN)
 248                         return -EBADFD;
 249                 break;
 250         case SNDRV_PCM_IOCTL_READN_FRAMES:
 251                 if (substream->stream  != SNDRV_PCM_STREAM_CAPTURE)
 252                         return -EINVAL;
 253                 break;
 254         }
 255         if ((ch = substream->runtime->channels) > 128)
 256                 return -EINVAL;
 257         if (get_user(data32.frames, &srcptr->frames))
 258                 return -EFAULT;
 259         __get_user(data32.bufs, &srcptr->bufs);
 260         bufptr = compat_ptr(data32.bufs);
 261         bufs = kmalloc(sizeof(void *) * 128, GFP_KERNEL);
 262         if (bufs == NULL)
 263                 return -ENOMEM;
 264         for (i = 0; i < ch; i++) {
 265                 u32 ptr;
 266                 if (get_user(ptr, bufptr))
 267                         return -EFAULT;
 268                 bufs[ch] = compat_ptr(ptr);
 269                 bufptr++;
 270         }
 271         oldseg = get_fs();
 272         set_fs(KERNEL_DS);
 273         switch (native_ctl) {
 274         case SNDRV_PCM_IOCTL_WRITEN_FRAMES:
 275                 err = snd_pcm_lib_writev(substream, bufs, data32.frames);
 276                 break;
 277         case SNDRV_PCM_IOCTL_READN_FRAMES:
 278                 err = snd_pcm_lib_readv(substream, bufs, data32.frames);
 279                 break;
 280         }
 281         set_fs(oldseg);
 282         if (err >= 0) {
 283                 if (put_user(err, &srcptr->result))
 284                         err = -EFAULT;
 285         }
 286         kfree(bufs);
 287         return 0;
 288 }
 289
 290
 291 struct sndrv_pcm_hw_params_old32 {
 292         u32 flags;
 293         u32 masks[SNDRV_PCM_HW_PARAM_SUBFORMAT -
 294                            SNDRV_PCM_HW_PARAM_ACCESS + 1];
 295         struct sndrv_interval32 intervals[SNDRV_PCM_HW_PARAM_TICK_TIME -
 296                                         SNDRV_PCM_HW_PARAM_SAMPLE_BITS + 1];
 297         u32 rmask;
 298         u32 cmask;
 299         u32 info;
 300         u32 msbits;
 301         u32 rate_num;
 302         u32 rate_den;
 303         u32 fifo_size;
 304         unsigned char reserved[64];
 305 } __attribute__((packed));
 306
 307 #define __OLD_TO_NEW_MASK(x) ((x&7)|((x&0x07fffff8)<<5))
 308 #define __NEW_TO_OLD_MASK(x) ((x&7)|((x&0xffffff00)>>5))
 309
 310 static void snd_pcm_hw_convert_from_old_params(snd_pcm_hw_params_t *params, struct sndrv_pcm_hw_params_old32 *oparams)
 311 {
 312         unsigned int i;
 313
 314         memset(params, 0, sizeof(*params));
 315         params->flags = oparams->flags;
 316         for (i = 0; i < ARRAY_SIZE(oparams->masks); i++)
 317                 params->masks[i].bits[0] = oparams->masks[i];
 318         memcpy(params->intervals, oparams->intervals, sizeof(oparams->intervals));
 319         params->rmask = __OLD_TO_NEW_MASK(oparams->rmask);
 320         params->cmask = __OLD_TO_NEW_MASK(oparams->cmask);
 321         params->info = oparams->info;
 322         params->msbits = oparams->msbits;
 323         params->rate_num = oparams->rate_num;
 324         params->rate_den = oparams->rate_den;
 325         params->fifo_size = oparams->fifo_size;
 326 }
 327
 328 static void snd_pcm_hw_convert_to_old_params(struct sndrv_pcm_hw_params_old32 *oparams, snd_pcm_hw_params_t *params)
 329 {
 330         unsigned int i;
 331
 332         memset(oparams, 0, sizeof(*oparams));
 333         oparams->flags = params->flags;
 334         for (i = 0; i < ARRAY_SIZE(oparams->masks); i++)
 335                 oparams->masks[i] = params->masks[i].bits[0];
 336         memcpy(oparams->intervals, params->intervals, sizeof(oparams->intervals));
 337         oparams->rmask = __NEW_TO_OLD_MASK(params->rmask);
 338         oparams->cmask = __NEW_TO_OLD_MASK(params->cmask);
 339         oparams->info = params->info;
 340         oparams->msbits = params->msbits;
 341         oparams->rate_num = params->rate_num;
 342         oparams->rate_den = params->rate_den;
 343         oparams->fifo_size = params->fifo_size;
 344 }
 345
 346 static int _snd_ioctl32_pcm_hw_params_old(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file, unsigned int native_ctl)
 347 {
 348         struct sndrv_pcm_hw_params_old32 *data32;
 349         struct sndrv_pcm_hw_params *data;
 350         mm_segment_t oldseg;
 351         int err;
 352
 353         data32 = kcalloc(1, sizeof(*data32), GFP_KERNEL);
 354         data = kcalloc(1, sizeof(*data), GFP_KERNEL);
 355         if (data32 == NULL || data == NULL) {
 356                 err = -ENOMEM;
 357                 goto __end;
 358         }
 359         if (copy_from_user(data32, (void __user *)arg, sizeof(*data32))) {
 360                 err = -EFAULT;
 361                 goto __end;
 362         }
 363         snd_pcm_hw_convert_from_old_params(data, data32);
 364         oldseg = get_fs();
 365         set_fs(KERNEL_DS);
 366         err = file->f_op->ioctl(file->f_dentry->d_inode, file, native_ctl, (unsigned long)data);
 367         set_fs(oldseg);
 368         if (err < 0)
 369                 goto __end;
 370         snd_pcm_hw_convert_to_old_params(data32, data);
 371         err = 0;
 372         if (copy_to_user((void __user *)arg, data32, sizeof(*data32)))
 373                 err = -EFAULT;
 374       __end:
 375         if (data)
 376                 kfree(data);
 377         if (data32)
 378                 kfree(data32);
 379         return err;
 380 }
 381
 382 struct sndrv_pcm_mmap_status32 {
 383         s32 state;
 384         s32 pad1;
 385         u32 hw_ptr;
 386         struct compat_timespec tstamp;
 387         s32 suspended_state;
 388 } __attribute__((packed));
 389
 390 struct sndrv_pcm_mmap_control32 {
 391         u32 appl_ptr;
 392         u32 avail_min;
 393 } __attribute__((packed));
 394
 395 struct sndrv_pcm_sync_ptr32 {
 396         u32 flags;
 397         union {
 398                 struct sndrv_pcm_mmap_status32 status;
 399                 unsigned char reserved[64];
 400         } s;
 401         union {
 402                 struct sndrv_pcm_mmap_control32 control;
 403                 unsigned char reserved[64];
 404         } c;
 405 } __attribute__((packed));
 406
 407 #define CVT_sndrv_pcm_sync_ptr()\
 408 {\
 409         COPY(flags);\
 410         COPY(s.status.state);\
 411         COPY(s.status.pad1);\
 412         COPY(s.status.hw_ptr);\
 413         COPY(s.status.tstamp.tv_sec);\
 414         COPY(s.status.tstamp.tv_nsec);\
 415         COPY(s.status.suspended_state);\
 416         COPY(c.control.appl_ptr);\
 417         COPY(c.control.avail_min);\
 418 }
 419
 420 DEFINE_ALSA_IOCTL_BIG(pcm_sync_ptr);
 421
 422 /*
 423  */
 424
 425 DEFINE_ALSA_IOCTL_ENTRY(pcm_hw_refine, pcm_hw_params, SNDRV_PCM_IOCTL_HW_REFINE);
 426 DEFINE_ALSA_IOCTL_ENTRY(pcm_hw_params, pcm_hw_params, SNDRV_PCM_IOCTL_HW_PARAMS);
 427 DEFINE_ALSA_IOCTL_ENTRY(pcm_sw_params, pcm_sw_params, SNDRV_PCM_IOCTL_SW_PARAMS);
 428 DEFINE_ALSA_IOCTL_ENTRY(pcm_hw_refine_old, pcm_hw_params_old, SNDRV_PCM_IOCTL_HW_REFINE);
 429 DEFINE_ALSA_IOCTL_ENTRY(pcm_hw_params_old, pcm_hw_params_old, SNDRV_PCM_IOCTL_HW_PARAMS);
 430 DEFINE_ALSA_IOCTL_ENTRY(pcm_status, pcm_status, SNDRV_PCM_IOCTL_STATUS);
 431 DEFINE_ALSA_IOCTL_ENTRY(pcm_delay, pcm_sframes_str, SNDRV_PCM_IOCTL_DELAY);
 432 DEFINE_ALSA_IOCTL_ENTRY(pcm_channel_info, pcm_channel_info, SNDRV_PCM_IOCTL_CHANNEL_INFO);
 433 DEFINE_ALSA_IOCTL_ENTRY(pcm_rewind, pcm_uframes_str, SNDRV_PCM_IOCTL_REWIND);
 434 DEFINE_ALSA_IOCTL_ENTRY(pcm_readi, xferi, SNDRV_PCM_IOCTL_READI_FRAMES);
 435 DEFINE_ALSA_IOCTL_ENTRY(pcm_writei, xferi, SNDRV_PCM_IOCTL_WRITEI_FRAMES);
 436 DEFINE_ALSA_IOCTL_ENTRY(pcm_readn, xfern, SNDRV_PCM_IOCTL_READN_FRAMES);
 437 DEFINE_ALSA_IOCTL_ENTRY(pcm_writen, xfern, SNDRV_PCM_IOCTL_WRITEN_FRAMES);
 438 DEFINE_ALSA_IOCTL_ENTRY(pcm_sync_ptr, pcm_sync_ptr, SNDRV_PCM_IOCTL_SYNC_PTR);
 439
 440
 441 /*
 442  */
 443 #define AP(x) snd_ioctl32_##x
 444
 445 enum {
 446         SNDRV_PCM_IOCTL_HW_REFINE32 = _IOWR('A', 0x10, struct sndrv_pcm_hw_params32),
 447         SNDRV_PCM_IOCTL_HW_PARAMS32 = _IOWR('A', 0x11, struct sndrv_pcm_hw_params32),
 448         SNDRV_PCM_IOCTL_SW_PARAMS32 = _IOWR('A', 0x13, struct sndrv_pcm_sw_params32),
 449         SNDRV_PCM_IOCTL_STATUS32 = _IOR('A', 0x20, struct sndrv_pcm_status32),
 450         SNDRV_PCM_IOCTL_DELAY32 = _IOR('A', 0x21, s32),
 451         SNDRV_PCM_IOCTL_CHANNEL_INFO32 = _IOR('A', 0x32, struct sndrv_pcm_channel_info32),
 452         SNDRV_PCM_IOCTL_REWIND32 = _IOW('A', 0x46, u32),
 453         SNDRV_PCM_IOCTL_WRITEI_FRAMES32 = _IOW('A', 0x50, struct sndrv_xferi32),
 454         SNDRV_PCM_IOCTL_READI_FRAMES32 = _IOR('A', 0x51, struct sndrv_xferi32),
 455         SNDRV_PCM_IOCTL_WRITEN_FRAMES32 = _IOW('A', 0x52, struct sndrv_xfern32),
 456         SNDRV_PCM_IOCTL_READN_FRAMES32 = _IOR('A', 0x53, struct sndrv_xfern32),
 457         SNDRV_PCM_IOCTL_HW_REFINE_OLD32 = _IOWR('A', 0x10, struct sndrv_pcm_hw_params_old32),
 458         SNDRV_PCM_IOCTL_HW_PARAMS_OLD32 = _IOWR('A', 0x11, struct sndrv_pcm_hw_params_old32),
 459         SNDRV_PCM_IOCTL_SYNC_PTR32 = _IOWR('A', 0x23, struct sndrv_pcm_sync_ptr),
 460
 461 };
 462
 463 struct ioctl32_mapper pcm_mappers[] = {
 464         MAP_COMPAT(SNDRV_PCM_IOCTL_PVERSION),
 465         MAP_COMPAT(SNDRV_PCM_IOCTL_INFO),
 466         MAP_COMPAT(SNDRV_PCM_IOCTL_TSTAMP),
 467         { SNDRV_PCM_IOCTL_HW_REFINE32, AP(pcm_hw_refine) },
 468         { SNDRV_PCM_IOCTL_HW_PARAMS32, AP(pcm_hw_params) },
 469         { SNDRV_PCM_IOCTL_HW_REFINE_OLD32, AP(pcm_hw_refine_old) },
 470         { SNDRV_PCM_IOCTL_HW_PARAMS_OLD32, AP(pcm_hw_params_old) },
 471         MAP_COMPAT(SNDRV_PCM_IOCTL_HW_FREE),
 472         { SNDRV_PCM_IOCTL_SW_PARAMS32, AP(pcm_sw_params) },
 473         { SNDRV_PCM_IOCTL_STATUS32, AP(pcm_status) },
 474         { SNDRV_PCM_IOCTL_DELAY32, AP(pcm_delay) },
 475         MAP_COMPAT(SNDRV_PCM_IOCTL_HWSYNC),
 476         { SNDRV_PCM_IOCTL_SYNC_PTR32, AP(pcm_sync_ptr) },
 477         { SNDRV_PCM_IOCTL_CHANNEL_INFO32, AP(pcm_channel_info) },
 478         MAP_COMPAT(SNDRV_PCM_IOCTL_PREPARE),
 479         MAP_COMPAT(SNDRV_PCM_IOCTL_RESET),
 480         MAP_COMPAT(SNDRV_PCM_IOCTL_START),
 481         MAP_COMPAT(SNDRV_PCM_IOCTL_DROP),
 482         MAP_COMPAT(SNDRV_PCM_IOCTL_DRAIN),
 483         MAP_COMPAT(SNDRV_PCM_IOCTL_PAUSE),
 484         { SNDRV_PCM_IOCTL_REWIND32, AP(pcm_rewind) },
 485         MAP_COMPAT(SNDRV_PCM_IOCTL_RESUME),
 486         MAP_COMPAT(SNDRV_PCM_IOCTL_XRUN),
 487         { SNDRV_PCM_IOCTL_WRITEI_FRAMES32, AP(pcm_writei) },
 488         { SNDRV_PCM_IOCTL_READI_FRAMES32, AP(pcm_readi) },
 489         { SNDRV_PCM_IOCTL_WRITEN_FRAMES32, AP(pcm_writen) },
 490         { SNDRV_PCM_IOCTL_READN_FRAMES32, AP(pcm_readn) },
 491         MAP_COMPAT(SNDRV_PCM_IOCTL_LINK),
 492         MAP_COMPAT(SNDRV_PCM_IOCTL_UNLINK),
 493
 494         { 0 },
 495 };