sound/oss/pas2_mixer.c

   1
   2 /*
   3  * sound/oss/pas2_mixer.c
   4  *
   5  * Mixer routines for the Pro Audio Spectrum cards.
   6  */
   7
   8 /*
   9  * Copyright (C) by Hannu Savolainen 1993-1997
  10  *
  11  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  12  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  13  * for more info.
  14  */
  15 /*
  16  * Thomas Sailer   : ioctl code reworked (vmalloc/vfree removed)
  17  * Bartlomiej Zolnierkiewicz : added __init to pas_init_mixer()
  18  */
  19 #include <linux/init.h>
  20 #include "sound_config.h"
  21
  22 #include "pas2.h"
  23
  24 #ifndef DEB
  25 #define DEB(what)               /* (what) */
  26 #endif
  27
  28 extern int      pas_translate_code;
  29 extern char     pas_model;
  30 extern int     *pas_osp;
  31 extern int      pas_audiodev;
  32
  33 static int      rec_devices = (SOUND_MASK_MIC);         /* Default recording source */
  34 static int      mode_control;
  35
  36 #define POSSIBLE_RECORDING_DEVICES      (SOUND_MASK_SYNTH | SOUND_MASK_SPEAKER | SOUND_MASK_LINE | SOUND_MASK_MIC | \
  37                                          SOUND_MASK_CD | SOUND_MASK_ALTPCM)
  38
  39 #define SUPPORTED_MIXER_DEVICES         (SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_SPEAKER | SOUND_MASK_LINE | SOUND_MASK_MIC | \
  40                                          SOUND_MASK_CD | SOUND_MASK_ALTPCM | SOUND_MASK_IMIX | \
  41                                          SOUND_MASK_VOLUME | SOUND_MASK_BASS | SOUND_MASK_TREBLE | SOUND_MASK_RECLEV)
  42
  43 static int     *levels;
  44
  45 static int      default_levels[32] =
  46 {
  47         0x3232,                 /* Master Volume */
  48         0x3232,                 /* Bass */
  49         0x3232,                 /* Treble */
  50         0x5050,                 /* FM */
  51         0x4b4b,                 /* PCM */
  52         0x3232,                 /* PC Speaker */
  53         0x4b4b,                 /* Ext Line */
  54         0x4b4b,                 /* Mic */
  55         0x4b4b,                 /* CD */
  56         0x6464,                 /* Recording monitor */
  57         0x4b4b,                 /* SB PCM */
  58         0x6464                  /* Recording level */
  59 };
  60
  61 void
  62 mix_write(unsigned char data, int ioaddr)
  63 {
  64         /*
  65          * The Revision D cards have a problem with their MVA508 interface. The
  66          * kludge-o-rama fix is to make a 16-bit quantity with identical LSB and
  67          * MSBs out of the output byte and to do a 16-bit out to the mixer port -
  68          * 1. We need to do this because it isn't timing problem but chip access
  69          * sequence problem.
  70          */
  71
  72         if (pas_model == 4)
  73           {
  74                   outw(data | (data << 8), (ioaddr + pas_translate_code) - 1);
  75                   outb((0x80), 0);
  76         } else
  77                 pas_write(data, ioaddr);
  78 }
  79
  80 static int
  81 mixer_output(int right_vol, int left_vol, int div, int bits,
  82              int mixer)         /* Input or output mixer */
  83 {
  84         int             left = left_vol * div / 100;
  85         int             right = right_vol * div / 100;
  86
  87
  88         if (bits & 0x10)
  89           {
  90                   left |= mixer;
  91                   right |= mixer;
  92           }
  93         if (bits == 0x03 || bits == 0x04)
  94           {
  95                   mix_write(0x80 | bits, 0x078B);
  96                   mix_write(left, 0x078B);
  97                   right_vol = left_vol;
  98         } else
  99           {
 100                   mix_write(0x80 | 0x20 | bits, 0x078B);
 101                   mix_write(left, 0x078B);
 102                   mix_write(0x80 | 0x40 | bits, 0x078B);
 103                   mix_write(right, 0x078B);
 104           }
 105
 106         return (left_vol | (right_vol << 8));
 107 }
 108
 109 static void
 110 set_mode(int new_mode)
 111 {
 112         mix_write(0x80 | 0x05, 0x078B);
 113         mix_write(new_mode, 0x078B);
 114
 115         mode_control = new_mode;
 116 }
 117
 118 static int
 119 pas_mixer_set(int whichDev, unsigned int level)
 120 {
 121         int             left, right, devmask, changed, i, mixer = 0;
 122
 123         DEB(printk("static int pas_mixer_set(int whichDev = %d, unsigned int level = %X)\n", whichDev, level));
 124
 125         left = level & 0x7f;
 126         right = (level & 0x7f00) >> 8;
 127
 128         if (whichDev < SOUND_MIXER_NRDEVICES) {
 129                 if ((1 << whichDev) & rec_devices)
 130                         mixer = 0x20;
 131                 else
 132                         mixer = 0x00;
 133         }
 134
 135         switch (whichDev)
 136           {
 137           case SOUND_MIXER_VOLUME:      /* Master volume (0-63) */
 138                   levels[whichDev] = mixer_output(right, left, 63, 0x01, 0);
 139                   break;
 140
 141                   /*
 142                    * Note! Bass and Treble are mono devices. Will use just the left
 143                    * channel.
 144                    */
 145           case SOUND_MIXER_BASS:        /* Bass (0-12) */
 146                   levels[whichDev] = mixer_output(right, left, 12, 0x03, 0);
 147                   break;
 148           case SOUND_MIXER_TREBLE:      /* Treble (0-12) */
 149                   levels[whichDev] = mixer_output(right, left, 12, 0x04, 0);
 150                   break;
 151
 152           case SOUND_MIXER_SYNTH:       /* Internal synthesizer (0-31) */
 153                   levels[whichDev] = mixer_output(right, left, 31, 0x10 | 0x00, mixer);
 154                   break;
 155           case SOUND_MIXER_PCM: /* PAS PCM (0-31) */
 156                   levels[whichDev] = mixer_output(right, left, 31, 0x10 | 0x05, mixer);
 157                   break;
 158           case SOUND_MIXER_ALTPCM:      /* SB PCM (0-31) */
 159                   levels[whichDev] = mixer_output(right, left, 31, 0x10 | 0x07, mixer);
 160                   break;
 161           case SOUND_MIXER_SPEAKER:     /* PC speaker (0-31) */
 162                   levels[whichDev] = mixer_output(right, left, 31, 0x10 | 0x06, mixer);
 163                   break;
 164           case SOUND_MIXER_LINE:        /* External line (0-31) */
 165                   levels[whichDev] = mixer_output(right, left, 31, 0x10 | 0x02, mixer);
 166                   break;
 167           case SOUND_MIXER_CD:  /* CD (0-31) */
 168                   levels[whichDev] = mixer_output(right, left, 31, 0x10 | 0x03, mixer);
 169                   break;
 170           case SOUND_MIXER_MIC: /* External microphone (0-31) */
 171                   levels[whichDev] = mixer_output(right, left, 31, 0x10 | 0x04, mixer);
 172                   break;
 173           case SOUND_MIXER_IMIX:        /* Recording monitor (0-31) (Output mixer only) */
 174                   levels[whichDev] = mixer_output(right, left, 31, 0x10 | 0x01,
 175                                                   0x00);
 176                   break;
 177           case SOUND_MIXER_RECLEV:      /* Recording level (0-15) */
 178                   levels[whichDev] = mixer_output(right, left, 15, 0x02, 0);
 179                   break;
 180
 181
 182           case SOUND_MIXER_RECSRC:
 183                   devmask = level & POSSIBLE_RECORDING_DEVICES;
 184
 185                   changed = devmask ^ rec_devices;
 186                   rec_devices = devmask;
 187
 188                   for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
 189                           if (changed & (1 << i))
 190                             {
 191                                     pas_mixer_set(i, levels[i]);
 192                             }
 193                   return rec_devices;
 194                   break;
 195
 196           default:
 197                   return -EINVAL;
 198           }
 199
 200         return (levels[whichDev]);
 201 }
 202
 203 /*****/
 204
 205 static void
 206 pas_mixer_reset(void)
 207 {
 208         int             foo;
 209
 210         DEB(printk("pas2_mixer.c: void pas_mixer_reset(void)\n"));
 211
 212         for (foo = 0; foo < SOUND_MIXER_NRDEVICES; foo++)
 213                 pas_mixer_set(foo, levels[foo]);
 214
 215         set_mode(0x04 | 0x01);
 216 }
 217
 218 static int pas_mixer_ioctl(int dev, unsigned int cmd, void __user *arg)
 219 {
 220         int level,v ;
 221         int __user *p = (int __user *)arg;
 222
 223         DEB(printk("pas2_mixer.c: int pas_mixer_ioctl(unsigned int cmd = %X, unsigned int arg = %X)\n", cmd, arg));
 224         if (cmd == SOUND_MIXER_PRIVATE1) { /* Set loudness bit */
 225                 if (get_user(level, p))
 226                         return -EFAULT;
 227                 if (level == -1)  /* Return current settings */
 228                         level = (mode_control & 0x04);
 229                 else {
 230                         mode_control &= ~0x04;
 231                         if (level)
 232                                 mode_control |= 0x04;
 233                         set_mode(mode_control);
 234                 }
 235                 level = !!level;
 236                 return put_user(level, p);
 237         }
 238         if (cmd == SOUND_MIXER_PRIVATE2) { /* Set enhance bit */
 239                 if (get_user(level, p))
 240                         return -EFAULT;
 241                 if (level == -1) { /* Return current settings */
 242                         if (!(mode_control & 0x03))
 243                                 level = 0;
 244                         else
 245                                 level = ((mode_control & 0x03) + 1) * 20;
 246                 } else {
 247                         int i = 0;
 248
 249                         level &= 0x7f;
 250                         if (level)
 251                                 i = (level / 20) - 1;
 252                         mode_control &= ~0x03;
 253                         mode_control |= i & 0x03;
 254                         set_mode(mode_control);
 255                         if (i)
 256                                 i = (i + 1) * 20;
 257                         level = i;
 258                 }
 259                 return put_user(level, p);
 260         }
 261         if (cmd == SOUND_MIXER_PRIVATE3) { /* Set mute bit */
 262                 if (get_user(level, p))
 263                         return -EFAULT;
 264                 if (level == -1)        /* Return current settings */
 265                         level = !(pas_read(0x0B8A) & 0x20);
 266                 else {
 267                         if (level)
 268                                 pas_write(pas_read(0x0B8A) & (~0x20), 0x0B8A);
 269                         else
 270                                 pas_write(pas_read(0x0B8A) | 0x20, 0x0B8A);
 271
 272                         level = !(pas_read(0x0B8A) & 0x20);
 273                 }
 274                 return put_user(level, p);
 275         }
 276         if (((cmd >> 8) & 0xff) == 'M') {
 277                 if (get_user(v, p))
 278                         return -EFAULT;
 279                 if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
 280                         v = pas_mixer_set(cmd & 0xff, v);
 281                 } else {
 282                         switch (cmd & 0xff) {
 283                         case SOUND_MIXER_RECSRC:
 284                                 v = rec_devices;
 285                                 break;
 286
 287                         case SOUND_MIXER_STEREODEVS:
 288                                 v = SUPPORTED_MIXER_DEVICES & ~(SOUND_MASK_BASS | SOUND_MASK_TREBLE);
 289                                 break;
 290
 291                         case SOUND_MIXER_DEVMASK:
 292                                 v = SUPPORTED_MIXER_DEVICES;
 293                                 break;
 294
 295                         case SOUND_MIXER_RECMASK:
 296                                 v = POSSIBLE_RECORDING_DEVICES & SUPPORTED_MIXER_DEVICES;
 297                                 break;
 298
 299                         case SOUND_MIXER_CAPS:
 300                                 v = 0;  /* No special capabilities */
 301                                 break;
 302
 303                         default:
 304                                 v = levels[cmd & 0xff];
 305                                 break;
 306                         }
 307                 }
 308                 return put_user(v, p);
 309         }
 310         return -EINVAL;
 311 }
 312
 313 static struct mixer_operations pas_mixer_operations =
 314 {
 315         .owner  = THIS_MODULE,
 316         .id     = "PAS16",
 317         .name   = "Pro Audio Spectrum 16",
 318         .ioctl  = pas_mixer_ioctl
 319 };
 320
 321 int __init
 322 pas_init_mixer(void)
 323 {
 324         int             d;
 325
 326         levels = load_mixer_volumes("PAS16_1", default_levels, 1);
 327
 328         pas_mixer_reset();
 329
 330         if ((d = sound_alloc_mixerdev()) != -1)
 331           {
 332                   audio_devs[pas_audiodev]->mixer_dev = d;
 333                   mixer_devs[d] = &pas_mixer_operations;
 334           }
 335         return 1;
 336 }