sound/core/control.c

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