~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/core/oss/mixer_oss.c

Version: ~ [ linux-6.2-rc3 ] ~ [ linux-6.1.5 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.87 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.162 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.228 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.269 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.302 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-or-later
  2 /*
  3  *  OSS emulation layer for the mixer interface
  4  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
  5  */
  6 
  7 #include <linux/init.h>
  8 #include <linux/slab.h>
  9 #include <linux/time.h>
 10 #include <linux/string.h>
 11 #include <linux/module.h>
 12 #include <linux/compat.h>
 13 #include <sound/core.h>
 14 #include <sound/minors.h>
 15 #include <sound/control.h>
 16 #include <sound/info.h>
 17 #include <sound/mixer_oss.h>
 18 #include <linux/soundcard.h>
 19 
 20 #define OSS_ALSAEMULVER         _SIOR ('M', 249, int)
 21 
 22 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
 23 MODULE_DESCRIPTION("Mixer OSS emulation for ALSA.");
 24 MODULE_LICENSE("GPL");
 25 MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_MIXER);
 26 
 27 static int snd_mixer_oss_open(struct inode *inode, struct file *file)
 28 {
 29         struct snd_card *card;
 30         struct snd_mixer_oss_file *fmixer;
 31         int err;
 32 
 33         err = nonseekable_open(inode, file);
 34         if (err < 0)
 35                 return err;
 36 
 37         card = snd_lookup_oss_minor_data(iminor(inode),
 38                                          SNDRV_OSS_DEVICE_TYPE_MIXER);
 39         if (card == NULL)
 40                 return -ENODEV;
 41         if (card->mixer_oss == NULL) {
 42                 snd_card_unref(card);
 43                 return -ENODEV;
 44         }
 45         err = snd_card_file_add(card, file);
 46         if (err < 0) {
 47                 snd_card_unref(card);
 48                 return err;
 49         }
 50         fmixer = kzalloc(sizeof(*fmixer), GFP_KERNEL);
 51         if (fmixer == NULL) {
 52                 snd_card_file_remove(card, file);
 53                 snd_card_unref(card);
 54                 return -ENOMEM;
 55         }
 56         fmixer->card = card;
 57         fmixer->mixer = card->mixer_oss;
 58         file->private_data = fmixer;
 59         if (!try_module_get(card->module)) {
 60                 kfree(fmixer);
 61                 snd_card_file_remove(card, file);
 62                 snd_card_unref(card);
 63                 return -EFAULT;
 64         }
 65         snd_card_unref(card);
 66         return 0;
 67 }
 68 
 69 static int snd_mixer_oss_release(struct inode *inode, struct file *file)
 70 {
 71         struct snd_mixer_oss_file *fmixer;
 72 
 73         if (file->private_data) {
 74                 fmixer = file->private_data;
 75                 module_put(fmixer->card->module);
 76                 snd_card_file_remove(fmixer->card, file);
 77                 kfree(fmixer);
 78         }
 79         return 0;
 80 }
 81 
 82 static int snd_mixer_oss_info(struct snd_mixer_oss_file *fmixer,
 83                               mixer_info __user *_info)
 84 {
 85         struct snd_card *card = fmixer->card;
 86         struct snd_mixer_oss *mixer = fmixer->mixer;
 87         struct mixer_info info;
 88         
 89         memset(&info, 0, sizeof(info));
 90         strscpy(info.id, mixer && mixer->id[0] ? mixer->id : card->driver, sizeof(info.id));
 91         strscpy(info.name, mixer && mixer->name[0] ? mixer->name : card->mixername, sizeof(info.name));
 92         info.modify_counter = card->mixer_oss_change_count;
 93         if (copy_to_user(_info, &info, sizeof(info)))
 94                 return -EFAULT;
 95         return 0;
 96 }
 97 
 98 static int snd_mixer_oss_info_obsolete(struct snd_mixer_oss_file *fmixer,
 99                                        _old_mixer_info __user *_info)
