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