sound/core/oss/mixer_oss.c

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