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