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