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