sound/core/control.c

   1 /*
   2  *  Routines for driver control interface
   3  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   4  *
   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
  22 #include <linux/threads.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/slab.h>
  25 #include <linux/vmalloc.h>
  26 #include <linux/time.h>
  27 #include <sound/core.h>
  28 #include <sound/minors.h>
  29 #include <sound/info.h>
  30 #include <sound/control.h>
  31
  32 /* max number of user-defined controls */
  33 #define MAX_USER_CONTROLS       32
  34
  35 struct snd_kctl_ioctl {
  36         struct list_head list;          /* list of all ioctls */
  37         snd_kctl_ioctl_func_t fioctl;
  38 };
  39
  40 static DECLARE_RWSEM(snd_ioctl_rwsem);
  41 static LIST_HEAD(snd_control_ioctls);
  42 #ifdef CONFIG_COMPAT
  43 static LIST_HEAD(snd_control_compat_ioctls);
  44 #endif
  45
  46 static int snd_ctl_open(struct inode *inode, struct file *file)
  47 {
  48         unsigned long flags;
  49         struct snd_card *card;
  50         struct snd_ctl_file *ctl;
  51         int err;
  52
  53         err = nonseekable_open(inode, file);
  54         if (err < 0)
  55                 return err;
  56
  57         card = snd_lookup_minor_data(iminor(inode), SNDRV_DEVICE_TYPE_CONTROL);
  58         if (!card) {
  59                 err = -ENODEV;
  60                 goto __error1;
  61         }
  62         err = snd_card_file_add(card, file);
  63         if (err < 0) {
  64                 err = -ENODEV;
  65                 goto __error1;
  66         }
  67         if (!try_module_get(card->module)) {
  68                 err = -EFAULT;
  69                 goto __error2;
  70         }
  71         ctl = kzalloc(sizeof(*ctl), GFP_KERNEL);
  72         if (ctl == NULL) {
  73                 err = -ENOMEM;
  74                 goto __error;
  75         }
  76         INIT_LIST_HEAD(&ctl->events);
  77         init_waitqueue_head(&ctl->change_sleep);
  78         spin_lock_init(&ctl->read_lock);
  79         ctl->card = card;
  80         ctl->prefer_pcm_subdevice = -1;
  81         ctl->prefer_rawmidi_subdevice = -1;
  82         ctl->pid = get_pid(task_pid(current));
  83         file->private_data = ctl;
  84         write_lock_irqsave(&card->ctl_files_rwlock, flags);
  85         list_add_tail(&ctl->list, &card->ctl_files);
  86         write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
  87         return 0;
  88
  89       __error:
  90         module_put(card->module);
  91       __error2:
  92         snd_card_file_remove(card, file);
  93       __error1:
  94         return err;
  95 }
  96
  97 static void snd_ctl_empty_read_queue(struct snd_ctl_file * ctl)
  98 {
  99         unsigned long flags;
 100         struct snd_kctl_event *cread;
 101
 102         spin_lock_irqsave(&ctl->read_lock, flags);
 103         while (!list_empty(&ctl->events)) {
 104                 cread = snd_kctl_event(ctl->events.next);
 105                 list_del(&cread->list);
 106                 kfree(cread);
 107         }
 108         spin_unlock_irqrestore(&ctl->read_lock, flags);
 109 }
 110
 111 static int snd_ctl_release(struct inode *inode, struct file *file)
 112 {
 113         unsigned long flags;
 114         struct snd_card *card;
 115         struct snd_ctl_file *ctl;
 116         struct snd_kcontrol *control;
 117         unsigned int idx;
 118
 119         ctl = file->private_data;
 120         file->private_data = NULL;
 121         card = ctl->card;
 122         write_lock_irqsave(&card->ctl_files_rwlock, flags);
 123         list_del(&ctl->list);
 124         write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
 125         down_write(&card->controls_rwsem);
 126         list_for_each_entry(control, &card->controls, list)
 127                 for (idx = 0; idx < control->count; idx++)
 128                         if (control->vd[idx].owner == ctl)
 129                                 control->vd[idx].owner = NULL;
 130         up_write(&card->controls_rwsem);
 131         snd_ctl_empty_read_queue(ctl);
 132         put_pid(ctl->pid);
 133         kfree(ctl);
 134         module_put(card->module);
 135         snd_card_file_remove(card, file);
 136         return 0;
 137 }
 138
 139 void snd_ctl_notify(struct snd_card *card, unsigned int mask,
 140                     struct snd_ctl_elem_id *id)
 141 {
 142         unsigned long flags;
 143         struct snd_ctl_file *ctl;
 144         struct snd_kctl_event *ev;
 145
 146         if (snd_BUG_ON(!card || !id))
 147                 return;
 148         read_lock(&card->ctl_files_rwlock);
 149 #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
 150         card->mixer_oss_change_count++;
 151 #endif
 152         list_for_each_entry(ctl, &card->ctl_files, list) {
 153                 if (!ctl->subscribed)
 154                         continue;
 155                 spin_lock_irqsave(&ctl->read_lock, flags);
 156                 list_for_each_entry(ev, &ctl->events, list) {
 157                         if (ev->id.numid == id->numid) {
 158                                 ev->mask |= mask;
 159                                 goto _found;
 160                         }
 161                 }
 162                 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
 163                 if (ev) {
 164                         ev->id = *id;
 165                         ev->mask = mask;
 166                         list_add_tail(&ev->list, &ctl->events);
 167                 } else {
 168                         snd_printk(KERN_ERR "No memory available to allocate event\n");
 169                 }
 170         _found:
 171                 wake_up(&ctl->change_sleep);
 172                 spin_unlock_irqrestore(&ctl->read_lock, flags);
 173                 kill_fasync(&ctl->fasync, SIGIO, POLL_IN);
 174         }
 175         read_unlock(&card->ctl_files_rwlock);
 176 }
 177
 178 EXPORT_SYMBOL(snd_ctl_notify);
 179
 180 /**
 181  * snd_ctl_new - create a control instance from the template
 182  * @control: the control template
 183  * @access: the default control access
 184  *
 185  * Allocates a new struct snd_kcontrol instance and copies the given template
 186  * to the new instance. It does not copy volatile data (access).
 187  *
 188  * Returns the pointer of the new instance, or NULL on failure.
 189  */
 190 static struct snd_kcontrol *snd_ctl_new(struct snd_kcontrol *control,
 191                                         unsigned int access)
 192 {
 193         struct snd_kcontrol *kctl;
 194         unsigned int idx;
 195
 196         if (snd_BUG_ON(!control || !control->count))
 197                 return NULL;
 198         kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcontrol_volatile) * control->count, GFP_KERNEL);
 199         if (kctl == NULL) {
 200                 snd_printk(KERN_ERR "Cannot allocate control instance\n");
 201                 return NULL;
 202         }
 203         *kctl = *control;
 204         for (idx = 0; idx < kctl->count; idx++)
 205                 kctl->vd[idx].access = access;
 206         return kctl;
 207 }
 208
 209 /**
 210  * snd_ctl_new1 - create a control instance from the template
 211  * @ncontrol: the initialization record
 212  * @private_data: the private data to set
 213  *
 214  * Allocates a new struct snd_kcontrol instance and initialize from the given
 215  * template.  When the access field of ncontrol is 0, it's assumed as
 216  * READWRITE access. When the count field is 0, it's assumes as one.
 217  *
 218  * Returns the pointer of the newly generated instance, or NULL on failure.
 219  */
 220 struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol,
 221                                   void *private_data)
 222 {
 223         struct snd_kcontrol kctl;
 224         unsigned int access;
 225
 226         if (snd_BUG_ON(!ncontrol || !ncontrol->info))
 227                 return NULL;
 228         memset(&kctl, 0, sizeof(kctl));
 229         kctl.id.iface = ncontrol->iface;
 230         kctl.id.device = ncontrol->device;
 231         kctl.id.subdevice = ncontrol->subdevice;
 232         if (ncontrol->name) {
 233                 strlcpy(kctl.id.name, ncontrol->name, sizeof(kctl.id.name));
 234                 if (strcmp(ncontrol->name, kctl.id.name) != 0)
 235                         snd_printk(KERN_WARNING
 236                                    "Control name '%s' truncated to '%s'\n",
 237                                    ncontrol->name, kctl.id.name);
 238         }
 239         kctl.id.index = ncontrol->index;
 240         kctl.count = ncontrol->count ? ncontrol->count : 1;
 241         access = ncontrol->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
 242                  (ncontrol->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|
 243                                       SNDRV_CTL_ELEM_ACCESS_INACTIVE|
 244                                       SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE|
 245                                       SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND|
 246                                       SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK));
 247         kctl.info = ncontrol->info;
 248         kctl.get = ncontrol->get;
 249         kctl.put = ncontrol->put;
 250         kctl.tlv.p = ncontrol->tlv.p;
 251         kctl.private_value = ncontrol->private_value;
 252         kctl.private_data = private_data;
 253         return snd_ctl_new(&kctl, access);
 254 }
 255
 256 EXPORT_SYMBOL(snd_ctl_new1);
 257
 258 /**
 259  * snd_ctl_free_one - release the control instance
 260  * @kcontrol: the control instance
 261  *
 262  * Releases the control instance created via snd_ctl_new()
 263  * or snd_ctl_new1().
 264  * Don't call this after the control was added to the card.
 265  */
 266 void snd_ctl_free_one(struct snd_kcontrol *kcontrol)
 267 {
 268         if (kcontrol) {
 269                 if (kcontrol->private_free)
 270                         kcontrol->private_free(kcontrol);
 271                 kfree(kcontrol);
 272         }
 273 }
 274
 275 EXPORT_SYMBOL(snd_ctl_free_one);
 276
 277 static unsigned int snd_ctl_hole_check(struct snd_card *card,
 278                                        unsigned int count)
 279 {
 280         struct snd_kcontrol *kctl;
 281
 282         list_for_each_entry(kctl, &card->controls, list) {
 283                 if ((kctl->id.numid <= card->last_numid &&
 284                      kctl->id.numid + kctl->count > card->last_numid) ||
 285                     (kctl->id.numid <= card->last_numid + count - 1 &&
 286                      kctl->id.numid + kctl->count > card->last_numid + count - 1))
 287                         return card->last_numid = kctl->id.numid + kctl->count - 1;
 288         }
 289         return card->last_numid;
 290 }
 291
 292 static int snd_ctl_find_hole(struct snd_card *card, unsigned int count)
 293 {
 294         unsigned int last_numid, iter = 100000;
 295
 296         last_numid = card->last_numid;
 297         while (last_numid != snd_ctl_hole_check(card, count)) {
 298                 if (--iter == 0) {
 299                         /* this situation is very unlikely */
 300                         snd_printk(KERN_ERR "unable to allocate new control numid\n");
 301                         return -ENOMEM;
 302                 }
 303                 last_numid = card->last_numid;
 304         }
 305         return 0;
 306 }
 307
 308 /**
 309  * snd_ctl_add - add the control instance to the card
 310  * @card: the card instance
 311  * @kcontrol: the control instance to add
 312  *
 313  * Adds the control instance created via snd_ctl_new() or
 314  * snd_ctl_new1() to the given card. Assigns also an unique
 315  * numid used for fast search.
 316  *
 317  * Returns zero if successful, or a negative error code on failure.
 318  *
 319  * It frees automatically the control which cannot be added.
 320  */
 321 int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol)
 322 {
 323         struct snd_ctl_elem_id id;
 324         unsigned int idx;
 325         int err = -EINVAL;
 326
 327         if (! kcontrol)
 328                 return err;
 329         if (snd_BUG_ON(!card || !kcontrol->info))
 330                 goto error;
 331         id = kcontrol->id;
 332         down_write(&card->controls_rwsem);
 333         if (snd_ctl_find_id(card, &id)) {
 334                 up_write(&card->controls_rwsem);
 335                 snd_printd(KERN_ERR "control %i:%i:%i:%s:%i is already present\n",
 336                                         id.iface,
 337                                         id.device,
 338                                         id.subdevice,
 339                                         id.name,
 340                                         id.index);
 341                 err = -EBUSY;
 342                 goto error;
 343         }
 344         if (snd_ctl_find_hole(card, kcontrol->count) < 0) {
 345                 up_write(&card->controls_rwsem);
 346                 err = -ENOMEM;
 347                 goto error;
 348         }
 349         list_add_tail(&kcontrol->list, &card->controls);
 350         card->controls_count += kcontrol->count;
 351         kcontrol->id.numid = card->last_numid + 1;
 352         card->last_numid += kcontrol->count;
 353         up_write(&card->controls_rwsem);
 354         for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
 355                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_ADD, &id);
 356         return 0;
 357
 358  error:
 359         snd_ctl_free_one(kcontrol);
 360         return err;
 361 }
 362
 363 EXPORT_SYMBOL(snd_ctl_add);
 364
 365 /**
 366  * snd_ctl_remove - remove the control from the card and release it
 367  * @card: the card instance
 368  * @kcontrol: the control instance to remove
 369  *
 370  * Removes the control from the card and then releases the instance.
 371  * You don't need to call snd_ctl_free_one(). You must be in
 372  * the write lock - down_write(&card->controls_rwsem).
 373  *
 374  * Returns 0 if successful, or a negative error code on failure.
 375  */
 376 int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol)
 377 {
 378         struct snd_ctl_elem_id id;
 379         unsigned int idx;
 380
 381         if (snd_BUG_ON(!card || !kcontrol))
 382                 return -EINVAL;
 383         list_del(&kcontrol->list);
 384         card->controls_count -= kcontrol->count;
 385         id = kcontrol->id;
 386         for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
 387                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_REMOVE, &id);
 388         snd_ctl_free_one(kcontrol);
 389         return 0;
 390 }
 391
 392 EXPORT_SYMBOL(snd_ctl_remove);
 393
 394 /**
 395  * snd_ctl_remove_id - remove the control of the given id and release it
 396  * @card: the card instance
 397  * @id: the control id to remove
 398  *
 399  * Finds the control instance with the given id, removes it from the
 400  * card list and releases it.
 401  *
 402  * Returns 0 if successful, or a negative error code on failure.
 403  */
 404 int snd_ctl_remove_id(struct snd_card *card, struct snd_ctl_elem_id *id)
 405 {
 406         struct snd_kcontrol *kctl;
 407         int ret;
 408
 409         down_write(&card->controls_rwsem);
 410         kctl = snd_ctl_find_id(card, id);
 411         if (kctl == NULL) {
 412                 up_write(&card->controls_rwsem);
 413                 return -ENOENT;
 414         }
 415         ret = snd_ctl_remove(card, kctl);
 416         up_write(&card->controls_rwsem);
 417         return ret;
 418 }
 419
 420 EXPORT_SYMBOL(snd_ctl_remove_id);
 421
 422 /**
 423  * snd_ctl_remove_user_ctl - remove and release the unlocked user control
 424  * @file: active control handle
 425  * @id: the control id to remove
 426  *
 427  * Finds the control instance with the given id, removes it from the
 428  * card list and releases it.
 429  *
 430  * Returns 0 if successful, or a negative error code on failure.
 431  */
 432 static int snd_ctl_remove_user_ctl(struct snd_ctl_file * file,
 433                                    struct snd_ctl_elem_id *id)
 434 {
 435         struct snd_card *card = file->card;
 436         struct snd_kcontrol *kctl;
 437         int idx, ret;
 438
 439         down_write(&card->controls_rwsem);
 440         kctl = snd_ctl_find_id(card, id);
 441         if (kctl == NULL) {
 442                 ret = -ENOENT;
 443                 goto error;
 444         }
 445         if (!(kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_USER)) {
 446                 ret = -EINVAL;
 447                 goto error;
 448         }
 449         for (idx = 0; idx < kctl->count; idx++)
 450                 if (kctl->vd[idx].owner != NULL && kctl->vd[idx].owner != file) {
 451                         ret = -EBUSY;
 452                         goto error;
 453                 }
 454         ret = snd_ctl_remove(card, kctl);
 455         if (ret < 0)
 456                 goto error;
 457         card->user_ctl_count--;
 458 error:
 459         up_write(&card->controls_rwsem);
 460         return ret;
 461 }
 462
 463 /**
 464  * snd_ctl_rename_id - replace the id of a control on the card
 465  * @card: the card instance
 466  * @src_id: the old id
 467  * @dst_id: the new id
 468  *
 469  * Finds the control with the old id from the card, and replaces the
 470  * id with the new one.
 471  *
 472  * Returns zero if successful, or a negative error code on failure.
 473  */
 474 int snd_ctl_rename_id(struct snd_card *card, struct snd_ctl_elem_id *src_id,
 475                       struct snd_ctl_elem_id *dst_id)
 476 {
 477         struct snd_kcontrol *kctl;
 478
 479         down_write(&card->controls_rwsem);
 480         kctl = snd_ctl_find_id(card, src_id);
 481         if (kctl == NULL) {
 482                 up_write(&card->controls_rwsem);
 483                 return -ENOENT;
 484         }
 485         kctl->id = *dst_id;
 486         kctl->id.numid = card->last_numid + 1;
 487         card->last_numid += kctl->count;
 488         up_write(&card->controls_rwsem);
 489         return 0;
 490 }
 491
 492 EXPORT_SYMBOL(snd_ctl_rename_id);
 493
 494 /**
 495  * snd_ctl_find_numid - find the control instance with the given number-id
 496  * @card: the card instance
 497  * @numid: the number-id to search
 498  *
 499  * Finds the control instance with the given number-id from the card.
 500  *
 501  * Returns the pointer of the instance if found, or NULL if not.
 502  *
 503  * The caller must down card->controls_rwsem before calling this function
 504  * (if the race condition can happen).
 505  */
 506 struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card, unsigned int numid)
 507 {
 508         struct snd_kcontrol *kctl;
 509
 510         if (snd_BUG_ON(!card || !numid))
 511                 return NULL;
 512         list_for_each_entry(kctl, &card->controls, list) {
 513                 if (kctl->id.numid <= numid && kctl->id.numid + kctl->count > numid)
 514                         return kctl;
 515         }
 516         return NULL;
 517 }
 518
 519 EXPORT_SYMBOL(snd_ctl_find_numid);
 520
 521 /**
 522  * snd_ctl_find_id - find the control instance with the given id
 523  * @card: the card instance
 524  * @id: the id to search
 525  *
 526  * Finds the control instance with the given id from the card.
 527  *
 528  * Returns the pointer of the instance if found, or NULL if not.
 529  *
 530  * The caller must down card->controls_rwsem before calling this function
 531  * (if the race condition can happen).
 532  */
 533 struct snd_kcontrol *snd_ctl_find_id(struct snd_card *card,
 534                                      struct snd_ctl_elem_id *id)
 535 {
 536         struct snd_kcontrol *kctl;
 537
 538         if (snd_BUG_ON(!card || !id))
 539                 return NULL;
 540         if (id->numid != 0)
 541                 return snd_ctl_find_numid(card, id->numid);
 542         list_for_each_entry(kctl, &card->controls, list) {
 543                 if (kctl->id.iface != id->iface)
 544                         continue;
 545                 if (kctl->id.device != id->device)
 546                         continue;
 547                 if (kctl->id.subdevice != id->subdevice)
 548                         continue;
 549                 if (strncmp(kctl->id.name, id->name, sizeof(kctl->id.name)))
 550                         continue;
 551                 if (kctl->id.index > id->index)
 552                         continue;
 553                 if (kctl->id.index + kctl->count <= id->index)
 554                         continue;
 555                 return kctl;
 556         }
 557         return NULL;
 558 }
 559
 560 EXPORT_SYMBOL(snd_ctl_find_id);
 561
 562 static int snd_ctl_card_info(struct snd_card *card, struct snd_ctl_file * ctl,
 563                              unsigned int cmd, void __user *arg)
 564 {
 565         struct snd_ctl_card_info *info;
 566
 567         info = kzalloc(sizeof(*info), GFP_KERNEL);
 568         if (! info)
 569                 return -ENOMEM;
 570         down_read(&snd_ioctl_rwsem);
 571         info->card = card->number;
 572         strlcpy(info->id, card->id, sizeof(info->id));
 573         strlcpy(info->driver, card->driver, sizeof(info->driver));
 574         strlcpy(info->name, card->shortname, sizeof(info->name));
 575         strlcpy(info->longname, card->longname, sizeof(info->longname));
 576         strlcpy(info->mixername, card->mixername, sizeof(info->mixername));
 577         strlcpy(info->components, card->components, sizeof(info->components));
 578         up_read(&snd_ioctl_rwsem);
 579         if (copy_to_user(arg, info, sizeof(struct snd_ctl_card_info))) {
 580                 kfree(info);
 581                 return -EFAULT;
 582         }
 583         kfree(info);
 584         return 0;
 585 }
 586
 587 static int snd_ctl_elem_list(struct snd_card *card,
 588                              struct snd_ctl_elem_list __user *_list)
 589 {
 590         struct list_head *plist;
 591         struct snd_ctl_elem_list list;
 592         struct snd_kcontrol *kctl;
 593         struct snd_ctl_elem_id *dst, *id;
 594         unsigned int offset, space, first, jidx;
 595
 596         if (copy_from_user(&list, _list, sizeof(list)))
 597                 return -EFAULT;
 598         offset = list.offset;
 599         space = list.space;
 600         first = 0;
 601         /* try limit maximum space */
 602         if (space > 16384)
 603                 return -ENOMEM;
 604         if (space > 0) {
 605                 /* allocate temporary buffer for atomic operation */
 606                 dst = vmalloc(space * sizeof(struct snd_ctl_elem_id));
 607                 if (dst == NULL)
 608                         return -ENOMEM;
 609                 down_read(&card->controls_rwsem);
 610                 list.count = card->controls_count;
 611                 plist = card->controls.next;
 612                 while (plist != &card->controls) {
 613                         if (offset == 0)
 614                                 break;
 615                         kctl = snd_kcontrol(plist);
 616                         if (offset < kctl->count)
 617                                 break;
 618                         offset -= kctl->count;
 619                         plist = plist->next;
 620                 }
 621                 list.used = 0;
 622                 id = dst;
 623                 while (space > 0 && plist != &card->controls) {
 624                         kctl = snd_kcontrol(plist);
 625                         for (jidx = offset; space > 0 && jidx < kctl->count; jidx++) {
 626                                 snd_ctl_build_ioff(id, kctl, jidx);
 627                                 id++;
 628                                 space--;
 629                                 list.used++;
 630                         }
 631                         plist = plist->next;
 632                         offset = 0;
 633                 }
 634                 up_read(&card->controls_rwsem);
 635                 if (list.used > 0 &&
 636                     copy_to_user(list.pids, dst,
 637                                  list.used * sizeof(struct snd_ctl_elem_id))) {
 638                         vfree(dst);
 639                         return -EFAULT;
 640                 }
 641                 vfree(dst);
 642         } else {
 643                 down_read(&card->controls_rwsem);
 644                 list.count = card->controls_count;
 645                 up_read(&card->controls_rwsem);
 646         }
 647         if (copy_to_user(_list, &list, sizeof(list)))
 648                 return -EFAULT;
 649         return 0;
 650 }
 651
 652 static int snd_ctl_elem_info(struct snd_ctl_file *ctl,
 653                              struct snd_ctl_elem_info *info)
 654 {
 655         struct snd_card *card = ctl->card;
 656         struct snd_kcontrol *kctl;
 657         struct snd_kcontrol_volatile *vd;
 658         unsigned int index_offset;
 659         int result;
 660
 661         down_read(&card->controls_rwsem);
 662         kctl = snd_ctl_find_id(card, &info->id);
 663         if (kctl == NULL) {
 664                 up_read(&card->controls_rwsem);
 665                 return -ENOENT;
 666         }
 667 #ifdef CONFIG_SND_DEBUG
 668         info->access = 0;
 669 #endif
 670         result = kctl->info(kctl, info);
 671         if (result >= 0) {
 672                 snd_BUG_ON(info->access);
 673                 index_offset = snd_ctl_get_ioff(kctl, &info->id);
 674                 vd = &kctl->vd[index_offset];
 675                 snd_ctl_build_ioff(&info->id, kctl, index_offset);
 676                 info->access = vd->access;
 677                 if (vd->owner) {
 678                         info->access |= SNDRV_CTL_ELEM_ACCESS_LOCK;
 679                         if (vd->owner == ctl)
 680                                 info->access |= SNDRV_CTL_ELEM_ACCESS_OWNER;
 681                         info->owner = pid_vnr(vd->owner->pid);
 682                 } else {
 683                         info->owner = -1;
 684                 }
 685         }
 686         up_read(&card->controls_rwsem);
 687         return result;
 688 }
 689
 690 static int snd_ctl_elem_info_user(struct snd_ctl_file *ctl,
 691                                   struct snd_ctl_elem_info __user *_info)
 692 {
 693         struct snd_ctl_elem_info info;
 694         int result;
 695
 696         if (copy_from_user(&info, _info, sizeof(info)))
 697                 return -EFAULT;
 698         snd_power_lock(ctl->card);
 699         result = snd_power_wait(ctl->card, SNDRV_CTL_POWER_D0);
 700         if (result >= 0)
 701                 result = snd_ctl_elem_info(ctl, &info);
 702         snd_power_unlock(ctl->card);
 703         if (result >= 0)
 704                 if (copy_to_user(_info, &info, sizeof(info)))
 705                         return -EFAULT;
 706         return result;
 707 }
 708
 709 static int snd_ctl_elem_read(struct snd_card *card,
 710                              struct snd_ctl_elem_value *control)
 711 {
 712         struct snd_kcontrol *kctl;
 713         struct snd_kcontrol_volatile *vd;
 714         unsigned int index_offset;
 715         int result;
 716
 717         down_read(&card->controls_rwsem);
 718         kctl = snd_ctl_find_id(card, &control->id);
 719         if (kctl == NULL) {
 720                 result = -ENOENT;
 721         } else {
 722                 index_offset = snd_ctl_get_ioff(kctl, &control->id);
 723                 vd = &kctl->vd[index_offset];
 724                 if ((vd->access & SNDRV_CTL_ELEM_ACCESS_READ) &&
 725                     kctl->get != NULL) {
 726                         snd_ctl_build_ioff(&control->id, kctl, index_offset);
 727                         result = kctl->get(kctl, control);
 728                 } else
 729                         result = -EPERM;
 730         }
 731         up_read(&card->controls_rwsem);
 732         return result;
 733 }
 734
 735 static int snd_ctl_elem_read_user(struct snd_card *card,
 736                                   struct snd_ctl_elem_value __user *_control)
 737 {
 738         struct snd_ctl_elem_value *control;
 739         int result;
 740
 741         control = memdup_user(_control, sizeof(*control));
 742         if (IS_ERR(control))
 743                 return PTR_ERR(control);
 744
 745         snd_power_lock(card);
 746         result = snd_power_wait(card, SNDRV_CTL_POWER_D0);
 747         if (result >= 0)
 748                 result = snd_ctl_elem_read(card, control);
 749         snd_power_unlock(card);
 750         if (result >= 0)
 751                 if (copy_to_user(_control, control, sizeof(*control)))
 752                         result = -EFAULT;
 753         kfree(control);
 754         return result;
 755 }
 756
 757 static int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file,
 758                               struct snd_ctl_elem_value *control)
 759 {
 760         struct snd_kcontrol *kctl;
 761         struct snd_kcontrol_volatile *vd;
 762         unsigned int index_offset;
 763         int result;
 764
 765         down_read(&card->controls_rwsem);
 766         kctl = snd_ctl_find_id(card, &control->id);
 767         if (kctl == NULL) {
 768                 result = -ENOENT;
 769         } else {
 770                 index_offset = snd_ctl_get_ioff(kctl, &control->id);
 771                 vd = &kctl->vd[index_offset];
 772                 if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_WRITE) ||
 773                     kctl->put == NULL ||
 774                     (file && vd->owner && vd->owner != file)) {
 775                         result = -EPERM;
 776                 } else {
 777                         snd_ctl_build_ioff(&control->id, kctl, index_offset);
 778                         result = kctl->put(kctl, control);
 779                 }
 780                 if (result > 0) {
 781                         up_read(&card->controls_rwsem);
 782                         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
 783                                        &control->id);
 784                         return 0;
 785                 }
 786         }
 787         up_read(&card->controls_rwsem);
 788         return result;
 789 }
 790
 791 static int snd_ctl_elem_write_user(struct snd_ctl_file *file,
 792                                    struct snd_ctl_elem_value __user *_control)
 793 {
 794         struct snd_ctl_elem_value *control;
 795         struct snd_card *card;
 796         int result;
 797
 798         control = memdup_user(_control, sizeof(*control));
 799         if (IS_ERR(control))
 800                 return PTR_ERR(control);
 801
 802         card = file->card;
 803         snd_power_lock(card);
 804         result = snd_power_wait(card, SNDRV_CTL_POWER_D0);
 805         if (result >= 0)
 806                 result = snd_ctl_elem_write(card, file, control);
 807         snd_power_unlock(card);
 808         if (result >= 0)
 809                 if (copy_to_user(_control, control, sizeof(*control)))
 810                         result = -EFAULT;
 811         kfree(control);
 812         return result;
 813 }
 814
 815 static int snd_ctl_elem_lock(struct snd_ctl_file *file,
 816                              struct snd_ctl_elem_id __user *_id)
 817 {
 818         struct snd_card *card = file->card;
 819         struct snd_ctl_elem_id id;
 820         struct snd_kcontrol *kctl;
 821         struct snd_kcontrol_volatile *vd;
 822         int result;
 823
 824         if (copy_from_user(&id, _id, sizeof(id)))
 825                 return -EFAULT;
 826         down_write(&card->controls_rwsem);
 827         kctl = snd_ctl_find_id(card, &id);
 828         if (kctl == NULL) {
 829                 result = -ENOENT;
 830         } else {
 831                 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
 832                 if (vd->owner != NULL)
 833                         result = -EBUSY;
 834                 else {
 835                         vd->owner = file;
 836                         result = 0;
 837                 }
 838         }
 839         up_write(&card->controls_rwsem);
 840         return result;
 841 }
 842
 843 static int snd_ctl_elem_unlock(struct snd_ctl_file *file,
 844                                struct snd_ctl_elem_id __user *_id)
 845 {
 846         struct snd_card *card = file->card;
 847         struct snd_ctl_elem_id id;
 848         struct snd_kcontrol *kctl;
 849         struct snd_kcontrol_volatile *vd;
 850         int result;
 851
 852         if (copy_from_user(&id, _id, sizeof(id)))
 853                 return -EFAULT;
 854         down_write(&card->controls_rwsem);
 855         kctl = snd_ctl_find_id(card, &id);
 856         if (kctl == NULL) {
 857                 result = -ENOENT;
 858         } else {
 859                 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
 860                 if (vd->owner == NULL)
 861                         result = -EINVAL;
 862                 else if (vd->owner != file)
 863                         result = -EPERM;
 864                 else {
 865                         vd->owner = NULL;
 866                         result = 0;
 867                 }
 868         }
 869         up_write(&card->controls_rwsem);
 870         return result;
 871 }
 872
 873 struct user_element {
 874         struct snd_ctl_elem_info info;
 875         void *elem_data;                /* element data */
 876         unsigned long elem_data_size;   /* size of element data in bytes */
 877         void *tlv_data;                 /* TLV data */
 878         unsigned long tlv_data_size;    /* TLV data size */
 879         void *priv_data;                /* private data (like strings for enumerated type) */
 880         unsigned long priv_data_size;   /* size of private data in bytes */
 881 };
 882
 883 static int snd_ctl_elem_user_info(struct snd_kcontrol *kcontrol,
 884                                   struct snd_ctl_elem_info *uinfo)
 885 {
 886         struct user_element *ue = kcontrol->private_data;
 887
 888         *uinfo = ue->info;
 889         return 0;
 890 }
 891
 892 static int snd_ctl_elem_user_get(struct snd_kcontrol *kcontrol,
 893                                  struct snd_ctl_elem_value *ucontrol)
 894 {
 895         struct user_element *ue = kcontrol->private_data;
 896
 897         memcpy(&ucontrol->value, ue->elem_data, ue->elem_data_size);
 898         return 0;
 899 }
 900
 901 static int snd_ctl_elem_user_put(struct snd_kcontrol *kcontrol,
 902                                  struct snd_ctl_elem_value *ucontrol)
 903 {
 904         int change;
 905         struct user_element *ue = kcontrol->private_data;
 906
 907         change = memcmp(&ucontrol->value, ue->elem_data, ue->elem_data_size) != 0;
 908         if (change)
 909                 memcpy(ue->elem_data, &ucontrol->value, ue->elem_data_size);
 910         return change;
 911 }
 912
 913 static int snd_ctl_elem_user_tlv(struct snd_kcontrol *kcontrol,
 914                                  int op_flag,
 915                                  unsigned int size,
 916                                  unsigned int __user *tlv)
 917 {
 918         struct user_element *ue = kcontrol->private_data;
 919         int change = 0;
 920         void *new_data;
 921
 922         if (op_flag > 0) {
 923                 if (size > 1024 * 128)  /* sane value */
 924                         return -EINVAL;
 925
 926                 new_data = memdup_user(tlv, size);
 927                 if (IS_ERR(new_data))
 928                         return PTR_ERR(new_data);
 929                 change = ue->tlv_data_size != size;
 930                 if (!change)
 931                         change = memcmp(ue->tlv_data, new_data, size);
 932                 kfree(ue->tlv_data);
 933                 ue->tlv_data = new_data;
 934                 ue->tlv_data_size = size;
 935         } else {
 936                 if (! ue->tlv_data_size || ! ue->tlv_data)
 937                         return -ENXIO;
 938                 if (size < ue->tlv_data_size)
 939                         return -ENOSPC;
 940                 if (copy_to_user(tlv, ue->tlv_data, ue->tlv_data_size))
 941                         return -EFAULT;
 942         }
 943         return change;
 944 }
 945
 946 static void snd_ctl_elem_user_free(struct snd_kcontrol *kcontrol)
 947 {
 948         struct user_element *ue = kcontrol->private_data;
 949         if (ue->tlv_data)
 950                 kfree(ue->tlv_data);
 951         kfree(ue);
 952 }
 953
 954 static int snd_ctl_elem_add(struct snd_ctl_file *file,
 955                             struct snd_ctl_elem_info *info, int replace)
 956 {
 957         struct snd_card *card = file->card;
 958         struct snd_kcontrol kctl, *_kctl;
 959         unsigned int access;
 960         long private_size;
 961         struct user_element *ue;
 962         int idx, err;
 963
 964         if (card->user_ctl_count >= MAX_USER_CONTROLS)
 965                 return -ENOMEM;
 966         if (info->count < 1)
 967                 return -EINVAL;
 968         access = info->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
 969                 (info->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|
 970                                  SNDRV_CTL_ELEM_ACCESS_INACTIVE|
 971                                  SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE));
 972         info->id.numid = 0;
 973         memset(&kctl, 0, sizeof(kctl));
 974         down_write(&card->controls_rwsem);
 975         _kctl = snd_ctl_find_id(card, &info->id);
 976         err = 0;
 977         if (_kctl) {
 978                 if (replace)
 979                         err = snd_ctl_remove(card, _kctl);
 980                 else
 981                         err = -EBUSY;
 982         } else {
 983                 if (replace)
 984                         err = -ENOENT;
 985         }
 986         up_write(&card->controls_rwsem);
 987         if (err < 0)
 988                 return err;
 989         memcpy(&kctl.id, &info->id, sizeof(info->id));
 990         kctl.count = info->owner ? info->owner : 1;
 991         access |= SNDRV_CTL_ELEM_ACCESS_USER;
 992         kctl.info = snd_ctl_elem_user_info;
 993         if (access & SNDRV_CTL_ELEM_ACCESS_READ)
 994                 kctl.get = snd_ctl_elem_user_get;
 995         if (access & SNDRV_CTL_ELEM_ACCESS_WRITE)
 996                 kctl.put = snd_ctl_elem_user_put;
 997         if (access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE) {
 998                 kctl.tlv.c = snd_ctl_elem_user_tlv;
 999                 access |= SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
1000         }
1001         switch (info->type) {
1002         case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
1003         case SNDRV_CTL_ELEM_TYPE_INTEGER:
1004                 private_size = sizeof(long);
1005                 if (info->count > 128)
1006                         return -EINVAL;
1007                 break;
1008         case SNDRV_CTL_ELEM_TYPE_INTEGER64:
1009                 private_size = sizeof(long long);
1010                 if (info->count > 64)
1011                         return -EINVAL;
1012                 break;
1013         case SNDRV_CTL_ELEM_TYPE_BYTES:
1014                 private_size = sizeof(unsigned char);
1015                 if (info->count > 512)
1016                         return -EINVAL;
1017                 break;
1018         case SNDRV_CTL_ELEM_TYPE_IEC958:
1019                 private_size = sizeof(struct snd_aes_iec958);
1020                 if (info->count != 1)
1021                         return -EINVAL;
1022                 break;
1023         default:
1024                 return -EINVAL;
1025         }
1026         private_size *= info->count;
1027         ue = kzalloc(sizeof(struct user_element) + private_size, GFP_KERNEL);
1028         if (ue == NULL)
1029                 return -ENOMEM;
1030         ue->info = *info;
1031         ue->info.access = 0;
1032         ue->elem_data = (char *)ue + sizeof(*ue);
1033         ue->elem_data_size = private_size;
1034         kctl.private_free = snd_ctl_elem_user_free;
1035         _kctl = snd_ctl_new(&kctl, access);
1036         if (_kctl == NULL) {
1037                 kfree(ue);
1038                 return -ENOMEM;
1039         }
1040         _kctl->private_data = ue;
1041         for (idx = 0; idx < _kctl->count; idx++)
1042                 _kctl->vd[idx].owner = file;
1043         err = snd_ctl_add(card, _kctl);
1044         if (err < 0)
1045                 return err;
1046
1047         down_write(&card->controls_rwsem);
1048         card->user_ctl_count++;
1049         up_write(&card->controls_rwsem);
1050
1051         return 0;
1052 }
1053
1054 static int snd_ctl_elem_add_user(struct snd_ctl_file *file,
1055                                  struct snd_ctl_elem_info __user *_info, int replace)
1056 {
1057         struct snd_ctl_elem_info info;
1058         if (copy_from_user(&info, _info, sizeof(info)))
1059                 return -EFAULT;
1060         return snd_ctl_elem_add(file, &info, replace);
1061 }
1062
1063 static int snd_ctl_elem_remove(struct snd_ctl_file *file,
1064                                struct snd_ctl_elem_id __user *_id)
1065 {
1066         struct snd_ctl_elem_id id;
1067
1068         if (copy_from_user(&id, _id, sizeof(id)))
1069                 return -EFAULT;
1070         return snd_ctl_remove_user_ctl(file, &id);
1071 }
1072
1073 static int snd_ctl_subscribe_events(struct snd_ctl_file *file, int __user *ptr)
1074 {
1075         int subscribe;
1076         if (get_user(subscribe, ptr))
1077                 return -EFAULT;
1078         if (subscribe < 0) {
1079                 subscribe = file->subscribed;
1080                 if (put_user(subscribe, ptr))
1081                         return -EFAULT;
1082                 return 0;
1083         }
1084         if (subscribe) {
1085                 file->subscribed = 1;
1086                 return 0;
1087         } else if (file->subscribed) {
1088                 snd_ctl_empty_read_queue(file);
1089                 file->subscribed = 0;
1090         }
1091         return 0;
1092 }
1093
1094 static int snd_ctl_tlv_ioctl(struct snd_ctl_file *file,
1095                              struct snd_ctl_tlv __user *_tlv,
1096                              int op_flag)
1097 {
1098         struct snd_card *card = file->card;
1099         struct snd_ctl_tlv tlv;
1100         struct snd_kcontrol *kctl;
1101         struct snd_kcontrol_volatile *vd;
1102         unsigned int len;
1103         int err = 0;
1104
1105         if (copy_from_user(&tlv, _tlv, sizeof(tlv)))
1106                 return -EFAULT;
1107         if (tlv.length < sizeof(unsigned int) * 2)
1108                 return -EINVAL;
1109         down_read(&card->controls_rwsem);
1110         kctl = snd_ctl_find_numid(card, tlv.numid);
1111         if (kctl == NULL) {
1112                 err = -ENOENT;
1113                 goto __kctl_end;
1114         }
1115         if (kctl->tlv.p == NULL) {
1116                 err = -ENXIO;
1117                 goto __kctl_end;
1118         }
1119         vd = &kctl->vd[tlv.numid - kctl->id.numid];
1120         if ((op_flag == 0 && (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_READ) == 0) ||
1121             (op_flag > 0 && (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_WRITE) == 0) ||
1122             (op_flag < 0 && (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND) == 0)) {
1123                 err = -ENXIO;
1124                 goto __kctl_end;
1125         }
1126         if (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
1127                 if (vd->owner != NULL && vd->owner != file) {
1128                         err = -EPERM;
1129                         goto __kctl_end;
1130                 }
1131                 err = kctl->tlv.c(kctl, op_flag, tlv.length, _tlv->tlv);
1132                 if (err > 0) {
1133                         up_read(&card->controls_rwsem);
1134                         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_TLV, &kctl->id);
1135                         return 0;
1136                 }
1137         } else {
1138                 if (op_flag) {
1139                         err = -ENXIO;
1140                         goto __kctl_end;
1141                 }
1142                 len = kctl->tlv.p[1] + 2 * sizeof(unsigned int);
1143                 if (tlv.length < len) {
1144                         err = -ENOMEM;
1145                         goto __kctl_end;
1146                 }
1147                 if (copy_to_user(_tlv->tlv, kctl->tlv.p, len))
1148                         err = -EFAULT;
1149         }
1150       __kctl_end:
1151         up_read(&card->controls_rwsem);
1152         return err;
1153 }
1154
1155 static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1156 {
1157         struct snd_ctl_file *ctl;
1158         struct snd_card *card;
1159         struct snd_kctl_ioctl *p;
1160         void __user *argp = (void __user *)arg;
1161         int __user *ip = argp;
1162         int err;
1163
1164         ctl = file->private_data;
1165         card = ctl->card;
1166         if (snd_BUG_ON(!card))
1167                 return -ENXIO;
1168         switch (cmd) {
1169         case SNDRV_CTL_IOCTL_PVERSION:
1170                 return put_user(SNDRV_CTL_VERSION, ip) ? -EFAULT : 0;
1171         case SNDRV_CTL_IOCTL_CARD_INFO:
1172                 return snd_ctl_card_info(card, ctl, cmd, argp);
1173         case SNDRV_CTL_IOCTL_ELEM_LIST:
1174                 return snd_ctl_elem_list(card, argp);
1175         case SNDRV_CTL_IOCTL_ELEM_INFO:
1176                 return snd_ctl_elem_info_user(ctl, argp);
1177         case SNDRV_CTL_IOCTL_ELEM_READ:
1178                 return snd_ctl_elem_read_user(card, argp);
1179         case SNDRV_CTL_IOCTL_ELEM_WRITE:
1180                 return snd_ctl_elem_write_user(ctl, argp);
1181         case SNDRV_CTL_IOCTL_ELEM_LOCK:
1182                 return snd_ctl_elem_lock(ctl, argp);
1183         case SNDRV_CTL_IOCTL_ELEM_UNLOCK:
1184                 return snd_ctl_elem_unlock(ctl, argp);
1185         case SNDRV_CTL_IOCTL_ELEM_ADD:
1186                 return snd_ctl_elem_add_user(ctl, argp, 0);
1187         case SNDRV_CTL_IOCTL_ELEM_REPLACE:
1188                 return snd_ctl_elem_add_user(ctl, argp, 1);
1189         case SNDRV_CTL_IOCTL_ELEM_REMOVE:
1190                 return snd_ctl_elem_remove(ctl, argp);
1191         case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS:
1192                 return snd_ctl_subscribe_events(ctl, ip);
1193         case SNDRV_CTL_IOCTL_TLV_READ:
1194                 return snd_ctl_tlv_ioctl(ctl, argp, 0);
1195         case SNDRV_CTL_IOCTL_TLV_WRITE:
1196                 return snd_ctl_tlv_ioctl(ctl, argp, 1);
1197         case SNDRV_CTL_IOCTL_TLV_COMMAND:
1198                 return snd_ctl_tlv_ioctl(ctl, argp, -1);
1199         case SNDRV_CTL_IOCTL_POWER:
1200                 return -ENOPROTOOPT;
1201         case SNDRV_CTL_IOCTL_POWER_STATE:
1202 #ifdef CONFIG_PM
1203                 return put_user(card->power_state, ip) ? -EFAULT : 0;
1204 #else
1205                 return put_user(SNDRV_CTL_POWER_D0, ip) ? -EFAULT : 0;
1206 #endif
1207         }
1208         down_read(&snd_ioctl_rwsem);
1209         list_for_each_entry(p, &snd_control_ioctls, list) {
1210                 err = p->fioctl(card, ctl, cmd, arg);
1211                 if (err != -ENOIOCTLCMD) {
1212                         up_read(&snd_ioctl_rwsem);
1213                         return err;
1214                 }
1215         }
1216         up_read(&snd_ioctl_rwsem);
1217         snd_printdd("unknown ioctl = 0x%x\n", cmd);
1218         return -ENOTTY;
1219 }
1220
1221 static ssize_t snd_ctl_read(struct file *file, char __user *buffer,
1222                             size_t count, loff_t * offset)
1223 {
1224         struct snd_ctl_file *ctl;
1225         int err = 0;
1226         ssize_t result = 0;
1227
1228         ctl = file->private_data;
1229         if (snd_BUG_ON(!ctl || !ctl->card))
1230                 return -ENXIO;
1231         if (!ctl->subscribed)
1232                 return -EBADFD;
1233         if (count < sizeof(struct snd_ctl_event))
1234                 return -EINVAL;
1235         spin_lock_irq(&ctl->read_lock);
1236         while (count >= sizeof(struct snd_ctl_event)) {
1237                 struct snd_ctl_event ev;
1238                 struct snd_kctl_event *kev;
1239                 while (list_empty(&ctl->events)) {
1240                         wait_queue_t wait;
1241                         if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {
1242                                 err = -EAGAIN;
1243                                 goto __end_lock;
1244                         }
1245                         init_waitqueue_entry(&wait, current);
1246                         add_wait_queue(&ctl->change_sleep, &wait);
1247                         set_current_state(TASK_INTERRUPTIBLE);
1248                         spin_unlock_irq(&ctl->read_lock);
1249                         schedule();
1250                         remove_wait_queue(&ctl->change_sleep, &wait);
1251                         if (signal_pending(current))
1252                                 return -ERESTARTSYS;
1253                         spin_lock_irq(&ctl->read_lock);
1254                 }
1255                 kev = snd_kctl_event(ctl->events.next);
1256                 ev.type = SNDRV_CTL_EVENT_ELEM;
1257                 ev.data.elem.mask = kev->mask;
1258                 ev.data.elem.id = kev->id;
1259                 list_del(&kev->list);
1260                 spin_unlock_irq(&ctl->read_lock);
1261                 kfree(kev);
1262                 if (copy_to_user(buffer, &ev, sizeof(struct snd_ctl_event))) {
1263                         err = -EFAULT;
1264                         goto __end;
1265                 }
1266                 spin_lock_irq(&ctl->read_lock);
1267                 buffer += sizeof(struct snd_ctl_event);
1268                 count -= sizeof(struct snd_ctl_event);
1269                 result += sizeof(struct snd_ctl_event);
1270         }
1271       __end_lock:
1272         spin_unlock_irq(&ctl->read_lock);
1273       __end:
1274         return result > 0 ? result : err;
1275 }
1276
1277 static unsigned int snd_ctl_poll(struct file *file, poll_table * wait)
1278 {
1279         unsigned int mask;
1280         struct snd_ctl_file *ctl;
1281
1282         ctl = file->private_data;
1283         if (!ctl->subscribed)
1284                 return 0;
1285         poll_wait(file, &ctl->change_sleep, wait);
1286
1287         mask = 0;
1288         if (!list_empty(&ctl->events))
1289                 mask |= POLLIN | POLLRDNORM;
1290
1291         return mask;
1292 }
1293
1294 /*
1295  * register the device-specific control-ioctls.
1296  * called from each device manager like pcm.c, hwdep.c, etc.
1297  */
1298 static int _snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn, struct list_head *lists)
1299 {
1300         struct snd_kctl_ioctl *pn;
1301
1302         pn = kzalloc(sizeof(struct snd_kctl_ioctl), GFP_KERNEL);
1303         if (pn == NULL)
1304                 return -ENOMEM;
1305         pn->fioctl = fcn;
1306         down_write(&snd_ioctl_rwsem);
1307         list_add_tail(&pn->list, lists);
1308         up_write(&snd_ioctl_rwsem);
1309         return 0;
1310 }
1311
1312 int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn)
1313 {
1314         return _snd_ctl_register_ioctl(fcn, &snd_control_ioctls);
1315 }
1316
1317 EXPORT_SYMBOL(snd_ctl_register_ioctl);
1318
1319 #ifdef CONFIG_COMPAT
1320 int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn)
1321 {
1322         return _snd_ctl_register_ioctl(fcn, &snd_control_compat_ioctls);
1323 }
1324
1325 EXPORT_SYMBOL(snd_ctl_register_ioctl_compat);
1326 #endif
1327
1328 /*
1329  * de-register the device-specific control-ioctls.
1330  */
1331 static int _snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn,
1332                                      struct list_head *lists)
1333 {
1334         struct snd_kctl_ioctl *p;
1335
1336         if (snd_BUG_ON(!fcn))
1337                 return -EINVAL;
1338         down_write(&snd_ioctl_rwsem);
1339         list_for_each_entry(p, lists, list) {
1340                 if (p->fioctl == fcn) {
1341                         list_del(&p->list);
1342                         up_write(&snd_ioctl_rwsem);
1343                         kfree(p);
1344                         return 0;
1345                 }
1346         }
1347         up_write(&snd_ioctl_rwsem);
1348         snd_BUG();
1349         return -EINVAL;
1350 }
1351
1352 int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn)
1353 {
1354         return _snd_ctl_unregister_ioctl(fcn, &snd_control_ioctls);
1355 }
1356
1357 EXPORT_SYMBOL(snd_ctl_unregister_ioctl);
1358
1359 #ifdef CONFIG_COMPAT
1360 int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn)
1361 {
1362         return _snd_ctl_unregister_ioctl(fcn, &snd_control_compat_ioctls);
1363 }
1364
1365 EXPORT_SYMBOL(snd_ctl_unregister_ioctl_compat);
1366 #endif
1367
1368 static int snd_ctl_fasync(int fd, struct file * file, int on)
1369 {
1370         struct snd_ctl_file *ctl;
1371
1372         ctl = file->private_data;
1373         return fasync_helper(fd, file, on, &ctl->fasync);
1374 }
1375
1376 /*
1377  * ioctl32 compat
1378  */
1379 #ifdef CONFIG_COMPAT
1380 #include "control_compat.c"
1381 #else
1382 #define snd_ctl_ioctl_compat    NULL
1383 #endif
1384
1385 /*
1386  *  INIT PART
1387  */
1388
1389 static const struct file_operations snd_ctl_f_ops =
1390 {
1391         .owner =        THIS_MODULE,
1392         .read =         snd_ctl_read,
1393         .open =         snd_ctl_open,
1394         .release =      snd_ctl_release,
1395         .llseek =       no_llseek,
1396         .poll =         snd_ctl_poll,
1397         .unlocked_ioctl =       snd_ctl_ioctl,
1398         .compat_ioctl = snd_ctl_ioctl_compat,
1399         .fasync =       snd_ctl_fasync,
1400 };
1401
1402 /*
1403  * registration of the control device
1404  */
1405 static int snd_ctl_dev_register(struct snd_device *device)
1406 {
1407         struct snd_card *card = device->device_data;
1408         int err, cardnum;
1409         char name[16];
1410
1411         if (snd_BUG_ON(!card))
1412                 return -ENXIO;
1413         cardnum = card->number;
1414         if (snd_BUG_ON(cardnum < 0 || cardnum >= SNDRV_CARDS))
1415                 return -ENXIO;
1416         sprintf(name, "controlC%i", cardnum);
1417         if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1,
1418                                        &snd_ctl_f_ops, card, name)) < 0)
1419                 return err;
1420         return 0;
1421 }
1422
1423 /*
1424  * disconnection of the control device
1425  */
1426 static int snd_ctl_dev_disconnect(struct snd_device *device)
1427 {
1428         struct snd_card *card = device->device_data;
1429         struct snd_ctl_file *ctl;
1430         int err, cardnum;
1431
1432         if (snd_BUG_ON(!card))
1433                 return -ENXIO;
1434         cardnum = card->number;
1435         if (snd_BUG_ON(cardnum < 0 || cardnum >= SNDRV_CARDS))
1436                 return -ENXIO;
1437
1438         read_lock(&card->ctl_files_rwlock);
1439         list_for_each_entry(ctl, &card->ctl_files, list) {
1440                 wake_up(&ctl->change_sleep);
1441                 kill_fasync(&ctl->fasync, SIGIO, POLL_ERR);
1442         }
1443         read_unlock(&card->ctl_files_rwlock);
1444
1445         if ((err = snd_unregister_device(SNDRV_DEVICE_TYPE_CONTROL,
1446                                          card, -1)) < 0)
1447                 return err;
1448         return 0;
1449 }
1450
1451 /*
1452  * free all controls
1453  */
1454 static int snd_ctl_dev_free(struct snd_device *device)
1455 {
1456         struct snd_card *card = device->device_data;
1457         struct snd_kcontrol *control;
1458
1459         down_write(&card->controls_rwsem);
1460         while (!list_empty(&card->controls)) {
1461                 control = snd_kcontrol(card->controls.next);
1462                 snd_ctl_remove(card, control);
1463         }
1464         up_write(&card->controls_rwsem);
1465         return 0;
1466 }
1467
1468 /*
1469  * create control core:
1470  * called from init.c
1471  */
1472 int snd_ctl_create(struct snd_card *card)
1473 {
1474         static struct snd_device_ops ops = {
1475                 .dev_free = snd_ctl_dev_free,
1476                 .dev_register = snd_ctl_dev_register,
1477                 .dev_disconnect = snd_ctl_dev_disconnect,
1478         };
1479
1480         if (snd_BUG_ON(!card))
1481                 return -ENXIO;
1482         return snd_device_new(card, SNDRV_DEV_CONTROL, card, &ops);
1483 }
1484
1485 /*
1486  * Frequently used control callbacks
1487  */
1488 int snd_ctl_boolean_mono_info(struct snd_kcontrol *kcontrol,
1489                               struct snd_ctl_elem_info *uinfo)
1490 {
1491         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1492         uinfo->count = 1;
1493         uinfo->value.integer.min = 0;
1494         uinfo->value.integer.max = 1;
1495         return 0;
1496 }
1497
1498 EXPORT_SYMBOL(snd_ctl_boolean_mono_info);
1499
1500 int snd_ctl_boolean_stereo_info(struct snd_kcontrol *kcontrol,
1501                                 struct snd_ctl_elem_info *uinfo)
1502 {
1503         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1504         uinfo->count = 2;
1505         uinfo->value.integer.min = 0;
1506         uinfo->value.integer.max = 1;
1507         return 0;
1508 }
1509
1510 EXPORT_SYMBOL(snd_ctl_boolean_stereo_info);