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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
dossb.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：12k
源码类别：

Windows CE

开发平台：

C/C++

dossb.c：源码内容
  1. /* MikMod sound library
  2. (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
  3. complete list.
  5. This library is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU Library General Public License as
  7. published by the Free Software Foundation; either version 2 of
  8. the License, or (at your option) any later version.
  9.  
  10. This program is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. GNU Library General Public License for more details.
  14.  
  15. You should have received a copy of the GNU Library General Public
  16. License along with this library; if not, write to the Free Software
  17. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  18. 02111-1307, USA.
  19. */
  21. /*==============================================================================
  23.   $Id: dossb.c,v 1.1 2004/02/01 02:01:17 raph Exp $
  25.   Sound Blaster I/O routines, common for SB8, SBPro and SB16
  27. ==============================================================================*/
  29. /*
  31. Written by Andrew Zabolotny <bit@eltech.ru>
  33. */
  35. #include <stdlib.h>
  36. #include <dpmi.h>
  37. #include <go32.h>
  38. #include <dos.h>
  39. #include <sys/nearptr.h>
  40. #include <sys/farptr.h>
  41. #include <string.h>
  43. #include "dossb.h"
  45. /********************************************* Private variables/routines *****/
  47. __sb_state sb;
  49. /* Wait for SoundBlaster for some time */
  50. volatile void __sb_wait()
  51. {
  52. inportb(SB_DSP_RESET);
  53. inportb(SB_DSP_RESET);
  54. inportb(SB_DSP_RESET);
  55. inportb(SB_DSP_RESET);
  56. inportb(SB_DSP_RESET);
  57. inportb(SB_DSP_RESET);
  58. }
  60. static void sb_irq()
  61. {
  62. /* Make sure its not a spurious IRQ */
  63. if (!irq_check(sb.irq_handle))
  64. return;
  66. sb.irqcount++;
  68. /* Acknowledge DMA transfer is complete */
  69. if (sb.mode & SBMODE_16BITS)
  70. __sb_dsp_ack_dma16();
  71. else
  72. __sb_dsp_ack_dma8();
  74. /* SoundBlaster 1.x cannot do autoinit ... */
  75. if (sb.dspver < SBVER_20)
  76. __sb_dspreg_outwlh(SBDSP_DMA_PCM8, (sb.dma_buff->size >> 1) - 1);
  78. /* Send EOI */
  79. irq_ack(sb.irq_handle);
  81. enable();
  82. if (sb.timer_callback)
  83. sb.timer_callback();
  84. }
  86. static void sb_irq_end()
  87. {
  88. }
  90. static boolean __sb_reset()
  91. {
  92. /* Disable the output */
  93. sb_output(FALSE);
  95. /* Clear pending ints if any */
  96. __sb_dsp_ack_dma8();
  97. __sb_dsp_ack_dma16();
  99. /* Reset the DSP */
  100. outportb(SB_DSP_RESET, SBM_DSP_RESET);
  101. __sb_wait();
  102. __sb_wait();
  103. outportb(SB_DSP_RESET, 0);
  105. /* Now wait for AA coming from datain port */
  106. if (__sb_dsp_in() != 0xaa)
  107. return FALSE;
  109. /* Finally, get the DSP version */
  110. if ((sb.dspver = __sb_dsp_version()) == 0xffff)
  111. return FALSE;
  112. /* Check again */
  113. if (sb.dspver != __sb_dsp_version())
  114. return FALSE;
  116. return TRUE;
  117. }
  119. /***************************************************** SB detection stuff *****/
  121. static int __sb_irq_irqdetect(int irqno)
  122. {
  123. __sb_dsp_ack_dma8();
  124. return 1;
  125. }
  127. static void __sb_irq_dmadetect()
  128. {
  129. /* Make sure its not a spurious IRQ */
  130. if (!irq_check(sb.irq_handle))
  131. return;
  133. sb.irqcount++;
  135. /* Acknowledge DMA transfer is complete */
  136. if (sb.mode & SBMODE_16BITS)
  137. __sb_dsp_ack_dma16();
  138. else
  139. __sb_dsp_ack_dma8();
  141. /* Send EOI */
  142. irq_ack(sb.irq_handle);
  143. }
  145. static boolean __sb_detect()
  146. {
  147. /* First find the port number */
  148. if (!sb.port) {
  149. int i;
  150. for (i = 5; i >= 0; i--) {
  151. sb.port = 0x210 + i * 0x10;
  152. if (__sb_reset())
  153. break;
  154. }
  155. if (i < 0) {
  156. sb.port = 0;
  157. return FALSE;
  158. }
  159. }
  161. /* Now detect the IRQ and DMA numbers */
  162. if (!sb.irq) {
  163. unsigned int irqmask, sbirqmask, sbirqcount;
  164. unsigned long timer;
  166. /* IRQ can be one of 2,3,5,7,10 */
  167. irq_detect_start(0x04ac, __sb_irq_irqdetect);
  169. /* Prepare timeout counter */
  170. _farsetsel(_dos_ds);
  171. timer = _farnspeekl(0x46c);
  173. sbirqmask = 0;
  174. sbirqcount = 10; /* Emit 10 SB irqs */
  176. /* Tell SoundBlaster to emit IRQ for 8-bit transfers */
  177. __sb_dsp_out(SBDSP_GEN_IRQ8);
  178. __sb_wait();
  179. for (;;) {
  180. irq_detect_get(0, &irqmask);
  181. if (irqmask) {
  182. sbirqmask |= irqmask;
  183. if (!--sbirqcount)
  184. break;
  185. __sb_dsp_out(SBDSP_GEN_IRQ8);
  186. }
  187. if (_farnspeekl(0x46c) - timer >= 9) /* Wait ~1/2 secs */
  188. break;
  189. }
  190. if (sbirqmask)
  191. for (sb.irq = 15; sb.irq > 0; sb.irq--)
  192. if (irq_detect_get(sb.irq, &irqmask) == 10)
  193. break;
  195. irq_detect_end();
  196. if (!sb.irq)
  197. return FALSE;
  198. }
  200. /* Detect the 8-bit and 16-bit DMAs */
  201. if (!sb.dma8 || ((sb.dspver >= SBVER_16) && !sb.dma16)) {
  202. static int __dma8[] = { 0, 1, 3 };
  203. static int __dma16[] = { 5, 6, 7 };
  204. int *dma;
  206. sb_output(FALSE);
  207. /* Temporary hook SB IRQ */
  208. sb.irq_handle = irq_hook(sb.irq, __sb_irq_dmadetect, 200);
  209. irq_enable(sb.irq_handle);
  210. if (sb.irq > 7)
  211. _irq_enable(2);
  213. /* Start a short DMA transfer and check if IRQ happened */
  214. for (;;) {
  215. int i;
  216. unsigned int timer, oldcount;
  218. if (!sb.dma8)
  219. dma = &sb.dma8;
  220. else if ((sb.dspver >= SBVER_16) && !sb.dma16)
  221. dma = &sb.dma16;
  222. else
  223. break;
  225. for (i = 0; i < 3; i++) {
  226. boolean success = 1;
  228. *dma = (dma == &sb.dma8) ? __dma8[i] : __dma16[i];
  229. oldcount = sb.irqcount;
  231. dma_disable(*dma);
  232. dma_set_mode(*dma, DMA_MODE_WRITE);
  233. dma_clear_ff(*dma);
  234. dma_set_count(*dma, 2);
  235. dma_enable(*dma);
  237. __sb_dspreg_out(SBDSP_SET_TIMING, 206); /* 20KHz */
  238. if (dma == &sb.dma8) {
  239. sb.mode = 0;
  240. __sb_dspreg_outwlh(SBDSP_DMA_PCM8, 1);
  241. } else {
  242. sb.mode = SBMODE_16BITS;
  243. __sb_dspreg_out(SBDSP_DMA_GENERIC16, 0);
  244. __sb_dsp_out(0);
  245. __sb_dsp_out(1);
  246. }
  248. _farsetsel(_dos_ds);
  249. timer = _farnspeekl(0x46c);
  251. while (oldcount == sb.irqcount)
  252. if (_farnspeekl(0x46c) - timer >= 2) {
  253. success = 0;
  254. break;
  255. }
  256. dma_disable(*dma);
  257. if (success)
  258. break;
  259. *dma = 0;
  260. }
  261. if (!*dma)
  262. break;
  263. }
  265. irq_unhook(sb.irq_handle);
  266. if (!sb.dma8 || ((sb.dspver >= SBVER_16) && !sb.dma16))
  267. return FALSE;
  268. }
  269. return TRUE;
  270. }
  272. /*************************************************** High-level interface *****/
  274. /* Detect whenever SoundBlaster is present and fill "sb" structure */
  275. boolean sb_detect()
  276. {
  277. char *env;
  279. /* Try to find the port and DMA from environment */
  280. env = getenv("BLASTER");
  282. while (env && *env) {
  283. /* Skip whitespace */
  284. while ((*env == ' ') || (*env == 't'))
  285. env++;
  286. if (!*env)
  287. break;
  289. switch (*env++) {
  290.   case 'A':
  291.   case 'a':
  292. if (!sb.port)
  293. sb.port = strtol(env, &env, 16);
  294. break;
  295.   case 'E':
  296.   case 'e':
  297. if (!sb.aweport)
  298. sb.aweport = strtol(env, &env, 16);
  299. break;
  300.   case 'I':
  301.   case 'i':
  302. if (!sb.irq)
  303. sb.irq = strtol(env, &env, 10);
  304. break;
  305.   case 'D':
  306.   case 'd':
  307. if (!sb.dma8)
  308. sb.dma8 = strtol(env, &env, 10);
  309. break;
  310.   case 'H':
  311.   case 'h':
  312. if (!sb.dma16)
  313. sb.dma16 = strtol(env, &env, 10);
  314. break;
  315.   default:
  316. /* Skip other values (H == MIDI, T == model, any other?) */
  317. while (*env && (*env != ' ') && (*env != 't'))
  318. env++;
  319. break;
  320. }
  321. }
  323. /* Try to detect missing sound card parameters */
  324. __sb_detect();
  326. if (!sb.port || !sb.irq || !sb.dma8)
  327. return FALSE;
  329. if (!__sb_reset())
  330. return FALSE;
  332. if ((sb.dspver >= SBVER_16) && !sb.dma16)
  333. return FALSE;
  335. if (sb.dspver >= SBVER_PRO)
  336. sb.caps |= SBMODE_STEREO;
  337. if (sb.dspver >= SBVER_16 && sb.dma16)
  338. sb.caps |= SBMODE_16BITS;
  339. if (sb.dspver < SBVER_20)
  340. sb.maxfreq_mono = 22222;
  341. else
  342. sb.maxfreq_mono = 45454;
  343. if (sb.dspver <= SBVER_16)
  344. sb.maxfreq_stereo = 22727;
  345. else
  346. sb.maxfreq_stereo = 45454;
  348. sb.ok = 1;
  349. return TRUE;
  350. }
  352. /* Reset SoundBlaster */
  353. void sb_reset()
  354. {
  355. sb_stop_dma();
  356. __sb_reset();
  357. }
  359. /* Start working with SoundBlaster */
  360. boolean sb_open()
  361. {
  362. __dpmi_meminfo struct_info;
  364. if (!sb.ok)
  365. if (!sb_detect())
  366. return FALSE;
  368. if (sb.open)
  369. return FALSE;
  371. /* Now lock the sb structure in memory */
  372. struct_info.address = __djgpp_base_address + (unsigned long)&sb;
  373. struct_info.size = sizeof(sb);
  374. if (__dpmi_lock_linear_region(&struct_info))
  375. return FALSE;
  377. /* Hook the SB IRQ */
  378. sb.irq_handle = irq_hook(sb.irq, sb_irq, (long)sb_irq_end - (long)sb_irq);
  379. if (!sb.irq_handle) {
  380. __dpmi_unlock_linear_region(&struct_info);
  381. return FALSE;
  382. }
  384. /* Enable the interrupt */
  385. irq_enable(sb.irq_handle);
  386. if (sb.irq > 7)
  387. _irq_enable(2);
  389. sb.open++;
  391. return TRUE;
  392. }
  394. /* Finish working with SoundBlaster */
  395. boolean sb_close()
  396. {
  397. __dpmi_meminfo struct_info;
  398. if (!sb.open)
  399. return FALSE;
  401. sb.open--;
  403. /* Stop/free DMA buffer */
  404. sb_stop_dma();
  406. /* Unhook IRQ */
  407. irq_unhook(sb.irq_handle);
  408. sb.irq_handle = NULL;
  410. /* Unlock the sb structure */
  411. struct_info.address = __djgpp_base_address + (unsigned long)&sb;
  412. struct_info.size = sizeof(sb);
  413. __dpmi_unlock_linear_region(&struct_info);
  415. return TRUE;
  416. }
  418. /* Enable/disable stereo DSP mode */
  419. /* Enable/disable speaker output */
  420. void sb_output(boolean enable)
  421. {
  422. __sb_dsp_out(enable ? SBDSP_SPEAKER_ENA : SBDSP_SPEAKER_DIS);
  423. }
  425. /* Start playing from DMA buffer */
  426. boolean sb_start_dma(unsigned char mode, unsigned int freq)
  427. {
  428. int dmachannel = (mode & SBMODE_16BITS) ? sb.dma16 : sb.dma8;
  429. int dmabuffsize;
  430. unsigned int tc = 0; /* timing constant (<=sbpro only) */
  432. /* Stop DMA transfer if it is enabled */
  433. sb_stop_dma();
  435. /* Sanity check */
  436. if ((mode & SBMODE_MASK & sb.caps) != (mode & SBMODE_MASK))
  437. return FALSE;
  439. /* Check this SB can perform at requested frequency */
  440. if (((mode & SBMODE_STEREO) && (freq > sb.maxfreq_stereo))
  441. || (!(mode & SBMODE_STEREO) && (freq > sb.maxfreq_mono)))
  442. return FALSE;
  444. /* Check the timing constant here to avoid failing later */
  445. if (sb.dspver < SBVER_16) {
  446. /* SBpro cannot do signed transfer */
  447. if (mode & SBMODE_SIGNED)
  448. return FALSE;
  450. /* Old SBs have a different way on setting DMA timing constant */
  451. tc = freq;
  452. if (mode & SBMODE_STEREO)
  453. tc *= 2;
  454. tc = 1000000 / tc;
  455. if (tc > 255)
  456. return FALSE;
  457. }
  459. sb.mode = mode;
  461. /* Get a DMA buffer enough for a 1/4sec interval... 4K <= dmasize <= 32K */
  462. dmabuffsize = freq;
  463. if (mode & SBMODE_STEREO)
  464. dmabuffsize *= 2;
  465. if (mode & SBMODE_16BITS)
  466. dmabuffsize *= 2;
  467. dmabuffsize >>= 2;
  468. if (dmabuffsize < 4096)
  469. dmabuffsize = 4096;
  470. if (dmabuffsize > 32768)
  471. dmabuffsize = 32768;
  472. dmabuffsize = (dmabuffsize + 255) & 0xffffff00;
  474. sb.dma_buff = dma_allocate(dmachannel, dmabuffsize);
  475. if (!sb.dma_buff)
  476. return FALSE;
  478. /* Fill DMA buffer with silence */
  479. dmabuffsize = sb.dma_buff->size;
  480. if (mode & SBMODE_SIGNED)
  481. memset(sb.dma_buff->linear, 0, dmabuffsize);
  482. else
  483. memset(sb.dma_buff->linear, 0x80, dmabuffsize);
  485. /* Prime DMA for transfer */
  486. dma_start(sb.dma_buff, dmabuffsize, DMA_MODE_WRITE | DMA_MODE_AUTOINIT);
  488. /* Tell SoundBlaster to start transfer */
  489. dmabuffsize = (dmabuffsize >> 1) - 1;
  490. if (sb.dspver >= SBVER_16) { /* SB16 */
  491. /* SoundBlaster 16 */
  492. __sb_dspreg_outwhl(SBDSP_SET_RATE, freq);
  494. /* Start DMA->DAC transfer */
  495. __sb_dspreg_out(SBM_GENDAC_AUTOINIT |
  496. ((mode & SBMODE_16BITS) ? SBDSP_DMA_GENERIC16 :
  497.  SBDSP_DMA_GENERIC8),
  498. ((mode & SBMODE_SIGNED) ? SBM_GENDAC_SIGNED : 0) |
  499. ((mode & SBMODE_STEREO) ? SBM_GENDAC_STEREO : 0));
  501. /* Write the length of transfer */
  502. __sb_dsp_out(dmabuffsize);
  503. __sb_dsp_out(dmabuffsize >> 8);
  504. } else {
  505. __sb_dspreg_out(SBDSP_SET_TIMING, 256 - tc);
  506. if (sb.dspver >= SBVER_20) { /* SB 2.0/Pro */
  507. /* Set stereo mode */
  508. __sb_stereo((mode & SBMODE_STEREO) ? TRUE : FALSE);
  509. __sb_dspreg_outwlh(SBDSP_SET_DMA_BLOCK, dmabuffsize);
  510. if (sb.dspver >= SBVER_PRO)
  511. __sb_dsp_out(SBDSP_HS_DMA_DAC8_AUTO);
  512. else
  513. __sb_dsp_out(SBDSP_DMA_PCM8_AUTO);
  514. } else { /* Original SB */
  516. /* Start DMA->DAC transfer */
  517. __sb_dspreg_outwlh(SBDSP_DMA_PCM8, dmabuffsize);
  518. }
  519. }
  521. return TRUE;
  522. }
  524. /* Stop playing from DMA buffer */
  525. void sb_stop_dma()
  526. {
  527. if (!sb.dma_buff)
  528. return;
  530. if (sb.mode & SBMODE_16BITS)
  531. __sb_dsp_out(SBDSP_DMA_HALT16);
  532. else
  533. __sb_dsp_out(SBDSP_DMA_HALT8);
  535. dma_disable(sb.dma_buff->channel);
  536. dma_free(sb.dma_buff);
  537. sb.dma_buff = NULL;
  538. }
  540. /* Query current position/total size of the DMA buffer */
  541. void sb_query_dma(unsigned int *dma_size, unsigned int *dma_pos)
  542. {
  543. unsigned int dma_left;
  544. *dma_size = sb.dma_buff->size;
  545. /* It can happen we try to read DMA count when HI/LO bytes will be
  546.    inconsistent */
  547. for (;;) {
  548. unsigned int dma_left_test;
  549. dma_clear_ff(sb.dma_buff->channel);
  550. dma_left_test = dma_get_count(sb.dma_buff->channel);
  551. dma_left = dma_get_count(sb.dma_buff->channel);
  552. if ((dma_left >= dma_left_test) && (dma_left - dma_left_test < 10))
  553. break;
  554. }
  555. *dma_pos = *dma_size - dma_left;
  556. }
  558. /* ex:set ts=4: */