sound/core/oss/mixer_oss.c

   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)