GNU Linux-libre 4.19.314-gnu1
[releases.git] / sound / core / oss / mixer_oss.c
1 /*
2  *  OSS emulation layer for the mixer interface
3  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
4  *
5  *
6  *   This program is free software; you can redistribute it and/or modify
7  *   it under the terms of the GNU General Public License as published by
8  *   the Free Software Foundation; either version 2 of the License, or
9  *   (at your option) any later version.
10  *
11  *   This program is distributed in the hope that it will be useful,
12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *   GNU General Public License for more details.
15  *
16  *   You should have received a copy of the GNU General Public License
17  *   along with this program; if not, write to the Free Software
18  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19  *
20  */
21
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/time.h>
25 #include <linux/string.h>
26 #include <linux/module.h>
27 #include <linux/compat.h>
28 #include <sound/core.h>
29 #include <sound/minors.h>
30 #include <sound/control.h>
31 #include <sound/info.h>
32 #include <sound/mixer_oss.h>
33 #include <linux/soundcard.h>
34
35 #define OSS_ALSAEMULVER         _SIOR ('M', 249, int)
36
37 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
38 MODULE_DESCRIPTION("Mixer OSS emulation for ALSA.");
39 MODULE_LICENSE("GPL");
40 MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_MIXER);
41
42 static int snd_mixer_oss_open(struct inode *inode, struct file *file)
43 {
44         struct snd_card *card;
45         struct snd_mixer_oss_file *fmixer;
46         int err;
47
48         err = nonseekable_open(inode, file);
49         if (err < 0)
50                 return err;
51
52         card = snd_lookup_oss_minor_data(iminor(inode),
53                                          SNDRV_OSS_DEVICE_TYPE_MIXER);
54         if (card == NULL)
55                 return -ENODEV;
56         if (card->mixer_oss == NULL) {
57                 snd_card_unref(card);
58                 return -ENODEV;
59         }
60         err = snd_card_file_add(card, file);
61         if (err < 0) {
62                 snd_card_unref(card);
63                 return err;
64         }
65         fmixer = kzalloc(sizeof(*fmixer), GFP_KERNEL);
66         if (fmixer == NULL) {
67                 snd_card_file_remove(card, file);
68                 snd_card_unref(card);
69                 return -ENOMEM;
70         }
71         fmixer->card = card;
72         fmixer->mixer = card->mixer_oss;
73         file->private_data = fmixer;
74         if (!try_module_get(card->module)) {
75                 kfree(fmixer);
76                 snd_card_file_remove(card, file);
77                 snd_card_unref(card);
78                 return -EFAULT;
79         }
80         snd_card_unref(card);
81         return 0;
82 }
83
84 static int snd_mixer_oss_release(struct inode *inode, struct file *file)
85 {
86         struct snd_mixer_oss_file *fmixer;
87
88         if (file->private_data) {
89                 fmixer = file->private_data;
90                 module_put(fmixer->card->module);
91                 snd_card_file_remove(fmixer->card, file);
92                 kfree(fmixer);
93         }
94         return 0;
95 }
96
97 static int snd_mixer_oss_info(struct snd_mixer_oss_file *fmixer,
98                               mixer_info __user *_info)
99 {
100         struct snd_card *card = fmixer->card;
101         struct snd_mixer_oss *mixer = fmixer->mixer;
102         struct mixer_info info;
103         
104         memset(&info, 0, sizeof(info));
105         strlcpy(info.id, mixer && mixer->id[0] ? mixer->id : card->driver, sizeof(info.id));
106         strlcpy(info.name, mixer && mixer->name[0] ? mixer->name : card->mixername, sizeof(info.name));
107         info.modify_counter = card->mixer_oss_change_count;
108         if (copy_to_user(_info, &info, sizeof(info)))
109                 return -EFAULT;
110         return 0;
111 }
112
113 static int snd_mixer_oss_info_obsolete(struct snd_mixer_oss_file *fmixer,
114                                        _old_mixer_info __user *_info)
115 {
116         struct snd_card *card = fmixer->card;
117         struct snd_mixer_oss *mixer = fmixer->mixer;
118         _old_mixer_info info;
119         
120         memset(&info, 0, sizeof(info));
121         strlcpy(info.id, mixer && mixer->id[0] ? mixer->id : card->driver, sizeof(info.id));
122         strlcpy(info.name, mixer && mixer->name[0] ? mixer->name : card->mixername, sizeof(info.name));
123         if (copy_to_user(_info, &info, sizeof(info)))
124                 return -EFAULT;
125         return 0;
126 }
127
128 static int snd_mixer_oss_caps(struct snd_mixer_oss_file *fmixer)
129 {
130         struct snd_mixer_oss *mixer = fmixer->mixer;
131         int result = 0;
132
133         if (mixer == NULL)
134                 return -EIO;
135         if (mixer->get_recsrc && mixer->put_recsrc)
136                 result |= SOUND_CAP_EXCL_INPUT;
137         return result;
138 }
139
140 static int snd_mixer_oss_devmask(struct snd_mixer_oss_file *fmixer)
141 {
142         struct snd_mixer_oss *mixer = fmixer->mixer;
143         struct snd_mixer_oss_slot *pslot;
144         int result = 0, chn;
145
146         if (mixer == NULL)
147                 return -EIO;
148         mutex_lock(&mixer->reg_mutex);
149         for (chn = 0; chn < 31; chn++) {
150                 pslot = &mixer->slots[chn];
151                 if (pslot->put_volume || pslot->put_recsrc)
152                         result |= 1 << chn;
153         }
154         mutex_unlock(&mixer->reg_mutex);
155         return result;
156 }
157
158 static int snd_mixer_oss_stereodevs(struct snd_mixer_oss_file *fmixer)
159 {
160         struct snd_mixer_oss *mixer = fmixer->mixer;
161         struct snd_mixer_oss_slot *pslot;
162         int result = 0, chn;
163
164         if (mixer == NULL)
165                 return -EIO;
166         mutex_lock(&mixer->reg_mutex);
167         for (chn = 0; chn < 31; chn++) {
168                 pslot = &mixer->slots[chn];
169                 if (pslot->put_volume && pslot->stereo)
170                         result |= 1 << chn;
171         }
172         mutex_unlock(&mixer->reg_mutex);
173         return result;
174 }
175
176 static int snd_mixer_oss_recmask(struct snd_mixer_oss_file *fmixer)
177 {
178         struct snd_mixer_oss *mixer = fmixer->mixer;
179         int result = 0;
180
181         if (mixer == NULL)
182                 return -EIO;
183         mutex_lock(&mixer->reg_mutex);
184         if (mixer->put_recsrc && mixer->get_recsrc) {   /* exclusive */
185                 result = mixer->mask_recsrc;
186         } else {
187                 struct snd_mixer_oss_slot *pslot;
188                 int chn;
189                 for (chn = 0; chn < 31; chn++) {
190                         pslot = &mixer->slots[chn];
191                         if (pslot->put_recsrc)
192                                 result |= 1 << chn;
193                 }
194         }
195         mutex_unlock(&mixer->reg_mutex);
196         return result;
197 }
198
199 static int snd_mixer_oss_get_recsrc(struct snd_mixer_oss_file *fmixer)
200 {
201         struct snd_mixer_oss *mixer = fmixer->mixer;
202         int result = 0;
203
204         if (mixer == NULL)
205                 return -EIO;
206         mutex_lock(&mixer->reg_mutex);
207         if (mixer->put_recsrc && mixer->get_recsrc) {   /* exclusive */
208                 unsigned int index;
209                 result = mixer->get_recsrc(fmixer, &index);
210                 if (result < 0)
211                         goto unlock;
212                 result = 1 << index;
213         } else {
214                 struct snd_mixer_oss_slot *pslot;
215                 int chn;
216                 for (chn = 0; chn < 31; chn++) {
217                         pslot = &mixer->slots[chn];
218                         if (pslot->get_recsrc) {
219                                 int active = 0;
220                                 pslot->get_recsrc(fmixer, pslot, &active);
221                                 if (active)
222                                         result |= 1 << chn;
223                         }
224                 }
225         }
226         mixer->oss_recsrc = result;
227  unlock:
228         mutex_unlock(&mixer->reg_mutex);
229         return result;
230 }
231
232 static int snd_mixer_oss_set_recsrc(struct snd_mixer_oss_file *fmixer, int recsrc)
233 {
234         struct snd_mixer_oss *mixer = fmixer->mixer;
235         struct snd_mixer_oss_slot *pslot;
236         int chn, active;
237         unsigned int index;
238         int result = 0;
239
240         if (mixer == NULL)
241                 return -EIO;
242         mutex_lock(&mixer->reg_mutex);
243         if (mixer->get_recsrc && mixer->put_recsrc) {   /* exclusive input */
244                 if (recsrc & ~mixer->oss_recsrc)
245                         recsrc &= ~mixer->oss_recsrc;
246                 mixer->put_recsrc(fmixer, ffz(~recsrc));
247                 mixer->get_recsrc(fmixer, &index);
248                 result = 1 << index;
249         }
250         for (chn = 0; chn < 31; chn++) {
251                 pslot = &mixer->slots[chn];
252                 if (pslot->put_recsrc) {
253                         active = (recsrc & (1 << chn)) ? 1 : 0;
254                         pslot->put_recsrc(fmixer, pslot, active);
255                 }
256         }
257         if (! result) {
258                 for (chn = 0; chn < 31; chn++) {
259                         pslot = &mixer->slots[chn];
260                         if (pslot->get_recsrc) {
261                                 active = 0;
262                                 pslot->get_recsrc(fmixer, pslot, &active);
263                                 if (active)
264                                         result |= 1 << chn;
265                         }
266                 }
267         }
268         mutex_unlock(&mixer->reg_mutex);
269         return result;
270 }
271
272 static int snd_mixer_oss_get_volume(struct snd_mixer_oss_file *fmixer, int slot)
273 {
274         struct snd_mixer_oss *mixer = fmixer->mixer;
275         struct snd_mixer_oss_slot *pslot;
276         int result = 0, left, right;
277
278         if (mixer == NULL || slot > 30)
279                 return -EIO;
280         mutex_lock(&mixer->reg_mutex);
281         pslot = &mixer->slots[slot];
282         left = pslot->volume[0];
283         right = pslot->volume[1];
284         if (pslot->get_volume)
285                 result = pslot->get_volume(fmixer, pslot, &left, &right);
286         if (!pslot->stereo)
287                 right = left;
288         if (snd_BUG_ON(left < 0 || left > 100)) {
289                 result = -EIO;
290                 goto unlock;
291         }
292         if (snd_BUG_ON(right < 0 || right > 100)) {
293                 result = -EIO;
294                 goto unlock;
295         }
296         if (result >= 0) {
297                 pslot->volume[0] = left;
298                 pslot->volume[1] = right;
299                 result = (left & 0xff) | ((right & 0xff) << 8);
300         }
301  unlock:
302         mutex_unlock(&mixer->reg_mutex);
303         return result;
304 }
305
306 static int snd_mixer_oss_set_volume(struct snd_mixer_oss_file *fmixer,
307                                     int slot, int volume)
308 {
309         struct snd_mixer_oss *mixer = fmixer->mixer;
310         struct snd_mixer_oss_slot *pslot;
311         int result = 0, left = volume & 0xff, right = (volume >> 8) & 0xff;
312
313         if (mixer == NULL || slot > 30)
314                 return -EIO;
315         mutex_lock(&mixer->reg_mutex);
316         pslot = &mixer->slots[slot];
317         if (left > 100)
318                 left = 100;
319         if (right > 100)
320                 right = 100;
321         if (!pslot->stereo)
322                 right = left;
323         if (pslot->put_volume)
324                 result = pslot->put_volume(fmixer, pslot, left, right);
325         if (result < 0)
326                 goto unlock;
327         pslot->volume[0] = left;
328         pslot->volume[1] = right;
329         result = (left & 0xff) | ((right & 0xff) << 8);
330  unlock:
331         mutex_unlock(&mixer->reg_mutex);
332         return result;
333 }
334
335 static int snd_mixer_oss_ioctl1(struct snd_mixer_oss_file *fmixer, unsigned int cmd, unsigned long arg)
336 {
337         void __user *argp = (void __user *)arg;
338         int __user *p = argp;
339         int tmp;
340
341         if (snd_BUG_ON(!fmixer))
342                 return -ENXIO;
343         if (((cmd >> 8) & 0xff) == 'M') {
344                 switch (cmd) {
345                 case SOUND_MIXER_INFO:
346                         return snd_mixer_oss_info(fmixer, argp);
347                 case SOUND_OLD_MIXER_INFO:
348                         return snd_mixer_oss_info_obsolete(fmixer, argp);
349                 case SOUND_MIXER_WRITE_RECSRC:
350                         if (get_user(tmp, p))
351                                 return -EFAULT;
352                         tmp = snd_mixer_oss_set_recsrc(fmixer, tmp);
353                         if (tmp < 0)
354                                 return tmp;
355                         return put_user(tmp, p);
356                 case OSS_GETVERSION:
357                         return put_user(SNDRV_OSS_VERSION, p);
358                 case OSS_ALSAEMULVER:
359                         return put_user(1, p);
360                 case SOUND_MIXER_READ_DEVMASK:
361                         tmp = snd_mixer_oss_devmask(fmixer);
362                         if (tmp < 0)
363                                 return tmp;
364                         return put_user(tmp, p);
365                 case SOUND_MIXER_READ_STEREODEVS:
366                         tmp = snd_mixer_oss_stereodevs(fmixer);
367                         if (tmp < 0)
368                                 return tmp;
369                         return put_user(tmp, p);
370                 case SOUND_MIXER_READ_RECMASK:
371                         tmp = snd_mixer_oss_recmask(fmixer);
372                         if (tmp < 0)
373                                 return tmp;
374                         return put_user(tmp, p);
375                 case SOUND_MIXER_READ_CAPS:
376                         tmp = snd_mixer_oss_caps(fmixer);
377                         if (tmp < 0)
378                                 return tmp;
379                         return put_user(tmp, p);
380                 case SOUND_MIXER_READ_RECSRC:
381                         tmp = snd_mixer_oss_get_recsrc(fmixer);
382                         if (tmp < 0)
383                                 return tmp;
384                         return put_user(tmp, p);
385                 }
386         }
387         if (cmd & SIOC_IN) {
388                 if (get_user(tmp, p))
389                         return -EFAULT;
390                 tmp = snd_mixer_oss_set_volume(fmixer, cmd & 0xff, tmp);
391                 if (tmp < 0)
392                         return tmp;
393                 return put_user(tmp, p);
394         } else if (cmd & SIOC_OUT) {
395                 tmp = snd_mixer_oss_get_volume(fmixer, cmd & 0xff);
396                 if (tmp < 0)
397                         return tmp;
398                 return put_user(tmp, p);
399         }
400         return -ENXIO;
401 }
402
403 static long snd_mixer_oss_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
404 {
405         return snd_mixer_oss_ioctl1(file->private_data, cmd, arg);
406 }
407
408 int snd_mixer_oss_ioctl_card(struct snd_card *card, unsigned int cmd, unsigned long arg)
409 {
410         struct snd_mixer_oss_file fmixer;
411         
412         if (snd_BUG_ON(!card))
413                 return -ENXIO;
414         if (card->mixer_oss == NULL)
415                 return -ENXIO;
416         memset(&fmixer, 0, sizeof(fmixer));
417         fmixer.card = card;
418         fmixer.mixer = card->mixer_oss;
419         return snd_mixer_oss_ioctl1(&fmixer, cmd, arg);
420 }
421 EXPORT_SYMBOL(snd_mixer_oss_ioctl_card);
422
423 #ifdef CONFIG_COMPAT
424 /* all compatible */
425 static long snd_mixer_oss_ioctl_compat(struct file *file, unsigned int cmd,
426                                        unsigned long arg)
427 {
428         return snd_mixer_oss_ioctl1(file->private_data, cmd,
429                                     (unsigned long)compat_ptr(arg));
430 }
431 #else
432 #define snd_mixer_oss_ioctl_compat      NULL
433 #endif
434
435 /*
436  *  REGISTRATION PART
437  */
438
439 static const struct file_operations snd_mixer_oss_f_ops =
440 {
441         .owner =        THIS_MODULE,
442         .open =         snd_mixer_oss_open,
443         .release =      snd_mixer_oss_release,
444         .llseek =       no_llseek,
445         .unlocked_ioctl =       snd_mixer_oss_ioctl,
446         .compat_ioctl = snd_mixer_oss_ioctl_compat,
447 };
448
449 /*
450  *  utilities
451  */
452
453 static long snd_mixer_oss_conv(long val, long omin, long omax, long nmin, long nmax)
454 {
455         long orange = omax - omin, nrange = nmax - nmin;
456         
457         if (orange == 0)
458                 return 0;
459         return ((nrange * (val - omin)) + (orange / 2)) / orange + nmin;
460 }
461
462 /* convert from alsa native to oss values (0-100) */
463 static long snd_mixer_oss_conv1(long val, long min, long max, int *old)
464 {
465         if (val == snd_mixer_oss_conv(*old, 0, 100, min, max))
466                 return *old;
467         return snd_mixer_oss_conv(val, min, max, 0, 100);
468 }
469
470 /* convert from oss to alsa native values */
471 static long snd_mixer_oss_conv2(long val, long min, long max)
472 {
473         return snd_mixer_oss_conv(val, 0, 100, min, max);
474 }
475
476 #if 0
477 static void snd_mixer_oss_recsrce_set(struct snd_card *card, int slot)
478 {
479         struct snd_mixer_oss *mixer = card->mixer_oss;
480         if (mixer)
481                 mixer->mask_recsrc |= 1 << slot;
482 }
483
484 static int snd_mixer_oss_recsrce_get(struct snd_card *card, int slot)
485 {
486         struct snd_mixer_oss *mixer = card->mixer_oss;
487         if (mixer && (mixer->mask_recsrc & (1 << slot)))
488                 return 1;
489         return 0;
490 }
491 #endif
492
493 #define SNDRV_MIXER_OSS_SIGNATURE               0x65999250
494
495 #define SNDRV_MIXER_OSS_ITEM_GLOBAL     0
496 #define SNDRV_MIXER_OSS_ITEM_GSWITCH    1
497 #define SNDRV_MIXER_OSS_ITEM_GROUTE     2
498 #define SNDRV_MIXER_OSS_ITEM_GVOLUME    3
499 #define SNDRV_MIXER_OSS_ITEM_PSWITCH    4
500 #define SNDRV_MIXER_OSS_ITEM_PROUTE     5
501 #define SNDRV_MIXER_OSS_ITEM_PVOLUME    6
502 #define SNDRV_MIXER_OSS_ITEM_CSWITCH    7
503 #define SNDRV_MIXER_OSS_ITEM_CROUTE     8
504 #define SNDRV_MIXER_OSS_ITEM_CVOLUME    9
505 #define SNDRV_MIXER_OSS_ITEM_CAPTURE    10
506
507 #define SNDRV_MIXER_OSS_ITEM_COUNT      11
508
509 #define SNDRV_MIXER_OSS_PRESENT_GLOBAL  (1<<0)
510 #define SNDRV_MIXER_OSS_PRESENT_GSWITCH (1<<1)
511 #define SNDRV_MIXER_OSS_PRESENT_GROUTE  (1<<2)
512 #define SNDRV_MIXER_OSS_PRESENT_GVOLUME (1<<3)
513 #define SNDRV_MIXER_OSS_PRESENT_PSWITCH (1<<4)
514 #define SNDRV_MIXER_OSS_PRESENT_PROUTE  (1<<5)
515 #define SNDRV_MIXER_OSS_PRESENT_PVOLUME (1<<6)
516 #define SNDRV_MIXER_OSS_PRESENT_CSWITCH (1<<7)
517 #define SNDRV_MIXER_OSS_PRESENT_CROUTE  (1<<8)
518 #define SNDRV_MIXER_OSS_PRESENT_CVOLUME (1<<9)
519 #define SNDRV_MIXER_OSS_PRESENT_CAPTURE (1<<10)
520
521 struct slot {
522         unsigned int signature;
523         unsigned int present;
524         unsigned int channels;
525         unsigned int numid[SNDRV_MIXER_OSS_ITEM_COUNT];
526         unsigned int capture_item;
527         struct snd_mixer_oss_assign_table *assigned;
528         unsigned int allocated: 1;
529 };
530
531 #define ID_UNKNOWN      ((unsigned int)-1)
532
533 static struct snd_kcontrol *snd_mixer_oss_test_id(struct snd_mixer_oss *mixer, const char *name, int index)
534 {
535         struct snd_card *card = mixer->card;
536         struct snd_ctl_elem_id id;
537         
538         memset(&id, 0, sizeof(id));
539         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
540         strlcpy(id.name, name, sizeof(id.name));
541         id.index = index;
542         return snd_ctl_find_id(card, &id);
543 }
544
545 static void snd_mixer_oss_get_volume1_vol(struct snd_mixer_oss_file *fmixer,
546                                           struct snd_mixer_oss_slot *pslot,
547                                           unsigned int numid,
548                                           int *left, int *right)
549 {
550         struct snd_ctl_elem_info *uinfo;
551         struct snd_ctl_elem_value *uctl;
552         struct snd_kcontrol *kctl;
553         struct snd_card *card = fmixer->card;
554
555         if (numid == ID_UNKNOWN)
556                 return;
557         down_read(&card->controls_rwsem);
558         if ((kctl = snd_ctl_find_numid(card, numid)) == NULL) {
559                 up_read(&card->controls_rwsem);
560                 return;
561         }
562         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
563         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
564         if (uinfo == NULL || uctl == NULL)
565                 goto __unalloc;
566         if (kctl->info(kctl, uinfo))
567                 goto __unalloc;
568         if (kctl->get(kctl, uctl))
569                 goto __unalloc;
570         if (uinfo->type == SNDRV_CTL_ELEM_TYPE_BOOLEAN &&
571             uinfo->value.integer.min == 0 && uinfo->value.integer.max == 1)
572                 goto __unalloc;
573         *left = snd_mixer_oss_conv1(uctl->value.integer.value[0], uinfo->value.integer.min, uinfo->value.integer.max, &pslot->volume[0]);
574         if (uinfo->count > 1)
575                 *right = snd_mixer_oss_conv1(uctl->value.integer.value[1], uinfo->value.integer.min, uinfo->value.integer.max, &pslot->volume[1]);
576       __unalloc:
577         up_read(&card->controls_rwsem);
578         kfree(uctl);
579         kfree(uinfo);
580 }
581
582 static void snd_mixer_oss_get_volume1_sw(struct snd_mixer_oss_file *fmixer,
583                                          struct snd_mixer_oss_slot *pslot,
584                                          unsigned int numid,
585                                          int *left, int *right,
586                                          int route)
587 {
588         struct snd_ctl_elem_info *uinfo;
589         struct snd_ctl_elem_value *uctl;
590         struct snd_kcontrol *kctl;
591         struct snd_card *card = fmixer->card;
592
593         if (numid == ID_UNKNOWN)
594                 return;
595         down_read(&card->controls_rwsem);
596         if ((kctl = snd_ctl_find_numid(card, numid)) == NULL) {
597                 up_read(&card->controls_rwsem);
598                 return;
599         }
600         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
601         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
602         if (uinfo == NULL || uctl == NULL)
603                 goto __unalloc;
604         if (kctl->info(kctl, uinfo))
605                 goto __unalloc;
606         if (kctl->get(kctl, uctl))
607                 goto __unalloc;
608         if (!uctl->value.integer.value[0]) {
609                 *left = 0;
610                 if (uinfo->count == 1)
611                         *right = 0;
612         }
613         if (uinfo->count > 1 && !uctl->value.integer.value[route ? 3 : 1])
614                 *right = 0;
615       __unalloc:
616         up_read(&card->controls_rwsem);
617         kfree(uctl);
618         kfree(uinfo);
619 }
620
621 static int snd_mixer_oss_get_volume1(struct snd_mixer_oss_file *fmixer,
622                                      struct snd_mixer_oss_slot *pslot,
623                                      int *left, int *right)
624 {
625         struct slot *slot = pslot->private_data;
626         
627         *left = *right = 100;
628         if (slot->present & SNDRV_MIXER_OSS_PRESENT_PVOLUME) {
629                 snd_mixer_oss_get_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PVOLUME], left, right);
630         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GVOLUME) {
631                 snd_mixer_oss_get_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GVOLUME], left, right);
632         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GLOBAL) {
633                 snd_mixer_oss_get_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GLOBAL], left, right);
634         }
635         if (slot->present & SNDRV_MIXER_OSS_PRESENT_PSWITCH) {
636                 snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PSWITCH], left, right, 0);
637         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GSWITCH) {
638                 snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GSWITCH], left, right, 0);
639         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_PROUTE) {
640                 snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PROUTE], left, right, 1);
641         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GROUTE) {
642                 snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GROUTE], left, right, 1);
643         }
644         return 0;
645 }
646
647 static void snd_mixer_oss_put_volume1_vol(struct snd_mixer_oss_file *fmixer,
648                                           struct snd_mixer_oss_slot *pslot,
649                                           unsigned int numid,
650                                           int left, int right)
651 {
652         struct snd_ctl_elem_info *uinfo;
653         struct snd_ctl_elem_value *uctl;
654         struct snd_kcontrol *kctl;
655         struct snd_card *card = fmixer->card;
656         int res;
657
658         if (numid == ID_UNKNOWN)
659                 return;
660         down_read(&card->controls_rwsem);
661         if ((kctl = snd_ctl_find_numid(card, numid)) == NULL) {
662                 up_read(&card->controls_rwsem);
663                 return;
664         }
665         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
666         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
667         if (uinfo == NULL || uctl == NULL)
668                 goto __unalloc;
669         if (kctl->info(kctl, uinfo))
670                 goto __unalloc;
671         if (uinfo->type == SNDRV_CTL_ELEM_TYPE_BOOLEAN &&
672             uinfo->value.integer.min == 0 && uinfo->value.integer.max == 1)
673                 goto __unalloc;
674         uctl->value.integer.value[0] = snd_mixer_oss_conv2(left, uinfo->value.integer.min, uinfo->value.integer.max);
675         if (uinfo->count > 1)
676                 uctl->value.integer.value[1] = snd_mixer_oss_conv2(right, uinfo->value.integer.min, uinfo->value.integer.max);
677         if ((res = kctl->put(kctl, uctl)) < 0)
678                 goto __unalloc;
679         if (res > 0)
680                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &kctl->id);
681       __unalloc:
682         up_read(&card->controls_rwsem);
683         kfree(uctl);
684         kfree(uinfo);
685 }
686
687 static void snd_mixer_oss_put_volume1_sw(struct snd_mixer_oss_file *fmixer,
688                                          struct snd_mixer_oss_slot *pslot,
689                                          unsigned int numid,
690                                          int left, int right,
691                                          int route)
692 {
693         struct snd_ctl_elem_info *uinfo;
694         struct snd_ctl_elem_value *uctl;
695         struct snd_kcontrol *kctl;
696         struct snd_card *card = fmixer->card;
697         int res;
698
699         if (numid == ID_UNKNOWN)
700                 return;
701         down_read(&card->controls_rwsem);
702         if ((kctl = snd_ctl_find_numid(card, numid)) == NULL) {
703                 up_read(&card->controls_rwsem);
704                 return;
705         }
706         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
707         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
708         if (uinfo == NULL || uctl == NULL)
709                 goto __unalloc;
710         if (kctl->info(kctl, uinfo))
711                 goto __unalloc;
712         if (uinfo->count > 1) {
713                 uctl->value.integer.value[0] = left > 0 ? 1 : 0;
714                 uctl->value.integer.value[route ? 3 : 1] = right > 0 ? 1 : 0;
715                 if (route) {
716                         uctl->value.integer.value[1] =
717                         uctl->value.integer.value[2] = 0;
718                 }
719         } else {
720                 uctl->value.integer.value[0] = (left > 0 || right > 0) ? 1 : 0;
721         }
722         if ((res = kctl->put(kctl, uctl)) < 0)
723                 goto __unalloc;
724         if (res > 0)
725                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &kctl->id);
726       __unalloc:
727         up_read(&card->controls_rwsem);
728         kfree(uctl);
729         kfree(uinfo);
730 }
731
732 static int snd_mixer_oss_put_volume1(struct snd_mixer_oss_file *fmixer,
733                                      struct snd_mixer_oss_slot *pslot,
734                                      int left, int right)
735 {
736         struct slot *slot = pslot->private_data;
737         
738         if (slot->present & SNDRV_MIXER_OSS_PRESENT_PVOLUME) {
739                 snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PVOLUME], left, right);
740                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_CVOLUME)
741                         snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CVOLUME], left, right);
742         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_CVOLUME) {
743                 snd_mixer_oss_put_volume1_vol(fmixer, pslot,
744                         slot->numid[SNDRV_MIXER_OSS_ITEM_CVOLUME], left, right);
745         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GVOLUME) {
746                 snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GVOLUME], left, right);
747         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GLOBAL) {
748                 snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GLOBAL], left, right);
749         }
750         if (left || right) {
751                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_PSWITCH)
752                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PSWITCH], left, right, 0);
753                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_CSWITCH)
754                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CSWITCH], left, right, 0);
755                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_GSWITCH)
756                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GSWITCH], left, right, 0);
757                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_PROUTE)
758                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PROUTE], left, right, 1);
759                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_CROUTE)
760                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CROUTE], left, right, 1);
761                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_GROUTE)
762                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GROUTE], left, right, 1);
763         } else {
764                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_PSWITCH) {
765                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PSWITCH], left, right, 0);
766                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_CSWITCH) {
767                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CSWITCH], left, right, 0);
768                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GSWITCH) {
769                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GSWITCH], left, right, 0);
770                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_PROUTE) {
771                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PROUTE], left, right, 1);
772                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_CROUTE) {
773                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CROUTE], left, right, 1);
774                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GROUTE) {
775                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GROUTE], left, right, 1);
776                 }
777         }
778         return 0;
779 }
780
781 static int snd_mixer_oss_get_recsrc1_sw(struct snd_mixer_oss_file *fmixer,
782                                         struct snd_mixer_oss_slot *pslot,
783                                         int *active)
784 {
785         struct slot *slot = pslot->private_data;
786         int left, right;
787         
788         left = right = 1;
789         snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CSWITCH], &left, &right, 0);
790         *active = (left || right) ? 1 : 0;
791         return 0;
792 }
793
794 static int snd_mixer_oss_get_recsrc1_route(struct snd_mixer_oss_file *fmixer,
795                                            struct snd_mixer_oss_slot *pslot,
796                                            int *active)
797 {
798         struct slot *slot = pslot->private_data;
799         int left, right;
800         
801         left = right = 1;
802         snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CROUTE], &left, &right, 1);
803         *active = (left || right) ? 1 : 0;
804         return 0;
805 }
806
807 static int snd_mixer_oss_put_recsrc1_sw(struct snd_mixer_oss_file *fmixer,
808                                         struct snd_mixer_oss_slot *pslot,
809                                         int active)
810 {
811         struct slot *slot = pslot->private_data;
812         
813         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CSWITCH], active, active, 0);
814         return 0;
815 }
816
817 static int snd_mixer_oss_put_recsrc1_route(struct snd_mixer_oss_file *fmixer,
818                                            struct snd_mixer_oss_slot *pslot,
819                                            int active)
820 {
821         struct slot *slot = pslot->private_data;
822         
823         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CROUTE], active, active, 1);
824         return 0;
825 }
826
827 static int snd_mixer_oss_get_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned int *active_index)
828 {
829         struct snd_card *card = fmixer->card;
830         struct snd_mixer_oss *mixer = fmixer->mixer;
831         struct snd_kcontrol *kctl;
832         struct snd_mixer_oss_slot *pslot;
833         struct slot *slot;
834         struct snd_ctl_elem_info *uinfo;
835         struct snd_ctl_elem_value *uctl;
836         int err, idx;
837         
838         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
839         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
840         if (uinfo == NULL || uctl == NULL) {
841                 err = -ENOMEM;
842                 goto __free_only;
843         }
844         down_read(&card->controls_rwsem);
845         kctl = snd_mixer_oss_test_id(mixer, "Capture Source", 0);
846         if (! kctl) {
847                 err = -ENOENT;
848                 goto __unlock;
849         }
850         if ((err = kctl->info(kctl, uinfo)) < 0)
851                 goto __unlock;
852         if ((err = kctl->get(kctl, uctl)) < 0)
853                 goto __unlock;
854         for (idx = 0; idx < 32; idx++) {
855                 if (!(mixer->mask_recsrc & (1 << idx)))
856                         continue;
857                 pslot = &mixer->slots[idx];
858                 slot = pslot->private_data;
859                 if (slot->signature != SNDRV_MIXER_OSS_SIGNATURE)
860                         continue;
861                 if (!(slot->present & SNDRV_MIXER_OSS_PRESENT_CAPTURE))
862                         continue;
863                 if (slot->capture_item == uctl->value.enumerated.item[0]) {
864                         *active_index = idx;
865                         break;
866                 }
867         }
868         err = 0;
869       __unlock:
870         up_read(&card->controls_rwsem);
871       __free_only:
872         kfree(uctl);
873         kfree(uinfo);
874         return err;
875 }
876
877 static int snd_mixer_oss_put_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned int active_index)
878 {
879         struct snd_card *card = fmixer->card;
880         struct snd_mixer_oss *mixer = fmixer->mixer;
881         struct snd_kcontrol *kctl;
882         struct snd_mixer_oss_slot *pslot;
883         struct slot *slot = NULL;
884         struct snd_ctl_elem_info *uinfo;
885         struct snd_ctl_elem_value *uctl;
886         int err;
887         unsigned int idx;
888
889         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
890         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
891         if (uinfo == NULL || uctl == NULL) {
892                 err = -ENOMEM;
893                 goto __free_only;
894         }
895         down_read(&card->controls_rwsem);
896         kctl = snd_mixer_oss_test_id(mixer, "Capture Source", 0);
897         if (! kctl) {
898                 err = -ENOENT;
899                 goto __unlock;
900         }
901         if ((err = kctl->info(kctl, uinfo)) < 0)
902                 goto __unlock;
903         for (idx = 0; idx < 32; idx++) {
904                 if (!(mixer->mask_recsrc & (1 << idx)))
905                         continue;
906                 pslot = &mixer->slots[idx];
907                 slot = pslot->private_data;
908                 if (slot->signature != SNDRV_MIXER_OSS_SIGNATURE)
909                         continue;
910                 if (!(slot->present & SNDRV_MIXER_OSS_PRESENT_CAPTURE))
911                         continue;
912                 if (idx == active_index)
913                         break;
914                 slot = NULL;
915         }
916         if (! slot)
917                 goto __unlock;
918         for (idx = 0; idx < uinfo->count; idx++)
919                 uctl->value.enumerated.item[idx] = slot->capture_item;
920         err = kctl->put(kctl, uctl);
921         if (err > 0)
922                 snd_ctl_notify(fmixer->card, SNDRV_CTL_EVENT_MASK_VALUE, &kctl->id);
923         err = 0;
924       __unlock:
925         up_read(&card->controls_rwsem);
926       __free_only:
927         kfree(uctl);
928         kfree(uinfo);
929         return err;
930 }
931
932 struct snd_mixer_oss_assign_table {
933         int oss_id;
934         const char *name;
935         int index;
936 };
937
938 static int snd_mixer_oss_build_test(struct snd_mixer_oss *mixer, struct slot *slot, const char *name, int index, int item)
939 {
940         struct snd_ctl_elem_info *info;
941         struct snd_kcontrol *kcontrol;
942         struct snd_card *card = mixer->card;
943         int err;
944
945         down_read(&card->controls_rwsem);
946         kcontrol = snd_mixer_oss_test_id(mixer, name, index);
947         if (kcontrol == NULL) {
948                 up_read(&card->controls_rwsem);
949                 return 0;
950         }
951         info = kmalloc(sizeof(*info), GFP_KERNEL);
952         if (! info) {
953                 up_read(&card->controls_rwsem);
954                 return -ENOMEM;
955         }
956         if ((err = kcontrol->info(kcontrol, info)) < 0) {
957                 up_read(&card->controls_rwsem);
958                 kfree(info);
959                 return err;
960         }
961         slot->numid[item] = kcontrol->id.numid;
962         up_read(&card->controls_rwsem);
963         if (info->count > slot->channels)
964                 slot->channels = info->count;
965         slot->present |= 1 << item;
966         kfree(info);
967         return 0;
968 }
969
970 static void snd_mixer_oss_slot_free(struct snd_mixer_oss_slot *chn)
971 {
972         struct slot *p = chn->private_data;
973         if (p) {
974                 if (p->allocated && p->assigned) {
975                         kfree(p->assigned->name);
976                         kfree(p->assigned);
977                 }
978                 kfree(p);
979         }
980 }
981
982 static void mixer_slot_clear(struct snd_mixer_oss_slot *rslot)
983 {
984         int idx = rslot->number; /* remember this */
985         if (rslot->private_free)
986                 rslot->private_free(rslot);
987         memset(rslot, 0, sizeof(*rslot));
988         rslot->number = idx;
989 }
990
991 /* In a separate function to keep gcc 3.2 happy - do NOT merge this in
992    snd_mixer_oss_build_input! */
993 static int snd_mixer_oss_build_test_all(struct snd_mixer_oss *mixer,
994                                         struct snd_mixer_oss_assign_table *ptr,
995                                         struct slot *slot)
996 {
997         char str[64];
998         int err;
999
1000         err = snd_mixer_oss_build_test(mixer, slot, ptr->name, ptr->index,
1001                                        SNDRV_MIXER_OSS_ITEM_GLOBAL);
1002         if (err)
1003                 return err;
1004         sprintf(str, "%s Switch", ptr->name);
1005         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1006                                        SNDRV_MIXER_OSS_ITEM_GSWITCH);
1007         if (err)
1008                 return err;
1009         sprintf(str, "%s Route", ptr->name);
1010         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1011                                        SNDRV_MIXER_OSS_ITEM_GROUTE);
1012         if (err)
1013                 return err;
1014         sprintf(str, "%s Volume", ptr->name);
1015         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1016                                        SNDRV_MIXER_OSS_ITEM_GVOLUME);
1017         if (err)
1018                 return err;
1019         sprintf(str, "%s Playback Switch", ptr->name);
1020         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1021                                        SNDRV_MIXER_OSS_ITEM_PSWITCH);
1022         if (err)
1023                 return err;
1024         sprintf(str, "%s Playback Route", ptr->name);
1025         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1026                                        SNDRV_MIXER_OSS_ITEM_PROUTE);
1027         if (err)
1028                 return err;
1029         sprintf(str, "%s Playback Volume", ptr->name);
1030         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1031                                        SNDRV_MIXER_OSS_ITEM_PVOLUME);
1032         if (err)
1033                 return err;
1034         sprintf(str, "%s Capture Switch", ptr->name);
1035         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1036                                        SNDRV_MIXER_OSS_ITEM_CSWITCH);
1037         if (err)
1038                 return err;
1039         sprintf(str, "%s Capture Route", ptr->name);
1040         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1041                                        SNDRV_MIXER_OSS_ITEM_CROUTE);
1042         if (err)
1043                 return err;
1044         sprintf(str, "%s Capture Volume", ptr->name);
1045         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1046                                        SNDRV_MIXER_OSS_ITEM_CVOLUME);
1047         if (err)
1048                 return err;
1049
1050         return 0;
1051 }
1052
1053 /*
1054  * build an OSS mixer element.
1055  * ptr_allocated means the entry is dynamically allocated (change via proc file).
1056  * when replace_old = 1, the old entry is replaced with the new one.
1057  */
1058 static int snd_mixer_oss_build_input(struct snd_mixer_oss *mixer, struct snd_mixer_oss_assign_table *ptr, int ptr_allocated, int replace_old)
1059 {
1060         struct slot slot;
1061         struct slot *pslot;
1062         struct snd_kcontrol *kctl;
1063         struct snd_mixer_oss_slot *rslot;
1064         char str[64];   
1065         
1066         /* check if already assigned */
1067         if (mixer->slots[ptr->oss_id].get_volume && ! replace_old)
1068                 return 0;
1069
1070         memset(&slot, 0, sizeof(slot));
1071         memset(slot.numid, 0xff, sizeof(slot.numid)); /* ID_UNKNOWN */
1072         if (snd_mixer_oss_build_test_all(mixer, ptr, &slot))
1073                 return 0;
1074         down_read(&mixer->card->controls_rwsem);
1075         if (ptr->index == 0 && (kctl = snd_mixer_oss_test_id(mixer, "Capture Source", 0)) != NULL) {
1076                 struct snd_ctl_elem_info *uinfo;
1077
1078                 uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
1079                 if (! uinfo) {
1080                         up_read(&mixer->card->controls_rwsem);
1081                         return -ENOMEM;
1082                 }
1083                         
1084                 if (kctl->info(kctl, uinfo)) {
1085                         up_read(&mixer->card->controls_rwsem);
1086                         kfree(uinfo);
1087                         return 0;
1088                 }
1089                 strcpy(str, ptr->name);
1090                 if (!strcmp(str, "Master"))
1091                         strcpy(str, "Mix");
1092                 if (!strcmp(str, "Master Mono"))
1093                         strcpy(str, "Mix Mono");
1094                 slot.capture_item = 0;
1095                 if (!strcmp(uinfo->value.enumerated.name, str)) {
1096                         slot.present |= SNDRV_MIXER_OSS_PRESENT_CAPTURE;
1097                 } else {
1098                         for (slot.capture_item = 1; slot.capture_item < uinfo->value.enumerated.items; slot.capture_item++) {
1099                                 uinfo->value.enumerated.item = slot.capture_item;
1100                                 if (kctl->info(kctl, uinfo)) {
1101                                         up_read(&mixer->card->controls_rwsem);
1102                                         kfree(uinfo);
1103                                         return 0;
1104                                 }
1105                                 if (!strcmp(uinfo->value.enumerated.name, str)) {
1106                                         slot.present |= SNDRV_MIXER_OSS_PRESENT_CAPTURE;
1107                                         break;
1108                                 }
1109                         }
1110                 }
1111                 kfree(uinfo);
1112         }
1113         up_read(&mixer->card->controls_rwsem);
1114         if (slot.present != 0) {
1115                 pslot = kmalloc(sizeof(slot), GFP_KERNEL);
1116                 if (! pslot)
1117                         return -ENOMEM;
1118                 *pslot = slot;
1119                 pslot->signature = SNDRV_MIXER_OSS_SIGNATURE;
1120                 pslot->assigned = ptr;
1121                 pslot->allocated = ptr_allocated;
1122                 rslot = &mixer->slots[ptr->oss_id];
1123                 mixer_slot_clear(rslot);
1124                 rslot->stereo = slot.channels > 1 ? 1 : 0;
1125                 rslot->get_volume = snd_mixer_oss_get_volume1;
1126                 rslot->put_volume = snd_mixer_oss_put_volume1;
1127                 /* note: ES18xx have both Capture Source and XX Capture Volume !!! */
1128                 if (slot.present & SNDRV_MIXER_OSS_PRESENT_CSWITCH) {
1129                         rslot->get_recsrc = snd_mixer_oss_get_recsrc1_sw;
1130                         rslot->put_recsrc = snd_mixer_oss_put_recsrc1_sw;
1131                 } else if (slot.present & SNDRV_MIXER_OSS_PRESENT_CROUTE) {
1132                         rslot->get_recsrc = snd_mixer_oss_get_recsrc1_route;
1133                         rslot->put_recsrc = snd_mixer_oss_put_recsrc1_route;
1134                 } else if (slot.present & SNDRV_MIXER_OSS_PRESENT_CAPTURE) {
1135                         mixer->mask_recsrc |= 1 << ptr->oss_id;
1136                 }
1137                 rslot->private_data = pslot;
1138                 rslot->private_free = snd_mixer_oss_slot_free;
1139                 return 1;
1140         }
1141         return 0;
1142 }
1143
1144 #ifdef CONFIG_SND_PROC_FS
1145 /*
1146  */
1147 #define MIXER_VOL(name) [SOUND_MIXER_##name] = #name
1148 static char *oss_mixer_names[SNDRV_OSS_MAX_MIXERS] = {
1149         MIXER_VOL(VOLUME),
1150         MIXER_VOL(BASS),
1151         MIXER_VOL(TREBLE),
1152         MIXER_VOL(SYNTH),
1153         MIXER_VOL(PCM),
1154         MIXER_VOL(SPEAKER),
1155         MIXER_VOL(LINE),
1156         MIXER_VOL(MIC),
1157         MIXER_VOL(CD),
1158         MIXER_VOL(IMIX),
1159         MIXER_VOL(ALTPCM),
1160         MIXER_VOL(RECLEV),
1161         MIXER_VOL(IGAIN),
1162         MIXER_VOL(OGAIN),
1163         MIXER_VOL(LINE1),
1164         MIXER_VOL(LINE2),
1165         MIXER_VOL(LINE3),
1166         MIXER_VOL(DIGITAL1),
1167         MIXER_VOL(DIGITAL2),
1168         MIXER_VOL(DIGITAL3),
1169         MIXER_VOL(PHONEIN),
1170         MIXER_VOL(PHONEOUT),
1171         MIXER_VOL(VIDEO),
1172         MIXER_VOL(RADIO),
1173         MIXER_VOL(MONITOR),
1174 };
1175         
1176 /*
1177  *  /proc interface
1178  */
1179
1180 static void snd_mixer_oss_proc_read(struct snd_info_entry *entry,
1181                                     struct snd_info_buffer *buffer)
1182 {
1183         struct snd_mixer_oss *mixer = entry->private_data;
1184         int i;
1185
1186         mutex_lock(&mixer->reg_mutex);
1187         for (i = 0; i < SNDRV_OSS_MAX_MIXERS; i++) {
1188                 struct slot *p;
1189
1190                 if (! oss_mixer_names[i])
1191                         continue;
1192                 p = (struct slot *)mixer->slots[i].private_data;
1193                 snd_iprintf(buffer, "%s ", oss_mixer_names[i]);
1194                 if (p && p->assigned)
1195                         snd_iprintf(buffer, "\"%s\" %d\n",
1196                                     p->assigned->name,
1197                                     p->assigned->index);
1198                 else
1199                         snd_iprintf(buffer, "\"\" 0\n");
1200         }
1201         mutex_unlock(&mixer->reg_mutex);
1202 }
1203
1204 static void snd_mixer_oss_proc_write(struct snd_info_entry *entry,
1205                                      struct snd_info_buffer *buffer)
1206 {
1207         struct snd_mixer_oss *mixer = entry->private_data;
1208         char line[128], str[32], idxstr[16];
1209         const char *cptr;
1210         unsigned int idx;
1211         int ch;
1212         struct snd_mixer_oss_assign_table *tbl;
1213         struct slot *slot;
1214
1215         while (!snd_info_get_line(buffer, line, sizeof(line))) {
1216                 cptr = snd_info_get_str(str, line, sizeof(str));
1217                 for (ch = 0; ch < SNDRV_OSS_MAX_MIXERS; ch++)
1218                         if (oss_mixer_names[ch] && strcmp(oss_mixer_names[ch], str) == 0)
1219                                 break;
1220                 if (ch >= SNDRV_OSS_MAX_MIXERS) {
1221                         pr_err("ALSA: mixer_oss: invalid OSS volume '%s'\n",
1222                                str);
1223                         continue;
1224                 }
1225                 cptr = snd_info_get_str(str, cptr, sizeof(str));
1226                 if (! *str) {
1227                         /* remove the entry */
1228                         mutex_lock(&mixer->reg_mutex);
1229                         mixer_slot_clear(&mixer->slots[ch]);
1230                         mutex_unlock(&mixer->reg_mutex);
1231                         continue;
1232                 }
1233                 snd_info_get_str(idxstr, cptr, sizeof(idxstr));
1234                 idx = simple_strtoul(idxstr, NULL, 10);
1235                 if (idx >= 0x4000) { /* too big */
1236                         pr_err("ALSA: mixer_oss: invalid index %d\n", idx);
1237                         continue;
1238                 }
1239                 mutex_lock(&mixer->reg_mutex);
1240                 slot = (struct slot *)mixer->slots[ch].private_data;
1241                 if (slot && slot->assigned &&
1242                     slot->assigned->index == idx && ! strcmp(slot->assigned->name, str))
1243                         /* not changed */
1244                         goto __unlock;
1245                 tbl = kmalloc(sizeof(*tbl), GFP_KERNEL);
1246                 if (!tbl)
1247                         goto __unlock;
1248                 tbl->oss_id = ch;
1249                 tbl->name = kstrdup(str, GFP_KERNEL);
1250                 if (! tbl->name) {
1251                         kfree(tbl);
1252                         goto __unlock;
1253                 }
1254                 tbl->index = idx;
1255                 if (snd_mixer_oss_build_input(mixer, tbl, 1, 1) <= 0) {
1256                         kfree(tbl->name);
1257                         kfree(tbl);
1258                 }
1259         __unlock:
1260                 mutex_unlock(&mixer->reg_mutex);
1261         }
1262 }
1263
1264 static void snd_mixer_oss_proc_init(struct snd_mixer_oss *mixer)
1265 {
1266         struct snd_info_entry *entry;
1267
1268         entry = snd_info_create_card_entry(mixer->card, "oss_mixer",
1269                                            mixer->card->proc_root);
1270         if (! entry)
1271                 return;
1272         entry->content = SNDRV_INFO_CONTENT_TEXT;
1273         entry->mode = S_IFREG | 0644;
1274         entry->c.text.read = snd_mixer_oss_proc_read;
1275         entry->c.text.write = snd_mixer_oss_proc_write;
1276         entry->private_data = mixer;
1277         if (snd_info_register(entry) < 0) {
1278                 snd_info_free_entry(entry);
1279                 entry = NULL;
1280         }
1281         mixer->proc_entry = entry;
1282 }
1283
1284 static void snd_mixer_oss_proc_done(struct snd_mixer_oss *mixer)
1285 {
1286         snd_info_free_entry(mixer->proc_entry);
1287         mixer->proc_entry = NULL;
1288 }
1289 #else /* !CONFIG_SND_PROC_FS */
1290 #define snd_mixer_oss_proc_init(mix)
1291 #define snd_mixer_oss_proc_done(mix)
1292 #endif /* CONFIG_SND_PROC_FS */
1293
1294 static void snd_mixer_oss_build(struct snd_mixer_oss *mixer)
1295 {
1296         static struct snd_mixer_oss_assign_table table[] = {
1297                 { SOUND_MIXER_VOLUME,   "Master",               0 },
1298                 { SOUND_MIXER_VOLUME,   "Front",                0 }, /* fallback */
1299                 { SOUND_MIXER_BASS,     "Tone Control - Bass",  0 },
1300                 { SOUND_MIXER_TREBLE,   "Tone Control - Treble", 0 },
1301                 { SOUND_MIXER_SYNTH,    "Synth",                0 },
1302                 { SOUND_MIXER_SYNTH,    "FM",                   0 }, /* fallback */
1303                 { SOUND_MIXER_SYNTH,    "Music",                0 }, /* fallback */
1304                 { SOUND_MIXER_PCM,      "PCM",                  0 },
1305                 { SOUND_MIXER_SPEAKER,  "Beep",                 0 },
1306                 { SOUND_MIXER_SPEAKER,  "PC Speaker",           0 }, /* fallback */
1307                 { SOUND_MIXER_SPEAKER,  "Speaker",              0 }, /* fallback */
1308                 { SOUND_MIXER_LINE,     "Line",                 0 },
1309                 { SOUND_MIXER_MIC,      "Mic",                  0 },
1310                 { SOUND_MIXER_CD,       "CD",                   0 },
1311                 { SOUND_MIXER_IMIX,     "Monitor Mix",          0 },
1312                 { SOUND_MIXER_ALTPCM,   "PCM",                  1 },
1313                 { SOUND_MIXER_ALTPCM,   "Headphone",            0 }, /* fallback */
1314                 { SOUND_MIXER_ALTPCM,   "Wave",                 0 }, /* fallback */
1315                 { SOUND_MIXER_RECLEV,   "-- nothing --",        0 },
1316                 { SOUND_MIXER_IGAIN,    "Capture",              0 },
1317                 { SOUND_MIXER_OGAIN,    "Playback",             0 },
1318                 { SOUND_MIXER_LINE1,    "Aux",                  0 },
1319                 { SOUND_MIXER_LINE2,    "Aux",                  1 },
1320                 { SOUND_MIXER_LINE3,    "Aux",                  2 },
1321                 { SOUND_MIXER_DIGITAL1, "Digital",              0 },
1322                 { SOUND_MIXER_DIGITAL1, "IEC958",               0 }, /* fallback */
1323                 { SOUND_MIXER_DIGITAL1, "IEC958 Optical",       0 }, /* fallback */
1324                 { SOUND_MIXER_DIGITAL1, "IEC958 Coaxial",       0 }, /* fallback */
1325                 { SOUND_MIXER_DIGITAL2, "Digital",              1 },
1326                 { SOUND_MIXER_DIGITAL3, "Digital",              2 },
1327                 { SOUND_MIXER_PHONEIN,  "Phone",                0 },
1328                 { SOUND_MIXER_PHONEOUT, "Master Mono",          0 },
1329                 { SOUND_MIXER_PHONEOUT, "Speaker",              0 }, /*fallback*/
1330                 { SOUND_MIXER_PHONEOUT, "Mono",                 0 }, /*fallback*/
1331                 { SOUND_MIXER_PHONEOUT, "Phone",                0 }, /* fallback */
1332                 { SOUND_MIXER_VIDEO,    "Video",                0 },
1333                 { SOUND_MIXER_RADIO,    "Radio",                0 },
1334                 { SOUND_MIXER_MONITOR,  "Monitor",              0 }
1335         };
1336         unsigned int idx;
1337         
1338         for (idx = 0; idx < ARRAY_SIZE(table); idx++)
1339                 snd_mixer_oss_build_input(mixer, &table[idx], 0, 0);
1340         if (mixer->mask_recsrc) {
1341                 mixer->get_recsrc = snd_mixer_oss_get_recsrc2;
1342                 mixer->put_recsrc = snd_mixer_oss_put_recsrc2;
1343         }
1344 }
1345
1346 /*
1347  *
1348  */
1349
1350 static int snd_mixer_oss_free1(void *private)
1351 {
1352         struct snd_mixer_oss *mixer = private;
1353         struct snd_card *card;
1354         int idx;
1355  
1356         if (!mixer)
1357                 return 0;
1358         card = mixer->card;
1359         if (snd_BUG_ON(mixer != card->mixer_oss))
1360                 return -ENXIO;
1361         card->mixer_oss = NULL;
1362         for (idx = 0; idx < SNDRV_OSS_MAX_MIXERS; idx++) {
1363                 struct snd_mixer_oss_slot *chn = &mixer->slots[idx];
1364                 if (chn->private_free)
1365                         chn->private_free(chn);
1366         }
1367         kfree(mixer);
1368         return 0;
1369 }
1370
1371 static int snd_mixer_oss_notify_handler(struct snd_card *card, int cmd)
1372 {
1373         struct snd_mixer_oss *mixer;
1374
1375         if (cmd == SND_MIXER_OSS_NOTIFY_REGISTER) {
1376                 int idx, err;
1377
1378                 mixer = kcalloc(2, sizeof(*mixer), GFP_KERNEL);
1379                 if (mixer == NULL)
1380                         return -ENOMEM;
1381                 mutex_init(&mixer->reg_mutex);
1382                 if ((err = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIXER,
1383                                                    card, 0,
1384                                                    &snd_mixer_oss_f_ops, card)) < 0) {
1385                         dev_err(card->dev,
1386                                 "unable to register OSS mixer device %i:%i\n",
1387                                 card->number, 0);
1388                         kfree(mixer);
1389                         return err;
1390                 }
1391                 mixer->oss_dev_alloc = 1;
1392                 mixer->card = card;
1393                 if (*card->mixername)
1394                         strlcpy(mixer->name, card->mixername, sizeof(mixer->name));
1395                 else
1396                         snprintf(mixer->name, sizeof(mixer->name),
1397                                  "mixer%i", card->number);
1398 #ifdef SNDRV_OSS_INFO_DEV_MIXERS
1399                 snd_oss_info_register(SNDRV_OSS_INFO_DEV_MIXERS,
1400                                       card->number,
1401                                       mixer->name);
1402 #endif
1403                 for (idx = 0; idx < SNDRV_OSS_MAX_MIXERS; idx++)
1404                         mixer->slots[idx].number = idx;
1405                 card->mixer_oss = mixer;
1406                 snd_mixer_oss_build(mixer);
1407                 snd_mixer_oss_proc_init(mixer);
1408         } else {
1409                 mixer = card->mixer_oss;
1410                 if (mixer == NULL)
1411                         return 0;
1412                 if (mixer->oss_dev_alloc) {
1413 #ifdef SNDRV_OSS_INFO_DEV_MIXERS
1414                         snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_MIXERS, mixer->card->number);
1415 #endif
1416                         snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIXER, mixer->card, 0);
1417                         mixer->oss_dev_alloc = 0;
1418                 }
1419                 if (cmd == SND_MIXER_OSS_NOTIFY_DISCONNECT)
1420                         return 0;
1421                 snd_mixer_oss_proc_done(mixer);
1422                 return snd_mixer_oss_free1(mixer);
1423         }
1424         return 0;
1425 }
1426
1427 static int __init alsa_mixer_oss_init(void)
1428 {
1429         int idx;
1430         
1431         snd_mixer_oss_notify_callback = snd_mixer_oss_notify_handler;
1432         for (idx = 0; idx < SNDRV_CARDS; idx++) {
1433                 if (snd_cards[idx])
1434                         snd_mixer_oss_notify_handler(snd_cards[idx], SND_MIXER_OSS_NOTIFY_REGISTER);
1435         }
1436         return 0;
1437 }
1438
1439 static void __exit alsa_mixer_oss_exit(void)
1440 {
1441         int idx;
1442
1443         snd_mixer_oss_notify_callback = NULL;
1444         for (idx = 0; idx < SNDRV_CARDS; idx++) {
1445                 if (snd_cards[idx])
1446                         snd_mixer_oss_notify_handler(snd_cards[idx], SND_MIXER_OSS_NOTIFY_FREE);
1447         }
1448 }
1449
1450 module_init(alsa_mixer_oss_init)
1451 module_exit(alsa_mixer_oss_exit)