1 /* This file is part of the Dreamcast function library.
2 * Please see libdream.c for further details.
12 /* #define dc_snd_base ((volatile unsigned char *)0x00800000) */ /* arm side */
13 #define dc_snd_base ((volatile unsigned char *)0xa0700000) /* dc side */
15 /* Some convienence macros */
16 #define SNDREGADDR(x) (0xa0700000 + (x))
17 #define CHNREGADDR(ch,x) SNDREGADDR(0x80*(ch)+(x))
20 #define SNDREG32(x) (*(volatile unsigned long *)SNDREGADDR(x))
21 #define SNDREG8(x) (*(volatile unsigned char *)SNDREGADDR(x))
22 #define CHNREG32(ch, x) (*(volatile unsigned long *)CHNREGADDR(ch,x))
23 #define CHNREG8(ch, x) (*(volatile unsigned long *)CHNREGADDR(ch,x))
25 #define G2_LOCK(OLD) \
27 if (!irq_inside_int()) \
28 OLD = irq_disable(); \
29 /* suspend any G2 DMA here... */ \
30 while((*(volatile unsigned int *)0xa05f688c) & 0x20) \
34 #define G2_UNLOCK(OLD) \
36 /* resume any G2 DMA here... */ \
37 if (!irq_inside_int()) \
45 /* Initialize AICA channels */
47 SNDREG32(0x2800) = 0x0000;
49 for (i=0; i<64; i++) {
50 for (j=0; j<0x80; j+=4) {
51 if ((j&31)==0) g2_fifo_wait();
55 CHNREG32(i,0) = 0x8000;
56 CHNREG32(i,20) = 0x1f;
59 SNDREG32(0x2800) = 0x000f;
64 /* Translates a volume from linear form to logarithmic form (required by
68 0, 40, 50, 58, 63, 68, 73, 77, 80, 83, 86, 89, 92, 94, 97, 99, 101, 103,
69 105, 107, 109, 111, 112, 114, 116, 117, 119, 120, 122, 123, 125, 126, 127,
70 129, 130, 131, 133, 134, 135, 136, 137, 139, 140, 141, 142, 143, 144, 145,
71 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 156, 157, 158, 159,
72 160, 161, 162, 162, 163, 164, 165, 166, 166, 167, 168, 169, 170, 170, 171,
73 172, 172, 173, 174, 175, 175, 176, 177, 177, 178, 179, 180, 180, 181, 182,
74 182, 183, 183, 184, 185, 185, 186, 187, 187, 188, 188, 189, 190, 190, 191,
75 191, 192, 193, 193, 194, 194, 195, 196, 196, 197, 197, 198, 198, 199, 199,
76 200, 201, 201, 202, 202, 203, 203, 204, 204, 205, 205, 206, 206, 207, 207,
77 208, 208, 209, 209, 210, 210, 211, 211, 212, 212, 213, 213, 214, 214, 215,
78 215, 216, 216, 217, 217, 217, 218, 218, 219, 219, 220, 220, 221, 221, 222,
79 222, 222, 223, 223, 224, 224, 225, 225, 225, 226, 226, 227, 227, 228, 228,
80 228, 229, 229, 230, 230, 230, 231, 231, 232, 232, 232, 233, 233, 234, 234,
81 234, 235, 235, 236, 236, 236, 237, 237, 238, 238, 238, 239, 239, 240, 240,
82 240, 241, 241, 241, 242, 242, 243, 243, 243, 244, 244, 244, 245, 245, 245,
83 246, 246, 247, 247, 247, 248, 248, 248, 249, 249, 249, 250, 250, 250, 251,
84 251, 251, 252, 252, 252, 253, 253, 253, 254, 254, 254, 255
88 const static unsigned char logs[] = {
89 0, 15, 22, 27, 31, 35, 39, 42, 45, 47, 50, 52, 55, 57, 59, 61,
90 63, 65, 67, 69, 71, 73, 74, 76, 78, 79, 81, 82, 84, 85, 87, 88,
91 90, 91, 92, 94, 95, 96, 98, 99, 100, 102, 103, 104, 105, 106,
92 108, 109, 110, 111, 112, 113, 114, 116, 117, 118, 119, 120, 121,
93 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
94 135, 136, 137, 138, 138, 139, 140, 141, 142, 143, 144, 145, 146,
95 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 156,
96 157, 158, 159, 160, 160, 161, 162, 163, 164, 164, 165, 166, 167,
97 167, 168, 169, 170, 170, 171, 172, 173, 173, 174, 175, 176, 176,
98 177, 178, 178, 179, 180, 181, 181, 182, 183, 183, 184, 185, 185,
99 186, 187, 187, 188, 189, 189, 190, 191, 191, 192, 193, 193, 194,
100 195, 195, 196, 197, 197, 198, 199, 199, 200, 200, 201, 202, 202,
101 203, 204, 204, 205, 205, 206, 207, 207, 208, 209, 209, 210, 210,
102 211, 212, 212, 213, 213, 214, 215, 215, 216, 216, 217, 217, 218,
103 219, 219, 220, 220, 221, 221, 222, 223, 223, 224, 224, 225, 225,
104 226, 227, 227, 228, 228, 229, 229, 230, 230, 231, 232, 232, 233,
105 233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 239, 239, 240,
106 240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246,
107 247, 247, 248, 248, 249, 249, 250, 250, 251, 251, 252, 252, 253, 254, 255
110 /* For the moment this is going to have to suffice, until we really
111 figure out what these mean. */
112 #define AICA_PAN(x) ((x)==0x80?(0):((x)<0x80?(0x1f):(0x0f)))
113 #define AICA_VOL(x) (0xff - logs[128 + (((x) & 0xff) / 2)])
114 //#define AICA_VOL(x) (0xff - logs[x&255])
116 static inline unsigned AICA_FREQ(unsigned freq) {
117 unsigned long freq_lo, freq_base = 5644800;
120 /* Need to convert frequency to floating point format
121 (freq_hi is exponent, freq_lo is mantissa)
122 Formula is ferq = 44100*2^freq_hi*(1+freq_lo/1024) */
123 while (freq < freq_base && freq_hi > -8) {
127 while (freq < freq_base && freq_hi > -8) {
131 freq_lo = (freq<<10) / freq_base;
132 return (freq_hi << 11) | (freq_lo & 1023);
135 /* Sets up a sound channel completely. This is generally good if you want
136 a quick and dirty way to play notes. If you want a more comprehensive
137 set of routines (more like PC wavetable cards) see below.
139 ch is the channel to play on (0 - 63)
140 smpptr is the pointer to the sound data; if you're running off the
141 SH4, then this ought to be (ptr - 0xa0800000); otherwise it's just
142 ptr. Basically, it's an offset into sound ram.
143 mode is one of the mode constants (16 bit, 8 bit, ADPCM)
144 nsamp is the number of samples to play (not number of bytes!)
145 freq is the sampling rate of the sound
146 vol is the volume, 0 to 0xff (0xff is louder)
147 pan is a panning constant -- 0 is left, 128 is center, 255 is right.
149 This routine (and the similar ones) owe a lot to Marcus' sound example --
150 I hadn't gotten quite this far into dissecting the individual regs yet. */
151 void aica_play(int ch,int mode,unsigned long smpptr,int loopst,int loopend,int freq,int vol,int pan,int loopflag) {
157 /* Stop the channel (if it's already playing) */
159 /* doesn't seem to be needed, but it's here just in case */
161 for (i=0; i<256; i++) {
169 /* Envelope setup. The first of these is the loop point,
170 e.g., where the sample starts over when it loops. The second
171 is the loop end. This is the full length of the sample when
172 you are not looping, or the loop end point when you are (though
173 storing more than that is a waste of memory if you're not doing
174 volume enveloping). */
175 CHNREG32(ch, 8) = loopst & 0xffff;
176 CHNREG32(ch, 12) = loopend & 0xffff;
178 /* Write resulting values */
179 CHNREG32(ch, 24) = AICA_FREQ(freq);
181 /* Set volume, pan, and some other things that we don't know what
183 CHNREG32(ch, 36) = AICA_PAN(pan) | (0xf<<8);
184 /* Convert the incoming volume and pan into hardware values */
185 /* Vol starts at zero so we can ramp */
187 CHNREG32(ch, 40) = 0x24 | (vol<<8);
188 /* Convert the incoming volume and pan into hardware values */
189 /* Vol starts at zero so we can ramp */
191 /* If we supported volume envelopes (which we don't yet) then
192 this value would set that up. The top 4 bits determine the
193 envelope speed. f is the fastest, 1 is the slowest, and 0
194 seems to be an invalid value and does weird things). The
195 default (below) sets it into normal mode (play and terminate/loop).
196 CHNREG32(ch, 16) = 0xf010;
198 CHNREG32(ch, 16) = 0x1f; /* No volume envelope */
201 /* Set sample format, buffer address, and looping control. If
202 0x0200 mask is set on reg 0, the sample loops infinitely. If
203 it's not set, the sample plays once and terminates. We'll
204 also set the bits to start playback here. */
205 CHNREG32(ch, 4) = smpptr & 0xffff;
206 val = 0xc000 | 0x0000 | (mode<<7) | (smpptr >> 16);
207 if (loopflag) val|=0x200;
209 CHNREG32(ch, 0) = val;
213 /* Enable playback */
214 /* CHNREG32(ch, 0) |= 0xc000; */
218 for (i=0xff; i>=vol; i--) {
219 if ((i&7)==0) g2_fifo_wait();
220 CHNREG32(ch, 40) = 0x24 | (i<<8);;
227 /* Stop the sound on a given channel */
228 void aica_stop(int ch) {
229 g2_write_32(CHNREGADDR(ch, 0),(g2_read_32(CHNREGADDR(ch, 0)) & ~0x4000) | 0x8000);
234 /* The rest of these routines can change the channel in mid-stride so you
235 can do things like vibrato and panning effects. */
237 /* Set channel volume */
238 void aica_vol(int ch,int vol) {
239 // g2_write_8(CHNREGADDR(ch, 41),AICA_VOL(vol));
240 g2_write_32(CHNREGADDR(ch, 40),(g2_read_32(CHNREGADDR(ch, 40))&0xffff00ff)|(AICA_VOL(vol)<<8) );
244 /* Set channel pan */
245 void aica_pan(int ch,int pan) {
246 // g2_write_8(CHNREGADDR(ch, 36),AICA_PAN(pan));
247 g2_write_32(CHNREGADDR(ch, 36),(g2_read_32(CHNREGADDR(ch, 36))&0xffffff00)|(AICA_PAN(pan)) );
251 /* Set channel frequency */
252 void aica_freq(int ch,int freq) {
253 g2_write_32(CHNREGADDR(ch, 24),AICA_FREQ(freq));
257 /* Get channel position */
258 int aica_get_pos(int ch) {
260 /* Observe channel ch */
261 g2_write_32(SNDREGADDR(0x280c),(g2_read_32(SNDREGADDR(0x280c))&0xffff00ff) | (ch<<8));
263 /* Update position counters */
264 return g2_read_32(SNDREGADDR(0x2814)) & 0xffff;
266 /* Observe channel ch */
267 g2_write_8(SNDREGADDR(0x280d),ch);
268 /* Update position counters */
269 return g2_read_32(SNDREGADDR(0x2814)) & 0xffff;