drivers/sound/pas2_mixer.c

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