2 * Copyright (c) by Uros Bizjak <uros@kss-loka.si>
4 * Midi synth routines for OPL2/OPL3/OPL4 FM
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include "opl3_voice.h"
26 #include <sound/asoundef.h>
28 extern char snd_opl3_regmap
[MAX_OPL2_VOICES
][4];
30 extern int use_internal_drums
;
33 * The next table looks magical, but it certainly is not. Its values have
34 * been calculated as table[i]=8*log(i/64)/log(2) with an obvious exception
35 * for i=0. This log-table converts a linear volume-scaling (0..127) to a
36 * logarithmic scaling as present in the FM-synthesizer chips. so : Volume
37 * 64 = 0 db = relative volume 0 and: Volume 32 = -6 db = relative
38 * volume -8 it was implemented as a table because it is only 128 bytes and
39 * it saves a lot of log() calculations. (Rob Hooft <hooft@chem.ruu.nl>)
42 static char opl3_volume_table
[128] =
44 -63, -48, -40, -35, -32, -29, -27, -26,
45 -24, -23, -21, -20, -19, -18, -18, -17,
46 -16, -15, -15, -14, -13, -13, -12, -12,
47 -11, -11, -10, -10, -10, -9, -9, -8,
48 -8, -8, -7, -7, -7, -6, -6, -6,
49 -5, -5, -5, -5, -4, -4, -4, -4,
50 -3, -3, -3, -3, -2, -2, -2, -2,
51 -2, -1, -1, -1, -1, 0, 0, 0,
52 0, 0, 0, 1, 1, 1, 1, 1,
53 1, 2, 2, 2, 2, 2, 2, 2,
54 3, 3, 3, 3, 3, 3, 3, 4,
55 4, 4, 4, 4, 4, 4, 4, 5,
56 5, 5, 5, 5, 5, 5, 5, 5,
57 6, 6, 6, 6, 6, 6, 6, 6,
58 6, 7, 7, 7, 7, 7, 7, 7,
59 7, 7, 7, 8, 8, 8, 8, 8
62 void snd_opl3_calc_volume(unsigned char *volbyte
, int vel
,
63 struct snd_midi_channel
*chan
)
65 int oldvol
, newvol
, n
;
68 volume
= (vel
* chan
->gm_volume
* chan
->gm_expression
) / (127*127);
72 oldvol
= OPL3_TOTAL_LEVEL_MASK
- (*volbyte
& OPL3_TOTAL_LEVEL_MASK
);
74 newvol
= opl3_volume_table
[volume
] + oldvol
;
75 if (newvol
> OPL3_TOTAL_LEVEL_MASK
)
76 newvol
= OPL3_TOTAL_LEVEL_MASK
;
80 n
= OPL3_TOTAL_LEVEL_MASK
- (newvol
& OPL3_TOTAL_LEVEL_MASK
);
82 *volbyte
= (*volbyte
& OPL3_KSL_MASK
) | (n
& OPL3_TOTAL_LEVEL_MASK
);
86 * Converts the note frequency to block and fnum values for the FM chip
88 static short opl3_note_table
[16] =
90 305, 323, /* for pitch bending, -2 semitones */
91 343, 363, 385, 408, 432, 458, 485, 514, 544, 577, 611, 647,
92 686, 726 /* for pitch bending, +2 semitones */
95 static void snd_opl3_calc_pitch(unsigned char *fnum
, unsigned char *blocknum
,
96 int note
, struct snd_midi_channel
*chan
)
98 int block
= ((note
/ 12) & 0x07) - 1;
99 int idx
= (note
% 12) + 2;
102 if (chan
->midi_pitchbend
) {
103 int pitchbend
= chan
->midi_pitchbend
;
106 if (pitchbend
> 0x1FFF)
109 segment
= pitchbend
/ 0x1000;
110 freq
= opl3_note_table
[idx
+segment
];
111 freq
+= ((opl3_note_table
[idx
+segment
+1] - freq
) *
112 (pitchbend
% 0x1000)) / 0x1000;
114 freq
= opl3_note_table
[idx
];
117 *fnum
= (unsigned char) freq
;
118 *blocknum
= ((freq
>> 8) & OPL3_FNUM_HIGH_MASK
) |
119 ((block
<< 2) & OPL3_BLOCKNUM_MASK
);
124 static void debug_alloc(struct snd_opl3
*opl3
, char *s
, int voice
) {
128 printk("time %.5i: %s [%.2i]: ", opl3
->use_time
, s
, voice
);
129 for (i
= 0; i
< opl3
->max_voices
; i
++)
130 printk("%c", *(str
+ opl3
->voices
[i
].state
+ 1));
136 * Get a FM voice (channel) to play a note on.
138 static int opl3_get_voice(struct snd_opl3
*opl3
, int instr_4op
,
139 struct snd_midi_channel
*chan
) {
140 int chan_4op_1
; /* first voice for 4op instrument */
141 int chan_4op_2
; /* second voice for 4op instrument */
143 struct snd_opl3_voice
*vp
, *vp2
;
144 unsigned int voice_time
;
148 char *alloc_type
[3] = { "FREE ", "CHEAP ", "EXPENSIVE" };
151 /* This is our "allocation cost" table */
153 FREE
= 0, CHEAP
, EXPENSIVE
, END
156 /* Keeps track of what we are finding */
163 for (i
= 0; i
< END
; i
++) {
164 best
[i
].time
= (unsigned int)(-1); /* XXX MAX_?INT really */;
168 /* Look through all the channels for the most suitable. */
169 for (i
= 0; i
< opl3
->max_voices
; i
++) {
170 vp
= &opl3
->voices
[i
];
172 if (vp
->state
== SNDRV_OPL3_ST_NOT_AVAIL
)
173 /* skip unavailable channels, allocated by
174 drum voices or by bounded 4op voices) */
177 voice_time
= vp
->time
;
180 chan_4op_1
= ((i
< 3) || (i
> 8 && i
< 12));
181 chan_4op_2
= ((i
> 2 && i
< 6) || (i
> 11 && i
< 15));
183 /* allocate 4op voice */
184 /* skip channels unavailable to 4op instrument */
189 /* kill one voice, CHEAP */
191 /* get state of bounded 2op channel
192 to be allocated for 4op instrument */
193 vp2
= &opl3
->voices
[i
+ 3];
194 if (vp2
->state
== SNDRV_OPL3_ST_ON_2OP
) {
195 /* kill two voices, EXPENSIVE */
197 voice_time
= (voice_time
> vp
->time
) ?
198 voice_time
: vp
->time
;
201 /* allocate 2op voice */
202 if ((chan_4op_1
) || (chan_4op_2
))
203 /* use bounded channels for 2op, CHEAP */
206 /* kill one voice on 2op channel, CHEAP */
208 /* raise kill cost to EXPENSIVE for all channels */
212 if (voice_time
< bp
->time
) {
213 bp
->time
= voice_time
;
218 for (i
= 0; i
< END
; i
++) {
219 if (best
[i
].voice
>= 0) {
221 printk("%s %iop allocation on voice %i\n",
222 alloc_type
[i
], instr_4op
? 4 : 2,
225 return best
[i
].voice
;
232 /* ------------------------------ */
235 * System timer interrupt function
237 void snd_opl3_timer_func(unsigned long data
)
240 struct snd_opl3
*opl3
= (struct snd_opl3
*)data
;
245 spin_lock_irqsave(&opl3
->sys_timer_lock
, flags
);
246 for (i
= 0; i
< opl3
->max_voices
; i
++) {
247 struct snd_opl3_voice
*vp
= &opl3
->voices
[i
];
248 if (vp
->state
> 0 && vp
->note_off_check
) {
249 if (vp
->note_off
== jiffies
)
250 snd_opl3_note_off(opl3
, vp
->note
, 0, vp
->chan
);
256 opl3
->tlist
.expires
= jiffies
+ 1; /* invoke again */
257 add_timer(&opl3
->tlist
);
259 opl3
->sys_timer_status
= 0;
261 spin_unlock_irqrestore(&opl3
->sys_timer_lock
, flags
);
267 static void snd_opl3_start_timer(struct snd_opl3
*opl3
)
270 spin_lock_irqsave(&opl3
->sys_timer_lock
, flags
);
271 if (! opl3
->sys_timer_status
) {
272 opl3
->tlist
.expires
= jiffies
+ 1;
273 add_timer(&opl3
->tlist
);
274 opl3
->sys_timer_status
= 1;
276 spin_unlock_irqrestore(&opl3
->sys_timer_lock
, flags
);
279 /* ------------------------------ */
282 static int snd_opl3_oss_map
[MAX_OPL3_VOICES
] = {
283 0, 1, 2, 9, 10, 11, 6, 7, 8, 15, 16, 17, 3, 4 ,5, 12, 13, 14
289 void snd_opl3_note_on(void *p
, int note
, int vel
, struct snd_midi_channel
*chan
)
291 struct snd_opl3
*opl3
;
292 struct snd_seq_instr wanted
;
293 struct snd_seq_kinstr
*kinstr
;
297 struct snd_opl3_voice
*vp
, *vp2
;
298 unsigned short connect_mask
;
299 unsigned char connection
;
300 unsigned char vol_op
[4];
304 unsigned short reg_side
;
305 unsigned char op_offset
;
306 unsigned char voice_offset
;
307 unsigned short opl3_reg
;
308 unsigned char reg_val
;
311 unsigned char fnum
, blocknum
;
314 struct fm_instrument
*fm
;
320 snd_printk("Note on, ch %i, inst %i, note %i, vel %i\n",
321 chan
->number
, chan
->midi_program
, note
, vel
);
324 wanted
.std
= SNDRV_SEQ_INSTR_TYPE2_OPL2_3
;
326 /* in SYNTH mode, application takes care of voices */
327 /* in SEQ mode, drum voice numbers are notes on drum channel */
328 if (opl3
->synth_mode
== SNDRV_OPL3_MODE_SEQ
) {
329 if (chan
->drum_channel
) {
330 /* percussion instruments are located in bank 128 */
334 wanted
.bank
= chan
->gm_bank_select
;
335 wanted
.prg
= chan
->midi_program
;
338 /* Prepare for OSS mode */
339 if (chan
->number
>= MAX_OPL3_VOICES
)
342 /* OSS instruments are located in bank 127 */
344 wanted
.prg
= chan
->midi_program
;
347 spin_lock_irqsave(&opl3
->voice_lock
, flags
);
349 if (use_internal_drums
) {
350 snd_opl3_drum_switch(opl3
, note
, vel
, 1, chan
);
351 spin_unlock_irqrestore(&opl3
->voice_lock
, flags
);
356 kinstr
= snd_seq_instr_find(opl3
->ilist
, &wanted
, 1, 0);
357 if (kinstr
== NULL
) {
358 spin_unlock_irqrestore(&opl3
->voice_lock
, flags
);
362 fm
= KINSTR_DATA(kinstr
);
369 if (opl3
->hardware
>= OPL3_HW_OPL3
) {
374 snd_seq_instr_free_use(opl3
->ilist
, kinstr
);
375 spin_unlock_irqrestore(&opl3
->voice_lock
, flags
);
380 snd_printk(" --> OPL%i instrument: %s\n",
381 instr_4op
? 3 : 2, kinstr
->name
);
383 /* in SYNTH mode, application takes care of voices */
384 /* in SEQ mode, allocate voice on free OPL3 channel */
385 if (opl3
->synth_mode
== SNDRV_OPL3_MODE_SEQ
) {
386 voice
= opl3_get_voice(opl3
, instr_4op
, chan
);
388 /* remap OSS voice */
389 voice
= snd_opl3_oss_map
[chan
->number
];
392 if (voice
< MAX_OPL2_VOICES
) {
393 /* Left register block for voices 0 .. 8 */
394 reg_side
= OPL3_LEFT
;
395 voice_offset
= voice
;
396 connect_mask
= (OPL3_LEFT_4OP_0
<< voice_offset
) & 0x07;
398 /* Right register block for voices 9 .. 17 */
399 reg_side
= OPL3_RIGHT
;
400 voice_offset
= voice
- MAX_OPL2_VOICES
;
401 connect_mask
= (OPL3_RIGHT_4OP_0
<< voice_offset
) & 0x38;
404 /* kill voice on channel */
405 vp
= &opl3
->voices
[voice
];
407 opl3_reg
= reg_side
| (OPL3_REG_KEYON_BLOCK
+ voice_offset
);
408 reg_val
= vp
->keyon_reg
& ~OPL3_KEYON_BIT
;
409 opl3
->command(opl3
, opl3_reg
, reg_val
);
412 vp2
= &opl3
->voices
[voice
+ 3];
414 opl3_reg
= reg_side
| (OPL3_REG_KEYON_BLOCK
+
416 reg_val
= vp
->keyon_reg
& ~OPL3_KEYON_BIT
;
417 opl3
->command(opl3
, opl3_reg
, reg_val
);
421 /* set connection register */
423 if ((opl3
->connection_reg
^ connect_mask
) & connect_mask
) {
424 opl3
->connection_reg
|= connect_mask
;
425 /* set connection bit */
426 opl3_reg
= OPL3_RIGHT
| OPL3_REG_CONNECTION_SELECT
;
427 opl3
->command(opl3
, opl3_reg
, opl3
->connection_reg
);
430 if ((opl3
->connection_reg
^ ~connect_mask
) & connect_mask
) {
431 opl3
->connection_reg
&= ~connect_mask
;
432 /* clear connection bit */
433 opl3_reg
= OPL3_RIGHT
| OPL3_REG_CONNECTION_SELECT
;
434 opl3
->command(opl3
, opl3_reg
, opl3
->connection_reg
);
439 snd_printk(" --> setting OPL3 connection: 0x%x\n",
440 opl3
->connection_reg
);
443 * calculate volume depending on connection
444 * between FM operators (see include/opl3.h)
446 for (i
= 0; i
< (instr_4op
? 4 : 2); i
++)
447 vol_op
[i
] = fm
->op
[i
].ksl_level
;
449 connection
= fm
->feedback_connection
[0] & 0x01;
452 connection
|= fm
->feedback_connection
[1] & 0x01;
454 snd_opl3_calc_volume(&vol_op
[3], vel
, chan
);
455 switch (connection
) {
457 snd_opl3_calc_volume(&vol_op
[2], vel
, chan
);
460 snd_opl3_calc_volume(&vol_op
[0], vel
, chan
);
463 snd_opl3_calc_volume(&vol_op
[1], vel
, chan
);
466 snd_opl3_calc_volume(&vol_op
[1], vel
, chan
);
468 snd_opl3_calc_volume(&vol_op
[0], vel
, chan
);
471 /* Program the FM voice characteristics */
472 for (i
= 0; i
< (instr_4op
? 4 : 2); i
++) {
474 snd_printk(" --> programming operator %i\n", i
);
476 op_offset
= snd_opl3_regmap
[voice_offset
][i
];
478 /* Set OPL3 AM_VIB register of requested voice/operator */
479 reg_val
= fm
->op
[i
].am_vib
;
480 opl3_reg
= reg_side
| (OPL3_REG_AM_VIB
+ op_offset
);
481 opl3
->command(opl3
, opl3_reg
, reg_val
);
483 /* Set OPL3 KSL_LEVEL register of requested voice/operator */
485 opl3_reg
= reg_side
| (OPL3_REG_KSL_LEVEL
+ op_offset
);
486 opl3
->command(opl3
, opl3_reg
, reg_val
);
488 /* Set OPL3 ATTACK_DECAY register of requested voice/operator */
489 reg_val
= fm
->op
[i
].attack_decay
;
490 opl3_reg
= reg_side
| (OPL3_REG_ATTACK_DECAY
+ op_offset
);
491 opl3
->command(opl3
, opl3_reg
, reg_val
);
493 /* Set OPL3 SUSTAIN_RELEASE register of requested voice/operator */
494 reg_val
= fm
->op
[i
].sustain_release
;
495 opl3_reg
= reg_side
| (OPL3_REG_SUSTAIN_RELEASE
+ op_offset
);
496 opl3
->command(opl3
, opl3_reg
, reg_val
);
498 /* Select waveform */
499 reg_val
= fm
->op
[i
].wave_select
;
500 opl3_reg
= reg_side
| (OPL3_REG_WAVE_SELECT
+ op_offset
);
501 opl3
->command(opl3
, opl3_reg
, reg_val
);
504 /* Set operator feedback and 2op inter-operator connection */
505 reg_val
= fm
->feedback_connection
[0];
506 /* Set output voice connection */
507 reg_val
|= OPL3_STEREO_BITS
;
508 if (chan
->gm_pan
< 43)
509 reg_val
&= ~OPL3_VOICE_TO_RIGHT
;
510 if (chan
->gm_pan
> 85)
511 reg_val
&= ~OPL3_VOICE_TO_LEFT
;
512 opl3_reg
= reg_side
| (OPL3_REG_FEEDBACK_CONNECTION
+ voice_offset
);
513 opl3
->command(opl3
, opl3_reg
, reg_val
);
516 /* Set 4op inter-operator connection */
517 reg_val
= fm
->feedback_connection
[1] & OPL3_CONNECTION_BIT
;
518 /* Set output voice connection */
519 reg_val
|= OPL3_STEREO_BITS
;
520 if (chan
->gm_pan
< 43)
521 reg_val
&= ~OPL3_VOICE_TO_RIGHT
;
522 if (chan
->gm_pan
> 85)
523 reg_val
&= ~OPL3_VOICE_TO_LEFT
;
524 opl3_reg
= reg_side
| (OPL3_REG_FEEDBACK_CONNECTION
+
526 opl3
->command(opl3
, opl3_reg
, reg_val
);
530 * Special treatment of percussion notes for fm:
531 * Requested pitch is really program, and pitch for
532 * device is whatever was specified in the patch library.
537 * use transpose if defined in patch library
540 note
+= (fm
->trnsps
- 64);
542 snd_opl3_calc_pitch(&fnum
, &blocknum
, note
, chan
);
544 /* Set OPL3 FNUM_LOW register of requested voice */
545 opl3_reg
= reg_side
| (OPL3_REG_FNUM_LOW
+ voice_offset
);
546 opl3
->command(opl3
, opl3_reg
, fnum
);
548 opl3
->voices
[voice
].keyon_reg
= blocknum
;
550 /* Set output sound flag */
551 blocknum
|= OPL3_KEYON_BIT
;
554 snd_printk(" --> trigger voice %i\n", voice
);
556 /* Set OPL3 KEYON_BLOCK register of requested voice */
557 opl3_reg
= reg_side
| (OPL3_REG_KEYON_BLOCK
+ voice_offset
);
558 opl3
->command(opl3
, opl3_reg
, blocknum
);
560 /* kill note after fixed duration (in centiseconds) */
562 opl3
->voices
[voice
].note_off
= jiffies
+
563 (fm
->fix_dur
* HZ
) / 100;
564 snd_opl3_start_timer(opl3
);
565 opl3
->voices
[voice
].note_off_check
= 1;
567 opl3
->voices
[voice
].note_off_check
= 0;
569 /* get extra pgm, but avoid possible loops */
570 extra_prg
= (extra_prg
) ? 0 : fm
->modes
;
572 snd_seq_instr_free_use(opl3
->ilist
, kinstr
);
574 /* do the bookkeeping */
575 vp
->time
= opl3
->use_time
++;
580 vp
->state
= SNDRV_OPL3_ST_ON_4OP
;
582 vp2
= &opl3
->voices
[voice
+ 3];
583 vp2
->time
= opl3
->use_time
++;
586 vp2
->state
= SNDRV_OPL3_ST_NOT_AVAIL
;
588 if (vp
->state
== SNDRV_OPL3_ST_ON_4OP
) {
589 /* 4op killed by 2op, release bounded voice */
590 vp2
= &opl3
->voices
[voice
+ 3];
591 vp2
->time
= opl3
->use_time
++;
592 vp2
->state
= SNDRV_OPL3_ST_OFF
;
594 vp
->state
= SNDRV_OPL3_ST_ON_2OP
;
598 debug_alloc(opl3
, "note on ", voice
);
601 /* allocate extra program if specified in patch library */
603 if (extra_prg
> 128) {
605 /* percussions start at 35 */
606 wanted
.prg
= extra_prg
- 128 + 35 - 1;
609 wanted
.prg
= extra_prg
- 1;
612 snd_printk(" *** allocating extra program\n");
616 spin_unlock_irqrestore(&opl3
->voice_lock
, flags
);
619 static void snd_opl3_kill_voice(struct snd_opl3
*opl3
, int voice
)
621 unsigned short reg_side
;
622 unsigned char voice_offset
;
623 unsigned short opl3_reg
;
625 struct snd_opl3_voice
*vp
, *vp2
;
627 snd_assert(voice
< MAX_OPL3_VOICES
, return);
629 vp
= &opl3
->voices
[voice
];
630 if (voice
< MAX_OPL2_VOICES
) {
631 /* Left register block for voices 0 .. 8 */
632 reg_side
= OPL3_LEFT
;
633 voice_offset
= voice
;
635 /* Right register block for voices 9 .. 17 */
636 reg_side
= OPL3_RIGHT
;
637 voice_offset
= voice
- MAX_OPL2_VOICES
;
642 snd_printk(" --> kill voice %i\n", voice
);
644 opl3_reg
= reg_side
| (OPL3_REG_KEYON_BLOCK
+ voice_offset
);
645 /* clear Key ON bit */
646 opl3
->command(opl3
, opl3_reg
, vp
->keyon_reg
);
648 /* do the bookkeeping */
649 vp
->time
= opl3
->use_time
++;
651 if (vp
->state
== SNDRV_OPL3_ST_ON_4OP
) {
652 vp2
= &opl3
->voices
[voice
+ 3];
654 vp2
->time
= opl3
->use_time
++;
655 vp2
->state
= SNDRV_OPL3_ST_OFF
;
657 vp
->state
= SNDRV_OPL3_ST_OFF
;
659 debug_alloc(opl3
, "note off", voice
);
665 * Release a note in response to a midi note off.
667 void snd_opl3_note_off(void *p
, int note
, int vel
, struct snd_midi_channel
*chan
)
669 struct snd_opl3
*opl3
;
672 struct snd_opl3_voice
*vp
;
679 snd_printk("Note off, ch %i, inst %i, note %i\n",
680 chan
->number
, chan
->midi_program
, note
);
683 spin_lock_irqsave(&opl3
->voice_lock
, flags
);
685 if (opl3
->synth_mode
== SNDRV_OPL3_MODE_SEQ
) {
686 if (chan
->drum_channel
&& use_internal_drums
) {
687 snd_opl3_drum_switch(opl3
, note
, vel
, 0, chan
);
688 spin_unlock_irqrestore(&opl3
->voice_lock
, flags
);
691 /* this loop will hopefully kill all extra voices, because
692 they are grouped by the same channel and note values */
693 for (voice
= 0; voice
< opl3
->max_voices
; voice
++) {
694 vp
= &opl3
->voices
[voice
];
695 if (vp
->state
> 0 && vp
->chan
== chan
&& vp
->note
== note
) {
696 snd_opl3_kill_voice(opl3
, voice
);
700 /* remap OSS voices */
701 if (chan
->number
< MAX_OPL3_VOICES
) {
702 voice
= snd_opl3_oss_map
[chan
->number
];
703 snd_opl3_kill_voice(opl3
, voice
);
706 spin_unlock_irqrestore(&opl3
->voice_lock
, flags
);
710 * key pressure change
712 void snd_opl3_key_press(void *p
, int note
, int vel
, struct snd_midi_channel
*chan
)
714 struct snd_opl3
*opl3
;
718 snd_printk("Key pressure, ch#: %i, inst#: %i\n",
719 chan
->number
, chan
->midi_program
);
726 void snd_opl3_terminate_note(void *p
, int note
, struct snd_midi_channel
*chan
)
728 struct snd_opl3
*opl3
;
732 snd_printk("Terminate note, ch#: %i, inst#: %i\n",
733 chan
->number
, chan
->midi_program
);
737 static void snd_opl3_update_pitch(struct snd_opl3
*opl3
, int voice
)
739 unsigned short reg_side
;
740 unsigned char voice_offset
;
741 unsigned short opl3_reg
;
743 unsigned char fnum
, blocknum
;
745 struct snd_opl3_voice
*vp
;
747 snd_assert(voice
< MAX_OPL3_VOICES
, return);
749 vp
= &opl3
->voices
[voice
];
750 if (vp
->chan
== NULL
)
751 return; /* not allocated? */
753 if (voice
< MAX_OPL2_VOICES
) {
754 /* Left register block for voices 0 .. 8 */
755 reg_side
= OPL3_LEFT
;
756 voice_offset
= voice
;
758 /* Right register block for voices 9 .. 17 */
759 reg_side
= OPL3_RIGHT
;
760 voice_offset
= voice
- MAX_OPL2_VOICES
;
763 snd_opl3_calc_pitch(&fnum
, &blocknum
, vp
->note
, vp
->chan
);
765 /* Set OPL3 FNUM_LOW register of requested voice */
766 opl3_reg
= reg_side
| (OPL3_REG_FNUM_LOW
+ voice_offset
);
767 opl3
->command(opl3
, opl3_reg
, fnum
);
769 vp
->keyon_reg
= blocknum
;
771 /* Set output sound flag */
772 blocknum
|= OPL3_KEYON_BIT
;
774 /* Set OPL3 KEYON_BLOCK register of requested voice */
775 opl3_reg
= reg_side
| (OPL3_REG_KEYON_BLOCK
+ voice_offset
);
776 opl3
->command(opl3
, opl3_reg
, blocknum
);
778 vp
->time
= opl3
->use_time
++;
782 * Update voice pitch controller
784 static void snd_opl3_pitch_ctrl(struct snd_opl3
*opl3
, struct snd_midi_channel
*chan
)
787 struct snd_opl3_voice
*vp
;
791 spin_lock_irqsave(&opl3
->voice_lock
, flags
);
793 if (opl3
->synth_mode
== SNDRV_OPL3_MODE_SEQ
) {
794 for (voice
= 0; voice
< opl3
->max_voices
; voice
++) {
795 vp
= &opl3
->voices
[voice
];
796 if (vp
->state
> 0 && vp
->chan
== chan
) {
797 snd_opl3_update_pitch(opl3
, voice
);
801 /* remap OSS voices */
802 if (chan
->number
< MAX_OPL3_VOICES
) {
803 voice
= snd_opl3_oss_map
[chan
->number
];
804 snd_opl3_update_pitch(opl3
, voice
);
807 spin_unlock_irqrestore(&opl3
->voice_lock
, flags
);
811 * Deal with a controler type event. This includes all types of
812 * control events, not just the midi controllers
814 void snd_opl3_control(void *p
, int type
, struct snd_midi_channel
*chan
)
816 struct snd_opl3
*opl3
;
820 snd_printk("Controller, TYPE = %i, ch#: %i, inst#: %i\n",
821 type
, chan
->number
, chan
->midi_program
);
825 case MIDI_CTL_MSB_MODWHEEL
:
826 if (chan
->control
[MIDI_CTL_MSB_MODWHEEL
] > 63)
827 opl3
->drum_reg
|= OPL3_VIBRATO_DEPTH
;
829 opl3
->drum_reg
&= ~OPL3_VIBRATO_DEPTH
;
830 opl3
->command(opl3
, OPL3_LEFT
| OPL3_REG_PERCUSSION
,
833 case MIDI_CTL_E2_TREMOLO_DEPTH
:
834 if (chan
->control
[MIDI_CTL_E2_TREMOLO_DEPTH
] > 63)
835 opl3
->drum_reg
|= OPL3_TREMOLO_DEPTH
;
837 opl3
->drum_reg
&= ~OPL3_TREMOLO_DEPTH
;
838 opl3
->command(opl3
, OPL3_LEFT
| OPL3_REG_PERCUSSION
,
841 case MIDI_CTL_PITCHBEND
:
842 snd_opl3_pitch_ctrl(opl3
, chan
);
850 void snd_opl3_nrpn(void *p
, struct snd_midi_channel
*chan
,
851 struct snd_midi_channel_set
*chset
)
853 struct snd_opl3
*opl3
;
857 snd_printk("NRPN, ch#: %i, inst#: %i\n",
858 chan
->number
, chan
->midi_program
);
865 void snd_opl3_sysex(void *p
, unsigned char *buf
, int len
,
866 int parsed
, struct snd_midi_channel_set
*chset
)
868 struct snd_opl3
*opl3
;
872 snd_printk("SYSEX\n");