sys/dev/sound/isa/i386/pas2/pas2_mixer.c

   1 /*
   2  * sound/pas2_mixer.c
   3  *
   4  * Mixer routines for the Pro Audio Spectrum cards.
   5  *
   6  * Copyright by Hannu Savolainen 1993
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are
  10  * met: 1. Redistributions of source code must retain the above copyright
  11  * notice, this list of conditions and the following disclaimer. 2.
  12  * Redistributions in binary form must reproduce the above copyright notice,
  13  * this list of conditions and the following disclaimer in the documentation
  14  * and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
  17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  20  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * $FreeBSD: src/sys/i386/isa/sound/pas2_mixer.c,v 1.22 1999/12/20 18:05:00 eivind Exp $
  29  * $DragonFly: src/sys/dev/sound/isa/i386/pas2/Attic/pas2_mixer.c,v 1.2 2003/06/17 04:28:38 dillon Exp $
  30  */
  31
  32 #define _PAS2_MIXER_C_
  33
  34 #include <i386/isa/sound/sound_config.h>
  35
  36 #if defined(CONFIG_PAS)
  37
  38 #include <i386/isa/sound/pas_hw.h>
  39
  40 #define TRACE(what)             /* (what) */
  41
  42 extern int      translat_code;
  43 extern char     pas_model;
  44 extern sound_os_info *pas_osp;
  45
  46 static int      rec_devices = (SOUND_MASK_MIC); /* Default recording source */
  47 static int      mode_control = 0;
  48
  49 #define POSSIBLE_RECORDING_DEVICES      (SOUND_MASK_SYNTH | SOUND_MASK_SPEAKER | SOUND_MASK_LINE | SOUND_MASK_MIC | \
  50                                          SOUND_MASK_CD | SOUND_MASK_ALTPCM)
  51
  52 #define SUPPORTED_MIXER_DEVICES         (SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_SPEAKER | SOUND_MASK_LINE | SOUND_MASK_MIC | \
  53                                          SOUND_MASK_CD | SOUND_MASK_ALTPCM | SOUND_MASK_IMIX | \
  54                                          SOUND_MASK_VOLUME | SOUND_MASK_BASS | SOUND_MASK_TREBLE | SOUND_MASK_RECLEV | \
  55                                          SOUND_MASK_MUTE | SOUND_MASK_ENHANCE | SOUND_MASK_LOUD)
  56
  57 static u_short levels[SOUND_MIXER_NRDEVICES] =
  58 {
  59         0x3232,                 /* Master Volume */
  60         0x3232,                 /* Bass */
  61         0x3232,                 /* Treble */
  62         0x5050,                 /* FM */
  63         0x4b4b,                 /* PCM */
  64         0x3232,                 /* PC Speaker */
  65         0x4b4b,                 /* Ext Line */
  66         0x4b4b,                 /* Mic */
  67         0x4b4b,                 /* CD */
  68         0x6464,                 /* Recording monitor */
  69         0x4b4b,                 /* SB PCM */
  70         0x6464                  /* Recording level */
  71 };
  72
  73 void mix_write(u_char data, int ioaddr);
  74
  75 void
  76 mix_write(u_char data, int ioaddr)
  77 {
  78         /*
  79          * The Revision D cards have a problem with their MVA508 interface.
  80          * The kludge-o-rama fix is to make a 16-bit quantity with identical
  81          * LSB and MSBs out of the output byte and to do a 16-bit out to the
  82          * mixer port - 1. We need to do this because it isn't timing problem
  83          * but chip access sequence problem.
  84          */
  85
  86         if (pas_model == PAS_16D) {
  87                 outw((ioaddr ^ translat_code) - 1, data | (data << 8));
  88                 outb(0, 0x80);
  89         } else
  90                 pas_write(data, ioaddr);
  91 }
  92
  93 static int
  94 mixer_output(int right_vol, int left_vol, int div, int bits,
  95              int mixer)
  96 {                               /* Input or output mixer */
  97         int             left = left_vol * div / 100;
  98         int             right = right_vol * div / 100;
  99
 100
 101         if (bits & P_M_MV508_MIXER) {   /* Select input or output mixer */
 102                 left |= mixer;
 103                 right |= mixer;
 104         }
 105         if (bits == P_M_MV508_BASS || bits == P_M_MV508_TREBLE) {       /* Bass and treble are
 106                                                                          * mono devices */
 107                 mix_write(P_M_MV508_ADDRESS | bits, PARALLEL_MIXER);
 108                 mix_write(left, PARALLEL_MIXER);
 109                 right_vol = left_vol;
 110         } else {
 111                 mix_write(P_M_MV508_ADDRESS | P_M_MV508_LEFT | bits, PARALLEL_MIXER);
 112                 mix_write(left, PARALLEL_MIXER);
 113                 mix_write(P_M_MV508_ADDRESS | P_M_MV508_RIGHT | bits, PARALLEL_MIXER);
 114                 mix_write(right, PARALLEL_MIXER);
 115         }
 116
 117         return (left_vol | (right_vol << 8));
 118 }
 119
 120 static void
 121 set_mode(int new_mode)
 122 {
 123         mix_write(P_M_MV508_ADDRESS | P_M_MV508_MODE, PARALLEL_MIXER);
 124         mix_write(new_mode, PARALLEL_MIXER);
 125
 126         mode_control = new_mode;
 127 }
 128
 129 static int
 130 pas_mixer_set(int whichDev, u_int level)
 131 {
 132         int             left, right, devmask, changed, i, mixer = 0;
 133
 134         TRACE(printf("static int pas_mixer_set(int whichDev = %d, u_int level = %X)\n", whichDev, level));
 135
 136         left = level & 0x7f;
 137         right = (level & 0x7f00) >> 8;
 138
 139         if (whichDev < SOUND_MIXER_NRDEVICES) {
 140                 if ((1 << whichDev) & rec_devices)
 141                         mixer = P_M_MV508_INPUTMIX;
 142                 else
 143                         mixer = P_M_MV508_OUTPUTMIX;
 144         }
 145         switch (whichDev) {
 146         case SOUND_MIXER_VOLUME:        /* Master volume (0-63) */
 147                 levels[whichDev] = mixer_output(right, left, 63, P_M_MV508_MASTER_A, 0);
 148                 break;
 149
 150                 /*
 151                  * Note! Bass and Treble are mono devices. Will use just the
 152                  * left channel.
 153                  */
 154         case SOUND_MIXER_BASS:  /* Bass (0-12) */
 155                 levels[whichDev] = mixer_output(right, left, 12, P_M_MV508_BASS, 0);
 156                 break;
 157         case SOUND_MIXER_TREBLE:        /* Treble (0-12) */
 158                 levels[whichDev] = mixer_output(right, left, 12, P_M_MV508_TREBLE, 0);
 159                 break;
 160
 161         case SOUND_MIXER_SYNTH:/* Internal synthesizer (0-31) */
 162                 levels[whichDev] = mixer_output(right, left, 31, P_M_MV508_MIXER | P_M_MV508_FM, mixer);
 163                 break;
 164         case SOUND_MIXER_PCM:   /* PAS PCM (0-31) */
 165                 levels[whichDev] = mixer_output(right, left, 31, P_M_MV508_MIXER | P_M_MV508_PCM, mixer);
 166                 break;
 167         case SOUND_MIXER_ALTPCM:        /* SB PCM (0-31) */
 168                 levels[whichDev] = mixer_output(right, left, 31, P_M_MV508_MIXER | P_M_MV508_SB, mixer);
 169                 break;
 170         case SOUND_MIXER_SPEAKER:       /* PC speaker (0-31) */
 171                 levels[whichDev] = mixer_output(right, left, 31, P_M_MV508_MIXER | P_M_MV508_SPEAKER, mixer);
 172                 break;
 173         case SOUND_MIXER_LINE:  /* External line (0-31) */
 174                 levels[whichDev] = mixer_output(right, left, 31, P_M_MV508_MIXER | P_M_MV508_LINE, mixer);
 175                 break;
 176         case SOUND_MIXER_CD:    /* CD (0-31) */
 177                 levels[whichDev] = mixer_output(right, left, 31, P_M_MV508_MIXER | P_M_MV508_CDROM, mixer);
 178                 break;
 179         case SOUND_MIXER_MIC:   /* External microphone (0-31) */
 180                 levels[whichDev] = mixer_output(right, left, 31, P_M_MV508_MIXER | P_M_MV508_MIC, mixer);
 181                 break;
 182         case SOUND_MIXER_IMIX:  /* Recording monitor (0-31) (Output mixer
 183                                  * only) */
 184                 levels[whichDev] = mixer_output(right, left, 31, P_M_MV508_MIXER | P_M_MV508_IMIXER,
 185                                                 P_M_MV508_OUTPUTMIX);
 186                 break;
 187         case SOUND_MIXER_RECLEV:        /* Recording level (0-15) */
 188                 levels[whichDev] = mixer_output(right, left, 15, P_M_MV508_MASTER_B, 0);
 189                 break;
 190
 191         case SOUND_MIXER_MUTE:
 192                 return 0;
 193                 break;
 194
 195         case SOUND_MIXER_ENHANCE:
 196                 i = 0;
 197                 level &= 0x7f;
 198                 if (level)
 199                         i = (level / 20) - 1;
 200
 201                 mode_control &= ~P_M_MV508_ENHANCE_BITS;
 202                 mode_control |= P_M_MV508_ENHANCE_BITS;
 203                 set_mode(mode_control);
 204
 205                 if (i)
 206                         i = (i + 1) * 20;
 207                 return i;
 208                 break;
 209
 210         case SOUND_MIXER_LOUD:
 211                 mode_control &= ~P_M_MV508_LOUDNESS;
 212                 if (level)
 213                         mode_control |= P_M_MV508_LOUDNESS;
 214                 set_mode(mode_control);
 215                 return !!level; /* 0 or 1 */
 216                 break;
 217
 218         case SOUND_MIXER_RECSRC:
 219                 devmask = level & POSSIBLE_RECORDING_DEVICES;
 220
 221                 changed = devmask ^ rec_devices;
 222                 rec_devices = devmask;
 223
 224                 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
 225                         if (changed & (1 << i)) {
 226                                 pas_mixer_set(i, levels[i]);
 227                         }
 228                 return rec_devices;
 229                 break;
 230
 231         default:
 232                 return -(EINVAL);
 233         }
 234
 235         return (levels[whichDev]);
 236 }
 237
 238 /*****/
 239
 240 static void
 241 pas_mixer_reset(void)
 242 {
 243         int             foo;
 244
 245         TRACE(printf("pas2_mixer.c: void pas_mixer_reset(void)\n"));
 246
 247         for (foo = 0; foo < SOUND_MIXER_NRDEVICES; foo++)
 248                 pas_mixer_set(foo, levels[foo]);
 249
 250         set_mode(P_M_MV508_LOUDNESS | P_M_MV508_ENHANCE_40);
 251 }
 252
 253 static int
 254 pas_mixer_ioctl(int dev, u_int cmd, ioctl_arg arg)
 255 {
 256         TRACE(printf("pas2_mixer.c: int pas_mixer_ioctl(u_int cmd = %X, u_int arg = %X)\n", cmd, arg));
 257
 258         if (((cmd >> 8) & 0xff) == 'M') {
 259                 if (cmd & IOC_IN)
 260                         return *(int *) arg = pas_mixer_set(cmd & 0xff, (*(int *) arg));
 261                 else {          /* Read parameters */
 262
 263                         switch (cmd & 0xff) {
 264
 265                         case SOUND_MIXER_RECSRC:
 266                                 return *(int *) arg = rec_devices;
 267                                 break;
 268
 269                         case SOUND_MIXER_STEREODEVS:
 270                                 return *(int *) arg = SUPPORTED_MIXER_DEVICES & ~(SOUND_MASK_BASS | SOUND_MASK_TREBLE);
 271                                 break;
 272
 273                         case SOUND_MIXER_DEVMASK:
 274                                 return *(int *) arg = SUPPORTED_MIXER_DEVICES;
 275                                 break;
 276
 277                         case SOUND_MIXER_RECMASK:
 278                                 return *(int *) arg = POSSIBLE_RECORDING_DEVICES & SUPPORTED_MIXER_DEVICES;
 279                                 break;
 280
 281                         case SOUND_MIXER_CAPS:
 282                                 return *(int *) arg = 0;        /* No special
 283                                                                  * capabilities */
 284                                 break;
 285
 286                         case SOUND_MIXER_MUTE:
 287                                 return *(int *) arg = 0;        /* No mute yet */
 288                                 break;
 289
 290                         case SOUND_MIXER_ENHANCE:
 291                                 if (!(mode_control & P_M_MV508_ENHANCE_BITS))
 292                                         return *(int *) arg = 0;
 293                                 return *(int *) arg = ((mode_control & P_M_MV508_ENHANCE_BITS) + 1) * 20;
 294                                 break;
 295
 296                         case SOUND_MIXER_LOUD:
 297                                 if (mode_control & P_M_MV508_LOUDNESS)
 298                                         return *(int *) arg = 1;
 299                                 return *(int *) arg = 0;
 300                                 break;
 301
 302                         default:
 303                                 return *(int *) arg = levels[cmd & 0xff];
 304                         }
 305                 }
 306         }
 307         return -(EINVAL);
 308 }
 309
 310 static struct mixer_operations pas_mixer_operations =
 311 {
 312         "Pro Audio Spectrum 16",
 313         pas_mixer_ioctl
 314 };
 315
 316 int
 317 pas_init_mixer(void)
 318 {
 319         pas_mixer_reset();
 320
 321         if (num_mixers < MAX_MIXER_DEV)
 322                 mixer_devs[num_mixers++] = &pas_mixer_operations;
 323         return 1;
 324 }
 325
 326 #endif