开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
ac97.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：11k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

ac97.c：源码内容
  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/init.h>
  4. #include "ac97.h"
  6. /* Flag for mono controls. */
  7. #define MO 0
  8. /* And for stereo. */
  9. #define ST 1
  11. /* Whether or not the bits in the channel are inverted. */
  12. #define INV 1
  13. #define NINV 0
  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. };
  41. static struct ac97_chn_desc *
  42. ac97_find_chndesc (struct ac97_hwint *dev, int oss_channel)
  43. {
  44.     int x;
  46.     for (x = 0; mixerRegs[x].oss_channel != -1; x++) {
  47. if (mixerRegs[x].oss_channel == oss_channel)
  48.     return mixerRegs + x;
  49.     }
  51.     return NULL;
  52. }
  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. }
  61. int
  62. ac97_init (struct ac97_hwint *dev)
  63. {
  64.     int x;
  65.     int reg0;
  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;
  71.     for (x = 0; x < SOUND_MIXER_NRDEVICES; x++)
  72. dev->last_written_OSS_values[x] = AC97_REGVAL_UNKNOWN;
  74.     /* Clear the device masks.  */
  75.     dev->mixer_devmask = 0;
  76.     dev->mixer_stereomask = 0;
  77.     dev->mixer_recmask = 0;
  79.     /* ??? Do a "standard reset" via register 0? */
  81.     /* Hardware-dependent reset.  */
  82.     if (dev->reset_device (dev))
  83. return -1;
  85.     /* Check the mixer device capabilities.  */
  86.     reg0 = dev->read_reg (dev, AC97_RESET);
  88.     if (reg0 < 0)
  89. return -1;
  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.     }
  97.     /* ??? There may be other tests here? */
  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;
  104.     if (mixerRegs[x].is_stereo)
  105. dev->mixer_stereomask |= mixerRegs[x].oss_mask;
  107.     if (mixerRegs[x].recordNum != -1)
  108. dev->mixer_recmask |= mixerRegs[x].oss_mask;
  109. }
  110.     }
  112.     return 0;
  113. }
  115. /* Reset the mixer to the currently saved settings.  */
  116. int
  117. ac97_reset (struct ac97_hwint *dev)
  118. {
  119.     int x;
  121.     if (dev->reset_device (dev))
  122. return -1;
  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. }
  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. int
  137. ac97_get_register (struct ac97_hwint *dev, u8 reg) 
  138. {
  139.     if (reg > 127 || (reg & 1))
  140. return -EINVAL;
  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. }
  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;
  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. }
  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.
  182.    A negative error code is returned on failure, or the unsigned
  183.    scaled value on success.  */
  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;
  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;
  198. /* Inverted. */
  199. if (inv)
  200.     value = maxval - value;
  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. }
  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. }
  229. 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;
  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;
  246.     if (channel->regmask != 0) {
  247. int mv;
  249. int oldval = ac97_get_register (dev, channel->ac97_regnum);
  250. if (oldval < 0)
  251.     return oldval;
  253. for (mv = channel->regmask; ! (mv & 1); mv >>= 1)
  254.     scaled_value <<= 1;
  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. }
  265. 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;
  271.     if (channel == NULL)
  272. return -ENODEV;
  274.     if (! ac97_is_valid_channel (dev, channel))
  275. return -ENODEV;
  277.     regval = ac97_get_register (dev, channel->ac97_regnum);
  279.     if (regval < 0)
  280. return regval;
  282.     if (channel->regmask != 0) {
  283. int mv;
  285. regval &= channel->regmask;
  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. }
  295. int
  296. ac97_get_recmask (struct ac97_hwint *dev)
  297. {
  298.     int recReg = ac97_get_register (dev, AC97_RECORD_SELECT);
  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. }
  312. int
  313. ac97_set_recmask (struct ac97_hwint *dev, int oss_recmask)
  314. {
  315.     int x;
  317.     if (oss_recmask == 0)
  318. oss_recmask = SOUND_MIXER_MIC;
  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. }
  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;
  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;
  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. }
  371. int
  372. ac97_mixer_ioctl (struct ac97_hwint *dev, unsigned int cmd, caddr_t arg)
  373. {
  374.     int ret;
  376.     switch (cmd) {
  377.     case SOUND_MIXER_READ_RECSRC:
  378. ret = ac97_get_recmask (dev);
  379. break;
  381.     case SOUND_MIXER_WRITE_RECSRC:
  382. {
  383.     if (get_user (ret, (int *) arg))
  384. ret = -EFAULT;
  385.     else
  386. ret = ac97_set_recmask (dev, ret);
  387. }
  388. break;
  390.     case SOUND_MIXER_READ_CAPS:
  391. ret = SOUND_CAP_EXCL_INPUT;
  392. break;
  394.     case SOUND_MIXER_READ_DEVMASK:
  395. ret = dev->mixer_devmask;
  396. break;
  398.     case SOUND_MIXER_READ_RECMASK:
  399. ret = dev->mixer_recmask;
  400. break;
  402.     case SOUND_MIXER_READ_STEREODEVS:
  403. ret = dev->mixer_stereomask;
  404. break;
  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);
  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 *) 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.     }
  434.     if (ret < 0)
  435. return ret;
  436.     else
  437. return put_user(ret, (int *) arg);
  438. }
  440. EXPORT_SYMBOL(ac97_init);
  441. EXPORT_SYMBOL(ac97_set_values);
  442. EXPORT_SYMBOL(ac97_set_mixer);
  443. EXPORT_SYMBOL(ac97_get_register);
  444. EXPORT_SYMBOL(ac97_put_register);
  445. EXPORT_SYMBOL(ac97_get_mixer_scaled);
  446. EXPORT_SYMBOL(ac97_mixer_ioctl);
  447. EXPORT_SYMBOL(ac97_reset);
  448. MODULE_LICENSE("GPL");
  451. /*
  452.  * Local variables:
  453.  *  c-basic-offset: 4
  454.  * End:
  455.  */