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         strlcpy(info.id, mixer && mixer->id[0] ? mixer->id : card->driver, sizeof(info.id));
  91         strlcpy(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         strlcpy(info.id, mixer && mixer->id[0] ? mixer->id : card->driver, sizeof(info.id));
 107         strlcpy(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 ((nrange * (val - omin)) + (orange / 2)) / 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         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         strlcpy(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         if ((kctl = snd_ctl_find_numid(card, numid)) == NULL) {
 544                 up_read(&card->controls_rwsem);
 545                 return;
 546         }
 547         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
 548         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
 549         if (uinfo == NULL || uctl == NULL)
 550                 goto __unalloc;
 551         if (kctl->info(kctl, uinfo))
 552                 goto __unalloc;
 553         if (kctl->get(kctl, uctl))
 554                 goto __unalloc;
 555         if (uinfo->type == SNDRV_CTL_ELEM_TYPE_BOOLEAN &&
 556             uinfo->value.integer.min == 0 && uinfo->value.integer.max == 1)
 557                 goto __unalloc;
 558         *left = snd_mixer_oss_conv1(uctl->value.integer.value[0], uinfo->value.integer.min, uinfo->value.integer.max, &pslot->volume[0]);
 559         if (uinfo->count > 1)
 560                 *right = snd_mixer_oss_conv1(uctl->value.integer.value[1], uinfo->value.integer.min, uinfo->value.integer.max, &pslot->volume[1]);
 561       __unalloc:
 562         up_read(&card->controls_rwsem);
 563         kfree(uctl);
 564         kfree(uinfo);
 565 }
 566
 567 static void snd_mixer_oss_get_volume1_sw(struct snd_mixer_oss_file *fmixer,
 568                                          struct snd_mixer_oss_slot *pslot,
 569                                          unsigned int numid,
 570                                          int *left, int *right,
 571                                          int route)
 572 {
 573         struct snd_ctl_elem_info *uinfo;
 574         struct snd_ctl_elem_value *uctl;
 575         struct snd_kcontrol *kctl;
 576         struct snd_card *card = fmixer->card;
 577
 578         if (numid == ID_UNKNOWN)
 579                 return;
 580         down_read(&card->controls_rwsem);
 581         if ((kctl = snd_ctl_find_numid(card, numid)) == NULL) {
 582                 up_read(&card->controls_rwsem);
 583                 return;
 584         }
 585         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
 586         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
 587         if (uinfo == NULL || uctl == NULL)
 588                 goto __unalloc;
 589         if (kctl->info(kctl, uinfo))
 590                 goto __unalloc;
 591         if (kctl->get(kctl, uctl))
 592                 goto __unalloc;
 593         if (!uctl->value.integer.value[0]) {
 594                 *left = 0;
 595                 if (uinfo->count == 1)
 596                         *right = 0;
 597         }
 598         if (uinfo->count > 1 && !uctl->value.integer.value[route ? 3 : 1])
 599                 *right = 0;
 600       __unalloc:
 601         up_read(&card->controls_rwsem);
 602         kfree(uctl);
 603         kfree(uinfo);
 604 }
 605
 606 static int snd_mixer_oss_get_volume1(struct snd_mixer_oss_file *fmixer,
 607                                      struct snd_mixer_oss_slot *pslot,
 608                                      int *left, int *right)
 609 {
 610         struct slot *slot = pslot->private_data;
 611
 612         *left = *right = 100;
 613         if (slot->present & SNDRV_MIXER_OSS_PRESENT_PVOLUME) {
 614                 snd_mixer_oss_get_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PVOLUME], left, right);
 615         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GVOLUME) {
 616                 snd_mixer_oss_get_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GVOLUME], left, right);
 617         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GLOBAL) {
 618                 snd_mixer_oss_get_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GLOBAL], left, right);
 619         }
 620         if (slot->present & SNDRV_MIXER_OSS_PRESENT_PSWITCH) {
 621                 snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PSWITCH], left, right, 0);
 622         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GSWITCH) {
 623                 snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GSWITCH], left, right, 0);
 624         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_PROUTE) {
 625                 snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PROUTE], left, right, 1);
 626         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GROUTE) {
 627                 snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GROUTE], left, right, 1);
 628         }
 629         return 0;
 630 }
 631
 632 static void snd_mixer_oss_put_volume1_vol(struct snd_mixer_oss_file *fmixer,
 633                                           struct snd_mixer_oss_slot *pslot,
 634                                           unsigned int numid,
 635                                           int left, int right)
 636 {
 637         struct snd_ctl_elem_info *uinfo;
 638         struct snd_ctl_elem_value *uctl;
 639         struct snd_kcontrol *kctl;
 640         struct snd_card *card = fmixer->card;
 641         int res;
 642
 643         if (numid == ID_UNKNOWN)
 644                 return;
 645         down_read(&card->controls_rwsem);
 646         if ((kctl = snd_ctl_find_numid(card, numid)) == NULL) {
 647                 up_read(&card->controls_rwsem);
 648                 return;
 649         }
 650         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
 651         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
 652         if (uinfo == NULL || uctl == NULL)
 653                 goto __unalloc;
 654         if (kctl->info(kctl, uinfo))
 655                 goto __unalloc;
 656         if (uinfo->type == SNDRV_CTL_ELEM_TYPE_BOOLEAN &&
 657             uinfo->value.integer.min == 0 && uinfo->value.integer.max == 1)
 658                 goto __unalloc;
 659         uctl->value.integer.value[0] = snd_mixer_oss_conv2(left, uinfo->value.integer.min, uinfo->value.integer.max);
 660         if (uinfo->count > 1)
 661                 uctl->value.integer.value[1] = snd_mixer_oss_conv2(right, uinfo->value.integer.min, uinfo->value.integer.max);
 662         if ((res = kctl->put(kctl, uctl)) < 0)
 663                 goto __unalloc;
 664         if (res > 0)
 665                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &kctl->id);
 666       __unalloc:
 667         up_read(&card->controls_rwsem);
 668         kfree(uctl);
 669         kfree(uinfo);
 670 }
 671
 672 static void snd_mixer_oss_put_volume1_sw(struct snd_mixer_oss_file *fmixer,
 673                                          struct snd_mixer_oss_slot *pslot,
 674                                          unsigned int numid,
 675                                          int left, int right,
 676                                          int route)
 677 {
 678         struct snd_ctl_elem_info *uinfo;
 679         struct snd_ctl_elem_value *uctl;
 680         struct snd_kcontrol *kctl;
 681         struct snd_card *card = fmixer->card;
 682         int res;
 683
 684         if (numid == ID_UNKNOWN)
 685                 return;
 686         down_read(&card->controls_rwsem);
 687         if ((kctl = snd_ctl_find_numid(card, numid)) == NULL) {
 688                 up_read(&card->controls_rwsem);
 689                 return;
 690         }
 691         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
 692         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
 693         if (uinfo == NULL || uctl == NULL)
 694                 goto __unalloc;
 695         if (kctl->info(kctl, uinfo))
 696                 goto __unalloc;
 697         if (uinfo->count > 1) {
 698                 uctl->value.integer.value[0] = left > 0 ? 1 : 0;
 699                 uctl->value.integer.value[route ? 3 : 1] = right > 0 ? 1 : 0;
 700                 if (route) {
 701                         uctl->value.integer.value[1] =
 702                         uctl->value.integer.value[2] = 0;
 703                 }
 704         } else {
 705                 uctl->value.integer.value[0] = (left > 0 || right > 0) ? 1 : 0;
 706         }
 707         if ((res = kctl->put(kctl, uctl)) < 0)
 708                 goto __unalloc;
 709         if (res > 0)
 710                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &kctl->id);
 711       __unalloc:
 712         up_read(&card->controls_rwsem);
 713         kfree(uctl);
 714         kfree(uinfo);
 715 }
 716
 717 static int snd_mixer_oss_put_volume1(struct snd_mixer_oss_file *fmixer,
 718                                      struct snd_mixer_oss_slot *pslot,
 719                                      int left, int right)
 720 {
 721         struct slot *slot = pslot->private_data;
 722
 723         if (slot->present & SNDRV_MIXER_OSS_PRESENT_PVOLUME) {
 724                 snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PVOLUME], left, right);
 725                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_CVOLUME)
 726                         snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CVOLUME], left, right);
 727         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_CVOLUME) {
 728                 snd_mixer_oss_put_volume1_vol(fmixer, pslot,
 729                         slot->numid[SNDRV_MIXER_OSS_ITEM_CVOLUME], left, right);
 730         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GVOLUME) {
 731                 snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GVOLUME], left, right);
 732         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GLOBAL) {
 733                 snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GLOBAL], left, right);
 734         }
 735         if (left || right) {
 736                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_PSWITCH)
 737                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PSWITCH], left, right, 0);
 738                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_CSWITCH)
 739                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CSWITCH], left, right, 0);
 740                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_GSWITCH)
 741                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GSWITCH], left, right, 0);
 742                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_PROUTE)
 743                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PROUTE], left, right, 1);
 744                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_CROUTE)
 745                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CROUTE], left, right, 1);
 746                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_GROUTE)
 747                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GROUTE], left, right, 1);
 748         } else {
 749                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_PSWITCH) {
 750                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PSWITCH], left, right, 0);
 751                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_CSWITCH) {
 752                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CSWITCH], left, right, 0);
 753                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GSWITCH) {
 754                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GSWITCH], left, right, 0);
 755                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_PROUTE) {
 756                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PROUTE], left, right, 1);
 757                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_CROUTE) {
 758                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CROUTE], left, right, 1);
 759                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GROUTE) {
 760                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GROUTE], left, right, 1);
 761                 }
 762         }
 763         return 0;
 764 }
 765
 766 static int snd_mixer_oss_get_recsrc1_sw(struct snd_mixer_oss_file *fmixer,
 767                                         struct snd_mixer_oss_slot *pslot,
 768                                         int *active)
 769 {
 770         struct slot *slot = pslot->private_data;
 771         int left, right;
 772
 773         left = right = 1;
 774         snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CSWITCH], &left, &right, 0);
 775         *active = (left || right) ? 1 : 0;
 776         return 0;
 777 }
 778
 779 static int snd_mixer_oss_get_recsrc1_route(struct snd_mixer_oss_file *fmixer,
 780                                            struct snd_mixer_oss_slot *pslot,
 781                                            int *active)
 782 {
 783         struct slot *slot = pslot->private_data;
 784         int left, right;
 785
 786         left = right = 1;
 787         snd_mixer_oss_get_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CROUTE], &left, &right, 1);
 788         *active = (left || right) ? 1 : 0;
 789         return 0;
 790 }
 791
 792 static int snd_mixer_oss_put_recsrc1_sw(struct snd_mixer_oss_file *fmixer,
 793                                         struct snd_mixer_oss_slot *pslot,
 794                                         int active)
 795 {
 796         struct slot *slot = pslot->private_data;
 797
 798         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CSWITCH], active, active, 0);
 799         return 0;
 800 }
 801
 802 static int snd_mixer_oss_put_recsrc1_route(struct snd_mixer_oss_file *fmixer,
 803                                            struct snd_mixer_oss_slot *pslot,
 804                                            int active)
 805 {
 806         struct slot *slot = pslot->private_data;
 807
 808         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CROUTE], active, active, 1);
 809         return 0;
 810 }
 811
 812 static int snd_mixer_oss_get_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned int *active_index)
 813 {
 814         struct snd_card *card = fmixer->card;
 815         struct snd_mixer_oss *mixer = fmixer->mixer;
 816         struct snd_kcontrol *kctl;
 817         struct snd_mixer_oss_slot *pslot;
 818         struct slot *slot;
 819         struct snd_ctl_elem_info *uinfo;
 820         struct snd_ctl_elem_value *uctl;
 821         int err, idx;
 822
 823         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
 824         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
 825         if (uinfo == NULL || uctl == NULL) {
 826                 err = -ENOMEM;
 827                 goto __free_only;
 828         }
 829         down_read(&card->controls_rwsem);
 830         kctl = snd_mixer_oss_test_id(mixer, "Capture Source", 0);
 831         if (! kctl) {
 832                 err = -ENOENT;
 833                 goto __unlock;
 834         }
 835         if ((err = kctl->info(kctl, uinfo)) < 0)
 836                 goto __unlock;
 837         if ((err = kctl->get(kctl, uctl)) < 0)
 838                 goto __unlock;
 839         for (idx = 0; idx < 32; idx++) {
 840                 if (!(mixer->mask_recsrc & (1 << idx)))
 841                         continue;
 842                 pslot = &mixer->slots[idx];
 843                 slot = pslot->private_data;
 844                 if (slot->signature != SNDRV_MIXER_OSS_SIGNATURE)
 845                         continue;
 846                 if (!(slot->present & SNDRV_MIXER_OSS_PRESENT_CAPTURE))
 847                         continue;
 848                 if (slot->capture_item == uctl->value.enumerated.item[0]) {
 849                         *active_index = idx;
 850                         break;
 851                 }
 852         }
 853         err = 0;
 854       __unlock:
 855         up_read(&card->controls_rwsem);
 856       __free_only:
 857         kfree(uctl);
 858         kfree(uinfo);
 859         return err;
 860 }
 861
 862 static int snd_mixer_oss_put_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned int active_index)
 863 {
 864         struct snd_card *card = fmixer->card;
 865         struct snd_mixer_oss *mixer = fmixer->mixer;
 866         struct snd_kcontrol *kctl;
 867         struct snd_mixer_oss_slot *pslot;
 868         struct slot *slot = NULL;
 869         struct snd_ctl_elem_info *uinfo;
 870         struct snd_ctl_elem_value *uctl;
 871         int err;
 872         unsigned int idx;
 873
 874         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
 875         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
 876         if (uinfo == NULL || uctl == NULL) {
 877                 err = -ENOMEM;
 878                 goto __free_only;
 879         }
 880         down_read(&card->controls_rwsem);
 881         kctl = snd_mixer_oss_test_id(mixer, "Capture Source", 0);
 882         if (! kctl) {
 883                 err = -ENOENT;
 884                 goto __unlock;
 885         }
 886         if ((err = kctl->info(kctl, uinfo)) < 0)
 887                 goto __unlock;
 888         for (idx = 0; idx < 32; idx++) {
 889                 if (!(mixer->mask_recsrc & (1 << idx)))
 890                         continue;
 891                 pslot = &mixer->slots[idx];
 892                 slot = pslot->private_data;
 893                 if (slot->signature != SNDRV_MIXER_OSS_SIGNATURE)
 894                         continue;
 895                 if (!(slot->present & SNDRV_MIXER_OSS_PRESENT_CAPTURE))
 896                         continue;
 897                 if (idx == active_index)
 898                         break;
 899                 slot = NULL;
 900         }
 901         if (! slot)
 902                 goto __unlock;
 903         for (idx = 0; idx < uinfo->count; idx++)
 904                 uctl->value.enumerated.item[idx] = slot->capture_item;
 905         err = kctl->put(kctl, uctl);
 906         if (err > 0)
 907                 snd_ctl_notify(fmixer->card, SNDRV_CTL_EVENT_MASK_VALUE, &kctl->id);
 908         err = 0;
 909       __unlock:
 910         up_read(&card->controls_rwsem);
 911       __free_only:
 912         kfree(uctl);
 913         kfree(uinfo);
 914         return err;
 915 }
 916
 917 struct snd_mixer_oss_assign_table {
 918         int oss_id;
 919         const char *name;
 920         int index;
 921 };
 922
 923 static int snd_mixer_oss_build_test(struct snd_mixer_oss *mixer, struct slot *slot, const char *name, int index, int item)
 924 {
 925         struct snd_ctl_elem_info *info;
 926         struct snd_kcontrol *kcontrol;
 927         struct snd_card *card = mixer->card;
 928         int err;
 929
 930         down_read(&card->controls_rwsem);
 931         kcontrol = snd_mixer_oss_test_id(mixer, name, index);
 932         if (kcontrol == NULL) {
 933                 up_read(&card->controls_rwsem);
 934                 return 0;
 935         }
 936         info = kmalloc(sizeof(*info), GFP_KERNEL);
 937         if (! info) {
 938                 up_read(&card->controls_rwsem);
 939                 return -ENOMEM;
 940         }
 941         if ((err = kcontrol->info(kcontrol, info)) < 0) {
 942                 up_read(&card->controls_rwsem);
 943                 kfree(info);
 944                 return err;
 945         }
 946         slot->numid[item] = kcontrol->id.numid;
 947         up_read(&card->controls_rwsem);
 948         if (info->count > slot->channels)
 949                 slot->channels = info->count;
 950         slot->present |= 1 << item;
 951         kfree(info);
 952         return 0;
 953 }
 954
 955 static void snd_mixer_oss_slot_free(struct snd_mixer_oss_slot *chn)
 956 {
 957         struct slot *p = chn->private_data;
 958         if (p) {
 959                 if (p->allocated && p->assigned) {
 960                         kfree(p->assigned->name);
 961                         kfree(p->assigned);
 962                 }
 963                 kfree(p);
 964         }
 965 }
 966
 967 static void mixer_slot_clear(struct snd_mixer_oss_slot *rslot)
 968 {
 969         int idx = rslot->number; /* remember this */
 970         if (rslot->private_free)
 971                 rslot->private_free(rslot);
 972         memset(rslot, 0, sizeof(*rslot));
 973         rslot->number = idx;
 974 }
 975
 976 /* In a separate function to keep gcc 3.2 happy - do NOT merge this in
 977    snd_mixer_oss_build_input! */
 978 static int snd_mixer_oss_build_test_all(struct snd_mixer_oss *mixer,
 979                                         struct snd_mixer_oss_assign_table *ptr,
 980                                         struct slot *slot)
 981 {
 982         char str[64];
 983         int err;
 984
 985         err = snd_mixer_oss_build_test(mixer, slot, ptr->name, ptr->index,
 986                                        SNDRV_MIXER_OSS_ITEM_GLOBAL);
 987         if (err)
 988                 return err;
 989         sprintf(str, "%s Switch", ptr->name);
 990         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
 991                                        SNDRV_MIXER_OSS_ITEM_GSWITCH);
 992         if (err)
 993                 return err;
 994         sprintf(str, "%s Route", ptr->name);
 995         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
 996                                        SNDRV_MIXER_OSS_ITEM_GROUTE);
 997         if (err)
 998                 return err;
 999         sprintf(str, "%s Volume", ptr->name);
