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