diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /sound/oss/gus_wave.c |
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'sound/oss/gus_wave.c')
-rw-r--r-- | sound/oss/gus_wave.c | 3464 |
1 files changed, 3464 insertions, 0 deletions
diff --git a/sound/oss/gus_wave.c b/sound/oss/gus_wave.c new file mode 100644 index 000000000000..942d5186580d --- /dev/null +++ b/sound/oss/gus_wave.c | |||
@@ -0,0 +1,3464 @@ | |||
1 | /* | ||
2 | * sound/gus_wave.c | ||
3 | * | ||
4 | * Driver for the Gravis UltraSound wave table synth. | ||
5 | * | ||
6 | * | ||
7 | * Copyright (C) by Hannu Savolainen 1993-1997 | ||
8 | * | ||
9 | * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL) | ||
10 | * Version 2 (June 1991). See the "COPYING" file distributed with this software | ||
11 | * for more info. | ||
12 | * | ||
13 | * | ||
14 | * Thomas Sailer : ioctl code reworked (vmalloc/vfree removed) | ||
15 | * Frank van de Pol : Fixed GUS MAX interrupt handling. Enabled simultanious | ||
16 | * usage of CS4231A codec, GUS wave and MIDI for GUS MAX. | ||
17 | * Bartlomiej Zolnierkiewicz : added some __init/__exit | ||
18 | */ | ||
19 | |||
20 | #include <linux/init.h> | ||
21 | #include <linux/config.h> | ||
22 | #include <linux/spinlock.h> | ||
23 | |||
24 | #define GUSPNP_AUTODETECT | ||
25 | |||
26 | #include "sound_config.h" | ||
27 | #include <linux/ultrasound.h> | ||
28 | |||
29 | #include "gus.h" | ||
30 | #include "gus_hw.h" | ||
31 | |||
32 | #define GUS_BANK_SIZE (((iw_mode) ? 256*1024*1024 : 256*1024)) | ||
33 | |||
34 | #define MAX_SAMPLE 150 | ||
35 | #define MAX_PATCH 256 | ||
36 | |||
37 | #define NOT_SAMPLE 0xffff | ||
38 | |||
39 | struct voice_info | ||
40 | { | ||
41 | unsigned long orig_freq; | ||
42 | unsigned long current_freq; | ||
43 | unsigned long mode; | ||
44 | int fixed_pitch; | ||
45 | int bender; | ||
46 | int bender_range; | ||
47 | int panning; | ||
48 | int midi_volume; | ||
49 | unsigned int initial_volume; | ||
50 | unsigned int current_volume; | ||
51 | int loop_irq_mode, loop_irq_parm; | ||
52 | #define LMODE_FINISH 1 | ||
53 | #define LMODE_PCM 2 | ||
54 | #define LMODE_PCM_STOP 3 | ||
55 | int volume_irq_mode, volume_irq_parm; | ||
56 | #define VMODE_HALT 1 | ||
57 | #define VMODE_ENVELOPE 2 | ||
58 | #define VMODE_START_NOTE 3 | ||
59 | |||
60 | int env_phase; | ||
61 | unsigned char env_rate[6]; | ||
62 | unsigned char env_offset[6]; | ||
63 | |||
64 | /* | ||
65 | * Volume computation parameters for gus_adagio_vol() | ||
66 | */ | ||
67 | int main_vol, expression_vol, patch_vol; | ||
68 | |||
69 | /* Variables for "Ultraclick" removal */ | ||
70 | int dev_pending, note_pending, volume_pending, | ||
71 | sample_pending; | ||
72 | char kill_pending; | ||
73 | long offset_pending; | ||
74 | |||
75 | }; | ||
76 | |||
77 | static struct voice_alloc_info *voice_alloc; | ||
78 | static struct address_info *gus_hw_config; | ||
79 | extern int gus_base; | ||
80 | extern int gus_irq, gus_dma; | ||
81 | extern int gus_pnp_flag; | ||
82 | extern int gus_no_wave_dma; | ||
83 | static int gus_dma2 = -1; | ||
84 | static int dual_dma_mode; | ||
85 | static long gus_mem_size; | ||
86 | static long free_mem_ptr; | ||
87 | static int gus_busy; | ||
88 | static int gus_no_dma; | ||
89 | static int nr_voices; | ||
90 | static int gus_devnum; | ||
91 | static int volume_base, volume_scale, volume_method; | ||
92 | static int gus_recmask = SOUND_MASK_MIC; | ||
93 | static int recording_active; | ||
94 | static int only_read_access; | ||
95 | static int only_8_bits; | ||
96 | |||
97 | static int iw_mode = 0; | ||
98 | int gus_wave_volume = 60; | ||
99 | int gus_pcm_volume = 80; | ||
100 | int have_gus_max = 0; | ||
101 | static int gus_line_vol = 100, gus_mic_vol; | ||
102 | static unsigned char mix_image = 0x00; | ||
103 | |||
104 | int gus_timer_enabled = 0; | ||
105 | |||
106 | /* | ||
107 | * Current version of this driver doesn't allow synth and PCM functions | ||
108 | * at the same time. The active_device specifies the active driver | ||
109 | */ | ||
110 | |||
111 | static int active_device; | ||
112 | |||
113 | #define GUS_DEV_WAVE 1 /* Wave table synth */ | ||
114 | #define GUS_DEV_PCM_DONE 2 /* PCM device, transfer done */ | ||
115 | #define GUS_DEV_PCM_CONTINUE 3 /* PCM device, transfer done ch. 1/2 */ | ||
116 | |||
117 | static int gus_audio_speed; | ||
118 | static int gus_audio_channels; | ||
119 | static int gus_audio_bits; | ||
120 | static int gus_audio_bsize; | ||
121 | static char bounce_buf[8 * 1024]; /* Must match value set to max_fragment */ | ||
122 | |||
123 | static DECLARE_WAIT_QUEUE_HEAD(dram_sleeper); | ||
124 | |||
125 | /* | ||
126 | * Variables and buffers for PCM output | ||
127 | */ | ||
128 | |||
129 | #define MAX_PCM_BUFFERS (128*MAX_REALTIME_FACTOR) /* Don't change */ | ||
130 | |||
131 | static int pcm_bsize, pcm_nblk, pcm_banksize; | ||
132 | static int pcm_datasize[MAX_PCM_BUFFERS]; | ||
133 | static volatile int pcm_head, pcm_tail, pcm_qlen; | ||
134 | static volatile int pcm_active; | ||
135 | static volatile int dma_active; | ||
136 | static int pcm_opened; | ||
137 | static int pcm_current_dev; | ||
138 | static int pcm_current_block; | ||
139 | static unsigned long pcm_current_buf; | ||
140 | static int pcm_current_count; | ||
141 | static int pcm_current_intrflag; | ||
142 | DEFINE_SPINLOCK(gus_lock); | ||
143 | |||
144 | extern int *gus_osp; | ||
145 | |||
146 | static struct voice_info voices[32]; | ||
147 | |||
148 | static int freq_div_table[] = | ||
149 | { | ||
150 | 44100, /* 14 */ | ||
151 | 41160, /* 15 */ | ||
152 | 38587, /* 16 */ | ||
153 | 36317, /* 17 */ | ||
154 | 34300, /* 18 */ | ||
155 | 32494, /* 19 */ | ||
156 | 30870, /* 20 */ | ||
157 | 29400, /* 21 */ | ||
158 | 28063, /* 22 */ | ||
159 | 26843, /* 23 */ | ||
160 | 25725, /* 24 */ | ||
161 | 24696, /* 25 */ | ||
162 | 23746, /* 26 */ | ||
163 | 22866, /* 27 */ | ||
164 | 22050, /* 28 */ | ||
165 | 21289, /* 29 */ | ||
166 | 20580, /* 30 */ | ||
167 | 19916, /* 31 */ | ||
168 | 19293 /* 32 */ | ||
169 | }; | ||
170 | |||
171 | static struct patch_info *samples; | ||
172 | static long sample_ptrs[MAX_SAMPLE + 1]; | ||
173 | static int sample_map[32]; | ||
174 | static int free_sample; | ||
175 | static int mixer_type; | ||
176 | |||
177 | |||
178 | static int patch_table[MAX_PATCH]; | ||
179 | static int patch_map[32]; | ||
180 | |||
181 | static struct synth_info gus_info = { | ||
182 | "Gravis UltraSound", 0, SYNTH_TYPE_SAMPLE, SAMPLE_TYPE_GUS, | ||
183 | 0, 16, 0, MAX_PATCH | ||
184 | }; | ||
185 | |||
186 | static void gus_poke(long addr, unsigned char data); | ||
187 | static void compute_and_set_volume(int voice, int volume, int ramp_time); | ||
188 | extern unsigned short gus_adagio_vol(int vel, int mainv, int xpn, int voicev); | ||
189 | extern unsigned short gus_linear_vol(int vol, int mainvol); | ||
190 | static void compute_volume(int voice, int volume); | ||
191 | static void do_volume_irq(int voice); | ||
192 | static void set_input_volumes(void); | ||
193 | static void gus_tmr_install(int io_base); | ||
194 | |||
195 | #define INSTANT_RAMP -1 /* Instant change. No ramping */ | ||
196 | #define FAST_RAMP 0 /* Fastest possible ramp */ | ||
197 | |||
198 | static void reset_sample_memory(void) | ||
199 | { | ||
200 | int i; | ||
201 | |||
202 | for (i = 0; i <= MAX_SAMPLE; i++) | ||
203 | sample_ptrs[i] = -1; | ||
204 | for (i = 0; i < 32; i++) | ||
205 | sample_map[i] = -1; | ||
206 | for (i = 0; i < 32; i++) | ||
207 | patch_map[i] = -1; | ||
208 | |||
209 | gus_poke(0, 0); /* Put a silent sample to the beginning */ | ||
210 | gus_poke(1, 0); | ||
211 | free_mem_ptr = 2; | ||
212 | |||
213 | free_sample = 0; | ||
214 | |||
215 | for (i = 0; i < MAX_PATCH; i++) | ||
216 | patch_table[i] = NOT_SAMPLE; | ||
217 | } | ||
218 | |||
219 | void gus_delay(void) | ||
220 | { | ||
221 | int i; | ||
222 | |||
223 | for (i = 0; i < 7; i++) | ||
224 | inb(u_DRAMIO); | ||
225 | } | ||
226 | |||
227 | static void gus_poke(long addr, unsigned char data) | ||
228 | { /* Writes a byte to the DRAM */ | ||
229 | outb((0x43), u_Command); | ||
230 | outb((addr & 0xff), u_DataLo); | ||
231 | outb(((addr >> 8) & 0xff), u_DataHi); | ||
232 | |||
233 | outb((0x44), u_Command); | ||
234 | outb(((addr >> 16) & 0xff), u_DataHi); | ||
235 | outb((data), u_DRAMIO); | ||
236 | } | ||
237 | |||
238 | static unsigned char gus_peek(long addr) | ||
239 | { /* Reads a byte from the DRAM */ | ||
240 | unsigned char tmp; | ||
241 | |||
242 | outb((0x43), u_Command); | ||
243 | outb((addr & 0xff), u_DataLo); | ||
244 | outb(((addr >> 8) & 0xff), u_DataHi); | ||
245 | |||
246 | outb((0x44), u_Command); | ||
247 | outb(((addr >> 16) & 0xff), u_DataHi); | ||
248 | tmp = inb(u_DRAMIO); | ||
249 | |||
250 | return tmp; | ||
251 | } | ||
252 | |||
253 | void gus_write8(int reg, unsigned int data) | ||
254 | { /* Writes to an indirect register (8 bit) */ | ||
255 | outb((reg), u_Command); | ||
256 | outb(((unsigned char) (data & 0xff)), u_DataHi); | ||
257 | } | ||
258 | |||
259 | static unsigned char gus_read8(int reg) | ||
260 | { | ||
261 | /* Reads from an indirect register (8 bit). Offset 0x80. */ | ||
262 | unsigned char val; | ||
263 | |||
264 | outb((reg | 0x80), u_Command); | ||
265 | val = inb(u_DataHi); | ||
266 | |||
267 | return val; | ||
268 | } | ||
269 | |||
270 | static unsigned char gus_look8(int reg) | ||
271 | { | ||
272 | /* Reads from an indirect register (8 bit). No additional offset. */ | ||
273 | unsigned char val; | ||
274 | |||
275 | outb((reg), u_Command); | ||
276 | val = inb(u_DataHi); | ||
277 | |||
278 | return val; | ||
279 | } | ||
280 | |||
281 | static void gus_write16(int reg, unsigned int data) | ||
282 | { | ||
283 | /* Writes to an indirect register (16 bit) */ | ||
284 | outb((reg), u_Command); | ||
285 | |||
286 | outb(((unsigned char) (data & 0xff)), u_DataLo); | ||
287 | outb(((unsigned char) ((data >> 8) & 0xff)), u_DataHi); | ||
288 | } | ||
289 | |||
290 | static unsigned short gus_read16(int reg) | ||
291 | { | ||
292 | /* Reads from an indirect register (16 bit). Offset 0x80. */ | ||
293 | unsigned char hi, lo; | ||
294 | |||
295 | outb((reg | 0x80), u_Command); | ||
296 | |||
297 | lo = inb(u_DataLo); | ||
298 | hi = inb(u_DataHi); | ||
299 | |||
300 | return ((hi << 8) & 0xff00) | lo; | ||
301 | } | ||
302 | |||
303 | static unsigned short gus_look16(int reg) | ||
304 | { | ||
305 | /* Reads from an indirect register (16 bit). No additional offset. */ | ||
306 | unsigned char hi, lo; | ||
307 | |||
308 | outb((reg), u_Command); | ||
309 | |||
310 | lo = inb(u_DataLo); | ||
311 | hi = inb(u_DataHi); | ||
312 | |||
313 | return ((hi << 8) & 0xff00) | lo; | ||
314 | } | ||
315 | |||
316 | static void gus_write_addr(int reg, unsigned long address, int frac, int is16bit) | ||
317 | { | ||
318 | /* Writes an 24 bit memory address */ | ||
319 | unsigned long hold_address; | ||
320 | |||
321 | if (is16bit) | ||
322 | { | ||
323 | if (iw_mode) | ||
324 | { | ||
325 | /* Interwave spesific address translations */ | ||
326 | address >>= 1; | ||
327 | } | ||
328 | else | ||
329 | { | ||
330 | /* | ||
331 | * Special processing required for 16 bit patches | ||
332 | */ | ||
333 | |||
334 | hold_address = address; | ||
335 | address = address >> 1; | ||
336 | address &= 0x0001ffffL; | ||
337 | address |= (hold_address & 0x000c0000L); | ||
338 | } | ||
339 | } | ||
340 | gus_write16(reg, (unsigned short) ((address >> 7) & 0xffff)); | ||
341 | gus_write16(reg + 1, (unsigned short) ((address << 9) & 0xffff) | ||
342 | + (frac << 5)); | ||
343 | /* Could writing twice fix problems with GUS_VOICE_POS()? Let's try. */ | ||
344 | gus_delay(); | ||
345 | gus_write16(reg, (unsigned short) ((address >> 7) & 0xffff)); | ||
346 | gus_write16(reg + 1, (unsigned short) ((address << 9) & 0xffff) | ||
347 | + (frac << 5)); | ||
348 | } | ||
349 | |||
350 | static void gus_select_voice(int voice) | ||
351 | { | ||
352 | if (voice < 0 || voice > 31) | ||
353 | return; | ||
354 | outb((voice), u_Voice); | ||
355 | } | ||
356 | |||
357 | static void gus_select_max_voices(int nvoices) | ||
358 | { | ||
359 | if (iw_mode) | ||
360 | nvoices = 32; | ||
361 | if (nvoices < 14) | ||
362 | nvoices = 14; | ||
363 | if (nvoices > 32) | ||
364 | nvoices = 32; | ||
365 | |||
366 | voice_alloc->max_voice = nr_voices = nvoices; | ||
367 | gus_write8(0x0e, (nvoices - 1) | 0xc0); | ||
368 | } | ||
369 | |||
370 | static void gus_voice_on(unsigned int mode) | ||
371 | { | ||
372 | gus_write8(0x00, (unsigned char) (mode & 0xfc)); | ||
373 | gus_delay(); | ||
374 | gus_write8(0x00, (unsigned char) (mode & 0xfc)); | ||
375 | } | ||
376 | |||
377 | static void gus_voice_off(void) | ||
378 | { | ||
379 | gus_write8(0x00, gus_read8(0x00) | 0x03); | ||
380 | } | ||
381 | |||
382 | static void gus_voice_mode(unsigned int m) | ||
383 | { | ||
384 | unsigned char mode = (unsigned char) (m & 0xff); | ||
385 | |||
386 | gus_write8(0x00, (gus_read8(0x00) & 0x03) | | ||
387 | (mode & 0xfc)); /* Don't touch last two bits */ | ||
388 | gus_delay(); | ||
389 | gus_write8(0x00, (gus_read8(0x00) & 0x03) | (mode & 0xfc)); | ||
390 | } | ||
391 | |||
392 | static void gus_voice_freq(unsigned long freq) | ||
393 | { | ||
394 | unsigned long divisor = freq_div_table[nr_voices - 14]; | ||
395 | unsigned short fc; | ||
396 | |||
397 | /* Interwave plays at 44100 Hz with any number of voices */ | ||
398 | if (iw_mode) | ||
399 | fc = (unsigned short) (((freq << 9) + (44100 >> 1)) / 44100); | ||
400 | else | ||
401 | fc = (unsigned short) (((freq << 9) + (divisor >> 1)) / divisor); | ||
402 | fc = fc << 1; | ||
403 | |||
404 | gus_write16(0x01, fc); | ||
405 | } | ||
406 | |||
407 | static void gus_voice_volume(unsigned int vol) | ||
408 | { | ||
409 | gus_write8(0x0d, 0x03); /* Stop ramp before setting volume */ | ||
410 | gus_write16(0x09, (unsigned short) (vol << 4)); | ||
411 | } | ||
412 | |||
413 | static void gus_voice_balance(unsigned int balance) | ||
414 | { | ||
415 | gus_write8(0x0c, (unsigned char) (balance & 0xff)); | ||
416 | } | ||
417 | |||
418 | static void gus_ramp_range(unsigned int low, unsigned int high) | ||
419 | { | ||
420 | gus_write8(0x07, (unsigned char) ((low >> 4) & 0xff)); | ||
421 | gus_write8(0x08, (unsigned char) ((high >> 4) & 0xff)); | ||
422 | } | ||
423 | |||
424 | static void gus_ramp_rate(unsigned int scale, unsigned int rate) | ||
425 | { | ||
426 | gus_write8(0x06, (unsigned char) (((scale & 0x03) << 6) | (rate & 0x3f))); | ||
427 | } | ||
428 | |||
429 | static void gus_rampon(unsigned int m) | ||
430 | { | ||
431 | unsigned char mode = (unsigned char) (m & 0xff); | ||
432 | |||
433 | gus_write8(0x0d, mode & 0xfc); | ||
434 | gus_delay(); | ||
435 | gus_write8(0x0d, mode & 0xfc); | ||
436 | } | ||
437 | |||
438 | static void gus_ramp_mode(unsigned int m) | ||
439 | { | ||
440 | unsigned char mode = (unsigned char) (m & 0xff); | ||
441 | |||
442 | gus_write8(0x0d, (gus_read8(0x0d) & 0x03) | | ||
443 | (mode & 0xfc)); /* Leave the last 2 bits alone */ | ||
444 | gus_delay(); | ||
445 | gus_write8(0x0d, (gus_read8(0x0d) & 0x03) | (mode & 0xfc)); | ||
446 | } | ||
447 | |||
448 | static void gus_rampoff(void) | ||
449 | { | ||
450 | gus_write8(0x0d, 0x03); | ||
451 | } | ||
452 | |||
453 | static void gus_set_voice_pos(int voice, long position) | ||
454 | { | ||
455 | int sample_no; | ||
456 | |||
457 | if ((sample_no = sample_map[voice]) != -1) { | ||
458 | if (position < samples[sample_no].len) { | ||
459 | if (voices[voice].volume_irq_mode == VMODE_START_NOTE) | ||
460 | voices[voice].offset_pending = position; | ||
461 | else | ||
462 | gus_write_addr(0x0a, sample_ptrs[sample_no] + position, 0, | ||
463 | samples[sample_no].mode & WAVE_16_BITS); | ||
464 | } | ||
465 | } | ||
466 | } | ||
467 | |||
468 | static void gus_voice_init(int voice) | ||
469 | { | ||
470 | unsigned long flags; | ||
471 | |||
472 | spin_lock_irqsave(&gus_lock,flags); | ||
473 | gus_select_voice(voice); | ||
474 | gus_voice_volume(0); | ||
475 | gus_voice_off(); | ||
476 | gus_write_addr(0x0a, 0, 0, 0); /* Set current position to 0 */ | ||
477 | gus_write8(0x00, 0x03); /* Voice off */ | ||
478 | gus_write8(0x0d, 0x03); /* Ramping off */ | ||
479 | voice_alloc->map[voice] = 0; | ||
480 | voice_alloc->alloc_times[voice] = 0; | ||
481 | spin_unlock_irqrestore(&gus_lock,flags); | ||
482 | |||
483 | } | ||
484 | |||
485 | static void gus_voice_init2(int voice) | ||
486 | { | ||
487 | voices[voice].panning = 0; | ||
488 | voices[voice].mode = 0; | ||
489 | voices[voice].orig_freq = 20000; | ||
490 | voices[voice].current_freq = 20000; | ||
491 | voices[voice].bender = 0; | ||
492 | voices[voice].bender_range = 200; | ||
493 | voices[voice].initial_volume = 0; | ||
494 | voices[voice].current_volume = 0; | ||
495 | voices[voice].loop_irq_mode = 0; | ||
496 | voices[voice].loop_irq_parm = 0; | ||
497 | voices[voice].volume_irq_mode = 0; | ||
498 | voices[voice].volume_irq_parm = 0; | ||
499 | voices[voice].env_phase = 0; | ||
500 | voices[voice].main_vol = 127; | ||
501 | voices[voice].patch_vol = 127; | ||
502 | voices[voice].expression_vol = 127; | ||
503 | voices[voice].sample_pending = -1; | ||
504 | voices[voice].fixed_pitch = 0; | ||
505 | } | ||
506 | |||
507 | static void step_envelope(int voice) | ||
508 | { | ||
509 | unsigned vol, prev_vol, phase; | ||
510 | unsigned char rate; | ||
511 | unsigned long flags; | ||
512 | |||
513 | if (voices[voice].mode & WAVE_SUSTAIN_ON && voices[voice].env_phase == 2) | ||
514 | { | ||
515 | spin_lock_irqsave(&gus_lock,flags); | ||
516 | gus_select_voice(voice); | ||
517 | gus_rampoff(); | ||
518 | spin_unlock_irqrestore(&gus_lock,flags); | ||
519 | return; | ||
520 | /* | ||
521 | * Sustain phase begins. Continue envelope after receiving note off. | ||
522 | */ | ||
523 | } | ||
524 | if (voices[voice].env_phase >= 5) | ||
525 | { | ||
526 | /* Envelope finished. Shoot the voice down */ | ||
527 | gus_voice_init(voice); | ||
528 | return; | ||
529 | } | ||
530 | prev_vol = voices[voice].current_volume; | ||
531 | phase = ++voices[voice].env_phase; | ||
532 | compute_volume(voice, voices[voice].midi_volume); | ||
533 | vol = voices[voice].initial_volume * voices[voice].env_offset[phase] / 255; | ||
534 | rate = voices[voice].env_rate[phase]; | ||
535 | |||
536 | spin_lock_irqsave(&gus_lock,flags); | ||
537 | gus_select_voice(voice); | ||
538 | |||
539 | gus_voice_volume(prev_vol); | ||
540 | |||
541 | |||
542 | gus_write8(0x06, rate); /* Ramping rate */ | ||
543 | |||
544 | voices[voice].volume_irq_mode = VMODE_ENVELOPE; | ||
545 | |||
546 | if (((vol - prev_vol) / 64) == 0) /* No significant volume change */ | ||
547 | { | ||
548 | spin_unlock_irqrestore(&gus_lock,flags); | ||
549 | step_envelope(voice); /* Continue the envelope on the next step */ | ||
550 | return; | ||
551 | } | ||
552 | if (vol > prev_vol) | ||
553 | { | ||
554 | if (vol >= (4096 - 64)) | ||
555 | vol = 4096 - 65; | ||
556 | gus_ramp_range(0, vol); | ||
557 | gus_rampon(0x20); /* Increasing volume, with IRQ */ | ||
558 | } | ||
559 | else | ||
560 | { | ||
561 | if (vol <= 64) | ||
562 | vol = 65; | ||
563 | gus_ramp_range(vol, 4030); | ||
564 | gus_rampon(0x60); /* Decreasing volume, with IRQ */ | ||
565 | } | ||
566 | voices[voice].current_volume = vol; | ||
567 | spin_unlock_irqrestore(&gus_lock,flags); | ||
568 | } | ||
569 | |||
570 | static void init_envelope(int voice) | ||
571 | { | ||
572 | voices[voice].env_phase = -1; | ||
573 | voices[voice].current_volume = 64; | ||
574 | |||
575 | step_envelope(voice); | ||
576 | } | ||
577 | |||
578 | static void start_release(int voice) | ||
579 | { | ||
580 | if (gus_read8(0x00) & 0x03) | ||
581 | return; /* Voice already stopped */ | ||
582 | |||
583 | voices[voice].env_phase = 2; /* Will be incremented by step_envelope */ | ||
584 | |||
585 | voices[voice].current_volume = voices[voice].initial_volume = | ||
586 | gus_read16(0x09) >> 4; /* Get current volume */ | ||
587 | |||
588 | voices[voice].mode &= ~WAVE_SUSTAIN_ON; | ||
589 | gus_rampoff(); | ||
590 | step_envelope(voice); | ||
591 | } | ||
592 | |||
593 | static void gus_voice_fade(int voice) | ||
594 | { | ||
595 | int instr_no = sample_map[voice], is16bits; | ||
596 | unsigned long flags; | ||
597 | |||
598 | spin_lock_irqsave(&gus_lock,flags); | ||
599 | gus_select_voice(voice); | ||
600 | |||
601 | if (instr_no < 0 || instr_no > MAX_SAMPLE) | ||
602 | { | ||
603 | gus_write8(0x00, 0x03); /* Hard stop */ | ||
604 | voice_alloc->map[voice] = 0; | ||
605 | spin_unlock_irqrestore(&gus_lock,flags); | ||
606 | return; | ||
607 | } | ||
608 | is16bits = (samples[instr_no].mode & WAVE_16_BITS) ? 1 : 0; /* 8 or 16 bits */ | ||
609 | |||
610 | if (voices[voice].mode & WAVE_ENVELOPES) | ||
611 | { | ||
612 | start_release(voice); | ||
613 | spin_unlock_irqrestore(&gus_lock,flags); | ||
614 | return; | ||
615 | } | ||
616 | /* | ||
617 | * Ramp the volume down but not too quickly. | ||
618 | */ | ||
619 | if ((int) (gus_read16(0x09) >> 4) < 100) /* Get current volume */ | ||
620 | { | ||
621 | gus_voice_off(); | ||
622 | gus_rampoff(); | ||
623 | gus_voice_init(voice); | ||
624 | spin_unlock_irqrestore(&gus_lock,flags); | ||
625 | return; | ||
626 | } | ||
627 | gus_ramp_range(65, 4030); | ||
628 | gus_ramp_rate(2, 4); | ||
629 | gus_rampon(0x40 | 0x20); /* Down, once, with IRQ */ | ||
630 | voices[voice].volume_irq_mode = VMODE_HALT; | ||
631 | spin_unlock_irqrestore(&gus_lock,flags); | ||
632 | } | ||
633 | |||
634 | static void gus_reset(void) | ||
635 | { | ||
636 | int i; | ||
637 | |||
638 | gus_select_max_voices(24); | ||
639 | volume_base = 3071; | ||
640 | volume_scale = 4; | ||
641 | volume_method = VOL_METHOD_ADAGIO; | ||
642 | |||
643 | for (i = 0; i < 32; i++) | ||
644 | { | ||
645 | gus_voice_init(i); /* Turn voice off */ | ||
646 | gus_voice_init2(i); | ||
647 | } | ||
648 | } | ||
649 | |||
650 | static void gus_initialize(void) | ||
651 | { | ||
652 | unsigned long flags; | ||
653 | unsigned char dma_image, irq_image, tmp; | ||
654 | |||
655 | static unsigned char gus_irq_map[16] = { | ||
656 | 0, 0, 0, 3, 0, 2, 0, 4, 0, 1, 0, 5, 6, 0, 0, 7 | ||
657 | }; | ||
658 | |||
659 | static unsigned char gus_dma_map[8] = { | ||
660 | 0, 1, 0, 2, 0, 3, 4, 5 | ||
661 | }; | ||
662 | |||
663 | spin_lock_irqsave(&gus_lock,flags); | ||
664 | gus_write8(0x4c, 0); /* Reset GF1 */ | ||
665 | gus_delay(); | ||
666 | gus_delay(); | ||
667 | |||
668 | gus_write8(0x4c, 1); /* Release Reset */ | ||
669 | gus_delay(); | ||
670 | gus_delay(); | ||
671 | |||
672 | /* | ||
673 | * Clear all interrupts | ||
674 | */ | ||
675 | |||
676 | gus_write8(0x41, 0); /* DMA control */ | ||
677 | gus_write8(0x45, 0); /* Timer control */ | ||
678 | gus_write8(0x49, 0); /* Sample control */ | ||
679 | |||
680 | gus_select_max_voices(24); | ||
681 | |||
682 | inb(u_Status); /* Touch the status register */ | ||
683 | |||
684 | gus_look8(0x41); /* Clear any pending DMA IRQs */ | ||
685 | gus_look8(0x49); /* Clear any pending sample IRQs */ | ||
686 | gus_read8(0x0f); /* Clear pending IRQs */ | ||
687 | |||
688 | gus_reset(); /* Resets all voices */ | ||
689 | |||
690 | gus_look8(0x41); /* Clear any pending DMA IRQs */ | ||
691 | gus_look8(0x49); /* Clear any pending sample IRQs */ | ||
692 | gus_read8(0x0f); /* Clear pending IRQs */ | ||
693 | |||
694 | gus_write8(0x4c, 7); /* Master reset | DAC enable | IRQ enable */ | ||
695 | |||
696 | /* | ||
697 | * Set up for Digital ASIC | ||
698 | */ | ||
699 | |||
700 | outb((0x05), gus_base + 0x0f); | ||
701 | |||
702 | mix_image |= 0x02; /* Disable line out (for a moment) */ | ||
703 | outb((mix_image), u_Mixer); | ||
704 | |||
705 | outb((0x00), u_IRQDMAControl); | ||
706 | |||
707 | outb((0x00), gus_base + 0x0f); | ||
708 | |||
709 | /* | ||
710 | * Now set up the DMA and IRQ interface | ||
711 | * | ||
712 | * The GUS supports two IRQs and two DMAs. | ||
713 | * | ||
714 | * Just one DMA channel is used. This prevents simultaneous ADC and DAC. | ||
715 | * Adding this support requires significant changes to the dmabuf.c, dsp.c | ||
716 | * and audio.c also. | ||
717 | */ | ||
718 | |||
719 | irq_image = 0; | ||
720 | tmp = gus_irq_map[gus_irq]; | ||
721 | if (!gus_pnp_flag && !tmp) | ||
722 | printk(KERN_WARNING "Warning! GUS IRQ not selected\n"); | ||
723 | irq_image |= tmp; | ||
724 | irq_image |= 0x40; /* Combine IRQ1 (GF1) and IRQ2 (Midi) */ | ||
725 | |||
726 | dual_dma_mode = 1; | ||
727 | if (gus_dma2 == gus_dma || gus_dma2 == -1) | ||
728 | { | ||
729 | dual_dma_mode = 0; | ||
730 | dma_image = 0x40; /* Combine DMA1 (DRAM) and IRQ2 (ADC) */ | ||
731 | |||
732 | tmp = gus_dma_map[gus_dma]; | ||
733 | if (!tmp) | ||
734 | printk(KERN_WARNING "Warning! GUS DMA not selected\n"); | ||
735 | |||
736 | dma_image |= tmp; | ||
737 | } | ||
738 | else | ||
739 | { | ||
740 | /* Setup dual DMA channel mode for GUS MAX */ | ||
741 | |||
742 | dma_image = gus_dma_map[gus_dma]; | ||
743 | if (!dma_image) | ||
744 | printk(KERN_WARNING "Warning! GUS DMA not selected\n"); | ||
745 | |||
746 | tmp = gus_dma_map[gus_dma2] << 3; | ||
747 | if (!tmp) | ||
748 | { | ||
749 | printk(KERN_WARNING "Warning! Invalid GUS MAX DMA\n"); | ||
750 | tmp = 0x40; /* Combine DMA channels */ | ||
751 | dual_dma_mode = 0; | ||
752 | } | ||
753 | dma_image |= tmp; | ||
754 | } | ||
755 | |||
756 | /* | ||
757 | * For some reason the IRQ and DMA addresses must be written twice | ||
758 | */ | ||
759 | |||
760 | /* | ||
761 | * Doing it first time | ||
762 | */ | ||
763 | |||
764 | outb((mix_image), u_Mixer); /* Select DMA control */ | ||
765 | outb((dma_image | 0x80), u_IRQDMAControl); /* Set DMA address */ | ||
766 | |||
767 | outb((mix_image | 0x40), u_Mixer); /* Select IRQ control */ | ||
768 | outb((irq_image), u_IRQDMAControl); /* Set IRQ address */ | ||
769 | |||
770 | /* | ||
771 | * Doing it second time | ||
772 | */ | ||
773 | |||
774 | outb((mix_image), u_Mixer); /* Select DMA control */ | ||
775 | outb((dma_image), u_IRQDMAControl); /* Set DMA address */ | ||
776 | |||
777 | outb((mix_image | 0x40), u_Mixer); /* Select IRQ control */ | ||
778 | outb((irq_image), u_IRQDMAControl); /* Set IRQ address */ | ||
779 | |||
780 | gus_select_voice(0); /* This disables writes to IRQ/DMA reg */ | ||
781 | |||
782 | mix_image &= ~0x02; /* Enable line out */ | ||
783 | mix_image |= 0x08; /* Enable IRQ */ | ||
784 | outb((mix_image), u_Mixer); /* | ||
785 | * Turn mixer channels on | ||
786 | * Note! Mic in is left off. | ||
787 | */ | ||
788 | |||
789 | gus_select_voice(0); /* This disables writes to IRQ/DMA reg */ | ||
790 | |||
791 | gusintr(gus_irq, (void *)gus_hw_config, NULL); /* Serve pending interrupts */ | ||
792 | |||
793 | inb(u_Status); /* Touch the status register */ | ||
794 | |||
795 | gus_look8(0x41); /* Clear any pending DMA IRQs */ | ||
796 | gus_look8(0x49); /* Clear any pending sample IRQs */ | ||
797 | |||
798 | gus_read8(0x0f); /* Clear pending IRQs */ | ||
799 | |||
800 | if (iw_mode) | ||
801 | gus_write8(0x19, gus_read8(0x19) | 0x01); | ||
802 | spin_unlock_irqrestore(&gus_lock,flags); | ||
803 | } | ||
804 | |||
805 | |||
806 | static void __init pnp_mem_init(void) | ||
807 | { | ||
808 | #include "iwmem.h" | ||
809 | #define CHUNK_SIZE (256*1024) | ||
810 | #define BANK_SIZE (4*1024*1024) | ||
811 | #define CHUNKS_PER_BANK (BANK_SIZE/CHUNK_SIZE) | ||
812 | |||
813 | int bank, chunk, addr, total = 0; | ||
814 | int bank_sizes[4]; | ||
815 | int i, j, bits = -1, testbits = -1, nbanks = 0; | ||
816 | |||
817 | /* | ||
818 | * This routine determines what kind of RAM is installed in each of the four | ||
819 | * SIMM banks and configures the DRAM address decode logic accordingly. | ||
820 | */ | ||
821 | |||
822 | /* | ||
823 | * Place the chip into enhanced mode | ||
824 | */ | ||
825 | gus_write8(0x19, gus_read8(0x19) | 0x01); | ||
826 | gus_write8(0x53, gus_look8(0x53) & ~0x02); /* Select DRAM I/O access */ | ||
827 | |||
828 | /* | ||
829 | * Set memory configuration to 4 DRAM banks of 4M in each (16M total). | ||
830 | */ | ||
831 | |||
832 | gus_write16(0x52, (gus_look16(0x52) & 0xfff0) | 0x000c); | ||
833 | |||
834 | /* | ||
835 | * Perform the DRAM size detection for each bank individually. | ||
836 | */ | ||
837 | for (bank = 0; bank < 4; bank++) | ||
838 | { | ||
839 | int size = 0; | ||
840 | |||
841 | addr = bank * BANK_SIZE; | ||
842 | |||
843 | /* Clean check points of each chunk */ | ||
844 | for (chunk = 0; chunk < CHUNKS_PER_BANK; chunk++) | ||
845 | { | ||
846 | gus_poke(addr + chunk * CHUNK_SIZE + 0L, 0x00); | ||
847 | gus_poke(addr + chunk * CHUNK_SIZE + 1L, 0x00); | ||
848 | } | ||
849 | |||
850 | /* Write a value to each chunk point and verify the result */ | ||
851 | for (chunk = 0; chunk < CHUNKS_PER_BANK; chunk++) | ||
852 | { | ||
853 | gus_poke(addr + chunk * CHUNK_SIZE + 0L, 0x55); | ||
854 | gus_poke(addr + chunk * CHUNK_SIZE + 1L, 0xAA); | ||
855 | |||
856 | if (gus_peek(addr + chunk * CHUNK_SIZE + 0L) == 0x55 && | ||
857 | gus_peek(addr + chunk * CHUNK_SIZE + 1L) == 0xAA) | ||
858 | { | ||
859 | /* OK. There is RAM. Now check for possible shadows */ | ||
860 | int ok = 1, chunk2; | ||
861 | |||
862 | for (chunk2 = 0; ok && chunk2 < chunk; chunk2++) | ||
863 | if (gus_peek(addr + chunk2 * CHUNK_SIZE + 0L) || | ||
864 | gus_peek(addr + chunk2 * CHUNK_SIZE + 1L)) | ||
865 | ok = 0; /* Addressing wraps */ | ||
866 | |||
867 | if (ok) | ||
868 | size = (chunk + 1) * CHUNK_SIZE; | ||
869 | } | ||
870 | gus_poke(addr + chunk * CHUNK_SIZE + 0L, 0x00); | ||
871 | gus_poke(addr + chunk * CHUNK_SIZE + 1L, 0x00); | ||
872 | } | ||
873 | bank_sizes[bank] = size; | ||
874 | if (size) | ||
875 | nbanks = bank + 1; | ||
876 | DDB(printk("Interwave: Bank %d, size=%dk\n", bank, size / 1024)); | ||
877 | } | ||
878 | |||
879 | if (nbanks == 0) /* No RAM - Give up */ | ||
880 | { | ||
881 | printk(KERN_ERR "Sound: An Interwave audio chip detected but no DRAM\n"); | ||
882 | printk(KERN_ERR "Sound: Unable to work with this card.\n"); | ||
883 | gus_write8(0x19, gus_read8(0x19) & ~0x01); | ||
884 | gus_mem_size = 0; | ||
885 | return; | ||
886 | } | ||
887 | |||
888 | /* | ||
889 | * Now we know how much DRAM there is in each bank. The next step is | ||
890 | * to find a DRAM size encoding (0 to 12) which is best for the combination | ||
891 | * we have. | ||
892 | * | ||
893 | * First try if any of the possible alternatives matches exactly the amount | ||
894 | * of memory we have. | ||
895 | */ | ||
896 | |||
897 | for (i = 0; bits == -1 && i < 13; i++) | ||
898 | { | ||
899 | bits = i; | ||
900 | |||
901 | for (j = 0; bits != -1 && j < 4; j++) | ||
902 | if (mem_decode[i][j] != bank_sizes[j]) | ||
903 | bits = -1; /* No hit */ | ||
904 | } | ||
905 | |||
906 | /* | ||
907 | * If necessary, try to find a combination where other than the last | ||
908 | * bank matches our configuration and the last bank is left oversized. | ||
909 | * In this way we don't leave holes in the middle of memory. | ||
910 | */ | ||
911 | |||
912 | if (bits == -1) /* No luck yet */ | ||
913 | { | ||
914 | for (i = 0; bits == -1 && i < 13; i++) | ||
915 | { | ||
916 | bits = i; | ||
917 | |||
918 | for (j = 0; bits != -1 && j < nbanks - 1; j++) | ||
919 | if (mem_decode[i][j] != bank_sizes[j]) | ||
920 | bits = -1; /* No hit */ | ||
921 | if (mem_decode[i][nbanks - 1] < bank_sizes[nbanks - 1]) | ||
922 | bits = -1; /* The last bank is too small */ | ||
923 | } | ||
924 | } | ||
925 | /* | ||
926 | * The last resort is to search for a combination where the banks are | ||
927 | * smaller than the actual SIMMs. This leaves some memory in the banks | ||
928 | * unused but doesn't leave holes in the DRAM address space. | ||
929 | */ | ||
930 | if (bits == -1) /* No luck yet */ | ||
931 | { | ||
932 | for (i = 0; i < 13; i++) | ||
933 | { | ||
934 | testbits = i; | ||
935 | for (j = 0; testbits != -1 && j < nbanks - 1; j++) | ||
936 | if (mem_decode[i][j] > bank_sizes[j]) { | ||
937 | testbits = -1; | ||
938 | } | ||
939 | if(testbits > bits) bits = testbits; | ||
940 | } | ||
941 | if (bits != -1) | ||
942 | { | ||
943 | printk(KERN_INFO "Interwave: Can't use all installed RAM.\n"); | ||
944 | printk(KERN_INFO "Interwave: Try reordering SIMMS.\n"); | ||
945 | } | ||
946 | printk(KERN_INFO "Interwave: Can't find working DRAM encoding.\n"); | ||
947 | printk(KERN_INFO "Interwave: Defaulting to 256k. Try reordering SIMMS.\n"); | ||
948 | bits = 0; | ||
949 | } | ||
950 | DDB(printk("Interwave: Selecting DRAM addressing mode %d\n", bits)); | ||
951 | |||
952 | for (bank = 0; bank < 4; bank++) | ||
953 | { | ||
954 | DDB(printk(" Bank %d, mem=%dk (limit %dk)\n", bank, bank_sizes[bank] / 1024, mem_decode[bits][bank] / 1024)); | ||
955 | |||
956 | if (bank_sizes[bank] > mem_decode[bits][bank]) | ||
957 | total += mem_decode[bits][bank]; | ||
958 | else | ||
959 | total += bank_sizes[bank]; | ||
960 | } | ||
961 | |||
962 | DDB(printk("Total %dk of DRAM (enhanced mode)\n", total / 1024)); | ||
963 | |||
964 | /* | ||
965 | * Set the memory addressing mode. | ||
966 | */ | ||
967 | gus_write16(0x52, (gus_look16(0x52) & 0xfff0) | bits); | ||
968 | |||
969 | /* Leave the chip into enhanced mode. Disable LFO */ | ||
970 | gus_mem_size = total; | ||
971 | iw_mode = 1; | ||
972 | gus_write8(0x19, (gus_read8(0x19) | 0x01) & ~0x02); | ||
973 | } | ||
974 | |||
975 | int __init gus_wave_detect(int baseaddr) | ||
976 | { | ||
977 | unsigned long i, max_mem = 1024L; | ||
978 | unsigned long loc; | ||
979 | unsigned char val; | ||
980 | |||
981 | if (!request_region(baseaddr, 16, "GUS")) | ||
982 | return 0; | ||
983 | if (!request_region(baseaddr + 0x100, 12, "GUS")) { /* 0x10c-> is MAX */ | ||
984 | release_region(baseaddr, 16); | ||
985 | return 0; | ||
986 | } | ||
987 | |||
988 | gus_base = baseaddr; | ||
989 | |||
990 | gus_write8(0x4c, 0); /* Reset GF1 */ | ||
991 | gus_delay(); | ||
992 | gus_delay(); | ||
993 | |||
994 | gus_write8(0x4c, 1); /* Release Reset */ | ||
995 | gus_delay(); | ||
996 | gus_delay(); | ||
997 | |||
998 | #ifdef GUSPNP_AUTODETECT | ||
999 | val = gus_look8(0x5b); /* Version number register */ | ||
1000 | gus_write8(0x5b, ~val); /* Invert all bits */ | ||
1001 | |||
1002 | if ((gus_look8(0x5b) & 0xf0) == (val & 0xf0)) /* No change */ | ||
1003 | { | ||
1004 | if ((gus_look8(0x5b) & 0x0f) == ((~val) & 0x0f)) /* Change */ | ||
1005 | { | ||
1006 | DDB(printk("Interwave chip version %d detected\n", (val & 0xf0) >> 4)); | ||
1007 | gus_pnp_flag = 1; | ||
1008 | } | ||
1009 | else | ||
1010 | { | ||
1011 | DDB(printk("Not an Interwave chip (%x)\n", gus_look8(0x5b))); | ||
1012 | gus_pnp_flag = 0; | ||
1013 | } | ||
1014 | } | ||
1015 | gus_write8(0x5b, val); /* Restore all bits */ | ||
1016 | #endif | ||
1017 | |||
1018 | if (gus_pnp_flag) | ||
1019 | pnp_mem_init(); | ||
1020 | if (iw_mode) | ||
1021 | return 1; | ||
1022 | |||
1023 | /* See if there is first block there.... */ | ||
1024 | gus_poke(0L, 0xaa); | ||
1025 | if (gus_peek(0L) != 0xaa) { | ||
1026 | release_region(baseaddr + 0x100, 12); | ||
1027 | release_region(baseaddr, 16); | ||
1028 | return 0; | ||
1029 | } | ||
1030 | |||
1031 | /* Now zero it out so that I can check for mirroring .. */ | ||
1032 | gus_poke(0L, 0x00); | ||
1033 | for (i = 1L; i < max_mem; i++) | ||
1034 | { | ||
1035 | int n, failed; | ||
1036 | |||
1037 | /* check for mirroring ... */ | ||
1038 | if (gus_peek(0L) != 0) | ||
1039 | break; | ||
1040 | loc = i << 10; | ||
1041 | |||
1042 | for (n = loc - 1, failed = 0; n <= loc; n++) | ||
1043 | { | ||
1044 | gus_poke(loc, 0xaa); | ||
1045 | if (gus_peek(loc) != 0xaa) | ||
1046 | failed = 1; | ||
1047 | gus_poke(loc, 0x55); | ||
1048 | if (gus_peek(loc) != 0x55) | ||
1049 | failed = 1; | ||
1050 | } | ||
1051 | if (failed) | ||
1052 | break; | ||
1053 | } | ||
1054 | gus_mem_size = i << 10; | ||
1055 | return 1; | ||
1056 | } | ||
1057 | |||
1058 | static int guswave_ioctl(int dev, unsigned int cmd, void __user *arg) | ||
1059 | { | ||
1060 | |||
1061 | switch (cmd) | ||
1062 | { | ||
1063 | case SNDCTL_SYNTH_INFO: | ||
1064 | gus_info.nr_voices = nr_voices; | ||
1065 | if (copy_to_user(arg, &gus_info, sizeof(gus_info))) | ||
1066 | return -EFAULT; | ||
1067 | return 0; | ||
1068 | |||
1069 | case SNDCTL_SEQ_RESETSAMPLES: | ||
1070 | reset_sample_memory(); | ||
1071 | return 0; | ||
1072 | |||
1073 | case SNDCTL_SEQ_PERCMODE: | ||
1074 | return 0; | ||
1075 | |||
1076 | case SNDCTL_SYNTH_MEMAVL: | ||
1077 | return (gus_mem_size == 0) ? 0 : gus_mem_size - free_mem_ptr - 32; | ||
1078 | |||
1079 | default: | ||
1080 | return -EINVAL; | ||
1081 | } | ||
1082 | } | ||
1083 | |||
1084 | static int guswave_set_instr(int dev, int voice, int instr_no) | ||
1085 | { | ||
1086 | int sample_no; | ||
1087 | |||
1088 | if (instr_no < 0 || instr_no > MAX_PATCH) | ||
1089 | instr_no = 0; /* Default to acoustic piano */ | ||
1090 | |||
1091 | if (voice < 0 || voice > 31) | ||
1092 | return -EINVAL; | ||
1093 | |||
1094 | if (voices[voice].volume_irq_mode == VMODE_START_NOTE) | ||
1095 | { | ||
1096 | voices[voice].sample_pending = instr_no; | ||
1097 | return 0; | ||
1098 | } | ||
1099 | sample_no = patch_table[instr_no]; | ||
1100 | patch_map[voice] = -1; | ||
1101 | |||
1102 | if (sample_no == NOT_SAMPLE) | ||
1103 | { | ||
1104 | /* printk("GUS: Undefined patch %d for voice %d\n", instr_no, voice);*/ | ||
1105 | return -EINVAL; /* Patch not defined */ | ||
1106 | } | ||
1107 | if (sample_ptrs[sample_no] == -1) /* Sample not loaded */ | ||
1108 | { | ||
1109 | /* printk("GUS: Sample #%d not loaded for patch %d (voice %d)\n", sample_no, instr_no, voice);*/ | ||
1110 | return -EINVAL; | ||
1111 | } | ||
1112 | sample_map[voice] = sample_no; | ||
1113 | patch_map[voice] = instr_no; | ||
1114 | return 0; | ||
1115 | } | ||
1116 | |||
1117 | static int guswave_kill_note(int dev, int voice, int note, int velocity) | ||
1118 | { | ||
1119 | unsigned long flags; | ||
1120 | |||
1121 | spin_lock_irqsave(&gus_lock,flags); | ||
1122 | /* voice_alloc->map[voice] = 0xffff; */ | ||
1123 | if (voices[voice].volume_irq_mode == VMODE_START_NOTE) | ||
1124 | { | ||
1125 | voices[voice].kill_pending = 1; | ||
1126 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1127 | } | ||
1128 | else | ||
1129 | { | ||
1130 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1131 | gus_voice_fade(voice); | ||
1132 | } | ||
1133 | |||
1134 | return 0; | ||
1135 | } | ||
1136 | |||
1137 | static void guswave_aftertouch(int dev, int voice, int pressure) | ||
1138 | { | ||
1139 | } | ||
1140 | |||
1141 | static void guswave_panning(int dev, int voice, int value) | ||
1142 | { | ||
1143 | if (voice >= 0 || voice < 32) | ||
1144 | voices[voice].panning = value; | ||
1145 | } | ||
1146 | |||
1147 | static void guswave_volume_method(int dev, int mode) | ||
1148 | { | ||
1149 | if (mode == VOL_METHOD_LINEAR || mode == VOL_METHOD_ADAGIO) | ||
1150 | volume_method = mode; | ||
1151 | } | ||
1152 | |||
1153 | static void compute_volume(int voice, int volume) | ||
1154 | { | ||
1155 | if (volume < 128) | ||
1156 | voices[voice].midi_volume = volume; | ||
1157 | |||
1158 | switch (volume_method) | ||
1159 | { | ||
1160 | case VOL_METHOD_ADAGIO: | ||
1161 | voices[voice].initial_volume = | ||
1162 | gus_adagio_vol(voices[voice].midi_volume, voices[voice].main_vol, | ||
1163 | voices[voice].expression_vol, | ||
1164 | voices[voice].patch_vol); | ||
1165 | break; | ||
1166 | |||
1167 | case VOL_METHOD_LINEAR: /* Totally ignores patch-volume and expression */ | ||
1168 | voices[voice].initial_volume = gus_linear_vol(volume, voices[voice].main_vol); | ||
1169 | break; | ||
1170 | |||
1171 | default: | ||
1172 | voices[voice].initial_volume = volume_base + | ||
1173 | (voices[voice].midi_volume * volume_scale); | ||
1174 | } | ||
1175 | |||
1176 | if (voices[voice].initial_volume > 4030) | ||
1177 | voices[voice].initial_volume = 4030; | ||
1178 | } | ||
1179 | |||
1180 | static void compute_and_set_volume(int voice, int volume, int ramp_time) | ||
1181 | { | ||
1182 | int curr, target, rate; | ||
1183 | unsigned long flags; | ||
1184 | |||
1185 | compute_volume(voice, volume); | ||
1186 | voices[voice].current_volume = voices[voice].initial_volume; | ||
1187 | |||
1188 | spin_lock_irqsave(&gus_lock,flags); | ||
1189 | /* | ||
1190 | * CAUTION! Interrupts disabled. Enable them before returning | ||
1191 | */ | ||
1192 | |||
1193 | gus_select_voice(voice); | ||
1194 | |||
1195 | curr = gus_read16(0x09) >> 4; | ||
1196 | target = voices[voice].initial_volume; | ||
1197 | |||
1198 | if (ramp_time == INSTANT_RAMP) | ||
1199 | { | ||
1200 | gus_rampoff(); | ||
1201 | gus_voice_volume(target); | ||
1202 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1203 | return; | ||
1204 | } | ||
1205 | if (ramp_time == FAST_RAMP) | ||
1206 | rate = 63; | ||
1207 | else | ||
1208 | rate = 16; | ||
1209 | gus_ramp_rate(0, rate); | ||
1210 | |||
1211 | if ((target - curr) / 64 == 0) /* Close enough to target. */ | ||
1212 | { | ||
1213 | gus_rampoff(); | ||
1214 | gus_voice_volume(target); | ||
1215 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1216 | return; | ||
1217 | } | ||
1218 | if (target > curr) | ||
1219 | { | ||
1220 | if (target > (4095 - 65)) | ||
1221 | target = 4095 - 65; | ||
1222 | gus_ramp_range(curr, target); | ||
1223 | gus_rampon(0x00); /* Ramp up, once, no IRQ */ | ||
1224 | } | ||
1225 | else | ||
1226 | { | ||
1227 | if (target < 65) | ||
1228 | target = 65; | ||
1229 | |||
1230 | gus_ramp_range(target, curr); | ||
1231 | gus_rampon(0x40); /* Ramp down, once, no irq */ | ||
1232 | } | ||
1233 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1234 | } | ||
1235 | |||
1236 | static void dynamic_volume_change(int voice) | ||
1237 | { | ||
1238 | unsigned char status; | ||
1239 | unsigned long flags; | ||
1240 | |||
1241 | spin_lock_irqsave(&gus_lock,flags); | ||
1242 | gus_select_voice(voice); | ||
1243 | status = gus_read8(0x00); /* Get voice status */ | ||
1244 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1245 | |||
1246 | if (status & 0x03) | ||
1247 | return; /* Voice was not running */ | ||
1248 | |||
1249 | if (!(voices[voice].mode & WAVE_ENVELOPES)) | ||
1250 | { | ||
1251 | compute_and_set_volume(voice, voices[voice].midi_volume, 1); | ||
1252 | return; | ||
1253 | } | ||
1254 | |||
1255 | /* | ||
1256 | * Voice is running and has envelopes. | ||
1257 | */ | ||
1258 | |||
1259 | spin_lock_irqsave(&gus_lock,flags); | ||
1260 | gus_select_voice(voice); | ||
1261 | status = gus_read8(0x0d); /* Ramping status */ | ||
1262 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1263 | |||
1264 | if (status & 0x03) /* Sustain phase? */ | ||
1265 | { | ||
1266 | compute_and_set_volume(voice, voices[voice].midi_volume, 1); | ||
1267 | return; | ||
1268 | } | ||
1269 | if (voices[voice].env_phase < 0) | ||
1270 | return; | ||
1271 | |||
1272 | compute_volume(voice, voices[voice].midi_volume); | ||
1273 | |||
1274 | } | ||
1275 | |||
1276 | static void guswave_controller(int dev, int voice, int ctrl_num, int value) | ||
1277 | { | ||
1278 | unsigned long flags; | ||
1279 | unsigned long freq; | ||
1280 | |||
1281 | if (voice < 0 || voice > 31) | ||
1282 | return; | ||
1283 | |||
1284 | switch (ctrl_num) | ||
1285 | { | ||
1286 | case CTRL_PITCH_BENDER: | ||
1287 | voices[voice].bender = value; | ||
1288 | |||
1289 | if (voices[voice].volume_irq_mode != VMODE_START_NOTE) | ||
1290 | { | ||
1291 | freq = compute_finetune(voices[voice].orig_freq, value, voices[voice].bender_range, 0); | ||
1292 | voices[voice].current_freq = freq; | ||
1293 | |||
1294 | spin_lock_irqsave(&gus_lock,flags); | ||
1295 | gus_select_voice(voice); | ||
1296 | gus_voice_freq(freq); | ||
1297 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1298 | } | ||
1299 | break; | ||
1300 | |||
1301 | case CTRL_PITCH_BENDER_RANGE: | ||
1302 | voices[voice].bender_range = value; | ||
1303 | break; | ||
1304 | case CTL_EXPRESSION: | ||
1305 | value /= 128; | ||
1306 | case CTRL_EXPRESSION: | ||
1307 | if (volume_method == VOL_METHOD_ADAGIO) | ||
1308 | { | ||
1309 | voices[voice].expression_vol = value; | ||
1310 | if (voices[voice].volume_irq_mode != VMODE_START_NOTE) | ||
1311 | dynamic_volume_change(voice); | ||
1312 | } | ||
1313 | break; | ||
1314 | |||
1315 | case CTL_PAN: | ||
1316 | voices[voice].panning = (value * 2) - 128; | ||
1317 | break; | ||
1318 | |||
1319 | case CTL_MAIN_VOLUME: | ||
1320 | value = (value * 100) / 16383; | ||
1321 | |||
1322 | case CTRL_MAIN_VOLUME: | ||
1323 | voices[voice].main_vol = value; | ||
1324 | if (voices[voice].volume_irq_mode != VMODE_START_NOTE) | ||
1325 | dynamic_volume_change(voice); | ||
1326 | break; | ||
1327 | |||
1328 | default: | ||
1329 | break; | ||
1330 | } | ||
1331 | } | ||
1332 | |||
1333 | static int guswave_start_note2(int dev, int voice, int note_num, int volume) | ||
1334 | { | ||
1335 | int sample, best_sample, best_delta, delta_freq; | ||
1336 | int is16bits, samplep, patch, pan; | ||
1337 | unsigned long note_freq, base_note, freq, flags; | ||
1338 | unsigned char mode = 0; | ||
1339 | |||
1340 | if (voice < 0 || voice > 31) | ||
1341 | { | ||
1342 | /* printk("GUS: Invalid voice\n");*/ | ||
1343 | return -EINVAL; | ||
1344 | } | ||
1345 | if (note_num == 255) | ||
1346 | { | ||
1347 | if (voices[voice].mode & WAVE_ENVELOPES) | ||
1348 | { | ||
1349 | voices[voice].midi_volume = volume; | ||
1350 | dynamic_volume_change(voice); | ||
1351 | return 0; | ||
1352 | } | ||
1353 | compute_and_set_volume(voice, volume, 1); | ||
1354 | return 0; | ||
1355 | } | ||
1356 | if ((patch = patch_map[voice]) == -1) | ||
1357 | return -EINVAL; | ||
1358 | if ((samplep = patch_table[patch]) == NOT_SAMPLE) | ||
1359 | { | ||
1360 | return -EINVAL; | ||
1361 | } | ||
1362 | note_freq = note_to_freq(note_num); | ||
1363 | |||
1364 | /* | ||
1365 | * Find a sample within a patch so that the note_freq is between low_note | ||
1366 | * and high_note. | ||
1367 | */ | ||
1368 | sample = -1; | ||
1369 | |||
1370 | best_sample = samplep; | ||
1371 | best_delta = 1000000; | ||
1372 | while (samplep != 0 && samplep != NOT_SAMPLE && sample == -1) | ||
1373 | { | ||
1374 | delta_freq = note_freq - samples[samplep].base_note; | ||
1375 | if (delta_freq < 0) | ||
1376 | delta_freq = -delta_freq; | ||
1377 | if (delta_freq < best_delta) | ||
1378 | { | ||
1379 | best_sample = samplep; | ||
1380 | best_delta = delta_freq; | ||
1381 | } | ||
1382 | if (samples[samplep].low_note <= note_freq && | ||
1383 | note_freq <= samples[samplep].high_note) | ||
1384 | { | ||
1385 | sample = samplep; | ||
1386 | } | ||
1387 | else | ||
1388 | samplep = samples[samplep].key; /* Link to next sample */ | ||
1389 | } | ||
1390 | if (sample == -1) | ||
1391 | sample = best_sample; | ||
1392 | |||
1393 | if (sample == -1) | ||
1394 | { | ||
1395 | /* printk("GUS: Patch %d not defined for note %d\n", patch, note_num);*/ | ||
1396 | return 0; /* Should play default patch ??? */ | ||
1397 | } | ||
1398 | is16bits = (samples[sample].mode & WAVE_16_BITS) ? 1 : 0; | ||
1399 | voices[voice].mode = samples[sample].mode; | ||
1400 | voices[voice].patch_vol = samples[sample].volume; | ||
1401 | |||
1402 | if (iw_mode) | ||
1403 | gus_write8(0x15, 0x00); /* RAM, Reset voice deactivate bit of SMSI */ | ||
1404 | |||
1405 | if (voices[voice].mode & WAVE_ENVELOPES) | ||
1406 | { | ||
1407 | int i; | ||
1408 | |||
1409 | for (i = 0; i < 6; i++) | ||
1410 | { | ||
1411 | voices[voice].env_rate[i] = samples[sample].env_rate[i]; | ||
1412 | voices[voice].env_offset[i] = samples[sample].env_offset[i]; | ||
1413 | } | ||
1414 | } | ||
1415 | sample_map[voice] = sample; | ||
1416 | |||
1417 | if (voices[voice].fixed_pitch) /* Fixed pitch */ | ||
1418 | { | ||
1419 | freq = samples[sample].base_freq; | ||
1420 | } | ||
1421 | else | ||
1422 | { | ||
1423 | base_note = samples[sample].base_note / 100; | ||
1424 | note_freq /= 100; | ||
1425 | |||
1426 | freq = samples[sample].base_freq * note_freq / base_note; | ||
1427 | } | ||
1428 | |||
1429 | voices[voice].orig_freq = freq; | ||
1430 | |||
1431 | /* | ||
1432 | * Since the pitch bender may have been set before playing the note, we | ||
1433 | * have to calculate the bending now. | ||
1434 | */ | ||
1435 | |||
1436 | freq = compute_finetune(voices[voice].orig_freq, voices[voice].bender, | ||
1437 | voices[voice].bender_range, 0); | ||
1438 | voices[voice].current_freq = freq; | ||
1439 | |||
1440 | pan = (samples[sample].panning + voices[voice].panning) / 32; | ||
1441 | pan += 7; | ||
1442 | if (pan < 0) | ||
1443 | pan = 0; | ||
1444 | if (pan > 15) | ||
1445 | pan = 15; | ||
1446 | |||
1447 | if (samples[sample].mode & WAVE_16_BITS) | ||
1448 | { | ||
1449 | mode |= 0x04; /* 16 bits */ | ||
1450 | if ((sample_ptrs[sample] / GUS_BANK_SIZE) != | ||
1451 | ((sample_ptrs[sample] + samples[sample].len) / GUS_BANK_SIZE)) | ||
1452 | printk(KERN_ERR "GUS: Sample address error\n"); | ||
1453 | } | ||
1454 | spin_lock_irqsave(&gus_lock,flags); | ||
1455 | gus_select_voice(voice); | ||
1456 | gus_voice_off(); | ||
1457 | gus_rampoff(); | ||
1458 | |||
1459 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1460 | |||
1461 | if (voices[voice].mode & WAVE_ENVELOPES) | ||
1462 | { | ||
1463 | compute_volume(voice, volume); | ||
1464 | init_envelope(voice); | ||
1465 | } | ||
1466 | else | ||
1467 | { | ||
1468 | compute_and_set_volume(voice, volume, 0); | ||
1469 | } | ||
1470 | |||
1471 | spin_lock_irqsave(&gus_lock,flags); | ||
1472 | gus_select_voice(voice); | ||
1473 | |||
1474 | if (samples[sample].mode & WAVE_LOOP_BACK) | ||
1475 | gus_write_addr(0x0a, sample_ptrs[sample] + samples[sample].len - | ||
1476 | voices[voice].offset_pending, 0, is16bits); /* start=end */ | ||
1477 | else | ||
1478 | gus_write_addr(0x0a, sample_ptrs[sample] + voices[voice].offset_pending, 0, is16bits); /* Sample start=begin */ | ||
1479 | |||
1480 | if (samples[sample].mode & WAVE_LOOPING) | ||
1481 | { | ||
1482 | mode |= 0x08; | ||
1483 | |||
1484 | if (samples[sample].mode & WAVE_BIDIR_LOOP) | ||
1485 | mode |= 0x10; | ||
1486 | |||
1487 | if (samples[sample].mode & WAVE_LOOP_BACK) | ||
1488 | { | ||
1489 | gus_write_addr(0x0a, sample_ptrs[sample] + samples[sample].loop_end - | ||
1490 | voices[voice].offset_pending, | ||
1491 | (samples[sample].fractions >> 4) & 0x0f, is16bits); | ||
1492 | mode |= 0x40; | ||
1493 | } | ||
1494 | gus_write_addr(0x02, sample_ptrs[sample] + samples[sample].loop_start, | ||
1495 | samples[sample].fractions & 0x0f, is16bits); /* Loop start location */ | ||
1496 | gus_write_addr(0x04, sample_ptrs[sample] + samples[sample].loop_end, | ||
1497 | (samples[sample].fractions >> 4) & 0x0f, is16bits); /* Loop end location */ | ||
1498 | } | ||
1499 | else | ||
1500 | { | ||
1501 | mode |= 0x20; /* Loop IRQ at the end */ | ||
1502 | voices[voice].loop_irq_mode = LMODE_FINISH; /* Ramp down at the end */ | ||
1503 | voices[voice].loop_irq_parm = 1; | ||
1504 | gus_write_addr(0x02, sample_ptrs[sample], 0, is16bits); /* Loop start location */ | ||
1505 | gus_write_addr(0x04, sample_ptrs[sample] + samples[sample].len - 1, | ||
1506 | (samples[sample].fractions >> 4) & 0x0f, is16bits); /* Loop end location */ | ||
1507 | } | ||
1508 | gus_voice_freq(freq); | ||
1509 | gus_voice_balance(pan); | ||
1510 | gus_voice_on(mode); | ||
1511 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1512 | |||
1513 | return 0; | ||
1514 | } | ||
1515 | |||
1516 | /* | ||
1517 | * New guswave_start_note by Andrew J. Robinson attempts to minimize clicking | ||
1518 | * when the note playing on the voice is changed. It uses volume | ||
1519 | * ramping. | ||
1520 | */ | ||
1521 | |||
1522 | static int guswave_start_note(int dev, int voice, int note_num, int volume) | ||
1523 | { | ||
1524 | unsigned long flags; | ||
1525 | int mode; | ||
1526 | int ret_val = 0; | ||
1527 | |||
1528 | spin_lock_irqsave(&gus_lock,flags); | ||
1529 | if (note_num == 255) | ||
1530 | { | ||
1531 | if (voices[voice].volume_irq_mode == VMODE_START_NOTE) | ||
1532 | { | ||
1533 | voices[voice].volume_pending = volume; | ||
1534 | } | ||
1535 | else | ||
1536 | { | ||
1537 | ret_val = guswave_start_note2(dev, voice, note_num, volume); | ||
1538 | } | ||
1539 | } | ||
1540 | else | ||
1541 | { | ||
1542 | gus_select_voice(voice); | ||
1543 | mode = gus_read8(0x00); | ||
1544 | if (mode & 0x20) | ||
1545 | gus_write8(0x00, mode & 0xdf); /* No interrupt! */ | ||
1546 | |||
1547 | voices[voice].offset_pending = 0; | ||
1548 | voices[voice].kill_pending = 0; | ||
1549 | voices[voice].volume_irq_mode = 0; | ||
1550 | voices[voice].loop_irq_mode = 0; | ||
1551 | |||
1552 | if (voices[voice].sample_pending >= 0) | ||
1553 | { | ||
1554 | spin_unlock_irqrestore(&gus_lock,flags); /* Run temporarily with interrupts enabled */ | ||
1555 | guswave_set_instr(voices[voice].dev_pending, voice, voices[voice].sample_pending); | ||
1556 | voices[voice].sample_pending = -1; | ||
1557 | spin_lock_irqsave(&gus_lock,flags); | ||
1558 | gus_select_voice(voice); /* Reselect the voice (just to be sure) */ | ||
1559 | } | ||
1560 | if ((mode & 0x01) || (int) ((gus_read16(0x09) >> 4) < (unsigned) 2065)) | ||
1561 | { | ||
1562 | ret_val = guswave_start_note2(dev, voice, note_num, volume); | ||
1563 | } | ||
1564 | else | ||
1565 | { | ||
1566 | voices[voice].dev_pending = dev; | ||
1567 | voices[voice].note_pending = note_num; | ||
1568 | voices[voice].volume_pending = volume; | ||
1569 | voices[voice].volume_irq_mode = VMODE_START_NOTE; | ||
1570 | |||
1571 | gus_rampoff(); | ||
1572 | gus_ramp_range(2000, 4065); | ||
1573 | gus_ramp_rate(0, 63); /* Fastest possible rate */ | ||
1574 | gus_rampon(0x20 | 0x40); /* Ramp down, once, irq */ | ||
1575 | } | ||
1576 | } | ||
1577 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1578 | return ret_val; | ||
1579 | } | ||
1580 | |||
1581 | static void guswave_reset(int dev) | ||
1582 | { | ||
1583 | int i; | ||
1584 | |||
1585 | for (i = 0; i < 32; i++) | ||
1586 | { | ||
1587 | gus_voice_init(i); | ||
1588 | gus_voice_init2(i); | ||
1589 | } | ||
1590 | } | ||
1591 | |||
1592 | static int guswave_open(int dev, int mode) | ||
1593 | { | ||
1594 | int err; | ||
1595 | |||
1596 | if (gus_busy) | ||
1597 | return -EBUSY; | ||
1598 | |||
1599 | voice_alloc->timestamp = 0; | ||
1600 | |||
1601 | if (gus_no_wave_dma) { | ||
1602 | gus_no_dma = 1; | ||
1603 | } else { | ||
1604 | if ((err = DMAbuf_open_dma(gus_devnum)) < 0) | ||
1605 | { | ||
1606 | /* printk( "GUS: Loading samples without DMA\n"); */ | ||
1607 | gus_no_dma = 1; /* Upload samples using PIO */ | ||
1608 | } | ||
1609 | else | ||
1610 | gus_no_dma = 0; | ||
1611 | } | ||
1612 | |||
1613 | init_waitqueue_head(&dram_sleeper); | ||
1614 | gus_busy = 1; | ||
1615 | active_device = GUS_DEV_WAVE; | ||
1616 | |||
1617 | gusintr(gus_irq, (void *)gus_hw_config, NULL); /* Serve pending interrupts */ | ||
1618 | gus_initialize(); | ||
1619 | gus_reset(); | ||
1620 | gusintr(gus_irq, (void *)gus_hw_config, NULL); /* Serve pending interrupts */ | ||
1621 | |||
1622 | return 0; | ||
1623 | } | ||
1624 | |||
1625 | static void guswave_close(int dev) | ||
1626 | { | ||
1627 | gus_busy = 0; | ||
1628 | active_device = 0; | ||
1629 | gus_reset(); | ||
1630 | |||
1631 | if (!gus_no_dma) | ||
1632 | DMAbuf_close_dma(gus_devnum); | ||
1633 | } | ||
1634 | |||
1635 | static int guswave_load_patch(int dev, int format, const char __user *addr, | ||
1636 | int offs, int count, int pmgr_flag) | ||
1637 | { | ||
1638 | struct patch_info patch; | ||
1639 | int instr; | ||
1640 | long sizeof_patch; | ||
1641 | |||
1642 | unsigned long blk_sz, blk_end, left, src_offs, target; | ||
1643 | |||
1644 | sizeof_patch = (long) &patch.data[0] - (long) &patch; /* Header size */ | ||
1645 | |||
1646 | if (format != GUS_PATCH) | ||
1647 | { | ||
1648 | /* printk("GUS Error: Invalid patch format (key) 0x%x\n", format);*/ | ||
1649 | return -EINVAL; | ||
1650 | } | ||
1651 | if (count < sizeof_patch) | ||
1652 | { | ||
1653 | /* printk("GUS Error: Patch header too short\n");*/ | ||
1654 | return -EINVAL; | ||
1655 | } | ||
1656 | count -= sizeof_patch; | ||
1657 | |||
1658 | if (free_sample >= MAX_SAMPLE) | ||
1659 | { | ||
1660 | /* printk("GUS: Sample table full\n");*/ | ||
1661 | return -ENOSPC; | ||
1662 | } | ||
1663 | /* | ||
1664 | * Copy the header from user space but ignore the first bytes which have | ||
1665 | * been transferred already. | ||
1666 | */ | ||
1667 | |||
1668 | if (copy_from_user(&((char *) &patch)[offs], &(addr)[offs], | ||
1669 | sizeof_patch - offs)) | ||
1670 | return -EFAULT; | ||
1671 | |||
1672 | if (patch.mode & WAVE_ROM) | ||
1673 | return -EINVAL; | ||
1674 | if (gus_mem_size == 0) | ||
1675 | return -ENOSPC; | ||
1676 | |||
1677 | instr = patch.instr_no; | ||
1678 | |||
1679 | if (instr < 0 || instr > MAX_PATCH) | ||
1680 | { | ||
1681 | /* printk(KERN_ERR "GUS: Invalid patch number %d\n", instr);*/ | ||
1682 | return -EINVAL; | ||
1683 | } | ||
1684 | if (count < patch.len) | ||
1685 | { | ||
1686 | /* printk(KERN_ERR "GUS Warning: Patch record too short (%d<%d)\n", count, (int) patch.len);*/ | ||
1687 | patch.len = count; | ||
1688 | } | ||
1689 | if (patch.len <= 0 || patch.len > gus_mem_size) | ||
1690 | { | ||
1691 | /* printk(KERN_ERR "GUS: Invalid sample length %d\n", (int) patch.len);*/ | ||
1692 | return -EINVAL; | ||
1693 | } | ||
1694 | if (patch.mode & WAVE_LOOPING) | ||
1695 | { | ||
1696 | if (patch.loop_start < 0 || patch.loop_start >= patch.len) | ||
1697 | { | ||
1698 | /* printk(KERN_ERR "GUS: Invalid loop start\n");*/ | ||
1699 | return -EINVAL; | ||
1700 | } | ||
1701 | if (patch.loop_end < patch.loop_start || patch.loop_end > patch.len) | ||
1702 | { | ||
1703 | /* printk(KERN_ERR "GUS: Invalid loop end\n");*/ | ||
1704 | return -EINVAL; | ||
1705 | } | ||
1706 | } | ||
1707 | free_mem_ptr = (free_mem_ptr + 31) & ~31; /* 32 byte alignment */ | ||
1708 | |||
1709 | if (patch.mode & WAVE_16_BITS) | ||
1710 | { | ||
1711 | /* | ||
1712 | * 16 bit samples must fit one 256k bank. | ||
1713 | */ | ||
1714 | if (patch.len >= GUS_BANK_SIZE) | ||
1715 | { | ||
1716 | /* printk("GUS: Sample (16 bit) too long %d\n", (int) patch.len);*/ | ||
1717 | return -ENOSPC; | ||
1718 | } | ||
1719 | if ((free_mem_ptr / GUS_BANK_SIZE) != | ||
1720 | ((free_mem_ptr + patch.len) / GUS_BANK_SIZE)) | ||
1721 | { | ||
1722 | unsigned long tmp_mem = | ||
1723 | /* Align to 256K */ | ||
1724 | ((free_mem_ptr / GUS_BANK_SIZE) + 1) * GUS_BANK_SIZE; | ||
1725 | |||
1726 | if ((tmp_mem + patch.len) > gus_mem_size) | ||
1727 | return -ENOSPC; | ||
1728 | |||
1729 | free_mem_ptr = tmp_mem; /* This leaves unusable memory */ | ||
1730 | } | ||
1731 | } | ||
1732 | if ((free_mem_ptr + patch.len) > gus_mem_size) | ||
1733 | return -ENOSPC; | ||
1734 | |||
1735 | sample_ptrs[free_sample] = free_mem_ptr; | ||
1736 | |||
1737 | /* | ||
1738 | * Tremolo is not possible with envelopes | ||
1739 | */ | ||
1740 | |||
1741 | if (patch.mode & WAVE_ENVELOPES) | ||
1742 | patch.mode &= ~WAVE_TREMOLO; | ||
1743 | |||
1744 | if (!(patch.mode & WAVE_FRACTIONS)) | ||
1745 | { | ||
1746 | patch.fractions = 0; | ||
1747 | } | ||
1748 | memcpy((char *) &samples[free_sample], &patch, sizeof_patch); | ||
1749 | |||
1750 | /* | ||
1751 | * Link this_one sample to the list of samples for patch 'instr'. | ||
1752 | */ | ||
1753 | |||
1754 | samples[free_sample].key = patch_table[instr]; | ||
1755 | patch_table[instr] = free_sample; | ||
1756 | |||
1757 | /* | ||
1758 | * Use DMA to transfer the wave data to the DRAM | ||
1759 | */ | ||
1760 | |||
1761 | left = patch.len; | ||
1762 | src_offs = 0; | ||
1763 | target = free_mem_ptr; | ||
1764 | |||
1765 | while (left) /* Not completely transferred yet */ | ||
1766 | { | ||
1767 | blk_sz = audio_devs[gus_devnum]->dmap_out->bytes_in_use; | ||
1768 | if (blk_sz > left) | ||
1769 | blk_sz = left; | ||
1770 | |||
1771 | /* | ||
1772 | * DMA cannot cross bank (256k) boundaries. Check for that. | ||
1773 | */ | ||
1774 | |||
1775 | blk_end = target + blk_sz; | ||
1776 | |||
1777 | if ((target / GUS_BANK_SIZE) != (blk_end / GUS_BANK_SIZE)) | ||
1778 | { | ||
1779 | /* Split the block */ | ||
1780 | blk_end &= ~(GUS_BANK_SIZE - 1); | ||
1781 | blk_sz = blk_end - target; | ||
1782 | } | ||
1783 | if (gus_no_dma) | ||
1784 | { | ||
1785 | /* | ||
1786 | * For some reason the DMA is not possible. We have to use PIO. | ||
1787 | */ | ||
1788 | long i; | ||
1789 | unsigned char data; | ||
1790 | |||
1791 | for (i = 0; i < blk_sz; i++) | ||
1792 | { | ||
1793 | get_user(*(unsigned char *) &data, (unsigned char __user *) &((addr)[sizeof_patch + i])); | ||
1794 | if (patch.mode & WAVE_UNSIGNED) | ||
1795 | if (!(patch.mode & WAVE_16_BITS) || (i & 0x01)) | ||
1796 | data ^= 0x80; /* Convert to signed */ | ||
1797 | gus_poke(target + i, data); | ||
1798 | } | ||
1799 | } | ||
1800 | else | ||
1801 | { | ||
1802 | unsigned long address, hold_address; | ||
1803 | unsigned char dma_command; | ||
1804 | unsigned long flags; | ||
1805 | |||
1806 | if (audio_devs[gus_devnum]->dmap_out->raw_buf == NULL) | ||
1807 | { | ||
1808 | printk(KERN_ERR "GUS: DMA buffer == NULL\n"); | ||
1809 | return -ENOSPC; | ||
1810 | } | ||
1811 | /* | ||
1812 | * OK, move now. First in and then out. | ||
1813 | */ | ||
1814 | |||
1815 | if (copy_from_user(audio_devs[gus_devnum]->dmap_out->raw_buf, | ||
1816 | &(addr)[sizeof_patch + src_offs], | ||
1817 | blk_sz)) | ||
1818 | return -EFAULT; | ||
1819 | |||
1820 | spin_lock_irqsave(&gus_lock,flags); | ||
1821 | gus_write8(0x41, 0); /* Disable GF1 DMA */ | ||
1822 | DMAbuf_start_dma(gus_devnum, audio_devs[gus_devnum]->dmap_out->raw_buf_phys, | ||
1823 | blk_sz, DMA_MODE_WRITE); | ||
1824 | |||
1825 | /* | ||
1826 | * Set the DRAM address for the wave data | ||
1827 | */ | ||
1828 | |||
1829 | if (iw_mode) | ||
1830 | { | ||
1831 | /* Different address translation in enhanced mode */ | ||
1832 | |||
1833 | unsigned char hi; | ||
1834 | |||
1835 | if (gus_dma > 4) | ||
1836 | address = target >> 1; /* Convert to 16 bit word address */ | ||
1837 | else | ||
1838 | address = target; | ||
1839 | |||
1840 | hi = (unsigned char) ((address >> 16) & 0xf0); | ||
1841 | hi += (unsigned char) (address & 0x0f); | ||
1842 | |||
1843 | gus_write16(0x42, (address >> 4) & 0xffff); /* DMA address (low) */ | ||
1844 | gus_write8(0x50, hi); | ||
1845 | } | ||
1846 | else | ||
1847 | { | ||
1848 | address = target; | ||
1849 | if (audio_devs[gus_devnum]->dmap_out->dma > 3) | ||
1850 | { | ||
1851 | hold_address = address; | ||
1852 | address = address >> 1; | ||
1853 | address &= 0x0001ffffL; | ||
1854 | address |= (hold_address & 0x000c0000L); | ||
1855 | } | ||
1856 | gus_write16(0x42, (address >> 4) & 0xffff); /* DRAM DMA address */ | ||
1857 | } | ||
1858 | |||
1859 | /* | ||
1860 | * Start the DMA transfer | ||
1861 | */ | ||
1862 | |||
1863 | dma_command = 0x21; /* IRQ enable, DMA start */ | ||
1864 | if (patch.mode & WAVE_UNSIGNED) | ||
1865 | dma_command |= 0x80; /* Invert MSB */ | ||
1866 | if (patch.mode & WAVE_16_BITS) | ||
1867 | dma_command |= 0x40; /* 16 bit _DATA_ */ | ||
1868 | if (audio_devs[gus_devnum]->dmap_out->dma > 3) | ||
1869 | dma_command |= 0x04; /* 16 bit DMA _channel_ */ | ||
1870 | |||
1871 | /* | ||
1872 | * Sleep here until the DRAM DMA done interrupt is served | ||
1873 | */ | ||
1874 | active_device = GUS_DEV_WAVE; | ||
1875 | gus_write8(0x41, dma_command); /* Lets go luteet (=bugs) */ | ||
1876 | |||
1877 | spin_unlock_irqrestore(&gus_lock,flags); /* opens a race */ | ||
1878 | if (!interruptible_sleep_on_timeout(&dram_sleeper, HZ)) | ||
1879 | printk("GUS: DMA Transfer timed out\n"); | ||
1880 | } | ||
1881 | |||
1882 | /* | ||
1883 | * Now the next part | ||
1884 | */ | ||
1885 | |||
1886 | left -= blk_sz; | ||
1887 | src_offs += blk_sz; | ||
1888 | target += blk_sz; | ||
1889 | |||
1890 | gus_write8(0x41, 0); /* Stop DMA */ | ||
1891 | } | ||
1892 | |||
1893 | free_mem_ptr += patch.len; | ||
1894 | free_sample++; | ||
1895 | return 0; | ||
1896 | } | ||
1897 | |||
1898 | static void guswave_hw_control(int dev, unsigned char *event_rec) | ||
1899 | { | ||
1900 | int voice, cmd; | ||
1901 | unsigned short p1, p2; | ||
1902 | unsigned int plong; | ||
1903 | unsigned long flags; | ||
1904 | |||
1905 | cmd = event_rec[2]; | ||
1906 | voice = event_rec[3]; | ||
1907 | p1 = *(unsigned short *) &event_rec[4]; | ||
1908 | p2 = *(unsigned short *) &event_rec[6]; | ||
1909 | plong = *(unsigned int *) &event_rec[4]; | ||
1910 | |||
1911 | if ((voices[voice].volume_irq_mode == VMODE_START_NOTE) && | ||
1912 | (cmd != _GUS_VOICESAMPLE) && (cmd != _GUS_VOICE_POS)) | ||
1913 | do_volume_irq(voice); | ||
1914 | |||
1915 | switch (cmd) | ||
1916 | { | ||
1917 | case _GUS_NUMVOICES: | ||
1918 | spin_lock_irqsave(&gus_lock,flags); | ||
1919 | gus_select_voice(voice); | ||
1920 | gus_select_max_voices(p1); | ||
1921 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1922 | break; | ||
1923 | |||
1924 | case _GUS_VOICESAMPLE: | ||
1925 | guswave_set_instr(dev, voice, p1); | ||
1926 | break; | ||
1927 | |||
1928 | case _GUS_VOICEON: | ||
1929 | spin_lock_irqsave(&gus_lock,flags); | ||
1930 | gus_select_voice(voice); | ||
1931 | p1 &= ~0x20; /* Don't allow interrupts */ | ||
1932 | gus_voice_on(p1); | ||
1933 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1934 | break; | ||
1935 | |||
1936 | case _GUS_VOICEOFF: | ||
1937 | spin_lock_irqsave(&gus_lock,flags); | ||
1938 | gus_select_voice(voice); | ||
1939 | gus_voice_off(); | ||
1940 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1941 | break; | ||
1942 | |||
1943 | case _GUS_VOICEFADE: | ||
1944 | gus_voice_fade(voice); | ||
1945 | break; | ||
1946 | |||
1947 | case _GUS_VOICEMODE: | ||
1948 | spin_lock_irqsave(&gus_lock,flags); | ||
1949 | gus_select_voice(voice); | ||
1950 | p1 &= ~0x20; /* Don't allow interrupts */ | ||
1951 | gus_voice_mode(p1); | ||
1952 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1953 | break; | ||
1954 | |||
1955 | case _GUS_VOICEBALA: | ||
1956 | spin_lock_irqsave(&gus_lock,flags); | ||
1957 | gus_select_voice(voice); | ||
1958 | gus_voice_balance(p1); | ||
1959 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1960 | break; | ||
1961 | |||
1962 | case _GUS_VOICEFREQ: | ||
1963 | spin_lock_irqsave(&gus_lock,flags); | ||
1964 | gus_select_voice(voice); | ||
1965 | gus_voice_freq(plong); | ||
1966 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1967 | break; | ||
1968 | |||
1969 | case _GUS_VOICEVOL: | ||
1970 | spin_lock_irqsave(&gus_lock,flags); | ||
1971 | gus_select_voice(voice); | ||
1972 | gus_voice_volume(p1); | ||
1973 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1974 | break; | ||
1975 | |||
1976 | case _GUS_VOICEVOL2: /* Just update the software voice level */ | ||
1977 | voices[voice].initial_volume = voices[voice].current_volume = p1; | ||
1978 | break; | ||
1979 | |||
1980 | case _GUS_RAMPRANGE: | ||
1981 | if (voices[voice].mode & WAVE_ENVELOPES) | ||
1982 | break; /* NO-NO */ | ||
1983 | spin_lock_irqsave(&gus_lock,flags); | ||
1984 | gus_select_voice(voice); | ||
1985 | gus_ramp_range(p1, p2); | ||
1986 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1987 | break; | ||
1988 | |||
1989 | case _GUS_RAMPRATE: | ||
1990 | if (voices[voice].mode & WAVE_ENVELOPES) | ||
1991 | break; /* NJET-NJET */ | ||
1992 | spin_lock_irqsave(&gus_lock,flags); | ||
1993 | gus_select_voice(voice); | ||
1994 | gus_ramp_rate(p1, p2); | ||
1995 | spin_unlock_irqrestore(&gus_lock,flags); | ||
1996 | break; | ||
1997 | |||
1998 | case _GUS_RAMPMODE: | ||
1999 | if (voices[voice].mode & WAVE_ENVELOPES) | ||
2000 | break; /* NO-NO */ | ||
2001 | spin_lock_irqsave(&gus_lock,flags); | ||
2002 | gus_select_voice(voice); | ||
2003 | p1 &= ~0x20; /* Don't allow interrupts */ | ||
2004 | gus_ramp_mode(p1); | ||
2005 | spin_unlock_irqrestore(&gus_lock,flags); | ||
2006 | break; | ||
2007 | |||
2008 | case _GUS_RAMPON: | ||
2009 | if (voices[voice].mode & WAVE_ENVELOPES) | ||
2010 | break; /* EI-EI */ | ||
2011 | spin_lock_irqsave(&gus_lock,flags); | ||
2012 | gus_select_voice(voice); | ||
2013 | p1 &= ~0x20; /* Don't allow interrupts */ | ||
2014 | gus_rampon(p1); | ||
2015 | spin_unlock_irqrestore(&gus_lock,flags); | ||
2016 | break; | ||
2017 | |||
2018 | case _GUS_RAMPOFF: | ||
2019 | if (voices[voice].mode & WAVE_ENVELOPES) | ||
2020 | break; /* NEJ-NEJ */ | ||
2021 | spin_lock_irqsave(&gus_lock,flags); | ||
2022 | gus_select_voice(voice); | ||
2023 | gus_rampoff(); | ||
2024 | spin_unlock_irqrestore(&gus_lock,flags); | ||
2025 | break; | ||
2026 | |||
2027 | case _GUS_VOLUME_SCALE: | ||
2028 | volume_base = p1; | ||
2029 | volume_scale = p2; | ||
2030 | break; | ||
2031 | |||
2032 | case _GUS_VOICE_POS: | ||
2033 | spin_lock_irqsave(&gus_lock,flags); | ||
2034 | gus_select_voice(voice); | ||
2035 | gus_set_voice_pos(voice, plong); | ||
2036 | spin_unlock_irqrestore(&gus_lock,flags); | ||
2037 | break; | ||
2038 | |||
2039 | default: | ||
2040 | break; | ||
2041 | } | ||
2042 | } | ||
2043 | |||
2044 | static int gus_audio_set_speed(int speed) | ||
2045 | { | ||
2046 | if (speed <= 0) | ||
2047 | speed = gus_audio_speed; | ||
2048 | |||
2049 | if (speed < 4000) | ||
2050 | speed = 4000; | ||
2051 | |||
2052 | if (speed > 44100) | ||
2053 | speed = 44100; | ||
2054 | |||
2055 | gus_audio_speed = speed; | ||
2056 | |||
2057 | if (only_read_access) | ||
2058 | { | ||
2059 | /* Compute nearest valid recording speed and return it */ | ||
2060 | |||
2061 | /* speed = (9878400 / (gus_audio_speed + 2)) / 16; */ | ||
2062 | speed = (((9878400 + gus_audio_speed / 2) / (gus_audio_speed + 2)) + 8) / 16; | ||
2063 | speed = (9878400 / (speed * 16)) - 2; | ||
2064 | } | ||
2065 | return speed; | ||
2066 | } | ||
2067 | |||
2068 | static int gus_audio_set_channels(int channels) | ||
2069 | { | ||
2070 | if (!channels) | ||
2071 | return gus_audio_channels; | ||
2072 | if (channels > 2) | ||
2073 | channels = 2; | ||
2074 | if (channels < 1) | ||
2075 | channels = 1; | ||
2076 | gus_audio_channels = channels; | ||
2077 | return channels; | ||
2078 | } | ||
2079 | |||
2080 | static int gus_audio_set_bits(int bits) | ||
2081 | { | ||
2082 | if (!bits) | ||
2083 | return gus_audio_bits; | ||
2084 | |||
2085 | if (bits != 8 && bits != 16) | ||
2086 | bits = 8; | ||
2087 | |||
2088 | if (only_8_bits) | ||
2089 | bits = 8; | ||
2090 | |||
2091 | gus_audio_bits = bits; | ||
2092 | return bits; | ||
2093 | } | ||
2094 | |||
2095 | static int gus_audio_ioctl(int dev, unsigned int cmd, void __user *arg) | ||
2096 | { | ||
2097 | int val; | ||
2098 | |||
2099 | switch (cmd) | ||
2100 | { | ||
2101 | case SOUND_PCM_WRITE_RATE: | ||
2102 | if (get_user(val, (int __user*)arg)) | ||
2103 | return -EFAULT; | ||
2104 | val = gus_audio_set_speed(val); | ||
2105 | break; | ||
2106 | |||
2107 | case SOUND_PCM_READ_RATE: | ||
2108 | val = gus_audio_speed; | ||
2109 | break; | ||
2110 | |||
2111 | case SNDCTL_DSP_STEREO: | ||
2112 | if (get_user(val, (int __user *)arg)) | ||
2113 | return -EFAULT; | ||
2114 | val = gus_audio_set_channels(val + 1) - 1; | ||
2115 | break; | ||
2116 | |||
2117 | case SOUND_PCM_WRITE_CHANNELS: | ||
2118 | if (get_user(val, (int __user *)arg)) | ||
2119 | return -EFAULT; | ||
2120 | val = gus_audio_set_channels(val); | ||
2121 | break; | ||
2122 | |||
2123 | case SOUND_PCM_READ_CHANNELS: | ||
2124 | val = gus_audio_channels; | ||
2125 | break; | ||
2126 | |||
2127 | case SNDCTL_DSP_SETFMT: | ||
2128 | if (get_user(val, (int __user *)arg)) | ||
2129 | return -EFAULT; | ||
2130 | val = gus_audio_set_bits(val); | ||
2131 | break; | ||
2132 | |||
2133 | case SOUND_PCM_READ_BITS: | ||
2134 | val = gus_audio_bits; | ||
2135 | break; | ||
2136 | |||
2137 | case SOUND_PCM_WRITE_FILTER: /* NOT POSSIBLE */ | ||
2138 | case SOUND_PCM_READ_FILTER: | ||
2139 | val = -EINVAL; | ||
2140 | break; | ||
2141 | default: | ||
2142 | return -EINVAL; | ||
2143 | } | ||
2144 | return put_user(val, (int __user *)arg); | ||
2145 | } | ||
2146 | |||
2147 | static void gus_audio_reset(int dev) | ||
2148 | { | ||
2149 | if (recording_active) | ||
2150 | { | ||
2151 | gus_write8(0x49, 0x00); /* Halt recording */ | ||
2152 | set_input_volumes(); | ||
2153 | } | ||
2154 | } | ||
2155 | |||
2156 | static int saved_iw_mode; /* A hack hack hack */ | ||
2157 | |||
2158 | static int gus_audio_open(int dev, int mode) | ||
2159 | { | ||
2160 | if (gus_busy) | ||
2161 | return -EBUSY; | ||
2162 | |||
2163 | if (gus_pnp_flag && mode & OPEN_READ) | ||
2164 | { | ||
2165 | /* printk(KERN_ERR "GUS: Audio device #%d is playback only.\n", dev);*/ | ||
2166 | return -EIO; | ||
2167 | } | ||
2168 | gus_initialize(); | ||
2169 | |||
2170 | gus_busy = 1; | ||
2171 | active_device = 0; | ||
2172 | |||
2173 | saved_iw_mode = iw_mode; | ||
2174 | if (iw_mode) | ||
2175 | { | ||
2176 | /* There are some problems with audio in enhanced mode so disable it */ | ||
2177 | gus_write8(0x19, gus_read8(0x19) & ~0x01); /* Disable enhanced mode */ | ||
2178 | iw_mode = 0; | ||
2179 | } | ||
2180 | |||
2181 | gus_reset(); | ||
2182 | reset_sample_memory(); | ||
2183 | gus_select_max_voices(14); | ||
2184 | |||
2185 | pcm_active = 0; | ||
2186 | dma_active = 0; | ||
2187 | pcm_opened = 1; | ||
2188 | if (mode & OPEN_READ) | ||
2189 | { | ||
2190 | recording_active = 1; | ||
2191 | set_input_volumes(); | ||
2192 | } | ||
2193 | only_read_access = !(mode & OPEN_WRITE); | ||
2194 | only_8_bits = mode & OPEN_READ; | ||
2195 | if (only_8_bits) | ||
2196 | audio_devs[dev]->format_mask = AFMT_U8; | ||
2197 | else | ||
2198 | audio_devs[dev]->format_mask = AFMT_U8 | AFMT_S16_LE; | ||
2199 | |||
2200 | return 0; | ||
2201 | } | ||
2202 | |||
2203 | static void gus_audio_close(int dev) | ||
2204 | { | ||
2205 | iw_mode = saved_iw_mode; | ||
2206 | gus_reset(); | ||
2207 | gus_busy = 0; | ||
2208 | pcm_opened = 0; | ||
2209 | active_device = 0; | ||
2210 | |||
2211 | if (recording_active) | ||
2212 | { | ||
2213 | gus_write8(0x49, 0x00); /* Halt recording */ | ||
2214 | set_input_volumes(); | ||
2215 | } | ||
2216 | recording_active = 0; | ||
2217 | } | ||
2218 | |||
2219 | static void gus_audio_update_volume(void) | ||
2220 | { | ||
2221 | unsigned long flags; | ||
2222 | int voice; | ||
2223 | |||
2224 | if (pcm_active && pcm_opened) | ||
2225 | for (voice = 0; voice < gus_audio_channels; voice++) | ||
2226 | { | ||
2227 | spin_lock_irqsave(&gus_lock,flags); | ||
2228 | gus_select_voice(voice); | ||
2229 | gus_rampoff(); | ||
2230 | gus_voice_volume(1530 + (25 * gus_pcm_volume)); | ||
2231 | gus_ramp_range(65, 1530 + (25 * gus_pcm_volume)); | ||
2232 | spin_unlock_irqrestore(&gus_lock,flags); | ||
2233 | } | ||
2234 | } | ||
2235 | |||
2236 | static void play_next_pcm_block(void) | ||
2237 | { | ||
2238 | unsigned long flags; | ||
2239 | int speed = gus_audio_speed; | ||
2240 | int this_one, is16bits, chn; | ||
2241 | unsigned long dram_loc; | ||
2242 | unsigned char mode[2], ramp_mode[2]; | ||
2243 | |||
2244 | if (!pcm_qlen) | ||
2245 | return; | ||
2246 | |||
2247 | this_one = pcm_head; | ||
2248 | |||
2249 | for (chn = 0; chn < gus_audio_channels; chn++) | ||
2250 | { | ||
2251 | mode[chn] = 0x00; | ||
2252 | ramp_mode[chn] = 0x03; /* Ramping and rollover off */ | ||
2253 | |||
2254 | if (chn == 0) | ||
2255 | { | ||
2256 | mode[chn] |= 0x20; /* Loop IRQ */ | ||
2257 | voices[chn].loop_irq_mode = LMODE_PCM; | ||
2258 | } | ||
2259 | if (gus_audio_bits != 8) | ||
2260 | { | ||
2261 | is16bits = 1; | ||
2262 | mode[chn] |= 0x04; /* 16 bit data */ | ||
2263 | } | ||
2264 | else | ||
2265 | is16bits = 0; | ||
2266 | |||
2267 | dram_loc = this_one * pcm_bsize; | ||
2268 | dram_loc += chn * pcm_banksize; | ||
2269 | |||
2270 | if (this_one == (pcm_nblk - 1)) /* Last fragment of the DRAM buffer */ | ||
2271 | { | ||
2272 | mode[chn] |= 0x08; /* Enable loop */ | ||
2273 | ramp_mode[chn] = 0x03; /* Disable rollover bit */ | ||
2274 | } | ||
2275 | else | ||
2276 | { | ||
2277 | if (chn == 0) | ||
2278 | ramp_mode[chn] = 0x04; /* Enable rollover bit */ | ||
2279 | } | ||
2280 | spin_lock_irqsave(&gus_lock,flags); | ||
2281 | gus_select_voice(chn); | ||
2282 | gus_voice_freq(speed); | ||
2283 | |||
2284 | if (gus_audio_channels == 1) | ||
2285 | gus_voice_balance(7); /* mono */ | ||
2286 | else if (chn == 0) | ||
2287 | gus_voice_balance(0); /* left */ | ||
2288 | else | ||
2289 | gus_voice_balance(15); /* right */ | ||
2290 | |||
2291 | if (!pcm_active) /* Playback not already active */ | ||
2292 | { | ||
2293 | /* | ||
2294 | * The playback was not started yet (or there has been a pause). | ||
2295 | * Start the voice (again) and ask for a rollover irq at the end of | ||
2296 | * this_one block. If this_one one is last of the buffers, use just | ||
2297 | * the normal loop with irq. | ||
2298 | */ | ||
2299 | |||
2300 | gus_voice_off(); | ||
2301 | gus_rampoff(); | ||
2302 | gus_voice_volume(1530 + (25 * gus_pcm_volume)); | ||
2303 | gus_ramp_range(65, 1530 + (25 * gus_pcm_volume)); | ||
2304 | |||
2305 | gus_write_addr(0x0a, chn * pcm_banksize, 0, is16bits); /* Starting position */ | ||
2306 | gus_write_addr(0x02, chn * pcm_banksize, 0, is16bits); /* Loop start */ | ||
2307 | |||
2308 | if (chn != 0) | ||
2309 | gus_write_addr(0x04, pcm_banksize + (pcm_bsize * pcm_nblk) - 1, | ||
2310 | 0, is16bits); /* Loop end location */ | ||
2311 | } | ||
2312 | if (chn == 0) | ||
2313 | gus_write_addr(0x04, dram_loc + pcm_bsize - 1, | ||
2314 | 0, is16bits); /* Loop end location */ | ||
2315 | else | ||
2316 | mode[chn] |= 0x08; /* Enable looping */ | ||
2317 | spin_unlock_irqrestore(&gus_lock,flags); | ||
2318 | } | ||
2319 | for (chn = 0; chn < gus_audio_channels; chn++) | ||
2320 | { | ||
2321 | spin_lock_irqsave(&gus_lock,flags); | ||
2322 | gus_select_voice(chn); | ||
2323 | gus_write8(0x0d, ramp_mode[chn]); | ||
2324 | if (iw_mode) | ||
2325 | gus_write8(0x15, 0x00); /* Reset voice deactivate bit of SMSI */ | ||
2326 | gus_voice_on(mode[chn]); | ||
2327 | spin_unlock_irqrestore(&gus_lock,flags); | ||
2328 | } | ||
2329 | pcm_active = 1; | ||
2330 | } | ||
2331 | |||
2332 | static void gus_transfer_output_block(int dev, unsigned long buf, | ||
2333 | int total_count, int intrflag, int chn) | ||
2334 | { | ||
2335 | /* | ||
2336 | * This routine transfers one block of audio data to the DRAM. In mono mode | ||
2337 | * it's called just once. When in stereo mode, this_one routine is called | ||
2338 | * once for both channels. | ||
2339 | * | ||
2340 | * The left/mono channel data is transferred to the beginning of dram and the | ||
2341 | * right data to the area pointed by gus_page_size. | ||
2342 | */ | ||
2343 | |||
2344 | int this_one, count; | ||
2345 | unsigned long flags; | ||
2346 | unsigned char dma_command; | ||
2347 | unsigned long address, hold_address; | ||
2348 | |||
2349 | spin_lock_irqsave(&gus_lock,flags); | ||
2350 | |||
2351 | count = total_count / gus_audio_channels; | ||
2352 | |||
2353 | if (chn == 0) | ||
2354 | { | ||
2355 | if (pcm_qlen >= pcm_nblk) | ||
2356 | printk(KERN_WARNING "GUS Warning: PCM buffers out of sync\n"); | ||
2357 | |||
2358 | this_one = pcm_current_block = pcm_tail; | ||
2359 | pcm_qlen++; | ||
2360 | pcm_tail = (pcm_tail + 1) % pcm_nblk; | ||
2361 | pcm_datasize[this_one] = count; | ||
2362 | } | ||
2363 | else | ||
2364 | this_one = pcm_current_block; | ||
2365 | |||
2366 | gus_write8(0x41, 0); /* Disable GF1 DMA */ | ||
2367 | DMAbuf_start_dma(dev, buf + (chn * count), count, DMA_MODE_WRITE); | ||
2368 | |||
2369 | address = this_one * pcm_bsize; | ||
2370 | address += chn * pcm_banksize; | ||
2371 | |||
2372 | if (audio_devs[dev]->dmap_out->dma > 3) | ||
2373 | { | ||
2374 | hold_address = address; | ||
2375 | address = address >> 1; | ||
2376 | address &= 0x0001ffffL; | ||
2377 | address |= (hold_address & 0x000c0000L); | ||
2378 | } | ||
2379 | gus_write16(0x42, (address >> 4) & 0xffff); /* DRAM DMA address */ | ||
2380 | |||
2381 | dma_command = 0x21; /* IRQ enable, DMA start */ | ||
2382 | |||
2383 | if (gus_audio_bits != 8) | ||
2384 | dma_command |= 0x40; /* 16 bit _DATA_ */ | ||
2385 | else | ||
2386 | dma_command |= 0x80; /* Invert MSB */ | ||
2387 | |||
2388 | if (audio_devs[dev]->dmap_out->dma > 3) | ||
2389 | dma_command |= 0x04; /* 16 bit DMA channel */ | ||
2390 | |||
2391 | gus_write8(0x41, dma_command); /* Kick start */ | ||
2392 | |||
2393 | if (chn == (gus_audio_channels - 1)) /* Last channel */ | ||
2394 | { | ||
2395 | /* | ||
2396 | * Last (right or mono) channel data | ||
2397 | */ | ||
2398 | dma_active = 1; /* DMA started. There is a unacknowledged buffer */ | ||
2399 | active_device = GUS_DEV_PCM_DONE; | ||
2400 | if (!pcm_active && (pcm_qlen > 1 || count < pcm_bsize)) | ||
2401 | { | ||
2402 | play_next_pcm_block(); | ||
2403 | } | ||
2404 | } | ||
2405 | else | ||
2406 | { | ||
2407 | /* | ||
2408 | * Left channel data. The right channel | ||
2409 | * is transferred after DMA interrupt | ||
2410 | */ | ||
2411 | active_device = GUS_DEV_PCM_CONTINUE; | ||
2412 | } | ||
2413 | |||
2414 | spin_unlock_irqrestore(&gus_lock,flags); | ||
2415 | } | ||
2416 | |||
2417 | static void gus_uninterleave8(char *buf, int l) | ||
2418 | { | ||
2419 | /* This routine uninterleaves 8 bit stereo output (LRLRLR->LLLRRR) */ | ||
2420 | int i, p = 0, halfsize = l / 2; | ||
2421 | char *buf2 = buf + halfsize, *src = bounce_buf; | ||
2422 | |||
2423 | memcpy(bounce_buf, buf, l); | ||
2424 | |||
2425 | for (i = 0; i < halfsize; i++) | ||
2426 | { | ||
2427 | buf[i] = src[p++]; /* Left channel */ | ||
2428 | buf2[i] = src[p++]; /* Right channel */ | ||
2429 | } | ||
2430 | } | ||
2431 | |||
2432 | static void gus_uninterleave16(short *buf, int l) | ||
2433 | { | ||
2434 | /* This routine uninterleaves 16 bit stereo output (LRLRLR->LLLRRR) */ | ||
2435 | int i, p = 0, halfsize = l / 2; | ||
2436 | short *buf2 = buf + halfsize, *src = (short *) bounce_buf; | ||
2437 | |||
2438 | memcpy(bounce_buf, (char *) buf, l * 2); | ||
2439 | |||
2440 | for (i = 0; i < halfsize; i++) | ||
2441 | { | ||
2442 | buf[i] = src[p++]; /* Left channel */ | ||
2443 | buf2[i] = src[p++]; /* Right channel */ | ||
2444 | } | ||
2445 | } | ||
2446 | |||
2447 | static void gus_audio_output_block(int dev, unsigned long buf, int total_count, | ||
2448 | int intrflag) | ||
2449 | { | ||
2450 | struct dma_buffparms *dmap = audio_devs[dev]->dmap_out; | ||
2451 | |||
2452 | dmap->flags |= DMA_NODMA | DMA_NOTIMEOUT; | ||
2453 | |||
2454 | pcm_current_buf = buf; | ||
2455 | pcm_current_count = total_count; | ||
2456 | pcm_current_intrflag = intrflag; | ||
2457 | pcm_current_dev = dev; | ||
2458 | if (gus_audio_channels == 2) | ||
2459 | { | ||
2460 | char *b = dmap->raw_buf + (buf - dmap->raw_buf_phys); | ||
2461 | |||
2462 | if (gus_audio_bits == 8) | ||
2463 | gus_uninterleave8(b, total_count); | ||
2464 | else | ||
2465 | gus_uninterleave16((short *) b, total_count / 2); | ||
2466 | } | ||
2467 | gus_transfer_output_block(dev, buf, total_count, intrflag, 0); | ||
2468 | } | ||
2469 | |||
2470 | static void gus_audio_start_input(int dev, unsigned long buf, int count, | ||
2471 | int intrflag) | ||
2472 | { | ||
2473 | unsigned long flags; | ||
2474 | unsigned char mode; | ||
2475 | |||
2476 | spin_lock_irqsave(&gus_lock,flags); | ||
2477 | |||
2478 | DMAbuf_start_dma(dev, buf, count, DMA_MODE_READ); | ||
2479 | mode = 0xa0; /* DMA IRQ enabled, invert MSB */ | ||
2480 | |||
2481 | if (audio_devs[dev]->dmap_in->dma > 3) | ||
2482 | mode |= 0x04; /* 16 bit DMA channel */ | ||
2483 | if (gus_audio_channels > 1) | ||
2484 | mode |= 0x02; /* Stereo */ | ||
2485 | mode |= 0x01; /* DMA enable */ | ||
2486 | |||
2487 | gus_write8(0x49, mode); | ||
2488 | spin_unlock_irqrestore(&gus_lock,flags); | ||
2489 | } | ||
2490 | |||
2491 | static int gus_audio_prepare_for_input(int dev, int bsize, int bcount) | ||
2492 | { | ||
2493 | unsigned int rate; | ||
2494 | |||
2495 | gus_audio_bsize = bsize; | ||
2496 | audio_devs[dev]->dmap_in->flags |= DMA_NODMA; | ||
2497 | rate = (((9878400 + gus_audio_speed / 2) / (gus_audio_speed + 2)) + 8) / 16; | ||
2498 | |||
2499 | gus_write8(0x48, rate & 0xff); /* Set sampling rate */ | ||
2500 | |||
2501 | if (gus_audio_bits != 8) | ||
2502 | { | ||
2503 | /* printk("GUS Error: 16 bit recording not supported\n");*/ | ||
2504 | return -EINVAL; | ||
2505 | } | ||
2506 | return 0; | ||
2507 | } | ||
2508 | |||
2509 | static int gus_audio_prepare_for_output(int dev, int bsize, int bcount) | ||
2510 | { | ||
2511 | int i; | ||
2512 | |||
2513 | long mem_ptr, mem_size; | ||
2514 | |||
2515 | audio_devs[dev]->dmap_out->flags |= DMA_NODMA | DMA_NOTIMEOUT; | ||
2516 | mem_ptr = 0; | ||
2517 | mem_size = gus_mem_size / gus_audio_channels; | ||
2518 | |||
2519 | if (mem_size > (256 * 1024)) | ||
2520 | mem_size = 256 * 1024; | ||
2521 | |||
2522 | pcm_bsize = bsize / gus_audio_channels; | ||
2523 | pcm_head = pcm_tail = pcm_qlen = 0; | ||
2524 | |||
2525 | pcm_nblk = 2; /* MAX_PCM_BUFFERS; */ | ||
2526 | if ((pcm_bsize * pcm_nblk) > mem_size) | ||
2527 | pcm_nblk = mem_size / pcm_bsize; | ||
2528 | |||
2529 | for (i = 0; i < pcm_nblk; i++) | ||
2530 | pcm_datasize[i] = 0; | ||
2531 | |||
2532 | pcm_banksize = pcm_nblk * pcm_bsize; | ||
2533 | |||
2534 | if (gus_audio_bits != 8 && pcm_banksize == (256 * 1024)) | ||
2535 | pcm_nblk--; | ||
2536 | gus_write8(0x41, 0); /* Disable GF1 DMA */ | ||
2537 | return 0; | ||
2538 | } | ||
2539 | |||
2540 | static int gus_local_qlen(int dev) | ||
2541 | { | ||
2542 | return pcm_qlen; | ||
2543 | } | ||
2544 | |||
2545 | |||
2546 | static struct audio_driver gus_audio_driver = | ||
2547 | { | ||
2548 | .owner = THIS_MODULE, | ||
2549 | .open = gus_audio_open, | ||
2550 | .close = gus_audio_close, | ||
2551 | .output_block = gus_audio_output_block, | ||
2552 | .start_input = gus_audio_start_input, | ||
2553 | .ioctl = gus_audio_ioctl, | ||
2554 | .prepare_for_input = gus_audio_prepare_for_input, | ||
2555 | .prepare_for_output = gus_audio_prepare_for_output, | ||
2556 | .halt_io = gus_audio_reset, | ||
2557 | .local_qlen = gus_local_qlen, | ||
2558 | }; | ||
2559 | |||
2560 | static void guswave_setup_voice(int dev, int voice, int chn) | ||
2561 | { | ||
2562 | struct channel_info *info = &synth_devs[dev]->chn_info[chn]; | ||
2563 | |||
2564 | guswave_set_instr(dev, voice, info->pgm_num); | ||
2565 | voices[voice].expression_vol = info->controllers[CTL_EXPRESSION]; /* Just MSB */ | ||
2566 | voices[voice].main_vol = (info->controllers[CTL_MAIN_VOLUME] * 100) / (unsigned) 128; | ||
2567 | voices[voice].panning = (info->controllers[CTL_PAN] * 2) - 128; | ||
2568 | voices[voice].bender = 0; | ||
2569 | voices[voice].bender_range = info->bender_range; | ||
2570 | |||
2571 | if (chn == 9) | ||
2572 | voices[voice].fixed_pitch = 1; | ||
2573 | } | ||
2574 | |||
2575 | static void guswave_bender(int dev, int voice, int value) | ||
2576 | { | ||
2577 | int freq; | ||
2578 | unsigned long flags; | ||
2579 | |||
2580 | voices[voice].bender = value - 8192; | ||
2581 | freq = compute_finetune(voices[voice].orig_freq, value - 8192, voices[voice].bender_range, 0); | ||
2582 | voices[voice].current_freq = freq; | ||
2583 | |||
2584 | spin_lock_irqsave(&gus_lock,flags); | ||
2585 | gus_select_voice(voice); | ||
2586 | gus_voice_freq(freq); | ||
2587 | spin_unlock_irqrestore(&gus_lock,flags); | ||
2588 | } | ||
2589 | |||
2590 | static int guswave_alloc(int dev, int chn, int note, struct voice_alloc_info *alloc) | ||
2591 | { | ||
2592 | int i, p, best = -1, best_time = 0x7fffffff; | ||
2593 | |||
2594 | p = alloc->ptr; | ||
2595 | /* | ||
2596 | * First look for a completely stopped voice | ||
2597 | */ | ||
2598 | |||
2599 | for (i = 0; i < alloc->max_voice; i++) | ||
2600 | { | ||
2601 | if (alloc->map[p] == 0) | ||
2602 | { | ||
2603 | alloc->ptr = p; | ||
2604 | return p; | ||
2605 | } | ||
2606 | if (alloc->alloc_times[p] < best_time) | ||
2607 | { | ||
2608 | best = p; | ||
2609 | best_time = alloc->alloc_times[p]; | ||
2610 | } | ||
2611 | p = (p + 1) % alloc->max_voice; | ||
2612 | } | ||
2613 | |||
2614 | /* | ||
2615 | * Then look for a releasing voice | ||
2616 | */ | ||
2617 | |||
2618 | for (i = 0; i < alloc->max_voice; i++) | ||
2619 | { | ||
2620 | if (alloc->map[p] == 0xffff) | ||
2621 | { | ||
2622 | alloc->ptr = p; | ||
2623 | return p; | ||
2624 | } | ||
2625 | p = (p + 1) % alloc->max_voice; | ||
2626 | } | ||
2627 | if (best >= 0) | ||
2628 | p = best; | ||
2629 | |||
2630 | alloc->ptr = p; | ||
2631 | return p; | ||
2632 | } | ||
2633 | |||
2634 | static struct synth_operations guswave_operations = | ||
2635 | { | ||
2636 | .owner = THIS_MODULE, | ||
2637 | .id = "GUS", | ||
2638 | .info = &gus_info, | ||
2639 | .midi_dev = 0, | ||
2640 | .synth_type = SYNTH_TYPE_SAMPLE, | ||
2641 | .synth_subtype = SAMPLE_TYPE_GUS, | ||
2642 | .open = guswave_open, | ||
2643 | .close = guswave_close, | ||
2644 | .ioctl = guswave_ioctl, | ||
2645 | .kill_note = guswave_kill_note, | ||
2646 | .start_note = guswave_start_note, | ||
2647 | .set_instr = guswave_set_instr, | ||
2648 | .reset = guswave_reset, | ||
2649 | .hw_control = guswave_hw_control, | ||
2650 | .load_patch = guswave_load_patch, | ||
2651 | .aftertouch = guswave_aftertouch, | ||
2652 | .controller = guswave_controller, | ||
2653 | .panning = guswave_panning, | ||
2654 | .volume_method = guswave_volume_method, | ||
2655 | .bender = guswave_bender, | ||
2656 | .alloc_voice = guswave_alloc, | ||
2657 | .setup_voice = guswave_setup_voice | ||
2658 | }; | ||
2659 | |||
2660 | static void set_input_volumes(void) | ||
2661 | { | ||
2662 | unsigned long flags; | ||
2663 | unsigned char mask = 0xff & ~0x06; /* Just line out enabled */ | ||
2664 | |||
2665 | if (have_gus_max) /* Don't disturb GUS MAX */ | ||
2666 | return; | ||
2667 | |||
2668 | spin_lock_irqsave(&gus_lock,flags); | ||
2669 | |||
2670 | /* | ||
2671 | * Enable channels having vol > 10% | ||
2672 | * Note! bit 0x01 means the line in DISABLED while 0x04 means | ||
2673 | * the mic in ENABLED. | ||
2674 | */ | ||
2675 | if (gus_line_vol > 10) | ||
2676 | mask &= ~0x01; | ||
2677 | if (gus_mic_vol > 10) | ||
2678 | mask |= 0x04; | ||
2679 | |||
2680 | if (recording_active) | ||
2681 | { | ||
2682 | /* | ||
2683 | * Disable channel, if not selected for recording | ||
2684 | */ | ||
2685 | if (!(gus_recmask & SOUND_MASK_LINE)) | ||
2686 | mask |= 0x01; | ||
2687 | if (!(gus_recmask & SOUND_MASK_MIC)) | ||
2688 | mask &= ~0x04; | ||
2689 | } | ||
2690 | mix_image &= ~0x07; | ||
2691 | mix_image |= mask & 0x07; | ||
2692 | outb((mix_image), u_Mixer); | ||
2693 | |||
2694 | spin_unlock_irqrestore(&gus_lock,flags); | ||
2695 | } | ||
2696 | |||
2697 | #define MIX_DEVS (SOUND_MASK_MIC|SOUND_MASK_LINE| \ | ||
2698 | SOUND_MASK_SYNTH|SOUND_MASK_PCM) | ||
2699 | |||
2700 | int gus_default_mixer_ioctl(int dev, unsigned int cmd, void __user *arg) | ||
2701 | { | ||
2702 | int vol, val; | ||
2703 | |||
2704 | if (((cmd >> 8) & 0xff) != 'M') | ||
2705 | return -EINVAL; | ||
2706 | |||
2707 | if (!access_ok(VERIFY_WRITE, arg, sizeof(int))) | ||
2708 | return -EFAULT; | ||
2709 | |||
2710 | if (_SIOC_DIR(cmd) & _SIOC_WRITE) | ||
2711 | { | ||
2712 | if (__get_user(val, (int __user *) arg)) | ||
2713 | return -EFAULT; | ||
2714 | |||
2715 | switch (cmd & 0xff) | ||
2716 | { | ||
2717 | case SOUND_MIXER_RECSRC: | ||
2718 | gus_recmask = val & MIX_DEVS; | ||
2719 | if (!(gus_recmask & (SOUND_MASK_MIC | SOUND_MASK_LINE))) | ||
2720 | gus_recmask = SOUND_MASK_MIC; | ||
2721 | /* Note! Input volumes are updated during next open for recording */ | ||
2722 | val = gus_recmask; | ||
2723 | break; | ||
2724 | |||
2725 | case SOUND_MIXER_MIC: | ||
2726 | vol = val & 0xff; | ||
2727 | if (vol < 0) | ||
2728 | vol = 0; | ||
2729 | if (vol > 100) | ||
2730 | vol = 100; | ||
2731 | gus_mic_vol = vol; | ||
2732 | set_input_volumes(); | ||
2733 | val = vol | (vol << 8); | ||
2734 | break; | ||
2735 | |||
2736 | case SOUND_MIXER_LINE: | ||
2737 | vol = val & 0xff; | ||
2738 | if (vol < 0) | ||
2739 | vol = 0; | ||
2740 | if (vol > 100) | ||
2741 | vol = 100; | ||
2742 | gus_line_vol = vol; | ||
2743 | set_input_volumes(); | ||
2744 | val = vol | (vol << 8); | ||
2745 | break; | ||
2746 | |||
2747 | case SOUND_MIXER_PCM: | ||
2748 | gus_pcm_volume = val & 0xff; | ||
2749 | if (gus_pcm_volume < 0) | ||
2750 | gus_pcm_volume = 0; | ||
2751 | if (gus_pcm_volume > 100) | ||
2752 | gus_pcm_volume = 100; | ||
2753 | gus_audio_update_volume(); | ||
2754 | val = gus_pcm_volume | (gus_pcm_volume << 8); | ||
2755 | break; | ||
2756 | |||
2757 | case SOUND_MIXER_SYNTH: | ||
2758 | gus_wave_volume = val & 0xff; | ||
2759 | if (gus_wave_volume < 0) | ||
2760 | gus_wave_volume = 0; | ||
2761 | if (gus_wave_volume > 100) | ||
2762 | gus_wave_volume = 100; | ||
2763 | if (active_device == GUS_DEV_WAVE) | ||
2764 | { | ||
2765 | int voice; | ||
2766 | for (voice = 0; voice < nr_voices; voice++) | ||
2767 | dynamic_volume_change(voice); /* Apply the new vol */ | ||
2768 | } | ||
2769 | val = gus_wave_volume | (gus_wave_volume << 8); | ||
2770 | break; | ||
2771 | |||
2772 | default: | ||
2773 | return -EINVAL; | ||
2774 | } | ||
2775 | } | ||
2776 | else | ||
2777 | { | ||
2778 | switch (cmd & 0xff) | ||
2779 | { | ||
2780 | /* | ||
2781 | * Return parameters | ||
2782 | */ | ||
2783 | case SOUND_MIXER_RECSRC: | ||
2784 | val = gus_recmask; | ||
2785 | break; | ||
2786 | |||
2787 | case SOUND_MIXER_DEVMASK: | ||
2788 | val = MIX_DEVS; | ||
2789 | break; | ||
2790 | |||
2791 | case SOUND_MIXER_STEREODEVS: | ||
2792 | val = 0; | ||
2793 | break; | ||
2794 | |||
2795 | case SOUND_MIXER_RECMASK: | ||
2796 | val = SOUND_MASK_MIC | SOUND_MASK_LINE; | ||
2797 | break; | ||
2798 | |||
2799 | case SOUND_MIXER_CAPS: | ||
2800 | val = 0; | ||
2801 | break; | ||
2802 | |||
2803 | case SOUND_MIXER_MIC: | ||
2804 | val = gus_mic_vol | (gus_mic_vol << 8); | ||
2805 | break; | ||
2806 | |||
2807 | case SOUND_MIXER_LINE: | ||
2808 | val = gus_line_vol | (gus_line_vol << 8); | ||
2809 | break; | ||
2810 | |||
2811 | case SOUND_MIXER_PCM: | ||
2812 | val = gus_pcm_volume | (gus_pcm_volume << 8); | ||
2813 | break; | ||
2814 | |||
2815 | case SOUND_MIXER_SYNTH: | ||
2816 | val = gus_wave_volume | (gus_wave_volume << 8); | ||
2817 | break; | ||
2818 | |||
2819 | default: | ||
2820 | return -EINVAL; | ||
2821 | } | ||
2822 | } | ||
2823 | return __put_user(val, (int __user *)arg); | ||
2824 | } | ||
2825 | |||
2826 | static struct mixer_operations gus_mixer_operations = | ||
2827 | { | ||
2828 | .owner = THIS_MODULE, | ||
2829 | .id = "GUS", | ||
2830 | .name = "Gravis Ultrasound", | ||
2831 | .ioctl = gus_default_mixer_ioctl | ||
2832 | }; | ||
2833 | |||
2834 | static int __init gus_default_mixer_init(void) | ||
2835 | { | ||
2836 | int n; | ||
2837 | |||
2838 | if ((n = sound_alloc_mixerdev()) != -1) | ||
2839 | { | ||
2840 | /* | ||
2841 | * Don't install if there is another | ||
2842 | * mixer | ||
2843 | */ | ||
2844 | mixer_devs[n] = &gus_mixer_operations; | ||
2845 | } | ||
2846 | if (have_gus_max) | ||
2847 | { | ||
2848 | /* | ||
2849 | * Enable all mixer channels on the GF1 side. Otherwise recording will | ||
2850 | * not be possible using GUS MAX. | ||
2851 | */ | ||
2852 | mix_image &= ~0x07; | ||
2853 | mix_image |= 0x04; /* All channels enabled */ | ||
2854 | outb((mix_image), u_Mixer); | ||
2855 | } | ||
2856 | return n; | ||
2857 | } | ||
2858 | |||
2859 | void __init gus_wave_init(struct address_info *hw_config) | ||
2860 | { | ||
2861 | unsigned long flags; | ||
2862 | unsigned char val; | ||
2863 | char *model_num = "2.4"; | ||
2864 | char tmp[64]; | ||
2865 | int gus_type = 0x24; /* 2.4 */ | ||
2866 | |||
2867 | int irq = hw_config->irq, dma = hw_config->dma, dma2 = hw_config->dma2; | ||
2868 | int sdev; | ||
2869 | |||
2870 | hw_config->slots[0] = -1; /* No wave */ | ||
2871 | hw_config->slots[1] = -1; /* No ad1848 */ | ||
2872 | hw_config->slots[4] = -1; /* No audio */ | ||
2873 | hw_config->slots[5] = -1; /* No mixer */ | ||
2874 | |||
2875 | if (!gus_pnp_flag) | ||
2876 | { | ||
2877 | if (irq < 0 || irq > 15) | ||
2878 | { | ||
2879 | printk(KERN_ERR "ERROR! Invalid IRQ#%d. GUS Disabled", irq); | ||
2880 | return; | ||
2881 | } | ||
2882 | } | ||
2883 | |||
2884 | if (dma < 0 || dma > 7 || dma == 4) | ||
2885 | { | ||
2886 | printk(KERN_ERR "ERROR! Invalid DMA#%d. GUS Disabled", dma); | ||
2887 | return; | ||
2888 | } | ||
2889 | gus_irq = irq; | ||
2890 | gus_dma = dma; | ||
2891 | gus_dma2 = dma2; | ||
2892 | gus_hw_config = hw_config; | ||
2893 | |||
2894 | if (gus_dma2 == -1) | ||
2895 | gus_dma2 = dma; | ||
2896 | |||
2897 | /* | ||
2898 | * Try to identify the GUS model. | ||
2899 | * | ||
2900 | * Versions < 3.6 don't have the digital ASIC. Try to probe it first. | ||
2901 | */ | ||
2902 | |||
2903 | spin_lock_irqsave(&gus_lock,flags); | ||
2904 | outb((0x20), gus_base + 0x0f); | ||
2905 | val = inb(gus_base + 0x0f); | ||
2906 | spin_unlock_irqrestore(&gus_lock,flags); | ||
2907 | |||
2908 | if (gus_pnp_flag || (val != 0xff && (val & 0x06))) /* Should be 0x02?? */ | ||
2909 | { | ||
2910 | int ad_flags = 0; | ||
2911 | |||
2912 | if (gus_pnp_flag) | ||
2913 | ad_flags = 0x12345678; /* Interwave "magic" */ | ||
2914 | /* | ||
2915 | * It has the digital ASIC so the card is at least v3.4. | ||
2916 | * Next try to detect the true model. | ||
2917 | */ | ||
2918 | |||
2919 | if (gus_pnp_flag) /* Hack hack hack */ | ||
2920 | val = 10; | ||
2921 | else | ||
2922 | val = inb(u_MixSelect); | ||
2923 | |||
2924 | /* | ||
2925 | * Value 255 means pre-3.7 which don't have mixer. | ||
2926 | * Values 5 thru 9 mean v3.7 which has a ICS2101 mixer. | ||
2927 | * 10 and above is GUS MAX which has the CS4231 codec/mixer. | ||
2928 | * | ||
2929 | */ | ||
2930 | |||
2931 | if (val == 255 || val < 5) | ||
2932 | { | ||
2933 | model_num = "3.4"; | ||
2934 | gus_type = 0x34; | ||
2935 | } | ||
2936 | else if (val < 10) | ||
2937 | { | ||
2938 | model_num = "3.7"; | ||
2939 | gus_type = 0x37; | ||
2940 | mixer_type = ICS2101; | ||
2941 | request_region(u_MixSelect, 1, "GUS mixer"); | ||
2942 | } | ||
2943 | else | ||
2944 | { | ||
2945 | struct resource *ports; | ||
2946 | ports = request_region(gus_base + 0x10c, 4, "ad1848"); | ||
2947 | model_num = "MAX"; | ||
2948 | gus_type = 0x40; | ||
2949 | mixer_type = CS4231; | ||
2950 | #ifdef CONFIG_SOUND_GUSMAX | ||
2951 | { | ||
2952 | unsigned char max_config = 0x40; /* Codec enable */ | ||
2953 | |||
2954 | if (gus_dma2 == -1) | ||
2955 | gus_dma2 = gus_dma; | ||
2956 | |||
2957 | if (gus_dma > 3) | ||
2958 | max_config |= 0x10; /* 16 bit capture DMA */ | ||
2959 | |||
2960 | if (gus_dma2 > 3) | ||
2961 | max_config |= 0x20; /* 16 bit playback DMA */ | ||
2962 | |||
2963 | max_config |= (gus_base >> 4) & 0x0f; /* Extract the X from 2X0 */ | ||
2964 | |||
2965 | outb((max_config), gus_base + 0x106); /* UltraMax control */ | ||
2966 | } | ||
2967 | |||
2968 | if (!ports) | ||
2969 | goto no_cs4231; | ||
2970 | |||
2971 | if (ad1848_detect(ports, &ad_flags, hw_config->osp)) | ||
2972 | { | ||
2973 | char *name = "GUS MAX"; | ||
2974 | int old_num_mixers = num_mixers; | ||
2975 | |||
2976 | if (gus_pnp_flag) | ||
2977 | name = "GUS PnP"; | ||
2978 | |||
2979 | gus_mic_vol = gus_line_vol = gus_pcm_volume = 100; | ||
2980 | gus_wave_volume = 90; | ||
2981 | have_gus_max = 1; | ||
2982 | if (hw_config->name) | ||
2983 | name = hw_config->name; | ||
2984 | |||
2985 | hw_config->slots[1] = ad1848_init(name, ports, | ||
2986 | -irq, gus_dma2, /* Playback DMA */ | ||
2987 | gus_dma, /* Capture DMA */ | ||
2988 | 1, /* Share DMA channels with GF1 */ | ||
2989 | hw_config->osp, | ||
2990 | THIS_MODULE); | ||
2991 | |||
2992 | if (num_mixers > old_num_mixers) | ||
2993 | { | ||
2994 | /* GUS has it's own mixer map */ | ||
2995 | AD1848_REROUTE(SOUND_MIXER_LINE1, SOUND_MIXER_SYNTH); | ||
2996 | AD1848_REROUTE(SOUND_MIXER_LINE2, SOUND_MIXER_CD); | ||
2997 | AD1848_REROUTE(SOUND_MIXER_LINE3, SOUND_MIXER_LINE); | ||
2998 | } | ||
2999 | } | ||
3000 | else { | ||
3001 | release_region(gus_base + 0x10c, 4); | ||
3002 | no_cs4231: | ||
3003 | printk(KERN_WARNING "GUS: No CS4231 ??"); | ||
3004 | } | ||
3005 | #else | ||
3006 | printk(KERN_ERR "GUS MAX found, but not compiled in\n"); | ||
3007 | #endif | ||
3008 | } | ||
3009 | } | ||
3010 | else | ||
3011 | { | ||
3012 | /* | ||
3013 | * ASIC not detected so the card must be 2.2 or 2.4. | ||
3014 | * There could still be the 16-bit/mixer daughter card. | ||
3015 | */ | ||
3016 | } | ||
3017 | |||
3018 | if (hw_config->name) | ||
3019 | snprintf(tmp, sizeof(tmp), "%s (%dk)", hw_config->name, | ||
3020 | (int) gus_mem_size / 1024); | ||
3021 | else if (gus_pnp_flag) | ||
3022 | snprintf(tmp, sizeof(tmp), "Gravis UltraSound PnP (%dk)", | ||
3023 | (int) gus_mem_size / 1024); | ||
3024 | else | ||
3025 | snprintf(tmp, sizeof(tmp), "Gravis UltraSound %s (%dk)", model_num, | ||
3026 | (int) gus_mem_size / 1024); | ||
3027 | |||
3028 | |||
3029 | samples = (struct patch_info *)vmalloc((MAX_SAMPLE + 1) * sizeof(*samples)); | ||
3030 | if (samples == NULL) | ||
3031 | { | ||
3032 | printk(KERN_WARNING "gus_init: Cant allocate memory for instrument tables\n"); | ||
3033 | return; | ||
3034 | } | ||
3035 | conf_printf(tmp, hw_config); | ||
3036 | strlcpy(gus_info.name, tmp, sizeof(gus_info.name)); | ||
3037 | |||
3038 | if ((sdev = sound_alloc_synthdev()) == -1) | ||
3039 | printk(KERN_WARNING "gus_init: Too many synthesizers\n"); | ||
3040 | else | ||
3041 | { | ||
3042 | voice_alloc = &guswave_operations.alloc; | ||
3043 | if (iw_mode) | ||
3044 | guswave_operations.id = "IWAVE"; | ||
3045 | hw_config->slots[0] = sdev; | ||
3046 | synth_devs[sdev] = &guswave_operations; | ||
3047 | sequencer_init(); | ||
3048 | gus_tmr_install(gus_base + 8); | ||
3049 | } | ||
3050 | |||
3051 | reset_sample_memory(); | ||
3052 | |||
3053 | gus_initialize(); | ||
3054 | |||
3055 | if ((gus_mem_size > 0) && !gus_no_wave_dma) | ||
3056 | { | ||
3057 | hw_config->slots[4] = -1; | ||
3058 | if ((gus_devnum = sound_install_audiodrv(AUDIO_DRIVER_VERSION, | ||
3059 | "Ultrasound", | ||
3060 | &gus_audio_driver, | ||
3061 | sizeof(struct audio_driver), | ||
3062 | NEEDS_RESTART | | ||
3063 | ((!iw_mode && dma2 != dma && dma2 != -1) ? | ||
3064 | DMA_DUPLEX : 0), | ||
3065 | AFMT_U8 | AFMT_S16_LE, | ||
3066 | NULL, dma, dma2)) < 0) | ||
3067 | { | ||
3068 | return; | ||
3069 | } | ||
3070 | |||
3071 | hw_config->slots[4] = gus_devnum; | ||
3072 | audio_devs[gus_devnum]->min_fragment = 9; /* 512k */ | ||
3073 | audio_devs[gus_devnum]->max_fragment = 11; /* 8k (must match size of bounce_buf */ | ||
3074 | audio_devs[gus_devnum]->mixer_dev = -1; /* Next mixer# */ | ||
3075 | audio_devs[gus_devnum]->flags |= DMA_HARDSTOP; | ||
3076 | } | ||
3077 | |||
3078 | /* | ||
3079 | * Mixer dependent initialization. | ||
3080 | */ | ||
3081 | |||
3082 | switch (mixer_type) | ||
3083 | { | ||
3084 | case ICS2101: | ||
3085 | gus_mic_vol = gus_line_vol = gus_pcm_volume = 100; | ||
3086 | gus_wave_volume = 90; | ||
3087 | request_region(u_MixSelect, 1, "GUS mixer"); | ||
3088 | hw_config->slots[5] = ics2101_mixer_init(); | ||
3089 | audio_devs[gus_devnum]->mixer_dev = hw_config->slots[5]; /* Next mixer# */ | ||
3090 | return; | ||
3091 | |||
3092 | case CS4231: | ||
3093 | /* Initialized elsewhere (ad1848.c) */ | ||
3094 | default: | ||
3095 | hw_config->slots[5] = gus_default_mixer_init(); | ||
3096 | audio_devs[gus_devnum]->mixer_dev = hw_config->slots[5]; /* Next mixer# */ | ||
3097 | return; | ||
3098 | } | ||
3099 | } | ||
3100 | |||
3101 | void __exit gus_wave_unload(struct address_info *hw_config) | ||
3102 | { | ||
3103 | #ifdef CONFIG_SOUND_GUSMAX | ||
3104 | if (have_gus_max) | ||
3105 | { | ||
3106 | ad1848_unload(gus_base + 0x10c, | ||
3107 | -gus_irq, | ||
3108 | gus_dma2, /* Playback DMA */ | ||
3109 | gus_dma, /* Capture DMA */ | ||
3110 | 1); /* Share DMA channels with GF1 */ | ||
3111 | } | ||
3112 | #endif | ||
3113 | |||
3114 | if (mixer_type == ICS2101) | ||
3115 | { | ||
3116 | release_region(u_MixSelect, 1); | ||
3117 | } | ||
3118 | if (hw_config->slots[0] != -1) | ||
3119 | sound_unload_synthdev(hw_config->slots[0]); | ||
3120 | if (hw_config->slots[1] != -1) | ||
3121 | sound_unload_audiodev(hw_config->slots[1]); | ||
3122 | if (hw_config->slots[2] != -1) | ||
3123 | sound_unload_mididev(hw_config->slots[2]); | ||
3124 | if (hw_config->slots[4] != -1) | ||
3125 | sound_unload_audiodev(hw_config->slots[4]); | ||
3126 | if (hw_config->slots[5] != -1) | ||
3127 | sound_unload_mixerdev(hw_config->slots[5]); | ||
3128 | |||
3129 | vfree(samples); | ||
3130 | samples=NULL; | ||
3131 | } | ||
3132 | /* called in interrupt context */ | ||
3133 | static void do_loop_irq(int voice) | ||
3134 | { | ||
3135 | unsigned char tmp; | ||
3136 | int mode, parm; | ||
3137 | |||
3138 | spin_lock(&gus_lock); | ||
3139 | gus_select_voice(voice); | ||
3140 | |||
3141 | tmp = gus_read8(0x00); | ||
3142 | tmp &= ~0x20; /* | ||
3143 | * Disable wave IRQ for this_one voice | ||
3144 | */ | ||
3145 | gus_write8(0x00, tmp); | ||
3146 | |||
3147 | if (tmp & 0x03) /* Voice stopped */ | ||
3148 | voice_alloc->map[voice] = 0; | ||
3149 | |||
3150 | mode = voices[voice].loop_irq_mode; | ||
3151 | voices[voice].loop_irq_mode = 0; | ||
3152 | parm = voices[voice].loop_irq_parm; | ||
3153 | |||
3154 | switch (mode) | ||
3155 | { | ||
3156 | case LMODE_FINISH: /* | ||
3157 | * Final loop finished, shoot volume down | ||
3158 | */ | ||
3159 | |||
3160 | if ((int) (gus_read16(0x09) >> 4) < 100) /* | ||
3161 | * Get current volume | ||
3162 | */ | ||
3163 | { | ||
3164 | gus_voice_off(); | ||
3165 | gus_rampoff(); | ||
3166 | gus_voice_init(voice); | ||
3167 | break; | ||
3168 | } | ||
3169 | gus_ramp_range(65, 4065); | ||
3170 | gus_ramp_rate(0, 63); /* | ||
3171 | * Fastest possible rate | ||
3172 | */ | ||
3173 | gus_rampon(0x20 | 0x40); /* | ||
3174 | * Ramp down, once, irq | ||
3175 | */ | ||
3176 | voices[voice].volume_irq_mode = VMODE_HALT; | ||
3177 | break; | ||
3178 | |||
3179 | case LMODE_PCM_STOP: | ||
3180 | pcm_active = 0; /* Signal to the play_next_pcm_block routine */ | ||
3181 | case LMODE_PCM: | ||
3182 | { | ||
3183 | pcm_qlen--; | ||
3184 | pcm_head = (pcm_head + 1) % pcm_nblk; | ||
3185 | if (pcm_qlen && pcm_active) | ||
3186 | { | ||
3187 | play_next_pcm_block(); | ||
3188 | } | ||
3189 | else | ||
3190 | { | ||
3191 | /* Underrun. Just stop the voice */ | ||
3192 | gus_select_voice(0); /* Left channel */ | ||
3193 | gus_voice_off(); | ||
3194 | gus_rampoff(); | ||
3195 | gus_select_voice(1); /* Right channel */ | ||
3196 | gus_voice_off(); | ||
3197 | gus_rampoff(); | ||
3198 | pcm_active = 0; | ||
3199 | } | ||
3200 | |||
3201 | /* | ||
3202 | * If the queue was full before this interrupt, the DMA transfer was | ||
3203 | * suspended. Let it continue now. | ||
3204 | */ | ||
3205 | |||
3206 | if (audio_devs[gus_devnum]->dmap_out->qlen > 0) | ||
3207 | DMAbuf_outputintr(gus_devnum, 0); | ||
3208 | } | ||
3209 | break; | ||
3210 | |||
3211 | default: | ||
3212 | break; | ||
3213 | } | ||
3214 | spin_unlock(&gus_lock); | ||
3215 | } | ||
3216 | |||
3217 | static void do_volume_irq(int voice) | ||
3218 | { | ||
3219 | unsigned char tmp; | ||
3220 | int mode, parm; | ||
3221 | unsigned long flags; | ||
3222 | |||
3223 | spin_lock_irqsave(&gus_lock,flags); | ||
3224 | |||
3225 | gus_select_voice(voice); | ||
3226 | tmp = gus_read8(0x0d); | ||
3227 | tmp &= ~0x20; /* | ||
3228 | * Disable volume ramp IRQ | ||
3229 | */ | ||
3230 | gus_write8(0x0d, tmp); | ||
3231 | |||
3232 | mode = voices[voice].volume_irq_mode; | ||
3233 | voices[voice].volume_irq_mode = 0; | ||
3234 | parm = voices[voice].volume_irq_parm; | ||
3235 | |||
3236 | switch (mode) | ||
3237 | { | ||
3238 | case VMODE_HALT: /* Decay phase finished */ | ||
3239 | if (iw_mode) | ||
3240 | gus_write8(0x15, 0x02); /* Set voice deactivate bit of SMSI */ | ||
3241 | spin_unlock_irqrestore(&gus_lock,flags); | ||
3242 | gus_voice_init(voice); | ||
3243 | break; | ||
3244 | |||
3245 | case VMODE_ENVELOPE: | ||
3246 | gus_rampoff(); | ||
3247 | spin_unlock_irqrestore(&gus_lock,flags); | ||
3248 | step_envelope(voice); | ||
3249 | break; | ||
3250 | |||
3251 | case VMODE_START_NOTE: | ||
3252 | spin_unlock_irqrestore(&gus_lock,flags); | ||
3253 | guswave_start_note2(voices[voice].dev_pending, voice, | ||
3254 | voices[voice].note_pending, voices[voice].volume_pending); | ||
3255 | if (voices[voice].kill_pending) | ||
3256 | guswave_kill_note(voices[voice].dev_pending, voice, | ||
3257 | voices[voice].note_pending, 0); | ||
3258 | |||
3259 | if (voices[voice].sample_pending >= 0) | ||
3260 | { | ||
3261 | guswave_set_instr(voices[voice].dev_pending, voice, | ||
3262 | voices[voice].sample_pending); | ||
3263 | voices[voice].sample_pending = -1; | ||
3264 | } | ||
3265 | break; | ||
3266 | |||
3267 | default: | ||
3268 | spin_unlock_irqrestore(&gus_lock,flags); | ||
3269 | } | ||
3270 | } | ||
3271 | /* called in irq context */ | ||
3272 | void gus_voice_irq(void) | ||
3273 | { | ||
3274 | unsigned long wave_ignore = 0, volume_ignore = 0; | ||
3275 | unsigned long voice_bit; | ||
3276 | |||
3277 | unsigned char src, voice; | ||
3278 | |||
3279 | while (1) | ||
3280 | { | ||
3281 | src = gus_read8(0x0f); /* | ||
3282 | * Get source info | ||
3283 | */ | ||
3284 | voice = src & 0x1f; | ||
3285 | src &= 0xc0; | ||
3286 | |||
3287 | if (src == (0x80 | 0x40)) | ||
3288 | return; /* | ||
3289 | * No interrupt | ||
3290 | */ | ||
3291 | |||
3292 | voice_bit = 1 << voice; | ||
3293 | |||
3294 | if (!(src & 0x80)) /* | ||
3295 | * Wave IRQ pending | ||
3296 | */ | ||
3297 | if (!(wave_ignore & voice_bit) && (int) voice < nr_voices) /* | ||
3298 | * Not done | ||
3299 | * yet | ||
3300 | */ | ||
3301 | { | ||
3302 | wave_ignore |= voice_bit; | ||
3303 | do_loop_irq(voice); | ||
3304 | } | ||
3305 | if (!(src & 0x40)) /* | ||
3306 | * Volume IRQ pending | ||
3307 | */ | ||
3308 | if (!(volume_ignore & voice_bit) && (int) voice < nr_voices) /* | ||
3309 | * Not done | ||
3310 | * yet | ||
3311 | */ | ||
3312 | { | ||
3313 | volume_ignore |= voice_bit; | ||
3314 | do_volume_irq(voice); | ||
3315 | } | ||
3316 | } | ||
3317 | } | ||
3318 | |||
3319 | void guswave_dma_irq(void) | ||
3320 | { | ||
3321 | unsigned char status; | ||
3322 | |||
3323 | status = gus_look8(0x41); /* Get DMA IRQ Status */ | ||
3324 | if (status & 0x40) /* DMA interrupt pending */ | ||
3325 | switch (active_device) | ||
3326 | { | ||
3327 | case GUS_DEV_WAVE: | ||
3328 | wake_up(&dram_sleeper); | ||
3329 | break; | ||
3330 | |||
3331 | case GUS_DEV_PCM_CONTINUE: /* Left channel data transferred */ | ||
3332 | gus_write8(0x41, 0); /* Disable GF1 DMA */ | ||
3333 | gus_transfer_output_block(pcm_current_dev, pcm_current_buf, | ||
3334 | pcm_current_count, | ||
3335 | pcm_current_intrflag, 1); | ||
3336 | break; | ||
3337 | |||
3338 | case GUS_DEV_PCM_DONE: /* Right or mono channel data transferred */ | ||
3339 | gus_write8(0x41, 0); /* Disable GF1 DMA */ | ||
3340 | if (pcm_qlen < pcm_nblk) | ||
3341 | { | ||
3342 | dma_active = 0; | ||
3343 | if (gus_busy) | ||
3344 | { | ||
3345 | if (audio_devs[gus_devnum]->dmap_out->qlen > 0) | ||
3346 | DMAbuf_outputintr(gus_devnum, 0); | ||
3347 | } | ||
3348 | } | ||
3349 | break; | ||
3350 | |||
3351 | default: | ||
3352 | break; | ||
3353 | } | ||
3354 | status = gus_look8(0x49); /* | ||
3355 | * Get Sampling IRQ Status | ||
3356 | */ | ||
3357 | if (status & 0x40) /* | ||
3358 | * Sampling Irq pending | ||
3359 | */ | ||
3360 | { | ||
3361 | DMAbuf_inputintr(gus_devnum); | ||
3362 | } | ||
3363 | } | ||
3364 | |||
3365 | /* | ||
3366 | * Timer stuff | ||
3367 | */ | ||
3368 | |||
3369 | static volatile int select_addr, data_addr; | ||
3370 | static volatile int curr_timer; | ||
3371 | |||
3372 | void gus_timer_command(unsigned int addr, unsigned int val) | ||
3373 | { | ||
3374 | int i; | ||
3375 | |||
3376 | outb(((unsigned char) (addr & 0xff)), select_addr); | ||
3377 | |||
3378 | for (i = 0; i < 2; i++) | ||
3379 | inb(select_addr); | ||
3380 | |||
3381 | outb(((unsigned char) (val & 0xff)), data_addr); | ||
3382 | |||
3383 | for (i = 0; i < 2; i++) | ||
3384 | inb(select_addr); | ||
3385 | } | ||
3386 | |||
3387 | static void arm_timer(int timer, unsigned int interval) | ||
3388 | { | ||
3389 | curr_timer = timer; | ||
3390 | |||
3391 | if (timer == 1) | ||
3392 | { | ||
3393 | gus_write8(0x46, 256 - interval); /* Set counter for timer 1 */ | ||
3394 | gus_write8(0x45, 0x04); /* Enable timer 1 IRQ */ | ||
3395 | gus_timer_command(0x04, 0x01); /* Start timer 1 */ | ||
3396 | } | ||
3397 | else | ||
3398 | { | ||
3399 | gus_write8(0x47, 256 - interval); /* Set counter for timer 2 */ | ||
3400 | gus_write8(0x45, 0x08); /* Enable timer 2 IRQ */ | ||
3401 | gus_timer_command(0x04, 0x02); /* Start timer 2 */ | ||
3402 | } | ||
3403 | |||
3404 | gus_timer_enabled = 1; | ||
3405 | } | ||
3406 | |||
3407 | static unsigned int gus_tmr_start(int dev, unsigned int usecs_per_tick) | ||
3408 | { | ||
3409 | int timer_no, resolution; | ||
3410 | int divisor; | ||
3411 | |||
3412 | if (usecs_per_tick > (256 * 80)) | ||
3413 | { | ||
3414 | timer_no = 2; | ||
3415 | resolution = 320; /* usec */ | ||
3416 | } | ||
3417 | else | ||
3418 | { | ||
3419 | timer_no = 1; | ||
3420 | resolution = 80; /* usec */ | ||
3421 | } | ||
3422 | divisor = (usecs_per_tick + (resolution / 2)) / resolution; | ||
3423 | arm_timer(timer_no, divisor); | ||
3424 | |||
3425 | return divisor * resolution; | ||
3426 | } | ||
3427 | |||
3428 | static void gus_tmr_disable(int dev) | ||
3429 | { | ||
3430 | gus_write8(0x45, 0); /* Disable both timers */ | ||
3431 | gus_timer_enabled = 0; | ||
3432 | } | ||
3433 | |||
3434 | static void gus_tmr_restart(int dev) | ||
3435 | { | ||
3436 | if (curr_timer == 1) | ||
3437 | gus_write8(0x45, 0x04); /* Start timer 1 again */ | ||
3438 | else | ||
3439 | gus_write8(0x45, 0x08); /* Start timer 2 again */ | ||
3440 | gus_timer_enabled = 1; | ||
3441 | } | ||
3442 | |||
3443 | static struct sound_lowlev_timer gus_tmr = | ||
3444 | { | ||
3445 | 0, | ||
3446 | 1, | ||
3447 | gus_tmr_start, | ||
3448 | gus_tmr_disable, | ||
3449 | gus_tmr_restart | ||
3450 | }; | ||
3451 | |||
3452 | static void gus_tmr_install(int io_base) | ||
3453 | { | ||
3454 | struct sound_lowlev_timer *tmr; | ||
3455 | |||
3456 | select_addr = io_base; | ||
3457 | data_addr = io_base + 1; | ||
3458 | |||
3459 | tmr = &gus_tmr; | ||
3460 | |||
3461 | #ifdef THIS_GETS_FIXED | ||
3462 | sound_timer_init(&gus_tmr, "GUS"); | ||
3463 | #endif | ||
3464 | } | ||