1/* 2 * compat ioctls for control API 3 * 4 * Copyright (c) by Takashi Iwai <tiwai@suse.de> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 */ 20 21/* this file included from control.c */ 22 23#include <linux/compat.h> 24#include <linux/slab.h> 25 26struct snd_ctl_elem_list32 { 27 u32 offset; 28 u32 space; 29 u32 used; 30 u32 count; 31 u32 pids; 32 unsigned char reserved[50]; 33} /* don't set packed attribute here */; 34 35static int snd_ctl_elem_list_compat(struct snd_card *card, 36 struct snd_ctl_elem_list32 __user *data32) 37{ 38 struct snd_ctl_elem_list __user *data; 39 compat_caddr_t ptr; 40 int err; 41 42 data = compat_alloc_user_space(sizeof(*data)); 43 44 /* offset, space, used, count */ 45 if (copy_in_user(data, data32, 4 * sizeof(u32))) 46 return -EFAULT; 47 /* pids */ 48 if (get_user(ptr, &data32->pids) || 49 put_user(compat_ptr(ptr), &data->pids)) 50 return -EFAULT; 51 err = snd_ctl_elem_list(card, data); 52 if (err < 0) 53 return err; 54 /* copy the result */ 55 if (copy_in_user(data32, data, 4 * sizeof(u32))) 56 return -EFAULT; 57 return 0; 58} 59 60/* 61 * control element info 62 * it uses union, so the things are not easy.. 63 */ 64 65struct snd_ctl_elem_info32 { 66 struct snd_ctl_elem_id id; // the size of struct is same 67 s32 type; 68 u32 access; 69 u32 count; 70 s32 owner; 71 union { 72 struct { 73 s32 min; 74 s32 max; 75 s32 step; 76 } integer; 77 struct { 78 u64 min; 79 u64 max; 80 u64 step; 81 } integer64; 82 struct { 83 u32 items; 84 u32 item; 85 char name[64]; 86 } enumerated; 87 unsigned char reserved[128]; 88 } value; 89 unsigned char reserved[64]; 90} __attribute__((packed)); 91 92static int snd_ctl_elem_info_compat(struct snd_ctl_file *ctl, 93 struct snd_ctl_elem_info32 __user *data32) 94{ 95 struct snd_ctl_elem_info *data; 96 int err; 97 98 data = kzalloc(sizeof(*data), GFP_KERNEL); 99 if (! data) 100 return -ENOMEM; 101 102 err = -EFAULT; 103 /* copy id */ 104 if (copy_from_user(&data->id, &data32->id, sizeof(data->id))) 105 goto error; 106 /* we need to copy the item index. 107 * hope this doesn't break anything.. 108 */ 109 if (get_user(data->value.enumerated.item, &data32->value.enumerated.item)) 110 goto error; 111 112 snd_power_lock(ctl->card); 113 err = snd_power_wait(ctl->card, SNDRV_CTL_POWER_D0); 114 if (err >= 0) 115 err = snd_ctl_elem_info(ctl, data); 116 snd_power_unlock(ctl->card); 117 118 if (err < 0) 119 goto error; 120 /* restore info to 32bit */ 121 err = -EFAULT; 122 /* id, type, access, count */ 123 if (copy_to_user(&data32->id, &data->id, sizeof(data->id)) || 124 copy_to_user(&data32->type, &data->type, 3 * sizeof(u32))) 125 goto error; 126 if (put_user(data->owner, &data32->owner)) 127 goto error; 128 switch (data->type) { 129 case SNDRV_CTL_ELEM_TYPE_BOOLEAN: 130 case SNDRV_CTL_ELEM_TYPE_INTEGER: 131 if (put_user(data->value.integer.min, &data32->value.integer.min) || 132 put_user(data->value.integer.max, &data32->value.integer.max) || 133 put_user(data->value.integer.step, &data32->value.integer.step)) 134 goto error; 135 break; 136 case SNDRV_CTL_ELEM_TYPE_INTEGER64: 137 if (copy_to_user(&data32->value.integer64, 138 &data->value.integer64, 139 sizeof(data->value.integer64))) 140 goto error; 141 break; 142 case SNDRV_CTL_ELEM_TYPE_ENUMERATED: 143 if (copy_to_user(&data32->value.enumerated, 144 &data->value.enumerated, 145 sizeof(data->value.enumerated))) 146 goto error; 147 break; 148 default: 149 break; 150 } 151 err = 0; 152 error: 153 kfree(data); 154 return err; 155} 156 157/* read / write */ 158struct snd_ctl_elem_value32 { 159 struct snd_ctl_elem_id id; 160 unsigned int indirect; /* bit-field causes misalignment */ 161 union { 162 s32 integer[128]; 163 unsigned char data[512]; 164#ifndef CONFIG_X86_64 165 s64 integer64[64]; 166#endif 167 } value; 168 unsigned char reserved[128]; 169}; 170 171 172/* get the value type and count of the control */ 173static int get_ctl_type(struct snd_card *card, struct snd_ctl_elem_id *id, 174 int *countp) 175{ 176 struct snd_kcontrol *kctl; 177 struct snd_ctl_elem_info *info; 178 int err; 179 180 down_read(&card->controls_rwsem); 181 kctl = snd_ctl_find_id(card, id); 182 if (! kctl) { 183 up_read(&card->controls_rwsem); 184 return -ENXIO; 185 } 186 info = kzalloc(sizeof(*info), GFP_KERNEL); 187 if (info == NULL) { 188 up_read(&card->controls_rwsem); 189 return -ENOMEM; 190 } 191 info->id = *id; 192 err = kctl->info(kctl, info); 193 up_read(&card->controls_rwsem); 194 if (err >= 0) { 195 err = info->type; 196 *countp = info->count; 197 } 198 kfree(info); 199 return err; 200} 201 202static int get_elem_size(int type, int count) 203{ 204 switch (type) { 205 case SNDRV_CTL_ELEM_TYPE_INTEGER64: 206 return sizeof(s64) * count; 207 case SNDRV_CTL_ELEM_TYPE_ENUMERATED: 208 return sizeof(int) * count; 209 case SNDRV_CTL_ELEM_TYPE_BYTES: 210 return 512; 211 case SNDRV_CTL_ELEM_TYPE_IEC958: 212 return sizeof(struct snd_aes_iec958); 213 default: 214 return -1; 215 } 216} 217 218static int copy_ctl_value_from_user(struct snd_card *card, 219 struct snd_ctl_elem_value *data, 220 struct snd_ctl_elem_value32 __user *data32, 221 int *typep, int *countp) 222{ 223 int i, type, size; 224 int uninitialized_var(count); 225 unsigned int indirect; 226 227 if (copy_from_user(&data->id, &data32->id, sizeof(data->id))) 228 return -EFAULT; 229 if (get_user(indirect, &data32->indirect)) 230 return -EFAULT; 231 if (indirect) 232 return -EINVAL; 233 type = get_ctl_type(card, &data->id, &count); 234 if (type < 0) 235 return type; 236 237 if (type == SNDRV_CTL_ELEM_TYPE_BOOLEAN || 238 type == SNDRV_CTL_ELEM_TYPE_INTEGER) { 239 for (i = 0; i < count; i++) { 240 int val; 241 if (get_user(val, &data32->value.integer[i])) 242 return -EFAULT; 243 data->value.integer.value[i] = val; 244 } 245 } else { 246 size = get_elem_size(type, count); 247 if (size < 0) { 248 printk(KERN_ERR "snd_ioctl32_ctl_elem_value: unknown type %d\n", type); 249 return -EINVAL; 250 } 251 if (copy_from_user(data->value.bytes.data, 252 data32->value.data, size)) 253 return -EFAULT; 254 } 255 256 *typep = type; 257 *countp = count; 258 return 0; 259} 260 261/* restore the value to 32bit */ 262static int copy_ctl_value_to_user(struct snd_ctl_elem_value32 __user *data32, 263 struct snd_ctl_elem_value *data, 264 int type, int count) 265{ 266 int i, size; 267 268 if (type == SNDRV_CTL_ELEM_TYPE_BOOLEAN || 269 type == SNDRV_CTL_ELEM_TYPE_INTEGER) { 270 for (i = 0; i < count; i++) { 271 int val; 272 val = data->value.integer.value[i]; 273 if (put_user(val, &data32->value.integer[i])) 274 return -EFAULT; 275 } 276 } else { 277 size = get_elem_size(type, count); 278 if (copy_to_user(data32->value.data, 279 data->value.bytes.data, size)) 280 return -EFAULT; 281 } 282 return 0; 283} 284 285static int snd_ctl_elem_read_user_compat(struct snd_card *card, 286 struct snd_ctl_elem_value32 __user *data32) 287{ 288 struct snd_ctl_elem_value *data; 289 int err, type, count; 290 291 data = kzalloc(sizeof(*data), GFP_KERNEL); 292 if (data == NULL) 293 return -ENOMEM; 294 295 if ((err = copy_ctl_value_from_user(card, data, data32, &type, &count)) < 0) 296 goto error; 297 298 snd_power_lock(card); 299 err = snd_power_wait(card, SNDRV_CTL_POWER_D0); 300 if (err >= 0) 301 err = snd_ctl_elem_read(card, data); 302 snd_power_unlock(card); 303 if (err >= 0) 304 err = copy_ctl_value_to_user(data32, data, type, count); 305 error: 306 kfree(data); 307 return err; 308} 309 310static int snd_ctl_elem_write_user_compat(struct snd_ctl_file *file, 311 struct snd_ctl_elem_value32 __user *data32) 312{ 313 struct snd_ctl_elem_value *data; 314 struct snd_card *card = file->card; 315 int err, type, count; 316 317 data = kzalloc(sizeof(*data), GFP_KERNEL); 318 if (data == NULL) 319 return -ENOMEM; 320 321 if ((err = copy_ctl_value_from_user(card, data, data32, &type, &count)) < 0) 322 goto error; 323 324 snd_power_lock(card); 325 err = snd_power_wait(card, SNDRV_CTL_POWER_D0); 326 if (err >= 0) 327 err = snd_ctl_elem_write(card, file, data); 328 snd_power_unlock(card); 329 if (err >= 0) 330 err = copy_ctl_value_to_user(data32, data, type, count); 331 error: 332 kfree(data); 333 return err; 334} 335 336/* add or replace a user control */ 337static int snd_ctl_elem_add_compat(struct snd_ctl_file *file, 338 struct snd_ctl_elem_info32 __user *data32, 339 int replace) 340{ 341 struct snd_ctl_elem_info *data; 342 int err; 343 344 data = kzalloc(sizeof(*data), GFP_KERNEL); 345 if (! data) 346 return -ENOMEM; 347 348 err = -EFAULT; 349 /* id, type, access, count */ \ 350 if (copy_from_user(&data->id, &data32->id, sizeof(data->id)) || 351 copy_from_user(&data->type, &data32->type, 3 * sizeof(u32))) 352 goto error; 353 if (get_user(data->owner, &data32->owner) || 354 get_user(data->type, &data32->type)) 355 goto error; 356 switch (data->type) { 357 case SNDRV_CTL_ELEM_TYPE_BOOLEAN: 358 case SNDRV_CTL_ELEM_TYPE_INTEGER: 359 if (get_user(data->value.integer.min, &data32->value.integer.min) || 360 get_user(data->value.integer.max, &data32->value.integer.max) || 361 get_user(data->value.integer.step, &data32->value.integer.step)) 362 goto error; 363 break; 364 case SNDRV_CTL_ELEM_TYPE_INTEGER64: 365 if (copy_from_user(&data->value.integer64, 366 &data32->value.integer64, 367 sizeof(data->value.integer64))) 368 goto error; 369 break; 370 case SNDRV_CTL_ELEM_TYPE_ENUMERATED: 371 if (copy_from_user(&data->value.enumerated, 372 &data32->value.enumerated, 373 sizeof(data->value.enumerated))) 374 goto error; 375 break; 376 default: 377 break; 378 } 379 err = snd_ctl_elem_add(file, data, replace); 380 error: 381 kfree(data); 382 return err; 383} 384 385enum { 386 SNDRV_CTL_IOCTL_ELEM_LIST32 = _IOWR('U', 0x10, struct snd_ctl_elem_list32), 387 SNDRV_CTL_IOCTL_ELEM_INFO32 = _IOWR('U', 0x11, struct snd_ctl_elem_info32), 388 SNDRV_CTL_IOCTL_ELEM_READ32 = _IOWR('U', 0x12, struct snd_ctl_elem_value32), 389 SNDRV_CTL_IOCTL_ELEM_WRITE32 = _IOWR('U', 0x13, struct snd_ctl_elem_value32), 390 SNDRV_CTL_IOCTL_ELEM_ADD32 = _IOWR('U', 0x17, struct snd_ctl_elem_info32), 391 SNDRV_CTL_IOCTL_ELEM_REPLACE32 = _IOWR('U', 0x18, struct snd_ctl_elem_info32), 392}; 393 394static inline long snd_ctl_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg) 395{ 396 struct snd_ctl_file *ctl; 397 struct snd_kctl_ioctl *p; 398 void __user *argp = compat_ptr(arg); 399 int err; 400 401 ctl = file->private_data; 402 if (snd_BUG_ON(!ctl || !ctl->card)) 403 return -ENXIO; 404 405 switch (cmd) { 406 case SNDRV_CTL_IOCTL_PVERSION: 407 case SNDRV_CTL_IOCTL_CARD_INFO: 408 case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS: 409 case SNDRV_CTL_IOCTL_POWER: 410 case SNDRV_CTL_IOCTL_POWER_STATE: 411 case SNDRV_CTL_IOCTL_ELEM_LOCK: 412 case SNDRV_CTL_IOCTL_ELEM_UNLOCK: 413 case SNDRV_CTL_IOCTL_ELEM_REMOVE: 414 case SNDRV_CTL_IOCTL_TLV_READ: 415 case SNDRV_CTL_IOCTL_TLV_WRITE: 416 case SNDRV_CTL_IOCTL_TLV_COMMAND: 417 return snd_ctl_ioctl(file, cmd, (unsigned long)argp); 418 case SNDRV_CTL_IOCTL_ELEM_LIST32: 419 return snd_ctl_elem_list_compat(ctl->card, argp); 420 case SNDRV_CTL_IOCTL_ELEM_INFO32: 421 return snd_ctl_elem_info_compat(ctl, argp); 422 case SNDRV_CTL_IOCTL_ELEM_READ32: 423 return snd_ctl_elem_read_user_compat(ctl->card, argp); 424 case SNDRV_CTL_IOCTL_ELEM_WRITE32: 425 return snd_ctl_elem_write_user_compat(ctl, argp); 426 case SNDRV_CTL_IOCTL_ELEM_ADD32: 427 return snd_ctl_elem_add_compat(ctl, argp, 0); 428 case SNDRV_CTL_IOCTL_ELEM_REPLACE32: 429 return snd_ctl_elem_add_compat(ctl, argp, 1); 430 } 431 432 down_read(&snd_ioctl_rwsem); 433 list_for_each_entry(p, &snd_control_compat_ioctls, list) { 434 if (p->fioctl) { 435 err = p->fioctl(ctl->card, ctl, cmd, arg); 436 if (err != -ENOIOCTLCMD) { 437 up_read(&snd_ioctl_rwsem); 438 return err; 439 } 440 } 441 } 442 up_read(&snd_ioctl_rwsem); 443 return -ENOIOCTLCMD; 444} 445