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