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

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

Windows CE

开发平台：

C/C++

dosgus.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.
  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.
  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: dosgus.c,v 1.1 2004/02/01 02:01:17 raph Exp $
  24.   
  25.   Driver for GUS cards under DOS
  27. ==============================================================================*/
  29. /*
  31. Written by Andrew Zabolotny <bit@eltech.ru>
  33. */
  35. #include <stdio.h>
  36. #include <stdlib.h>
  37. #include <dos.h>
  38. #include <dpmi.h>
  39. #include <sys/farptr.h>
  40. #include <sys/nearptr.h>
  41. #include <go32.h>
  42. #include <string.h>
  44. #include "dosgus.h"
  46. /********************************************* Private variables/routines *****/
  48. /* The Gravis Ultrasound state/info */
  49. __gus_state gus;
  51. /* Try to avoid holes in DRAM less than this size */
  52. #define DRAM_HOLE_THRESHOLD 8192
  53. /* If hole is larger than that, create a free block describing it */
  54. #define DRAM_SPLIT_THRESHOLD 64
  55. /* The size of DMA buffer used for RAM->DRAM transfers */
  56. #define GF1_DMA_BUFFER_SIZE 8192
  58. /* Debug macro: useful to change screen locations when some event occurs */
  59. #ifdef MIKMOD_DEBUG
  60. #  define DEBUG_PRINT(x) printf x;
  61. #  define DEBUG_OFS(addr, attr)
  62.    {
  63.      unsigned short x;
  64.      _dosmemgetw (0xb8780 + addr*2, 1, &x);
  65.      if ((x >> 8) != attr) x = '0';
  66.      x = ((x + 1) & 0xff) | (attr << 8);
  67.      _dosmemputw (&x, 1, 0xb8780 + addr*2);
  68.    }
  69. #else
  70. #  define DEBUG_PRINT(x)
  71. #  define DEBUG_OFS(addr, attr)
  72. #endif
  74. static unsigned short __gus_volume_table[512] = {
  75. 0x0000, 0x7000, 0x7ff0, 0x8800, 0x8ff0, 0x9400, 0x9800, 0x9c00,
  76. 0x9ff0, 0xa200, 0xa400, 0xa600, 0xa800, 0xaa00, 0xac00, 0xae00,
  77. 0xaff0, 0xb100, 0xb200, 0xb300, 0xb400, 0xb500, 0xb600, 0xb700,
  78. 0xb800, 0xb900, 0xba00, 0xbb00, 0xbc00, 0xbd00, 0xbe00, 0xbf00,
  79. 0xbff0, 0xc080, 0xc100, 0xc180, 0xc200, 0xc280, 0xc300, 0xc380,
  80. 0xc400, 0xc480, 0xc500, 0xc580, 0xc600, 0xc680, 0xc700, 0xc780,
  81. 0xc800, 0xc880, 0xc900, 0xc980, 0xca00, 0xca80, 0xcb00, 0xcb80,
  82. 0xcc00, 0xcc80, 0xcd00, 0xcd80, 0xce00, 0xce80, 0xcf00, 0xcf80,
  83. 0xcff0, 0xd040, 0xd080, 0xd0c0, 0xd100, 0xd140, 0xd180, 0xd1c0,
  84. 0xd200, 0xd240, 0xd280, 0xd2c0, 0xd300, 0xd340, 0xd380, 0xd3c0,
  85. 0xd400, 0xd440, 0xd480, 0xd4c0, 0xd500, 0xd540, 0xd580, 0xd5c0,
  86. 0xd600, 0xd640, 0xd680, 0xd6c0, 0xd700, 0xd740, 0xd780, 0xd7c0,
  87. 0xd800, 0xd840, 0xd880, 0xd8c0, 0xd900, 0xd940, 0xd980, 0xd9c0,
  88. 0xda00, 0xda40, 0xda80, 0xdac0, 0xdb00, 0xdb40, 0xdb80, 0xdbc0,
  89. 0xdc00, 0xdc40, 0xdc80, 0xdcc0, 0xdd00, 0xdd40, 0xdd80, 0xddc0,
  90. 0xde00, 0xde40, 0xde80, 0xdec0, 0xdf00, 0xdf40, 0xdf80, 0xdfc0,
  91. 0xdff0, 0xe020, 0xe040, 0xe060, 0xe080, 0xe0a0, 0xe0c0, 0xe0e0,
  92. 0xe100, 0xe120, 0xe140, 0xe160, 0xe180, 0xe1a0, 0xe1c0, 0xe1e0,
  93. 0xe200, 0xe220, 0xe240, 0xe260, 0xe280, 0xe2a0, 0xe2c0, 0xe2e0,
  94. 0xe300, 0xe320, 0xe340, 0xe360, 0xe380, 0xe3a0, 0xe3c0, 0xe3e0,
  95. 0xe400, 0xe420, 0xe440, 0xe460, 0xe480, 0xe4a0, 0xe4c0, 0xe4e0,
  96. 0xe500, 0xe520, 0xe540, 0xe560, 0xe580, 0xe5a0, 0xe5c0, 0xe5e0,
  97. 0xe600, 0xe620, 0xe640, 0xe660, 0xe680, 0xe6a0, 0xe6c0, 0xe6e0,
  98. 0xe700, 0xe720, 0xe740, 0xe760, 0xe780, 0xe7a0, 0xe7c0, 0xe7e0,
  99. 0xe800, 0xe820, 0xe840, 0xe860, 0xe880, 0xe8a0, 0xe8c0, 0xe8e0,
  100. 0xe900, 0xe920, 0xe940, 0xe960, 0xe980, 0xe9a0, 0xe9c0, 0xe9e0,
  101. 0xea00, 0xea20, 0xea40, 0xea60, 0xea80, 0xeaa0, 0xeac0, 0xeae0,
  102. 0xeb00, 0xeb20, 0xeb40, 0xeb60, 0xeb80, 0xeba0, 0xebc0, 0xebe0,
  103. 0xec00, 0xec20, 0xec40, 0xec60, 0xec80, 0xeca0, 0xecc0, 0xece0,
  104. 0xed00, 0xed20, 0xed40, 0xed60, 0xed80, 0xeda0, 0xedc0, 0xede0,
  105. 0xee00, 0xee20, 0xee40, 0xee60, 0xee80, 0xeea0, 0xeec0, 0xeee0,
  106. 0xef00, 0xef20, 0xef40, 0xef60, 0xef80, 0xefa0, 0xefc0, 0xefe0,
  107. 0xeff0, 0xf010, 0xf020, 0xf030, 0xf040, 0xf050, 0xf060, 0xf070,
  108. 0xf080, 0xf090, 0xf0a0, 0xf0b0, 0xf0c0, 0xf0d0, 0xf0e0, 0xf0f0,
  109. 0xf100, 0xf110, 0xf120, 0xf130, 0xf140, 0xf150, 0xf160, 0xf170,
  110. 0xf180, 0xf190, 0xf1a0, 0xf1b0, 0xf1c0, 0xf1d0, 0xf1e0, 0xf1f0,
  111. 0xf200, 0xf210, 0xf220, 0xf230, 0xf240, 0xf250, 0xf260, 0xf270,
  112. 0xf280, 0xf290, 0xf2a0, 0xf2b0, 0xf2c0, 0xf2d0, 0xf2e0, 0xf2f0,
  113. 0xf300, 0xf310, 0xf320, 0xf330, 0xf340, 0xf350, 0xf360, 0xf370,
  114. 0xf380, 0xf390, 0xf3a0, 0xf3b0, 0xf3c0, 0xf3d0, 0xf3e0, 0xf3f0,
  115. 0xf400, 0xf410, 0xf420, 0xf430, 0xf440, 0xf450, 0xf460, 0xf470,
  116. 0xf480, 0xf490, 0xf4a0, 0xf4b0, 0xf4c0, 0xf4d0, 0xf4e0, 0xf4f0,
  117. 0xf500, 0xf510, 0xf520, 0xf530, 0xf540, 0xf550, 0xf560, 0xf570,
  118. 0xf580, 0xf590, 0xf5a0, 0xf5b0, 0xf5c0, 0xf5d0, 0xf5e0, 0xf5f0,
  119. 0xf600, 0xf610, 0xf620, 0xf630, 0xf640, 0xf650, 0xf660, 0xf670,
  120. 0xf680, 0xf690, 0xf6a0, 0xf6b0, 0xf6c0, 0xf6d0, 0xf6e0, 0xf6f0,
  121. 0xf700, 0xf710, 0xf720, 0xf730, 0xf740, 0xf750, 0xf760, 0xf770,
  122. 0xf780, 0xf790, 0xf7a0, 0xf7b0, 0xf7c0, 0xf7d0, 0xf7e0, 0xf7f0,
  123. 0xf800, 0xf810, 0xf820, 0xf830, 0xf840, 0xf850, 0xf860, 0xf870,
  124. 0xf880, 0xf890, 0xf8a0, 0xf8b0, 0xf8c0, 0xf8d0, 0xf8e0, 0xf8f0,
  125. 0xf900, 0xf910, 0xf920, 0xf930, 0xf940, 0xf950, 0xf960, 0xf970,
  126. 0xf980, 0xf990, 0xf9a0, 0xf9b0, 0xf9c0, 0xf9d0, 0xf9e0, 0xf9f0,
  127. 0xfa00, 0xfa10, 0xfa20, 0xfa30, 0xfa40, 0xfa50, 0xfa60, 0xfa70,
  128. 0xfa80, 0xfa90, 0xfaa0, 0xfab0, 0xfac0, 0xfad0, 0xfae0, 0xfaf0,
  129. 0xfb00, 0xfb10, 0xfb20, 0xfb30, 0xfb40, 0xfb50, 0xfb60, 0xfb70,
  130. 0xfb80, 0xfb90, 0xfba0, 0xfbb0, 0xfbc0, 0xfbd0, 0xfbe0, 0xfbf0,
  131. 0xfc00, 0xfc10, 0xfc20, 0xfc30, 0xfc40, 0xfc50, 0xfc60, 0xfc70,
  132. 0xfc80, 0xfc90, 0xfca0, 0xfcb0, 0xfcc0, 0xfcd0, 0xfce0, 0xfcf0,
  133. 0xfd00, 0xfd10, 0xfd20, 0xfd30, 0xfd40, 0xfd50, 0xfd60, 0xfd70,
  134. 0xfd80, 0xfd90, 0xfda0, 0xfdb0, 0xfdc0, 0xfdd0, 0xfde0, 0xfdf0,
  135. 0xfe00, 0xfe10, 0xfe20, 0xfe30, 0xfe40, 0xfe50, 0xfe60, 0xfe70,
  136. 0xfe80, 0xfe90, 0xfea0, 0xfeb0, 0xfec0, 0xfed0, 0xfee0, 0xfef0,
  137. 0xff00, 0xff10, 0xff20, 0xff30, 0xff40, 0xff50, 0xff60, 0xff70,
  138. 0xff80, 0xff90, 0xffa0, 0xffb0, 0xffc0, 0xffd0, 0xffe0, 0xfff0
  139. };
  141. /* Wait a bit for GUS before doing something
  142.  * Mark function as volatile: don't allow it to be inlined.
  143.  * It *should* be slow, no need to make it work faster :-)
  144.  */
  145. volatile void __gus_delay()
  146. {
  147. inportb(GF1_MIX_CTRL);
  148. inportb(GF1_MIX_CTRL);
  149. inportb(GF1_MIX_CTRL);
  150. inportb(GF1_MIX_CTRL);
  151. inportb(GF1_MIX_CTRL);
  152. inportb(GF1_MIX_CTRL);
  153. inportb(GF1_MIX_CTRL);
  154. inportb(GF1_MIX_CTRL);
  155. }
  157. static void __gus_stop_controller(unsigned char gf1reg)
  158. {
  159. register unsigned char value = __gus_inregb(gf1reg);
  160. __gus_outregb(gf1reg, (value | GF1VC_STOPPED | GF1VC_STOP) &
  161.                       ~(GF1VC_IRQ_PENDING | GF1VC_IRQ));
  162. }
  164. /* Returns 1 if volume is already at given position */
  165. static boolean __gus_volume_ramp_to(unsigned short volume,
  166.                                     unsigned char rate,
  167.                                     unsigned char vol_ctrl)
  168. {
  169. int svol = __gus_inregw(GF1R_VOLUME) & 0xfff0;
  170. int evol = volume;
  172. /* First of all, disable volume ramp */
  173. __gus_stop_controller(GF1R_VOLUME_CONTROL);
  175. /* If voice is stopped, set the volume to zero and return */
  176. if (__gus_inregb(GF1R_VOICE_CONTROL) & GF1VC_STOPPED) {
  177. __gus_outregw(GF1R_VOLUME, 0);
  178. return 1;
  179. }
  181. /* Avoid clicks when volume ramp goes too high or too low */
  182. if (svol < 0x0400)
  183. svol = 0x0400;
  184. if (svol > 0xfc00)
  185. svol = 0xfc00;
  186. if (evol < 0x0400)
  187. evol = 0x0400;
  188. if (evol > 0xfc00)
  189. evol = 0xfc00;
  191. /* Adjust start/end positions */
  192. if (svol > evol) {
  193. unsigned short tmp = evol;
  194. evol = svol;
  195. svol = tmp;
  196. vol_ctrl |= GF1VL_BACKWARD;
  197. }
  199. /* If we already are (near) the target volume, quit */
  200. if (evol - svol < 0x1000) {
  201. __gus_outregw(GF1R_VOLUME, volume);
  202. return 1;
  203. }
  205. __gus_outregb(GF1R_VOLUME_START, svol >> 8);
  206. __gus_outregb(GF1R_VOLUME_END, evol >> 8);
  207. __gus_outregb(GF1R_VOLUME_RATE, rate);
  208. __gus_outregb_slow(GF1R_VOLUME_CONTROL, vol_ctrl);
  209. return 0;
  210. }
  212. static inline void __gus_stop_voice()
  213. {
  214. __gus_stop_controller(GF1R_VOICE_CONTROL);
  215. __gus_outregb_slow(GF1R_VOICE_CONTROL, GF1VC_STOPPED | GF1VC_STOP);
  216. }
  218. /* The GUS IRQ handler */
  219. static void gf1_irq()
  220. {
  221. unsigned char irq_source; /* The contents of GF1_IRQ_STATUS register */
  222. boolean timer_cb = 0; /* Call timer callback function */
  224. DEBUG_OFS(0, 0xCE)
  225. gus.eow_ignore = 0;
  226. while ((irq_source = inportb(GF1_IRQ_STATUS))) {
  227. DEBUG_OFS(1, 0xCE)
  229.   if (irq_source & GF1M_IRQ_DMA_COMPLETE) {
  230. DEBUG_OFS(4, 0x9F)
  231.   /* reset the IRQ pending bit */
  232.   __gus_inregb(GF1R_DMA_CONTROL);
  233. gus.dma_active = 0;
  235. if (gus.dma_callback)
  236. gus.dma_callback();
  237. }
  239. if (irq_source & (GF1M_IRQ_WAVETABLE | GF1M_IRQ_ENVELOPE)) {
  240. unsigned char vcirq;
  241. unsigned int done_mask = 0;
  243. /* IRQ bits are inverse (i.e. 0 = IRQ pending) */
  244. while ((vcirq = __gus_inregb(GF1R_IRQ_SOURCE) ^
  245.                                (GF1IRQ_WAVE | GF1IRQ_VOLUME)) &
  246.                                (GF1IRQ_WAVE | GF1IRQ_VOLUME)) {
  247. unsigned long voice = (vcirq & 0x1f);
  248. unsigned char voice_ctl, volume_ctl;
  249. unsigned int voice_mask = (1 << voice);
  251. /* Don't handle more than one IRQ from same voice */
  252. if (done_mask & voice_mask)
  253. continue;
  255. done_mask |= voice_mask;
  257. /* Read voice/volume selection registers */
  258. __gus_select_voice(voice);
  259. voice_ctl = __gus_inregb(GF1R_VOICE_CONTROL);
  260. volume_ctl = __gus_inregb(GF1R_VOLUME_CONTROL);
  262. if ((vcirq & GF1IRQ_WAVE) && (gus.wt_callback)
  263. && !(gus.eow_ignore & voice_mask)) {
  264. DEBUG_OFS(5, 0xAF)
  265. gus.wt_callback(voice, voice_ctl, volume_ctl);
  266. }
  268. if ((vcirq & GF1IRQ_VOLUME) && (gus.vl_callback)) {
  269. DEBUG_OFS(6, 0xAF)
  270. gus.vl_callback(voice, voice_ctl, volume_ctl);
  271. }
  272. }
  273. }
  275. /* Reset timers that sent this IRQ */
  276. if (irq_source & (GF1M_IRQ_TIMER1 | GF1M_IRQ_TIMER2)) {
  277. unsigned char timer_ctl = gus.timer_ctl_reg;
  279. if (irq_source & GF1M_IRQ_TIMER1)
  280. timer_ctl &= ~GF1M_TIMER1;
  282. if (irq_source & GF1M_IRQ_TIMER2)
  283. timer_ctl &= ~GF1M_TIMER2;
  285. __gus_outregb_slow(GF1R_TIMER_CONTROL, timer_ctl);
  286. __gus_outregb_slow(GF1R_TIMER_CONTROL, gus.timer_ctl_reg);
  287. }
  289. if (irq_source & GF1M_IRQ_TIMER1)
  290. if (--gus.t1_countdown == 0) {
  291. gus.t1_countdown = gus.t1_multiple;
  292. gus.t1_ticks++;
  294. DEBUG_OFS(2, 0xCF)
  296. if (gus.t1_callback) {
  297. timer_cb = 1;
  298. gus.t1_callback();
  299. }
  300. }
  302. if (irq_source & GF1M_IRQ_TIMER2)
  303. if (--gus.t2_countdown == 0) {
  304. gus.t2_countdown = gus.t2_multiple;
  305. gus.t2_ticks++;
  307. DEBUG_OFS(3, 0xCF)
  309. if (gus.t2_callback)
  310. gus.t2_callback();
  311. }
  312. #if 0
  313. /* The following are not used and implemented yet */
  314. if (irq_source & (GF1M_IRQ_MIDI_TX | GF1M_IRQ_MIDI_RX)) {
  315. }
  316. #endif
  317. }
  319. irq_ack(gus.gf1_irq);
  321. if (timer_cb && gus.timer_callback)
  322. gus.timer_callback();
  323. }
  325. static void gf1_irq_end()
  326. {
  327. }
  329. static boolean __gus_detect()
  330. {
  331. /* A relatively relaxed autodetection;
  332.    We don't count on DRAM: GUS PnP could not have it
  333.    (although its anyway bad for us)
  334.  */
  335. __gus_select_voice(0);
  336. __gus_stop_voice();
  337. __gus_outregw(GF1R_FREQUENCY, 0x1234);
  338. __gus_outregw(GF1R_VOLUME, 0x5670);
  339. return ((__gus_inregw(GF1R_FREQUENCY) & 0xfffe) == 0x1234)
  340.   && ((__gus_inregw(GF1R_VOLUME) & 0xfff0) == 0x5670);
  341. }
  343. static void __gus_reset(boolean reset_io_dma)
  344. {
  345. static unsigned char irqctl[16] = { 0, 0, 1, 3, 0, 2, 0, 4, 0, 0, 0, 5, 6, 0, 0, 7 };
  346. static unsigned char dmactl[8] = { 0, 1, 0, 2, 0, 3, 4, 5 };
  347. unsigned char irqtmp, dmatmp;
  349. /* Disable interrupts while resetting to avoid spurious IRQs */
  350. int i, timer, old_ints = disable();
  352. /* Stop the timer so that GUS IRQ won't clobber registers */
  353. timer = (gus.timer_ctl_reg & GF1M_TIMER1);
  354. if (timer)
  355. gus_timer_stop();
  357. gus.dma_active = 0;
  359. __gus_outregb(GF1R_RESET, 0);
  360. for (i = 0; i < 10; i++)
  361. __gus_delay();
  362. __gus_outregb(GF1R_RESET, GF1M_MASTER_RESET);
  363. for (i = 0; i < 10; i++)
  364. __gus_delay();
  366. outportb(GF1_MIDI_CTRL, GF1M_MIDI_RESET);
  367. for (i = 0; i < 10; i++)
  368. __gus_delay();
  369. outportb(GF1_MIDI_CTRL, 0);
  371. /* Reset all IRQ sources */
  372. __gus_outregb(GF1R_DMA_CONTROL, 0);
  373. __gus_outregb(GF1R_TIMER_CONTROL, 0);
  374. __gus_outregb(GF1R_SAMPLE_CONTROL, 0);
  376. /* Reset all voices */
  377. gus_reset(gus.voices, gus.dynmask);
  379. /* Flush any pending IRQs */
  380. inportb(GF1_IRQ_STATUS);
  381. __gus_inregb(GF1R_DMA_CONTROL);
  382. __gus_inregb(GF1R_SAMPLE_CONTROL);
  383. __gus_inregb(GF1R_IRQ_SOURCE);
  385. if (reset_io_dma) {
  386. /* Now set up the GUS card to required IRQs and DMAs */
  387. if (gus.irq[0] == gus.irq[1])
  388. irqtmp = irqctl[gus.irq[0]] | GF1M_IRQ_EQUAL;
  389. else
  390. irqtmp = irqctl[gus.irq[0]] | (irqctl[gus.irq[1]] << 3);
  392. if (gus.dma[0] == gus.dma[1])
  393. dmatmp = dmactl[gus.dma[0]] | GF1M_DMA_EQUAL;
  394. else
  395. dmatmp = dmactl[gus.dma[0]] | (dmactl[gus.dma[1]] << 3);
  397. /* Reset IRQs if possible */
  398. gus.mixer =
  399.   GF1M_MIXER_NO_LINE_IN | GF1M_MIXER_NO_OUTPUT | GF1M_MIXER_GF1_IRQ;
  400. if (gus.version >= GUS_CARD_VERSION_CLASSIC1) {
  401. outportb(GF1_REG_CTRL, 0x05);
  402. outportb(GF1_MIX_CTRL, gus.mixer);
  403. outportb(GF1_IRQ_CTRL, 0x00); /* Reset IRQs */
  404. outportb(GF1_REG_CTRL, 0x00);
  405. }
  407. /* Set up DMA channels: NEVER disable MIXER_GF1_IRQ in the future */
  408. outportb(GF1_MIX_CTRL, gus.mixer);
  409. outportb(GF1_IRQ_CTRL, dmatmp);
  411. /* Set up IRQ channels */
  412. outportb(GF1_MIX_CTRL, gus.mixer | GF1M_CONTROL_SELECT);
  413. outportb(GF1_IRQ_CTRL, irqtmp);
  414. }
  416. __gus_outregb(GF1R_RESET, GF1M_MASTER_RESET | GF1M_OUTPUT_ENABLE | GF1M_MASTER_IRQ);
  417. __gus_delay();
  419. /* Flush IRQs again */
  420. inportb(GF1_IRQ_STATUS);
  421. __gus_inregb(GF1R_DMA_CONTROL);
  422. __gus_inregb(GF1R_SAMPLE_CONTROL);
  423. __gus_inregb(GF1R_IRQ_SOURCE);
  425. _irq_ack(gus.irq[0]);
  426. _irq_ack(gus.irq[1]);
  428. if (timer)
  429. gus_timer_continue();
  431. if (old_ints)
  432. enable();
  434. /* Enable output */
  435. __gus_mixer_output(1);
  436. }
  438. /* Transfer a block of data from GUS DRAM to main RAM through port I/O */
  439. static void __gus_transfer_io_in(unsigned long address, unsigned char *source,
  440.                                  unsigned long size)
  441. {
  442. while (size) {
  443. register unsigned int size64k;
  445. size64k = 0x10000 - (address & 0xffff);
  446. if (size64k > size)
  447. size64k = size;
  448. size -= size64k;
  450. __gus_outregb(GF1R_DRAM_HIGH, address >> 16);
  451. while (size64k--) {
  452. __gus_outregw(GF1R_DRAM_LOW, address++);
  453. *source++ = inportb(GF1_DRAM);
  454. }
  455. }
  456. }
  458. /* Transfer a block of data into GUS DRAM through port I/O */
  459. static void __gus_transfer_io(unsigned long address, unsigned char *source,
  460.                               unsigned long size, int flags)
  461. {
  462. while (size) {
  463. register unsigned int size64k;
  465. size64k = 0x10000 - (address & 0xffff);
  466. if (size64k > size)
  467. size64k = size;
  468. size -= size64k;
  470. __gus_outregb(GF1R_DRAM_HIGH, address >> 16);
  471. if (flags & GUS_WAVE_INVERT)
  472. if (flags & GUS_WAVE_16BIT)
  473. while (size64k-- && size64k--) {
  474. __gus_outregw(GF1R_DRAM_LOW, address++);
  475. outportb(GF1_DRAM, *source++);
  476. __gus_outregw(GF1R_DRAM_LOW, address++);
  477. outportb(GF1_DRAM, (*source++) ^ 0x80);
  478. } else
  479. while (size64k--) {
  480. __gus_outregw(GF1R_DRAM_LOW, address++);
  481. outportb(GF1_DRAM, (*source++) ^ 0x80);
  482. } else
  483. while (size64k--) {
  484. __gus_outregw(GF1R_DRAM_LOW, address++);
  485. outportb(GF1_DRAM, *source++);
  486. }
  487. }
  488. }
  490. /* Wait for DMA transfer to finish between 8-9 1/18sec timer ticks */
  491. static int __gus_wait_dma()
  492. {
  493. unsigned long timer;
  494. _farsetsel(_dos_ds);
  495. timer = _farnspeekl(0x46c);
  496. while (gus.dma_active)
  497. if (_farnspeekl(0x46c) - timer > 8) {
  498. /* Force DMA abort since something went wrong */
  499. __gus_reset(0);
  500. return -1;
  501. }
  503. return 0;
  504. }
  506. /* Transfer a block of data into GUS DRAM through DMA controller */
  507. static void __gus_transfer_dma(unsigned long address, unsigned char *source,
  508.                                unsigned long size, int flags)
  509. {
  510. unsigned char dma_control;
  511. unsigned long bytes_left;
  512. unsigned long cur_size;
  513. unsigned long dest_addr;
  515. if ((gus.dma[0] > 3) || (flags & GUS_WAVE_16BIT))
  516. size = (size + 1) & ~1;
  518. bytes_left = size;
  519. while (bytes_left) {
  520. __gus_wait_dma();
  522. cur_size = gus.dma_buff->size;
  523. if (cur_size > bytes_left)
  524. cur_size = bytes_left;
  525. bytes_left -= cur_size;
  526. dest_addr = address;
  528. if (gus.dma_buff->linear != source)
  529. memmove(gus.dma_buff->linear, source, cur_size);
  530. source += cur_size;
  531. address += cur_size;
  533. /* Disable GUS -> DMA tie */
  534. __gus_outregb(GF1R_DMA_CONTROL, 0);
  535. __gus_delay();
  537. /* Set up the DMA */
  538. dma_start(gus.dma_buff, cur_size, DMA_MODE_WRITE);
  539. gus.dma_active = 1;
  541. /* Reset the DMA IRQ pending bit if set */
  542. __gus_inregb(GF1R_DMA_CONTROL);
  544. /* The 16-bit DMA channels needs a slightly different approach */
  545. dma_control = GF1M_DMAR_ENABLE | GF1M_DMAR_IRQ_ENABLE | gus.dma_rate;
  546. if (gus.dma[0] > 3) {
  547. dest_addr = __gus_convert_addr16(dest_addr);
  548. dma_control |= GF1M_DMAR_CHAN16;
  549. }
  551. __gus_outregw(GF1R_DMA_ADDRESS, dest_addr >> 4);
  553. if (flags & GUS_WAVE_16BIT)
  554. dma_control |= GF1M_DMAR_DATA16;
  555. if (flags & GUS_WAVE_INVERT)
  556. dma_control |= GF1M_DMAR_TOGGLE_SIGN;
  558. /* Tell GUS to start transfer */
  559. __gus_outregb(GF1R_DMA_CONTROL, dma_control);
  560. }
  561. }
  563. static void __gus_detect_version()
  564. {
  565. unsigned char tmp;
  567. switch (gus.version = inportb(GF1_REVISION)) {
  568.   case 5:
  569. gus.version = GUS_CARD_VERSION_CLASSIC_ICS;
  570. gus.ics = 1;
  571. gus.ics_flipped = 1;
  572. break;
  573.   case 6:
  574.   case 7:
  575.   case 8:
  576.   case 9:
  577. gus.version = GUS_CARD_VERSION_CLASSIC_ICS;
  578. gus.ics = 1;
  579. break;
  580.   case 10:
  581. gus.version = GUS_CARD_VERSION_MAX;
  582. gus.codec = 1;
  583. break;
  584.   case 11:
  585. gus.version = GUS_CARD_VERSION_MAX1;
  586. gus.codec = 1;
  587. break;
  588.   case 0x30:
  589. gus.version = GUS_CARD_VERSION_ACE;
  590. break;
  591.   case 0x50:
  592. gus.version = GUS_CARD_VERSION_EXTREME;
  593. break;
  594.   case 0xff:
  595. /* Pre-3.7 board */
  596. outportb(GF1_REG_CTRL, 0x20);
  597. tmp = inportb(GF1_REG_CTRL);
  598. if ((tmp != 0xff) && (tmp & 0x06))
  599. gus.version = GUS_CARD_VERSION_CLASSIC1;
  600. else
  601. gus.version = GUS_CARD_VERSION_CLASSIC;
  602. break;
  603.   default:
  604. /* Hmm... unknown revision. Assume a safe Classic model */
  605. #ifdef MIKMOD_DEBUG
  606. fprintf(stderr, "libgus: Unknown board revision (%02x)n",
  607. gus.version);
  608. #endif
  609. gus.version = GUS_CARD_VERSION_CLASSIC;
  610. break;
  611. }
  612. }
  614. static void __gus_detect_transfer()
  615. {
  616. unsigned char *outbuff, *inbuff;
  617. unsigned int i, j, seed = 0x13243546;
  618. __gus_transfer_func func;
  620. #define TRANSFER_SIZE 0x4000
  622. outbuff = malloc(TRANSFER_SIZE);
  623. inbuff = malloc(TRANSFER_SIZE);
  625. /* Suppose we have an malfunctioning GUS */
  626. gus.transfer = NULL;
  628. for (i = (gus.dma_buff ? 0 : 4); i <= 4; i++) {
  629. switch (i) {
  630.   case 0:
  631. gus.dma_rate = GF1M_DMAR_RATE0;
  632. func = __gus_transfer_dma;
  633. break;
  634.   case 1:
  635. gus.dma_rate = GF1M_DMAR_RATE1;
  636. func = __gus_transfer_dma;
  637. break;
  638.   case 2:
  639. gus.dma_rate = GF1M_DMAR_RATE2;
  640. func = __gus_transfer_dma;
  641. break;
  642.   case 3:
  643. gus.dma_rate = GF1M_DMAR_RATE3;
  644. func = __gus_transfer_dma;
  645. break;
  646.   case 4:
  647. func = __gus_transfer_io;
  648. break;
  649. }
  651. /* Fill data array each time with pseudo-random values */
  652. for (j = 0; j < TRANSFER_SIZE; j++)
  653. outbuff[j] = seed, seed =
  654.   ((seed + 358979323) ^ (seed >> 16)) * 314159265;
  656. /* Transfer the random array to GUS */
  657. /* Poke a security fence around dest block */
  658. __gus_poke(0x100 - 1, 0xAA);
  659. __gus_poke(0x100 - 2, 0x55);
  660. __gus_poke(0x100 + TRANSFER_SIZE + 0, 0xAA);
  661. __gus_poke(0x100 + TRANSFER_SIZE + 1, 0x55);
  663. func(0x100, outbuff, TRANSFER_SIZE, 0);
  665. if (__gus_wait_dma() == 0) {
  666. /* Check if the security fence was not damaged */
  667. if ((__gus_peek(0x100 - 1) != 0xAA)
  668. || (__gus_peek(0x100 - 2) != 0x55)
  669. || (__gus_peek(0x100 + TRANSFER_SIZE + 0) != 0xAA)
  670. || (__gus_peek(0x100 + TRANSFER_SIZE + 1) != 0x55))
  671. continue;
  673. /* Now check if GUS DRAM really data that we expects to be transferred */
  674. __gus_transfer_io_in(0x100, inbuff, TRANSFER_SIZE);
  675. if (memcmp(outbuff, inbuff, TRANSFER_SIZE) == 0) {
  676. gus.transfer = func;
  677. break;
  678. }
  679. }
  680. }
  682. #undef TRANSFER_SIZE
  684. free(inbuff);
  685. free(outbuff);
  686. }
  688. static void __gus_detect_memory()
  689. {
  690. unsigned int size;
  691. for (size = 0; size < 1024; size += 256) {
  692. __gus_poke(size * 1024, 0xaa);
  693. if (__gus_peek(size * 1024) != 0xaa)
  694. break;
  695. __gus_poke(size * 1024, 0x55);
  696. if (__gus_peek(size * 1024) != 0x55)
  697. break;
  698. }
  699. gus.ram = size;
  700. }
  702. static void __gus_init()
  703. {
  704. char *gusenv = getenv("ULTRASND");
  706. memset((void *)&gus, 0, sizeof(gus));
  707. gus.cmd_voice = -1;
  709. if (!gusenv)
  710. return;
  712. sscanf(gusenv, "%x,%d,%d,%d,%d", &gus.port, &gus.dma[0], &gus.dma[1],
  713.    &gus.irq[0], &gus.irq[1]);
  715. /* A relaxed sanity check */
  716. if ((gus.port < 0x100) || (gus.port > 0x1000)
  717. || (gus.irq[0] < 2) || (gus.irq[0] > 15)
  718. || (gus.irq[1] < 2) || (gus.irq[1] > 15)
  719. || (gus.dma[0] < 0) || (gus.dma[0] > 7)
  720. || (gus.dma[1] < 0) || (gus.dma[1] > 7))
  721. return;
  723. gus.voices = 32;
  724. gus.timer_ctl = GF1M_MASK_TIMER1 | GF1M_MASK_TIMER2;
  726. /* Detect if the card is really there */
  727. if (__gus_detect() == 0)
  728. return;
  730. /* Detect the version of Gravis Ultrasound */
  731. __gus_detect_version();
  733. /* Reset the card */
  734. __gus_reset(1);
  736. /* Detect the amount of on-board memory */
  737. __gus_detect_memory();
  739. gus.ok = 1;
  740. }
  742. static void __gus_kick(gus_wave_t * wave, unsigned int wave_offset)
  743. {
  744. unsigned char vc;
  746. vc = GF1VC_IRQ;
  747. if (wave->format & GUS_WAVE_16BIT)
  748. vc |= GF1VC_DATA16;
  749. if (wave->format & GUS_WAVE_BACKWARD)
  750. vc |= GF1VC_BACKWARD;
  751. if (wave->format & GUS_WAVE_LOOP) {
  752. vc |= GF1VC_LOOP_ENABLE;
  753. if (wave->format & GUS_WAVE_BIDIR)
  754. vc |= GF1VC_BI_LOOP;
  755. }
  756. __gus_set_loop_start(vc, (wave->begin.memory << 4) + wave->loop_start);
  757. if (wave->format & GUS_WAVE_LOOP)
  758. __gus_set_loop_end(vc, (wave->begin.memory << 4) + wave->loop_end);
  759. else
  760. __gus_set_loop_end(vc, (wave->begin.memory + wave->size) << 4);
  761. __gus_set_current(vc, (wave->begin.memory << 4) + wave_offset + 100);
  762. __gus_outregb_slow(GF1R_VOICE_CONTROL, vc);
  763. }
  765. /* Timer 1 callback function (updates voices) */
  766. static void __gus_timer_update()
  767. {
  768. gus_wave_t *wave;
  769. unsigned long wave_offset;
  770. unsigned char *src, *top;
  771. unsigned int vmask = (1 << gus.cur_voice);
  773. if (!gus.cmd_pool_ready)
  774. return;
  776. __gus_select_voice(gus.cur_voice);
  777. wave_offset = 0;
  778. src = gus.cmd_pool;
  779. top = gus.cmd_pool + gus.cmd_pool_top;
  781. #define GET_B *src
  782. #define GET_W *((unsigned short *)src)
  783. #define GET_L *((unsigned long *)src)
  785. while (src < top) {
  786. __gus_delay();
  787. switch (GET_B++) {
  788.   case PCMD_VOICE:
  789. __gus_select_voice(gus.cur_voice = GET_B++);
  790. vmask = (1 << gus.cur_voice);
  791. break;
  792.   case PCMD_FREQ:
  793. __gus_outregw(GF1R_FREQUENCY, GET_W++);
  794. break;
  795.   case PCMD_PAN:
  796. __gus_outregb(GF1R_BALANCE, GET_B++);
  797. break;
  798.   case PCMD_VOLUME:
  799. __gus_volume_ramp_to(gus.cur_vol[gus.cur_voice] =
  800.  GET_W++, GUS_VOLCHANGE_RAMP, GF1VL_IRQ);
  801. break;
  802.   case PCMD_VOLUME_PREPARE:
  803. gus.cur_vol[gus.cur_voice] = GET_W++;
  804. break;
  805.   case PCMD_OFFSET:
  806. wave_offset = GET_L++;
  807. break;
  808.   case PCMD_START:
  809. wave = (gus_wave_t *) GET_L++;
  810. gus.cur_wave[gus.cur_voice] = wave;
  811. gus.kick_offs[gus.cur_voice] = wave_offset;
  812. if (__gus_volume_ramp_to(0, GUS_VOLCHANGE_RAMP, GF1VL_IRQ)) {
  813. __gus_kick(wave, wave_offset);
  814. __gus_volume_ramp_to(gus.cur_vol[gus.cur_voice],
  815.  GUS_VOLCHANGE_RAMP, GF1VL_IRQ);
  816. } else
  817. gus.voice_kick[gus.cur_voice] = 1;
  818. wave_offset = 0;
  819. gus.eow_ignore |= vmask;
  820. break;
  821.   case PCMD_STOP:
  822. /* If volume is close to nothing, abort immediately instead of
  823.    ramping */
  824. gus.cur_vol[gus.cur_voice] = 0;
  825. gus.cur_wave[gus.cur_voice] = NULL;
  826. if (__gus_volume_ramp_to(0, GUS_VOLCHANGE_RAMP, GF1VL_IRQ))
  827. __gus_stop_voice();
  828. break;
  829.   case PCMD_STOP_LOOP:
  830. __gus_outregb_slow(GF1R_VOICE_CONTROL,
  831.    (__gus_inregb(GF1R_VOICE_CONTROL) | GF1VC_IRQ)
  832.    & ~GF1VC_LOOP_ENABLE);
  833. __gus_outregb_slow(GF1R_VOLUME_CONTROL,
  834.    __gus_inregb(GF1R_VOLUME_CONTROL) &
  835.    ~GF1VL_ROLLOVER);
  836. break;
  837.   default:
  838. /* Alarm! Break out immediately */
  839. src = top;
  840. break;
  841. }
  842. }
  844. #undef GET_B
  845. #undef GET_W
  846. #undef GET_L
  848. gus.cmd_pool_ready = 0;
  849. gus.cmd_pool_top = 0;
  850. }
  852. static void __gus_wavetable_update(unsigned int voice, unsigned int voice_ctl,
  853.    unsigned int volume_ctl)
  854. {
  855. gus_wave_t *wave = gus.cur_wave[voice];
  857. if (!wave || !(wave->format & GUS_WAVE_LOOP)) {
  858. __gus_stop_voice();
  859. gus.cur_wave[voice] = NULL;
  860. gus.cur_vol[voice] = 0;
  861. if (__gus_volume_ramp_to(0, GUS_VOLCHANGE_RAMP, GF1VL_IRQ))
  862. __gus_stop_voice();
  863. }
  864. }
  866. static void __gus_volume_update(unsigned int voice, unsigned int voice_ctl,
  867. unsigned int volume_ctl)
  868. {
  869. __gus_volume_ramp_to(gus.cur_vol[voice], GUS_VOLCHANGE_RAMP, GF1VL_IRQ);
  870. if (!gus.cur_wave[voice])
  871. __gus_stop_voice();
  872. else if (gus.voice_kick[voice])
  873. __gus_kick(gus.cur_wave[voice], gus.kick_offs[voice]);
  874. gus.voice_kick[voice] = 0;
  875. }
  877. /***************************************************** GUS memory manager *****/
  879. /* Mark all GUS memory as available */
  880. static void __gus_mem_clear()
  881. {
  882. __gus_mcb *cur = gus.mcb;
  884. while (cur) {
  885. __gus_mcb *next = cur->next;
  886. if (cur != gus.mcb)
  887. free(cur);
  888. cur = next;
  889. }
  891. if (!gus.mcb)
  892. gus.mcb = malloc(sizeof(__gus_mcb));
  894. gus.mcb->next = gus.mcb->prev = NULL;
  895. gus.mcb->addr = 0;
  896. gus.mcb->size = gus.ram * 1024;
  897. gus.mcb->free = 1;
  898. }
  900. /* Return amount of free memory */
  901. static unsigned int __gus_mem_get_free()
  902. {
  903. __gus_mcb *cur = gus.mcb;
  904. unsigned int size = 0;
  906. if (!gus.open)
  907. return gus.ram * 1024;
  909. while (cur) {
  910. if (cur->free)
  911. size += cur->size;
  912. cur = cur->next;
  913. }
  915. return size;
  916. }
  918. /* Return largest size for a 8-bit sample */
  919. static unsigned int __gus_mem_get_free_8()
  920. {
  921. __gus_mcb *cur = gus.mcb;
  922. unsigned int size = 0;
  924. if (!gus.open)
  925. return 0;
  927. while (cur) {
  928. if (cur->free && (cur->size > size))
  929. size = cur->size;
  930. cur = cur->next;
  931. }
  933. return size;
  934. }
  936. /* Return largest size for a 16-bit sample */
  937. static unsigned int __gus_mem_get_free_16()
  938. {
  939. __gus_mcb *cur = gus.mcb;
  940. unsigned int size = 0;
  942. if (!gus.open)
  943. return 0;
  945. while (cur) {
  946. if (cur->free) {
  947. unsigned int size16 = cur->size;
  948. unsigned int tmp;
  949. /* 16-bit samples cannot cross 256K boundaries */
  950. tmp = 0x40000 - (cur->addr & 0x3ffff);
  951. if (size16 > tmp)
  952. size16 = tmp;
  953. /* 16-bit samples should be aligned on a 32-byte boundary */
  954. size16 -= (32 - cur->addr) & 0x1f;
  956. if (size16 > size)
  957. size = size16;
  959. /* Now try vice versa: skip a portion of aligned memory */
  960. size16 =
  961.   (cur->addr + cur->size) - ((cur->addr + 0x3ffff) & ~0x3ffff);
  962. if ((size16 < 0x7fffffff) && (size16 > size))
  963. size = size16;
  964. }
  965. cur = cur->next;
  966. }
  968. return size;
  969. }
  971. /* Allocate a segment of GUS DRAM for a sample with given bits per sample.
  972.  * The algorithm tries to find the smallest free block that fits requested
  973.  * size; but if found free block is larger by some (large) delta than
  974.  * requested block size, the largest possible block is preffered.
  975.  */
  976. static unsigned int __gus_mem_alloc(unsigned int size, int bits16)
  977. {
  978. __gus_mcb *cur = gus.mcb;
  979. __gus_mcb *best_max = NULL, *best_min = NULL;
  980. unsigned int best_max_delta = 0, best_min_delta = 0xffffffff;
  981. unsigned int best_max_prefix = 0, best_min_prefix = 0;
  982. unsigned int memaddr, memsize;
  984. if (!gus.open || !size || (bits16 && size > 0x40000))
  985. return -1;
  987. /* Round block size up to nearest acceptable DMA bound */
  988. if (bits16)
  989. size = (size + 0x1f) & ~0x1f;
  990. else
  991. size = (size + 0x0f) & ~0x0f;
  993. while (cur) {
  994. if (cur->free) {
  995. unsigned char fits = 0;
  997. memsize = cur->size;
  998. memaddr = cur->addr;
  1000. if (bits16) {
  1001. /* 16-bit samples cannot cross 256K boundaries */
  1002. unsigned int tmp = 256 * 1024 - (memaddr & 0x3ffff);
  1003. if (memsize > tmp)
  1004. memsize = tmp;
  1005. /* 16-bit samples should be aligned on a 32-byte boundary */
  1006. memsize -= (32 - memaddr) & 0x1f;
  1007. memaddr = (memaddr + 0x1f) & ~0x1f;
  1008. }
  1010. /* If block fits, analyze it */
  1011. if (size <= memsize)
  1012. fits = 1;
  1013. /* Look if we still can complete the request by creating a free
  1014.    block */
  1015. else if (size <= cur->size) {
  1016. /* Align start address to next 256k boundary */
  1017. unsigned int endaddr = cur->addr + cur->size;
  1018. memaddr = (cur->addr + 0x3ffff) & ~0x3ffff;
  1019. /* Can we split current block by inserting a free block at the
  1020.    beginning? */
  1021. if ((memaddr < endaddr) && (memaddr + size <= endaddr))
  1022. fits = 1;
  1023. }
  1025. if (fits) {
  1026. unsigned int size_delta = cur->size - size;
  1027. unsigned int size_prefix = memaddr - cur->addr;
  1028. if (size_delta < best_min_delta)
  1029. best_min = cur, best_min_delta =
  1030.   size_delta, best_min_prefix = size_prefix;
  1031. if (size_delta > best_max_delta)
  1032. best_max = cur, best_max_delta =
  1033.   size_delta, best_max_prefix = size_prefix;
  1034. }
  1035. }
  1037. cur = cur->next;
  1038. }
  1040. if (!best_min)
  1041. return -1;
  1043. /* If minimal block that fits is too large, use largest block that fits */
  1044. /* But if using the maximal block is going to create a small hole, forget
  1045.    it */
  1046. if ((best_max_prefix == 0)
  1047. || (best_max_prefix >= DRAM_HOLE_THRESHOLD)
  1048. || (best_min_prefix != 0))
  1049. if (
  1050. ((best_min_delta < DRAM_HOLE_THRESHOLD) &&
  1051.  (best_max_delta >= DRAM_HOLE_THRESHOLD)) ||
  1052. ((best_min_prefix > 0) && (best_min_prefix < DRAM_HOLE_THRESHOLD)
  1053.  && ((best_max_prefix == 0) ||
  1054.  (best_max_prefix > best_min_prefix))) ||
  1055. ((best_min_prefix != 0) && (best_max_prefix == 0))) {
  1056. best_min = best_max;
  1057. best_min_delta = best_max_delta;
  1058. best_min_prefix = best_max_prefix;
  1059. }
  1061. /* Compute the DRAM address to return */
  1062. memaddr = best_min->addr + best_min_prefix;
  1063. if (bits16)
  1064. memaddr = (memaddr + 0x1f) & ~0x1f;
  1065. else
  1066. memaddr = (memaddr + 0x0f) & ~0x0f;
  1068. /* If we have a considerable hole at the beginning of sample,
  1069.    create a free node describing the hole */
  1070. if (memaddr - best_min->addr >= DRAM_SPLIT_THRESHOLD) {
  1071. __gus_mcb *newmcb = malloc(sizeof(__gus_mcb));
  1072. newmcb->prev = best_min->prev;
  1073. newmcb->next = best_min;
  1074. newmcb->addr = best_min->addr;
  1075. newmcb->size = memaddr - best_min->addr;
  1076. newmcb->free = 1;
  1077. best_min->addr = memaddr;
  1078. best_min->size -= newmcb->size;
  1079. best_min->prev = newmcb;
  1080. if (newmcb->prev)
  1081. newmcb->prev->next = newmcb;
  1082. }
  1084. /* Compute the size of hole at the end of block */
  1085. memsize = (best_min->addr + best_min->size) - (memaddr + size);
  1087. /* Split the block if the block is larger than requested amount */
  1088. if (memsize > DRAM_SPLIT_THRESHOLD) {
  1089. /* The next node cannot be free since free blocks are always glued
  1090.    together */
  1091. __gus_mcb *newmcb = malloc(sizeof(__gus_mcb));
  1092. best_min->size -= memsize;
  1093. newmcb->prev = best_min;
  1094. newmcb->next = best_min->next;
  1095. newmcb->addr = best_min->addr + best_min->size;
  1096. newmcb->size = memsize;
  1097. newmcb->free = 1;
  1098. if (best_min->next)
  1099. best_min->next->prev = newmcb;
  1100. best_min->next = newmcb;
  1101. }
  1102. best_min->free = 0;
  1104. return memaddr;
  1105. }
  1107. static void __gus_mem_free(unsigned int addr)
  1108. {
  1109. __gus_mcb *cur = gus.mcb;
  1110. while (cur) {
  1111. if (!cur->free && (cur->addr <= addr) &&
  1112. (cur->addr + cur->size > addr)) {
  1113. cur->free = 1;
  1115. /* If next block is free as well, link them together */
  1116. if (cur->next && cur->next->free) {
  1117. __gus_mcb *next = cur->next;
  1118. cur->size += next->size;
  1119. cur->next = next->next;
  1120. if (next->next)
  1121. next->next->prev = cur;
  1122. free(next);
  1123. }
  1125. /* If previous block is free, link current block with it */
  1126. if (cur->prev && cur->prev->free) {
  1127. cur->prev->size += cur->size;
  1128. cur->prev->next = cur->next;
  1129. if (cur->next)
  1130. cur->next->prev = cur->prev;
  1131. free(cur);
  1132. }
  1133. return;
  1134. }
  1135. cur = cur->next;
  1136. }
  1137. }
  1139. static void __gus_mem_pack()
  1140. {
  1141. }
  1143. #ifdef MIKMOD_DEBUG
  1145. /* Debug dump of GUS DRAM heap */
  1146. void __gus_mem_dump()
  1147. {
  1148. __gus_mcb *cur = gus.mcb;
  1149. fprintf(stderr, "/-- Offset --+-- Prev --+-- Size --+-- Free --\n");
  1150. while (cur) {
  1151. fprintf(stderr, "|  %08X  | %08X |  %6d  |   %s    |n",
  1152. cur->addr, cur->prev ? cur->prev->addr : -1, cur->size,
  1153. cur->free ? "yes" : " no");
  1154. cur = cur->next;
  1155. }
  1156. fprintf(stderr, "\------------+----------+----------+----------/n");
  1157. }
  1159. #endif
  1161. /************************************************** Middle-level routines *****/
  1163. static int __gus_instrument_free(gus_instrument_t * instrument)
  1164. {
  1165. gus_instrument_t **cur_instr;
  1166. gus_layer_t *cur_layer;
  1167. gus_wave_t *cur_wave, *wave_head;
  1169. /* Remove the instrument from the list of registered instruments */
  1170. cur_instr = (gus_instrument_t **) & gus.instr;
  1171. while (*cur_instr) {
  1172. if (*cur_instr == instrument) {
  1173. *cur_instr = instrument->next;
  1174. goto instr_loaded;
  1175. }
  1176. cur_instr = &(*cur_instr)->next;
  1177. }
  1178. return -1;
  1180. instr_loaded:
  1181. wave_head = NULL;
  1182. for (cur_layer = instrument->info.layer; cur_layer;
  1183.  cur_layer = cur_layer->next)
  1184. /* Free all waves */
  1185. for (cur_wave = cur_layer->wave; cur_wave; cur_wave = cur_wave->next) {
  1186. if (!wave_head)
  1187. wave_head = cur_wave;
  1188. if (cur_wave->begin.memory != (unsigned int)-1)
  1189. __gus_mem_free(cur_wave->begin.memory);
  1190. }
  1191. if (wave_head)
  1192. free(wave_head);
  1194. free(instrument->info.layer);
  1195. if (instrument->name)
  1196. free(instrument->name);
  1197. free(instrument);
  1198. return 0;
  1199. }
  1201. static gus_instrument_t *__gus_instrument_get(int program)
  1202. {
  1203. gus_instrument_t *cur_instr = (gus_instrument_t *) gus.instr;
  1204. while (cur_instr) {
  1205. if (cur_instr->number.instrument == program)
  1206. return cur_instr;
  1207. cur_instr = cur_instr->next;
  1208. }
  1209. return NULL;
  1210. }
  1212. static gus_instrument_t *__gus_instrument_copy(gus_instrument_t * instrument)
  1213. {
  1214. gus_instrument_t **cur_instr, *instr;
  1215. gus_layer_t *cur_layer, *dest_layer;
  1216. gus_wave_t *cur_wave, *dest_wave;
  1217. unsigned int waves, layers;
  1219. if (!instrument || !instrument->info.layer || !gus.open)
  1220. return NULL;
  1222. if (__gus_instrument_get(instrument->number.instrument))
  1223. return NULL;
  1225. instr = malloc(sizeof(gus_instrument_t));
  1226. *instr = *instrument;
  1228. if (instrument->name)
  1229. instr->name = strdup(instrument->name);
  1231. /* Make a copy of all layers at once */
  1232. for (layers = 0, cur_layer = instrument->info.layer; cur_layer; layers++)
  1233. cur_layer = cur_layer->next;
  1235. if (!(dest_layer = instr->info.layer = malloc(sizeof(gus_layer_t) * layers))) {
  1236. if (instr->name)
  1237. free(instr->name);
  1238. free(instr);
  1239. return NULL;
  1240. }
  1241. for (waves = 0, cur_layer = instrument->info.layer; cur_layer;
  1242.  cur_layer = cur_layer->next) {
  1243. *dest_layer = *cur_layer;
  1244. dest_layer->wave = NULL;
  1245. /* Count the total number of waves */
  1246. for (cur_wave = cur_layer->wave; cur_wave; cur_wave = cur_wave->next)
  1247. waves++;
  1248. if (cur_layer->next)
  1249. dest_layer->next = dest_layer + 1;
  1250. else
  1251. dest_layer->next = NULL;
  1252. dest_layer++;
  1253. }
  1255. /* Allocate memory for waves */
  1256. if (!(dest_wave = malloc(sizeof(gus_wave_t) * waves))) {
  1257. free(instr->info.layer);
  1258. if (instr->name)
  1259. free(instr->name);
  1260. free(instr);
  1261. return NULL;
  1262. }
  1263. for (cur_layer = instrument->info.layer, dest_layer = instr->info.layer;
  1264.      cur_layer; cur_layer = cur_layer->next, dest_layer = dest_layer->next)
  1265. /* Copy all waves */
  1266. for (cur_wave = cur_layer->wave; cur_wave; cur_wave = cur_wave->next) {
  1267. if (!dest_layer->wave)
  1268. dest_layer->wave = dest_wave;
  1270. *dest_wave = *cur_wave;
  1271. /* Mark DRAM address as unallocated */
  1272. dest_wave->begin.memory = -1;
  1274. if (cur_wave->next)
  1275. dest_wave->next = (dest_wave + 1);
  1276. else
  1277. dest_wave->next = NULL;
  1278. dest_wave++;
  1279. }
  1281. /* Insert the instrument into list of registered instruments */
  1282. cur_instr = (gus_instrument_t **) & gus.instr;
  1283. while (*cur_instr)
  1284. cur_instr = &(*cur_instr)->next;
  1285. *cur_instr = instr;
  1287. return instr;
  1288. }
  1290. static void __gus_instruments_clear()
  1291. {
  1292. gus_instrument_t *next_instr, *cur_instr = (gus_instrument_t *) gus.instr;
  1293. while (cur_instr) {
  1294. next_instr = cur_instr->next;
  1295. __gus_instrument_free(cur_instr);
  1296. cur_instr = next_instr;
  1297. }
  1298. }
  1300. /******************************************************* libGUS interface *****/
  1302. /* return value: number of GUS cards installed in system */
  1303. int gus_cards()
  1304. {
  1305. if (!gus.ok)
  1306. __gus_init();
  1307. return gus.ok ? 1 : 0;
  1308. }
  1310. int gus_info(gus_info_t * info, int reread)
  1311. {
  1312. if (!gus.ok)
  1313. __gus_init();
  1314. if (!gus.ok)
  1315. return -1;
  1317. strcpy(info->id, "gus0");
  1318. info->flags = (gus.ram ? GUS_STRU_INFO_F_PCM : 0);
  1319. info->version = gus.version;
  1320. info->port = gus.port;
  1321. info->irq = gus.irq[0];
  1322. info->dma1 = gus.dma[0];
  1323. info->dma2 = gus.dma[1];
  1325. info->mixing_freq = gus.freq;
  1327. info->memory_size = gus.ram * 1024;
  1328. info->memory_free = __gus_mem_get_free();
  1329. info->memory_block_8 = __gus_mem_get_free_8();
  1330. info->memory_block_16 = __gus_mem_get_free_16();
  1331. return 0;
  1332. }
  1334. int gus_open(int card, size_t queue_buffer_size, int non_block)
  1335. {
  1336. __dpmi_meminfo struct_info, pool_info;
  1338. if (!gus.ok)
  1339. __gus_init();
  1341. if (!gus.ok || gus.open || card != 0)
  1342. return -1;
  1344. /* Now lock the gus structure in memory */
  1345. struct_info.address = __djgpp_base_address + (unsigned long)&gus;
  1346. struct_info.size = sizeof(gus);
  1347. if (__dpmi_lock_linear_region(&struct_info))
  1348. return -1;
  1350. /* And hook the GF1 interrupt */
  1351. __irq_stack_count = 4;
  1352. gus.gf1_irq =
  1353.   irq_hook(gus.irq[0], gf1_irq, (long)gf1_irq_end - (long)gf1_irq);
  1354. __irq_stack_count = 1;
  1355. if (!gus.gf1_irq) {
  1356. __dpmi_unlock_linear_region(&struct_info);
  1357. return -1;
  1358. }
  1360. /* Enable the interrupt */
  1361. irq_enable(gus.gf1_irq);
  1362. if (gus.irq[0] > 7)
  1363. _irq_enable(2);
  1365. /* Allocate a DMA buffer: if we fail, we just use I/O so don't fail */
  1366. if ((gus.transfer == NULL) || (gus.transfer == __gus_transfer_dma))
  1367. gus.dma_buff = dma_allocate(gus.dma[0], GF1_DMA_BUFFER_SIZE);
  1368. else
  1369. gus.dma_buff = NULL;
  1371. /* Detect the best available RAM -> DRAM transfer function */
  1372. if (!gus.transfer) {
  1373. __gus_detect_transfer();
  1374. if (gus.transfer != __gus_transfer_dma || !gus.transfer)
  1375. dma_free(gus.dma_buff), gus.dma_buff = NULL;
  1377. /* If no transfer function worked, fail */
  1378. if (!gus.transfer) {
  1379. if (gus.dma_buff)
  1380. dma_free(gus.dma_buff);
  1381. __dpmi_unlock_linear_region(&struct_info);
  1382. irq_unhook(gus.gf1_irq);
  1383. return -1;
  1384. }
  1385. }
  1387. /* Allocate and lock command pool buffer */
  1388. if (queue_buffer_size < 64)
  1389. queue_buffer_size = 64;
  1390. if (queue_buffer_size > 16384)
  1391. queue_buffer_size = 16384;
  1392. gus.cmd_pool = malloc(queue_buffer_size);
  1393. pool_info.address = __djgpp_base_address + (unsigned long)&gus.cmd_pool;
  1394. pool_info.size = sizeof(queue_buffer_size);
  1395. if (__dpmi_lock_linear_region(&pool_info)) {
  1396. if (gus.dma_buff)
  1397. dma_free(gus.dma_buff);
  1398. __dpmi_unlock_linear_region(&struct_info);
  1399. irq_unhook(gus.gf1_irq);
  1400. return -1;
  1401. }
  1403. gus.open++;
  1405. __gus_mem_clear();
  1406. gus.t1_callback = __gus_timer_update;
  1407. gus.wt_callback = __gus_wavetable_update;
  1408. gus.vl_callback = __gus_volume_update;
  1409. gus_do_tempo(60); /* Default is 60 Hz */
  1411. return 0;
  1412. }
  1414. int gus_close(int card)
  1415. {
  1416. __dpmi_meminfo struct_info;
  1418. if (!gus.open || card != 0)
  1419. return -1;
  1421. /* First reset the card: disable any operation it can currently perform */
  1422. __gus_reset(0);
  1424. gus.open--;
  1426. /* Stop the timer */
  1427. gus_timer_stop();
  1429. /* Free DMA buffer if used */
  1430. if (gus.dma_buff)
  1431. dma_free(gus.dma_buff);
  1433. /* And unhook the GF1 interrupt */
  1434. irq_unhook(gus.gf1_irq);
  1435. gus.gf1_irq = NULL;
  1437. /* Unlock the gus structure */
  1438. struct_info.address = __djgpp_base_address + (unsigned long)&gus;
  1439. struct_info.size = sizeof(gus);
  1440. __dpmi_unlock_linear_region(&struct_info);
  1442. __gus_mem_clear();
  1443. __gus_instruments_clear();
  1445. return 0;
  1446. }
  1448. int gus_select(int card)
  1449. {
  1450. if (!gus.open || (card != 0))
  1451. return -1;
  1453. return 0;
  1454. }
  1456. /* return value: same as gus_reset function
  1457.    note: this command doesn't change number of active voices and doesn't do
  1458.    hardware reset */
  1459. int gus_reset_engine_only()
  1460. {
  1461. gus.timer_base = 100;
  1462. return 0;
  1463. }
  1465. int gus_reset(int voices, unsigned int channel_voices)
  1466. {
  1467. static unsigned short freq_table[32 - 14 + 1] = {
  1468. 44100, 41160, 38587, 36317, 34300, 32494, 30870, 29400, 28063, 26843,
  1469. 25725, 24696, 23746, 22866, 22050, 21289, 20580, 19916, 19293
  1470. };
  1471. int voice;
  1472. int timer;
  1474. /* No support for dynamically allocated voices for now */
  1475. gus.dynmask = channel_voices;
  1477. if (voices < 14)
  1478. voices = 14;
  1479. if (voices > 32)
  1480. voices = 32;
  1482. /* Stop the timer so that GUS IRQ won't clobber registers */
  1483. timer = (gus.timer_ctl_reg & GF1M_TIMER1);
  1484. if (timer)
  1485. gus_timer_stop();
  1487. /* Stop all voices */
  1488. for (voice = 0; voice < 32; voice++) {
  1489. __gus_select_voice(voice);
  1490. __gus_stop_voice();
  1491. gus.cur_wave[voice] = NULL;
  1492. gus.cur_vol[voice] = 0;
  1494. __gus_delay();
  1496. /* Reset voice parameters to reasonable values */
  1497. __gus_set_current(0, 0);
  1498. __gus_set_loop_start(0, 0);
  1499. __gus_set_loop_end(0, 0);
  1500. __gus_outregw(GF1R_VOLUME, 0);
  1501. __gus_outregb(GF1R_VOLUME_RATE, 0);
  1502. __gus_outregb(GF1R_VOLUME_START, 0);
  1503. __gus_outregb(GF1R_VOLUME_END, 0);
  1504. __gus_outregb(GF1R_BALANCE, 0x7);
  1505. }
  1507. voice = (__gus_inregb(GF1R_VOICES) & 0x1f) + 1;
  1509. if (voice != voices) {
  1510. int reset = __gus_inregb(GF1R_RESET);
  1511. __gus_outregb(GF1R_RESET, reset & ~GF1M_OUTPUT_ENABLE);
  1512. __gus_delay();
  1513. __gus_outregb(GF1R_VOICES, 0xc0 | (voices - 1));
  1514. __gus_delay();
  1515. __gus_outregb(GF1R_RESET, reset);
  1516. }
  1518. /* Compute the discretization frequence */
  1519. gus.voices = voices;
  1520. if (gus.interwave)
  1521. gus.freq = 44100;
  1522. else
  1523. gus.freq = freq_table[voices - 14];
  1525. gus_reset_engine_only();
  1527. if (timer)
  1528. gus_timer_continue();
  1530. return gus.voices;
  1531. }
  1533. int gus_do_flush()
  1534. {
  1535. DEBUG_PRINT(("gus_do_flush: top = %dn", gus.cmd_pool_top))
  1536.   gus.cmd_pool_ready = 1;
  1537. return 0;
  1538. }
  1540. /* set new tempo */
  1541. void gus_do_tempo(unsigned int tempo)
  1542. {
  1543. DEBUG_PRINT(("gus_do_tempo (%d)n", tempo))
  1544.   gus_timer_tempo(tempo);
  1545. gus_timer_start();
  1546. }
  1548. /* set voice frequency in Hz */
  1549. void gus_do_voice_frequency(unsigned char voice, unsigned int freq)
  1550. {
  1551. DEBUG_PRINT(("gus_do_voice_frequency (%d, %d)n", voice, freq))
  1552.   __pool_select_voice(voice);
  1553. __pool_command_w(PCMD_FREQ,
  1554.  (((freq << 9) + (gus.freq >> 1)) / gus.freq) << 1);
  1555. }
  1557. /* set voice pan (0-16384) (full left - full right) */
  1558. void gus_do_voice_pan(unsigned char voice, unsigned short pan)
  1559. {
  1560. DEBUG_PRINT(("gus_do_voice_pan (%d, %d)n", voice, pan))
  1561.   pan >>= 10;
  1562. if (pan > 15)
  1563. pan = 15;
  1564. __pool_select_voice(voice);
  1565. __pool_command_b(PCMD_PAN, pan);
  1566. }
  1568. /* set voice volume level 0-16384 (linear) */
  1569. void gus_do_voice_volume(unsigned char voice, unsigned short vol)
  1570. {
  1571. DEBUG_PRINT(("gus_do_voice_volume (%d, %d)n", voice, vol))
  1572.   if (vol > 0x3fff)
  1573. vol = 0x3fff;
  1574. __pool_select_voice(voice);
  1575. __pool_command_w(PCMD_VOLUME, __gus_volume_table[vol >> 5]);
  1576. }
  1578. /* start voice
  1579.  *   voice    : voice #
  1580.  *   program  : program # or ~0 = current
  1581.  *   freq     : frequency in Hz
  1582.  *   volume   : volume level (0-16384) or ~0 = current
  1583.  *   pan      : pan level (0-16384) or ~0 = current
  1584.  */
  1585. void gus_do_voice_start(unsigned char voice, unsigned int program,
  1586. unsigned int freq, unsigned short volume,
  1587. unsigned short pan)
  1588. {
  1589. gus_do_voice_start_position(voice, program, freq, volume, pan, 0);
  1590. }
  1592. /* start voice
  1593.  *   voice    : voice #
  1594.  *   program  : program # or ~0 = current
  1595.  *   freq     : frequency in Hz
  1596.  *   volume   : volume level (0-16384) or ~0 = current
  1597.  *   pan      : pan level (0-16384) or ~0 = current
  1598.  *   position : offset to wave in bytes * 16 (lowest 4 bits - fraction)
  1599.  */
  1600. void gus_do_voice_start_position(unsigned char voice, unsigned int program,
  1601.  unsigned int freq, unsigned short volume,
  1602.  unsigned short pan, unsigned int position)
  1603. {
  1604. gus_instrument_t *instrument;
  1605. gus_wave_t *wave;
  1607. DEBUG_PRINT(
  1608. ("gus_do_voice_start_position (%d, %d, pos: %d)n", voice,
  1609.  program, position))
  1611.   instrument = __gus_instrument_get(program);
  1613. if (!instrument
  1614. || !instrument->info.layer
  1615. || !instrument->info.layer->wave
  1616. || instrument->flags == GUS_INSTR_F_NOT_FOUND
  1617. || instrument->flags == GUS_INSTR_F_NOT_LOADED) return;
  1619. gus_do_voice_frequency(voice, freq);
  1620. gus_do_voice_pan(voice, pan);
  1622. /* We have to set volume different way, to avoid unneeded work in handler */
  1623. if (volume > 0x3fff)
  1624. volume = 0x3fff;
  1625. __pool_command_w(PCMD_VOLUME_PREPARE, __gus_volume_table[volume >> 5]);
  1627. switch (instrument->mode) {
  1628.   case GUS_INSTR_SIMPLE:
  1629. wave = instrument->info.layer->wave;
  1630. if (position)
  1631. __pool_command_l(PCMD_OFFSET, position);
  1632. __pool_command_l(PCMD_START, (unsigned long)wave);
  1633. break;
  1634. }
  1635. }
  1637. /* stop voice
  1638.  *   mode = 0 : stop voice now
  1639.  *   mode = 1 : disable wave loop and finish it
  1640.  */
  1641. void gus_do_voice_stop(unsigned char voice, unsigned char mode)
  1642. {
  1643. __pool_select_voice(voice);
  1644. if (mode)
  1645. __pool_command(PCMD_STOP_LOOP);
  1646. else
  1647. __pool_command(PCMD_STOP);
  1648. }
  1650. /* wait x ticks - this command is block separator
  1651.    all commands between blocks are interpreted in the begining of one tick */
  1652. void gus_do_wait(unsigned int ticks)
  1653. {
  1654. DEBUG_PRINT(("gus_do_wait (%d)n", ticks))
  1656.   ticks += gus.t1_ticks;
  1657. while ((int)(ticks - gus.t1_ticks) > 0);
  1658. }
  1660. int gus_get_voice_status(int voice)
  1661. {
  1662. __gus_select_voice(voice);
  1663. return __gus_inregb(GF1R_VOICE_CONTROL) & GF1VC_STOPPED ? 0 : 1;
  1664. }
  1666. /* return value: file handle (descriptor) for /dev/gus */
  1667. int gus_get_handle()
  1668. {
  1669. /* Return stdout handle so that select() will "work" with it */
  1670. return 0;
  1671. }
  1673. /* return value: zero if instrument was successfully allocated */
  1674. int gus_memory_alloc(gus_instrument_t * instrument)
  1675. {
  1676. gus_instrument_t *instr = __gus_instrument_copy(instrument);
  1677. gus_layer_t *cur_layer;
  1678. gus_wave_t *cur_wave;
  1680. DEBUG_PRINT(("gus_memory_alloc (%d)n", instrument->number.instrument))
  1682.   if (!instr)
  1683. return -1;
  1685. for (cur_layer = instr->info.layer; cur_layer;
  1686.  cur_layer = cur_layer->next) for (cur_wave = cur_layer->wave;
  1687.    cur_wave;
  1688.    cur_wave = cur_wave->next) {
  1689. if (cur_layer->mode == GUS_INSTR_SIMPLE) {
  1690. cur_wave->begin.memory = __gus_mem_alloc(cur_wave->size,
  1691.  cur_wave->format &
  1692.  GUS_WAVE_16BIT);
  1693. if (cur_wave->begin.memory == (unsigned int)-1) {
  1694. __gus_instrument_free(instr);
  1695. return -1;
  1696. }
  1697. gus.transfer(cur_wave->begin.memory, cur_wave->begin.ptr,
  1698.  cur_wave->size, cur_wave->format);
  1699. } else if (cur_layer->mode == GUS_INSTR_PATCH)
  1700. /* not supported yet */ ;
  1701. }
  1703. return 0;
  1704. }
  1706. /* return value: zero if instrument was successfully removed */
  1707. int gus_memory_free(gus_instrument_t * instrument)
  1708. {
  1709. gus_instrument_t *cur_instr = gus.instr;
  1711. DEBUG_PRINT(("gus_memory_free (%d)n", instrument->number.instrument))
  1713.   for (; cur_instr; cur_instr = cur_instr->next)
  1714. if (cur_instr->number.instrument == instrument->number.instrument)
  1715. return __gus_instrument_free(cur_instr);
  1717. return -1;
  1718. }
  1720. /* return value: unused gus memory in bytes */
  1721. int gus_memory_free_size()
  1722. {
  1723. return __gus_mem_get_free();
  1724. }
  1726. /* return value: zero if success */
  1727. int gus_memory_pack()
  1728. {
  1729. __gus_mem_pack();
  1730. return 0;
  1731. }
  1733. /* return value: gus memory size in bytes */
  1734. int gus_memory_size()
  1735. {
  1736. return gus.ram * 1024;
  1737. }
  1739. /* return value: current largest free block for 8-bit or 16-bit wave */
  1740. int gus_memory_free_block(int w_16bit)
  1741. {
  1742. return w_16bit ? __gus_mem_get_free_16() : __gus_mem_get_free_8();
  1743. }
  1745. /* input value: see to GUS_DOWNLOAD_MODE_XXXX constants (gus.h) 
  1746.    return value: zero if samples & instruments was successfully removed from
  1747.    GF1 memory manager */
  1748. int gus_memory_reset(int mode)
  1749. {
  1750. __gus_mem_clear();
  1751. __gus_instruments_clear();
  1752. return 0;
  1753. }
  1755. /* return value: zero if command queue was successfully flushed */
  1756. int gus_queue_flush()
  1757. {
  1758. return 0;
  1759. }
  1761. /* input value: echo buffer size in items (if 0 - erase echo buffer) */
  1762. int gus_queue_read_set_size(int items)
  1763. {
  1764. return 0;
  1765. }
  1767. /* input value: write queue size in items (each item have 8 bytes) */
  1768. int gus_queue_write_set_size(int items)
  1769. {
  1770. return 0;
  1771. }
  1773. /* return value: zero if successfull */
  1774. int gus_timer_start()
  1775. {
  1776. gus.timer_ctl_reg |= GF1M_TIMER1;
  1777. __gus_outregb_slow(GF1R_TIMER_CONTROL, gus.timer_ctl_reg);
  1779. gus.timer_ctl = gus.timer_ctl & ~GF1M_MASK_TIMER1;
  1780. outportb(GF1_TIMER_CTRL, 0x04);
  1781. outportb(GF1_TIMER_DATA, gus.timer_ctl | GF1M_START_TIMER1);
  1782. return 0;
  1783. }
  1785. /* return value: zero if timer was stoped */
  1786. int gus_timer_stop()
  1787. {
  1788. gus.timer_ctl_reg &= ~GF1M_TIMER1;
  1789. __gus_outregb_slow(GF1R_TIMER_CONTROL, gus.timer_ctl_reg);
  1791. gus.timer_ctl = gus.timer_ctl | GF1M_MASK_TIMER1;
  1792. outportb(GF1_TIMER_CTRL, 0x04);
  1793. outportb(GF1_TIMER_DATA, gus.timer_ctl);
  1794. return 0;
  1795. }
  1797. /* return value: zero if setup was success */
  1798. int gus_timer_tempo(int ticks)
  1799. {
  1800. unsigned int counter;
  1802. /* Limit ticks per second to 1..1000 range */
  1803. if (ticks < 1)
  1804. ticks = 1;
  1805. if (ticks > 1000)
  1806. ticks = 1000;
  1808. /* GF1 timer1 period is 80 usecs, 12500 times per second */
  1809. counter = 1250000 / (ticks * gus.timer_base);
  1810. gus.t1_multiple = 1;
  1811. while (counter > 255) {
  1812. counter >>= 1;
  1813. gus.t1_multiple <<= 1;
  1814. }
  1815. gus.t1_countdown = gus.t1_multiple;
  1816. __gus_outregb(GF1R_TIMER1, 256 - counter);
  1817. return 0;
  1818. }
  1820. /* return value: zero if timer will be continue */
  1821. int gus_timer_continue()
  1822. {
  1823. return gus_timer_start();
  1824. }
  1826. /* return value: zero if setup was success (default timebase = 100) */
  1827. int gus_timer_base(int base)
  1828. {
  1829. gus.timer_base = base;
  1830. return 0;
  1831. }
  1833. void gus_timer_callback(void (*timer_callback) ())
  1834. {
  1835. gus.timer_callback = timer_callback;
  1836. }
  1838. void gus_convert_delta(unsigned int type, unsigned char *dest,
  1839.    unsigned char *src, size_t size)
  1840. {
  1841. if (!(type & GUS_WAVE_DELTA))
  1842. return;
  1844. /* This doesn't depend much on wave signedness, since addition/subtraction
  1845.    do not depend on operand signedness */
  1846. if (type & GUS_WAVE_16BIT) {
  1847. unsigned short delta = type & GUS_WAVE_UNSIGNED ? 0x8000 : 0;
  1848. while (size--) {
  1849. delta = *(unsigned short *)dest = *(unsigned short *)src + delta;
  1850. src += sizeof(unsigned short);
  1851. dest += sizeof(unsigned short);
  1852. }
  1853. } else {
  1854. unsigned char delta = type & GUS_WAVE_UNSIGNED ? 0x80 : 0;
  1855. while (size--) {
  1856. delta = *(unsigned char *)dest = *(unsigned char *)src + delta;
  1857. src++;
  1858. dest++;
  1859. }
  1860. }
  1861. }
  1863. int gus_dma_usage (int use)
  1864. {
  1865. if (gus.dma_buff)
  1866. return -1;
  1867. gus.transfer = __gus_transfer_io;
  1868. return 0;
  1869. }
  1871. /* ex:set ts=4: */