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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
hwaccess.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：13k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

hwaccess.c：源码内容
  1. /*
  2.  **********************************************************************
  3.  *     hwaccess.c -- Hardware access layer
  4.  *     Copyright 1999, 2000 Creative Labs, Inc.
  5.  *
  6.  **********************************************************************
  7.  *
  8.  *     Date                 Author          Summary of changes
  9.  *     ----                 ------          ------------------
  10.  *     October 20, 1999     Bertrand Lee    base code release
  11.  *     December 9, 1999     Jon Taylor      rewrote the I/O subsystem
  12.  *
  13.  **********************************************************************
  14.  *
  15.  *     This program is free software; you can redistribute it and/or
  16.  *     modify it under the terms of the GNU General Public License as
  17.  *     published by the Free Software Foundation; either version 2 of
  18.  *     the License, or (at your option) any later version.
  19.  *
  20.  *     This program is distributed in the hope that it will be useful,
  21.  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  22.  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23.  *     GNU General Public License for more details.
  24.  *
  25.  *     You should have received a copy of the GNU General Public
  26.  *     License along with this program; if not, write to the Free
  27.  *     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
  28.  *     USA.
  29.  *
  30.  **********************************************************************
  31.  */
  33. #include <asm/io.h>
  35. #include "hwaccess.h"
  36. #include "8010.h"
  37. #include "icardmid.h"
  39. /*************************************************************************
  40. * Function : srToPitch                                                   *
  41. * Input    : sampleRate - sampling rate                                  *
  42. * Return   : pitch value                                                 *
  43. * About    : convert sampling rate to pitch                              *
  44. * Note     : for 8010, sampling rate is at 48kHz, this function should   *
  45. *            be changed.                                                 *
  46. *************************************************************************/
  47. u32 srToPitch(u32 sampleRate)
  48. {
  49. int i;
  51. /* FIXME: These tables should be defined in a headerfile */
  52. static u32 logMagTable[128] = {
  53. 0x00000, 0x02dfc, 0x05b9e, 0x088e6, 0x0b5d6, 0x0e26f, 0x10eb3, 0x13aa2,
  54. 0x1663f, 0x1918a, 0x1bc84, 0x1e72e, 0x2118b, 0x23b9a, 0x2655d, 0x28ed5,
  55. 0x2b803, 0x2e0e8, 0x30985, 0x331db, 0x359eb, 0x381b6, 0x3a93d, 0x3d081,
  56. 0x3f782, 0x41e42, 0x444c1, 0x46b01, 0x49101, 0x4b6c4, 0x4dc49, 0x50191,
  57. 0x5269e, 0x54b6f, 0x57006, 0x59463, 0x5b888, 0x5dc74, 0x60029, 0x623a7,
  58. 0x646ee, 0x66a00, 0x68cdd, 0x6af86, 0x6d1fa, 0x6f43c, 0x7164b, 0x73829,
  59. 0x759d4, 0x77b4f, 0x79c9a, 0x7bdb5, 0x7dea1, 0x7ff5e, 0x81fed, 0x8404e,
  60. 0x86082, 0x88089, 0x8a064, 0x8c014, 0x8df98, 0x8fef1, 0x91e20, 0x93d26,
  61. 0x95c01, 0x97ab4, 0x9993e, 0x9b79f, 0x9d5d9, 0x9f3ec, 0xa11d8, 0xa2f9d,
  62. 0xa4d3c, 0xa6ab5, 0xa8808, 0xaa537, 0xac241, 0xadf26, 0xafbe7, 0xb1885,
  63. 0xb3500, 0xb5157, 0xb6d8c, 0xb899f, 0xba58f, 0xbc15e, 0xbdd0c, 0xbf899,
  64. 0xc1404, 0xc2f50, 0xc4a7b, 0xc6587, 0xc8073, 0xc9b3f, 0xcb5ed, 0xcd07c,
  65. 0xceaec, 0xd053f, 0xd1f73, 0xd398a, 0xd5384, 0xd6d60, 0xd8720, 0xda0c3,
  66. 0xdba4a, 0xdd3b4, 0xded03, 0xe0636, 0xe1f4e, 0xe384a, 0xe512c, 0xe69f3,
  67. 0xe829f, 0xe9b31, 0xeb3a9, 0xecc08, 0xee44c, 0xefc78, 0xf148a, 0xf2c83,
  68. 0xf4463, 0xf5c2a, 0xf73da, 0xf8b71, 0xfa2f0, 0xfba57, 0xfd1a7, 0xfe8df
  69. };
  71. static char logSlopeTable[128] = {
  72. 0x5c, 0x5c, 0x5b, 0x5a, 0x5a, 0x59, 0x58, 0x58,
  73. 0x57, 0x56, 0x56, 0x55, 0x55, 0x54, 0x53, 0x53,
  74. 0x52, 0x52, 0x51, 0x51, 0x50, 0x50, 0x4f, 0x4f,
  75. 0x4e, 0x4d, 0x4d, 0x4d, 0x4c, 0x4c, 0x4b, 0x4b,
  76. 0x4a, 0x4a, 0x49, 0x49, 0x48, 0x48, 0x47, 0x47,
  77. 0x47, 0x46, 0x46, 0x45, 0x45, 0x45, 0x44, 0x44,
  78. 0x43, 0x43, 0x43, 0x42, 0x42, 0x42, 0x41, 0x41,
  79. 0x41, 0x40, 0x40, 0x40, 0x3f, 0x3f, 0x3f, 0x3e,
  80. 0x3e, 0x3e, 0x3d, 0x3d, 0x3d, 0x3c, 0x3c, 0x3c,
  81. 0x3b, 0x3b, 0x3b, 0x3b, 0x3a, 0x3a, 0x3a, 0x39,
  82. 0x39, 0x39, 0x39, 0x38, 0x38, 0x38, 0x38, 0x37,
  83. 0x37, 0x37, 0x37, 0x36, 0x36, 0x36, 0x36, 0x35,
  84. 0x35, 0x35, 0x35, 0x34, 0x34, 0x34, 0x34, 0x34,
  85. 0x33, 0x33, 0x33, 0x33, 0x32, 0x32, 0x32, 0x32,
  86. 0x32, 0x31, 0x31, 0x31, 0x31, 0x31, 0x30, 0x30,
  87. 0x30, 0x30, 0x30, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f
  88. };
  90. if (sampleRate == 0)
  91. return 0; /* Bail out if no leading "1" */
  93. sampleRate *= 11185; /* Scale 48000 to 0x20002380 */
  95. for (i = 31; i > 0; i--) {
  96. if (sampleRate & 0x80000000) { /* Detect leading "1" */
  97. return (u32) (((s32) (i - 15) << 20) +
  98.       logMagTable[0x7f & (sampleRate >> 24)] +
  99.       (0x7f & (sampleRate >> 17)) * logSlopeTable[0x7f & (sampleRate >> 24)]);
  100. }
  101. sampleRate = sampleRate << 1;
  102. }
  104. DPF(2, "srToPitch: BUG!n");
  105. return 0; /* Should never reach this point */
  106. }
  108. /* Returns an attenuation based upon a cumulative volume value */
  110. /* Algorithm calculates 0x200 - 0x10 log2 (input) */
  111. u8 sumVolumeToAttenuation(u32 value)
  112. {
  113. u16 count = 16;
  114. s16 ans;
  116. if (value == 0)
  117. return 0xFF;
  119. /* Find first SET bit. This is the integer part of the value */
  120. while ((value & 0x10000) == 0) {
  121. value <<= 1;
  122. count--;
  123. }
  125. /* The REST of the data is the fractional part. */
  126. ans = (s16) (0x110 - ((count << 4) + ((value & 0x0FFFFL) >> 12)));
  127. if (ans > 0xFF)
  128. ans = 0xFF;
  130. return (u8) ans;
  131. }
  133. /*******************************************
  134. * write/read PCI function 0 registers      *
  135. ********************************************/
  136. void emu10k1_writefn0(struct emu10k1_card *card, u32 reg, u32 data)
  137. {
  138. unsigned long flags;
  140. if (reg & 0xff000000) {
  141. u32 mask;
  142. u8 size, offset;
  144. size = (reg >> 24) & 0x3f;
  145. offset = (reg >> 16) & 0x1f;
  146. mask = ((1 << size) - 1) << offset;
  147. data = (data << offset) & mask;
  148. reg &= 0x7f;
  150. spin_lock_irqsave(&card->lock, flags);
  151. data |= inl(card->iobase + reg) & ~mask;
  152. outl(data, card->iobase + reg);
  153. spin_unlock_irqrestore(&card->lock, flags);
  154. } else {
  155. spin_lock_irqsave(&card->lock, flags);
  156. outl(data, card->iobase + reg);
  157. spin_unlock_irqrestore(&card->lock, flags);
  158. }
  160. return;
  161. }
  163. u32 emu10k1_readfn0(struct emu10k1_card * card, u32 reg)
  164. {
  165. u32 val;
  166. unsigned long flags;
  168. if (reg & 0xff000000) {
  169. u32 mask;
  170. u8 size, offset;
  172. size = (reg >> 24) & 0x3f;
  173. offset = (reg >> 16) & 0x1f;
  174. mask = ((1 << size) - 1) << offset;
  175. reg &= 0x7f;
  177. spin_lock_irqsave(&card->lock, flags);
  178. val = inl(card->iobase + reg);
  179. spin_unlock_irqrestore(&card->lock, flags);
  181. return (val & mask) >> offset;
  182.         } else {
  183. spin_lock_irqsave(&card->lock, flags);
  184. val = inl(card->iobase + reg);
  185. spin_unlock_irqrestore(&card->lock, flags);
  186. return val;
  187. }
  188. }
  190. /************************************************************************
  191. * write/read Emu10k1 pointer-offset register set, accessed through      *
  192. *  the PTR and DATA registers                                           *
  193. *************************************************************************/
  194. void sblive_writeptr(struct emu10k1_card *card, u32 reg, u32 channel, u32 data)
  195. {
  196. u32 regptr;
  197. unsigned long flags;
  199. regptr = ((reg << 16) & PTR_ADDRESS_MASK) | (channel & PTR_CHANNELNUM_MASK);
  201. if (reg & 0xff000000) {
  202. u32 mask;
  203. u8 size, offset;
  205. size = (reg >> 24) & 0x3f;
  206. offset = (reg >> 16) & 0x1f;
  207. mask = ((1 << size) - 1) << offset;
  208. data = (data << offset) & mask;
  210. spin_lock_irqsave(&card->lock, flags);
  211. outl(regptr, card->iobase + PTR);
  212. data |= inl(card->iobase + DATA) & ~mask;
  213. outl(data, card->iobase + DATA);
  214. spin_unlock_irqrestore(&card->lock, flags);
  215. } else {
  216. spin_lock_irqsave(&card->lock, flags);
  217. outl(regptr, card->iobase + PTR);
  218. outl(data, card->iobase + DATA);
  219. spin_unlock_irqrestore(&card->lock, flags);
  220. }
  221. }
  223. /* ... :  data, reg, ... , TAGLIST_END */
  224. void sblive_writeptr_tag(struct emu10k1_card *card, u32 channel, ...)
  225. {
  226. va_list args;
  228. unsigned long flags;
  229.         u32 reg;
  231. va_start(args, channel);
  233. spin_lock_irqsave(&card->lock, flags);
  234. while ((reg = va_arg(args, u32)) != TAGLIST_END) {
  235. u32 data = va_arg(args, u32);
  236. u32 regptr = (((reg << 16) & PTR_ADDRESS_MASK)
  237.       | (channel & PTR_CHANNELNUM_MASK));
  238. outl(regptr, card->iobase + PTR);
  239. if (reg & 0xff000000) {
  240. int size = (reg >> 24) & 0x3f;
  241.                         int offset = (reg >> 16) & 0x1f;
  242. u32 mask = ((1 << size) - 1) << offset;
  243. data = (data << offset) & mask;
  245. data |= inl(card->iobase + DATA) & ~mask;
  246. }
  247. outl(data, card->iobase + DATA);
  248. }
  249. spin_unlock_irqrestore(&card->lock, flags);
  251. va_end(args);
  253. return;
  254. }
  256. u32 sblive_readptr(struct emu10k1_card * card, u32 reg, u32 channel)
  257. {
  258. u32 regptr, val;
  259. unsigned long flags;
  261. regptr = ((reg << 16) & PTR_ADDRESS_MASK) | (channel & PTR_CHANNELNUM_MASK);
  263. if (reg & 0xff000000) {
  264. u32 mask;
  265. u8 size, offset;
  267. size = (reg >> 24) & 0x3f;
  268. offset = (reg >> 16) & 0x1f;
  269. mask = ((1 << size) - 1) << offset;
  271. spin_lock_irqsave(&card->lock, flags);
  272. outl(regptr, card->iobase + PTR);
  273. val = inl(card->iobase + DATA);
  274. spin_unlock_irqrestore(&card->lock, flags);
  276. return (val & mask) >> offset;
  277. } else {
  278. spin_lock_irqsave(&card->lock, flags);
  279. outl(regptr, card->iobase + PTR);
  280. val = inl(card->iobase + DATA);
  281. spin_unlock_irqrestore(&card->lock, flags);
  283. return val;
  284. }
  285. }
  287. void emu10k1_irq_enable(struct emu10k1_card *card, u32 irq_mask)
  288. {
  289. u32 val;
  290. unsigned long flags;
  292. DPF(2,"emu10k1_irq_enable()n");
  294. spin_lock_irqsave(&card->lock, flags);
  295.         val = inl(card->iobase + INTE) | irq_mask;
  296.         outl(val, card->iobase + INTE);
  297. spin_unlock_irqrestore(&card->lock, flags);
  298. return;
  299. }
  301. void emu10k1_irq_disable(struct emu10k1_card *card, u32 irq_mask)
  302. {
  303.         u32 val;
  304.         unsigned long flags;
  306.         DPF(2,"emu10k1_irq_disable()n");
  308.         spin_lock_irqsave(&card->lock, flags);
  309.         val = inl(card->iobase + INTE) & ~irq_mask;
  310.         outl(val, card->iobase + INTE);
  311.         spin_unlock_irqrestore(&card->lock, flags);
  312.         return;
  313. }
  315. void emu10k1_set_stop_on_loop(struct emu10k1_card *card, u32 voicenum)
  316. {
  317. /* Voice interrupt */
  318. if (voicenum >= 32)
  319. sblive_writeptr(card, SOLEH | ((0x0100 | (voicenum - 32)) << 16), 0, 1);
  320. else
  321. sblive_writeptr(card, SOLEL | ((0x0100 | voicenum) << 16), 0, 1);
  323. return;
  324. }
  326. void emu10k1_clear_stop_on_loop(struct emu10k1_card *card, u32 voicenum)
  327. {
  328. /* Voice interrupt */
  329. if (voicenum >= 32)
  330. sblive_writeptr(card, SOLEH | ((0x0100 | (voicenum - 32)) << 16), 0, 0);
  331. else
  332. sblive_writeptr(card, SOLEL | ((0x0100 | voicenum) << 16), 0, 0);
  334. return;
  335. }
  337. static void sblive_wcwait(struct emu10k1_card *card, u32 wait)
  338. {
  339. volatile unsigned uCount;
  340. u32 newtime = 0, curtime;
  342. curtime = emu10k1_readfn0(card, WC_SAMPLECOUNTER);
  343. while (wait--) {
  344. uCount = 0;
  345. while (uCount++ < TIMEOUT) {
  346. newtime = emu10k1_readfn0(card, WC_SAMPLECOUNTER);
  347. if (newtime != curtime)
  348. break;
  349. }
  351. if (uCount >= TIMEOUT)
  352. break;
  354. curtime = newtime;
  355. }
  356. }
  358. u16 emu10k1_ac97_read(struct ac97_codec *codec, u8 reg)
  359. {
  360. struct emu10k1_card *card = codec->private_data;
  361. u16 data;
  362. unsigned long flags;
  364. spin_lock_irqsave(&card->lock, flags);
  366. outb(reg, card->iobase + AC97ADDRESS);
  367. data = inw(card->iobase + AC97DATA);
  369. spin_unlock_irqrestore(&card->lock, flags);
  371. return data;
  372. }
  374. void emu10k1_ac97_write(struct ac97_codec *codec, u8 reg, u16 value)
  375. {
  376. struct emu10k1_card *card = codec->private_data;
  377. unsigned long flags;
  379. spin_lock_irqsave(&card->lock, flags);
  381. outb(reg, card->iobase + AC97ADDRESS);
  382. outw(value, card->iobase + AC97DATA);
  384. spin_unlock_irqrestore(&card->lock, flags);
  385. }
  387. /*********************************************************
  388. *            MPU access functions                        *
  389. **********************************************************/
  391. int emu10k1_mpu_write_data(struct emu10k1_card *card, u8 data)
  392. {
  393. unsigned long flags;
  394. int ret;
  396. spin_lock_irqsave(&card->lock, flags);
  398. if ((inb(card->iobase + MUSTAT) & MUSTAT_ORDYN) == 0) {
  399. outb(data, card->iobase + MUDATA);
  400. ret = 0;
  401. } else
  402. ret = -1;
  404. spin_unlock_irqrestore(&card->lock, flags);
  406. return ret;
  407. }
  409. int emu10k1_mpu_read_data(struct emu10k1_card *card, u8 * data)
  410. {
  411. unsigned long flags;
  412. int ret;
  414. spin_lock_irqsave(&card->lock, flags);
  416. if ((inb(card->iobase + MUSTAT) & MUSTAT_IRDYN) == 0) {
  417. *data = inb(card->iobase + MUDATA);
  418. ret = 0;
  419. } else
  420. ret = -1;
  422. spin_unlock_irqrestore(&card->lock, flags);
  424. return ret;
  425. }
  427. int emu10k1_mpu_reset(struct emu10k1_card *card)
  428. {
  429. u8 status;
  430. unsigned long flags;
  432. DPF(2, "emu10k1_mpu_reset()n");
  434. if (card->mpuacqcount == 0) {
  435. spin_lock_irqsave(&card->lock, flags);
  436. outb(MUCMD_RESET, card->iobase + MUCMD);
  437. spin_unlock_irqrestore(&card->lock, flags);
  439. sblive_wcwait(card, 8);
  441. spin_lock_irqsave(&card->lock, flags);
  442. outb(MUCMD_RESET, card->iobase + MUCMD);
  443. spin_unlock_irqrestore(&card->lock, flags);
  445. sblive_wcwait(card, 8);
  447. spin_lock_irqsave(&card->lock, flags);
  448. outb(MUCMD_ENTERUARTMODE, card->iobase + MUCMD);
  449. spin_unlock_irqrestore(&card->lock, flags);
  451. sblive_wcwait(card, 8);
  453. spin_lock_irqsave(&card->lock, flags);
  454. status = inb(card->iobase + MUDATA);
  455. spin_unlock_irqrestore(&card->lock, flags);
  457. if (status == 0xfe)
  458. return 0;
  459. else
  460. return -1;
  461. }
  463. return 0;
  464. }
  466. int emu10k1_mpu_acquire(struct emu10k1_card *card)
  467. {
  468. /* FIXME: This should be a macro */
  469. ++card->mpuacqcount;
  471. return 0;
  472. }
  474. int emu10k1_mpu_release(struct emu10k1_card *card)
  475. {
  476. /* FIXME: this should be a macro */
  477. --card->mpuacqcount;
  479. return 0;
  480. }