1000         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1001                                        SNDRV_MIXER_OSS_ITEM_GVOLUME);
1002         if (err)
1003                 return err;
1004         sprintf(str, "%s Playback Switch", ptr->name);
1005         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1006                                        SNDRV_MIXER_OSS_ITEM_PSWITCH);
1007         if (err)
1008                 return err;
1009         sprintf(str, "%s Playback Route", ptr->name);
1010         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1011                                        SNDRV_MIXER_OSS_ITEM_PROUTE);
1012         if (err)
1013                 return err;
1014         sprintf(str, "%s Playback Volume", ptr->name);
1015         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1016                                        SNDRV_MIXER_OSS_ITEM_PVOLUME);
1017         if (err)
1018                 return err;
1019         sprintf(str, "%s Capture Switch", ptr->name);
1020         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1021                                        SNDRV_MIXER_OSS_ITEM_CSWITCH);
1022         if (err)
1023                 return err;
1024         sprintf(str, "%s Capture Route", ptr->name);
1025         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1026                                        SNDRV_MIXER_OSS_ITEM_CROUTE);
1027         if (err)
1028                 return err;
1029         sprintf(str, "%s Capture Volume", ptr->name);
1030         err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
1031                                        SNDRV_MIXER_OSS_ITEM_CVOLUME);
1032         if (err)
1033                 return err;
1034
1035         return 0;
1036 }
1037
1038 /*
1039  * build an OSS mixer element.
1040  * ptr_allocated means the entry is dynamically allocated (change via proc file).
1041  * when replace_old = 1, the old entry is replaced with the new one.
1042  */
1043 static int snd_mixer_oss_build_input(struct snd_mixer_oss *mixer, struct snd_mixer_oss_assign_table *ptr, int ptr_allocated, int replace_old)
1044 {
1045         struct slot slot;
1046         struct slot *pslot;
1047         struct snd_kcontrol *kctl;
1048         struct snd_mixer_oss_slot *rslot;
1049         char str[64];
1050
1051         /* check if already assigned */
1052         if (mixer->slots[ptr->oss_id].get_volume && ! replace_old)
1053                 return 0;
1054
1055         memset(&slot, 0, sizeof(slot));
1056         memset(slot.numid, 0xff, sizeof(slot.numid)); /* ID_UNKNOWN */
1057         if (snd_mixer_oss_build_test_all(mixer, ptr, &slot))
1058                 return 0;
1059         down_read(&mixer->card->controls_rwsem);
1060         if (ptr->index == 0 && (kctl = snd_mixer_oss_test_id(mixer, "Capture Source", 0)) != NULL) {
1061                 struct snd_ctl_elem_info *uinfo;
1062
1063                 uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
1064                 if (! uinfo) {
1065                         up_read(&mixer->card->controls_rwsem);
1066                         return -ENOMEM;
1067                 }
1068
1069                 if (kctl->info(kctl, uinfo)) {
1070                         up_read(&mixer->card->controls_rwsem);
1071                         kfree(uinfo);
1072                         return 0;
1073                 }
1074                 strcpy(str, ptr->name);
1075                 if (!strcmp(str, "Master"))
1076                         strcpy(str, "Mix");
1077                 if (!strcmp(str, "Master Mono"))
1078                         strcpy(str, "Mix Mono");
1079                 slot.capture_item = 0;
1080                 if (!strcmp(uinfo->value.enumerated.name, str)) {
1081                         slot.present |= SNDRV_MIXER_OSS_PRESENT_CAPTURE;
1082                 } else {
1083                         for (slot.capture_item = 1; slot.capture_item < uinfo->value.enumerated.items; slot.capture_item++) {
1084                                 uinfo->value.enumerated.item = slot.capture_item;
1085                                 if (kctl->info(kctl, uinfo)) {
1086                                         up_read(&mixer->card->controls_rwsem);
1087                                         kfree(uinfo);
1088                                         return 0;
1089                                 }
1090                                 if (!strcmp(uinfo->value.enumerated.name, str)) {
1091                                         slot.present |= SNDRV_MIXER_OSS_PRESENT_CAPTURE;
1092                                         break;
1093                                 }
1094                         }
1095                 }
1096                 kfree(uinfo);
1097         }
1098         up_read(&mixer->card->controls_rwsem);
1099         if (slot.present != 0) {
1100                 pslot = kmalloc(sizeof(slot), GFP_KERNEL);
1101                 if (! pslot)
1102                         return -ENOMEM;
1103                 *pslot = slot;
1104                 pslot->signature = SNDRV_MIXER_OSS_SIGNATURE;
1105                 pslot->assigned = ptr;
1106                 pslot->allocated = ptr_allocated;
1107                 rslot = &mixer->slots[ptr->oss_id];
1108                 mixer_slot_clear(rslot);
1109                 rslot->stereo = slot.channels > 1 ? 1 : 0;
1110                 rslot->get_volume = snd_mixer_oss_get_volume1;
1111                 rslot->put_volume = snd_mixer_oss_put_volume1;
1112                 /* note: ES18xx have both Capture Source and XX Capture Volume !!! */
1113                 if (slot.present & SNDRV_MIXER_OSS_PRESENT_CSWITCH) {
1114                         rslot->get_recsrc = snd_mixer_oss_get_recsrc1_sw;
1115                         rslot->put_recsrc = snd_mixer_oss_put_recsrc1_sw;
1116                 } else if (slot.present & SNDRV_MIXER_OSS_PRESENT_CROUTE) {
1117                         rslot->get_recsrc = snd_mixer_oss_get_recsrc1_route;
1118                         rslot->put_recsrc = snd_mixer_oss_put_recsrc1_route;
1119                 } else if (slot.present & SNDRV_MIXER_OSS_PRESENT_CAPTURE) {
1120                         mixer->mask_recsrc |= 1 << ptr->oss_id;
1121                 }
1122                 rslot->private_data = pslot;
1123                 rslot->private_free = snd_mixer_oss_slot_free;
1124                 return 1;
1125         }
1126         return 0;
1127 }
1128
1129 #ifdef CONFIG_SND_PROC_FS
1130 /*
1131  */
1132 #define MIXER_VOL(name) [SOUND_MIXER_##name] = #name
1133 static char *oss_mixer_names[SNDRV_OSS_MAX_MIXERS] = {
1134         MIXER_VOL(VOLUME),
1135         MIXER_VOL(BASS),
1136         MIXER_VOL(TREBLE),
1137         MIXER_VOL(SYNTH),
1138         MIXER_VOL(PCM),
1139         MIXER_VOL(SPEAKER),
1140         MIXER_VOL(LINE),
1141         MIXER_VOL(MIC),
1142         MIXER_VOL(CD),
1143         MIXER_VOL(IMIX),
1144         MIXER_VOL(ALTPCM),
1145         MIXER_VOL(RECLEV),
1146         MIXER_VOL(IGAIN),
1147         MIXER_VOL(OGAIN),
1148         MIXER_VOL(LINE1),
1149         MIXER_VOL(LINE2),
1150         MIXER_VOL(LINE3),
1151         MIXER_VOL(DIGITAL1),
1152         MIXER_VOL(DIGITAL2),
1153         MIXER_VOL(DIGITAL3),
1154         MIXER_VOL(PHONEIN),
1155         MIXER_VOL(PHONEOUT),
1156         MIXER_VOL(VIDEO),
1157         MIXER_VOL(RADIO),
1158         MIXER_VOL(MONITOR),
1159 };
1160
1161 /*
1162  *  /proc interface
1163  */
1164
1165 static void snd_mixer_oss_proc_read(struct snd_info_entry *entry,
1166                                     struct snd_info_buffer *buffer)
1167 {
1168         struct snd_mixer_oss *mixer = entry->private_data;
1169         int i;
1170
1171         mutex_lock(&mixer->reg_mutex);
1172         for (i = 0; i < SNDRV_OSS_MAX_MIXERS; i++) {
1173                 struct slot *p;
1174
1175                 if (! oss_mixer_names[i])
1176                         continue;
1177                 p = (struct slot *)mixer->slots[i].private_data;
1178                 snd_iprintf(buffer, "%s ", oss_mixer_names[i]);
1179                 if (p && p->assigned)
1180                         snd_iprintf(buffer, "\"%s\" %d\n",
1181                                     p->assigned->name,
1182                                     p->assigned->index);
1183                 else
1184                         snd_iprintf(buffer, "\"\" 0\n");
1185         }
1186         mutex_unlock(&mixer->reg_mutex);
1187 }
1188
1189 static void snd_mixer_oss_proc_write(struct snd_info_entry *entry,
1190                                      struct snd_info_buffer *buffer)
1191 {
1192         struct snd_mixer_oss *mixer = entry->private_data;
1193         char line[128], str[32], idxstr[16];
1194         const char *cptr;
1195         unsigned int idx;
1196         int ch;
1197         struct snd_mixer_oss_assign_table *tbl;
1198         struct slot *slot;
1199
1200         while (!snd_info_get_line(buffer, line, sizeof(line))) {
1201                 cptr = snd_info_get_str(str, line, sizeof(str));
1202                 for (ch = 0; ch < SNDRV_OSS_MAX_MIXERS; ch++)
1203                         if (oss_mixer_names[ch] && strcmp(oss_mixer_names[ch], str) == 0)
1204                                 break;
1205                 if (ch >= SNDRV_OSS_MAX_MIXERS) {
1206                         pr_err("ALSA: mixer_oss: invalid OSS volume '%s'\n",
1207                                str);
1208                         continue;
1209                 }
1210                 cptr = snd_info_get_str(str, cptr, sizeof(str));
1211                 if (! *str) {
1212                         /* remove the entry */
1213                         mutex_lock(&mixer->reg_mutex);
1214                         mixer_slot_clear(&mixer->slots[ch]);
1215                         mutex_unlock(&mixer->reg_mutex);
1216                         continue;
1217                 }
1218                 snd_info_get_str(idxstr, cptr, sizeof(idxstr));
1219                 idx = simple_strtoul(idxstr, NULL, 10);
1220                 if (idx >= 0x4000) { /* too big */
1221                         pr_err("ALSA: mixer_oss: invalid index %d\n", idx);
1222                         continue;
1223                 }
1224                 mutex_lock(&mixer->reg_mutex);
1225                 slot = (struct slot *)mixer->slots[ch].private_data;
1226                 if (slot && slot->assigned &&
1227                     slot->assigned->index == idx && ! strcmp(slot->assigned->name, str))
1228                         /* not changed */
1229                         goto __unlock;
1230                 tbl = kmalloc(sizeof(*tbl), GFP_KERNEL);
1231                 if (!tbl)
1232                         goto __unlock;
1233                 tbl->oss_id = ch;
1234                 tbl->name = kstrdup(str, GFP_KERNEL);
1235                 if (! tbl->name) {
1236                         kfree(tbl);
1237                         goto __unlock;
1238                 }
1239                 tbl->index = idx;
1240                 if (snd_mixer_oss_build_input(mixer, tbl, 1, 1) <= 0) {
1241                         kfree(tbl->name);
1242                         kfree(tbl);
1243                 }
1244         __unlock:
1245                 mutex_unlock(&mixer->reg_mutex);
1246         }
1247 }
1248
1249 static void snd_mixer_oss_proc_init(struct snd_mixer_oss *mixer)
1250 {
1251         struct snd_info_entry *entry;
1252
1253         entry = snd_info_create_card_entry(mixer->card, "oss_mixer",
1254                                            mixer->card->proc_root);
1255         if (! entry)
1256                 return;
1257         entry->content = SNDRV_INFO_CONTENT_TEXT;
1258         entry->mode = S_IFREG | 0644;
1259         entry->c.text.read = snd_mixer_oss_proc_read;
1260         entry->c.text.write = snd_mixer_oss_proc_write;
1261         entry->private_data = mixer;
1262         if (snd_info_register(entry) < 0) {
1263                 snd_info_free_entry(entry);
1264                 entry = NULL;
1265         }
1266         mixer->proc_entry = entry;
1267 }
1268
1269 static void snd_mixer_oss_proc_done(struct snd_mixer_oss *mixer)
1270 {
1271         snd_info_free_entry(mixer->proc_entry);
1272         mixer->proc_entry = NULL;
1273 }
1274 #else /* !CONFIG_SND_PROC_FS */
1275 #define snd_mixer_oss_proc_init(mix)
1276 #define snd_mixer_oss_proc_done(mix)
1277 #endif /* CONFIG_SND_PROC_FS */
1278
1279 static void snd_mixer_oss_build(struct snd_mixer_oss *mixer)
1280 {
1281         static struct snd_mixer_oss_assign_table table[] = {
1282                 { SOUND_MIXER_VOLUME,   "Master",               0 },
1283                 { SOUND_MIXER_VOLUME,   "Front",                0 }, /* fallback */
1284                 { SOUND_MIXER_BASS,     "Tone Control - Bass",  0 },
1285                 { SOUND_MIXER_TREBLE,   "Tone Control - Treble", 0 },
1286                 { SOUND_MIXER_SYNTH,    "Synth",                0 },
1287                 { SOUND_MIXER_SYNTH,    "FM",                   0 }, /* fallback */
1288                 { SOUND_MIXER_SYNTH,    "Music",                0 }, /* fallback */
1289                 { SOUND_MIXER_PCM,      "PCM",                  0 },
1290                 { SOUND_MIXER_SPEAKER,  "Beep",                 0 },
1291                 { SOUND_MIXER_SPEAKER,  "PC Speaker",           0 }, /* fallback */
1292                 { SOUND_MIXER_SPEAKER,  "Speaker",              0 }, /* fallback */
1293                 { SOUND_MIXER_LINE,     "Line",                 0 },
1294                 { SOUND_MIXER_MIC,      "Mic",                  0 },
1295                 { SOUND_MIXER_CD,       "CD",                   0 },
1296                 { SOUND_MIXER_IMIX,     "Monitor Mix",          0 },
1297                 { SOUND_MIXER_ALTPCM,   "PCM",                  1 },
1298                 { SOUND_MIXER_ALTPCM,   "Headphone",            0 }, /* fallback */
1299                 { SOUND_MIXER_ALTPCM,   "Wave",                 0 }, /* fallback */
1300                 { SOUND_MIXER_RECLEV,   "-- nothing --",        0 },
1301                 { SOUND_MIXER_IGAIN,    "Capture",              0 },
1302                 { SOUND_MIXER_OGAIN,    "Playback",             0 },
1303                 { SOUND_MIXER_LINE1,    "Aux",                  0 },
1304                 { SOUND_MIXER_LINE2,    "Aux",                  1 },
1305                 { SOUND_MIXER_LINE3,    "Aux",                  2 },
1306                 { SOUND_MIXER_DIGITAL1, "Digital",              0 },
1307                 { SOUND_MIXER_DIGITAL1, "IEC958",               0 }, /* fallback */
1308                 { SOUND_MIXER_DIGITAL1, "IEC958 Optical",       0 }, /* fallback */
1309                 { SOUND_MIXER_DIGITAL1, "IEC958 Coaxial",       0 }, /* fallback */
1310                 { SOUND_MIXER_DIGITAL2, "Digital",              1 },
1311                 { SOUND_MIXER_DIGITAL3, "Digital",              2 },
1312                 { SOUND_MIXER_PHONEIN,  "Phone",                0 },
1313                 { SOUND_MIXER_PHONEOUT, "Master Mono",          0 },
1314                 { SOUND_MIXER_PHONEOUT, "Speaker",              0 }, /*fallback*/
1315                 { SOUND_MIXER_PHONEOUT, "Mono",                 0 }, /*fallback*/
1316                 { SOUND_MIXER_PHONEOUT, "Phone",                0 }, /* fallback */
1317                 { SOUND_MIXER_VIDEO,    "Video",                0 },
1318                 { SOUND_MIXER_RADIO,    "Radio",                0 },
1319                 { SOUND_MIXER_MONITOR,  "Monitor",              0 }
1320         };
1321         unsigned int idx;
1322
1323         for (idx = 0; idx < ARRAY_SIZE(table); idx++)
1324                 snd_mixer_oss_build_input(mixer, &table[idx], 0, 0);
1325         if (mixer->mask_recsrc) {
1326                 mixer->get_recsrc = snd_mixer_oss_get_recsrc2;
1327                 mixer->put_recsrc = snd_mixer_oss_put_recsrc2;
1328         }
1329 }
1330
1331 /*
1332  *
1333  */
1334
1335 static int snd_mixer_oss_free1(void *private)
1336 {
1337         struct snd_mixer_oss *mixer = private;
1338         struct snd_card *card;
1339         int idx;
1340
1341         if (!mixer)
1342                 return 0;
1343         card = mixer->card;
1344         if (snd_BUG_ON(mixer != card->mixer_oss))
1345                 return -ENXIO;
1346         card->mixer_oss = NULL;
1347         for (idx = 0; idx < SNDRV_OSS_MAX_MIXERS; idx++) {
1348                 struct snd_mixer_oss_slot *chn = &mixer->slots[idx];
1349                 if (chn->private_free)
1350                         chn->private_free(chn);
1351         }
1352         kfree(mixer);
1353         return 0;
1354 }
1355
1356 static int snd_mixer_oss_notify_handler(struct snd_card *card, int cmd)
1357 {
1358         struct snd_mixer_oss *mixer;
1359
1360         if (cmd == SND_MIXER_OSS_NOTIFY_REGISTER) {
1361                 int idx, err;
1362
1363                 mixer = kcalloc(2, sizeof(*mixer), GFP_KERNEL);
1364                 if (mixer == NULL)
1365                         return -ENOMEM;
1366                 mutex_init(&mixer->reg_mutex);
1367                 if ((err = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIXER,
1368                                                    card, 0,
1369                                                    &snd_mixer_oss_f_ops, card)) < 0) {
1370                         dev_err(card->dev,
1371                                 "unable to register OSS mixer device %i:%i\n",
1372                                 card->number, 0);
1373                         kfree(mixer);
1374                         return err;
1375                 }
1376                 mixer->oss_dev_alloc = 1;
1377                 mixer->card = card;
1378                 if (*card->mixername)
1379                         strlcpy(mixer->name, card->mixername, sizeof(mixer->name));
1380                 else
1381                         snprintf(mixer->name, sizeof(mixer->name),
1382                                  "mixer%i", card->number);
1383 #ifdef SNDRV_OSS_INFO_DEV_MIXERS
1384                 snd_oss_info_register(SNDRV_OSS_INFO_DEV_MIXERS,
1385                                       card->number,
1386                                       mixer->name);
1387 #endif
1388                 for (idx = 0; idx < SNDRV_OSS_MAX_MIXERS; idx++)
1389                         mixer->slots[idx].number = idx;
1390                 card->mixer_oss = mixer;
1391                 snd_mixer_oss_build(mixer);
1392                 snd_mixer_oss_proc_init(mixer);
1393         } else {
1394                 mixer = card->mixer_oss;
1395                 if (mixer == NULL)
1396                         return 0;
1397                 if (mixer->oss_dev_alloc) {
1398 #ifdef SNDRV_OSS_INFO_DEV_MIXERS
1399                         snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_MIXERS, mixer->card->number);
1400 #endif
1401                         snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIXER, mixer->card, 0);
1402                         mixer->oss_dev_alloc = 0;
1403                 }
1404                 if (cmd == SND_MIXER_OSS_NOTIFY_DISCONNECT)
1405                         return 0;
1406                 snd_mixer_oss_proc_done(mixer);
1407                 return snd_mixer_oss_free1(mixer);
1408         }
1409         return 0;
1410 }
1411
1412 static int __init alsa_mixer_oss_init(void)
1413 {
1414         struct snd_card *card;
1415         int idx;
1416
1417         snd_mixer_oss_notify_callback = snd_mixer_oss_notify_handler;
1418         for (idx = 0; idx < SNDRV_CARDS; idx++) {
1419                 card = snd_card_ref(idx);
1420                 if (card) {
1421                         snd_mixer_oss_notify_handler(card, SND_MIXER_OSS_NOTIFY_REGISTER);
1422                         snd_card_unref(card);
1423                 }
1424         }
1425         return 0;
1426 }
1427
1428 static void __exit alsa_mixer_oss_exit(void)
1429 {
1430         struct snd_card *card;
1431         int idx;
1432
1433         snd_mixer_oss_notify_callback = NULL;
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_FREE);
1438                         snd_card_unref(card);
1439                 }
1440         }
1441 }
1442
1443 module_init(alsa_mixer_oss_init)
1444 module_exit(alsa_mixer_oss_exit)