100 {
101         struct snd_card *card = fmixer->card;
102         struct snd_mixer_oss *mixer = fmixer->mixer;
103         _old_mixer_info info;
104         
105         memset(&info, 0, sizeof(info));
106         strscpy(info.id, mixer && mixer->id[0] ? mixer->id : card->driver, sizeof(info.id));
107         strscpy(info.name, mixer && mixer->name[0] ? mixer->name : card->mixername, sizeof(info.name));
108         if (copy_to_user(_info, &info, sizeof(info)))
109                 return -EFAULT;
110         return 0;
111 }
112 
113 static int snd_mixer_oss_caps(struct snd_mixer_oss_file *fmixer)
114 {
115         struct snd_mixer_oss *mixer = fmixer->mixer;
116         int result = 0;
117 
118         if (mixer == NULL)
119                 return -EIO;
120         if (mixer->get_recsrc && mixer->put_recsrc)
121                 result |= SOUND_CAP_EXCL_INPUT;
122         return result;
123 }
124 
125 static int snd_mixer_oss_devmask(struct snd_mixer_oss_file *fmixer)
126 {
127         struct snd_mixer_oss *mixer = fmixer->mixer;
128         struct snd_mixer_oss_slot *pslot;
129         int result = 0, chn;
130 
131         if (mixer == NULL)
132                 return -EIO;
133         mutex_lock(&mixer->reg_mutex);
134         for (chn = 0; chn < 31; chn++) {
135                 pslot = &mixer->slots[chn];
136                 if (pslot->put_volume || pslot->put_recsrc)
137                         result |= 1 << chn;
138         }
139         mutex_unlock(&mixer->reg_mutex);
140         return result;
141 }
142 
143 static int snd_mixer_oss_stereodevs(struct snd_mixer_oss_file *fmixer)
144 {
145         struct snd_mixer_oss *mixer = fmixer->mixer;
146         struct snd_mixer_oss_slot *pslot;
147         int result = 0, chn;
148 
149         if (mixer == NULL)
150                 return -EIO;
151         mutex_lock(&mixer->reg_mutex);
152         for (chn = 0; chn < 31; chn++) {
153                 pslot = &mixer->slots[chn];
154                 if (pslot->put_volume && pslot->stereo)
155                         result |= 1 << chn;
156         }
157         mutex_unlock(&mixer->reg_mutex);
158         return result;
159 }
160 
161 static int snd_mixer_oss_recmask(struct snd_mixer_oss_file *fmixer)
162 {
163         struct snd_mixer_oss *mixer = fmixer->mixer;
164         int result = 0;
165 
166         if (mixer == NULL)
167                 return -EIO;
168         mutex_lock(&mixer->reg_mutex);
169         if (mixer->put_recsrc && mixer->get_recsrc) {   /* exclusive */
170                 result = mixer->mask_recsrc;
171         } else {
172                 struct snd_mixer_oss_slot *pslot;
173                 int chn;
174                 for (chn = 0; chn < 31; chn++) {
175                         pslot = &mixer->slots[chn];
176                         if (pslot->put_recsrc)
177                                 result |= 1 << chn;
178                 }
179         }
180         mutex_unlock(&mixer->reg_mutex);
181         return result;
182 }
183 
184 static int snd_mixer_oss_get_recsrc(struct snd_mixer_oss_file *fmixer)
185 {
186         struct snd_mixer_oss *mixer = fmixer->mixer;
187         int result = 0;
188 
189         if (mixer == NULL)
190                 return -EIO;
191         mutex_lock(&mixer->reg_mutex);
192         if (mixer->put_recsrc && mixer->get_recsrc) {   /* exclusive */
193                 unsigned int index;
194                 result = mixer->get_recsrc(fmixer, &index);
195                 if (result < 0)
196                         goto unlock;
197                 result = 1 << index;
198         } else {
199                 struct snd_mixer_oss_slot *pslot;
200                 int chn;
201                 for (chn = 0; chn < 31; chn++) {
202                         pslot = &mixer->slots[chn];
203                         if (pslot->get_recsrc) {
204                                 int active = 0;
205                                 pslot->get_recsrc(fmixer, pslot, &active);
206                                 if (active)
207                                         result |= 1 << chn;
208                         }
209                 }
210         }
211         mixer->oss_recsrc = result;
212  unlock:
213         mutex_unlock(&mixer->reg_mutex);
214         return result;
215 }
216 
217 static int snd_mixer_oss_set_recsrc(struct snd_mixer_oss_file *fmixer, int recsrc)
218 {
219         struct snd_mixer_oss *mixer = fmixer->mixer;
220         struct snd_mixer_oss_slot *pslot;
221         int chn, active;
222         unsigned int index;
223         int result = 0;
224 
225         if (mixer == NULL)
226                 return -EIO;
227         mutex_lock(&mixer->reg_mutex);
228         if (mixer->get_recsrc && mixer->put_recsrc) {   /* exclusive input */
229                 if (recsrc & ~mixer->oss_recsrc)
230                         recsrc &= ~mixer->oss_recsrc;
231                 mixer->put_recsrc(fmixer, ffz(~recsrc));
232                 mixer->get_recsrc(fmixer, &index);
233                 result = 1 << index;
234         }
235         for (chn = 0; chn < 31; chn++) {
236                 pslot = &mixer->slots[chn];
237                 if (pslot->put_recsrc) {
238                         active = (recsrc & (1 << chn)) ? 1 : 0;
239                         pslot->put_recsrc(fmixer, pslot, active);
240                 }
241         }
242         if (! result) {
243                 for (chn = 0; chn < 31; chn++) {
244                         pslot = &mixer->slots[chn];
245                         if (pslot->get_recsrc) {
246                                 active = 0;
247                                 pslot->get_recsrc(fmixer, pslot, &active);
248                                 if (active)
249                                         result |= 1 << chn;
250                         }
251                 }
252         }
253         mutex_unlock(&mixer->reg_mutex);
254         return result;
255 }
256 
257 static int snd_mixer_oss_get_volume(struct snd_mixer_oss_file *fmixer, int slot)
258 {
259         struct snd_mixer_oss *mixer = fmixer->mixer;
260         struct snd_mixer_oss_slot *pslot;
261         int result = 0, left, right;
262 
263         if (mixer == NULL || slot > 30)
264                 return -EIO;
265         mutex_lock(&mixer->reg_mutex);
266         pslot = &mixer->slots[slot];
267         left = pslot->volume[0];
268         right = pslot->volume[1];
269         if (pslot->get_volume)
270                 result = pslot->get_volume(fmixer, pslot, &left, &right);
271         if (!pslot->stereo)
272                 right = left;
273         if (snd_BUG_ON(left < 0 || left > 100)) {
274                 result = -EIO;
275                 goto unlock;
276         }
277         if (snd_BUG_ON(right < 0 || right > 100)) {
278                 result = -EIO;
279                 goto unlock;
280         }
281         if (result >= 0) {
282                 pslot->volume[0] = left;
283                 pslot->volume[1] = right;
284                 result = (left & 0xff) | ((right & 0xff) << 8);
285         }
286  unlock:
287         mutex_unlock(&mixer->reg_mutex);
288         return result;
289 }
290 
291 static int snd_mixer_oss_set_volume(struct snd_mixer_oss_file *fmixer,
292                                     int slot, int volume)
293 {
294         struct snd_mixer_oss *mixer = fmixer->mixer;
295         struct snd_mixer_oss_slot *pslot;
296         int result = 0, left = volume & 0xff, right = (volume >> 8) & 0xff;
297 
298         if (mixer == NULL || slot > 30)
299                 return -EIO;
300         mutex_lock(&mixer->reg_mutex);
301         pslot = &mixer->slots[slot];
302         if (left > 100)
303                 left = 100;
304         if (right > 100)
305                 right = 100;
306         if (!pslot->stereo)
307                 right = left;
308         if (pslot->put_volume)
309                 result = pslot->put_volume(fmixer, pslot, left, right);
310         if (result < 0)
311                 goto unlock;
312         pslot->volume[0] = left;
313         pslot->volume[1] = right;
314         result = (left & 0xff) | ((right & 0xff) << 8);
315  unlock:
316         mutex_unlock(&mixer->reg_mutex);
317         return result;
318 }
319 
320 static int snd_mixer_oss_ioctl1(struct snd_mixer_oss_file *fmixer, unsigned int cmd, unsigned long arg)
321 {
322         void __user *argp = (void __user *)arg;
323         int __user *p = argp;
324         int tmp;
325 
326         if (snd_BUG_ON(!fmixer))
327                 return -ENXIO;
328         if (((cmd >> 8) & 0xff) == 'M') {
329                 switch (cmd) {
330                 case SOUND_MIXER_INFO:
331                         return snd_mixer_oss_info(fmixer, argp);
332                 case SOUND_OLD_MIXER_INFO:
333                         return snd_mixer_oss_info_obsolete(fmixer, argp);
334                 case SOUND_MIXER_WRITE_RECSRC:
335                         if (get_user(tmp, p))
336                                 return -EFAULT;
337                         tmp = snd_mixer_oss_set_recsrc(fmixer, tmp);
338                         if (tmp < 0)
339                                 return tmp;
340                         return put_user(tmp, p);
341                 case OSS_GETVERSION:
342                         return put_user(SNDRV_OSS_VERSION, p);
343                 case OSS_ALSAEMULVER:
344                         return put_user(1, p);
345                 case SOUND_MIXER_READ_DEVMASK:
346                         tmp = snd_mixer_oss_devmask(fmixer);
347                         if (tmp < 0)
348                                 return tmp;
349                         return put_user(tmp, p);
350                 case SOUND_MIXER_READ_STEREODEVS:
351                         tmp = snd_mixer_oss_stereodevs(fmixer);
352                         if (tmp < 0)
353                                 return tmp;
354                         return put_user(tmp, p);
355                 case SOUND_MIXER_READ_RECMASK:
356                         tmp = snd_mixer_oss_recmask(fmixer);
357                         if (tmp < 0)
358                                 return tmp;
359                         return put_user(tmp, p);
360                 case SOUND_MIXER_READ_CAPS:
361                         tmp = snd_mixer_oss_caps(fmixer);
362                         if (tmp < 0)
363                                 return tmp;
364                         return put_user(tmp, p);
365                 case SOUND_MIXER_READ_RECSRC:
366                         tmp = snd_mixer_oss_get_recsrc(fmixer);
367                         if (tmp < 0)
368                                 return tmp;
369                         return put_user(tmp, p);
370                 }
371         }
372         if (cmd & SIOC_IN) {
373                 if (get_user(tmp, p))
374                         return -EFAULT;
375                 tmp = snd_mixer_oss_set_volume(fmixer, cmd & 0xff, tmp);
376                 if (tmp < 0)
377                         return tmp;
378                 return put_user(tmp, p);
379         } else if (cmd & SIOC_OUT) {
380                 tmp = snd_mixer_oss_get_volume(fmixer, cmd & 0xff);
381                 if (tmp < 0)
382                         return tmp;
383                 return put_user(tmp, p);
384         }
385         return -ENXIO;
386 }
387 
388 static long snd_mixer_oss_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
389 {
390         return snd_mixer_oss_ioctl1(file->private_data, cmd, arg);
391 }
392 
393 int snd_mixer_oss_ioctl_card(struct snd_card *card, unsigned int cmd, unsigned long arg)
394 {
395         struct snd_mixer_oss_file fmixer;
396         
397         if (snd_BUG_ON(!card))
398                 return -ENXIO;
399         if (card->mixer_oss == NULL)
400                 return -ENXIO;
401         memset(&fmixer, 0, sizeof(fmixer));
402         fmixer.card = card;
403         fmixer.mixer = card->mixer_oss;
404         return snd_mixer_oss_ioctl1(&fmixer, cmd, arg);
405 }
406 EXPORT_SYMBOL(snd_mixer_oss_ioctl_card);
407 
408 #ifdef CONFIG_COMPAT
409 /* all compatible */
410 static long snd_mixer_oss_ioctl_compat(struct file *file, unsigned int cmd,
411                                        unsigned long arg)
412 {
413         return snd_mixer_oss_ioctl1(file->private_data, cmd,
414                                     (unsigned long)compat_ptr(arg));
415 }
416 #else
417 #define snd_mixer_oss_ioctl_compat      NULL
418 #endif
419 
420 /*
421  *  REGISTRATION PART
422  */
423 
424 static const struct file_operations snd_mixer_oss_f_ops =
425 {
426         .owner =        THIS_MODULE,
427         .open =         snd_mixer_oss_open,
428         .release =      snd_mixer_oss_release,
429         .llseek =       no_llseek,
430         .unlocked_ioctl =       snd_mixer_oss_ioctl,
431         .compat_ioctl = snd_mixer_oss_ioctl_compat,
432 };
433 
434 /*
435  *  utilities
436  */
437 
438 static long snd_mixer_oss_conv(long val, long omin, long omax, long nmin, long nmax)
439 {
440         long orange = omax - omin, nrange = nmax - nmin;
441         
442         if (orange == 0)
443                 return 0;
444         return DIV_ROUND_CLOSEST(nrange * (val - omin), orange) + nmin;
445 }
446 
447 /* convert from alsa native to oss values (0-100) */
448 static long snd_mixer_oss_conv1(long val, long min, long max, int *old)
449 {
450         if (val == snd_mixer_oss_conv(*old, 0, 100, min, max))
451                 return *old;
452         return snd_mixer_oss_conv(val, min, max, 0, 100);
453 }
454 
455 /* convert from oss to alsa native values */
456 static long snd_mixer_oss_conv2(long val, long min, long max)
457 {
458         return snd_mixer_oss_conv(val, 0, 100, min, max);
459 }
460 
461 #if 0
462 static void snd_mixer_oss_recsrce_set(struct snd_card *card, int slot)
463 {
464         struct snd_mixer_oss *mixer = card->mixer_oss;
465         if (mixer)
466                 mixer->mask_recsrc |= 1 << slot;
467 }
468 
469 static int snd_mixer_oss_recsrce_get(struct snd_card *card, int slot)
470 {
471         struct snd_mixer_oss *mixer = card->mixer_oss;
472         if (mixer && (mixer->mask_recsrc & (1 << slot)))
473                 return 1;
474         return 0;
475 }
476 #endif
477 
478 #define SNDRV_MIXER_OSS_SIGNATURE               0x65999250
479 
480 #define SNDRV_MIXER_OSS_ITEM_GLOBAL     0
481 #define SNDRV_MIXER_OSS_ITEM_GSWITCH    1
482 #define SNDRV_MIXER_OSS_ITEM_GROUTE     2
483 #define SNDRV_MIXER_OSS_ITEM_GVOLUME    3
484 #define SNDRV_MIXER_OSS_ITEM_PSWITCH    4
485 #define SNDRV_MIXER_OSS_ITEM_PROUTE     5
486 #define SNDRV_MIXER_OSS_ITEM_PVOLUME    6
487 #define SNDRV_MIXER_OSS_ITEM_CSWITCH    7
488 #define SNDRV_MIXER_OSS_ITEM_CROUTE     8
489 #define SNDRV_MIXER_OSS_ITEM_CVOLUME    9
490 #define SNDRV_MIXER_OSS_ITEM_CAPTURE    10
491 
492 #define SNDRV_MIXER_OSS_ITEM_COUNT      11
493 
494 #define SNDRV_MIXER_OSS_PRESENT_GLOBAL  (1<<0)
495 #define SNDRV_MIXER_OSS_PRESENT_GSWITCH (1<<1)
496 #define SNDRV_MIXER_OSS_PRESENT_GROUTE  (1<<2)
497 #define SNDRV_MIXER_OSS_PRESENT_GVOLUME (1<<3)
498 #define SNDRV_MIXER_OSS_PRESENT_PSWITCH (1<<4)
499 #define SNDRV_MIXER_OSS_PRESENT_PROUTE  (1<<5)
500 #define SNDRV_MIXER_OSS_PRESENT_PVOLUME (1<<6)
501 #define SNDRV_MIXER_OSS_PRESENT_CSWITCH (1<<7)
502 #define SNDRV_MIXER_OSS_PRESENT_CROUTE  (1<<8)
503 #define SNDRV_MIXER_OSS_PRESENT_CVOLUME (1<<9)
504 #define SNDRV_MIXER_OSS_PRESENT_CAPTURE (1<<10)
505 
506 struct slot {
507         unsigned int signature;
508         unsigned int present;
509         unsigned int channels;
510         unsigned int numid[SNDRV_MIXER_OSS_ITEM_COUNT];
511         unsigned int capture_item;
512         const struct snd_mixer_oss_assign_table *assigned;
513         unsigned int allocated: 1;
514 };
515 
516 #define ID_UNKNOWN      ((unsigned int)-1)
517 
518 static struct snd_kcontrol *snd_mixer_oss_test_id(struct snd_mixer_oss *mixer, const char *name, int index)
519 {
520         struct snd_card *card = mixer->card;
521         struct snd_ctl_elem_id id;
522         
523         memset(&id, 0, sizeof(id));
524         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
525         strscpy(id.name, name, sizeof(id.name));
526         id.index = index;
527         return snd_ctl_find_id(card, &id);
528 }
529 
530 static void snd_mixer_oss_get_volume1_vol(struct snd_mixer_oss_file *fmixer,
531                                           struct snd_mixer_oss_slot *pslot,
532                                           unsigned int numid,
533                                           int *left, int *right)
534 {
535         struct snd_ctl_elem_info *uinfo;
536         struct snd_ctl_elem_value *uctl;
537         struct snd_kcontrol *kctl;
538         struct snd_card *card = fmixer->card;
539 
540         if (numid == ID_UNKNOWN)
541                 return;
542         down_read(&card->controls_rwsem);
543         kctl = snd_ctl_find_numid(card, numid);
544         if (!kctl) {
545                 up_read(&card->controls_rwsem);
546                 return;
547         }
548         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
549         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
550         if (uinfo == NULL || uctl == NULL)
551                 goto __unalloc;
552         if (kctl->info(kctl, uinfo))
553                 goto __unalloc;
554         if (kctl->get(kctl, uctl))
555                 goto __unalloc;
556         if (uinfo->type == SNDRV_CTL_ELEM_TYPE_BOOLEAN &&
557             uinfo->value.integer.min == 0 && uinfo->value.integer.max == 1)
558                 goto __unalloc;
559         *left = snd_mixer_oss_conv1(uctl->value.integer.value[0], uinfo->value.integer.min, uinfo->value.integer.max, &pslot->volume[0]);
560         if (uinfo->count > 1)
561                 *right = snd_mixer_oss_conv1(uctl->value.integer.value[1], uinfo->value.integer.min, uinfo->value.integer.max, &pslot->volume[1]);
562       __unalloc:
563         up_read(&card->controls_rwsem);
564         kfree(uctl);
565         kfree(uinfo);
566 }
567 
568 static void snd_mixer_oss_get_volume1_sw(struct snd_mixer_oss_file *fmixer,
569                                          struct snd_mixer_oss_slot *pslot,
570                                          unsigned int numid,
571                                          int *left, int *right,
572                                          int route)
573 {
574         struct snd_ctl_elem_info *uinfo;
575         struct snd_ctl_elem_value *uctl;
576         struct snd_kcontrol *kctl;
577         struct snd_card *card = fmixer->card;
578 
579         if (numid == ID_UNKNOWN)
580                 return;
581         down_read(&card->controls_rwsem);
582         kctl = snd_ctl_find_numid(card, numid);
583         if (!kctl) {
584                 up_read(&card->controls_rwsem);
585                 return;
586         }
587         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
588         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
589         if (uinfo == NULL || uctl == NULL)
590                 goto __unalloc;
591         if (kctl->info(kctl, uinfo))
592                 goto __unalloc;
593         if (kctl->get(kctl, uctl))
594                 goto __unalloc;
595         if (!uctl->value.integer.value[0]) {
596                 *left = 0;
597                 if (uinfo->count == 1)
598                         *right = 0;
599         }
600         if (uinfo->count > 1 && !uctl->value.integer.value[route ? 3 : 1])
601                 *right = 0;
602       __unalloc:
603         up_read(&card->controls_rwsem);
604         kfree(uctl);
605         kfree(uinfo);
606 }
607 
608 static int snd_mixer_oss_get_volume1(struct snd_mixer_oss_file *fmixer,
609                                      struct snd_mixer_oss_slot *pslot,
610                                      int *left, int *right)
611 {
612         struct slot *slot = pslot->private_data;
613         
614         *left = *right = 100;
615         if (slot->present & SNDRV_MIXER_OSS_PRESENT_PVOLUME) {
616                 snd_mixer_oss_get_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PVOLUME], left, right);
617         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GVOLUME) {
618                 snd_mixer_oss_get_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GVOLUME], left, right);
619         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GLOBAL) {
620                 snd_mixer_oss_get_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GLOBAL], left, right);
621         }
622         if (slot->present & SNDRV_MIXER_OSS_PRESENT_PSWITCH) {
623                 snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PSWITCH], left, right, 0);
624         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GSWITCH) {
625                 snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GSWITCH], left, right, 0);
626         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_PROUTE) {
627                 snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PROUTE], left, right, 1);
628         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GROUTE) {
629                 snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GROUTE], left, right, 1);
630         }
631         return 0;
632 }
633 
634 static void snd_mixer_oss_put_volume1_vol(struct snd_mixer_oss_file *fmixer,
635                                           struct snd_mixer_oss_slot *pslot,
636                                           unsigned int numid,
637                                           int left, int right)
638 {
639         struct snd_ctl_elem_info *uinfo;
640         struct snd_ctl_elem_value *uctl;
641         struct snd_kcontrol *kctl;
642         struct snd_card *card = fmixer->card;
643         int res;
644 
645         if (numid == ID_UNKNOWN)
646                 return;
647         down_read(&card->controls_rwsem);
648         kctl = snd_ctl_find_numid(card, numid);
649         if (!kctl) {
650                 up_read(&card->controls_rwsem);
651                 return;
652         }
653         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
654         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
655         if (uinfo == NULL || uctl == NULL)
656                 goto __unalloc;
657         if (kctl->info(kctl, uinfo))
658                 goto __unalloc;
659         if (uinfo->type == SNDRV_CTL_ELEM_TYPE_BOOLEAN &&
660             uinfo->value.integer.min == 0 && uinfo->value.integer.max == 1)
661                 goto __unalloc;
662         uctl->value.integer.value[0] = snd_mixer_oss_conv2(left, uinfo->value.integer.min, uinfo->value.integer.max);
663         if (uinfo->count > 1)
664                 uctl->value.integer.value[1] = snd_mixer_oss_conv2(right, uinfo->value.integer.min, uinfo->value.integer.max);
665         res = kctl->put(kctl, uctl);
666         if (res < 0)
667                 goto __unalloc;
668         if (res > 0)
669                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &kctl->id);
670       __unalloc:
671         up_read(&card->controls_rwsem);
672         kfree(uctl);
673         kfree(uinfo);
674 }
675 
676 static void snd_mixer_oss_put_volume1_sw(struct snd_mixer_oss_file *fmixer,
677                                          struct snd_mixer_oss_slot *pslot,
678                                          unsigned int numid,
679                                          int left, int right,
680                                          int route)
681 {
682         struct snd_ctl_elem_info *uinfo;
683         struct snd_ctl_elem_value *uctl;
684         struct snd_kcontrol *kctl;
685         struct snd_card *card = fmixer->card;
686         int res;
687 
688         if (numid == ID_UNKNOWN)
689                 return;
690         down_read(&card->controls_rwsem);
691         kctl = snd_ctl_find_numid(card, numid);
692         if (!kctl) {
693                 up_read(&card->controls_rwsem);
694                 return;
695         }
696         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
697         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
698         if (uinfo == NULL || uctl == NULL)
699                 goto __unalloc;
700         if (kctl->info(kctl, uinfo))
701                 goto __unalloc;
702         if (uinfo->count > 1) {
703                 uctl->value.integer.value[0] = left > 0 ? 1 : 0;
704                 uctl->value.integer.value[route ? 3 : 1] = right > 0 ? 1 : 0;
705                 if (route) {
706                         uctl->value.integer.value[1] =
707                         uctl->value.integer.value[2] = 0;
708                 }
709         } else {
710                 uctl->value.integer.value[0] = (left > 0 || right > 0) ? 1 : 0;
711         }
712         res = kctl->put(kctl, uctl);
713         if (res < 0)
714                 goto __unalloc;
715         if (res > 0)
716                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &kctl->id);
717       __unalloc:
718         up_read(&card->controls_rwsem);
719         kfree(uctl);
720         kfree(uinfo);
721 }
722 
723 static int snd_mixer_oss_put_volume1(struct snd_mixer_oss_file *fmixer,
724                                      struct snd_mixer_oss_slot *pslot,
725                                      int left, int right)
726 {
727         struct slot *slot = pslot->private_data;
728         
729         if (slot->present & SNDRV_MIXER_OSS_PRESENT_PVOLUME) {
730                 snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PVOLUME], left, right);
731                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_CVOLUME)
732                         snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CVOLUME], left, right);
733         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_CVOLUME) {
734                 snd_mixer_oss_put_volume1_vol(fmixer, pslot,
735                         slot->numid[SNDRV_MIXER_OSS_ITEM_CVOLUME], left, right);
736         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GVOLUME) {
737                 snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GVOLUME], left, right);
738         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GLOBAL) {
739                 snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GLOBAL], left, right);
740         }
741         if (left || right) {
742                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_PSWITCH)
743                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PSWITCH], left, right, 0);
744                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_CSWITCH)
745                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CSWITCH], left, right, 0);
746                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_GSWITCH)
747                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GSWITCH], left, right, 0);
748                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_PROUTE)
749                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PROUTE], left, right, 1);
750                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_CROUTE)
751                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CROUTE], left, right, 1);
752                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_GROUTE)
753                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GROUTE], left, right, 1);
754         } else {
755                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_PSWITCH) {
756                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PSWITCH], left, right, 0);
757                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_CSWITCH) {
758                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CSWITCH], left, right, 0);
759                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GSWITCH) {
760                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GSWITCH], left, right, 0);
761                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_PROUTE) {
762                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PROUTE], left, right, 1);
763                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_CROUTE) {
764                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CROUTE], left, right, 1);
765                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GROUTE) {
766                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GROUTE], left, right, 1);
767                 }
768         }
769         return 0;
770 }
771 
772 static int snd_mixer_oss_get_recsrc1_sw(struct snd_mixer_oss_file *fmixer,
773                                         struct snd_mixer_oss_slot *pslot,
774                                         int *active)
775 {
776         struct slot *slot = pslot->private_data;
777         int left, right;
778         
779         left = right = 1;
780         snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CSWITCH], &left, &right, 0);
781         *active = (left || right) ? 1 : 0;
782         return 0;
783 }
784 
785 static int snd_mixer_oss_get_recsrc1_route(struct snd_mixer_oss_file *fmixer,
786                                            struct snd_mixer_oss_slot *pslot,
787                                            int *active)
788 {
789         struct slot *slot = pslot->private_data;
790         int left, right;
791         
792         left = right = 1;
793         snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CROUTE], &left, &right, 1);
794         *active = (left || right) ? 1 : 0;
795         return 0;
796 }
797 
798 static int snd_mixer_oss_put_recsrc1_sw(struct snd_mixer_oss_file *fmixer,
799                                         struct snd_mixer_oss_slot *pslot,
800                                         int active)
801 {
802         struct slot *slot = pslot->private_data;
803         
804         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CSWITCH], active, active, 0);
805         return 0;
806 }
807 
808 static int snd_mixer_oss_put_recsrc1_route(struct snd_mixer_oss_file *fmixer,
809                                            struct snd_mixer_oss_slot *pslot,
810                                            int active)
811 {
812         struct slot *slot = pslot->private_data;
813         
814         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CROUTE], active, active, 1);
815         return 0;
816 }
817 
818 static int snd_mixer_oss_get_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned int *active_index)
819 {
820         struct snd_card *card = fmixer->card;
821         struct snd_mixer_oss *mixer = fmixer->mixer;
822         struct snd_kcontrol *kctl;
823         struct snd_mixer_oss_slot *pslot;
824         struct slot *slot;
825         struct snd_ctl_elem_info *uinfo;
826         struct snd_ctl_elem_value *uctl;
827         int err, idx;
828         
829         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
830         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
831         if (uinfo == NULL || uctl == NULL) {
832                 err = -ENOMEM;
833                 goto __free_only;
834         }
835         down_read(&card->controls_rwsem);
836         kctl = snd_mixer_oss_test_id(mixer, "Capture Source", 0);
837         if (! kctl) {
838                 err = -ENOENT;
839                 goto __unlock;
840         }
841         err = kctl->info(kctl, uinfo);
842         if (err < 0)
843                 goto __unlock;
844         err = kctl->get(kctl, uctl);
845         if (err < 0)
846                 goto __unlock;
847         for (idx = 0; idx < 32; idx++) {
848                 if (!(mixer->mask_recsrc & (1 << idx)))
849                         continue;
850                 pslot = &mixer->slots[idx];
851                 slot = pslot->private_data;
852                 if (slot->signature != SNDRV_MIXER_OSS_SIGNATURE)
853                         continue;
854                 if (!(slot->present & SNDRV_MIXER_OSS_PRESENT_CAPTURE))
855                         continue;
856                 if (slot->capture_item == uctl->value.enumerated.item[0]) {
857                         *active_index = idx;
858                         break;
859                 }
860         }
861         err = 0;
862       __unlock:
863         up_read(&card->controls_rwsem);
864       __free_only:
865         kfree(uctl);
866         kfree(uinfo);
867         return err;
868 }
869 
870 static int snd_mixer_oss_put_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned int active_index)
871 {
872         struct snd_card *card = fmixer->card;
873         struct snd_mixer_oss *mixer = fmixer->mixer;
874         struct snd_kcontrol *kctl;
875         struct snd_mixer_oss_slot *pslot;
876         struct slot *slot = NULL;
877         struct snd_ctl_elem_info *uinfo;
878         struct snd_ctl_elem_value *uctl;
879         int err;
880         unsigned int idx;
881 
882         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
883         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
884         if (uinfo == NULL || uctl == NULL) {
885                 err = -ENOMEM;
886                 goto __free_only;
887         }
888         down_read(&card->controls_rwsem);
889         kctl = snd_mixer_oss_test_id(mixer, "Capture Source", 0);
890         if (! kctl) {
891                 err = -ENOENT;
892                 goto __unlock;
893         }
894         err = kctl->info(kctl, uinfo);
895         if (err < 0)
896                 goto __unlock;
897         for (idx = 0; idx < 32; idx++) {
898                 if (!(mixer->mask_recsrc & (1 << idx)))
899                         continue;
900                 pslot = &mixer->slots[idx];
901                 slot = pslot->private_data;
902                 if (slot->signature != SNDRV_MIXER_OSS_SIGNATURE)
903                         continue;
904                 if (!(slot->present & SNDRV_MIXER_OSS_PRESENT_CAPTURE))
905                         continue;
906                 if (idx == active_index)
907                         break;
908                 slot = NULL;
909         }
910         if (! slot)
911                 goto __unlock;
912         for (idx = 0; idx < uinfo->count; idx++)
913                 uctl->value.enumerated.item[idx] = slot->capture_item;
914         err = kctl->put(kctl, uctl);
915         if (err > 0)
916                 snd_ctl_notify(fmixer->card, SNDRV_CTL_EVENT_MASK_VALUE, &kctl->id);
917         err = 0;
918       __unlock:
919         up_read(&card->controls_rwsem);
920       __free_only:
921         kfree(uctl);
922         kfree(uinfo);
923         return err;
924 }
925 
926 struct snd_mixer_oss_assign_table {
927         int oss_id;
928         const char *name;
929         int index;
930 };
931 
932 static int snd_mixer_oss_build_test(struct snd_mixer_oss *mixer, struct slot *slot, const char *name, int index, int item)
933 {
934         struct snd_ctl_elem_info *info;
935         struct snd_kcontrol *kcontrol;
936         struct snd_card *card = mixer->card;
937         int err;
938 
939         down_read(&card->controls_rwsem);
940         kcontrol = snd_mixer_oss_test_id(mixer, name, index);
941         if (kcontrol == NULL) {
942                 up_read(&card->controls_rwsem);
943                 return 0;
944         }
945         info = kmalloc(sizeof(*info), GFP_KERNEL);
946         if (! info) {
947                 up_read(&card->controls_rwsem);
948                 return -ENOMEM;
949         }
950         err = kcontrol->info(kcontrol, info);
951         if (err < 0) {
952                 up_read(&card->controls_rwsem);
953                 kfree(info);
954                 return err;
955         }
956         slot->numid[item] = kcontrol->id.numid;
957         up_read(&card->controls_rwsem);
958         if (info->count > slot->channels)
959                 slot->channels = info->count;
960         slot->present |= 1 << item;
961         kfree(info);
962         return 0;
963 }
964 
965 static void snd_mixer_oss_slot_free(struct snd_mixer_oss_slot *chn)
966 {
967         struct slot *p = chn->private_data;
968         if (p) {
969                 if (p->allocated && p->assigned) {
970                         kfree_const(p->assigned->name);
971                         kfree_const(p->assigned);
972                 }
973                 kfree(p);
974         }
975 }
976 
977 static void mixer_slot_clear(struct snd_mixer_oss_slot *rslot)
978 {
979         int idx = rslot->number; /* remember this */
980         if (rslot->private_free)
981                 rslot->private_free(rslot);
982         memset(rslot, 0, sizeof(*rslot));
983         rslot->number = idx;
984 }
985 
986 /* In a separate function to keep gcc 3.2 happy - do NOT merge this in
987    snd_mixer_oss_build_input! */
988 static int snd_mixer_oss_build_test_all(struct snd_mixer_oss *mixer,
989                                         const struct snd_mixer_oss_assign_table *ptr,
990                                         struct slot *slot)
991 {
992         char str[64];
993         int err;
994 
995         err = snd_mixer_oss_build_test(mixer, slot, ptr->name, ptr->index,
996                                        SNDRV_MIXER_OSS_ITEM_GLOBAL);
997         if (err)
998                 return err;
999         sprintf(str, "%s Switch", ptr->name);
1000         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1001                                        SNDRV_MIXER_OSS_ITEM_GSWITCH);
1002         if (err)
1003                 return err;
1004         sprintf(str, "%s Route", ptr->name);
1005         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1006                                        SNDRV_MIXER_OSS_ITEM_GROUTE);
1007         if (err)
1008                 return err;
1009         sprintf(str, "%s Volume", ptr->name);
1010         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1011                                        SNDRV_MIXER_OSS_ITEM_GVOLUME);
1012         if (err)
1013                 return err;
1014         sprintf(str, "%s Playback Switch", ptr->name);
1015         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1016                                        SNDRV_MIXER_OSS_ITEM_PSWITCH);
1017         if (err)
1018                 return err;
1019         sprintf(str, "%s Playback Route", ptr->name);
1020         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1021                                        SNDRV_MIXER_OSS_ITEM_PROUTE);
1022         if (err)
1023                 return err;
1024         sprintf(str, "%s Playback Volume", ptr->name);
1025         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1026                                        SNDRV_MIXER_OSS_ITEM_PVOLUME);
1027         if (err)
1028                 return err;
1029         sprintf(str, "%s Capture Switch", ptr->name);
1030         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1031                                        SNDRV_MIXER_OSS_ITEM_CSWITCH);
1032         if (err)
1033                 return err;
1034         sprintf(str, "%s Capture Route", ptr->name);
1035         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1036                                        SNDRV_MIXER_OSS_ITEM_CROUTE);
1037         if (err)
1038                 return err;
1039         sprintf(str, "%s Capture Volume", ptr->name);
1040         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1041                                        SNDRV_MIXER_OSS_ITEM_CVOLUME);
1042         if (err)
1043                 return err;
1044 
1045         return 0;
1046 }
1047 
1048 /*
1049  * build an OSS mixer element.
1050  * ptr_allocated means the entry is dynamically allocated (change via proc file).
1051  * when replace_old = 1, the old entry is replaced with the new one.
1052  */
1053 static int snd_mixer_oss_build_input(struct snd_mixer_oss *mixer,
1054                                      const struct snd_mixer_oss_assign_table *ptr,
1055                                      int ptr_allocated, int replace_old)
1056 {
1057         struct slot slot;
1058         struct slot *pslot;
1059         struct snd_kcontrol *kctl;
1060         struct snd_mixer_oss_slot *rslot;
1061         char str[64];   
1062         
1063         /* check if already assigned */
1064         if (mixer->slots[ptr->oss_id].get_volume && ! replace_old)
1065                 return 0;
1066 
1067         memset(&slot, 0, sizeof(slot));
1068         memset(slot.numid, 0xff, sizeof(slot.numid)); /* ID_UNKNOWN */
1069         if (snd_mixer_oss_build_test_all(mixer, ptr, &slot))
1070                 return 0;
1071         down_read(&mixer->card->controls_rwsem);
1072         kctl = NULL;
1073         if (!ptr->index)
1074                 kctl = snd_mixer_oss_test_id(mixer, "Capture Source", 0);
1075         if (kctl) {
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 const char * const 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 const 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                 err = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIXER,
1383                                               card, 0,
1384                                               &snd_mixer_oss_f_ops, card);
1385                 if (err < 0) {
1386                         dev_err(card->dev,
1387                                 "unable to register OSS mixer device %i:%i\n",
1388                                 card->number, 0);
1389                         kfree(mixer);
1390                         return err;
1391                 }
1392                 mixer->oss_dev_alloc = 1;
1393                 mixer->card = card;
1394                 if (*card->mixername)
1395                         strscpy(mixer->name, card->mixername, sizeof(mixer->name));
1396                 else
1397                         snprintf(mixer->name, sizeof(mixer->name),
1398                                  "mixer%i", card->number);
1399 #ifdef SNDRV_OSS_INFO_DEV_MIXERS
1400                 snd_oss_info_register(SNDRV_OSS_INFO_DEV_MIXERS,
1401                                       card->number,
1402                                       mixer->name);
1403 #endif
1404                 for (idx = 0; idx < SNDRV_OSS_MAX_MIXERS; idx++)
1405                         mixer->slots[idx].number = idx;
1406                 card->mixer_oss = mixer;
1407                 snd_mixer_oss_build(mixer);
1408                 snd_mixer_oss_proc_init(mixer);
1409         } else {
1410                 mixer = card->mixer_oss;
1411                 if (mixer == NULL)
1412                         return 0;
1413                 if (mixer->oss_dev_alloc) {
1414 #ifdef SNDRV_OSS_INFO_DEV_MIXERS
1415                         snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_MIXERS, mixer->card->number);
1416 #endif
1417                         snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIXER, mixer->card, 0);
1418                         mixer->oss_dev_alloc = 0;
1419                 }
1420                 if (cmd == SND_MIXER_OSS_NOTIFY_DISCONNECT)
1421                         return 0;
1422                 snd_mixer_oss_proc_done(mixer);
1423                 return snd_mixer_oss_free1(mixer);
1424         }
1425         return 0;
1426 }
1427 
1428 static int __init alsa_mixer_oss_init(void)
1429 {
1430         struct snd_card *card;
1431         int idx;
1432         
1433         snd_mixer_oss_notify_callback = snd_mixer_oss_notify_handler;
1434         for (idx = 0; idx < SNDRV_CARDS; idx++) {
1435                 card = snd_card_ref(idx);
1436                 if (card) {
1437                         snd_mixer_oss_notify_handler(card, SND_MIXER_OSS_NOTIFY_REGISTER);
1438                         snd_card_unref(card);
1439                 }
1440         }
1441         return 0;
1442 }
1443 
1444 static void __exit alsa_mixer_oss_exit(void)
1445 {
1446         struct snd_card *card;
1447         int idx;
1448 
1449         snd_mixer_oss_notify_callback = NULL;
1450         for (idx = 0; idx < SNDRV_CARDS; idx++) {
1451                 card = snd_card_ref(idx);
1452                 if (card) {
1453                         snd_mixer_oss_notify_handler(card, SND_MIXER_OSS_NOTIFY_FREE);
1454                         snd_card_unref(card);
1455                 }
1456         }
1457 }
1458 
1459 module_init(alsa_mixer_oss_init)
1460 module_exit(alsa_mixer_oss_exit)
1461 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp