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