ac97.c 11 KB

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