Merge with /pub/scm/linux/kernel/git/torvalds/linux-2.6.git
[linux-2.6] / 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
313         snd_assert(card != NULL, return -EINVAL);
314         if (! kcontrol)
315                 return -EINVAL;
316         snd_assert(kcontrol->info != NULL, return -EINVAL);
317         id = kcontrol->id;
318         down_write(&card->controls_rwsem);
319         if (snd_ctl_find_id(card, &id)) {
320                 up_write(&card->controls_rwsem);
321                 snd_ctl_free_one(kcontrol);
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                 return -EBUSY;
329         }
330         if (snd_ctl_find_hole(card, kcontrol->count) < 0) {
331                 up_write(&card->controls_rwsem);
332                 snd_ctl_free_one(kcontrol);
333                 return -ENOMEM;
334         }
335         list_add_tail(&kcontrol->list, &card->controls);
336         card->controls_count += kcontrol->count;
337         kcontrol->id.numid = card->last_numid + 1;
338         card->last_numid += kcontrol->count;
339         up_write(&card->controls_rwsem);
340         for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
341                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_ADD, &id);
342         return 0;
343 }
344
345 /**
346  * snd_ctl_remove - remove the control from the card and release it
347  * @card: the card instance
348  * @kcontrol: the control instance to remove
349  *
350  * Removes the control from the card and then releases the instance.
351  * You don't need to call snd_ctl_free_one(). You must be in
352  * the write lock - down_write(&card->controls_rwsem).
353  * 
354  * Returns 0 if successful, or a negative error code on failure.
355  */
356 int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol)
357 {
358         struct snd_ctl_elem_id id;
359         unsigned int idx;
360
361         snd_assert(card != NULL && kcontrol != NULL, return -EINVAL);
362         list_del(&kcontrol->list);
363         card->controls_count -= kcontrol->count;
364         id = kcontrol->id;
365         for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
366                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_REMOVE, &id);
367         snd_ctl_free_one(kcontrol);
368         return 0;
369 }
370
371 /**
372  * snd_ctl_remove_id - remove the control of the given id and release it
373  * @card: the card instance
374  * @id: the control id to remove
375  *
376  * Finds the control instance with the given id, removes it from the
377  * card list and releases it.
378  * 
379  * Returns 0 if successful, or a negative error code on failure.
380  */
381 int snd_ctl_remove_id(struct snd_card *card, struct snd_ctl_elem_id *id)
382 {
383         struct snd_kcontrol *kctl;
384         int ret;
385
386         down_write(&card->controls_rwsem);
387         kctl = snd_ctl_find_id(card, id);
388         if (kctl == NULL) {
389                 up_write(&card->controls_rwsem);
390                 return -ENOENT;
391         }
392         ret = snd_ctl_remove(card, kctl);
393         up_write(&card->controls_rwsem);
394         return ret;
395 }
396
397 /**
398  * snd_ctl_remove_unlocked_id - remove the unlocked control of the given id and release it
399  * @file: active control handle
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 static int snd_ctl_remove_unlocked_id(struct snd_ctl_file * file,
408                                       struct snd_ctl_elem_id *id)
409 {
410         struct snd_card *card = file->card;
411         struct snd_kcontrol *kctl;
412         int idx, ret;
413
414         down_write(&card->controls_rwsem);
415         kctl = snd_ctl_find_id(card, id);
416         if (kctl == NULL) {
417                 up_write(&card->controls_rwsem);
418                 return -ENOENT;
419         }
420         for (idx = 0; idx < kctl->count; idx++)
421                 if (kctl->vd[idx].owner != NULL && kctl->vd[idx].owner != file) {
422                         up_write(&card->controls_rwsem);
423                         return -EBUSY;
424                 }
425         ret = snd_ctl_remove(card, kctl);
426         up_write(&card->controls_rwsem);
427         return ret;
428 }
429
430 /**
431  * snd_ctl_rename_id - replace the id of a control on the card
432  * @card: the card instance
433  * @src_id: the old id
434  * @dst_id: the new id
435  *
436  * Finds the control with the old id from the card, and replaces the
437  * id with the new one.
438  *
439  * Returns zero if successful, or a negative error code on failure.
440  */
441 int snd_ctl_rename_id(struct snd_card *card, struct snd_ctl_elem_id *src_id,
442                       struct snd_ctl_elem_id *dst_id)
443 {
444         struct snd_kcontrol *kctl;
445
446         down_write(&card->controls_rwsem);
447         kctl = snd_ctl_find_id(card, src_id);
448         if (kctl == NULL) {
449                 up_write(&card->controls_rwsem);
450                 return -ENOENT;
451         }
452         kctl->id = *dst_id;
453         kctl->id.numid = card->last_numid + 1;
454         card->last_numid += kctl->count;
455         up_write(&card->controls_rwsem);
456         return 0;
457 }
458
459 /**
460  * snd_ctl_find_numid - find the control instance with the given number-id
461  * @card: the card instance
462  * @numid: the number-id to search
463  *
464  * Finds the control instance with the given number-id from the card.
465  *
466  * Returns the pointer of the instance if found, or NULL if not.
467  *
468  * The caller must down card->controls_rwsem before calling this function
469  * (if the race condition can happen).
470  */
471 struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card, unsigned int numid)
472 {
473         struct list_head *list;
474         struct snd_kcontrol *kctl;
475
476         snd_assert(card != NULL && numid != 0, return NULL);
477         list_for_each(list, &card->controls) {
478                 kctl = snd_kcontrol(list);
479                 if (kctl->id.numid <= numid && kctl->id.numid + kctl->count > numid)
480                         return kctl;
481         }
482         return NULL;
483 }
484
485 /**
486  * snd_ctl_find_id - find the control instance with the given id
487  * @card: the card instance
488  * @id: the id to search
489  *
490  * Finds the control instance with the given id from the card.
491  *
492  * Returns the pointer of the instance if found, or NULL if not.
493  *
494  * The caller must down card->controls_rwsem before calling this function
495  * (if the race condition can happen).
496  */
497 struct snd_kcontrol *snd_ctl_find_id(struct snd_card *card,
498                                      struct snd_ctl_elem_id *id)
499 {
500         struct list_head *list;
501         struct snd_kcontrol *kctl;
502
503         snd_assert(card != NULL && id != NULL, return NULL);
504         if (id->numid != 0)
505                 return snd_ctl_find_numid(card, id->numid);
506         list_for_each(list, &card->controls) {
507                 kctl = snd_kcontrol(list);
508                 if (kctl->id.iface != id->iface)
509                         continue;
510                 if (kctl->id.device != id->device)
511                         continue;
512                 if (kctl->id.subdevice != id->subdevice)
513                         continue;
514                 if (strncmp(kctl->id.name, id->name, sizeof(kctl->id.name)))
515                         continue;
516                 if (kctl->id.index > id->index)
517                         continue;
518                 if (kctl->id.index + kctl->count <= id->index)
519                         continue;
520                 return kctl;
521         }
522         return NULL;
523 }
524
525 static int snd_ctl_card_info(struct snd_card *card, struct snd_ctl_file * ctl,
526                              unsigned int cmd, void __user *arg)
527 {
528         struct snd_ctl_card_info *info;
529
530         info = kzalloc(sizeof(*info), GFP_KERNEL);
531         if (! info)
532                 return -ENOMEM;
533         down_read(&snd_ioctl_rwsem);
534         info->card = card->number;
535         strlcpy(info->id, card->id, sizeof(info->id));
536         strlcpy(info->driver, card->driver, sizeof(info->driver));
537         strlcpy(info->name, card->shortname, sizeof(info->name));
538         strlcpy(info->longname, card->longname, sizeof(info->longname));
539         strlcpy(info->mixername, card->mixername, sizeof(info->mixername));
540         strlcpy(info->components, card->components, sizeof(info->components));
541         up_read(&snd_ioctl_rwsem);
542         if (copy_to_user(arg, info, sizeof(struct snd_ctl_card_info))) {
543                 kfree(info);
544                 return -EFAULT;
545         }
546         kfree(info);
547         return 0;
548 }
549
550 static int snd_ctl_elem_list(struct snd_card *card,
551                              struct snd_ctl_elem_list __user *_list)
552 {
553         struct list_head *plist;
554         struct snd_ctl_elem_list list;
555         struct snd_kcontrol *kctl;
556         struct snd_ctl_elem_id *dst, *id;
557         unsigned int offset, space, first, jidx;
558         
559         if (copy_from_user(&list, _list, sizeof(list)))
560                 return -EFAULT;
561         offset = list.offset;
562         space = list.space;
563         first = 0;
564         /* try limit maximum space */
565         if (space > 16384)
566                 return -ENOMEM;
567         if (space > 0) {
568                 /* allocate temporary buffer for atomic operation */
569                 dst = vmalloc(space * sizeof(struct snd_ctl_elem_id));
570                 if (dst == NULL)
571                         return -ENOMEM;
572                 down_read(&card->controls_rwsem);
573                 list.count = card->controls_count;
574                 plist = card->controls.next;
575                 while (plist != &card->controls) {
576                         if (offset == 0)
577                                 break;
578                         kctl = snd_kcontrol(plist);
579                         if (offset < kctl->count)
580                                 break;
581                         offset -= kctl->count;
582                         plist = plist->next;
583                 }
584                 list.used = 0;
585                 id = dst;
586                 while (space > 0 && plist != &card->controls) {
587                         kctl = snd_kcontrol(plist);
588                         for (jidx = offset; space > 0 && jidx < kctl->count; jidx++) {
589                                 snd_ctl_build_ioff(id, kctl, jidx);
590                                 id++;
591                                 space--;
592                                 list.used++;
593                         }
594                         plist = plist->next;
595                         offset = 0;
596                 }
597                 up_read(&card->controls_rwsem);
598                 if (list.used > 0 &&
599                     copy_to_user(list.pids, dst,
600                                  list.used * sizeof(struct snd_ctl_elem_id))) {
601                         vfree(dst);
602                         return -EFAULT;
603                 }
604                 vfree(dst);
605         } else {
606                 down_read(&card->controls_rwsem);
607                 list.count = card->controls_count;
608                 up_read(&card->controls_rwsem);
609         }
610         if (copy_to_user(_list, &list, sizeof(list)))
611                 return -EFAULT;
612         return 0;
613 }
614
615 static int snd_ctl_elem_info(struct snd_ctl_file *ctl,
616                              struct snd_ctl_elem_info *info)
617 {
618         struct snd_card *card = ctl->card;
619         struct snd_kcontrol *kctl;
620         struct snd_kcontrol_volatile *vd;
621         unsigned int index_offset;
622         int result;
623         
624         down_read(&card->controls_rwsem);
625         kctl = snd_ctl_find_id(card, &info->id);
626         if (kctl == NULL) {
627                 up_read(&card->controls_rwsem);
628                 return -ENOENT;
629         }
630 #ifdef CONFIG_SND_DEBUG
631         info->access = 0;
632 #endif
633         result = kctl->info(kctl, info);
634         if (result >= 0) {
635                 snd_assert(info->access == 0, );
636                 index_offset = snd_ctl_get_ioff(kctl, &info->id);
637                 vd = &kctl->vd[index_offset];
638                 snd_ctl_build_ioff(&info->id, kctl, index_offset);
639                 info->access = vd->access;
640                 if (vd->owner) {
641                         info->access |= SNDRV_CTL_ELEM_ACCESS_LOCK;
642                         if (vd->owner == ctl)
643                                 info->access |= SNDRV_CTL_ELEM_ACCESS_OWNER;
644                         info->owner = vd->owner_pid;
645                 } else {
646                         info->owner = -1;
647                 }
648         }
649         up_read(&card->controls_rwsem);
650         return result;
651 }
652
653 static int snd_ctl_elem_info_user(struct snd_ctl_file *ctl,
654                                   struct snd_ctl_elem_info __user *_info)
655 {
656         struct snd_ctl_elem_info info;
657         int result;
658
659         if (copy_from_user(&info, _info, sizeof(info)))
660                 return -EFAULT;
661         result = snd_ctl_elem_info(ctl, &info);
662         if (result >= 0)
663                 if (copy_to_user(_info, &info, sizeof(info)))
664                         return -EFAULT;
665         return result;
666 }
667
668 int snd_ctl_elem_read(struct snd_card *card, struct snd_ctl_elem_value *control)
669 {
670         struct snd_kcontrol *kctl;
671         struct snd_kcontrol_volatile *vd;
672         unsigned int index_offset;
673         int result, indirect;
674
675         down_read(&card->controls_rwsem);
676         kctl = snd_ctl_find_id(card, &control->id);
677         if (kctl == NULL) {
678                 result = -ENOENT;
679         } else {
680                 index_offset = snd_ctl_get_ioff(kctl, &control->id);
681                 vd = &kctl->vd[index_offset];
682                 indirect = vd->access & SNDRV_CTL_ELEM_ACCESS_INDIRECT ? 1 : 0;
683                 if (control->indirect != indirect) {
684                         result = -EACCES;
685                 } else {
686                         if ((vd->access & SNDRV_CTL_ELEM_ACCESS_READ) && kctl->get != NULL) {
687                                 snd_ctl_build_ioff(&control->id, kctl, index_offset);
688                                 result = kctl->get(kctl, control);
689                         } else {
690                                 result = -EPERM;
691                         }
692                 }
693         }
694         up_read(&card->controls_rwsem);
695         return result;
696 }
697
698 static int snd_ctl_elem_read_user(struct snd_card *card,
699                                   struct snd_ctl_elem_value __user *_control)
700 {
701         struct snd_ctl_elem_value *control;
702         int result;
703         
704         control = kmalloc(sizeof(*control), GFP_KERNEL);
705         if (control == NULL)
706                 return -ENOMEM; 
707         if (copy_from_user(control, _control, sizeof(*control))) {
708                 kfree(control);
709                 return -EFAULT;
710         }
711         result = snd_ctl_elem_read(card, control);
712         if (result >= 0)
713                 if (copy_to_user(_control, control, sizeof(*control)))
714                         result = -EFAULT;
715         kfree(control);
716         return result;
717 }
718
719 int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file,
720                        struct snd_ctl_elem_value *control)
721 {
722         struct snd_kcontrol *kctl;
723         struct snd_kcontrol_volatile *vd;
724         unsigned int index_offset;
725         int result, indirect;
726
727         down_read(&card->controls_rwsem);
728         kctl = snd_ctl_find_id(card, &control->id);
729         if (kctl == NULL) {
730                 result = -ENOENT;
731         } else {
732                 index_offset = snd_ctl_get_ioff(kctl, &control->id);
733                 vd = &kctl->vd[index_offset];
734                 indirect = vd->access & SNDRV_CTL_ELEM_ACCESS_INDIRECT ? 1 : 0;
735                 if (control->indirect != indirect) {
736                         result = -EACCES;
737                 } else {
738                         if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_WRITE) ||
739                             kctl->put == NULL ||
740                             (file && vd->owner != NULL && vd->owner != file)) {
741                                 result = -EPERM;
742                         } else {
743                                 snd_ctl_build_ioff(&control->id, kctl, index_offset);
744                                 result = kctl->put(kctl, control);
745                         }
746                         if (result > 0) {
747                                 up_read(&card->controls_rwsem);
748                                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &control->id);
749                                 return 0;
750                         }
751                 }
752         }
753         up_read(&card->controls_rwsem);
754         return result;
755 }
756
757 static int snd_ctl_elem_write_user(struct snd_ctl_file *file,
758                                    struct snd_ctl_elem_value __user *_control)
759 {
760         struct snd_ctl_elem_value *control;
761         int result;
762
763         control = kmalloc(sizeof(*control), GFP_KERNEL);
764         if (control == NULL)
765                 return -ENOMEM; 
766         if (copy_from_user(control, _control, sizeof(*control))) {
767                 kfree(control);
768                 return -EFAULT;
769         }
770         result = snd_ctl_elem_write(file->card, file, control);
771         if (result >= 0)
772                 if (copy_to_user(_control, control, sizeof(*control)))
773                         result = -EFAULT;
774         kfree(control);
775         return result;
776 }
777
778 static int snd_ctl_elem_lock(struct snd_ctl_file *file,
779                              struct snd_ctl_elem_id __user *_id)
780 {
781         struct snd_card *card = file->card;
782         struct snd_ctl_elem_id id;
783         struct snd_kcontrol *kctl;
784         struct snd_kcontrol_volatile *vd;
785         int result;
786         
787         if (copy_from_user(&id, _id, sizeof(id)))
788                 return -EFAULT;
789         down_write(&card->controls_rwsem);
790         kctl = snd_ctl_find_id(card, &id);
791         if (kctl == NULL) {
792                 result = -ENOENT;
793         } else {
794                 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
795                 if (vd->owner != NULL)
796                         result = -EBUSY;
797                 else {
798                         vd->owner = file;
799                         vd->owner_pid = current->pid;
800                         result = 0;
801                 }
802         }
803         up_write(&card->controls_rwsem);
804         return result;
805 }
806
807 static int snd_ctl_elem_unlock(struct snd_ctl_file *file,
808                                struct snd_ctl_elem_id __user *_id)
809 {
810         struct snd_card *card = file->card;
811         struct snd_ctl_elem_id id;
812         struct snd_kcontrol *kctl;
813         struct snd_kcontrol_volatile *vd;
814         int result;
815         
816         if (copy_from_user(&id, _id, sizeof(id)))
817                 return -EFAULT;
818         down_write(&card->controls_rwsem);
819         kctl = snd_ctl_find_id(card, &id);
820         if (kctl == NULL) {
821                 result = -ENOENT;
822         } else {
823                 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
824                 if (vd->owner == NULL)
825                         result = -EINVAL;
826                 else if (vd->owner != file)
827                         result = -EPERM;
828                 else {
829                         vd->owner = NULL;
830                         vd->owner_pid = 0;
831                         result = 0;
832                 }
833         }
834         up_write(&card->controls_rwsem);
835         return result;
836 }
837
838 struct user_element {
839         struct snd_ctl_elem_info info;
840         void *elem_data;                /* element data */
841         unsigned long elem_data_size;   /* size of element data in bytes */
842         void *priv_data;                /* private data (like strings for enumerated type) */
843         unsigned long priv_data_size;   /* size of private data in bytes */
844 };
845
846 static int snd_ctl_elem_user_info(struct snd_kcontrol *kcontrol,
847                                   struct snd_ctl_elem_info *uinfo)
848 {
849         struct user_element *ue = kcontrol->private_data;
850
851         *uinfo = ue->info;
852         return 0;
853 }
854
855 static int snd_ctl_elem_user_get(struct snd_kcontrol *kcontrol,
856                                  struct snd_ctl_elem_value *ucontrol)
857 {
858         struct user_element *ue = kcontrol->private_data;
859
860         memcpy(&ucontrol->value, ue->elem_data, ue->elem_data_size);
861         return 0;
862 }
863
864 static int snd_ctl_elem_user_put(struct snd_kcontrol *kcontrol,
865                                  struct snd_ctl_elem_value *ucontrol)
866 {
867         int change;
868         struct user_element *ue = kcontrol->private_data;
869         
870         change = memcmp(&ucontrol->value, ue->elem_data, ue->elem_data_size) != 0;
871         if (change)
872                 memcpy(ue->elem_data, &ucontrol->value, ue->elem_data_size);
873         return change;
874 }
875
876 static void snd_ctl_elem_user_free(struct snd_kcontrol *kcontrol)
877 {
878         kfree(kcontrol->private_data);
879 }
880
881 static int snd_ctl_elem_add(struct snd_ctl_file *file,
882                             struct snd_ctl_elem_info *info, int replace)
883 {
884         struct snd_card *card = file->card;
885         struct snd_kcontrol kctl, *_kctl;
886         unsigned int access;
887         long private_size;
888         struct user_element *ue;
889         int idx, err;
890         
891         if (card->user_ctl_count >= MAX_USER_CONTROLS)
892                 return -ENOMEM;
893         if (info->count > 1024)
894                 return -EINVAL;
895         access = info->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
896                 (info->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|
897                                  SNDRV_CTL_ELEM_ACCESS_INACTIVE));
898         info->id.numid = 0;
899         memset(&kctl, 0, sizeof(kctl));
900         down_write(&card->controls_rwsem);
901         _kctl = snd_ctl_find_id(card, &info->id);
902         err = 0;
903         if (_kctl) {
904                 if (replace)
905                         err = snd_ctl_remove(card, _kctl);
906                 else
907                         err = -EBUSY;
908         } else {
909                 if (replace)
910                         err = -ENOENT;
911         }
912         up_write(&card->controls_rwsem);
913         if (err < 0)
914                 return err;
915         memcpy(&kctl.id, &info->id, sizeof(info->id));
916         kctl.count = info->owner ? info->owner : 1;
917         access |= SNDRV_CTL_ELEM_ACCESS_USER;
918         kctl.info = snd_ctl_elem_user_info;
919         if (access & SNDRV_CTL_ELEM_ACCESS_READ)
920                 kctl.get = snd_ctl_elem_user_get;
921         if (access & SNDRV_CTL_ELEM_ACCESS_WRITE)
922                 kctl.put = snd_ctl_elem_user_put;
923         switch (info->type) {
924         case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
925                 private_size = sizeof(char);
926                 if (info->count > 128)
927                         return -EINVAL;
928                 break;
929         case SNDRV_CTL_ELEM_TYPE_INTEGER:
930                 private_size = sizeof(long);
931                 if (info->count > 128)
932                         return -EINVAL;
933                 break;
934         case SNDRV_CTL_ELEM_TYPE_INTEGER64:
935                 private_size = sizeof(long long);
936                 if (info->count > 64)
937                         return -EINVAL;
938                 break;
939         case SNDRV_CTL_ELEM_TYPE_BYTES:
940                 private_size = sizeof(unsigned char);
941                 if (info->count > 512)
942                         return -EINVAL;
943                 break;
944         case SNDRV_CTL_ELEM_TYPE_IEC958:
945                 private_size = sizeof(struct snd_aes_iec958);
946                 if (info->count != 1)
947                         return -EINVAL;
948                 break;
949         default:
950                 return -EINVAL;
951         }
952         private_size *= info->count;
953         ue = kzalloc(sizeof(struct user_element) + private_size, GFP_KERNEL);
954         if (ue == NULL)
955                 return -ENOMEM;
956         ue->info = *info;
957         ue->elem_data = (char *)ue + sizeof(*ue);
958         ue->elem_data_size = private_size;
959         kctl.private_free = snd_ctl_elem_user_free;
960         _kctl = snd_ctl_new(&kctl, access);
961         if (_kctl == NULL) {
962                 kfree(_kctl->private_data);
963                 return -ENOMEM;
964         }
965         _kctl->private_data = ue;
966         for (idx = 0; idx < _kctl->count; idx++)
967                 _kctl->vd[idx].owner = file;
968         err = snd_ctl_add(card, _kctl);
969         if (err < 0) {
970                 snd_ctl_free_one(_kctl);
971                 return err;
972         }
973
974         down_write(&card->controls_rwsem);
975         card->user_ctl_count++;
976         up_write(&card->controls_rwsem);
977
978         return 0;
979 }
980
981 static int snd_ctl_elem_add_user(struct snd_ctl_file *file,
982                                  struct snd_ctl_elem_info __user *_info, int replace)
983 {
984         struct snd_ctl_elem_info info;
985         if (copy_from_user(&info, _info, sizeof(info)))
986                 return -EFAULT;
987         return snd_ctl_elem_add(file, &info, replace);
988 }
989
990 static int snd_ctl_elem_remove(struct snd_ctl_file *file,
991                                struct snd_ctl_elem_id __user *_id)
992 {
993         struct snd_ctl_elem_id id;
994         int err;
995
996         if (copy_from_user(&id, _id, sizeof(id)))
997                 return -EFAULT;
998         err = snd_ctl_remove_unlocked_id(file, &id);
999         if (! err) {
1000                 struct snd_card *card = file->card;
1001                 down_write(&card->controls_rwsem);
1002                 card->user_ctl_count--;
1003                 up_write(&card->controls_rwsem);
1004         }
1005         return err;
1006 }
1007
1008 static int snd_ctl_subscribe_events(struct snd_ctl_file *file, int __user *ptr)
1009 {
1010         int subscribe;
1011         if (get_user(subscribe, ptr))
1012                 return -EFAULT;
1013         if (subscribe < 0) {
1014                 subscribe = file->subscribed;
1015                 if (put_user(subscribe, ptr))
1016                         return -EFAULT;
1017                 return 0;
1018         }
1019         if (subscribe) {
1020                 file->subscribed = 1;
1021                 return 0;
1022         } else if (file->subscribed) {
1023                 snd_ctl_empty_read_queue(file);
1024                 file->subscribed = 0;
1025         }
1026         return 0;
1027 }
1028
1029 static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1030 {
1031         struct snd_ctl_file *ctl;
1032         struct snd_card *card;
1033         struct list_head *list;
1034         struct snd_kctl_ioctl *p;
1035         void __user *argp = (void __user *)arg;
1036         int __user *ip = argp;
1037         int err;
1038
1039         ctl = file->private_data;
1040         card = ctl->card;
1041         snd_assert(card != NULL, return -ENXIO);
1042         switch (cmd) {
1043         case SNDRV_CTL_IOCTL_PVERSION:
1044                 return put_user(SNDRV_CTL_VERSION, ip) ? -EFAULT : 0;
1045         case SNDRV_CTL_IOCTL_CARD_INFO:
1046                 return snd_ctl_card_info(card, ctl, cmd, argp);
1047         case SNDRV_CTL_IOCTL_ELEM_LIST:
1048                 return snd_ctl_elem_list(ctl->card, argp);
1049         case SNDRV_CTL_IOCTL_ELEM_INFO:
1050                 return snd_ctl_elem_info_user(ctl, argp);
1051         case SNDRV_CTL_IOCTL_ELEM_READ:
1052                 return snd_ctl_elem_read_user(ctl->card, argp);
1053         case SNDRV_CTL_IOCTL_ELEM_WRITE:
1054                 return snd_ctl_elem_write_user(ctl, argp);
1055         case SNDRV_CTL_IOCTL_ELEM_LOCK:
1056                 return snd_ctl_elem_lock(ctl, argp);
1057         case SNDRV_CTL_IOCTL_ELEM_UNLOCK:
1058                 return snd_ctl_elem_unlock(ctl, argp);
1059         case SNDRV_CTL_IOCTL_ELEM_ADD:
1060                 return snd_ctl_elem_add_user(ctl, argp, 0);
1061         case SNDRV_CTL_IOCTL_ELEM_REPLACE:
1062                 return snd_ctl_elem_add_user(ctl, argp, 1);
1063         case SNDRV_CTL_IOCTL_ELEM_REMOVE:
1064                 return snd_ctl_elem_remove(ctl, argp);
1065         case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS:
1066                 return snd_ctl_subscribe_events(ctl, ip);
1067         case SNDRV_CTL_IOCTL_POWER:
1068                 return -ENOPROTOOPT;
1069         case SNDRV_CTL_IOCTL_POWER_STATE:
1070 #ifdef CONFIG_PM
1071                 return put_user(card->power_state, ip) ? -EFAULT : 0;
1072 #else
1073                 return put_user(SNDRV_CTL_POWER_D0, ip) ? -EFAULT : 0;
1074 #endif
1075         }
1076         down_read(&snd_ioctl_rwsem);
1077         list_for_each(list, &snd_control_ioctls) {
1078                 p = list_entry(list, struct snd_kctl_ioctl, list);
1079                 err = p->fioctl(card, ctl, cmd, arg);
1080                 if (err != -ENOIOCTLCMD) {
1081                         up_read(&snd_ioctl_rwsem);
1082                         return err;
1083                 }
1084         }
1085         up_read(&snd_ioctl_rwsem);
1086         snd_printdd("unknown ioctl = 0x%x\n", cmd);
1087         return -ENOTTY;
1088 }
1089
1090 static ssize_t snd_ctl_read(struct file *file, char __user *buffer,
1091                             size_t count, loff_t * offset)
1092 {
1093         struct snd_ctl_file *ctl;
1094         int err = 0;
1095         ssize_t result = 0;
1096
1097         ctl = file->private_data;
1098         snd_assert(ctl != NULL && ctl->card != NULL, return -ENXIO);
1099         if (!ctl->subscribed)
1100                 return -EBADFD;
1101         if (count < sizeof(struct snd_ctl_event))
1102                 return -EINVAL;
1103         spin_lock_irq(&ctl->read_lock);
1104         while (count >= sizeof(struct snd_ctl_event)) {
1105                 struct snd_ctl_event ev;
1106                 struct snd_kctl_event *kev;
1107                 while (list_empty(&ctl->events)) {
1108                         wait_queue_t wait;
1109                         if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {
1110                                 err = -EAGAIN;
1111                                 goto __end_lock;
1112                         }
1113                         init_waitqueue_entry(&wait, current);
1114                         add_wait_queue(&ctl->change_sleep, &wait);
1115                         set_current_state(TASK_INTERRUPTIBLE);
1116                         spin_unlock_irq(&ctl->read_lock);
1117                         schedule();
1118                         remove_wait_queue(&ctl->change_sleep, &wait);
1119                         if (signal_pending(current))
1120                                 return result > 0 ? result : -ERESTARTSYS;
1121                         spin_lock_irq(&ctl->read_lock);
1122                 }
1123                 kev = snd_kctl_event(ctl->events.next);
1124                 ev.type = SNDRV_CTL_EVENT_ELEM;
1125                 ev.data.elem.mask = kev->mask;
1126                 ev.data.elem.id = kev->id;
1127                 list_del(&kev->list);
1128                 spin_unlock_irq(&ctl->read_lock);
1129                 kfree(kev);
1130                 if (copy_to_user(buffer, &ev, sizeof(struct snd_ctl_event))) {
1131                         err = -EFAULT;
1132                         goto __end;
1133                 }
1134                 spin_lock_irq(&ctl->read_lock);
1135                 buffer += sizeof(struct snd_ctl_event);
1136                 count -= sizeof(struct snd_ctl_event);
1137                 result += sizeof(struct snd_ctl_event);
1138         }
1139       __end_lock:
1140         spin_unlock_irq(&ctl->read_lock);
1141       __end:
1142         return result > 0 ? result : err;
1143 }
1144
1145 static unsigned int snd_ctl_poll(struct file *file, poll_table * wait)
1146 {
1147         unsigned int mask;
1148         struct snd_ctl_file *ctl;
1149
1150         ctl = file->private_data;
1151         if (!ctl->subscribed)
1152                 return 0;
1153         poll_wait(file, &ctl->change_sleep, wait);
1154
1155         mask = 0;
1156         if (!list_empty(&ctl->events))
1157                 mask |= POLLIN | POLLRDNORM;
1158
1159         return mask;
1160 }
1161
1162 /*
1163  * register the device-specific control-ioctls.
1164  * called from each device manager like pcm.c, hwdep.c, etc.
1165  */
1166 static int _snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn, struct list_head *lists)
1167 {
1168         struct snd_kctl_ioctl *pn;
1169
1170         pn = kzalloc(sizeof(struct snd_kctl_ioctl), GFP_KERNEL);
1171         if (pn == NULL)
1172                 return -ENOMEM;
1173         pn->fioctl = fcn;
1174         down_write(&snd_ioctl_rwsem);
1175         list_add_tail(&pn->list, lists);
1176         up_write(&snd_ioctl_rwsem);
1177         return 0;
1178 }
1179
1180 int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn)
1181 {
1182         return _snd_ctl_register_ioctl(fcn, &snd_control_ioctls);
1183 }
1184
1185 #ifdef CONFIG_COMPAT
1186 int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn)
1187 {
1188         return _snd_ctl_register_ioctl(fcn, &snd_control_compat_ioctls);
1189 }
1190 #endif
1191
1192 /*
1193  * de-register the device-specific control-ioctls.
1194  */
1195 static int _snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn,
1196                                      struct list_head *lists)
1197 {
1198         struct list_head *list;
1199         struct snd_kctl_ioctl *p;
1200
1201         snd_assert(fcn != NULL, return -EINVAL);
1202         down_write(&snd_ioctl_rwsem);
1203         list_for_each(list, lists) {
1204                 p = list_entry(list, struct snd_kctl_ioctl, list);
1205                 if (p->fioctl == fcn) {
1206                         list_del(&p->list);
1207                         up_write(&snd_ioctl_rwsem);
1208                         kfree(p);
1209                         return 0;
1210                 }
1211         }
1212         up_write(&snd_ioctl_rwsem);
1213         snd_BUG();
1214         return -EINVAL;
1215 }
1216
1217 int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn)
1218 {
1219         return _snd_ctl_unregister_ioctl(fcn, &snd_control_ioctls);
1220 }
1221
1222 #ifdef CONFIG_COMPAT
1223 int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn)
1224 {
1225         return _snd_ctl_unregister_ioctl(fcn, &snd_control_compat_ioctls);
1226 }
1227
1228 #endif
1229
1230 static int snd_ctl_fasync(int fd, struct file * file, int on)
1231 {
1232         struct snd_ctl_file *ctl;
1233         int err;
1234         ctl = file->private_data;
1235         err = fasync_helper(fd, file, on, &ctl->fasync);
1236         if (err < 0)
1237                 return err;
1238         return 0;
1239 }
1240
1241 /*
1242  * ioctl32 compat
1243  */
1244 #ifdef CONFIG_COMPAT
1245 #include "control_compat.c"
1246 #else
1247 #define snd_ctl_ioctl_compat    NULL
1248 #endif
1249
1250 /*
1251  *  INIT PART
1252  */
1253
1254 static struct file_operations snd_ctl_f_ops =
1255 {
1256         .owner =        THIS_MODULE,
1257         .read =         snd_ctl_read,
1258         .open =         snd_ctl_open,
1259         .release =      snd_ctl_release,
1260         .poll =         snd_ctl_poll,
1261         .unlocked_ioctl =       snd_ctl_ioctl,
1262         .compat_ioctl = snd_ctl_ioctl_compat,
1263         .fasync =       snd_ctl_fasync,
1264 };
1265
1266 /*
1267  * registration of the control device
1268  */
1269 static int snd_ctl_dev_register(struct snd_device *device)
1270 {
1271         struct snd_card *card = device->device_data;
1272         int err, cardnum;
1273         char name[16];
1274
1275         snd_assert(card != NULL, return -ENXIO);
1276         cardnum = card->number;
1277         snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO);
1278         sprintf(name, "controlC%i", cardnum);
1279         if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1,
1280                                        &snd_ctl_f_ops, card, name)) < 0)
1281                 return err;
1282         return 0;
1283 }
1284
1285 /*
1286  * disconnection of the control device
1287  */
1288 static int snd_ctl_dev_disconnect(struct snd_device *device)
1289 {
1290         struct snd_card *card = device->device_data;
1291         struct list_head *flist;
1292         struct snd_ctl_file *ctl;
1293
1294         down_read(&card->controls_rwsem);
1295         list_for_each(flist, &card->ctl_files) {
1296                 ctl = snd_ctl_file(flist);
1297                 wake_up(&ctl->change_sleep);
1298                 kill_fasync(&ctl->fasync, SIGIO, POLL_ERR);
1299         }
1300         up_read(&card->controls_rwsem);
1301         return 0;
1302 }
1303
1304 /*
1305  * free all controls
1306  */
1307 static int snd_ctl_dev_free(struct snd_device *device)
1308 {
1309         struct snd_card *card = device->device_data;
1310         struct snd_kcontrol *control;
1311
1312         down_write(&card->controls_rwsem);
1313         while (!list_empty(&card->controls)) {
1314                 control = snd_kcontrol(card->controls.next);
1315                 snd_ctl_remove(card, control);
1316         }
1317         up_write(&card->controls_rwsem);
1318         return 0;
1319 }
1320
1321 /*
1322  * de-registration of the control device
1323  */
1324 static int snd_ctl_dev_unregister(struct snd_device *device)
1325 {
1326         struct snd_card *card = device->device_data;
1327         int err, cardnum;
1328
1329         snd_assert(card != NULL, return -ENXIO);
1330         cardnum = card->number;
1331         snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO);
1332         if ((err = snd_unregister_device(SNDRV_DEVICE_TYPE_CONTROL,
1333                                          card, -1)) < 0)
1334                 return err;
1335         return snd_ctl_dev_free(device);
1336 }
1337
1338 /*
1339  * create control core:
1340  * called from init.c
1341  */
1342 int snd_ctl_create(struct snd_card *card)
1343 {
1344         static struct snd_device_ops ops = {
1345                 .dev_free = snd_ctl_dev_free,
1346                 .dev_register = snd_ctl_dev_register,
1347                 .dev_disconnect = snd_ctl_dev_disconnect,
1348                 .dev_unregister = snd_ctl_dev_unregister
1349         };
1350
1351         snd_assert(card != NULL, return -ENXIO);
1352         return snd_device_new(card, SNDRV_DEV_CONTROL, card, &ops);
1353 }