?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
um: Don't discard .text.exit section
[linux/fpc-iii.git] / sound / oss / opl3.c
blobb6d19adf8f4111d575c88b235142d6ed0580654f
1 /*
2 * sound/oss/opl3.c
3 *
4 * A low level driver for Yamaha YM3812 and OPL-3 -chips
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 * Changes
15 * Thomas Sailer ioctl code reworked (vmalloc/vfree removed)
16 * Alan Cox modularisation, fixed sound_mem allocs.
17 * Christoph Hellwig Adapted to module_init/module_exit
18 * Arnaldo C. de Melo get rid of check_region, use request_region for
19 * OPL4, release it on exit, some cleanups.
20 *
21 * Status
22 * Believed to work. Badly needs rewriting a bit to support multiple
23 * OPL3 devices.
24 */
25
26 #include <linux/init.h>
27 #include <linux/slab.h>
28 #include <linux/module.h>
29 #include <linux/delay.h>
30
31 /*
32 * Major improvements to the FM handling 30AUG92 by Rob Hooft,
33 * hooft@chem.ruu.nl
34 */
35
36 #include "sound_config.h"
37
38 #include "opl3_hw.h"
39
40 #define MAX_VOICE 18
41 #define OFFS_4OP 11
42
43 struct voice_info
44 {
45 unsigned char keyon_byte;
46 long bender;
47 long bender_range;
48 unsigned long orig_freq;
49 unsigned long current_freq;
50 int volume;
51 int mode;
52 int panning; /* 0xffff means not set */
53 };
54
55 struct opl_devinfo
56 {
57 int base;
58 int left_io, right_io;
59 int nr_voice;
60 int lv_map[MAX_VOICE];
61
62 struct voice_info voc[MAX_VOICE];
63 struct voice_alloc_info *v_alloc;
64 struct channel_info *chn_info;
65
66 struct sbi_instrument i_map[SBFM_MAXINSTR];
67 struct sbi_instrument *act_i[MAX_VOICE];
68
69 struct synth_info fm_info;
70
71 int busy;
72 int model;
73 unsigned char cmask;
74
75 int is_opl4;
76 };
77
78 static struct opl_devinfo *devc = NULL;
79
80 static int detected_model;
81
82 static int store_instr(int instr_no, struct sbi_instrument *instr);
83 static void freq_to_fnum(int freq, int *block, int *fnum);
84 static void opl3_command(int io_addr, unsigned int addr, unsigned int val);
85 static int opl3_kill_note(int dev, int voice, int note, int velocity);
86
87 static void enter_4op_mode(void)
88 {
89 int i;
90 static int v4op[MAX_VOICE] = {
91 0, 1, 2, 9, 10, 11, 6, 7, 8, 15, 16, 17
92 };
93
94 devc->cmask = 0x3f; /* Connect all possible 4 OP voice operators */
95 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, 0x3f);
96
97 for (i = 0; i < 3; i++)
98 pv_map[i].voice_mode = 4;
99 for (i = 3; i < 6; i++)
100 pv_map[i].voice_mode = 0;
101
102 for (i = 9; i < 12; i++)
103 pv_map[i].voice_mode = 4;
104 for (i = 12; i < 15; i++)
105 pv_map[i].voice_mode = 0;
106
107 for (i = 0; i < 12; i++)
108 devc->lv_map[i] = v4op[i];
109 devc->v_alloc->max_voice = devc->nr_voice = 12;
110 }
111
112 static int opl3_ioctl(int dev, unsigned int cmd, void __user * arg)
113 {
114 struct sbi_instrument ins;
115
116 switch (cmd) {
117 case SNDCTL_FM_LOAD_INSTR:
118 printk(KERN_WARNING "Warning: Obsolete ioctl(SNDCTL_FM_LOAD_INSTR) used. Fix the program.\n");
119 if (copy_from_user(&ins, arg, sizeof(ins)))
120 return -EFAULT;
121 if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR) {
122 printk(KERN_WARNING "FM Error: Invalid instrument number %d\n", ins.channel);
123 return -EINVAL;
124 }
125 return store_instr(ins.channel, &ins);
126
127 case SNDCTL_SYNTH_INFO:
128 devc->fm_info.nr_voices = (devc->nr_voice == 12) ? 6 : devc->nr_voice;
129 if (copy_to_user(arg, &devc->fm_info, sizeof(devc->fm_info)))
130 return -EFAULT;
131 return 0;
132
133 case SNDCTL_SYNTH_MEMAVL:
134 return 0x7fffffff;
135
136 case SNDCTL_FM_4OP_ENABLE:
137 if (devc->model == 2)
138 enter_4op_mode();
139 return 0;
140
141 default:
142 return -EINVAL;
143 }
144 }
145
146 static int opl3_detect(int ioaddr)
147 {
148 /*
149 * This function returns 1 if the FM chip is present at the given I/O port
150 * The detection algorithm plays with the timer built in the FM chip and
151 * looks for a change in the status register.
152 *
153 * Note! The timers of the FM chip are not connected to AdLib (and compatible)
154 * boards.
155 *
156 * Note2! The chip is initialized if detected.
157 */
158
159 unsigned char stat1, signature;
160 int i;
161
162 if (devc != NULL)
163 {
164 printk(KERN_ERR "opl3: Only one OPL3 supported.\n");
165 return 0;
166 }
167
168 devc = kzalloc(sizeof(*devc), GFP_KERNEL);
169
170 if (devc == NULL)
171 {
172 printk(KERN_ERR "opl3: Can't allocate memory for the device control "
173 "structure \n ");
174 return 0;
175 }
176
177 strcpy(devc->fm_info.name, "OPL2");
178
179 if (!request_region(ioaddr, 4, devc->fm_info.name)) {
180 printk(KERN_WARNING "opl3: I/O port 0x%x already in use\n", ioaddr);
181 goto cleanup_devc;
182 }
183
184 devc->base = ioaddr;
185
186 /* Reset timers 1 and 2 */
187 opl3_command(ioaddr, TIMER_CONTROL_REGISTER, TIMER1_MASK | TIMER2_MASK);
188
189 /* Reset the IRQ of the FM chip */
190 opl3_command(ioaddr, TIMER_CONTROL_REGISTER, IRQ_RESET);
191
192 signature = stat1 = inb(ioaddr); /* Status register */
193
194 if (signature != 0x00 && signature != 0x06 && signature != 0x02 &&
195 signature != 0x0f)
196 {
197 MDB(printk(KERN_INFO "OPL3 not detected %x\n", signature));
198 goto cleanup_region;
199 }
200
201 if (signature == 0x06) /* OPL2 */
202 {
203 detected_model = 2;
204 }
205 else if (signature == 0x00 || signature == 0x0f) /* OPL3 or OPL4 */
206 {
207 unsigned char tmp;
208
209 detected_model = 3;
210
211 /*
212 * Detect availability of OPL4 (_experimental_). Works probably
213 * only after a cold boot. In addition the OPL4 port
214 * of the chip may not be connected to the PC bus at all.
215 */
216
217 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, 0x00);
218 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, OPL3_ENABLE | OPL4_ENABLE);
219
220 if ((tmp = inb(ioaddr)) == 0x02) /* Have a OPL4 */
221 {
222 detected_model = 4;
223 }
224
225 if (request_region(ioaddr - 8, 2, "OPL4")) /* OPL4 port was free */
226 {
227 int tmp;
228
229 outb((0x02), ioaddr - 8); /* Select OPL4 ID register */
230 udelay(10);
231 tmp = inb(ioaddr - 7); /* Read it */
232 udelay(10);
233
234 if (tmp == 0x20) /* OPL4 should return 0x20 here */
235 {
236 detected_model = 4;
237 outb((0xF8), ioaddr - 8); /* Select OPL4 FM mixer control */
238 udelay(10);
239 outb((0x1B), ioaddr - 7); /* Write value */
240 udelay(10);
241 }
242 else
243 { /* release OPL4 port */
244 release_region(ioaddr - 8, 2);
245 detected_model = 3;
246 }
247 }
248 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, 0);
249 }
250 for (i = 0; i < 9; i++)
251 opl3_command(ioaddr, KEYON_BLOCK + i, 0); /*
252 * Note off
253 */
254
255 opl3_command(ioaddr, TEST_REGISTER, ENABLE_WAVE_SELECT);
256 opl3_command(ioaddr, PERCOSSION_REGISTER, 0x00); /*
257 * Melodic mode.
258 */
259 return 1;
260 cleanup_region:
261 release_region(ioaddr, 4);
262 cleanup_devc:
263 kfree(devc);
264 devc = NULL;
265 return 0;
266 }
267
268 static int opl3_kill_note (int devno, int voice, int note, int velocity)
269 {
270 struct physical_voice_info *map;
271
272 if (voice < 0 || voice >= devc->nr_voice)
273 return 0;
274
275 devc->v_alloc->map[voice] = 0;
276
277 map = &pv_map[devc->lv_map[voice]];
278
279 if (map->voice_mode == 0)
280 return 0;
281
282 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, devc->voc[voice].keyon_byte & ~0x20);
283 devc->voc[voice].keyon_byte = 0;
284 devc->voc[voice].bender = 0;
285 devc->voc[voice].volume = 64;
286 devc->voc[voice].panning = 0xffff; /* Not set */
287 devc->voc[voice].bender_range = 200;
288 devc->voc[voice].orig_freq = 0;
289 devc->voc[voice].current_freq = 0;
290 devc->voc[voice].mode = 0;
291 return 0;
292 }
293
294 #define HIHAT 0
295 #define CYMBAL 1
296 #define TOMTOM 2
297 #define SNARE 3
298 #define BDRUM 4
299 #define UNDEFINED TOMTOM
300 #define DEFAULT TOMTOM
301
302 static int store_instr(int instr_no, struct sbi_instrument *instr)
303 {
304 if (instr->key != FM_PATCH && (instr->key != OPL3_PATCH || devc->model != 2))
305 printk(KERN_WARNING "FM warning: Invalid patch format field (key) 0x%x\n", instr->key);
306 memcpy((char *) &(devc->i_map[instr_no]), (char *) instr, sizeof(*instr));
307 return 0;
308 }
309
310 static int opl3_set_instr (int dev, int voice, int instr_no)
311 {
312 if (voice < 0 || voice >= devc->nr_voice)
313 return 0;
314 if (instr_no < 0 || instr_no >= SBFM_MAXINSTR)
315 instr_no = 0; /* Acoustic piano (usually) */
316
317 devc->act_i[voice] = &devc->i_map[instr_no];
318 return 0;
319 }
320
321 /*
322 * The next table looks magical, but it certainly is not. Its values have
323 * been calculated as table[i]=8*log(i/64)/log(2) with an obvious exception
324 * for i=0. This log-table converts a linear volume-scaling (0..127) to a
325 * logarithmic scaling as present in the FM-synthesizer chips. so : Volume
326 * 64 = 0 db = relative volume 0 and: Volume 32 = -6 db = relative
327 * volume -8 it was implemented as a table because it is only 128 bytes and
328 * it saves a lot of log() calculations. (RH)
329 */
330
331 static char fm_volume_table[128] =
332 {
333 -64, -48, -40, -35, -32, -29, -27, -26,
334 -24, -23, -21, -20, -19, -18, -18, -17,
335 -16, -15, -15, -14, -13, -13, -12, -12,
336 -11, -11, -10, -10, -10, -9, -9, -8,
337 -8, -8, -7, -7, -7, -6, -6, -6,
338 -5, -5, -5, -5, -4, -4, -4, -4,
339 -3, -3, -3, -3, -2, -2, -2, -2,
340 -2, -1, -1, -1, -1, 0, 0, 0,
341 0, 0, 0, 1, 1, 1, 1, 1,
342 1, 2, 2, 2, 2, 2, 2, 2,
343 3, 3, 3, 3, 3, 3, 3, 4,
344 4, 4, 4, 4, 4, 4, 4, 5,
345 5, 5, 5, 5, 5, 5, 5, 5,
346 6, 6, 6, 6, 6, 6, 6, 6,
347 6, 7, 7, 7, 7, 7, 7, 7,
348 7, 7, 7, 8, 8, 8, 8, 8
349 };
350
351 static void calc_vol(unsigned char *regbyte, int volume, int main_vol)
352 {
353 int level = (~*regbyte & 0x3f);
354
355 if (main_vol > 127)
356 main_vol = 127;
357 volume = (volume * main_vol) / 127;
358
359 if (level)
360 level += fm_volume_table[volume];
361
362 if (level > 0x3f)
363 level = 0x3f;
364 if (level < 0)
365 level = 0;
366
367 *regbyte = (*regbyte & 0xc0) | (~level & 0x3f);
368 }
369
370 static void set_voice_volume(int voice, int volume, int main_vol)
371 {
372 unsigned char vol1, vol2, vol3, vol4;
373 struct sbi_instrument *instr;
374 struct physical_voice_info *map;
375
376 if (voice < 0 || voice >= devc->nr_voice)
377 return;
378
379 map = &pv_map[devc->lv_map[voice]];
380 instr = devc->act_i[voice];
381
382 if (!instr)
383 instr = &devc->i_map[0];
384
385 if (instr->channel < 0)
386 return;
387
388 if (devc->voc[voice].mode == 0)
389 return;
390
391 if (devc->voc[voice].mode == 2)
392 {
393 vol1 = instr->operators[2];
394 vol2 = instr->operators[3];
395 if ((instr->operators[10] & 0x01))
396 {
397 calc_vol(&vol1, volume, main_vol);
398 calc_vol(&vol2, volume, main_vol);
399 }
400 else
401 {
402 calc_vol(&vol2, volume, main_vol);
403 }
404 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], vol1);
405 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], vol2);
406 }
407 else
408 { /*
409 * 4 OP voice
410 */
411 int connection;
412
413 vol1 = instr->operators[2];
414 vol2 = instr->operators[3];
415 vol3 = instr->operators[OFFS_4OP + 2];
416 vol4 = instr->operators[OFFS_4OP + 3];
417
418 /*
419 * The connection method for 4 OP devc->voc is defined by the rightmost
420 * bits at the offsets 10 and 10+OFFS_4OP
421 */
422
423 connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
424
425 switch (connection)
426 {
427 case 0:
428 calc_vol(&vol4, volume, main_vol);
429 break;
430
431 case 1:
432 calc_vol(&vol2, volume, main_vol);
433 calc_vol(&vol4, volume, main_vol);
434 break;
435
436 case 2:
437 calc_vol(&vol1, volume, main_vol);
438 calc_vol(&vol4, volume, main_vol);
439 break;
440
441 case 3:
442 calc_vol(&vol1, volume, main_vol);
443 calc_vol(&vol3, volume, main_vol);
444 calc_vol(&vol4, volume, main_vol);
445 break;
446
447 default:
448 ;
449 }
450 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], vol1);
451 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], vol2);
452 opl3_command(map->ioaddr, KSL_LEVEL + map->op[2], vol3);
453 opl3_command(map->ioaddr, KSL_LEVEL + map->op[3], vol4);
454 }
455 }
456
457 static int opl3_start_note (int dev, int voice, int note, int volume)
458 {
459 unsigned char data, fpc;
460 int block, fnum, freq, voice_mode, pan;
461 struct sbi_instrument *instr;
462 struct physical_voice_info *map;
463
464 if (voice < 0 || voice >= devc->nr_voice)
465 return 0;
466
467 map = &pv_map[devc->lv_map[voice]];
468 pan = devc->voc[voice].panning;
469
470 if (map->voice_mode == 0)
471 return 0;
472
473 if (note == 255) /*
474 * Just change the volume
475 */
476 {
477 set_voice_volume(voice, volume, devc->voc[voice].volume);
478 return 0;
479 }
480
481 /*
482 * Kill previous note before playing
483 */
484
485 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], 0xff); /*
486 * Carrier
487 * volume to
488 * min
489 */
490 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], 0xff); /*
491 * Modulator
492 * volume to
493 */
494
495 if (map->voice_mode == 4)
496 {
497 opl3_command(map->ioaddr, KSL_LEVEL + map->op[2], 0xff);
498 opl3_command(map->ioaddr, KSL_LEVEL + map->op[3], 0xff);
499 }
500
501 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, 0x00); /*
502 * Note
503 * off
504 */
505
506 instr = devc->act_i[voice];
507
508 if (!instr)
509 instr = &devc->i_map[0];
510
511 if (instr->channel < 0)
512 {
513 printk(KERN_WARNING "opl3: Initializing voice %d with undefined instrument\n", voice);
514 return 0;
515 }
516
517 if (map->voice_mode == 2 && instr->key == OPL3_PATCH)
518 return 0; /*
519 * Cannot play
520 */
521
522 voice_mode = map->voice_mode;
523
524 if (voice_mode == 4)
525 {
526 int voice_shift;
527
528 voice_shift = (map->ioaddr == devc->left_io) ? 0 : 3;
529 voice_shift += map->voice_num;
530
531 if (instr->key != OPL3_PATCH) /*
532 * Just 2 OP patch
533 */
534 {
535 voice_mode = 2;
536 devc->cmask &= ~(1 << voice_shift);
537 }
538 else
539 {
540 devc->cmask |= (1 << voice_shift);
541 }
542
543 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
544 }
545
546 /*
547 * Set Sound Characteristics
548 */
549
550 opl3_command(map->ioaddr, AM_VIB + map->op[0], instr->operators[0]);
551 opl3_command(map->ioaddr, AM_VIB + map->op[1], instr->operators[1]);
552
553 /*
554 * Set Attack/Decay
555 */
556
557 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[0], instr->operators[4]);
558 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[1], instr->operators[5]);
559
560 /*
561 * Set Sustain/Release
562 */
563
564 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[0], instr->operators[6]);
565 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[1], instr->operators[7]);
566
567 /*
568 * Set Wave Select
569 */
570
571 opl3_command(map->ioaddr, WAVE_SELECT + map->op[0], instr->operators[8]);
572 opl3_command(map->ioaddr, WAVE_SELECT + map->op[1], instr->operators[9]);
573
574 /*
575 * Set Feedback/Connection
576 */
577
578 fpc = instr->operators[10];
579
580 if (pan != 0xffff)
581 {
582 fpc &= ~STEREO_BITS;
583 if (pan < -64)
584 fpc |= VOICE_TO_LEFT;
585 else
586 if (pan > 64)
587 fpc |= VOICE_TO_RIGHT;
588 else
589 fpc |= (VOICE_TO_LEFT | VOICE_TO_RIGHT);
590 }
591
592 if (!(fpc & 0x30))
593 fpc |= 0x30; /*
594 * Ensure that at least one chn is enabled
595 */
596 opl3_command(map->ioaddr, FEEDBACK_CONNECTION + map->voice_num, fpc);
597
598 /*
599 * If the voice is a 4 OP one, initialize the operators 3 and 4 also
600 */
601
602 if (voice_mode == 4)
603 {
604 /*
605 * Set Sound Characteristics
606 */
607
608 opl3_command(map->ioaddr, AM_VIB + map->op[2], instr->operators[OFFS_4OP + 0]);
609 opl3_command(map->ioaddr, AM_VIB + map->op[3], instr->operators[OFFS_4OP + 1]);
610
611 /*
612 * Set Attack/Decay
613 */
614
615 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[2], instr->operators[OFFS_4OP + 4]);
616 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[3], instr->operators[OFFS_4OP + 5]);
617
618 /*
619 * Set Sustain/Release
620 */
621
622 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[2], instr->operators[OFFS_4OP + 6]);
623 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[3], instr->operators[OFFS_4OP + 7]);
624
625 /*
626 * Set Wave Select
627 */
628
629 opl3_command(map->ioaddr, WAVE_SELECT + map->op[2], instr->operators[OFFS_4OP + 8]);
630 opl3_command(map->ioaddr, WAVE_SELECT + map->op[3], instr->operators[OFFS_4OP + 9]);
631
632 /*
633 * Set Feedback/Connection
634 */
635
636 fpc = instr->operators[OFFS_4OP + 10];
637 if (!(fpc & 0x30))
638 fpc |= 0x30; /*
639 * Ensure that at least one chn is enabled
640 */
641 opl3_command(map->ioaddr, FEEDBACK_CONNECTION + map->voice_num + 3, fpc);
642 }
643
644 devc->voc[voice].mode = voice_mode;
645 set_voice_volume(voice, volume, devc->voc[voice].volume);
646
647 freq = devc->voc[voice].orig_freq = note_to_freq(note) / 1000;
648
649 /*
650 * Since the pitch bender may have been set before playing the note, we
651 * have to calculate the bending now.
652 */
653
654 freq = compute_finetune(devc->voc[voice].orig_freq, devc->voc[voice].bender, devc->voc[voice].bender_range, 0);
655 devc->voc[voice].current_freq = freq;
656
657 freq_to_fnum(freq, &block, &fnum);
658
659 /*
660 * Play note
661 */
662
663 data = fnum & 0xff; /*
664 * Least significant bits of fnumber
665 */
666 opl3_command(map->ioaddr, FNUM_LOW + map->voice_num, data);
667
668 data = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
669 devc->voc[voice].keyon_byte = data;
670 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, data);
671 if (voice_mode == 4)
672 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num + 3, data);
673
674 return 0;
675 }
676
677 static void freq_to_fnum (int freq, int *block, int *fnum)
678 {
679 int f, octave;
680
681 /*
682 * Converts the note frequency to block and fnum values for the FM chip
683 */
684 /*
685 * First try to compute the block -value (octave) where the note belongs
686 */
687
688 f = freq;
689
690 octave = 5;
691
692 if (f == 0)
693 octave = 0;
694 else if (f < 261)
695 {
696 while (f < 261)
697 {
698 octave--;
699 f <<= 1;
700 }
701 }
702 else if (f > 493)
703 {
704 while (f > 493)
705 {
706 octave++;
707 f >>= 1;
708 }
709 }
710
711 if (octave > 7)
712 octave = 7;
713
714 *fnum = freq * (1 << (20 - octave)) / 49716;
715 *block = octave;
716 }
717
718 static void opl3_command (int io_addr, unsigned int addr, unsigned int val)
719 {
720 int i;
721
722 /*
723 * The original 2-OP synth requires a quite long delay after writing to a
724 * register. The OPL-3 survives with just two INBs
725 */
726
727 outb(((unsigned char) (addr & 0xff)), io_addr);
728
729 if (devc->model != 2)
730 udelay(10);
731 else
732 for (i = 0; i < 2; i++)
733 inb(io_addr);
734
735 outb(((unsigned char) (val & 0xff)), io_addr + 1);
736
737 if (devc->model != 2)
738 udelay(30);
739 else
740 for (i = 0; i < 2; i++)
741 inb(io_addr);
742 }
743
744 static void opl3_reset(int devno)
745 {
746 int i;
747
748 for (i = 0; i < 18; i++)
749 devc->lv_map[i] = i;
750
751 for (i = 0; i < devc->nr_voice; i++)
752 {
753 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
754 KSL_LEVEL + pv_map[devc->lv_map[i]].op[0], 0xff);
755
756 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
757 KSL_LEVEL + pv_map[devc->lv_map[i]].op[1], 0xff);
758
759 if (pv_map[devc->lv_map[i]].voice_mode == 4)
760 {
761 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
762 KSL_LEVEL + pv_map[devc->lv_map[i]].op[2], 0xff);
763
764 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
765 KSL_LEVEL + pv_map[devc->lv_map[i]].op[3], 0xff);
766 }
767
768 opl3_kill_note(devno, i, 0, 64);
769 }
770
771 if (devc->model == 2)
772 {
773 devc->v_alloc->max_voice = devc->nr_voice = 18;
774
775 for (i = 0; i < 18; i++)
776 pv_map[i].voice_mode = 2;
777
778 }
779 }
780
781 static int opl3_open(int dev, int mode)
782 {
783 int i;
784
785 if (devc->busy)
786 return -EBUSY;
787 devc->busy = 1;
788
789 devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
790 devc->v_alloc->timestamp = 0;
791
792 for (i = 0; i < 18; i++)
793 {
794 devc->v_alloc->map[i] = 0;
795 devc->v_alloc->alloc_times[i] = 0;
796 }
797
798 devc->cmask = 0x00; /*
799 * Just 2 OP mode
800 */
801 if (devc->model == 2)
802 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
803 return 0;
804 }
805
806 static void opl3_close(int dev)
807 {
808 devc->busy = 0;
809 devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
810
811 devc->fm_info.nr_drums = 0;
812 devc->fm_info.perc_mode = 0;
813
814 opl3_reset(dev);
815 }
816
817 static void opl3_hw_control(int dev, unsigned char *event)
818 {
819 }
820
821 static int opl3_load_patch(int dev, int format, const char __user *addr,
822 int count, int pmgr_flag)
823 {
824 struct sbi_instrument ins;
825
826 if (count <sizeof(ins))
827 {
828 printk(KERN_WARNING "FM Error: Patch record too short\n");
829 return -EINVAL;
830 }
831
832 if (copy_from_user(&ins, addr, sizeof(ins)))
833 return -EFAULT;
834
835 if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR)
836 {
837 printk(KERN_WARNING "FM Error: Invalid instrument number %d\n", ins.channel);
838 return -EINVAL;
839 }
840 ins.key = format;
841
842 return store_instr(ins.channel, &ins);
843 }
844
845 static void opl3_panning(int dev, int voice, int value)
846 {
847
848 if (voice < 0 || voice >= devc->nr_voice)
849 return;
850
851 devc->voc[voice].panning = value;
852 }
853
854 static void opl3_volume_method(int dev, int mode)
855 {
856 }
857
858 #define SET_VIBRATO(cell) { \
859 tmp = instr->operators[(cell-1)+(((cell-1)/2)*OFFS_4OP)]; \
860 if (pressure > 110) \
861 tmp |= 0x40; /* Vibrato on */ \
862 opl3_command (map->ioaddr, AM_VIB + map->op[cell-1], tmp);}
863
864 static void opl3_aftertouch(int dev, int voice, int pressure)
865 {
866 int tmp;
867 struct sbi_instrument *instr;
868 struct physical_voice_info *map;
869
870 if (voice < 0 || voice >= devc->nr_voice)
871 return;
872
873 map = &pv_map[devc->lv_map[voice]];
874
875 if (map->voice_mode == 0)
876 return;
877
878 /*
879 * Adjust the amount of vibrato depending the pressure
880 */
881
882 instr = devc->act_i[voice];
883
884 if (!instr)
885 instr = &devc->i_map[0];
886
887 if (devc->voc[voice].mode == 4)
888 {
889 int connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
890
891 switch (connection)
892 {
893 case 0:
894 SET_VIBRATO(4);
895 break;
896
897 case 1:
898 SET_VIBRATO(2);
899 SET_VIBRATO(4);
900 break;
901
902 case 2:
903 SET_VIBRATO(1);
904 SET_VIBRATO(4);
905 break;
906
907 case 3:
908 SET_VIBRATO(1);
909 SET_VIBRATO(3);
910 SET_VIBRATO(4);
911 break;
912
913 }
914 /*
915 * Not implemented yet
916 */
917 }
918 else
919 {
920 SET_VIBRATO(1);
921
922 if ((instr->operators[10] & 0x01)) /*
923 * Additive synthesis
924 */
925 SET_VIBRATO(2);
926 }
927 }
928
929 #undef SET_VIBRATO
930
931 static void bend_pitch(int dev, int voice, int value)
932 {
933 unsigned char data;
934 int block, fnum, freq;
935 struct physical_voice_info *map;
936
937 map = &pv_map[devc->lv_map[voice]];
938
939 if (map->voice_mode == 0)
940 return;
941
942 devc->voc[voice].bender = value;
943 if (!value)
944 return;
945 if (!(devc->voc[voice].keyon_byte & 0x20))
946 return; /*
947 * Not keyed on
948 */
949
950 freq = compute_finetune(devc->voc[voice].orig_freq, devc->voc[voice].bender, devc->voc[voice].bender_range, 0);
951 devc->voc[voice].current_freq = freq;
952
953 freq_to_fnum(freq, &block, &fnum);
954
955 data = fnum & 0xff; /*
956 * Least significant bits of fnumber
957 */
958 opl3_command(map->ioaddr, FNUM_LOW + map->voice_num, data);
959
960 data = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
961 devc->voc[voice].keyon_byte = data;
962 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, data);
963 }
964
965 static void opl3_controller (int dev, int voice, int ctrl_num, int value)
966 {
967 if (voice < 0 || voice >= devc->nr_voice)
968 return;
969
970 switch (ctrl_num)
971 {
972 case CTRL_PITCH_BENDER:
973 bend_pitch(dev, voice, value);
974 break;
975
976 case CTRL_PITCH_BENDER_RANGE:
977 devc->voc[voice].bender_range = value;
978 break;
979
980 case CTL_MAIN_VOLUME:
981 devc->voc[voice].volume = value / 128;
982 break;
983
984 case CTL_PAN:
985 devc->voc[voice].panning = (value * 2) - 128;
986 break;
987 }
988 }
989
990 static void opl3_bender(int dev, int voice, int value)
991 {
992 if (voice < 0 || voice >= devc->nr_voice)
993 return;
994
995 bend_pitch(dev, voice, value - 8192);
996 }
997
998 static int opl3_alloc_voice(int dev, int chn, int note, struct voice_alloc_info *alloc)
999 {
1000 int i, p, best, first, avail, best_time = 0x7fffffff;
1001 struct sbi_instrument *instr;
1002 int is4op;
1003 int instr_no;
1004
1005 if (chn < 0 || chn > 15)
1006 instr_no = 0;
1007 else
1008 instr_no = devc->chn_info[chn].pgm_num;
1009
1010 instr = &devc->i_map[instr_no];
1011 if (instr->channel < 0 || /* Instrument not loaded */
1012 devc->nr_voice != 12) /* Not in 4 OP mode */
1013 is4op = 0;
1014 else if (devc->nr_voice == 12) /* 4 OP mode */
1015 is4op = (instr->key == OPL3_PATCH);
1016 else
1017 is4op = 0;
1018
1019 if (is4op)
1020 {
1021 first = p = 0;
1022 avail = 6;
1023 }
1024 else
1025 {
1026 if (devc->nr_voice == 12) /* 4 OP mode. Use the '2 OP only' operators first */
1027 first = p = 6;
1028 else
1029 first = p = 0;
1030 avail = devc->nr_voice;
1031 }
1032
1033 /*
1034 * Now try to find a free voice
1035 */
1036 best = first;
1037
1038 for (i = 0; i < avail; i++)
1039 {
1040 if (alloc->map[p] == 0)
1041 {
1042 return p;
1043 }
1044 if (alloc->alloc_times[p] < best_time) /* Find oldest playing note */
1045 {
1046 best_time = alloc->alloc_times[p];
1047 best = p;
1048 }
1049 p = (p + 1) % avail;
1050 }
1051
1052 /*
1053 * Insert some kind of priority mechanism here.
1054 */
1055
1056 if (best < 0)
1057 best = 0;
1058 if (best > devc->nr_voice)
1059 best -= devc->nr_voice;
1060
1061 return best; /* All devc->voc in use. Select the first one. */
1062 }
1063
1064 static void opl3_setup_voice(int dev, int voice, int chn)
1065 {
1066 struct channel_info *info;
1067
1068 if (voice < 0 || voice >= devc->nr_voice)
1069 return;
1070
1071 if (chn < 0 || chn > 15)
1072 return;
1073
1074 info = &synth_devs[dev]->chn_info[chn];
1075
1076 opl3_set_instr(dev, voice, info->pgm_num);
1077
1078 devc->voc[voice].bender = 0;
1079 devc->voc[voice].bender_range = info->bender_range;
1080 devc->voc[voice].volume = info->controllers[CTL_MAIN_VOLUME];
1081 devc->voc[voice].panning = (info->controllers[CTL_PAN] * 2) - 128;
1082 }
1083
1084 static struct synth_operations opl3_operations =
1085 {
1086 .owner = THIS_MODULE,
1087 .id = "OPL",
1088 .info = NULL,
1089 .midi_dev = 0,
1090 .synth_type = SYNTH_TYPE_FM,
1091 .synth_subtype = FM_TYPE_ADLIB,
1092 .open = opl3_open,
1093 .close = opl3_close,
1094 .ioctl = opl3_ioctl,
1095 .kill_note = opl3_kill_note,
1096 .start_note = opl3_start_note,
1097 .set_instr = opl3_set_instr,
1098 .reset = opl3_reset,
1099 .hw_control = opl3_hw_control,
1100 .load_patch = opl3_load_patch,
1101 .aftertouch = opl3_aftertouch,
1102 .controller = opl3_controller,
1103 .panning = opl3_panning,
1104 .volume_method = opl3_volume_method,
1105 .bender = opl3_bender,
1106 .alloc_voice = opl3_alloc_voice,
1107 .setup_voice = opl3_setup_voice
1108 };
1109
1110 static int opl3_init(int ioaddr, struct module *owner)
1111 {
1112 int i;
1113 int me;
1114
1115 if (devc == NULL)
1116 {
1117 printk(KERN_ERR "opl3: Device control structure not initialized.\n");
1118 return -1;
1119 }
1120
1121 if ((me = sound_alloc_synthdev()) == -1)
1122 {
1123 printk(KERN_WARNING "opl3: Too many synthesizers\n");
1124 return -1;
1125 }
1126
1127 devc->nr_voice = 9;
1128
1129 devc->fm_info.device = 0;
1130 devc->fm_info.synth_type = SYNTH_TYPE_FM;
1131 devc->fm_info.synth_subtype = FM_TYPE_ADLIB;
1132 devc->fm_info.perc_mode = 0;
1133 devc->fm_info.nr_voices = 9;
1134 devc->fm_info.nr_drums = 0;
1135 devc->fm_info.instr_bank_size = SBFM_MAXINSTR;
1136 devc->fm_info.capabilities = 0;
1137 devc->left_io = ioaddr;
1138 devc->right_io = ioaddr + 2;
1139
1140 if (detected_model <= 2)
1141 devc->model = 1;
1142 else
1143 {
1144 devc->model = 2;
1145 if (detected_model == 4)
1146 devc->is_opl4 = 1;
1147 }
1148
1149 opl3_operations.info = &devc->fm_info;
1150
1151 synth_devs[me] = &opl3_operations;
1152
1153 if (owner)
1154 synth_devs[me]->owner = owner;
1155
1156 sequencer_init();
1157 devc->v_alloc = &opl3_operations.alloc;
1158 devc->chn_info = &opl3_operations.chn_info[0];
1159
1160 if (devc->model == 2)
1161 {
1162 if (devc->is_opl4)
1163 strcpy(devc->fm_info.name, "Yamaha OPL4/OPL3 FM");
1164 else
1165 strcpy(devc->fm_info.name, "Yamaha OPL3");
1166
1167 devc->v_alloc->max_voice = devc->nr_voice = 18;
1168 devc->fm_info.nr_drums = 0;
1169 devc->fm_info.synth_subtype = FM_TYPE_OPL3;
1170 devc->fm_info.capabilities |= SYNTH_CAP_OPL3;
1171
1172 for (i = 0; i < 18; i++)
1173 {
1174 if (pv_map[i].ioaddr == USE_LEFT)
1175 pv_map[i].ioaddr = devc->left_io;
1176 else
1177 pv_map[i].ioaddr = devc->right_io;
1178 }
1179 opl3_command(devc->right_io, OPL3_MODE_REGISTER, OPL3_ENABLE);
1180 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, 0x00);
1181 }
1182 else
1183 {
1184 strcpy(devc->fm_info.name, "Yamaha OPL2");
1185 devc->v_alloc->max_voice = devc->nr_voice = 9;
1186 devc->fm_info.nr_drums = 0;
1187
1188 for (i = 0; i < 18; i++)
1189 pv_map[i].ioaddr = devc->left_io;
1190 }
1191 conf_printf2(devc->fm_info.name, ioaddr, 0, -1, -1);
1192
1193 for (i = 0; i < SBFM_MAXINSTR; i++)
1194 devc->i_map[i].channel = -1;
1195
1196 return me;
1197 }
1198
1199 static int me;
1200
1201 static int io = -1;
1202
1203 module_param(io, int, 0);
1204
1205 static int __init init_opl3 (void)
1206 {
1207 printk(KERN_INFO "YM3812 and OPL-3 driver Copyright (C) by Hannu Savolainen, Rob Hooft 1993-1996\n");
1208
1209 if (io != -1) /* User loading pure OPL3 module */
1210 {
1211 if (!opl3_detect(io))
1212 {
1213 return -ENODEV;
1214 }
1215
1216 me = opl3_init(io, THIS_MODULE);
1217 }
1218
1219 return 0;
1220 }
1221
1222 static void __exit cleanup_opl3(void)
1223 {
1224 if (devc && io != -1)
1225 {
1226 if (devc->base) {
1227 release_region(devc->base,4);
1228 if (devc->is_opl4)
1229 release_region(devc->base - 8, 2);
1230 }
1231 kfree(devc);
1232 devc = NULL;
1233 sound_unload_synthdev(me);
1234 }
1235 }
1236
1237 module_init(init_opl3);
1238 module_exit(cleanup_opl3);
1239
1240 #ifndef MODULE
1241 static int __init setup_opl3(char *str)
1242 {
1243 /* io */
1244 int ints[2];
1245
1246 str = get_options(str, ARRAY_SIZE(ints), ints);
1247
1248 io = ints[1];
1249
1250 return 1;
1251 }
1252
1253 __setup("opl3=", setup_opl3);
1254 #endif
1255 MODULE_LICENSE("GPL");
Linux with added FPC-III support