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 15static 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 41static struct ac97_chn_desc * 42ac97_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 54static inline int 55ac97_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 61int 62ac97_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/* Return the contents of register REG; use the cache if the value in it 116 is valid. Returns a negative error code on failure. */ 117static int 118ac97_get_register (struct ac97_hwint *dev, u8 reg) 119{ 120 if (reg > 127 || (reg & 1)) 121 return -EINVAL; 122 123 /* See if it's in the cache, or if it's just plain invalid. */ 124 switch (dev->last_written_mixer_values[reg / 2]) { 125 case AC97_REG_UNSUPPORTED: 126 return -EINVAL; 127 break; 128 case AC97_REGVAL_UNKNOWN: 129 dev->last_written_mixer_values[reg / 2] = dev->read_reg (dev, reg); 130 break; 131 default: 132 break; 133 } 134 return dev->last_written_mixer_values[reg / 2]; 135} 136 137/* Write VALUE to AC97 register REG, and cache its value in the last-written 138 cache. Returns a negative error code on failure, or 0 on success. */ 139int 140ac97_put_register (struct ac97_hwint *dev, u8 reg, u16 value) 141{ 142 if (reg > 127 || (reg & 1)) 143 return -EINVAL; 144 145 if (dev->last_written_mixer_values[reg / 2] == AC97_REG_UNSUPPORTED) 146 return -EINVAL; 147 else { 148 int res = dev->write_reg (dev, reg, value); 149 if (res >= 0) { 150 dev->last_written_mixer_values[reg / 2] = value; 151 return 0; 152 } 153 else 154 return res; 155 } 156} 157 158/* Scale VALUE (a value fro 0 to MAXVAL) to a value from 0-100. If 159 IS_STEREO is set, VALUE is a stereo value; the left channel value 160 is in the lower 8 bits, and the right channel value is in the upper 161 8 bits. 162 163 A negative error code is returned on failure, or the unsigned 164 scaled value on success. */ 165 166static int 167ac97_scale_to_oss_val (int value, int maxval, int is_stereo, int inv) 168{ 169 /* Muted? */ 170 if (value & AC97_MUTE) 171 return 0; 172 173 if (is_stereo) 174 return (ac97_scale_to_oss_val (value & 255, maxval, 0, inv) << 8) 175 | (ac97_scale_to_oss_val ((value >> 8) & 255, maxval, 0, inv) << 0); 176 else { 177 int i; 178 179 /* Inverted. */ 180 if (inv) 181 value = maxval - value; 182 183 i = (value * 100 + (maxval / 2)) / maxval; 184 if (i > 100) 185 i = 100; 186 if (i < 0) 187 i = 0; 188 return i; 189 } 190} 191 192static int 193ac97_scale_from_oss_val (int value, int maxval, int is_stereo, int inv) 194{ 195 if (is_stereo) 196 return (ac97_scale_from_oss_val (value & 255, maxval, 0, inv) << 8) 197 | (ac97_scale_from_oss_val ((value >> 8) & 255, maxval, 0, inv) << 0); 198 else { 199 int i = ((value & 255) * maxval + 50) / 100; 200 if (inv) 201 i = maxval - i; 202 if (i < 0) 203 i = 0; 204 if (i > maxval) 205 i = maxval; 206 return i; 207 } 208} 209 210static int 211ac97_set_mixer (struct ac97_hwint *dev, int oss_channel, u16 oss_value) 212{ 213 int scaled_value; 214 struct ac97_chn_desc *channel = ac97_find_chndesc (dev, oss_channel); 215 int result; 216 217 if (channel == NULL) 218 return -ENODEV; 219 if (! ac97_is_valid_channel (dev, channel)) 220 return -ENODEV; 221 scaled_value = ac97_scale_from_oss_val (oss_value, channel->maxval, 222 channel->is_stereo, 223 channel->is_inverted); 224 if (scaled_value < 0) 225 return scaled_value; 226 227 if (channel->regmask != 0) { 228 int mv; 229 230 int oldval = ac97_get_register (dev, channel->ac97_regnum); 231 if (oldval < 0) 232 return oldval; 233 234 for (mv = channel->regmask; ! (mv & 1); mv >>= 1) 235 scaled_value <<= 1; 236 237 scaled_value &= channel->regmask; 238 scaled_value |= (oldval & ~channel->regmask); 239 } 240 result = ac97_put_register (dev, channel->ac97_regnum, scaled_value); 241 if (result == 0) 242 dev->last_written_OSS_values[oss_channel] = oss_value; 243 return result; 244} 245 246static int 247ac97_get_mixer_scaled (struct ac97_hwint *dev, int oss_channel) 248{ 249 struct ac97_chn_desc *channel = ac97_find_chndesc (dev, oss_channel); 250 int regval; 251 252 if (channel == NULL) 253 return -ENODEV; 254 255 if (! ac97_is_valid_channel (dev, channel)) 256 return -ENODEV; 257 258 regval = ac97_get_register (dev, channel->ac97_regnum); 259 260 if (regval < 0) 261 return regval; 262 263 if (channel->regmask != 0) { 264 int mv; 265 266 regval &= channel->regmask; 267 268 for (mv = channel->regmask; ! (mv & 1); mv >>= 1) 269 regval >>= 1; 270 } 271 return ac97_scale_to_oss_val (regval, channel->maxval, 272 channel->is_stereo, 273 channel->is_inverted); 274} 275 276static int 277ac97_get_recmask (struct ac97_hwint *dev) 278{ 279 int recReg = ac97_get_register (dev, AC97_RECORD_SELECT); 280 281 if (recReg < 0) 282 return recReg; 283 else { 284 int x; 285 for (x = 0; mixerRegs[x].ac97_regnum >= 0; x++) { 286 if (mixerRegs[x].recordNum == (recReg & 7)) 287 return mixerRegs[x].oss_mask; 288 } 289 return -ENODEV; 290 } 291} 292 293static int 294ac97_set_recmask (struct ac97_hwint *dev, int oss_recmask) 295{ 296 int x; 297 298 if (oss_recmask == 0) 299 oss_recmask = SOUND_MIXER_MIC; 300 301 for (x = 0; mixerRegs[x].ac97_regnum >= 0; x++) { 302 if ((mixerRegs[x].recordNum >= 0) 303 && (oss_recmask & mixerRegs[x].oss_mask)) 304 break; 305 } 306 if (mixerRegs[x].ac97_regnum < 0) 307 return -ENODEV; 308 else { 309 int regval = (mixerRegs[x].recordNum << 8) | mixerRegs[x].recordNum; 310 int res = ac97_put_register (dev, AC97_RECORD_SELECT, regval); 311 if (res == 0) 312 return ac97_get_recmask (dev); 313 else 314 return res; 315 } 316} 317 318/* Set the mixer DEV to the list of values in VALUE_LIST. Return 0 on 319 success, or a negative error code. */ 320int 321ac97_set_values (struct ac97_hwint *dev, 322 struct ac97_mixer_value_list *value_list) 323{ 324 int x; 325 326 for (x = 0; value_list[x].oss_channel != -1; x++) { 327 int chnum = value_list[x].oss_channel; 328 struct ac97_chn_desc *chent = ac97_find_chndesc (dev, chnum); 329 if (chent != NULL) { 330 u16 val; 331 int res; 332 333 if (chent->is_stereo) 334 val = (value_list[x].value.stereo.right << 8) 335 | value_list[x].value.stereo.left; 336 else { 337 /* We do this so the returned value looks OK in the 338 mixer app. It's not necessary otherwise. */ 339 val = (value_list[x].value.mono << 8) 340 | value_list[x].value.mono; 341 } 342 res = ac97_set_mixer (dev, chnum, val); 343 if (res < 0) 344 return res; 345 } 346 else 347 return -ENODEV; 348 } 349 return 0; 350} 351 352int 353ac97_mixer_ioctl (struct ac97_hwint *dev, unsigned int cmd, void __user *arg) 354{ 355 int ret; 356 357 switch (cmd) { 358 case SOUND_MIXER_READ_RECSRC: 359 ret = ac97_get_recmask (dev); 360 break; 361 362 case SOUND_MIXER_WRITE_RECSRC: 363 { 364 if (get_user (ret, (int __user *) arg)) 365 ret = -EFAULT; 366 else 367 ret = ac97_set_recmask (dev, ret); 368 } 369 break; 370 371 case SOUND_MIXER_READ_CAPS: 372 ret = SOUND_CAP_EXCL_INPUT; 373 break; 374 375 case SOUND_MIXER_READ_DEVMASK: 376 ret = dev->mixer_devmask; 377 break; 378 379 case SOUND_MIXER_READ_RECMASK: 380 ret = dev->mixer_recmask; 381 break; 382 383 case SOUND_MIXER_READ_STEREODEVS: 384 ret = dev->mixer_stereomask; 385 break; 386 387 default: 388 /* Read or write request. */ 389 ret = -EINVAL; 390 if (_IOC_TYPE (cmd) == 'M') { 391 int dir = _SIOC_DIR (cmd); 392 int channel = _IOC_NR (cmd); 393 394 if (channel >= 0 && channel < SOUND_MIXER_NRDEVICES) { 395 ret = 0; 396 if (dir & _SIOC_WRITE) { 397 int val; 398 if (get_user (val, (int __user *) arg) == 0) 399 ret = ac97_set_mixer (dev, channel, val); 400 else 401 ret = -EFAULT; 402 } 403 if (ret >= 0 && (dir & _SIOC_READ)) { 404 if (dev->last_written_OSS_values[channel] 405 == AC97_REGVAL_UNKNOWN) 406 dev->last_written_OSS_values[channel] 407 = ac97_get_mixer_scaled (dev, channel); 408 ret = dev->last_written_OSS_values[channel]; 409 } 410 } 411 } 412 break; 413 } 414 415 if (ret < 0) 416 return ret; 417 else 418 return put_user(ret, (int __user *) arg); 419} 420 421EXPORT_SYMBOL(ac97_init); 422EXPORT_SYMBOL(ac97_set_values); 423EXPORT_SYMBOL(ac97_put_register); 424EXPORT_SYMBOL(ac97_mixer_ioctl); 425MODULE_LICENSE("GPL"); 426 427 428/* 429 * Local variables: 430 * c-basic-offset: 4 431 * End: 432 */ 433