linux/sound/oss/pas2_mixer.c
<<
>>
Prefs
   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
  28extern int      pas_translate_code;
  29extern char     pas_model;
  30extern int     *pas_osp;
  31extern int      pas_audiodev;
  32
  33static int      rec_devices = (SOUND_MASK_MIC);         /* Default recording source */
  34static 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
  43static int     *levels;
  44
  45static 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
  61void
  62mix_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
  80static int
  81mixer_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
 109static void
 110set_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
 118static int
 119pas_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
 205static void
 206pas_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
 218static 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
 313static 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
 321int __init
 322pas_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}
 337
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.