This source file includes following definitions.
- enable_opl3_mode
- enter_4op_mode
- opl3_ioctl
- opl3_detect
- opl3_kill_note
- store_instr
- opl3_set_instr
- calc_vol
- set_voice_volume
- opl3_start_note
- freq_to_fnum
- opl3_command
- opl3_reset
- opl3_open
- opl3_close
- opl3_hw_control
- opl3_load_patch
- opl3_panning
- opl3_volume_method
- opl3_aftertouch
- bend_pitch
- opl3_controller
- opl3_patchmgr
- opl3_bender
- opl3_alloc_voice
- opl3_setup_voice
- opl3_init
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29 #include <linux/config.h>
30
31
32
33
34
35
36
37
38
39 #include "sound_config.h"
40
41 #if defined(CONFIG_YM3812)
42
43 #include "opl3.h"
44
45 #define MAX_VOICE 18
46 #define OFFS_4OP 11
47
48 struct voice_info
49 {
50 unsigned char keyon_byte;
51 long bender;
52 long bender_range;
53 unsigned long orig_freq;
54 unsigned long current_freq;
55 int volume;
56 int mode;
57 };
58
59 typedef struct opl_devinfo
60 {
61 int left_io, right_io;
62 int nr_voice;
63 int lv_map[MAX_VOICE];
64
65 struct voice_info voc[MAX_VOICE];
66 struct voice_alloc_info *v_alloc;
67 struct channel_info *chn_info;
68
69 struct sbi_instrument i_map[SBFM_MAXINSTR];
70 struct sbi_instrument *act_i[MAX_VOICE];
71
72 struct synth_info fm_info;
73
74 int busy;
75 int model;
76 unsigned char cmask;
77
78 int is_opl4;
79 int *osp;
80 }
81 opl_devinfo;
82
83 static struct opl_devinfo *devc = NULL;
84
85
86 static int detected_model;
87
88 static int store_instr (int instr_no, struct sbi_instrument *instr);
89 static void freq_to_fnum (int freq, int *block, int *fnum);
90 static void opl3_command (int io_addr, unsigned int addr, unsigned int val);
91 static int opl3_kill_note (int dev, int voice, int note, int velocity);
92
93 void
94 enable_opl3_mode (int left, int right, int both)
95 {
96
97 }
98
99 static void
100 enter_4op_mode (void)
101 {
102 int i;
103 static int v4op[MAX_VOICE] =
104 {0, 1, 2, 9, 10, 11, 6, 7, 8, 15, 16, 17};
105
106 devc->cmask = 0x3f;
107 opl3_command (devc->right_io, CONNECTION_SELECT_REGISTER, 0x3f);
108
109 for (i = 0; i < 3; i++)
110 pv_map[i].voice_mode = 4;
111 for (i = 3; i < 6; i++)
112 pv_map[i].voice_mode = 0;
113
114 for (i = 9; i < 12; i++)
115 pv_map[i].voice_mode = 4;
116 for (i = 12; i < 15; i++)
117 pv_map[i].voice_mode = 0;
118
119 for (i = 0; i < 12; i++)
120 devc->lv_map[i] = v4op[i];
121 devc->v_alloc->max_voice = devc->nr_voice = 12;
122 }
123
124 static int
125 opl3_ioctl (int dev,
126 unsigned int cmd, caddr_t arg)
127 {
128 switch (cmd)
129 {
130
131 case SNDCTL_FM_LOAD_INSTR:
132 {
133 struct sbi_instrument ins;
134
135 memcpy_fromfs ((char *) &ins, &(((char *) arg)[0]), sizeof (ins));
136
137 if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR)
138 {
139 printk ("FM Error: Invalid instrument number %d\n", ins.channel);
140 return -EINVAL;
141 }
142
143 pmgr_inform (dev, PM_E_PATCH_LOADED, ins.channel, 0, 0, 0);
144 return store_instr (ins.channel, &ins);
145 }
146 break;
147
148 case SNDCTL_SYNTH_INFO:
149 devc->fm_info.nr_voices = (devc->nr_voice == 12) ? 6 : devc->nr_voice;
150
151 memcpy_tofs ((&((char *) arg)[0]), &devc->fm_info, sizeof (devc->fm_info));
152 return 0;
153 break;
154
155 case SNDCTL_SYNTH_MEMAVL:
156 return 0x7fffffff;
157 break;
158
159 case SNDCTL_FM_4OP_ENABLE:
160 if (devc->model == 2)
161 enter_4op_mode ();
162 return 0;
163 break;
164
165 default:
166 return -EINVAL;
167 }
168
169 }
170
171 int
172 opl3_detect (int ioaddr, int *osp)
173 {
174
175
176
177
178
179
180
181
182
183
184
185 unsigned char stat1, stat2, signature;
186 int i;
187
188 if (devc != NULL)
189 return 0;
190
191
192 devc = (struct opl_devinfo *) (sound_mem_blocks[sound_num_blocks] = kmalloc (sizeof (*devc), GFP_KERNEL));
193 if (sound_num_blocks < 1024)
194 sound_num_blocks++;;
195
196 if (devc == NULL)
197 {
198 printk ("OPL3: Can't allocate memory for the device control structure\n");
199 return 0;
200 }
201
202 devc->osp = osp;
203
204
205 opl3_command (ioaddr, TIMER_CONTROL_REGISTER, TIMER1_MASK | TIMER2_MASK);
206
207
208 opl3_command (ioaddr, TIMER_CONTROL_REGISTER, IRQ_RESET);
209
210 signature = stat1 = inb (ioaddr);
211
212 if ((stat1 & 0xE0) != 0x00)
213 {
214 return 0;
215
216
217 }
218
219 opl3_command (ioaddr, TIMER1_REGISTER, 0xff);
220
221 opl3_command (ioaddr, TIMER_CONTROL_REGISTER,
222 TIMER2_MASK | TIMER1_START);
223
224
225
226
227
228
229
230 for (i = 0; i < 50; i++)
231 tenmicrosec (devc->osp);
232
233 stat2 = inb (ioaddr);
234
235
236
237
238
239
240
241
242 opl3_command (ioaddr, TIMER_CONTROL_REGISTER, TIMER1_MASK | TIMER2_MASK);
243
244 opl3_command (ioaddr, TIMER_CONTROL_REGISTER, IRQ_RESET);
245
246 if ((stat2 & 0xE0) != 0xc0)
247 {
248 return 0;
249
250
251 }
252
253
254
255
256
257 if (signature == 0x06)
258 {
259 detected_model = 2;
260 }
261 else if (signature == 0x00)
262 {
263 unsigned char tmp;
264
265 detected_model = 3;
266
267
268
269
270
271
272
273 opl3_command (ioaddr + 2, OPL3_MODE_REGISTER, 0x00);
274 opl3_command (ioaddr + 2, OPL3_MODE_REGISTER, OPL3_ENABLE | OPL4_ENABLE);
275
276 if ((tmp = inb (ioaddr)) == 0x02)
277 {
278 detected_model = 4;
279 }
280
281 if (!check_region (ioaddr - 8, 2))
282 {
283 int tmp;
284
285 outb (0x02, ioaddr - 8);
286 tenmicrosec (devc->osp);
287 tmp = inb (ioaddr - 7);
288 tenmicrosec (devc->osp);
289
290 if (tmp == 0x20)
291 {
292 detected_model = 4;
293
294 outb (0xF8, ioaddr - 8);
295 tenmicrosec (devc->osp);
296 outb (0x1B, ioaddr - 7);
297 tenmicrosec (devc->osp);
298 }
299 else
300 detected_model = 3;
301 }
302
303 opl3_command (ioaddr + 2, OPL3_MODE_REGISTER, 0);
304
305 }
306
307 for (i = 0; i < 9; i++)
308 opl3_command (ioaddr, KEYON_BLOCK + i, 0);
309
310
311
312 opl3_command (ioaddr, TEST_REGISTER, ENABLE_WAVE_SELECT);
313 opl3_command (ioaddr, PERCUSSION_REGISTER, 0x00);
314
315
316
317 return 1;
318 }
319
320 static int
321 opl3_kill_note (int dev, int voice, int note, int velocity)
322 {
323 struct physical_voice_info *map;
324
325 if (voice < 0 || voice >= devc->nr_voice)
326 return 0;
327
328 devc->v_alloc->map[voice] = 0;
329
330 map = &pv_map[devc->lv_map[voice]];
331
332 DEB (printk ("Kill note %d\n", voice));
333
334 if (map->voice_mode == 0)
335 return 0;
336
337 opl3_command (map->ioaddr, KEYON_BLOCK + map->voice_num, devc->voc[voice].keyon_byte & ~0x20);
338
339 devc->voc[voice].keyon_byte = 0;
340 devc->voc[voice].bender = 0;
341 devc->voc[voice].volume = 64;
342 devc->voc[voice].bender_range = 200;
343
344
345 devc->voc[voice].orig_freq = 0;
346 devc->voc[voice].current_freq = 0;
347 devc->voc[voice].mode = 0;
348
349 return 0;
350 }
351
352 #define HIHAT 0
353 #define CYMBAL 1
354 #define TOMTOM 2
355 #define SNARE 3
356 #define BDRUM 4
357 #define UNDEFINED TOMTOM
358 #define DEFAULT TOMTOM
359
360 static int
361 store_instr (int instr_no, struct sbi_instrument *instr)
362 {
363
364 if (instr->key != FM_PATCH && (instr->key != OPL3_PATCH || devc->model != 2))
365 printk ("FM warning: Invalid patch format field (key) 0x%x\n", instr->key);
366 memcpy ((char *) &(devc->i_map[instr_no]), (char *) instr, sizeof (*instr));
367
368 return 0;
369 }
370
371 static int
372 opl3_set_instr (int dev, int voice, int instr_no)
373 {
374 if (voice < 0 || voice >= devc->nr_voice)
375 return 0;
376
377 if (instr_no < 0 || instr_no >= SBFM_MAXINSTR)
378 return 0;
379
380 devc->act_i[voice] = &devc->i_map[instr_no];
381 return 0;
382 }
383
384
385
386
387
388
389
390
391
392
393 char fm_volume_table[128] =
394 {-64, -48, -40, -35, -32, -29, -27, -26,
395 -24, -23, -21, -20, -19, -18, -18, -17,
396 -16, -15, -15, -14, -13, -13, -12, -12,
397 -11, -11, -10, -10, -10, -9, -9, -8,
398 -8, -8, -7, -7, -7, -6, -6, -6,
399 -5, -5, -5, -5, -4, -4, -4, -4,
400 -3, -3, -3, -3, -2, -2, -2, -2,
401 -2, -1, -1, -1, -1, 0, 0, 0,
402 0, 0, 0, 1, 1, 1, 1, 1,
403 1, 2, 2, 2, 2, 2, 2, 2,
404 3, 3, 3, 3, 3, 3, 3, 4,
405 4, 4, 4, 4, 4, 4, 4, 5,
406 5, 5, 5, 5, 5, 5, 5, 5,
407 6, 6, 6, 6, 6, 6, 6, 6,
408 6, 7, 7, 7, 7, 7, 7, 7,
409 7, 7, 7, 8, 8, 8, 8, 8};
410
411 static void
412 calc_vol (unsigned char *regbyte, int volume, int main_vol)
413 {
414 int level = (~*regbyte & 0x3f);
415
416 if (main_vol > 127)
417 main_vol = 127;
418
419 volume = (volume * main_vol) / 127;
420
421 if (level)
422 level += fm_volume_table[volume];
423
424 if (level > 0x3f)
425 level = 0x3f;
426 if (level < 0)
427 level = 0;
428
429 *regbyte = (*regbyte & 0xc0) | (~level & 0x3f);
430 }
431
432 static void
433 set_voice_volume (int voice, int volume, int main_vol)
434 {
435 unsigned char vol1, vol2, vol3, vol4;
436 struct sbi_instrument *instr;
437 struct physical_voice_info *map;
438
439 if (voice < 0 || voice >= devc->nr_voice)
440 return;
441
442 map = &pv_map[devc->lv_map[voice]];
443
444 instr = devc->act_i[voice];
445
446 if (!instr)
447 instr = &devc->i_map[0];
448
449 if (instr->channel < 0)
450 return;
451
452 if (devc->voc[voice].mode == 0)
453 return;
454
455 if (devc->voc[voice].mode == 2)
456 {
457
458 vol1 = instr->operators[2];
459 vol2 = instr->operators[3];
460
461 if ((instr->operators[10] & 0x01))
462 {
463 calc_vol (&vol1, volume, main_vol);
464 calc_vol (&vol2, volume, main_vol);
465 }
466 else
467 {
468 calc_vol (&vol2, volume, main_vol);
469 }
470
471 opl3_command (map->ioaddr, KSL_LEVEL + map->op[0], vol1);
472 opl3_command (map->ioaddr, KSL_LEVEL + map->op[1], vol2);
473 }
474 else
475 {
476
477
478 int connection;
479
480 vol1 = instr->operators[2];
481 vol2 = instr->operators[3];
482 vol3 = instr->operators[OFFS_4OP + 2];
483 vol4 = instr->operators[OFFS_4OP + 3];
484
485
486
487
488
489
490 connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
491
492 switch (connection)
493 {
494 case 0:
495 calc_vol (&vol4, volume, main_vol);
496 break;
497
498 case 1:
499 calc_vol (&vol2, volume, main_vol);
500 calc_vol (&vol4, volume, main_vol);
501 break;
502
503 case 2:
504 calc_vol (&vol1, volume, main_vol);
505 calc_vol (&vol4, volume, main_vol);
506 break;
507
508 case 3:
509 calc_vol (&vol1, volume, main_vol);
510 calc_vol (&vol3, volume, main_vol);
511 calc_vol (&vol4, volume, main_vol);
512 break;
513
514 default:;
515 }
516
517 opl3_command (map->ioaddr, KSL_LEVEL + map->op[0], vol1);
518 opl3_command (map->ioaddr, KSL_LEVEL + map->op[1], vol2);
519 opl3_command (map->ioaddr, KSL_LEVEL + map->op[2], vol3);
520 opl3_command (map->ioaddr, KSL_LEVEL + map->op[3], vol4);
521 }
522 }
523
524 static int
525 opl3_start_note (int dev, int voice, int note, int volume)
526 {
527 unsigned char data, fpc;
528 int block, fnum, freq, voice_mode;
529 struct sbi_instrument *instr;
530 struct physical_voice_info *map;
531
532 if (voice < 0 || voice >= devc->nr_voice)
533 return 0;
534
535 map = &pv_map[devc->lv_map[voice]];
536
537 if (map->voice_mode == 0)
538 return 0;
539
540 if (note == 255)
541
542
543 {
544 set_voice_volume (voice, volume, devc->voc[voice].volume);
545 return 0;
546 }
547
548
549
550
551 opl3_command (map->ioaddr, KSL_LEVEL + map->op[1], 0xff);
552
553
554
555
556 opl3_command (map->ioaddr, KSL_LEVEL + map->op[0], 0xff);
557
558
559
560
561 if (map->voice_mode == 4)
562 {
563 opl3_command (map->ioaddr, KSL_LEVEL + map->op[2], 0xff);
564 opl3_command (map->ioaddr, KSL_LEVEL + map->op[3], 0xff);
565 }
566
567 opl3_command (map->ioaddr, KEYON_BLOCK + map->voice_num, 0x00);
568
569
570
571
572 instr = devc->act_i[voice];
573
574 if (!instr)
575 instr = &devc->i_map[0];
576
577 if (instr->channel < 0)
578 {
579 printk (
580 "OPL3: Initializing voice %d with undefined instrument\n",
581 voice);
582 return 0;
583 }
584
585 if (map->voice_mode == 2 && instr->key == OPL3_PATCH)
586 return 0;
587
588
589
590 voice_mode = map->voice_mode;
591
592 if (voice_mode == 4)
593 {
594 int voice_shift;
595
596 voice_shift = (map->ioaddr == devc->left_io) ? 0 : 3;
597 voice_shift += map->voice_num;
598
599 if (instr->key != OPL3_PATCH)
600
601
602 {
603 voice_mode = 2;
604 devc->cmask &= ~(1 << voice_shift);
605 }
606 else
607 {
608 devc->cmask |= (1 << voice_shift);
609 }
610
611 opl3_command (devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
612 }
613
614
615
616
617 opl3_command (map->ioaddr, AM_VIB + map->op[0], instr->operators[0]);
618 opl3_command (map->ioaddr, AM_VIB + map->op[1], instr->operators[1]);
619
620
621
622
623 opl3_command (map->ioaddr, ATTACK_DECAY + map->op[0], instr->operators[4]);
624 opl3_command (map->ioaddr, ATTACK_DECAY + map->op[1], instr->operators[5]);
625
626
627
628
629 opl3_command (map->ioaddr, SUSTAIN_RELEASE + map->op[0], instr->operators[6]);
630 opl3_command (map->ioaddr, SUSTAIN_RELEASE + map->op[1], instr->operators[7]);
631
632
633
634
635 opl3_command (map->ioaddr, WAVE_SELECT + map->op[0], instr->operators[8]);
636 opl3_command (map->ioaddr, WAVE_SELECT + map->op[1], instr->operators[9]);
637
638
639
640
641 fpc = instr->operators[10];
642 if (!(fpc & 0x30))
643 fpc |= 0x30;
644
645
646 opl3_command (map->ioaddr, FEEDBACK_CONNECTION + map->voice_num,
647 fpc);
648
649
650
651
652
653 if (voice_mode == 4)
654 {
655
656
657
658
659 opl3_command (map->ioaddr, AM_VIB + map->op[2], instr->operators[OFFS_4OP + 0]);
660 opl3_command (map->ioaddr, AM_VIB + map->op[3], instr->operators[OFFS_4OP + 1]);
661
662
663
664
665 opl3_command (map->ioaddr, ATTACK_DECAY + map->op[2], instr->operators[OFFS_4OP + 4]);
666 opl3_command (map->ioaddr, ATTACK_DECAY + map->op[3], instr->operators[OFFS_4OP + 5]);
667
668
669
670
671 opl3_command (map->ioaddr, SUSTAIN_RELEASE + map->op[2], instr->operators[OFFS_4OP + 6]);
672 opl3_command (map->ioaddr, SUSTAIN_RELEASE + map->op[3], instr->operators[OFFS_4OP + 7]);
673
674
675
676
677 opl3_command (map->ioaddr, WAVE_SELECT + map->op[2], instr->operators[OFFS_4OP + 8]);
678 opl3_command (map->ioaddr, WAVE_SELECT + map->op[3], instr->operators[OFFS_4OP + 9]);
679
680
681
682
683 fpc = instr->operators[OFFS_4OP + 10];
684 if (!(fpc & 0x30))
685 fpc |= 0x30;
686
687
688 opl3_command (map->ioaddr, FEEDBACK_CONNECTION + map->voice_num + 3, fpc);
689 }
690
691 devc->voc[voice].mode = voice_mode;
692
693 set_voice_volume (voice, volume, devc->voc[voice].volume);
694
695 freq = devc->voc[voice].orig_freq = note_to_freq (note) / 1000;
696
697
698
699
700
701
702 freq = compute_finetune (devc->voc[voice].orig_freq, devc->voc[voice].bender, devc->voc[voice].bender_range);
703 devc->voc[voice].current_freq = freq;
704
705 freq_to_fnum (freq, &block, &fnum);
706
707
708
709
710
711 data = fnum & 0xff;
712
713
714 opl3_command (map->ioaddr, FNUM_LOW + map->voice_num, data);
715
716 data = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
717 devc->voc[voice].keyon_byte = data;
718 opl3_command (map->ioaddr, KEYON_BLOCK + map->voice_num, data);
719 if (voice_mode == 4)
720 opl3_command (map->ioaddr, KEYON_BLOCK + map->voice_num + 3, data);
721
722 return 0;
723 }
724
725 static void
726 freq_to_fnum (int freq, int *block, int *fnum)
727 {
728 int f, octave;
729
730
731
732
733
734
735
736
737 f = freq;
738
739 octave = 5;
740
741 if (f == 0)
742 octave = 0;
743 else if (f < 261)
744 {
745 while (f < 261)
746 {
747 octave--;
748 f <<= 1;
749 }
750 }
751 else if (f > 493)
752 {
753 while (f > 493)
754 {
755 octave++;
756 f >>= 1;
757 }
758 }
759
760 if (octave > 7)
761 octave = 7;
762
763 *fnum = freq * (1 << (20 - octave)) / 49716;
764 *block = octave;
765 }
766
767 static void
768 opl3_command (int io_addr, unsigned int addr, unsigned int val)
769 {
770 int i;
771
772
773
774
775
776
777 outb ((unsigned char) (addr & 0xff), io_addr);
778
779 if (!devc->model != 2)
780 tenmicrosec (devc->osp);
781 else
782 for (i = 0; i < 2; i++)
783 inb (io_addr);
784
785 outb ((unsigned char) (val & 0xff), io_addr + 1);
786
787 if (devc->model != 2)
788 {
789 tenmicrosec (devc->osp);
790 tenmicrosec (devc->osp);
791 tenmicrosec (devc->osp);
792 }
793 else
794 for (i = 0; i < 2; i++)
795 inb (io_addr);
796 }
797
798 static void
799 opl3_reset (int dev)
800 {
801 int i;
802
803 for (i = 0; i < 18; i++)
804 devc->lv_map[i] = i;
805
806 for (i = 0; i < devc->nr_voice; i++)
807 {
808 opl3_command (pv_map[devc->lv_map[i]].ioaddr,
809 KSL_LEVEL + pv_map[devc->lv_map[i]].op[0], 0xff);
810
811 opl3_command (pv_map[devc->lv_map[i]].ioaddr,
812 KSL_LEVEL + pv_map[devc->lv_map[i]].op[1], 0xff);
813
814 if (pv_map[devc->lv_map[i]].voice_mode == 4)
815 {
816 opl3_command (pv_map[devc->lv_map[i]].ioaddr,
817 KSL_LEVEL + pv_map[devc->lv_map[i]].op[2], 0xff);
818
819 opl3_command (pv_map[devc->lv_map[i]].ioaddr,
820 KSL_LEVEL + pv_map[devc->lv_map[i]].op[3], 0xff);
821 }
822
823 opl3_kill_note (dev, i, 0, 64);
824 }
825
826 if (devc->model == 2)
827 {
828 devc->v_alloc->max_voice = devc->nr_voice = 18;
829
830 for (i = 0; i < 18; i++)
831 pv_map[i].voice_mode = 2;
832
833 }
834
835 }
836
837 static int
838 opl3_open (int dev, int mode)
839 {
840 int i;
841
842 if (devc->busy)
843 return -EBUSY;
844 devc->busy = 1;
845
846 devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
847 devc->v_alloc->timestamp = 0;
848
849 for (i = 0; i < 18; i++)
850 {
851 devc->v_alloc->map[i] = 0;
852 devc->v_alloc->alloc_times[i] = 0;
853 }
854
855 devc->cmask = 0x00;
856
857
858 if (devc->model == 2)
859 opl3_command (devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
860 return 0;
861 }
862
863 static void
864 opl3_close (int dev)
865 {
866 devc->busy = 0;
867 devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
868
869 devc->fm_info.nr_drums = 0;
870 devc->fm_info.perc_mode = 0;
871
872 opl3_reset (dev);
873 }
874
875 static void
876 opl3_hw_control (int dev, unsigned char *event)
877 {
878 }
879
880 static int
881 opl3_load_patch (int dev, int format, const char *addr,
882 int offs, int count, int pmgr_flag)
883 {
884 struct sbi_instrument ins;
885
886 if (count < sizeof (ins))
887 {
888 printk ("FM Error: Patch record too short\n");
889 return -EINVAL;
890 }
891
892 memcpy_fromfs (&((char *) &ins)[offs], &((addr)[offs]), sizeof (ins) - offs);
893
894 if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR)
895 {
896 printk ("FM Error: Invalid instrument number %d\n", ins.channel);
897 return -EINVAL;
898 }
899 ins.key = format;
900
901 return store_instr (ins.channel, &ins);
902 }
903
904 static void
905 opl3_panning (int dev, int voice, int pressure)
906 {
907 }
908
909 static void
910 opl3_volume_method (int dev, int mode)
911 {
912 }
913
914 #define SET_VIBRATO(cell) { \
915 tmp = instr->operators[(cell-1)+(((cell-1)/2)*OFFS_4OP)]; \
916 if (pressure > 110) \
917 tmp |= 0x40; \
918 opl3_command (map->ioaddr, AM_VIB + map->op[cell-1], tmp);}
919
920 static void
921 opl3_aftertouch (int dev, int voice, int pressure)
922 {
923 int tmp;
924 struct sbi_instrument *instr;
925 struct physical_voice_info *map;
926
927 if (voice < 0 || voice >= devc->nr_voice)
928 return;
929
930 map = &pv_map[devc->lv_map[voice]];
931
932 DEB (printk ("Aftertouch %d\n", voice));
933
934 if (map->voice_mode == 0)
935 return;
936
937
938
939
940
941 instr = devc->act_i[voice];
942
943 if (!instr)
944 instr = &devc->i_map[0];
945
946 if (devc->voc[voice].mode == 4)
947 {
948 int connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
949
950 switch (connection)
951 {
952 case 0:
953 SET_VIBRATO (4);
954 break;
955
956 case 1:
957 SET_VIBRATO (2);
958 SET_VIBRATO (4);
959 break;
960
961 case 2:
962 SET_VIBRATO (1);
963 SET_VIBRATO (4);
964 break;
965
966 case 3:
967 SET_VIBRATO (1);
968 SET_VIBRATO (3);
969 SET_VIBRATO (4);
970 break;
971
972 }
973
974
975
976 }
977 else
978 {
979 SET_VIBRATO (1);
980
981 if ((instr->operators[10] & 0x01))
982
983
984 SET_VIBRATO (2);
985 }
986 }
987
988 #undef SET_VIBRATO
989
990 static void
991 bend_pitch (int dev, int voice, int value)
992 {
993 unsigned char data;
994 int block, fnum, freq;
995 struct physical_voice_info *map;
996
997 map = &pv_map[devc->lv_map[voice]];
998
999 if (map->voice_mode == 0)
1000 return;
1001
1002 devc->voc[voice].bender = value;
1003 if (!value)
1004 return;
1005 if (!(devc->voc[voice].keyon_byte & 0x20))
1006 return;
1007
1008
1009
1010 freq = compute_finetune (devc->voc[voice].orig_freq, devc->voc[voice].bender, devc->voc[voice].bender_range);
1011 devc->voc[voice].current_freq = freq;
1012
1013 freq_to_fnum (freq, &block, &fnum);
1014
1015 data = fnum & 0xff;
1016
1017
1018 opl3_command (map->ioaddr, FNUM_LOW + map->voice_num, data);
1019
1020 data = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
1021
1022
1023
1024
1025
1026
1027
1028 devc->voc[voice].keyon_byte = data;
1029 opl3_command (map->ioaddr, KEYON_BLOCK + map->voice_num, data);
1030 }
1031
1032 static void
1033 opl3_controller (int dev, int voice, int ctrl_num, int value)
1034 {
1035 if (voice < 0 || voice >= devc->nr_voice)
1036 return;
1037
1038 switch (ctrl_num)
1039 {
1040 case CTRL_PITCH_BENDER:
1041 bend_pitch (dev, voice, value);
1042 break;
1043
1044 case CTRL_PITCH_BENDER_RANGE:
1045 devc->voc[voice].bender_range = value;
1046 break;
1047
1048 case CTL_MAIN_VOLUME:
1049 devc->voc[voice].volume = value / 128;
1050 break;
1051 }
1052 }
1053
1054 static int
1055 opl3_patchmgr (int dev, struct patmgr_info *rec)
1056 {
1057 return -EINVAL;
1058 }
1059
1060 static void
1061 opl3_bender (int dev, int voice, int value)
1062 {
1063 if (voice < 0 || voice >= devc->nr_voice)
1064 return;
1065
1066 bend_pitch (dev, voice, value - 8192);
1067 }
1068
1069 static int
1070 opl3_alloc_voice (int dev, int chn, int note, struct voice_alloc_info *alloc)
1071 {
1072 int i, p, best, first, avail, best_time = 0x7fffffff;
1073 struct sbi_instrument *instr;
1074 int is4op;
1075 int instr_no;
1076
1077 if (chn < 0 || chn > 15)
1078 instr_no = 0;
1079 else
1080 instr_no = devc->chn_info[chn].pgm_num;
1081
1082 instr = &devc->i_map[instr_no];
1083 if (instr->channel < 0 ||
1084 devc->nr_voice != 12)
1085 is4op = 0;
1086 else if (devc->nr_voice == 12)
1087 is4op = (instr->key == OPL3_PATCH);
1088 else
1089 is4op = 0;
1090
1091 if (is4op)
1092 {
1093 first = p = 0;
1094 avail = 6;
1095 }
1096 else
1097 {
1098 if (devc->nr_voice == 12)
1099 first = p = 6;
1100 else
1101 first = p = 0;
1102 avail = devc->nr_voice;
1103 }
1104
1105
1106
1107
1108 best = first;
1109
1110 for (i = 0; i < avail; i++)
1111 {
1112 if (alloc->map[p] == 0)
1113 {
1114 return p;
1115 }
1116 if (alloc->alloc_times[p] < best_time)
1117 {
1118 best_time = alloc->alloc_times[p];
1119 best = p;
1120 }
1121 p = (p + 1) % avail;
1122 }
1123
1124
1125
1126
1127
1128 if (best < 0)
1129 best = 0;
1130 if (best > devc->nr_voice)
1131 best -= devc->nr_voice;
1132
1133 return best;
1134 }
1135
1136 static void
1137 opl3_setup_voice (int dev, int voice, int chn)
1138 {
1139 struct channel_info *info =
1140 &synth_devs[dev]->chn_info[chn];
1141
1142 opl3_set_instr (dev, voice,
1143 info->pgm_num);
1144
1145 devc->voc[voice].bender = info->bender_value;
1146 devc->voc[voice].volume =
1147 info->controllers[CTL_MAIN_VOLUME];
1148 }
1149
1150 static struct synth_operations opl3_operations =
1151 {
1152 NULL,
1153 0,
1154 SYNTH_TYPE_FM,
1155 FM_TYPE_ADLIB,
1156 opl3_open,
1157 opl3_close,
1158 opl3_ioctl,
1159 opl3_kill_note,
1160 opl3_start_note,
1161 opl3_set_instr,
1162 opl3_reset,
1163 opl3_hw_control,
1164 opl3_load_patch,
1165 opl3_aftertouch,
1166 opl3_controller,
1167 opl3_panning,
1168 opl3_volume_method,
1169 opl3_patchmgr,
1170 opl3_bender,
1171 opl3_alloc_voice,
1172 opl3_setup_voice
1173 };
1174
1175 long
1176 opl3_init (long mem_start, int ioaddr, int *osp)
1177 {
1178 int i;
1179
1180 if (num_synths >= MAX_SYNTH_DEV)
1181 {
1182 printk ("OPL3 Error: Too many synthesizers\n");
1183 return mem_start;
1184 }
1185
1186 if (devc == NULL)
1187 {
1188 printk ("OPL3: Device control structure not initialized.\n");
1189 return mem_start;
1190 }
1191
1192 memset ((char *) devc, 0x00, sizeof (*devc));
1193 devc->osp = osp;
1194
1195 devc->nr_voice = 9;
1196 strcpy (devc->fm_info.name, "OPL2");
1197
1198 devc->fm_info.device = 0;
1199 devc->fm_info.synth_type = SYNTH_TYPE_FM;
1200 devc->fm_info.synth_subtype = FM_TYPE_ADLIB;
1201 devc->fm_info.perc_mode = 0;
1202 devc->fm_info.nr_voices = 9;
1203 devc->fm_info.nr_drums = 0;
1204 devc->fm_info.instr_bank_size = SBFM_MAXINSTR;
1205 devc->fm_info.capabilities = 0;
1206 devc->left_io = ioaddr;
1207 devc->right_io = ioaddr + 2;
1208
1209 if (detected_model <= 2)
1210 devc->model = 1;
1211 else
1212 {
1213 devc->model = 2;
1214 if (detected_model == 4)
1215 devc->is_opl4 = 1;
1216 }
1217
1218 opl3_operations.info = &devc->fm_info;
1219
1220 synth_devs[num_synths++] = &opl3_operations;
1221 devc->v_alloc = &opl3_operations.alloc;
1222 devc->chn_info = &opl3_operations.chn_info[0];
1223
1224 if (devc->model == 2)
1225 {
1226 if (devc->is_opl4)
1227 conf_printf2 ("Yamaha OPL4/OPL3 FM", ioaddr, 0, -1, -1);
1228 else
1229 conf_printf2 ("Yamaha OPL3 FM", ioaddr, 0, -1, -1);
1230
1231 devc->v_alloc->max_voice = devc->nr_voice = 18;
1232 devc->fm_info.nr_drums = 0;
1233 devc->fm_info.capabilities |= SYNTH_CAP_OPL3;
1234 strcpy (devc->fm_info.name, "Yamaha OPL-3");
1235
1236 for (i = 0; i < 18; i++)
1237 if (pv_map[i].ioaddr == USE_LEFT)
1238 pv_map[i].ioaddr = devc->left_io;
1239 else
1240 pv_map[i].ioaddr = devc->right_io;
1241
1242 opl3_command (devc->right_io, OPL3_MODE_REGISTER, OPL3_ENABLE);
1243 opl3_command (devc->right_io, CONNECTION_SELECT_REGISTER, 0x00);
1244 }
1245 else
1246 {
1247 conf_printf2 ("Yamaha OPL2 FM", ioaddr, 0, -1, -1);
1248 devc->v_alloc->max_voice = devc->nr_voice = 9;
1249 devc->fm_info.nr_drums = 0;
1250
1251 for (i = 0; i < 18; i++)
1252 pv_map[i].ioaddr = devc->left_io;
1253 };
1254
1255 for (i = 0; i < SBFM_MAXINSTR; i++)
1256 devc->i_map[i].channel = -1;
1257
1258 return mem_start;
1259 }
1260
1261 #endif