4 * A low level driver for Yamaha YM3812 and OPL-3 -chips
7 * Copyright (C) by Hannu Savolainen 1993-1997
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
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.
22 * Believed to work. Badly needs rewriting a bit to support multiple
26 #include <linux/init.h>
27 #include <linux/module.h>
28 #include <linux/delay.h>
31 * Major improvements to the FM handling 30AUG92 by Rob Hooft,
35 #include "sound_config.h"
45 unsigned char keyon_byte;
48 unsigned long orig_freq;
49 unsigned long current_freq;
52 int panning; /* 0xffff means not set */
55 typedef struct opl_devinfo
58 int left_io, right_io;
60 int lv_map[MAX_VOICE];
62 struct voice_info voc[MAX_VOICE];
63 struct voice_alloc_info *v_alloc;
64 struct channel_info *chn_info;
66 struct sbi_instrument i_map[SBFM_MAXINSTR];
67 struct sbi_instrument *act_i[MAX_VOICE];
69 struct synth_info fm_info;
79 static struct opl_devinfo *devc = NULL;
81 static int detected_model;
83 static int store_instr(int instr_no, struct sbi_instrument *instr);
84 static void freq_to_fnum(int freq, int *block, int *fnum);
85 static void opl3_command(int io_addr, unsigned int addr, unsigned int val);
86 static int opl3_kill_note(int dev, int voice, int note, int velocity);
88 static void enter_4op_mode(void)
91 static int v4op[MAX_VOICE] = {
92 0, 1, 2, 9, 10, 11, 6, 7, 8, 15, 16, 17
95 devc->cmask = 0x3f; /* Connect all possible 4 OP voice operators */
96 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, 0x3f);
98 for (i = 0; i < 3; i++)
99 pv_map[i].voice_mode = 4;
100 for (i = 3; i < 6; i++)
101 pv_map[i].voice_mode = 0;
103 for (i = 9; i < 12; i++)
104 pv_map[i].voice_mode = 4;
105 for (i = 12; i < 15; i++)
106 pv_map[i].voice_mode = 0;
108 for (i = 0; i < 12; i++)
109 devc->lv_map[i] = v4op[i];
110 devc->v_alloc->max_voice = devc->nr_voice = 12;
113 static int opl3_ioctl(int dev, unsigned int cmd, caddr_t arg)
115 struct sbi_instrument ins;
118 case SNDCTL_FM_LOAD_INSTR:
119 printk(KERN_WARNING "Warning: Obsolete ioctl(SNDCTL_FM_LOAD_INSTR) used. Fix the program.\n");
120 if (copy_from_user(&ins, arg, sizeof(ins)))
122 if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR) {
123 printk(KERN_WARNING "FM Error: Invalid instrument number %d\n", ins.channel);
126 return store_instr(ins.channel, &ins);
128 case SNDCTL_SYNTH_INFO:
129 devc->fm_info.nr_voices = (devc->nr_voice == 12) ? 6 : devc->nr_voice;
130 if (copy_to_user(arg, &devc->fm_info, sizeof(devc->fm_info)))
134 case SNDCTL_SYNTH_MEMAVL:
137 case SNDCTL_FM_4OP_ENABLE:
138 if (devc->model == 2)
147 int opl3_detect(int ioaddr, int *osp)
150 * This function returns 1 if the FM chip is present at the given I/O port
151 * The detection algorithm plays with the timer built in the FM chip and
152 * looks for a change in the status register.
154 * Note! The timers of the FM chip are not connected to AdLib (and compatible)
157 * Note2! The chip is initialized if detected.
160 unsigned char stat1, signature;
165 printk(KERN_ERR "opl3: Only one OPL3 supported.\n");
169 devc = (struct opl_devinfo *)kmalloc(sizeof(*devc), GFP_KERNEL);
173 printk(KERN_ERR "opl3: Can't allocate memory for the device control "
178 memset(devc, 0, sizeof(*devc));
179 strcpy(devc->fm_info.name, "OPL2");
181 if (!request_region(ioaddr, 4, devc->fm_info.name)) {
182 printk(KERN_WARNING "opl3: I/O port 0x%x already in use\n", ioaddr);
189 /* Reset timers 1 and 2 */
190 opl3_command(ioaddr, TIMER_CONTROL_REGISTER, TIMER1_MASK | TIMER2_MASK);
192 /* Reset the IRQ of the FM chip */
193 opl3_command(ioaddr, TIMER_CONTROL_REGISTER, IRQ_RESET);
195 signature = stat1 = inb(ioaddr); /* Status register */
197 if (signature != 0x00 && signature != 0x06 && signature != 0x02 &&
200 MDB(printk(KERN_INFO "OPL3 not detected %x\n", signature));
204 if (signature == 0x06) /* OPL2 */
208 else if (signature == 0x00 || signature == 0x0f) /* OPL3 or OPL4 */
215 * Detect availability of OPL4 (_experimental_). Works probably
216 * only after a cold boot. In addition the OPL4 port
217 * of the chip may not be connected to the PC bus at all.
220 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, 0x00);
221 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, OPL3_ENABLE | OPL4_ENABLE);
223 if ((tmp = inb(ioaddr)) == 0x02) /* Have a OPL4 */
228 if (request_region(ioaddr - 8, 2, "OPL4")) /* OPL4 port was free */
232 outb((0x02), ioaddr - 8); /* Select OPL4 ID register */
234 tmp = inb(ioaddr - 7); /* Read it */
237 if (tmp == 0x20) /* OPL4 should return 0x20 here */
240 outb((0xF8), ioaddr - 8); /* Select OPL4 FM mixer control */
242 outb((0x1B), ioaddr - 7); /* Write value */
246 { /* release OPL4 port */
247 release_region(ioaddr - 8, 2);
251 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, 0);
253 for (i = 0; i < 9; i++)
254 opl3_command(ioaddr, KEYON_BLOCK + i, 0); /*
258 opl3_command(ioaddr, TEST_REGISTER, ENABLE_WAVE_SELECT);
259 opl3_command(ioaddr, PERCOSSION_REGISTER, 0x00); /*
264 release_region(ioaddr, 4);
271 static int opl3_kill_note (int devno, int voice, int note, int velocity)
273 struct physical_voice_info *map;
275 if (voice < 0 || voice >= devc->nr_voice)
278 devc->v_alloc->map[voice] = 0;
280 map = &pv_map[devc->lv_map[voice]];
281 DEB(printk("Kill note %d\n", voice));
283 if (map->voice_mode == 0)
286 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, devc->voc[voice].keyon_byte & ~0x20);
287 devc->voc[voice].keyon_byte = 0;
288 devc->voc[voice].bender = 0;
289 devc->voc[voice].volume = 64;
290 devc->voc[voice].panning = 0xffff; /* Not set */
291 devc->voc[voice].bender_range = 200;
292 devc->voc[voice].orig_freq = 0;
293 devc->voc[voice].current_freq = 0;
294 devc->voc[voice].mode = 0;
303 #define UNDEFINED TOMTOM
304 #define DEFAULT TOMTOM
306 static int store_instr(int instr_no, struct sbi_instrument *instr)
308 if (instr->key != FM_PATCH && (instr->key != OPL3_PATCH || devc->model != 2))
309 printk(KERN_WARNING "FM warning: Invalid patch format field (key) 0x%x\n", instr->key);
310 memcpy((char *) &(devc->i_map[instr_no]), (char *) instr, sizeof(*instr));
314 static int opl3_set_instr (int dev, int voice, int instr_no)
316 if (voice < 0 || voice >= devc->nr_voice)
318 if (instr_no < 0 || instr_no >= SBFM_MAXINSTR)
319 instr_no = 0; /* Acoustic piano (usually) */
321 devc->act_i[voice] = &devc->i_map[instr_no];
326 * The next table looks magical, but it certainly is not. Its values have
327 * been calculated as table[i]=8*log(i/64)/log(2) with an obvious exception
328 * for i=0. This log-table converts a linear volume-scaling (0..127) to a
329 * logarithmic scaling as present in the FM-synthesizer chips. so : Volume
330 * 64 = 0 db = relative volume 0 and: Volume 32 = -6 db = relative
331 * volume -8 it was implemented as a table because it is only 128 bytes and
332 * it saves a lot of log() calculations. (RH)
335 static char fm_volume_table[128] =
337 -64, -48, -40, -35, -32, -29, -27, -26,
338 -24, -23, -21, -20, -19, -18, -18, -17,
339 -16, -15, -15, -14, -13, -13, -12, -12,
340 -11, -11, -10, -10, -10, -9, -9, -8,
341 -8, -8, -7, -7, -7, -6, -6, -6,
342 -5, -5, -5, -5, -4, -4, -4, -4,
343 -3, -3, -3, -3, -2, -2, -2, -2,
344 -2, -1, -1, -1, -1, 0, 0, 0,
345 0, 0, 0, 1, 1, 1, 1, 1,
346 1, 2, 2, 2, 2, 2, 2, 2,
347 3, 3, 3, 3, 3, 3, 3, 4,
348 4, 4, 4, 4, 4, 4, 4, 5,
349 5, 5, 5, 5, 5, 5, 5, 5,
350 6, 6, 6, 6, 6, 6, 6, 6,
351 6, 7, 7, 7, 7, 7, 7, 7,
352 7, 7, 7, 8, 8, 8, 8, 8
355 static void calc_vol(unsigned char *regbyte, int volume, int main_vol)
357 int level = (~*regbyte & 0x3f);
361 volume = (volume * main_vol) / 127;
364 level += fm_volume_table[volume];
371 *regbyte = (*regbyte & 0xc0) | (~level & 0x3f);
374 static void set_voice_volume(int voice, int volume, int main_vol)
376 unsigned char vol1, vol2, vol3, vol4;
377 struct sbi_instrument *instr;
378 struct physical_voice_info *map;
380 if (voice < 0 || voice >= devc->nr_voice)
383 map = &pv_map[devc->lv_map[voice]];
384 instr = devc->act_i[voice];
387 instr = &devc->i_map[0];
389 if (instr->channel < 0)
392 if (devc->voc[voice].mode == 0)
395 if (devc->voc[voice].mode == 2)
397 vol1 = instr->operators[2];
398 vol2 = instr->operators[3];
399 if ((instr->operators[10] & 0x01))
401 calc_vol(&vol1, volume, main_vol);
402 calc_vol(&vol2, volume, main_vol);
406 calc_vol(&vol2, volume, main_vol);
408 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], vol1);
409 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], vol2);
417 vol1 = instr->operators[2];
418 vol2 = instr->operators[3];
419 vol3 = instr->operators[OFFS_4OP + 2];
420 vol4 = instr->operators[OFFS_4OP + 3];
423 * The connection method for 4 OP devc->voc is defined by the rightmost
424 * bits at the offsets 10 and 10+OFFS_4OP
427 connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
432 calc_vol(&vol4, volume, main_vol);
436 calc_vol(&vol2, volume, main_vol);
437 calc_vol(&vol4, volume, main_vol);
441 calc_vol(&vol1, volume, main_vol);
442 calc_vol(&vol4, volume, main_vol);
446 calc_vol(&vol1, volume, main_vol);
447 calc_vol(&vol3, volume, main_vol);
448 calc_vol(&vol4, volume, main_vol);
454 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], vol1);
455 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], vol2);
456 opl3_command(map->ioaddr, KSL_LEVEL + map->op[2], vol3);
457 opl3_command(map->ioaddr, KSL_LEVEL + map->op[3], vol4);
461 static int opl3_start_note (int dev, int voice, int note, int volume)
463 unsigned char data, fpc;
464 int block, fnum, freq, voice_mode, pan;
465 struct sbi_instrument *instr;
466 struct physical_voice_info *map;
468 if (voice < 0 || voice >= devc->nr_voice)
471 map = &pv_map[devc->lv_map[voice]];
472 pan = devc->voc[voice].panning;
474 if (map->voice_mode == 0)
478 * Just change the volume
481 set_voice_volume(voice, volume, devc->voc[voice].volume);
486 * Kill previous note before playing
489 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], 0xff); /*
494 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], 0xff); /*
499 if (map->voice_mode == 4)
501 opl3_command(map->ioaddr, KSL_LEVEL + map->op[2], 0xff);
502 opl3_command(map->ioaddr, KSL_LEVEL + map->op[3], 0xff);
505 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, 0x00); /*
510 instr = devc->act_i[voice];
513 instr = &devc->i_map[0];
515 if (instr->channel < 0)
517 printk(KERN_WARNING "opl3: Initializing voice %d with undefined instrument\n", voice);
521 if (map->voice_mode == 2 && instr->key == OPL3_PATCH)
526 voice_mode = map->voice_mode;
532 voice_shift = (map->ioaddr == devc->left_io) ? 0 : 3;
533 voice_shift += map->voice_num;
535 if (instr->key != OPL3_PATCH) /*
540 devc->cmask &= ~(1 << voice_shift);
544 devc->cmask |= (1 << voice_shift);
547 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
551 * Set Sound Characteristics
554 opl3_command(map->ioaddr, AM_VIB + map->op[0], instr->operators[0]);
555 opl3_command(map->ioaddr, AM_VIB + map->op[1], instr->operators[1]);
561 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[0], instr->operators[4]);
562 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[1], instr->operators[5]);
565 * Set Sustain/Release
568 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[0], instr->operators[6]);
569 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[1], instr->operators[7]);
575 opl3_command(map->ioaddr, WAVE_SELECT + map->op[0], instr->operators[8]);
576 opl3_command(map->ioaddr, WAVE_SELECT + map->op[1], instr->operators[9]);
579 * Set Feedback/Connection
582 fpc = instr->operators[10];
588 fpc |= VOICE_TO_LEFT;
591 fpc |= VOICE_TO_RIGHT;
593 fpc |= (VOICE_TO_LEFT | VOICE_TO_RIGHT);
598 * Ensure that at least one chn is enabled
600 opl3_command(map->ioaddr, FEEDBACK_CONNECTION + map->voice_num, fpc);
603 * If the voice is a 4 OP one, initialize the operators 3 and 4 also
609 * Set Sound Characteristics
612 opl3_command(map->ioaddr, AM_VIB + map->op[2], instr->operators[OFFS_4OP + 0]);
613 opl3_command(map->ioaddr, AM_VIB + map->op[3], instr->operators[OFFS_4OP + 1]);
619 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[2], instr->operators[OFFS_4OP + 4]);
620 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[3], instr->operators[OFFS_4OP + 5]);
623 * Set Sustain/Release
626 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[2], instr->operators[OFFS_4OP + 6]);
627 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[3], instr->operators[OFFS_4OP + 7]);
633 opl3_command(map->ioaddr, WAVE_SELECT + map->op[2], instr->operators[OFFS_4OP + 8]);
634 opl3_command(map->ioaddr, WAVE_SELECT + map->op[3], instr->operators[OFFS_4OP + 9]);
637 * Set Feedback/Connection
640 fpc = instr->operators[OFFS_4OP + 10];
643 * Ensure that at least one chn is enabled
645 opl3_command(map->ioaddr, FEEDBACK_CONNECTION + map->voice_num + 3, fpc);
648 devc->voc[voice].mode = voice_mode;
649 set_voice_volume(voice, volume, devc->voc[voice].volume);
651 freq = devc->voc[voice].orig_freq = note_to_freq(note) / 1000;
654 * Since the pitch bender may have been set before playing the note, we
655 * have to calculate the bending now.
658 freq = compute_finetune(devc->voc[voice].orig_freq, devc->voc[voice].bender, devc->voc[voice].bender_range, 0);
659 devc->voc[voice].current_freq = freq;
661 freq_to_fnum(freq, &block, &fnum);
667 data = fnum & 0xff; /*
668 * Least significant bits of fnumber
670 opl3_command(map->ioaddr, FNUM_LOW + map->voice_num, data);
672 data = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
673 devc->voc[voice].keyon_byte = data;
674 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, data);
676 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num + 3, data);
681 static void freq_to_fnum (int freq, int *block, int *fnum)
686 * Converts the note frequency to block and fnum values for the FM chip
689 * First try to compute the block -value (octave) where the note belongs
718 *fnum = freq * (1 << (20 - octave)) / 49716;
722 static void opl3_command (int io_addr, unsigned int addr, unsigned int val)
727 * The original 2-OP synth requires a quite long delay after writing to a
728 * register. The OPL-3 survives with just two INBs
731 outb(((unsigned char) (addr & 0xff)), io_addr);
733 if (devc->model != 2)
736 for (i = 0; i < 2; i++)
739 outb(((unsigned char) (val & 0xff)), io_addr + 1);
741 if (devc->model != 2)
744 for (i = 0; i < 2; i++)
748 static void opl3_reset(int devno)
752 for (i = 0; i < 18; i++)
755 for (i = 0; i < devc->nr_voice; i++)
757 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
758 KSL_LEVEL + pv_map[devc->lv_map[i]].op[0], 0xff);
760 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
761 KSL_LEVEL + pv_map[devc->lv_map[i]].op[1], 0xff);
763 if (pv_map[devc->lv_map[i]].voice_mode == 4)
765 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
766 KSL_LEVEL + pv_map[devc->lv_map[i]].op[2], 0xff);
768 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
769 KSL_LEVEL + pv_map[devc->lv_map[i]].op[3], 0xff);
772 opl3_kill_note(devno, i, 0, 64);
775 if (devc->model == 2)
777 devc->v_alloc->max_voice = devc->nr_voice = 18;
779 for (i = 0; i < 18; i++)
780 pv_map[i].voice_mode = 2;
785 static int opl3_open(int dev, int mode)
793 devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
794 devc->v_alloc->timestamp = 0;
796 for (i = 0; i < 18; i++)
798 devc->v_alloc->map[i] = 0;
799 devc->v_alloc->alloc_times[i] = 0;
802 devc->cmask = 0x00; /*
805 if (devc->model == 2)
806 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
810 static void opl3_close(int dev)
813 devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
815 devc->fm_info.nr_drums = 0;
816 devc->fm_info.perc_mode = 0;
821 static void opl3_hw_control(int dev, unsigned char *event)
825 static int opl3_load_patch(int dev, int format, const char *addr,
826 int offs, int count, int pmgr_flag)
828 struct sbi_instrument ins;
830 if (count <sizeof(ins))
832 printk(KERN_WARNING "FM Error: Patch record too short\n");
836 if(copy_from_user(&((char *) &ins)[offs], &(addr)[offs], sizeof(ins) - offs))
839 if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR)
841 printk(KERN_WARNING "FM Error: Invalid instrument number %d\n", ins.channel);
846 return store_instr(ins.channel, &ins);
849 static void opl3_panning(int dev, int voice, int value)
851 devc->voc[voice].panning = value;
854 static void opl3_volume_method(int dev, int mode)
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);}
864 static void opl3_aftertouch(int dev, int voice, int pressure)
867 struct sbi_instrument *instr;
868 struct physical_voice_info *map;
870 if (voice < 0 || voice >= devc->nr_voice)
873 map = &pv_map[devc->lv_map[voice]];
875 DEB(printk("Aftertouch %d\n", voice));
877 if (map->voice_mode == 0)
881 * Adjust the amount of vibrato depending the pressure
884 instr = devc->act_i[voice];
887 instr = &devc->i_map[0];
889 if (devc->voc[voice].mode == 4)
891 int connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
917 * Not implemented yet
924 if ((instr->operators[10] & 0x01)) /*
933 static void bend_pitch(int dev, int voice, int value)
936 int block, fnum, freq;
937 struct physical_voice_info *map;
939 map = &pv_map[devc->lv_map[voice]];
941 if (map->voice_mode == 0)
944 devc->voc[voice].bender = value;
947 if (!(devc->voc[voice].keyon_byte & 0x20))
952 freq = compute_finetune(devc->voc[voice].orig_freq, devc->voc[voice].bender, devc->voc[voice].bender_range, 0);
953 devc->voc[voice].current_freq = freq;
955 freq_to_fnum(freq, &block, &fnum);
957 data = fnum & 0xff; /*
958 * Least significant bits of fnumber
960 opl3_command(map->ioaddr, FNUM_LOW + map->voice_num, data);
962 data = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
963 devc->voc[voice].keyon_byte = data;
964 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, data);
967 static void opl3_controller (int dev, int voice, int ctrl_num, int value)
969 if (voice < 0 || voice >= devc->nr_voice)
974 case CTRL_PITCH_BENDER:
975 bend_pitch(dev, voice, value);
978 case CTRL_PITCH_BENDER_RANGE:
979 devc->voc[voice].bender_range = value;
982 case CTL_MAIN_VOLUME:
983 devc->voc[voice].volume = value / 128;
987 devc->voc[voice].panning = (value * 2) - 128;
992 static void opl3_bender(int dev, int voice, int value)
994 if (voice < 0 || voice >= devc->nr_voice)
997 bend_pitch(dev, voice, value - 8192);
1000 static int opl3_alloc_voice(int dev, int chn, int note, struct voice_alloc_info *alloc)
1002 int i, p, best, first, avail, best_time = 0x7fffffff;
1003 struct sbi_instrument *instr;
1007 if (chn < 0 || chn > 15)
1010 instr_no = devc->chn_info[chn].pgm_num;
1012 instr = &devc->i_map[instr_no];
1013 if (instr->channel < 0 || /* Instrument not loaded */
1014 devc->nr_voice != 12) /* Not in 4 OP mode */
1016 else if (devc->nr_voice == 12) /* 4 OP mode */
1017 is4op = (instr->key == OPL3_PATCH);
1028 if (devc->nr_voice == 12) /* 4 OP mode. Use the '2 OP only' operators first */
1032 avail = devc->nr_voice;
1036 * Now try to find a free voice
1040 for (i = 0; i < avail; i++)
1042 if (alloc->map[p] == 0)
1046 if (alloc->alloc_times[p] < best_time) /* Find oldest playing note */
1048 best_time = alloc->alloc_times[p];
1051 p = (p + 1) % avail;
1055 * Insert some kind of priority mechanism here.
1060 if (best > devc->nr_voice)
1061 best -= devc->nr_voice;
1063 return best; /* All devc->voc in use. Select the first one. */
1066 static void opl3_setup_voice(int dev, int voice, int chn)
1068 struct channel_info *info =
1069 &synth_devs[dev]->chn_info[chn];
1071 opl3_set_instr(dev, voice, info->pgm_num);
1073 devc->voc[voice].bender = 0;
1074 devc->voc[voice].bender_range = info->bender_range;
1075 devc->voc[voice].volume = info->controllers[CTL_MAIN_VOLUME];
1076 devc->voc[voice].panning = (info->controllers[CTL_PAN] * 2) - 128;
1079 static struct synth_operations opl3_operations =
1081 .owner = THIS_MODULE,
1085 .synth_type = SYNTH_TYPE_FM,
1086 .synth_subtype = FM_TYPE_ADLIB,
1088 .close = opl3_close,
1089 .ioctl = opl3_ioctl,
1090 .kill_note = opl3_kill_note,
1091 .start_note = opl3_start_note,
1092 .set_instr = opl3_set_instr,
1093 .reset = opl3_reset,
1094 .hw_control = opl3_hw_control,
1095 .load_patch = opl3_load_patch,
1096 .aftertouch = opl3_aftertouch,
1097 .controller = opl3_controller,
1098 .panning = opl3_panning,
1099 .volume_method = opl3_volume_method,
1100 .bender = opl3_bender,
1101 .alloc_voice = opl3_alloc_voice,
1102 .setup_voice = opl3_setup_voice
1105 int opl3_init(int ioaddr, int *osp, struct module *owner)
1112 printk(KERN_ERR "opl3: Device control structure not initialized.\n");
1116 if ((me = sound_alloc_synthdev()) == -1)
1118 printk(KERN_WARNING "opl3: Too many synthesizers\n");
1124 devc->fm_info.device = 0;
1125 devc->fm_info.synth_type = SYNTH_TYPE_FM;
1126 devc->fm_info.synth_subtype = FM_TYPE_ADLIB;
1127 devc->fm_info.perc_mode = 0;
1128 devc->fm_info.nr_voices = 9;
1129 devc->fm_info.nr_drums = 0;
1130 devc->fm_info.instr_bank_size = SBFM_MAXINSTR;
1131 devc->fm_info.capabilities = 0;
1132 devc->left_io = ioaddr;
1133 devc->right_io = ioaddr + 2;
1135 if (detected_model <= 2)
1140 if (detected_model == 4)
1144 opl3_operations.info = &devc->fm_info;
1146 synth_devs[me] = &opl3_operations;
1149 synth_devs[me]->owner = owner;
1152 devc->v_alloc = &opl3_operations.alloc;
1153 devc->chn_info = &opl3_operations.chn_info[0];
1155 if (devc->model == 2)
1158 strcpy(devc->fm_info.name, "Yamaha OPL4/OPL3 FM");
1160 strcpy(devc->fm_info.name, "Yamaha OPL3");
1162 devc->v_alloc->max_voice = devc->nr_voice = 18;
1163 devc->fm_info.nr_drums = 0;
1164 devc->fm_info.synth_subtype = FM_TYPE_OPL3;
1165 devc->fm_info.capabilities |= SYNTH_CAP_OPL3;
1167 for (i = 0; i < 18; i++)
1169 if (pv_map[i].ioaddr == USE_LEFT)
1170 pv_map[i].ioaddr = devc->left_io;
1172 pv_map[i].ioaddr = devc->right_io;
1174 opl3_command(devc->right_io, OPL3_MODE_REGISTER, OPL3_ENABLE);
1175 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, 0x00);
1179 strcpy(devc->fm_info.name, "Yamaha OPL2");
1180 devc->v_alloc->max_voice = devc->nr_voice = 9;
1181 devc->fm_info.nr_drums = 0;
1183 for (i = 0; i < 18; i++)
1184 pv_map[i].ioaddr = devc->left_io;
1186 conf_printf2(devc->fm_info.name, ioaddr, 0, -1, -1);
1188 for (i = 0; i < SBFM_MAXINSTR; i++)
1189 devc->i_map[i].channel = -1;
1194 EXPORT_SYMBOL(opl3_init);
1195 EXPORT_SYMBOL(opl3_detect);
1201 MODULE_PARM(io, "i");
1203 static int __init init_opl3 (void)
1205 printk(KERN_INFO "YM3812 and OPL-3 driver Copyright (C) by Hannu Savolainen, Rob Hooft 1993-1996\n");
1207 if (io != -1) /* User loading pure OPL3 module */
1209 if (!opl3_detect(io, NULL))
1214 me = opl3_init(io, NULL, THIS_MODULE);
1220 static void __exit cleanup_opl3(void)
1222 if (devc && io != -1)
1225 release_region(devc->base,4);
1227 release_region(devc->base - 8, 2);
1231 sound_unload_synthdev(me);
1235 module_init(init_opl3);
1236 module_exit(cleanup_opl3);
1239 static int __init setup_opl3(char *str)
1244 str = get_options(str, ARRAY_SIZE(ints), ints);
1251 __setup("opl3=", setup_opl3);
1253 MODULE_LICENSE("GPL");