sound/core/control.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Routines for driver control interface
   4  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   5  */
   6
   7 #include <linux/threads.h>
   8 #include <linux/interrupt.h>
   9 #include <linux/module.h>
  10 #include <linux/moduleparam.h>
  11 #include <linux/slab.h>
  12 #include <linux/vmalloc.h>
  13 #include <linux/time.h>
  14 #include <linux/mm.h>
  15 #include <linux/math64.h>
  16 #include <linux/sched/signal.h>
  17 #include <sound/core.h>
  18 #include <sound/minors.h>
  19 #include <sound/info.h>
  20 #include <sound/control.h>
  21
  22 // Max allocation size for user controls.
  23 static int max_user_ctl_alloc_size = 8 * 1024 * 1024;
  24 module_param_named(max_user_ctl_alloc_size, max_user_ctl_alloc_size, int, 0444);
  25 MODULE_PARM_DESC(max_user_ctl_alloc_size, "Max allocation size for user controls");
  26
  27 #define MAX_CONTROL_COUNT       1028
  28
  29 struct snd_kctl_ioctl {
  30         struct list_head list;          /* list of all ioctls */
  31         snd_kctl_ioctl_func_t fioctl;
  32 };
  33
  34 static DECLARE_RWSEM(snd_ioctl_rwsem);
  35 static DECLARE_RWSEM(snd_ctl_layer_rwsem);
  36 static LIST_HEAD(snd_control_ioctls);
  37 #ifdef CONFIG_COMPAT
  38 static LIST_HEAD(snd_control_compat_ioctls);
  39 #endif
  40 static struct snd_ctl_layer_ops *snd_ctl_layer;
  41
  42 static int snd_ctl_remove_locked(struct snd_card *card,
  43                                  struct snd_kcontrol *kcontrol);
  44
  45 static int snd_ctl_open(struct inode *inode, struct file *file)
  46 {
  47         unsigned long flags;
  48         struct snd_card *card;
  49         struct snd_ctl_file *ctl;
  50         int i, err;
  51
  52         err = stream_open(inode, file);
  53         if (err < 0)
  54                 return err;
  55
  56         card = snd_lookup_minor_data(iminor(inode), SNDRV_DEVICE_TYPE_CONTROL);
  57         if (!card) {
  58                 err = -ENODEV;
  59                 goto __error1;
  60         }
  61         err = snd_card_file_add(card, file);
  62         if (err < 0) {
  63                 err = -ENODEV;
  64                 goto __error1;
  65         }
  66         if (!try_module_get(card->module)) {
  67                 err = -EFAULT;
  68                 goto __error2;
  69         }
  70         ctl = kzalloc(sizeof(*ctl), GFP_KERNEL);
  71         if (ctl == NULL) {
  72                 err = -ENOMEM;
  73                 goto __error;
  74         }
  75         INIT_LIST_HEAD(&ctl->events);
  76         init_waitqueue_head(&ctl->change_sleep);
  77         spin_lock_init(&ctl->read_lock);
  78         ctl->card = card;
  79         for (i = 0; i < SND_CTL_SUBDEV_ITEMS; i++)
  80                 ctl->preferred_subdevice[i] = -1;
  81         ctl->pid = get_pid(task_pid(current));
  82         file->private_data = ctl;
  83         write_lock_irqsave(&card->ctl_files_rwlock, flags);
  84         list_add_tail(&ctl->list, &card->ctl_files);
  85         write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
  86         snd_card_unref(card);
  87         return 0;
  88
  89       __error:
  90         module_put(card->module);
  91       __error2:
  92         snd_card_file_remove(card, file);
  93       __error1:
  94         if (card)
  95                 snd_card_unref(card);
  96         return err;
  97 }
  98
  99 static void snd_ctl_empty_read_queue(struct snd_ctl_file * ctl)
 100 {
 101         unsigned long flags;
 102         struct snd_kctl_event *cread;
 103
 104         spin_lock_irqsave(&ctl->read_lock, flags);
 105         while (!list_empty(&ctl->events)) {
 106                 cread = snd_kctl_event(ctl->events.next);
 107                 list_del(&cread->list);
 108                 kfree(cread);
 109         }
 110         spin_unlock_irqrestore(&ctl->read_lock, flags);
 111 }
 112
 113 static int snd_ctl_release(struct inode *inode, struct file *file)
 114 {
 115         unsigned long flags;
 116         struct snd_card *card;
 117         struct snd_ctl_file *ctl;
 118         struct snd_kcontrol *control;
 119         unsigned int idx;
 120
 121         ctl = file->private_data;
 122         file->private_data = NULL;
 123         card = ctl->card;
 124         write_lock_irqsave(&card->ctl_files_rwlock, flags);
 125         list_del(&ctl->list);
 126         write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
 127         down_write(&card->controls_rwsem);
 128         list_for_each_entry(control, &card->controls, list)
 129                 for (idx = 0; idx < control->count; idx++)
 130                         if (control->vd[idx].owner == ctl)
 131                                 control->vd[idx].owner = NULL;
 132         up_write(&card->controls_rwsem);
 133         snd_fasync_free(ctl->fasync);
 134         snd_ctl_empty_read_queue(ctl);
 135         put_pid(ctl->pid);
 136         kfree(ctl);
 137         module_put(card->module);
 138         snd_card_file_remove(card, file);
 139         return 0;
 140 }
 141
 142 /**
 143  * snd_ctl_notify - Send notification to user-space for a control change
 144  * @card: the card to send notification
 145  * @mask: the event mask, SNDRV_CTL_EVENT_*
 146  * @id: the ctl element id to send notification
 147  *
 148  * This function adds an event record with the given id and mask, appends
 149  * to the list and wakes up the user-space for notification.  This can be
 150  * called in the atomic context.
 151  */
 152 void snd_ctl_notify(struct snd_card *card, unsigned int mask,
 153                     struct snd_ctl_elem_id *id)
 154 {
 155         unsigned long flags;
 156         struct snd_ctl_file *ctl;
 157         struct snd_kctl_event *ev;
 158
 159         if (snd_BUG_ON(!card || !id))
 160                 return;
 161         if (card->shutdown)
 162                 return;
 163         read_lock_irqsave(&card->ctl_files_rwlock, flags);
 164 #if IS_ENABLED(CONFIG_SND_MIXER_OSS)
 165         card->mixer_oss_change_count++;
 166 #endif
 167         list_for_each_entry(ctl, &card->ctl_files, list) {
 168                 if (!ctl->subscribed)
 169                         continue;
 170                 spin_lock(&ctl->read_lock);
 171                 list_for_each_entry(ev, &ctl->events, list) {
 172                         if (ev->id.numid == id->numid) {
 173                                 ev->mask |= mask;
 174                                 goto _found;
 175                         }
 176                 }
 177                 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
 178                 if (ev) {
 179                         ev->id = *id;
 180                         ev->mask = mask;
 181                         list_add_tail(&ev->list, &ctl->events);
 182                 } else {
 183                         dev_err(card->dev, "No memory available to allocate event\n");
 184                 }
 185         _found:
 186                 wake_up(&ctl->change_sleep);
 187                 spin_unlock(&ctl->read_lock);
 188                 snd_kill_fasync(ctl->fasync, SIGIO, POLL_IN);
 189         }
 190         read_unlock_irqrestore(&card->ctl_files_rwlock, flags);
 191 }
 192 EXPORT_SYMBOL(snd_ctl_notify);
 193
 194 /**
 195  * snd_ctl_notify_one - Send notification to user-space for a control change
 196  * @card: the card to send notification
 197  * @mask: the event mask, SNDRV_CTL_EVENT_*
 198  * @kctl: the pointer with the control instance
 199  * @ioff: the additional offset to the control index
 200  *
 201  * This function calls snd_ctl_notify() and does additional jobs
 202  * like LED state changes.
 203  */
 204 void snd_ctl_notify_one(struct snd_card *card, unsigned int mask,
 205                         struct snd_kcontrol *kctl, unsigned int ioff)
 206 {
 207         struct snd_ctl_elem_id id = kctl->id;
 208         struct snd_ctl_layer_ops *lops;
 209
 210         id.index += ioff;
 211         id.numid += ioff;
 212         snd_ctl_notify(card, mask, &id);
 213         down_read(&snd_ctl_layer_rwsem);
 214         for (lops = snd_ctl_layer; lops; lops = lops->next)
 215                 lops->lnotify(card, mask, kctl, ioff);
 216         up_read(&snd_ctl_layer_rwsem);
 217 }
 218 EXPORT_SYMBOL(snd_ctl_notify_one);
 219
 220 /**
 221  * snd_ctl_new - create a new control instance with some elements
 222  * @kctl: the pointer to store new control instance
 223  * @count: the number of elements in this control
 224  * @access: the default access flags for elements in this control
 225  * @file: given when locking these elements
 226  *
 227  * Allocates a memory object for a new control instance. The instance has
 228  * elements as many as the given number (@count). Each element has given
 229  * access permissions (@access). Each element is locked when @file is given.
 230  *
 231  * Return: 0 on success, error code on failure
 232  */
 233 static int snd_ctl_new(struct snd_kcontrol **kctl, unsigned int count,
 234                        unsigned int access, struct snd_ctl_file *file)
 235 {
 236         unsigned int idx;
 237
 238         if (count == 0 || count > MAX_CONTROL_COUNT)
 239                 return -EINVAL;
 240
 241         *kctl = kzalloc(struct_size(*kctl, vd, count), GFP_KERNEL);
 242         if (!*kctl)
 243                 return -ENOMEM;
 244
 245         for (idx = 0; idx < count; idx++) {
 246                 (*kctl)->vd[idx].access = access;
 247                 (*kctl)->vd[idx].owner = file;
 248         }
 249         (*kctl)->count = count;
 250
 251         return 0;
 252 }
 253
 254 /**
 255  * snd_ctl_new1 - create a control instance from the template
 256  * @ncontrol: the initialization record
 257  * @private_data: the private data to set
 258  *
 259  * Allocates a new struct snd_kcontrol instance and initialize from the given
 260  * template.  When the access field of ncontrol is 0, it's assumed as
 261  * READWRITE access. When the count field is 0, it's assumes as one.
 262  *
 263  * Return: The pointer of the newly generated instance, or %NULL on failure.
 264  */
 265 struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol,
 266                                   void *private_data)
 267 {
 268         struct snd_kcontrol *kctl;
 269         unsigned int count;
 270         unsigned int access;
 271         int err;
 272
 273         if (snd_BUG_ON(!ncontrol || !ncontrol->info))
 274                 return NULL;
 275
 276         count = ncontrol->count;
 277         if (count == 0)
 278                 count = 1;
 279
 280         access = ncontrol->access;
 281         if (access == 0)
 282                 access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
 283         access &= (SNDRV_CTL_ELEM_ACCESS_READWRITE |
 284                    SNDRV_CTL_ELEM_ACCESS_VOLATILE |
 285                    SNDRV_CTL_ELEM_ACCESS_INACTIVE |
 286                    SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE |
 287                    SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND |
 288                    SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK |
 289                    SNDRV_CTL_ELEM_ACCESS_LED_MASK |
 290                    SNDRV_CTL_ELEM_ACCESS_SKIP_CHECK);
 291
 292         err = snd_ctl_new(&kctl, count, access, NULL);
 293         if (err < 0)
 294                 return NULL;
 295
 296         /* The 'numid' member is decided when calling snd_ctl_add(). */
 297         kctl->id.iface = ncontrol->iface;
 298         kctl->id.device = ncontrol->device;
 299         kctl->id.subdevice = ncontrol->subdevice;
 300         if (ncontrol->name) {
 301                 strscpy(kctl->id.name, ncontrol->name, sizeof(kctl->id.name));
 302                 if (strcmp(ncontrol->name, kctl->id.name) != 0)
 303                         pr_warn("ALSA: Control name '%s' truncated to '%s'\n",
 304                                 ncontrol->name, kctl->id.name);
 305         }
 306         kctl->id.index = ncontrol->index;
 307
 308         kctl->info = ncontrol->info;
 309         kctl->get = ncontrol->get;
 310         kctl->put = ncontrol->put;
 311         kctl->tlv.p = ncontrol->tlv.p;
 312
 313         kctl->private_value = ncontrol->private_value;
 314         kctl->private_data = private_data;
 315
 316         return kctl;
 317 }
 318 EXPORT_SYMBOL(snd_ctl_new1);
 319
 320 /**
 321  * snd_ctl_free_one - release the control instance
 322  * @kcontrol: the control instance
 323  *
 324  * Releases the control instance created via snd_ctl_new()
 325  * or snd_ctl_new1().
 326  * Don't call this after the control was added to the card.
 327  */
 328 void snd_ctl_free_one(struct snd_kcontrol *kcontrol)
 329 {
 330         if (kcontrol) {
 331                 if (kcontrol->private_free)
 332                         kcontrol->private_free(kcontrol);
 333                 kfree(kcontrol);
 334         }
 335 }
 336 EXPORT_SYMBOL(snd_ctl_free_one);
 337
 338 static bool snd_ctl_remove_numid_conflict(struct snd_card *card,
 339                                           unsigned int count)
 340 {
 341         struct snd_kcontrol *kctl;
 342
 343         /* Make sure that the ids assigned to the control do not wrap around */
 344         if (card->last_numid >= UINT_MAX - count)
 345                 card->last_numid = 0;
 346
 347         list_for_each_entry(kctl, &card->controls, list) {
 348                 if (kctl->id.numid < card->last_numid + 1 + count &&
 349                     kctl->id.numid + kctl->count > card->last_numid + 1) {
 350                         card->last_numid = kctl->id.numid + kctl->count - 1;
 351                         return true;
 352                 }
 353         }
 354         return false;
 355 }
 356
 357 static int snd_ctl_find_hole(struct snd_card *card, unsigned int count)
 358 {
 359         unsigned int iter = 100000;
 360
 361         while (snd_ctl_remove_numid_conflict(card, count)) {
 362                 if (--iter == 0) {
 363                         /* this situation is very unlikely */
 364                         dev_err(card->dev, "unable to allocate new control numid\n");
 365                         return -ENOMEM;
 366                 }
 367         }
 368         return 0;
 369 }
 370
 371 /* check whether the given id is contained in the given kctl */
 372 static bool elem_id_matches(const struct snd_kcontrol *kctl,
 373                             const struct snd_ctl_elem_id *id)
 374 {
 375         return kctl->id.iface == id->iface &&
 376                 kctl->id.device == id->device &&
 377                 kctl->id.subdevice == id->subdevice &&
 378                 !strncmp(kctl->id.name, id->name, sizeof(kctl->id.name)) &&
 379                 kctl->id.index <= id->index &&
 380                 kctl->id.index + kctl->count > id->index;
 381 }
 382
 383 #ifdef CONFIG_SND_CTL_FAST_LOOKUP
 384 /* Compute a hash key for the corresponding ctl id
 385  * It's for the name lookup, hence the numid is excluded.
 386  * The hash key is bound in LONG_MAX to be used for Xarray key.
 387  */
 388 #define MULTIPLIER      37
 389 static unsigned long get_ctl_id_hash(const struct snd_ctl_elem_id *id)
 390 {
 391         int i;
 392         unsigned long h;
 393
 394         h = id->iface;
 395         h = MULTIPLIER * h + id->device;
 396         h = MULTIPLIER * h + id->subdevice;
 397         for (i = 0; i < SNDRV_CTL_ELEM_ID_NAME_MAXLEN && id->name[i]; i++)
 398                 h = MULTIPLIER * h + id->name[i];
 399         h = MULTIPLIER * h + id->index;
 400         h &= LONG_MAX;
 401         return h;
 402 }
 403
 404 /* add hash entries to numid and ctl xarray tables */
 405 static void add_hash_entries(struct snd_card *card,
 406                              struct snd_kcontrol *kcontrol)
 407 {
 408         struct snd_ctl_elem_id id = kcontrol->id;
 409         int i;
 410
 411         xa_store_range(&card->ctl_numids, kcontrol->id.numid,
 412                        kcontrol->id.numid + kcontrol->count - 1,
 413                        kcontrol, GFP_KERNEL);
 414
 415         for (i = 0; i < kcontrol->count; i++) {
 416                 id.index = kcontrol->id.index + i;
 417                 if (xa_insert(&card->ctl_hash, get_ctl_id_hash(&id),
 418                               kcontrol, GFP_KERNEL)) {
 419                         /* skip hash for this entry, noting we had collision */
 420                         card->ctl_hash_collision = true;
 421                         dev_dbg(card->dev, "ctl_hash collision %d:%s:%d\n",
 422                                 id.iface, id.name, id.index);
 423                 }
 424         }
 425 }
 426
 427 /* remove hash entries that have been added */
 428 static void remove_hash_entries(struct snd_card *card,
 429                                 struct snd_kcontrol *kcontrol)
 430 {
 431         struct snd_ctl_elem_id id = kcontrol->id;
 432         struct snd_kcontrol *matched;
 433         unsigned long h;
 434         int i;
 435
 436         for (i = 0; i < kcontrol->count; i++) {
 437                 xa_erase(&card->ctl_numids, id.numid);
 438                 h = get_ctl_id_hash(&id);
 439                 matched = xa_load(&card->ctl_hash, h);
 440                 if (matched && (matched == kcontrol ||
 441                                 elem_id_matches(matched, &id)))
 442                         xa_erase(&card->ctl_hash, h);
 443                 id.index++;
 444                 id.numid++;
 445         }
 446 }
 447 #else /* CONFIG_SND_CTL_FAST_LOOKUP */
 448 static inline void add_hash_entries(struct snd_card *card,
 449                                     struct snd_kcontrol *kcontrol)
 450 {
 451 }
 452 static inline void remove_hash_entries(struct snd_card *card,
 453                                        struct snd_kcontrol *kcontrol)
 454 {
 455 }
 456 #endif /* CONFIG_SND_CTL_FAST_LOOKUP */
 457
 458 enum snd_ctl_add_mode {
 459         CTL_ADD_EXCLUSIVE, CTL_REPLACE, CTL_ADD_ON_REPLACE,
 460 };
 461
 462 /* add/replace a new kcontrol object; call with card->controls_rwsem locked */
 463 static int __snd_ctl_add_replace(struct snd_card *card,
 464                                  struct snd_kcontrol *kcontrol,
 465                                  enum snd_ctl_add_mode mode)
 466 {
 467         struct snd_ctl_elem_id id;
 468         unsigned int idx;
 469         struct snd_kcontrol *old;
 470         int err;
 471
 472         lockdep_assert_held_write(&card->controls_rwsem);
 473
 474         id = kcontrol->id;
 475         if (id.index > UINT_MAX - kcontrol->count)
 476                 return -EINVAL;
 477
 478         old = snd_ctl_find_id_locked(card, &id);
 479         if (!old) {
 480                 if (mode == CTL_REPLACE)
 481                         return -EINVAL;
 482         } else {
 483                 if (mode == CTL_ADD_EXCLUSIVE) {
 484                         dev_err(card->dev,
 485                                 "control %i:%i:%i:%s:%i is already present\n",
 486                                 id.iface, id.device, id.subdevice, id.name,
 487                                 id.index);
 488                         return -EBUSY;
 489                 }
 490
 491                 err = snd_ctl_remove_locked(card, old);
 492                 if (err < 0)
 493                         return err;
 494         }
 495
 496         if (snd_ctl_find_hole(card, kcontrol->count) < 0)
 497                 return -ENOMEM;
 498
 499         list_add_tail(&kcontrol->list, &card->controls);
 500         card->controls_count += kcontrol->count;
 501         kcontrol->id.numid = card->last_numid + 1;
 502         card->last_numid += kcontrol->count;
 503
 504         add_hash_entries(card, kcontrol);
 505
 506         for (idx = 0; idx < kcontrol->count; idx++)
 507                 snd_ctl_notify_one(card, SNDRV_CTL_EVENT_MASK_ADD, kcontrol, idx);
 508
 509         return 0;
 510 }
 511
 512 static int snd_ctl_add_replace(struct snd_card *card,
 513                                struct snd_kcontrol *kcontrol,
 514                                enum snd_ctl_add_mode mode)
 515 {
 516         int err = -EINVAL;
 517
 518         if (! kcontrol)
 519                 return err;
 520         if (snd_BUG_ON(!card || !kcontrol->info))
 521                 goto error;
 522
 523         down_write(&card->controls_rwsem);
 524         err = __snd_ctl_add_replace(card, kcontrol, mode);
 525         up_write(&card->controls_rwsem);
 526         if (err < 0)
 527                 goto error;
 528         return 0;
 529
 530  error:
 531         snd_ctl_free_one(kcontrol);
 532         return err;
 533 }
 534
 535 /**
 536  * snd_ctl_add - add the control instance to the card
 537  * @card: the card instance
 538  * @kcontrol: the control instance to add
 539  *
 540  * Adds the control instance created via snd_ctl_new() or
 541  * snd_ctl_new1() to the given card. Assigns also an unique
 542  * numid used for fast search.
 543  *
 544  * It frees automatically the control which cannot be added.
 545  *
 546  * Return: Zero if successful, or a negative error code on failure.
 547  *
 548  */
 549 int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol)
 550 {
 551         return snd_ctl_add_replace(card, kcontrol, CTL_ADD_EXCLUSIVE);
 552 }
 553 EXPORT_SYMBOL(snd_ctl_add);
 554
 555 /**
 556  * snd_ctl_replace - replace the control instance of the card
 557  * @card: the card instance
 558  * @kcontrol: the control instance to replace
 559  * @add_on_replace: add the control if not already added
 560  *
 561  * Replaces the given control.  If the given control does not exist
 562  * and the add_on_replace flag is set, the control is added.  If the
 563  * control exists, it is destroyed first.
 564  *
 565  * It frees automatically the control which cannot be added or replaced.
 566  *
 567  * Return: Zero if successful, or a negative error code on failure.
 568  */
 569 int snd_ctl_replace(struct snd_card *card, struct snd_kcontrol *kcontrol,
 570                     bool add_on_replace)
 571 {
 572         return snd_ctl_add_replace(card, kcontrol,
 573                                    add_on_replace ? CTL_ADD_ON_REPLACE : CTL_REPLACE);
 574 }
 575 EXPORT_SYMBOL(snd_ctl_replace);
 576
 577 static int __snd_ctl_remove(struct snd_card *card,
 578                             struct snd_kcontrol *kcontrol,
 579                             bool remove_hash)
 580 {
 581         unsigned int idx;
 582
 583         lockdep_assert_held_write(&card->controls_rwsem);
 584
 585         if (snd_BUG_ON(!card || !kcontrol))
 586                 return -EINVAL;
 587         list_del(&kcontrol->list);
 588
 589         if (remove_hash)
 590                 remove_hash_entries(card, kcontrol);
 591
 592         card->controls_count -= kcontrol->count;
 593         for (idx = 0; idx < kcontrol->count; idx++)
 594                 snd_ctl_notify_one(card, SNDRV_CTL_EVENT_MASK_REMOVE, kcontrol, idx);
 595         snd_ctl_free_one(kcontrol);
 596         return 0;
 597 }
 598
 599 static inline int snd_ctl_remove_locked(struct snd_card *card,
 600                                         struct snd_kcontrol *kcontrol)
 601 {
 602         return __snd_ctl_remove(card, kcontrol, true);
 603 }
 604
 605 /**
 606  * snd_ctl_remove - remove the control from the card and release it
 607  * @card: the card instance
 608  * @kcontrol: the control instance to remove
 609  *
 610  * Removes the control from the card and then releases the instance.
 611  * You don't need to call snd_ctl_free_one().
 612  *
 613  * Return: 0 if successful, or a negative error code on failure.
 614  *
 615  * Note that this function takes card->controls_rwsem lock internally.
 616  */
 617 int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol)
 618 {
 619         int ret;
 620
 621         down_write(&card->controls_rwsem);
 622         ret = snd_ctl_remove_locked(card, kcontrol);
 623         up_write(&card->controls_rwsem);
 624         return ret;
 625 }
 626 EXPORT_SYMBOL(snd_ctl_remove);
 627
 628 /**
 629  * snd_ctl_remove_id - remove the control of the given id and release it
 630  * @card: the card instance
 631  * @id: the control id to remove
 632  *
 633  * Finds the control instance with the given id, removes it from the
 634  * card list and releases it.
 635  *
 636  * Return: 0 if successful, or a negative error code on failure.
 637  */
 638 int snd_ctl_remove_id(struct snd_card *card, struct snd_ctl_elem_id *id)
 639 {
 640         struct snd_kcontrol *kctl;
 641         int ret;
 642
 643         down_write(&card->controls_rwsem);
 644         kctl = snd_ctl_find_id_locked(card, id);
 645         if (kctl == NULL) {
 646                 up_write(&card->controls_rwsem);
 647                 return -ENOENT;
 648         }
 649         ret = snd_ctl_remove_locked(card, kctl);
 650         up_write(&card->controls_rwsem);
 651         return ret;
 652 }
 653 EXPORT_SYMBOL(snd_ctl_remove_id);
 654
 655 /**
 656  * snd_ctl_remove_user_ctl - remove and release the unlocked user control
 657  * @file: active control handle
 658  * @id: the control id to remove
 659  *
 660  * Finds the control instance with the given id, removes it from the
 661  * card list and releases it.
 662  *
 663  * Return: 0 if successful, or a negative error code on failure.
 664  */
 665 static int snd_ctl_remove_user_ctl(struct snd_ctl_file * file,
 666                                    struct snd_ctl_elem_id *id)
 667 {
 668         struct snd_card *card = file->card;
 669         struct snd_kcontrol *kctl;
 670         int idx, ret;
 671
 672         down_write(&card->controls_rwsem);
 673         kctl = snd_ctl_find_id_locked(card, id);
 674         if (kctl == NULL) {
 675                 ret = -ENOENT;
 676                 goto error;
 677         }
 678         if (!(kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_USER)) {
 679                 ret = -EINVAL;
 680                 goto error;
 681         }
 682         for (idx = 0; idx < kctl->count; idx++)
 683                 if (kctl->vd[idx].owner != NULL && kctl->vd[idx].owner != file) {
 684                         ret = -EBUSY;
 685                         goto error;
 686                 }
 687         ret = snd_ctl_remove_locked(card, kctl);
 688 error:
 689         up_write(&card->controls_rwsem);
 690         return ret;
 691 }
 692
 693 /**
 694  * snd_ctl_activate_id - activate/inactivate the control of the given id
 695  * @card: the card instance
 696  * @id: the control id to activate/inactivate
 697  * @active: non-zero to activate
 698  *
 699  * Finds the control instance with the given id, and activate or
 700  * inactivate the control together with notification, if changed.
 701  * The given ID data is filled with full information.
 702  *
 703  * Return: 0 if unchanged, 1 if changed, or a negative error code on failure.
 704  */
 705 int snd_ctl_activate_id(struct snd_card *card, struct snd_ctl_elem_id *id,
 706                         int active)
 707 {
 708         struct snd_kcontrol *kctl;
 709         struct snd_kcontrol_volatile *vd;
 710         unsigned int index_offset;
 711         int ret;
 712
 713         down_write(&card->controls_rwsem);
 714         kctl = snd_ctl_find_id_locked(card, id);
 715         if (kctl == NULL) {
 716                 ret = -ENOENT;
 717                 goto unlock;
 718         }
 719         index_offset = snd_ctl_get_ioff(kctl, id);
 720         vd = &kctl->vd[index_offset];
 721         ret = 0;
 722         if (active) {
 723                 if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_INACTIVE))
 724                         goto unlock;
 725                 vd->access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
 726         } else {
 727                 if (vd->access & SNDRV_CTL_ELEM_ACCESS_INACTIVE)
 728                         goto unlock;
 729                 vd->access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
 730         }
 731         snd_ctl_build_ioff(id, kctl, index_offset);
 732         downgrade_write(&card->controls_rwsem);
 733         snd_ctl_notify_one(card, SNDRV_CTL_EVENT_MASK_INFO, kctl, index_offset);
 734         up_read(&card->controls_rwsem);
 735         return 1;
 736
 737  unlock:
 738         up_write(&card->controls_rwsem);
 739         return ret;
 740 }
 741 EXPORT_SYMBOL_GPL(snd_ctl_activate_id);
 742
 743 /**
 744  * snd_ctl_rename_id - replace the id of a control on the card
 745  * @card: the card instance
 746  * @src_id: the old id
 747  * @dst_id: the new id
 748  *
 749  * Finds the control with the old id from the card, and replaces the
 750  * id with the new one.
 751  *
 752  * The function tries to keep the already assigned numid while replacing
 753  * the rest.
 754  *
 755  * Note that this function should be used only in the card initialization
 756  * phase.  Calling after the card instantiation may cause issues with
 757  * user-space expecting persistent numids.
 758  *
 759  * Return: Zero if successful, or a negative error code on failure.
 760  */
 761 int snd_ctl_rename_id(struct snd_card *card, struct snd_ctl_elem_id *src_id,
 762                       struct snd_ctl_elem_id *dst_id)
 763 {
 764         struct snd_kcontrol *kctl;
 765         int saved_numid;
 766
 767         down_write(&card->controls_rwsem);
 768         kctl = snd_ctl_find_id_locked(card, src_id);
 769         if (kctl == NULL) {
 770                 up_write(&card->controls_rwsem);
 771                 return -ENOENT;
 772         }
 773         saved_numid = kctl->id.numid;
 774         remove_hash_entries(card, kctl);
 775         kctl->id = *dst_id;
 776         kctl->id.numid = saved_numid;
 777         add_hash_entries(card, kctl);
 778         up_write(&card->controls_rwsem);
 779         return 0;
 780 }
 781 EXPORT_SYMBOL(snd_ctl_rename_id);
 782
 783 /**
 784  * snd_ctl_rename - rename the control on the card
 785  * @card: the card instance
 786  * @kctl: the control to rename
 787  * @name: the new name
 788  *
 789  * Renames the specified control on the card to the new name.
 790  *
 791  * Note that this function takes card->controls_rwsem lock internally.
 792  */
 793 void snd_ctl_rename(struct snd_card *card, struct snd_kcontrol *kctl,
 794                     const char *name)
 795 {
 796         down_write(&card->controls_rwsem);
 797         remove_hash_entries(card, kctl);
 798
 799         if (strscpy(kctl->id.name, name, sizeof(kctl->id.name)) < 0)
 800                 pr_warn("ALSA: Renamed control new name '%s' truncated to '%s'\n",
 801                         name, kctl->id.name);
 802
 803         add_hash_entries(card, kctl);
 804         up_write(&card->controls_rwsem);
 805 }
 806 EXPORT_SYMBOL(snd_ctl_rename);
 807
 808 #ifndef CONFIG_SND_CTL_FAST_LOOKUP
 809 static struct snd_kcontrol *
 810 snd_ctl_find_numid_slow(struct snd_card *card, unsigned int numid)
 811 {
 812         struct snd_kcontrol *kctl;
 813
 814         list_for_each_entry(kctl, &card->controls, list) {
 815                 if (kctl->id.numid <= numid && kctl->id.numid + kctl->count > numid)
 816                         return kctl;
 817         }
 818         return NULL;
 819 }
 820 #endif /* !CONFIG_SND_CTL_FAST_LOOKUP */
 821
 822 /**
 823  * snd_ctl_find_numid_locked - find the control instance with the given number-id
 824  * @card: the card instance
 825  * @numid: the number-id to search
 826  *
 827  * Finds the control instance with the given number-id from the card.
 828  *
 829  * The caller must down card->controls_rwsem before calling this function
 830  * (if the race condition can happen).
 831  *
 832  * Return: The pointer of the instance if found, or %NULL if not.
 833  */
 834 struct snd_kcontrol *
 835 snd_ctl_find_numid_locked(struct snd_card *card, unsigned int numid)
 836 {
 837         if (snd_BUG_ON(!card || !numid))
 838                 return NULL;
 839         lockdep_assert_held(&card->controls_rwsem);
 840 #ifdef CONFIG_SND_CTL_FAST_LOOKUP
 841         return xa_load(&card->ctl_numids, numid);
 842 #else
 843         return snd_ctl_find_numid_slow(card, numid);
 844 #endif
 845 }
 846 EXPORT_SYMBOL(snd_ctl_find_numid_locked);
 847
 848 /**
 849  * snd_ctl_find_numid - find the control instance with the given number-id
 850  * @card: the card instance
 851  * @numid: the number-id to search
 852  *
 853  * Finds the control instance with the given number-id from the card.
 854  *
 855  * Return: The pointer of the instance if found, or %NULL if not.
 856  *
 857  * Note that this function takes card->controls_rwsem lock internally.
 858  */
 859 struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card,
 860                                         unsigned int numid)
 861 {
 862         struct snd_kcontrol *kctl;
 863
 864         down_read(&card->controls_rwsem);
 865         kctl = snd_ctl_find_numid_locked(card, numid);
 866         up_read(&card->controls_rwsem);
 867         return kctl;
 868 }
 869 EXPORT_SYMBOL(snd_ctl_find_numid);
 870
 871 /**
 872  * snd_ctl_find_id_locked - find the control instance with the given id
 873  * @card: the card instance
 874  * @id: the id to search
 875  *
 876  * Finds the control instance with the given id from the card.
 877  *
 878  * The caller must down card->controls_rwsem before calling this function
 879  * (if the race condition can happen).
 880  *
 881  * Return: The pointer of the instance if found, or %NULL if not.
 882  */
 883 struct snd_kcontrol *snd_ctl_find_id_locked(struct snd_card *card,
 884                                             const struct snd_ctl_elem_id *id)
 885 {
 886         struct snd_kcontrol *kctl;
 887
 888         if (snd_BUG_ON(!card || !id))
 889                 return NULL;
 890         lockdep_assert_held(&card->controls_rwsem);
 891         if (id->numid != 0)
 892                 return snd_ctl_find_numid_locked(card, id->numid);
 893 #ifdef CONFIG_SND_CTL_FAST_LOOKUP
 894         kctl = xa_load(&card->ctl_hash, get_ctl_id_hash(id));
 895         if (kctl && elem_id_matches(kctl, id))
 896                 return kctl;
 897         if (!card->ctl_hash_collision)
 898                 return NULL; /* we can rely on only hash table */
 899 #endif
 900         /* no matching in hash table - try all as the last resort */
 901         list_for_each_entry(kctl, &card->controls, list)
 902                 if (elem_id_matches(kctl, id))
 903                         return kctl;
 904
 905         return NULL;
 906 }
 907 EXPORT_SYMBOL(snd_ctl_find_id_locked);
 908
 909 /**
 910  * snd_ctl_find_id - find the control instance with the given id
 911  * @card: the card instance
 912  * @id: the id to search
 913  *
 914  * Finds the control instance with the given id from the card.
 915  *
 916  * Return: The pointer of the instance if found, or %NULL if not.
 917  *
 918  * Note that this function takes card->controls_rwsem lock internally.
 919  */
 920 struct snd_kcontrol *snd_ctl_find_id(struct snd_card *card,
 921                                      const struct snd_ctl_elem_id *id)
 922 {
 923         struct snd_kcontrol *kctl;
 924
 925         down_read(&card->controls_rwsem);
 926         kctl = snd_ctl_find_id_locked(card, id);
 927         up_read(&card->controls_rwsem);
 928         return kctl;
 929 }
 930 EXPORT_SYMBOL(snd_ctl_find_id);
 931
 932 static int snd_ctl_card_info(struct snd_card *card, struct snd_ctl_file * ctl,
 933                              unsigned int cmd, void __user *arg)
 934 {
 935         struct snd_ctl_card_info *info;
 936
 937         info = kzalloc(sizeof(*info), GFP_KERNEL);
 938         if (! info)
 939                 return -ENOMEM;
 940         down_read(&snd_ioctl_rwsem);
 941         info->card = card->number;
 942         strscpy(info->id, card->id, sizeof(info->id));
 943         strscpy(info->driver, card->driver, sizeof(info->driver));
 944         strscpy(info->name, card->shortname, sizeof(info->name));
 945         strscpy(info->longname, card->longname, sizeof(info->longname));
 946         strscpy(info->mixername, card->mixername, sizeof(info->mixername));
 947         strscpy(info->components, card->components, sizeof(info->components));
 948         up_read(&snd_ioctl_rwsem);
 949         if (copy_to_user(arg, info, sizeof(struct snd_ctl_card_info))) {
 950                 kfree(info);
 951                 return -EFAULT;
 952         }
 953         kfree(info);
 954         return 0;
 955 }
 956
 957 static int snd_ctl_elem_list(struct snd_card *card,
 958                              struct snd_ctl_elem_list *list)
 959 {
 960         struct snd_kcontrol *kctl;
 961         struct snd_ctl_elem_id id;
 962         unsigned int offset, space, jidx;
 963         int err = 0;
 964
 965         offset = list->offset;
 966         space = list->space;
 967
 968         down_read(&card->controls_rwsem);
 969         list->count = card->controls_count;
 970         list->used = 0;
 971         if (space > 0) {
 972                 list_for_each_entry(kctl, &card->controls, list) {
 973                         if (offset >= kctl->count) {
 974                                 offset -= kctl->count;
 975                                 continue;
 976                         }
 977                         for (jidx = offset; jidx < kctl->count; jidx++) {
 978                                 snd_ctl_build_ioff(&id, kctl, jidx);
 979                                 if (copy_to_user(list->pids + list->used, &id,
 980                                                  sizeof(id))) {
 981                                         err = -EFAULT;
 982                                         goto out;
 983                                 }
 984                                 list->used++;
 985                                 if (!--space)
 986                                         goto out;
 987                         }
 988                         offset = 0;
 989                 }
 990         }
 991  out:
 992         up_read(&card->controls_rwsem);
 993         return err;
 994 }
 995
 996 static int snd_ctl_elem_list_user(struct snd_card *card,
 997                                   struct snd_ctl_elem_list __user *_list)
 998 {
 999         struct snd_ctl_elem_list list;
1000         int err;
1001
1002         if (copy_from_user(&list, _list, sizeof(list)))
1003                 return -EFAULT;
1004         err = snd_ctl_elem_list(card, &list);
1005         if (err)
1006                 return err;
1007         if (copy_to_user(_list, &list, sizeof(list)))
1008                 return -EFAULT;
1009
1010         return 0;
1011 }
1012
1013 /* Check whether the given kctl info is valid */
1014 static int snd_ctl_check_elem_info(struct snd_card *card,
1015                                    const struct snd_ctl_elem_info *info)
1016 {
1017         static const unsigned int max_value_counts[] = {
1018                 [SNDRV_CTL_ELEM_TYPE_BOOLEAN]   = 128,
1019                 [SNDRV_CTL_ELEM_TYPE_INTEGER]   = 128,
1020                 [SNDRV_CTL_ELEM_TYPE_ENUMERATED] = 128,
1021                 [SNDRV_CTL_ELEM_TYPE_BYTES]     = 512,
1022                 [SNDRV_CTL_ELEM_TYPE_IEC958]    = 1,
1023                 [SNDRV_CTL_ELEM_TYPE_INTEGER64] = 64,
1024         };
1025
1026         if (info->type < SNDRV_CTL_ELEM_TYPE_BOOLEAN ||
1027             info->type > SNDRV_CTL_ELEM_TYPE_INTEGER64) {
1028                 if (card)
1029                         dev_err(card->dev,
1030                                 "control %i:%i:%i:%s:%i: invalid type %d\n",
1031                                 info->id.iface, info->id.device,
1032                                 info->id.subdevice, info->id.name,
1033                                 info->id.index, info->type);
1034                 return -EINVAL;
1035         }
1036         if (info->type == SNDRV_CTL_ELEM_TYPE_ENUMERATED &&
1037             info->value.enumerated.items == 0) {
1038                 if (card)
1039                         dev_err(card->dev,
1040                                 "control %i:%i:%i:%s:%i: zero enum items\n",
1041                                 info->id.iface, info->id.device,
1042                                 info->id.subdevice, info->id.name,
1043                                 info->id.index);
1044                 return -EINVAL;
1045         }
1046         if (info->count > max_value_counts[info->type]) {
1047                 if (card)
1048                         dev_err(card->dev,
1049                                 "control %i:%i:%i:%s:%i: invalid count %d\n",
1050                                 info->id.iface, info->id.device,
1051                                 info->id.subdevice, info->id.name,
1052                                 info->id.index, info->count);
1053                 return -EINVAL;
1054         }
1055
1056         return 0;
1057 }
1058
1059 /* The capacity of struct snd_ctl_elem_value.value.*/
1060 static const unsigned int value_sizes[] = {
1061         [SNDRV_CTL_ELEM_TYPE_BOOLEAN]   = sizeof(long),
1062         [SNDRV_CTL_ELEM_TYPE_INTEGER]   = sizeof(long),
1063         [SNDRV_CTL_ELEM_TYPE_ENUMERATED] = sizeof(unsigned int),
1064         [SNDRV_CTL_ELEM_TYPE_BYTES]     = sizeof(unsigned char),
1065         [SNDRV_CTL_ELEM_TYPE_IEC958]    = sizeof(struct snd_aes_iec958),
1066         [SNDRV_CTL_ELEM_TYPE_INTEGER64] = sizeof(long long),
1067 };
1068
1069 /* fill the remaining snd_ctl_elem_value data with the given pattern */
1070 static void fill_remaining_elem_value(struct snd_ctl_elem_value *control,
1071                                       struct snd_ctl_elem_info *info,
1072                                       u32 pattern)
1073 {
1074         size_t offset = value_sizes[info->type] * info->count;
1075
1076         offset = DIV_ROUND_UP(offset, sizeof(u32));
1077         memset32((u32 *)control->value.bytes.data + offset, pattern,
1078                  sizeof(control->value) / sizeof(u32) - offset);
1079 }
1080
1081 /* check whether the given integer ctl value is valid */
1082 static int sanity_check_int_value(struct snd_card *card,
1083                                   const struct snd_ctl_elem_value *control,
1084                                   const struct snd_ctl_elem_info *info,
1085                                   int i, bool print_error)
1086 {
1087         long long lval, lmin, lmax, lstep;
1088         u64 rem;
1089
1090         switch (info->type) {
1091         default:
1092         case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
1093                 lval = control->value.integer.value[i];
1094                 lmin = 0;
1095                 lmax = 1;
1096                 lstep = 0;
1097                 break;
1098         case SNDRV_CTL_ELEM_TYPE_INTEGER:
1099                 lval = control->value.integer.value[i];
1100                 lmin = info->value.integer.min;
1101                 lmax = info->value.integer.max;
1102                 lstep = info->value.integer.step;
1103                 break;
1104         case SNDRV_CTL_ELEM_TYPE_INTEGER64:
1105                 lval = control->value.integer64.value[i];
1106                 lmin = info->value.integer64.min;
1107                 lmax = info->value.integer64.max;
1108                 lstep = info->value.integer64.step;
1109                 break;
1110         case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
1111                 lval = control->value.enumerated.item[i];
1112                 lmin = 0;
1113                 lmax = info->value.enumerated.items - 1;
1114                 lstep = 0;
1115                 break;
1116         }
1117
1118         if (lval < lmin || lval > lmax) {
1119                 if (print_error)
1120                         dev_err(card->dev,
1121                                 "control %i:%i:%i:%s:%i: value out of range %lld (%lld/%lld) at count %i\n",
1122                                 control->id.iface, control->id.device,
1123                                 control->id.subdevice, control->id.name,
1124                                 control->id.index, lval, lmin, lmax, i);
1125                 return -EINVAL;
1126         }
1127         if (lstep) {
1128                 div64_u64_rem(lval, lstep, &rem);
1129                 if (rem) {
1130                         if (print_error)
1131                                 dev_err(card->dev,
1132                                         "control %i:%i:%i:%s:%i: unaligned value %lld (step %lld) at count %i\n",
1133                                         control->id.iface, control->id.device,
1134                                         control->id.subdevice, control->id.name,
1135                                         control->id.index, lval, lstep, i);
1136                         return -EINVAL;
1137                 }
1138         }
1139
1140         return 0;
1141 }
1142
1143 /* check whether the all input values are valid for the given elem value */
1144 static int sanity_check_input_values(struct snd_card *card,
1145                                      const struct snd_ctl_elem_value *control,
1146                                      const struct snd_ctl_elem_info *info,
1147                                      bool print_error)
1148 {
1149         int i, ret;
1150
1151         switch (info->type) {
1152         case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
1153         case SNDRV_CTL_ELEM_TYPE_INTEGER:
1154         case SNDRV_CTL_ELEM_TYPE_INTEGER64:
1155         case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
1156                 for (i = 0; i < info->count; i++) {
1157                         ret = sanity_check_int_value(card, control, info, i,
1158                                                      print_error);
1159                         if (ret < 0)
1160                                 return ret;
1161                 }
1162                 break;
1163         default:
1164                 break;
1165         }
1166
1167         return 0;
1168 }
1169
1170 /* perform sanity checks to the given snd_ctl_elem_value object */
1171 static int sanity_check_elem_value(struct snd_card *card,
1172                                    const struct snd_ctl_elem_value *control,
1173                                    const struct snd_ctl_elem_info *info,
1174                                    u32 pattern)
1175 {
1176         size_t offset;
1177         int ret;
1178         u32 *p;
1179
1180         ret = sanity_check_input_values(card, control, info, true);
1181         if (ret < 0)
1182                 return ret;
1183
1184         /* check whether the remaining area kept untouched */
1185         offset = value_sizes[info->type] * info->count;
1186         offset = DIV_ROUND_UP(offset, sizeof(u32));
1187         p = (u32 *)control->value.bytes.data + offset;
1188         for (; offset < sizeof(control->value) / sizeof(u32); offset++, p++) {
1189                 if (*p != pattern) {
1190                         ret = -EINVAL;
1191                         break;
1192                 }
1193                 *p = 0; /* clear the checked area */
1194         }
1195
1196         return ret;
1197 }
1198
1199 static int __snd_ctl_elem_info(struct snd_card *card,
1200                                struct snd_kcontrol *kctl,
1201                                struct snd_ctl_elem_info *info,
1202                                struct snd_ctl_file *ctl)
1203 {
1204         struct snd_kcontrol_volatile *vd;
1205         unsigned int index_offset;
1206         int result;
1207
1208 #ifdef CONFIG_SND_DEBUG
1209         info->access = 0;
1210 #endif
1211         result = snd_power_ref_and_wait(card);
1212         if (!result)
1213                 result = kctl->info(kctl, info);
1214         snd_power_unref(card);
1215         if (result >= 0) {
1216                 snd_BUG_ON(info->access);
1217                 index_offset = snd_ctl_get_ioff(kctl, &info->id);
1218                 vd = &kctl->vd[index_offset];
1219                 snd_ctl_build_ioff(&info->id, kctl, index_offset);
1220                 info->access = vd->access;
1221                 if (vd->owner) {
1222                         info->access |= SNDRV_CTL_ELEM_ACCESS_LOCK;
1223                         if (vd->owner == ctl)
1224                                 info->access |= SNDRV_CTL_ELEM_ACCESS_OWNER;
1225                         info->owner = pid_vnr(vd->owner->pid);
1226                 } else {
1227                         info->owner = -1;
1228                 }
1229                 if (!snd_ctl_skip_validation(info) &&
1230                     snd_ctl_check_elem_info(card, info) < 0)
1231                         result = -EINVAL;
1232         }
1233         return result;
1234 }
1235
1236 static int snd_ctl_elem_info(struct snd_ctl_file *ctl,
1237                              struct snd_ctl_elem_info *info)
1238 {
1239         struct snd_card *card = ctl->card;
1240         struct snd_kcontrol *kctl;
1241         int result;
1242
1243         down_read(&card->controls_rwsem);
1244         kctl = snd_ctl_find_id_locked(card, &info->id);
1245         if (kctl == NULL)
1246                 result = -ENOENT;
1247         else
1248                 result = __snd_ctl_elem_info(card, kctl, info, ctl);
1249         up_read(&card->controls_rwsem);
1250         return result;
1251 }
1252
1253 static int snd_ctl_elem_info_user(struct snd_ctl_file *ctl,
1254                                   struct snd_ctl_elem_info __user *_info)
1255 {
1256         struct snd_ctl_elem_info info;
1257         int result;
1258
1259         if (copy_from_user(&info, _info, sizeof(info)))
1260                 return -EFAULT;
1261         result = snd_ctl_elem_info(ctl, &info);
1262         if (result < 0)
1263                 return result;
1264         /* drop internal access flags */
1265         info.access &= ~(SNDRV_CTL_ELEM_ACCESS_SKIP_CHECK|
1266                          SNDRV_CTL_ELEM_ACCESS_LED_MASK);
1267         if (copy_to_user(_info, &info, sizeof(info)))
1268                 return -EFAULT;
1269         return result;
1270 }
1271
1272 static int snd_ctl_elem_read(struct snd_card *card,
1273                              struct snd_ctl_elem_value *control)
1274 {
1275         struct snd_kcontrol *kctl;
1276         struct snd_kcontrol_volatile *vd;
1277         unsigned int index_offset;
1278         struct snd_ctl_elem_info info;
1279         const u32 pattern = 0xdeadbeef;
1280         int ret;
1281
1282         down_read(&card->controls_rwsem);
1283         kctl = snd_ctl_find_id_locked(card, &control->id);
1284         if (kctl == NULL) {
1285                 ret = -ENOENT;
1286                 goto unlock;
1287         }
1288
1289         index_offset = snd_ctl_get_ioff(kctl, &control->id);
1290         vd = &kctl->vd[index_offset];
1291         if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_READ) || kctl->get == NULL) {
1292                 ret = -EPERM;
1293                 goto unlock;
1294         }
1295
1296         snd_ctl_build_ioff(&control->id, kctl, index_offset);
1297
1298 #ifdef CONFIG_SND_CTL_DEBUG
1299         /* info is needed only for validation */
1300         memset(&info, 0, sizeof(info));
1301         info.id = control->id;
1302         ret = __snd_ctl_elem_info(card, kctl, &info, NULL);
1303         if (ret < 0)
1304                 goto unlock;
1305 #endif
1306
1307         if (!snd_ctl_skip_validation(&info))
1308                 fill_remaining_elem_value(control, &info, pattern);
1309         ret = snd_power_ref_and_wait(card);
1310         if (!ret)
1311                 ret = kctl->get(kctl, control);
1312         snd_power_unref(card);
1313         if (ret < 0)
1314                 goto unlock;
1315         if (!snd_ctl_skip_validation(&info) &&
1316             sanity_check_elem_value(card, control, &info, pattern) < 0) {
1317                 dev_err(card->dev,
1318                         "control %i:%i:%i:%s:%i: access overflow\n",
1319                         control->id.iface, control->id.device,
1320                         control->id.subdevice, control->id.name,
1321                         control->id.index);
1322                 ret = -EINVAL;
1323                 goto unlock;
1324         }
1325 unlock:
1326         up_read(&card->controls_rwsem);
1327         return ret;
1328 }
1329
1330 static int snd_ctl_elem_read_user(struct snd_card *card,
1331                                   struct snd_ctl_elem_value __user *_control)
1332 {
1333         struct snd_ctl_elem_value *control;
1334         int result;
1335
1336         control = memdup_user(_control, sizeof(*control));
1337         if (IS_ERR(control))
1338                 return PTR_ERR(control);
1339
1340         result = snd_ctl_elem_read(card, control);
1341         if (result < 0)
1342                 goto error;
1343
1344         if (copy_to_user(_control, control, sizeof(*control)))
1345                 result = -EFAULT;
1346  error:
1347         kfree(control);
1348         return result;
1349 }
1350
1351 static int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file,
1352                               struct snd_ctl_elem_value *control)
1353 {
1354         struct snd_kcontrol *kctl;
1355         struct snd_kcontrol_volatile *vd;
1356         unsigned int index_offset;
1357         int result;
1358
1359         down_write(&card->controls_rwsem);
1360         kctl = snd_ctl_find_id_locked(card, &control->id);
1361         if (kctl == NULL) {
1362                 up_write(&card->controls_rwsem);
1363                 return -ENOENT;
1364         }
1365
1366         index_offset = snd_ctl_get_ioff(kctl, &control->id);
1367         vd = &kctl->vd[index_offset];
1368         if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_WRITE) || kctl->put == NULL ||
1369             (file && vd->owner && vd->owner != file)) {
1370                 up_write(&card->controls_rwsem);
1371                 return -EPERM;
1372         }
1373
1374         snd_ctl_build_ioff(&control->id, kctl, index_offset);
1375         result = snd_power_ref_and_wait(card);
1376         /* validate input values */
1377         if (IS_ENABLED(CONFIG_SND_CTL_INPUT_VALIDATION) && !result) {
1378                 struct snd_ctl_elem_info info;
1379
1380                 memset(&info, 0, sizeof(info));
1381                 info.id = control->id;
1382                 result = __snd_ctl_elem_info(card, kctl, &info, NULL);
1383                 if (!result)
1384                         result = sanity_check_input_values(card, control, &info,
1385                                                            false);
1386         }
1387         if (!result)
1388                 result = kctl->put(kctl, control);
1389         snd_power_unref(card);
1390         if (result < 0) {
1391                 up_write(&card->controls_rwsem);
1392                 return result;
1393         }
1394
1395         if (result > 0) {
1396                 downgrade_write(&card->controls_rwsem);
1397                 snd_ctl_notify_one(card, SNDRV_CTL_EVENT_MASK_VALUE, kctl, index_offset);
1398                 up_read(&card->controls_rwsem);
1399         } else {
1400                 up_write(&card->controls_rwsem);
1401         }
1402
1403         return 0;
1404 }
1405
1406 static int snd_ctl_elem_write_user(struct snd_ctl_file *file,
1407                                    struct snd_ctl_elem_value __user *_control)
1408 {
1409         struct snd_ctl_elem_value *control;
1410         struct snd_card *card;
1411         int result;
1412
1413         control = memdup_user(_control, sizeof(*control));
1414         if (IS_ERR(control))
1415                 return PTR_ERR(control);
1416
1417         card = file->card;
1418         result = snd_ctl_elem_write(card, file, control);
1419         if (result < 0)
1420                 goto error;
1421
1422         if (copy_to_user(_control, control, sizeof(*control)))
1423                 result = -EFAULT;
1424  error:
1425         kfree(control);
1426         return result;
1427 }
1428
1429 static int snd_ctl_elem_lock(struct snd_ctl_file *file,
1430                              struct snd_ctl_elem_id __user *_id)
1431 {
1432         struct snd_card *card = file->card;
1433         struct snd_ctl_elem_id id;
1434         struct snd_kcontrol *kctl;
1435         struct snd_kcontrol_volatile *vd;
1436         int result;
1437
1438         if (copy_from_user(&id, _id, sizeof(id)))
1439                 return -EFAULT;
1440         down_write(&card->controls_rwsem);
1441         kctl = snd_ctl_find_id_locked(card, &id);
1442         if (kctl == NULL) {
1443                 result = -ENOENT;
1444         } else {
1445                 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
1446                 if (vd->owner != NULL)
1447                         result = -EBUSY;
1448                 else {
1449                         vd->owner = file;
1450                         result = 0;
1451                 }
1452         }
1453         up_write(&card->controls_rwsem);
1454         return result;
1455 }
1456
1457 static int snd_ctl_elem_unlock(struct snd_ctl_file *file,
1458                                struct snd_ctl_elem_id __user *_id)
1459 {
1460         struct snd_card *card = file->card;
1461         struct snd_ctl_elem_id id;
1462         struct snd_kcontrol *kctl;
1463         struct snd_kcontrol_volatile *vd;
1464         int result;
1465
1466         if (copy_from_user(&id, _id, sizeof(id)))
1467                 return -EFAULT;
1468         down_write(&card->controls_rwsem);
1469         kctl = snd_ctl_find_id_locked(card, &id);
1470         if (kctl == NULL) {
1471                 result = -ENOENT;
1472         } else {
1473                 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
1474                 if (vd->owner == NULL)
1475                         result = -EINVAL;
1476                 else if (vd->owner != file)
1477                         result = -EPERM;
1478                 else {
1479                         vd->owner = NULL;
1480                         result = 0;
1481                 }
1482         }
1483         up_write(&card->controls_rwsem);
1484         return result;
1485 }
1486
1487 struct user_element {
1488         struct snd_ctl_elem_info info;
1489         struct snd_card *card;
1490         char *elem_data;                /* element data */
1491         unsigned long elem_data_size;   /* size of element data in bytes */
1492         void *tlv_data;                 /* TLV data */
1493         unsigned long tlv_data_size;    /* TLV data size */
1494         void *priv_data;                /* private data (like strings for enumerated type) */
1495 };
1496
1497 // check whether the addition (in bytes) of user ctl element may overflow the limit.
1498 static bool check_user_elem_overflow(struct snd_card *card, ssize_t add)
1499 {
1500         return (ssize_t)card->user_ctl_alloc_size + add > max_user_ctl_alloc_size;
1501 }
1502
1503 static int snd_ctl_elem_user_info(struct snd_kcontrol *kcontrol,
1504                                   struct snd_ctl_elem_info *uinfo)
1505 {
1506         struct user_element *ue = kcontrol->private_data;
1507         unsigned int offset;
1508
1509         offset = snd_ctl_get_ioff(kcontrol, &uinfo->id);
1510         *uinfo = ue->info;
1511         snd_ctl_build_ioff(&uinfo->id, kcontrol, offset);
1512
1513         return 0;
1514 }
1515
1516 static int snd_ctl_elem_user_enum_info(struct snd_kcontrol *kcontrol,
1517                                        struct snd_ctl_elem_info *uinfo)
1518 {
1519         struct user_element *ue = kcontrol->private_data;
1520         const char *names;
1521         unsigned int item;
1522         unsigned int offset;
1523
1524         item = uinfo->value.enumerated.item;
1525
1526         offset = snd_ctl_get_ioff(kcontrol, &uinfo->id);
1527         *uinfo = ue->info;
1528         snd_ctl_build_ioff(&uinfo->id, kcontrol, offset);
1529
1530         item = min(item, uinfo->value.enumerated.items - 1);
1531         uinfo->value.enumerated.item = item;
1532
1533         names = ue->priv_data;
1534         for (; item > 0; --item)
1535                 names += strlen(names) + 1;
1536         strcpy(uinfo->value.enumerated.name, names);
1537
1538         return 0;
1539 }
1540
1541 static int snd_ctl_elem_user_get(struct snd_kcontrol *kcontrol,
1542                                  struct snd_ctl_elem_value *ucontrol)
1543 {
1544         struct user_element *ue = kcontrol->private_data;
1545         unsigned int size = ue->elem_data_size;
1546         char *src = ue->elem_data +
1547                         snd_ctl_get_ioff(kcontrol, &ucontrol->id) * size;
1548
1549         memcpy(&ucontrol->value, src, size);
1550         return 0;
1551 }
1552
1553 static int snd_ctl_elem_user_put(struct snd_kcontrol *kcontrol,
1554                                  struct snd_ctl_elem_value *ucontrol)
1555 {
1556         int change;
1557         struct user_element *ue = kcontrol->private_data;
1558         unsigned int size = ue->elem_data_size;
1559         char *dst = ue->elem_data +
1560                         snd_ctl_get_ioff(kcontrol, &ucontrol->id) * size;
1561
1562         change = memcmp(&ucontrol->value, dst, size) != 0;
1563         if (change)
1564                 memcpy(dst, &ucontrol->value, size);
1565         return change;
1566 }
1567
1568 /* called in controls_rwsem write lock */
1569 static int replace_user_tlv(struct snd_kcontrol *kctl, unsigned int __user *buf,
1570                             unsigned int size)
1571 {
1572         struct user_element *ue = kctl->private_data;
1573         unsigned int *container;
1574         unsigned int mask = 0;
1575         int i;
1576         int change;
1577
1578         lockdep_assert_held_write(&ue->card->controls_rwsem);
1579
1580         if (size > 1024 * 128)  /* sane value */
1581                 return -EINVAL;
1582
1583         // does the TLV size change cause overflow?
1584         if (check_user_elem_overflow(ue->card, (ssize_t)(size - ue->tlv_data_size)))
1585                 return -ENOMEM;
1586
1587         container = vmemdup_user(buf, size);
1588         if (IS_ERR(container))
1589                 return PTR_ERR(container);
1590
1591         change = ue->tlv_data_size != size;
1592         if (!change)
1593                 change = memcmp(ue->tlv_data, container, size) != 0;
1594         if (!change) {
1595                 kvfree(container);
1596                 return 0;
1597         }
1598
1599         if (ue->tlv_data == NULL) {
1600                 /* Now TLV data is available. */
1601                 for (i = 0; i < kctl->count; ++i)
1602                         kctl->vd[i].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
1603                 mask = SNDRV_CTL_EVENT_MASK_INFO;
1604         } else {
1605                 ue->card->user_ctl_alloc_size -= ue->tlv_data_size;
1606                 ue->tlv_data_size = 0;
1607                 kvfree(ue->tlv_data);
1608         }
1609
1610         ue->tlv_data = container;
1611         ue->tlv_data_size = size;
1612         // decremented at private_free.
1613         ue->card->user_ctl_alloc_size += size;
1614
1615         mask |= SNDRV_CTL_EVENT_MASK_TLV;
1616         for (i = 0; i < kctl->count; ++i)
1617                 snd_ctl_notify_one(ue->card, mask, kctl, i);
1618
1619         return change;
1620 }
1621
1622 static int read_user_tlv(struct snd_kcontrol *kctl, unsigned int __user *buf,
1623                          unsigned int size)
1624 {
1625         struct user_element *ue = kctl->private_data;
1626
1627         if (ue->tlv_data_size == 0 || ue->tlv_data == NULL)
1628                 return -ENXIO;
1629
1630         if (size < ue->tlv_data_size)
1631                 return -ENOSPC;
1632
1633         if (copy_to_user(buf, ue->tlv_data, ue->tlv_data_size))
1634                 return -EFAULT;
1635
1636         return 0;
1637 }
1638
1639 static int snd_ctl_elem_user_tlv(struct snd_kcontrol *kctl, int op_flag,
1640                                  unsigned int size, unsigned int __user *buf)
1641 {
1642         if (op_flag == SNDRV_CTL_TLV_OP_WRITE)
1643                 return replace_user_tlv(kctl, buf, size);
1644         else
1645                 return read_user_tlv(kctl, buf, size);
1646 }
1647
1648 /* called in controls_rwsem write lock */
1649 static int snd_ctl_elem_init_enum_names(struct user_element *ue)
1650 {
1651         char *names, *p;
1652         size_t buf_len, name_len;
1653         unsigned int i;
1654         const uintptr_t user_ptrval = ue->info.value.enumerated.names_ptr;
1655
1656         lockdep_assert_held_write(&ue->card->controls_rwsem);
1657
1658         buf_len = ue->info.value.enumerated.names_length;
1659         if (buf_len > 64 * 1024)
1660                 return -EINVAL;
1661
1662         if (check_user_elem_overflow(ue->card, buf_len))
1663                 return -ENOMEM;
1664         names = vmemdup_user((const void __user *)user_ptrval, buf_len);
1665         if (IS_ERR(names))
1666                 return PTR_ERR(names);
1667
1668         /* check that there are enough valid names */
1669         p = names;
1670         for (i = 0; i < ue->info.value.enumerated.items; ++i) {
1671                 name_len = strnlen(p, buf_len);
1672                 if (name_len == 0 || name_len >= 64 || name_len == buf_len) {
1673                         kvfree(names);
1674                         return -EINVAL;
1675                 }
1676                 p += name_len + 1;
1677                 buf_len -= name_len + 1;
1678         }
1679
1680         ue->priv_data = names;
1681         ue->info.value.enumerated.names_ptr = 0;
1682         // increment the allocation size; decremented again at private_free.
1683         ue->card->user_ctl_alloc_size += ue->info.value.enumerated.names_length;
1684
1685         return 0;
1686 }
1687
1688 static size_t compute_user_elem_size(size_t size, unsigned int count)
1689 {
1690         return sizeof(struct user_element) + size * count;
1691 }
1692
1693 static void snd_ctl_elem_user_free(struct snd_kcontrol *kcontrol)
1694 {
1695         struct user_element *ue = kcontrol->private_data;
1696
1697         // decrement the allocation size.
1698         ue->card->user_ctl_alloc_size -= compute_user_elem_size(ue->elem_data_size, kcontrol->count);
1699         ue->card->user_ctl_alloc_size -= ue->tlv_data_size;
1700         if (ue->priv_data)
1701                 ue->card->user_ctl_alloc_size -= ue->info.value.enumerated.names_length;
1702
1703         kvfree(ue->tlv_data);
1704         kvfree(ue->priv_data);
1705         kfree(ue);
1706 }
1707
1708 static int snd_ctl_elem_add(struct snd_ctl_file *file,
1709                             struct snd_ctl_elem_info *info, int replace)
1710 {
1711         struct snd_card *card = file->card;
1712         struct snd_kcontrol *kctl;
1713         unsigned int count;
1714         unsigned int access;
1715         long private_size;
1716         size_t alloc_size;
1717         struct user_element *ue;
1718         unsigned int offset;
1719         int err;
1720
1721         if (!*info->id.name)
1722                 return -EINVAL;
1723         if (strnlen(info->id.name, sizeof(info->id.name)) >= sizeof(info->id.name))
1724                 return -EINVAL;
1725
1726         /* Delete a control to replace them if needed. */
1727         if (replace) {
1728                 info->id.numid = 0;
1729                 err = snd_ctl_remove_user_ctl(file, &info->id);
1730                 if (err)
1731                         return err;
1732         }
1733
1734         /* Check the number of elements for this userspace control. */
1735         count = info->owner;
1736         if (count == 0)
1737                 count = 1;
1738
1739         /* Arrange access permissions if needed. */
1740         access = info->access;
1741         if (access == 0)
1742                 access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
1743         access &= (SNDRV_CTL_ELEM_ACCESS_READWRITE |
1744                    SNDRV_CTL_ELEM_ACCESS_INACTIVE |
1745                    SNDRV_CTL_ELEM_ACCESS_TLV_WRITE);
1746
1747         /* In initial state, nothing is available as TLV container. */
1748         if (access & SNDRV_CTL_ELEM_ACCESS_TLV_WRITE)
1749                 access |= SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
1750         access |= SNDRV_CTL_ELEM_ACCESS_USER;
1751
1752         /*
1753          * Check information and calculate the size of data specific to
1754          * this userspace control.
1755          */
1756         /* pass NULL to card for suppressing error messages */
1757         err = snd_ctl_check_elem_info(NULL, info);
1758         if (err < 0)
1759                 return err;
1760         /* user-space control doesn't allow zero-size data */
1761         if (info->count < 1)
1762                 return -EINVAL;
1763         private_size = value_sizes[info->type] * info->count;
1764         alloc_size = compute_user_elem_size(private_size, count);
1765
1766         down_write(&card->controls_rwsem);
1767         if (check_user_elem_overflow(card, alloc_size)) {
1768                 err = -ENOMEM;
1769                 goto unlock;
1770         }
1771
1772         /*
1773          * Keep memory object for this userspace control. After passing this
1774          * code block, the instance should be freed by snd_ctl_free_one().
1775          *
1776          * Note that these elements in this control are locked.
1777          */
1778         err = snd_ctl_new(&kctl, count, access, file);
1779         if (err < 0)
1780                 goto unlock;
1781         memcpy(&kctl->id, &info->id, sizeof(kctl->id));
1782         ue = kzalloc(alloc_size, GFP_KERNEL);
1783         if (!ue) {
1784                 kfree(kctl);
1785                 err = -ENOMEM;
1786                 goto unlock;
1787         }
1788         kctl->private_data = ue;
1789         kctl->private_free = snd_ctl_elem_user_free;
1790
1791         // increment the allocated size; decremented again at private_free.
1792         card->user_ctl_alloc_size += alloc_size;
1793
1794         /* Set private data for this userspace control. */
1795         ue->card = card;
1796         ue->info = *info;
1797         ue->info.access = 0;
1798         ue->elem_data = (char *)ue + sizeof(*ue);
1799         ue->elem_data_size = private_size;
1800         if (ue->info.type == SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
1801                 err = snd_ctl_elem_init_enum_names(ue);
1802                 if (err < 0) {
1803                         snd_ctl_free_one(kctl);
1804                         goto unlock;
1805                 }
1806         }
1807
1808         /* Set callback functions. */
1809         if (info->type == SNDRV_CTL_ELEM_TYPE_ENUMERATED)
1810                 kctl->info = snd_ctl_elem_user_enum_info;
1811         else
1812                 kctl->info = snd_ctl_elem_user_info;
1813         if (access & SNDRV_CTL_ELEM_ACCESS_READ)
1814                 kctl->get = snd_ctl_elem_user_get;
1815         if (access & SNDRV_CTL_ELEM_ACCESS_WRITE)
1816                 kctl->put = snd_ctl_elem_user_put;
1817         if (access & SNDRV_CTL_ELEM_ACCESS_TLV_WRITE)
1818                 kctl->tlv.c = snd_ctl_elem_user_tlv;
1819
1820         /* This function manage to free the instance on failure. */
1821         err = __snd_ctl_add_replace(card, kctl, CTL_ADD_EXCLUSIVE);
1822         if (err < 0) {
1823                 snd_ctl_free_one(kctl);
1824                 goto unlock;
1825         }
1826         offset = snd_ctl_get_ioff(kctl, &info->id);
1827         snd_ctl_build_ioff(&info->id, kctl, offset);
1828         /*
1829          * Here we cannot fill any field for the number of elements added by
1830          * this operation because there're no specific fields. The usage of
1831          * 'owner' field for this purpose may cause any bugs to userspace
1832          * applications because the field originally means PID of a process
1833          * which locks the element.
1834          */
1835  unlock:
1836         up_write(&card->controls_rwsem);
1837         return err;
1838 }
1839
1840 static int snd_ctl_elem_add_user(struct snd_ctl_file *file,
1841                                  struct snd_ctl_elem_info __user *_info, int replace)
1842 {
1843         struct snd_ctl_elem_info info;
1844         int err;
1845
1846         if (copy_from_user(&info, _info, sizeof(info)))
1847                 return -EFAULT;
1848         err = snd_ctl_elem_add(file, &info, replace);
1849         if (err < 0)
1850                 return err;
1851         if (copy_to_user(_info, &info, sizeof(info))) {
1852                 snd_ctl_remove_user_ctl(file, &info.id);
1853                 return -EFAULT;
1854         }
1855
1856         return 0;
1857 }
1858
1859 static int snd_ctl_elem_remove(struct snd_ctl_file *file,
1860                                struct snd_ctl_elem_id __user *_id)
1861 {
1862         struct snd_ctl_elem_id id;
1863
1864         if (copy_from_user(&id, _id, sizeof(id)))
1865                 return -EFAULT;
1866         return snd_ctl_remove_user_ctl(file, &id);
1867 }
1868
1869 static int snd_ctl_subscribe_events(struct snd_ctl_file *file, int __user *ptr)
1870 {
1871         int subscribe;
1872         if (get_user(subscribe, ptr))
1873                 return -EFAULT;
1874         if (subscribe < 0) {
1875                 subscribe = file->subscribed;
1876                 if (put_user(subscribe, ptr))
1877                         return -EFAULT;
1878                 return 0;
1879         }
1880         if (subscribe) {
1881                 file->subscribed = 1;
1882                 return 0;
1883         } else if (file->subscribed) {
1884                 snd_ctl_empty_read_queue(file);
1885                 file->subscribed = 0;
1886         }
1887         return 0;
1888 }
1889
1890 static int call_tlv_handler(struct snd_ctl_file *file, int op_flag,
1891                             struct snd_kcontrol *kctl,
1892                             struct snd_ctl_elem_id *id,
1893                             unsigned int __user *buf, unsigned int size)
1894 {
1895         static const struct {
1896                 int op;
1897                 int perm;
1898         } pairs[] = {
1899                 {SNDRV_CTL_TLV_OP_READ,  SNDRV_CTL_ELEM_ACCESS_TLV_READ},
1900                 {SNDRV_CTL_TLV_OP_WRITE, SNDRV_CTL_ELEM_ACCESS_TLV_WRITE},
1901                 {SNDRV_CTL_TLV_OP_CMD,   SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND},
1902         };
1903         struct snd_kcontrol_volatile *vd = &kctl->vd[snd_ctl_get_ioff(kctl, id)];
1904         int i, ret;
1905
1906         /* Check support of the request for this element. */
1907         for (i = 0; i < ARRAY_SIZE(pairs); ++i) {
1908                 if (op_flag == pairs[i].op && (vd->access & pairs[i].perm))
1909                         break;
1910         }
1911         if (i == ARRAY_SIZE(pairs))
1912                 return -ENXIO;
1913
1914         if (kctl->tlv.c == NULL)
1915                 return -ENXIO;
1916
1917         /* Write and command operations are not allowed for locked element. */
1918         if (op_flag != SNDRV_CTL_TLV_OP_READ &&
1919             vd->owner != NULL && vd->owner != file)
1920                 return -EPERM;
1921
1922         ret = snd_power_ref_and_wait(file->card);
1923         if (!ret)
1924                 ret = kctl->tlv.c(kctl, op_flag, size, buf);
1925         snd_power_unref(file->card);
1926         return ret;
1927 }
1928
1929 static int read_tlv_buf(struct snd_kcontrol *kctl, struct snd_ctl_elem_id *id,
1930                         unsigned int __user *buf, unsigned int size)
1931 {
1932         struct snd_kcontrol_volatile *vd = &kctl->vd[snd_ctl_get_ioff(kctl, id)];
1933         unsigned int len;
1934
1935         if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_READ))
1936                 return -ENXIO;
1937
1938         if (kctl->tlv.p == NULL)
1939                 return -ENXIO;
1940
1941         len = sizeof(unsigned int) * 2 + kctl->tlv.p[1];
1942         if (size < len)
1943                 return -ENOMEM;
1944
1945         if (copy_to_user(buf, kctl->tlv.p, len))
1946                 return -EFAULT;
1947
1948         return 0;
1949 }
1950
1951 static int snd_ctl_tlv_ioctl(struct snd_ctl_file *file,
1952                              struct snd_ctl_tlv __user *buf,
1953                              int op_flag)
1954 {
1955         struct snd_ctl_tlv header;
1956         unsigned int __user *container;
1957         unsigned int container_size;
1958         struct snd_kcontrol *kctl;
1959         struct snd_ctl_elem_id id;
1960         struct snd_kcontrol_volatile *vd;
1961
1962         lockdep_assert_held(&file->card->controls_rwsem);
1963
1964         if (copy_from_user(&header, buf, sizeof(header)))
1965                 return -EFAULT;
1966
1967         /* In design of control core, numerical ID starts at 1. */
1968         if (header.numid == 0)
1969                 return -EINVAL;
1970
1971         /* At least, container should include type and length fields.  */
1972         if (header.length < sizeof(unsigned int) * 2)
1973                 return -EINVAL;
1974         container_size = header.length;
1975         container = buf->tlv;
1976
1977         kctl = snd_ctl_find_numid_locked(file->card, header.numid);
1978         if (kctl == NULL)
1979                 return -ENOENT;
1980
1981         /* Calculate index of the element in this set. */
1982         id = kctl->id;
1983         snd_ctl_build_ioff(&id, kctl, header.numid - id.numid);
1984         vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
1985
1986         if (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
1987                 return call_tlv_handler(file, op_flag, kctl, &id, container,
1988                                         container_size);
1989         } else {
1990                 if (op_flag == SNDRV_CTL_TLV_OP_READ) {
1991                         return read_tlv_buf(kctl, &id, container,
1992                                             container_size);
1993                 }
1994         }
1995
1996         /* Not supported. */
1997         return -ENXIO;
1998 }
1999
2000 static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2001 {
2002         struct snd_ctl_file *ctl;
2003         struct snd_card *card;
2004         struct snd_kctl_ioctl *p;
2005         void __user *argp = (void __user *)arg;
2006         int __user *ip = argp;
2007         int err;
2008
2009         ctl = file->private_data;
2010         card = ctl->card;
2011         if (snd_BUG_ON(!card))
2012                 return -ENXIO;
2013         switch (cmd) {
2014         case SNDRV_CTL_IOCTL_PVERSION:
2015                 return put_user(SNDRV_CTL_VERSION, ip) ? -EFAULT : 0;
2016         case SNDRV_CTL_IOCTL_CARD_INFO:
2017                 return snd_ctl_card_info(card, ctl, cmd, argp);
2018         case SNDRV_CTL_IOCTL_ELEM_LIST:
2019                 return snd_ctl_elem_list_user(card, argp);
2020         case SNDRV_CTL_IOCTL_ELEM_INFO:
2021                 return snd_ctl_elem_info_user(ctl, argp);
2022         case SNDRV_CTL_IOCTL_ELEM_READ:
2023                 return snd_ctl_elem_read_user(card, argp);
2024         case SNDRV_CTL_IOCTL_ELEM_WRITE:
2025                 return snd_ctl_elem_write_user(ctl, argp);
2026         case SNDRV_CTL_IOCTL_ELEM_LOCK:
2027                 return snd_ctl_elem_lock(ctl, argp);
2028         case SNDRV_CTL_IOCTL_ELEM_UNLOCK:
2029                 return snd_ctl_elem_unlock(ctl, argp);
2030         case SNDRV_CTL_IOCTL_ELEM_ADD:
2031                 return snd_ctl_elem_add_user(ctl, argp, 0);
2032         case SNDRV_CTL_IOCTL_ELEM_REPLACE:
2033                 return snd_ctl_elem_add_user(ctl, argp, 1);
2034         case SNDRV_CTL_IOCTL_ELEM_REMOVE:
2035                 return snd_ctl_elem_remove(ctl, argp);
2036         case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS:
2037                 return snd_ctl_subscribe_events(ctl, ip);
2038         case SNDRV_CTL_IOCTL_TLV_READ:
2039                 down_read(&ctl->card->controls_rwsem);
2040                 err = snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_READ);
2041                 up_read(&ctl->card->controls_rwsem);
2042                 return err;
2043         case SNDRV_CTL_IOCTL_TLV_WRITE:
2044                 down_write(&ctl->card->controls_rwsem);
2045                 err = snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_WRITE);
2046                 up_write(&ctl->card->controls_rwsem);
2047                 return err;
2048         case SNDRV_CTL_IOCTL_TLV_COMMAND:
2049                 down_write(&ctl->card->controls_rwsem);
2050                 err = snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_CMD);
2051                 up_write(&ctl->card->controls_rwsem);
2052                 return err;
2053         case SNDRV_CTL_IOCTL_POWER:
2054                 return -ENOPROTOOPT;
2055         case SNDRV_CTL_IOCTL_POWER_STATE:
2056                 return put_user(SNDRV_CTL_POWER_D0, ip) ? -EFAULT : 0;
2057         }
2058         down_read(&snd_ioctl_rwsem);
2059         list_for_each_entry(p, &snd_control_ioctls, list) {
2060                 err = p->fioctl(card, ctl, cmd, arg);
2061                 if (err != -ENOIOCTLCMD) {
2062                         up_read(&snd_ioctl_rwsem);
2063                         return err;
2064                 }
2065         }
2066         up_read(&snd_ioctl_rwsem);
2067         dev_dbg(card->dev, "unknown ioctl = 0x%x\n", cmd);
2068         return -ENOTTY;
2069 }
2070
2071 static ssize_t snd_ctl_read(struct file *file, char __user *buffer,
2072                             size_t count, loff_t * offset)
2073 {
2074         struct snd_ctl_file *ctl;
2075         int err = 0;
2076         ssize_t result = 0;
2077
2078         ctl = file->private_data;
2079         if (snd_BUG_ON(!ctl || !ctl->card))
2080                 return -ENXIO;
2081         if (!ctl->subscribed)
2082                 return -EBADFD;
2083         if (count < sizeof(struct snd_ctl_event))
2084                 return -EINVAL;
2085         spin_lock_irq(&ctl->read_lock);
2086         while (count >= sizeof(struct snd_ctl_event)) {
2087                 struct snd_ctl_event ev;
2088                 struct snd_kctl_event *kev;
2089                 while (list_empty(&ctl->events)) {
2090                         wait_queue_entry_t wait;
2091                         if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {
2092                                 err = -EAGAIN;
2093                                 goto __end_lock;
2094                         }
2095                         init_waitqueue_entry(&wait, current);
2096                         add_wait_queue(&ctl->change_sleep, &wait);
2097                         set_current_state(TASK_INTERRUPTIBLE);
2098                         spin_unlock_irq(&ctl->read_lock);
2099                         schedule();
2100                         remove_wait_queue(&ctl->change_sleep, &wait);
2101                         if (ctl->card->shutdown)
2102                                 return -ENODEV;
2103                         if (signal_pending(current))
2104                                 return -ERESTARTSYS;
2105                         spin_lock_irq(&ctl->read_lock);
2106                 }
2107                 kev = snd_kctl_event(ctl->events.next);
2108                 ev.type = SNDRV_CTL_EVENT_ELEM;
2109                 ev.data.elem.mask = kev->mask;
2110                 ev.data.elem.id = kev->id;
2111                 list_del(&kev->list);
2112                 spin_unlock_irq(&ctl->read_lock);
2113                 kfree(kev);
2114                 if (copy_to_user(buffer, &ev, sizeof(struct snd_ctl_event))) {
2115                         err = -EFAULT;
2116                         goto __end;
2117                 }
2118                 spin_lock_irq(&ctl->read_lock);
2119                 buffer += sizeof(struct snd_ctl_event);
2120                 count -= sizeof(struct snd_ctl_event);
2121                 result += sizeof(struct snd_ctl_event);
2122         }
2123       __end_lock:
2124         spin_unlock_irq(&ctl->read_lock);
2125       __end:
2126         return result > 0 ? result : err;
2127 }
2128
2129 static __poll_t snd_ctl_poll(struct file *file, poll_table * wait)
2130 {
2131         __poll_t mask;
2132         struct snd_ctl_file *ctl;
2133
2134         ctl = file->private_data;
2135         if (!ctl->subscribed)
2136                 return 0;
2137         poll_wait(file, &ctl->change_sleep, wait);
2138
2139         mask = 0;
2140         if (!list_empty(&ctl->events))
2141                 mask |= EPOLLIN | EPOLLRDNORM;
2142
2143         return mask;
2144 }
2145
2146 /*
2147  * register the device-specific control-ioctls.
2148  * called from each device manager like pcm.c, hwdep.c, etc.
2149  */
2150 static int _snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn, struct list_head *lists)
2151 {
2152         struct snd_kctl_ioctl *pn;
2153
2154         pn = kzalloc(sizeof(struct snd_kctl_ioctl), GFP_KERNEL);
2155         if (pn == NULL)
2156                 return -ENOMEM;
2157         pn->fioctl = fcn;
2158         down_write(&snd_ioctl_rwsem);
2159         list_add_tail(&pn->list, lists);
2160         up_write(&snd_ioctl_rwsem);
2161         return 0;
2162 }
2163
2164 /**
2165  * snd_ctl_register_ioctl - register the device-specific control-ioctls
2166  * @fcn: ioctl callback function
2167  *
2168  * called from each device manager like pcm.c, hwdep.c, etc.
2169  *
2170  * Return: zero if successful, or a negative error code
2171  */
2172 int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn)
2173 {
2174         return _snd_ctl_register_ioctl(fcn, &snd_control_ioctls);
2175 }
2176 EXPORT_SYMBOL(snd_ctl_register_ioctl);
2177
2178 #ifdef CONFIG_COMPAT
2179 /**
2180  * snd_ctl_register_ioctl_compat - register the device-specific 32bit compat
2181  * control-ioctls
2182  * @fcn: ioctl callback function
2183  *
2184  * Return: zero if successful, or a negative error code
2185  */
2186 int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn)
2187 {
2188         return _snd_ctl_register_ioctl(fcn, &snd_control_compat_ioctls);
2189 }
2190 EXPORT_SYMBOL(snd_ctl_register_ioctl_compat);
2191 #endif
2192
2193 /*
2194  * de-register the device-specific control-ioctls.
2195  */
2196 static int _snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn,
2197                                      struct list_head *lists)
2198 {
2199         struct snd_kctl_ioctl *p;
2200
2201         if (snd_BUG_ON(!fcn))
2202                 return -EINVAL;
2203         down_write(&snd_ioctl_rwsem);
2204         list_for_each_entry(p, lists, list) {
2205                 if (p->fioctl == fcn) {
2206                         list_del(&p->list);
2207                         up_write(&snd_ioctl_rwsem);
2208                         kfree(p);
2209                         return 0;
2210                 }
2211         }
2212         up_write(&snd_ioctl_rwsem);
2213         snd_BUG();
2214         return -EINVAL;
2215 }
2216
2217 /**
2218  * snd_ctl_unregister_ioctl - de-register the device-specific control-ioctls
2219  * @fcn: ioctl callback function to unregister
2220  *
2221  * Return: zero if successful, or a negative error code
2222  */
2223 int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn)
2224 {
2225         return _snd_ctl_unregister_ioctl(fcn, &snd_control_ioctls);
2226 }
2227 EXPORT_SYMBOL(snd_ctl_unregister_ioctl);
2228
2229 #ifdef CONFIG_COMPAT
2230 /**
2231  * snd_ctl_unregister_ioctl_compat - de-register the device-specific compat
2232  * 32bit control-ioctls
2233  * @fcn: ioctl callback function to unregister
2234  *
2235  * Return: zero if successful, or a negative error code
2236  */
2237 int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn)
2238 {
2239         return _snd_ctl_unregister_ioctl(fcn, &snd_control_compat_ioctls);
2240 }
2241 EXPORT_SYMBOL(snd_ctl_unregister_ioctl_compat);
2242 #endif
2243
2244 static int snd_ctl_fasync(int fd, struct file * file, int on)
2245 {
2246         struct snd_ctl_file *ctl;
2247
2248         ctl = file->private_data;
2249         return snd_fasync_helper(fd, file, on, &ctl->fasync);
2250 }
2251
2252 /* return the preferred subdevice number if already assigned;
2253  * otherwise return -1
2254  */
2255 int snd_ctl_get_preferred_subdevice(struct snd_card *card, int type)
2256 {
2257         struct snd_ctl_file *kctl;
2258         int subdevice = -1;
2259         unsigned long flags;
2260
2261         read_lock_irqsave(&card->ctl_files_rwlock, flags);
2262         list_for_each_entry(kctl, &card->ctl_files, list) {
2263                 if (kctl->pid == task_pid(current)) {
2264                         subdevice = kctl->preferred_subdevice[type];
2265                         if (subdevice != -1)
2266                                 break;
2267                 }
2268         }
2269         read_unlock_irqrestore(&card->ctl_files_rwlock, flags);
2270         return subdevice;
2271 }
2272 EXPORT_SYMBOL_GPL(snd_ctl_get_preferred_subdevice);
2273
2274 /*
2275  * ioctl32 compat
2276  */
2277 #ifdef CONFIG_COMPAT
2278 #include "control_compat.c"
2279 #else
2280 #define snd_ctl_ioctl_compat    NULL
2281 #endif
2282
2283 /*
2284  * control layers (audio LED etc.)
2285  */
2286
2287 /**
2288  * snd_ctl_request_layer - request to use the layer
2289  * @module_name: Name of the kernel module (NULL == build-in)
2290  *
2291  * Return: zero if successful, or an error code when the module cannot be loaded
2292  */
2293 int snd_ctl_request_layer(const char *module_name)
2294 {
2295         struct snd_ctl_layer_ops *lops;
2296
2297         if (module_name == NULL)
2298                 return 0;
2299         down_read(&snd_ctl_layer_rwsem);
2300         for (lops = snd_ctl_layer; lops; lops = lops->next)
2301                 if (strcmp(lops->module_name, module_name) == 0)
2302                         break;
2303         up_read(&snd_ctl_layer_rwsem);
2304         if (lops)
2305                 return 0;
2306         return request_module(module_name);
2307 }
2308 EXPORT_SYMBOL_GPL(snd_ctl_request_layer);
2309
2310 /**
2311  * snd_ctl_register_layer - register new control layer
2312  * @lops: operation structure
2313  *
2314  * The new layer can track all control elements and do additional
2315  * operations on top (like audio LED handling).
2316  */
2317 void snd_ctl_register_layer(struct snd_ctl_layer_ops *lops)
2318 {
2319         struct snd_card *card;
2320         int card_number;
2321
2322         down_write(&snd_ctl_layer_rwsem);
2323         lops->next = snd_ctl_layer;
2324         snd_ctl_layer = lops;
2325         up_write(&snd_ctl_layer_rwsem);
2326         for (card_number = 0; card_number < SNDRV_CARDS; card_number++) {
2327                 card = snd_card_ref(card_number);
2328                 if (card) {
2329                         down_read(&card->controls_rwsem);
2330                         lops->lregister(card);
2331                         up_read(&card->controls_rwsem);
2332                         snd_card_unref(card);
2333                 }
2334         }
2335 }
2336 EXPORT_SYMBOL_GPL(snd_ctl_register_layer);
2337
2338 /**
2339  * snd_ctl_disconnect_layer - disconnect control layer
2340  * @lops: operation structure
2341  *
2342  * It is expected that the information about tracked cards
2343  * is freed before this call (the disconnect callback is
2344  * not called here).
2345  */
2346 void snd_ctl_disconnect_layer(struct snd_ctl_layer_ops *lops)
2347 {
2348         struct snd_ctl_layer_ops *lops2, *prev_lops2;
2349
2350         down_write(&snd_ctl_layer_rwsem);
2351         for (lops2 = snd_ctl_layer, prev_lops2 = NULL; lops2; lops2 = lops2->next) {
2352                 if (lops2 == lops) {
2353                         if (!prev_lops2)
2354                                 snd_ctl_layer = lops->next;
2355                         else
2356                                 prev_lops2->next = lops->next;
2357                         break;
2358                 }
2359                 prev_lops2 = lops2;
2360         }
2361         up_write(&snd_ctl_layer_rwsem);
2362 }
2363 EXPORT_SYMBOL_GPL(snd_ctl_disconnect_layer);
2364
2365 /*
2366  *  INIT PART
2367  */
2368
2369 static const struct file_operations snd_ctl_f_ops =
2370 {
2371         .owner =        THIS_MODULE,
2372         .read =         snd_ctl_read,
2373         .open =         snd_ctl_open,
2374         .release =      snd_ctl_release,
2375         .llseek =       no_llseek,
2376         .poll =         snd_ctl_poll,
2377         .unlocked_ioctl =       snd_ctl_ioctl,
2378         .compat_ioctl = snd_ctl_ioctl_compat,
2379         .fasync =       snd_ctl_fasync,
2380 };
2381
2382 /*
2383  * registration of the control device
2384  */
2385 static int snd_ctl_dev_register(struct snd_device *device)
2386 {
2387         struct snd_card *card = device->device_data;
2388         struct snd_ctl_layer_ops *lops;
2389         int err;
2390
2391         err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1,
2392                                   &snd_ctl_f_ops, card, card->ctl_dev);
2393         if (err < 0)
2394                 return err;
2395         down_read(&card->controls_rwsem);
2396         down_read(&snd_ctl_layer_rwsem);
2397         for (lops = snd_ctl_layer; lops; lops = lops->next)
2398                 lops->lregister(card);
2399         up_read(&snd_ctl_layer_rwsem);
2400         up_read(&card->controls_rwsem);
2401         return 0;
2402 }
2403
2404 /*
2405  * disconnection of the control device
2406  */
2407 static int snd_ctl_dev_disconnect(struct snd_device *device)
2408 {
2409         struct snd_card *card = device->device_data;
2410         struct snd_ctl_file *ctl;
2411         struct snd_ctl_layer_ops *lops;
2412         unsigned long flags;
2413
2414         read_lock_irqsave(&card->ctl_files_rwlock, flags);
2415         list_for_each_entry(ctl, &card->ctl_files, list) {
2416                 wake_up(&ctl->change_sleep);
2417                 snd_kill_fasync(ctl->fasync, SIGIO, POLL_ERR);
2418         }
2419         read_unlock_irqrestore(&card->ctl_files_rwlock, flags);
2420
2421         down_read(&card->controls_rwsem);
2422         down_read(&snd_ctl_layer_rwsem);
2423         for (lops = snd_ctl_layer; lops; lops = lops->next)
2424                 lops->ldisconnect(card);
2425         up_read(&snd_ctl_layer_rwsem);
2426         up_read(&card->controls_rwsem);
2427
2428         return snd_unregister_device(card->ctl_dev);
2429 }
2430
2431 /*
2432  * free all controls
2433  */
2434 static int snd_ctl_dev_free(struct snd_device *device)
2435 {
2436         struct snd_card *card = device->device_data;
2437         struct snd_kcontrol *control;
2438
2439         down_write(&card->controls_rwsem);
2440         while (!list_empty(&card->controls)) {
2441                 control = snd_kcontrol(card->controls.next);
2442                 __snd_ctl_remove(card, control, false);
2443         }
2444
2445 #ifdef CONFIG_SND_CTL_FAST_LOOKUP
2446         xa_destroy(&card->ctl_numids);
2447         xa_destroy(&card->ctl_hash);
2448 #endif
2449         up_write(&card->controls_rwsem);
2450         put_device(card->ctl_dev);
2451         return 0;
2452 }
2453
2454 /*
2455  * create control core:
2456  * called from init.c
2457  */
2458 int snd_ctl_create(struct snd_card *card)
2459 {
2460         static const struct snd_device_ops ops = {
2461                 .dev_free = snd_ctl_dev_free,
2462                 .dev_register = snd_ctl_dev_register,
2463                 .dev_disconnect = snd_ctl_dev_disconnect,
2464         };
2465         int err;
2466
2467         if (snd_BUG_ON(!card))
2468                 return -ENXIO;
2469         if (snd_BUG_ON(card->number < 0 || card->number >= SNDRV_CARDS))
2470                 return -ENXIO;
2471
2472         err = snd_device_alloc(&card->ctl_dev, card);
2473         if (err < 0)
2474                 return err;
2475         dev_set_name(card->ctl_dev, "controlC%d", card->number);
2476
2477         err = snd_device_new(card, SNDRV_DEV_CONTROL, card, &ops);
2478         if (err < 0)
2479                 put_device(card->ctl_dev);
2480         return err;
2481 }
2482
2483 /*
2484  * Frequently used control callbacks/helpers
2485  */
2486
2487 /**
2488  * snd_ctl_boolean_mono_info - Helper function for a standard boolean info
2489  * callback with a mono channel
2490  * @kcontrol: the kcontrol instance
2491  * @uinfo: info to store
2492  *
2493  * This is a function that can be used as info callback for a standard
2494  * boolean control with a single mono channel.
2495  *
2496  * Return: Zero (always successful)
2497  */
2498 int snd_ctl_boolean_mono_info(struct snd_kcontrol *kcontrol,
2499                               struct snd_ctl_elem_info *uinfo)
2500 {
2501         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2502         uinfo->count = 1;
2503         uinfo->value.integer.min = 0;
2504         uinfo->value.integer.max = 1;
2505         return 0;
2506 }
2507 EXPORT_SYMBOL(snd_ctl_boolean_mono_info);
2508
2509 /**
2510  * snd_ctl_boolean_stereo_info - Helper function for a standard boolean info
2511  * callback with stereo two channels
2512  * @kcontrol: the kcontrol instance
2513  * @uinfo: info to store
2514  *
2515  * This is a function that can be used as info callback for a standard
2516  * boolean control with stereo two channels.
2517  *
2518  * Return: Zero (always successful)
2519  */
2520 int snd_ctl_boolean_stereo_info(struct snd_kcontrol *kcontrol,
2521                                 struct snd_ctl_elem_info *uinfo)
2522 {
2523         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2524         uinfo->count = 2;
2525         uinfo->value.integer.min = 0;
2526         uinfo->value.integer.max = 1;
2527         return 0;
2528 }
2529 EXPORT_SYMBOL(snd_ctl_boolean_stereo_info);
2530
2531 /**
2532  * snd_ctl_enum_info - fills the info structure for an enumerated control
2533  * @info: the structure to be filled
2534  * @channels: the number of the control's channels; often one
2535  * @items: the number of control values; also the size of @names
2536  * @names: an array containing the names of all control values
2537  *
2538  * Sets all required fields in @info to their appropriate values.
2539  * If the control's accessibility is not the default (readable and writable),
2540  * the caller has to fill @info->access.
2541  *
2542  * Return: Zero (always successful)
2543  */
2544 int snd_ctl_enum_info(struct snd_ctl_elem_info *info, unsigned int channels,
2545                       unsigned int items, const char *const names[])
2546 {
2547         info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2548         info->count = channels;
2549         info->value.enumerated.items = items;
2550         if (!items)
2551                 return 0;
2552         if (info->value.enumerated.item >= items)
2553                 info->value.enumerated.item = items - 1;
2554         WARN(strlen(names[info->value.enumerated.item]) >= sizeof(info->value.enumerated.name),
2555              "ALSA: too long item name '%s'\n",
2556              names[info->value.enumerated.item]);
2557         strscpy(info->value.enumerated.name,
2558                 names[info->value.enumerated.item],
2559                 sizeof(info->value.enumerated.name));
2560         return 0;
2561 }
2562 EXPORT_SYMBOL(snd_ctl_enum_info);