sound/oss/ac97.c

   1 #include <linux/module.h>
   2 #include <linux/kernel.h>
   3 #include <linux/init.h>
   4 #include "ac97.h"
   5
   6 /* Flag for mono controls. */
   7 #define MO 0
   8 /* And for stereo. */
   9 #define ST 1
  10
  11 /* Whether or not the bits in the channel are inverted. */
  12 #define INV 1
  13 #define NINV 0
  14
  15 static struct ac97_chn_desc {
  16     int ac97_regnum;
  17     int oss_channel;
  18     int maxval;
  19     int is_stereo;
  20     int oss_mask;
  21     int recordNum;
  22     u16 regmask;
  23     int is_inverted;
  24 } mixerRegs[] = {
  25     { AC97_MASTER_VOL_STEREO, SOUND_MIXER_VOLUME,   0x3f, ST, SOUND_MASK_VOLUME,   5, 0x0000, INV  },
  26     { AC97_MASTER_VOL_MONO,   SOUND_MIXER_PHONEOUT, 0x3f, MO, SOUND_MASK_PHONEOUT, 6, 0x0000, INV  },
  27     { AC97_MASTER_TONE,       SOUND_MIXER_TREBLE,   0x0f, MO, SOUND_MASK_TREBLE,  -1, 0x00ff, INV  },
  28     { AC97_MASTER_TONE,       SOUND_MIXER_BASS,     0x0f, MO, SOUND_MASK_BASS,    -1, 0xff00, INV  },
  29     { AC97_PCBEEP_VOL,        SOUND_MIXER_SPEAKER,  0x0f, MO, SOUND_MASK_SPEAKER, -1, 0x001e, INV  },
  30     { AC97_PHONE_VOL,         SOUND_MIXER_PHONEIN,  0x1f, MO, SOUND_MASK_PHONEIN,  7, 0x0000, INV  },
  31     { AC97_MIC_VOL,           SOUND_MIXER_MIC,      0x1f, MO, SOUND_MASK_MIC,      0, 0x0000, INV  },
  32     { AC97_LINEIN_VOL,        SOUND_MIXER_LINE,     0x1f, ST, SOUND_MASK_LINE,     4, 0x0000, INV  },
  33     { AC97_CD_VOL,            SOUND_MIXER_CD,       0x1f, ST, SOUND_MASK_CD,       1, 0x0000, INV  },
  34     { AC97_VIDEO_VOL,         SOUND_MIXER_VIDEO,    0x1f, ST, SOUND_MASK_VIDEO,    2, 0x0000, INV  },
  35     { AC97_AUX_VOL,           SOUND_MIXER_LINE1,    0x1f, ST, SOUND_MASK_LINE1,    3, 0x0000, INV  },
  36     { AC97_PCMOUT_VOL,        SOUND_MIXER_PCM,      0x1f, ST, SOUND_MASK_PCM,     -1, 0x0000, INV  },
  37     { AC97_RECORD_GAIN,       SOUND_MIXER_IGAIN,    0x0f, ST, SOUND_MASK_IGAIN,   -1, 0x0000, NINV },
  38     { -1,                     -1,                   0xff, 0,  0,                  -1, 0x0000, 0    },
  39 };
  40
  41 static struct ac97_chn_desc *
  42 ac97_find_chndesc (struct ac97_hwint *dev, int oss_channel)
  43 {
  44     int x;
  45
  46     for (x = 0; mixerRegs[x].oss_channel != -1; x++) {
  47         if (mixerRegs[x].oss_channel == oss_channel)
  48             return mixerRegs + x;
  49     }
  50
  51     return NULL;
  52 }
  53
  54 static inline int
  55 ac97_is_valid_channel (struct ac97_hwint *dev, struct ac97_chn_desc *chn)
  56 {
  57     return (dev->last_written_mixer_values[chn->ac97_regnum / 2]
  58             != AC97_REG_UNSUPPORTED);
  59 }
  60
  61 int
  62 ac97_init (struct ac97_hwint *dev)
  63 {
  64     int x;
  65     int reg0;
  66
  67     /* Clear out the arrays of cached values. */
  68     for (x = 0; x < AC97_REG_CNT; x++)
  69         dev->last_written_mixer_values[x] = AC97_REGVAL_UNKNOWN;
  70
  71     for (x = 0; x < SOUND_MIXER_NRDEVICES; x++)
  72         dev->last_written_OSS_values[x] = AC97_REGVAL_UNKNOWN;
  73
  74     /* Clear the device masks.  */
  75     dev->mixer_devmask = 0;
  76     dev->mixer_stereomask = 0;
  77     dev->mixer_recmask = 0;
  78
  79     /* ??? Do a "standard reset" via register 0? */
  80
  81     /* Hardware-dependent reset.  */
  82     if (dev->reset_device (dev))
  83         return -1;
  84
  85     /* Check the mixer device capabilities.  */
  86     reg0 = dev->read_reg (dev, AC97_RESET);
  87
  88     if (reg0 < 0)
  89         return -1;
  90
  91     /* Check for support for treble/bass controls.  */
  92     if (! (reg0 & 4)) {
  93         dev->last_written_mixer_values[AC97_MASTER_TONE / 2]
  94             = AC97_REG_UNSUPPORTED;
  95     }
  96
  97     /* ??? There may be other tests here? */
  98
  99     /* Fill in the device masks.  */
 100     for (x = 0; mixerRegs[x].ac97_regnum != -1; x++) {
 101         if (ac97_is_valid_channel (dev, mixerRegs + x)) {
 102             dev->mixer_devmask |= mixerRegs[x].oss_mask;
 103
 104             if (mixerRegs[x].is_stereo)
 105                 dev->mixer_stereomask |= mixerRegs[x].oss_mask;
 106
 107             if (mixerRegs[x].recordNum != -1)
 108                 dev->mixer_recmask |= mixerRegs[x].oss_mask;
 109         }
 110     }
 111
 112     return 0;
 113 }
 114
 115 /* Reset the mixer to the currently saved settings.  */
 116 int
 117 ac97_reset (struct ac97_hwint *dev)
 118 {
 119     int x;
 120
 121     if (dev->reset_device (dev))
 122         return -1;
 123
 124     /* Now set the registers back to their last-written values. */
 125     for (x = 0; mixerRegs[x].ac97_regnum != -1; x++) {
 126         int regnum = mixerRegs[x].ac97_regnum;
 127         int value = dev->last_written_mixer_values [regnum / 2];
 128         if (value >= 0)
 129             ac97_put_register (dev, regnum, value);
 130     }
 131     return 0;
 132 }
 133
 134 /* Return the contents of register REG; use the cache if the value in it
 135    is valid.  Returns a negative error code on failure. */
 136 static int
 137 ac97_get_register (struct ac97_hwint *dev, u8 reg)
 138 {
 139     if (reg > 127 || (reg & 1))
 140         return -EINVAL;
 141
 142     /* See if it's in the cache, or if it's just plain invalid.  */
 143     switch (dev->last_written_mixer_values[reg / 2]) {
 144     case AC97_REG_UNSUPPORTED:
 145         return -EINVAL;
 146         break;
 147     case AC97_REGVAL_UNKNOWN:
 148         dev->last_written_mixer_values[reg / 2] = dev->read_reg (dev, reg);
 149         break;
 150     default:
 151         break;
 152     }
 153     return dev->last_written_mixer_values[reg / 2];
 154 }
 155
 156 /* Write VALUE to AC97 register REG, and cache its value in the last-written
 157    cache.  Returns a negative error code on failure, or 0 on success. */
 158 int
 159 ac97_put_register (struct ac97_hwint *dev, u8 reg, u16 value)
 160 {
 161     if (reg > 127 || (reg & 1))
 162         return -EINVAL;
 163
 164     if (dev->last_written_mixer_values[reg / 2] == AC97_REG_UNSUPPORTED)
 165         return -EINVAL;
 166     else {
 167         int res = dev->write_reg (dev, reg, value);
 168         if (res >= 0) {
 169             dev->last_written_mixer_values[reg / 2] = value;
 170             return 0;
 171         }
 172         else
 173             return res;
 174     }
 175 }
 176
 177 /* Scale VALUE (a value fro 0 to MAXVAL) to a value from 0-100.  If
 178    IS_STEREO is set, VALUE is a stereo value; the left channel value
 179    is in the lower 8 bits, and the right channel value is in the upper
 180    8 bits.
 181
 182    A negative error code is returned on failure, or the unsigned
 183    scaled value on success.  */
 184
 185 static int
 186 ac97_scale_to_oss_val (int value, int maxval, int is_stereo, int inv)
 187 {
 188     /* Muted?  */
 189     if (value & AC97_MUTE)
 190         return 0;
 191
 192     if (is_stereo)
 193         return (ac97_scale_to_oss_val (value & 255, maxval, 0, inv) << 8)
 194         | (ac97_scale_to_oss_val ((value >> 8) & 255, maxval, 0, inv) << 0);
 195     else {
 196         int i;
 197
 198         /* Inverted. */
 199         if (inv)
 200             value = maxval - value;
 201
 202         i = (value * 100 + (maxval / 2)) / maxval;
 203         if (i > 100)
 204              i = 100;
 205         if (i < 0)
 206             i = 0;
 207         return i;
 208     }
 209 }
 210
 211 static int
 212 ac97_scale_from_oss_val (int value, int maxval, int is_stereo, int inv)
 213 {
 214     if (is_stereo)
 215         return (ac97_scale_from_oss_val (value & 255, maxval, 0, inv) << 8)
 216         | (ac97_scale_from_oss_val ((value >> 8) & 255, maxval, 0, inv) << 0);
 217     else {
 218         int i = ((value & 255) * maxval + 50) / 100;
 219         if (inv)
 220             i = maxval - i;
 221         if (i < 0)
 222             i = 0;
 223         if (i > maxval)
 224             i = maxval;
 225         return i;
 226     }
 227 }
 228
 229 static int
 230 ac97_set_mixer (struct ac97_hwint *dev, int oss_channel, u16 oss_value)
 231 {
 232     int scaled_value;
 233     struct ac97_chn_desc *channel = ac97_find_chndesc (dev, oss_channel);
 234     int result;
 235
 236     if (channel == NULL)
 237         return -ENODEV;
 238     if (! ac97_is_valid_channel (dev, channel))
 239         return -ENODEV;
 240     scaled_value = ac97_scale_from_oss_val (oss_value, channel->maxval,
 241                                             channel->is_stereo,
 242                                             channel->is_inverted);
 243     if (scaled_value < 0)
 244         return scaled_value;
 245
 246     if (channel->regmask != 0) {
 247         int mv;
 248
 249         int oldval = ac97_get_register (dev, channel->ac97_regnum);
 250         if (oldval < 0)
 251             return oldval;
 252
 253         for (mv = channel->regmask; ! (mv & 1); mv >>= 1)
 254             scaled_value <<= 1;
 255
 256         scaled_value &= channel->regmask;
 257         scaled_value |= (oldval & ~channel->regmask);
 258     }
 259     result = ac97_put_register (dev, channel->ac97_regnum, scaled_value);
 260     if (result == 0)
 261         dev->last_written_OSS_values[oss_channel] = oss_value;
 262     return result;
 263 }
 264
 265 static int
 266 ac97_get_mixer_scaled (struct ac97_hwint *dev, int oss_channel)
 267 {
 268     struct ac97_chn_desc *channel = ac97_find_chndesc (dev, oss_channel);
 269     int regval;
 270
 271     if (channel == NULL)
 272         return -ENODEV;
 273
 274     if (! ac97_is_valid_channel (dev, channel))
 275         return -ENODEV;
 276
 277     regval = ac97_get_register (dev, channel->ac97_regnum);
 278
 279     if (regval < 0)
 280         return regval;
 281
 282     if (channel->regmask != 0) {
 283         int mv;
 284
 285         regval &= channel->regmask;
 286
 287         for (mv = channel->regmask; ! (mv & 1); mv >>= 1)
 288             regval >>= 1;
 289     }
 290     return ac97_scale_to_oss_val (regval, channel->maxval,
 291                                   channel->is_stereo,
 292                                   channel->is_inverted);
 293 }
 294
 295 static int
 296 ac97_get_recmask (struct ac97_hwint *dev)
 297 {
 298     int recReg = ac97_get_register (dev, AC97_RECORD_SELECT);
 299
 300     if (recReg < 0)
 301         return recReg;
 302     else {
 303         int x;
 304         for (x = 0; mixerRegs[x].ac97_regnum >= 0; x++) {
 305             if (mixerRegs[x].recordNum == (recReg & 7))
 306                 return mixerRegs[x].oss_mask;
 307         }
 308         return -ENODEV;
 309     }
 310 }
 311
 312 static int
 313 ac97_set_recmask (struct ac97_hwint *dev, int oss_recmask)
 314 {
 315     int x;
 316
 317     if (oss_recmask == 0)
 318         oss_recmask = SOUND_MIXER_MIC;
 319
 320     for (x = 0; mixerRegs[x].ac97_regnum >= 0; x++) {
 321         if ((mixerRegs[x].recordNum >= 0)
 322              && (oss_recmask & mixerRegs[x].oss_mask))
 323             break;
 324     }
 325     if (mixerRegs[x].ac97_regnum < 0)
 326         return -ENODEV;
 327     else {
 328         int regval = (mixerRegs[x].recordNum << 8) | mixerRegs[x].recordNum;
 329         int res = ac97_put_register (dev, AC97_RECORD_SELECT, regval);
 330         if (res == 0)
 331             return ac97_get_recmask (dev);
 332         else
 333             return res;
 334     }
 335 }
 336
 337 /* Set the mixer DEV to the list of values in VALUE_LIST.  Return 0 on
 338    success, or a negative error code.  */
 339 int
 340 ac97_set_values (struct ac97_hwint *dev,
 341                  struct ac97_mixer_value_list *value_list)
 342 {
 343     int x;
 344
 345     for (x = 0; value_list[x].oss_channel != -1; x++) {
 346         int chnum = value_list[x].oss_channel;
 347         struct ac97_chn_desc *chent = ac97_find_chndesc (dev, chnum);
 348         if (chent != NULL) {
 349             u16 val;
 350             int res;
 351
 352             if (chent->is_stereo)
 353                 val = (value_list[x].value.stereo.right << 8)
 354                       | value_list[x].value.stereo.left;
 355             else {
 356                 /* We do this so the returned value looks OK in the
 357                    mixer app.  It's not necessary otherwise.  */
 358                 val = (value_list[x].value.mono << 8)
 359                       | value_list[x].value.mono;
 360             }
 361             res = ac97_set_mixer (dev, chnum, val);
 362             if (res < 0)
 363                 return res;
 364         }
 365         else
 366             return -ENODEV;
 367     }
 368     return 0;
 369 }
 370
 371 int
 372 ac97_mixer_ioctl (struct ac97_hwint *dev, unsigned int cmd, void __user *arg)
 373 {
 374     int ret;
 375
 376     switch (cmd) {
 377     case SOUND_MIXER_READ_RECSRC:
 378         ret = ac97_get_recmask (dev);
 379         break;
 380
 381     case SOUND_MIXER_WRITE_RECSRC:
 382         {
 383             if (get_user (ret, (int __user *) arg))
 384                 ret = -EFAULT;
 385             else
 386                 ret = ac97_set_recmask (dev, ret);
 387         }
 388         break;
 389
 390     case SOUND_MIXER_READ_CAPS:
 391         ret = SOUND_CAP_EXCL_INPUT;
 392         break;
 393
 394     case SOUND_MIXER_READ_DEVMASK:
 395         ret = dev->mixer_devmask;
 396         break;
 397
 398     case SOUND_MIXER_READ_RECMASK:
 399         ret = dev->mixer_recmask;
 400         break;
 401
 402     case SOUND_MIXER_READ_STEREODEVS:
 403         ret = dev->mixer_stereomask;
 404         break;
 405
 406     default:
 407         /* Read or write request. */
 408         ret = -EINVAL;
 409         if (_IOC_TYPE (cmd) == 'M') {
 410             int dir = _SIOC_DIR (cmd);
 411             int channel = _IOC_NR (cmd);
 412
 413             if (channel >= 0 && channel < SOUND_MIXER_NRDEVICES) {
 414                 ret = 0;
 415                 if (dir & _SIOC_WRITE) {
 416                     int val;
 417                     if (get_user (val, (int __user *) arg) == 0)
 418                         ret = ac97_set_mixer (dev, channel, val);
 419                     else
 420                         ret = -EFAULT;
 421                 }
 422                 if (ret >= 0 && (dir & _SIOC_READ)) {
 423                     if (dev->last_written_OSS_values[channel]
 424                         == AC97_REGVAL_UNKNOWN)
 425                         dev->last_written_OSS_values[channel]
 426                             = ac97_get_mixer_scaled (dev, channel);
 427                     ret = dev->last_written_OSS_values[channel];
 428                 }
 429             }
 430         }
 431         break;
 432     }
 433
 434     if (ret < 0)
 435         return ret;
 436     else
 437         return put_user(ret, (int __user *) arg);
 438 }
 439
 440 EXPORT_SYMBOL(ac97_init);
 441 EXPORT_SYMBOL(ac97_set_values);
 442 EXPORT_SYMBOL(ac97_put_register);
 443 EXPORT_SYMBOL(ac97_mixer_ioctl);
 444 EXPORT_SYMBOL(ac97_reset);
 445 MODULE_LICENSE("GPL");
 446
 447 \f
 448 /*
 449  * Local variables:
 450  *  c-basic-offset: 4
 451  * End:
 452  */