v2.6.22.24-op1
[linux-2.6.22.y-op.git] / sound / oss / opl3.c
blobfc273e55094480db93f3ad351c4e6aea49137c28
1 /*
2 * sound/oss/opl3.c
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
11 * for more info.
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.
21 * Status
22 * Believed to work. Badly needs rewriting a bit to support multiple
23 * OPL3 devices.
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,
32 * hooft@chem.ruu.nl
35 #include "sound_config.h"
37 #include "opl3.h"
38 #include "opl3_hw.h"
40 #define MAX_VOICE 18
41 #define OFFS_4OP 11
43 struct voice_info
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 */
55 typedef struct opl_devinfo
57 int base;
58 int left_io, right_io;
59 int nr_voice;
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;
71 int busy;
72 int model;
73 unsigned char cmask;
75 int is_opl4;
76 int *osp;
77 } opl_devinfo;
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)
90 int i;
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, void __user * arg)
115 struct sbi_instrument ins;
117 switch (cmd) {
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)))
121 return -EFAULT;
122 if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR) {
123 printk(KERN_WARNING "FM Error: Invalid instrument number %d\n", ins.channel);
124 return -EINVAL;
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)))
131 return -EFAULT;
132 return 0;
134 case SNDCTL_SYNTH_MEMAVL:
135 return 0x7fffffff;
137 case SNDCTL_FM_4OP_ENABLE:
138 if (devc->model == 2)
139 enter_4op_mode();
140 return 0;
142 default:
143 return -EINVAL;
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)
155 * boards.
157 * Note2! The chip is initialized if detected.
160 unsigned char stat1, signature;
161 int i;
163 if (devc != NULL)
165 printk(KERN_ERR "opl3: Only one OPL3 supported.\n");
166 return 0;
169 devc = kzalloc(sizeof(*devc), GFP_KERNEL);
171 if (devc == NULL)
173 printk(KERN_ERR "opl3: Can't allocate memory for the device control "
174 "structure \n ");
175 return 0;
178 strcpy(devc->fm_info.name, "OPL2");
180 if (!request_region(ioaddr, 4, devc->fm_info.name)) {
181 printk(KERN_WARNING "opl3: I/O port 0x%x already in use\n", ioaddr);
182 goto cleanup_devc;
185 devc->osp = osp;
186 devc->base = ioaddr;
188 /* Reset timers 1 and 2 */
189 opl3_command(ioaddr, TIMER_CONTROL_REGISTER, TIMER1_MASK | TIMER2_MASK);
191 /* Reset the IRQ of the FM chip */
192 opl3_command(ioaddr, TIMER_CONTROL_REGISTER, IRQ_RESET);
194 signature = stat1 = inb(ioaddr); /* Status register */
196 if (signature != 0x00 && signature != 0x06 && signature != 0x02 &&
197 signature != 0x0f)
199 MDB(printk(KERN_INFO "OPL3 not detected %x\n", signature));
200 goto cleanup_region;
203 if (signature == 0x06) /* OPL2 */
205 detected_model = 2;
207 else if (signature == 0x00 || signature == 0x0f) /* OPL3 or OPL4 */
209 unsigned char tmp;
211 detected_model = 3;
214 * Detect availability of OPL4 (_experimental_). Works probably
215 * only after a cold boot. In addition the OPL4 port
216 * of the chip may not be connected to the PC bus at all.
219 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, 0x00);
220 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, OPL3_ENABLE | OPL4_ENABLE);
222 if ((tmp = inb(ioaddr)) == 0x02) /* Have a OPL4 */
224 detected_model = 4;
227 if (request_region(ioaddr - 8, 2, "OPL4")) /* OPL4 port was free */
229 int tmp;
231 outb((0x02), ioaddr - 8); /* Select OPL4 ID register */
232 udelay(10);
233 tmp = inb(ioaddr - 7); /* Read it */
234 udelay(10);
236 if (tmp == 0x20) /* OPL4 should return 0x20 here */
238 detected_model = 4;
239 outb((0xF8), ioaddr - 8); /* Select OPL4 FM mixer control */
240 udelay(10);
241 outb((0x1B), ioaddr - 7); /* Write value */
242 udelay(10);
244 else
245 { /* release OPL4 port */
246 release_region(ioaddr - 8, 2);
247 detected_model = 3;
250 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, 0);
252 for (i = 0; i < 9; i++)
253 opl3_command(ioaddr, KEYON_BLOCK + i, 0); /*
254 * Note off
257 opl3_command(ioaddr, TEST_REGISTER, ENABLE_WAVE_SELECT);
258 opl3_command(ioaddr, PERCOSSION_REGISTER, 0x00); /*
259 * Melodic mode.
261 return 1;
262 cleanup_region:
263 release_region(ioaddr, 4);
264 cleanup_devc:
265 kfree(devc);
266 devc = NULL;
267 return 0;
270 static int opl3_kill_note (int devno, int voice, int note, int velocity)
272 struct physical_voice_info *map;
274 if (voice < 0 || voice >= devc->nr_voice)
275 return 0;
277 devc->v_alloc->map[voice] = 0;
279 map = &pv_map[devc->lv_map[voice]];
280 DEB(printk("Kill note %d\n", voice));
282 if (map->voice_mode == 0)
283 return 0;
285 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, devc->voc[voice].keyon_byte & ~0x20);
286 devc->voc[voice].keyon_byte = 0;
287 devc->voc[voice].bender = 0;
288 devc->voc[voice].volume = 64;
289 devc->voc[voice].panning = 0xffff; /* Not set */
290 devc->voc[voice].bender_range = 200;
291 devc->voc[voice].orig_freq = 0;
292 devc->voc[voice].current_freq = 0;
293 devc->voc[voice].mode = 0;
294 return 0;
297 #define HIHAT 0
298 #define CYMBAL 1
299 #define TOMTOM 2
300 #define SNARE 3
301 #define BDRUM 4
302 #define UNDEFINED TOMTOM
303 #define DEFAULT TOMTOM
305 static int store_instr(int instr_no, struct sbi_instrument *instr)
307 if (instr->key != FM_PATCH && (instr->key != OPL3_PATCH || devc->model != 2))
308 printk(KERN_WARNING "FM warning: Invalid patch format field (key) 0x%x\n", instr->key);
309 memcpy((char *) &(devc->i_map[instr_no]), (char *) instr, sizeof(*instr));
310 return 0;
313 static int opl3_set_instr (int dev, int voice, int instr_no)
315 if (voice < 0 || voice >= devc->nr_voice)
316 return 0;
317 if (instr_no < 0 || instr_no >= SBFM_MAXINSTR)
318 instr_no = 0; /* Acoustic piano (usually) */
320 devc->act_i[voice] = &devc->i_map[instr_no];
321 return 0;
325 * The next table looks magical, but it certainly is not. Its values have
326 * been calculated as table[i]=8*log(i/64)/log(2) with an obvious exception
327 * for i=0. This log-table converts a linear volume-scaling (0..127) to a
328 * logarithmic scaling as present in the FM-synthesizer chips. so : Volume
329 * 64 = 0 db = relative volume 0 and: Volume 32 = -6 db = relative
330 * volume -8 it was implemented as a table because it is only 128 bytes and
331 * it saves a lot of log() calculations. (RH)
334 static char fm_volume_table[128] =
336 -64, -48, -40, -35, -32, -29, -27, -26,
337 -24, -23, -21, -20, -19, -18, -18, -17,
338 -16, -15, -15, -14, -13, -13, -12, -12,
339 -11, -11, -10, -10, -10, -9, -9, -8,
340 -8, -8, -7, -7, -7, -6, -6, -6,
341 -5, -5, -5, -5, -4, -4, -4, -4,
342 -3, -3, -3, -3, -2, -2, -2, -2,
343 -2, -1, -1, -1, -1, 0, 0, 0,
344 0, 0, 0, 1, 1, 1, 1, 1,
345 1, 2, 2, 2, 2, 2, 2, 2,
346 3, 3, 3, 3, 3, 3, 3, 4,
347 4, 4, 4, 4, 4, 4, 4, 5,
348 5, 5, 5, 5, 5, 5, 5, 5,
349 6, 6, 6, 6, 6, 6, 6, 6,
350 6, 7, 7, 7, 7, 7, 7, 7,
351 7, 7, 7, 8, 8, 8, 8, 8
354 static void calc_vol(unsigned char *regbyte, int volume, int main_vol)
356 int level = (~*regbyte & 0x3f);
358 if (main_vol > 127)
359 main_vol = 127;
360 volume = (volume * main_vol) / 127;
362 if (level)
363 level += fm_volume_table[volume];
365 if (level > 0x3f)
366 level = 0x3f;
367 if (level < 0)
368 level = 0;
370 *regbyte = (*regbyte & 0xc0) | (~level & 0x3f);
373 static void set_voice_volume(int voice, int volume, int main_vol)
375 unsigned char vol1, vol2, vol3, vol4;
376 struct sbi_instrument *instr;
377 struct physical_voice_info *map;
379 if (voice < 0 || voice >= devc->nr_voice)
380 return;
382 map = &pv_map[devc->lv_map[voice]];
383 instr = devc->act_i[voice];
385 if (!instr)
386 instr = &devc->i_map[0];
388 if (instr->channel < 0)
389 return;
391 if (devc->voc[voice].mode == 0)
392 return;
394 if (devc->voc[voice].mode == 2)
396 vol1 = instr->operators[2];
397 vol2 = instr->operators[3];
398 if ((instr->operators[10] & 0x01))
400 calc_vol(&vol1, volume, main_vol);
401 calc_vol(&vol2, volume, main_vol);
403 else
405 calc_vol(&vol2, volume, main_vol);
407 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], vol1);
408 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], vol2);
410 else
411 { /*
412 * 4 OP voice
414 int connection;
416 vol1 = instr->operators[2];
417 vol2 = instr->operators[3];
418 vol3 = instr->operators[OFFS_4OP + 2];
419 vol4 = instr->operators[OFFS_4OP + 3];
422 * The connection method for 4 OP devc->voc is defined by the rightmost
423 * bits at the offsets 10 and 10+OFFS_4OP
426 connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
428 switch (connection)
430 case 0:
431 calc_vol(&vol4, volume, main_vol);
432 break;
434 case 1:
435 calc_vol(&vol2, volume, main_vol);
436 calc_vol(&vol4, volume, main_vol);
437 break;
439 case 2:
440 calc_vol(&vol1, volume, main_vol);
441 calc_vol(&vol4, volume, main_vol);
442 break;
444 case 3:
445 calc_vol(&vol1, volume, main_vol);
446 calc_vol(&vol3, volume, main_vol);
447 calc_vol(&vol4, volume, main_vol);
448 break;
450 default:
453 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], vol1);
454 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], vol2);
455 opl3_command(map->ioaddr, KSL_LEVEL + map->op[2], vol3);
456 opl3_command(map->ioaddr, KSL_LEVEL + map->op[3], vol4);
460 static int opl3_start_note (int dev, int voice, int note, int volume)
462 unsigned char data, fpc;
463 int block, fnum, freq, voice_mode, pan;
464 struct sbi_instrument *instr;
465 struct physical_voice_info *map;
467 if (voice < 0 || voice >= devc->nr_voice)
468 return 0;
470 map = &pv_map[devc->lv_map[voice]];
471 pan = devc->voc[voice].panning;
473 if (map->voice_mode == 0)
474 return 0;
476 if (note == 255) /*
477 * Just change the volume
480 set_voice_volume(voice, volume, devc->voc[voice].volume);
481 return 0;
485 * Kill previous note before playing
488 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], 0xff); /*
489 * Carrier
490 * volume to
491 * min
493 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], 0xff); /*
494 * Modulator
495 * volume to
498 if (map->voice_mode == 4)
500 opl3_command(map->ioaddr, KSL_LEVEL + map->op[2], 0xff);
501 opl3_command(map->ioaddr, KSL_LEVEL + map->op[3], 0xff);
504 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, 0x00); /*
505 * Note
506 * off
509 instr = devc->act_i[voice];
511 if (!instr)
512 instr = &devc->i_map[0];
514 if (instr->channel < 0)
516 printk(KERN_WARNING "opl3: Initializing voice %d with undefined instrument\n", voice);
517 return 0;
520 if (map->voice_mode == 2 && instr->key == OPL3_PATCH)
521 return 0; /*
522 * Cannot play
525 voice_mode = map->voice_mode;
527 if (voice_mode == 4)
529 int voice_shift;
531 voice_shift = (map->ioaddr == devc->left_io) ? 0 : 3;
532 voice_shift += map->voice_num;
534 if (instr->key != OPL3_PATCH) /*
535 * Just 2 OP patch
538 voice_mode = 2;
539 devc->cmask &= ~(1 << voice_shift);
541 else
543 devc->cmask |= (1 << voice_shift);
546 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
550 * Set Sound Characteristics
553 opl3_command(map->ioaddr, AM_VIB + map->op[0], instr->operators[0]);
554 opl3_command(map->ioaddr, AM_VIB + map->op[1], instr->operators[1]);
557 * Set Attack/Decay
560 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[0], instr->operators[4]);
561 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[1], instr->operators[5]);
564 * Set Sustain/Release
567 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[0], instr->operators[6]);
568 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[1], instr->operators[7]);
571 * Set Wave Select
574 opl3_command(map->ioaddr, WAVE_SELECT + map->op[0], instr->operators[8]);
575 opl3_command(map->ioaddr, WAVE_SELECT + map->op[1], instr->operators[9]);
578 * Set Feedback/Connection
581 fpc = instr->operators[10];
583 if (pan != 0xffff)
585 fpc &= ~STEREO_BITS;
586 if (pan < -64)
587 fpc |= VOICE_TO_LEFT;
588 else
589 if (pan > 64)
590 fpc |= VOICE_TO_RIGHT;
591 else
592 fpc |= (VOICE_TO_LEFT | VOICE_TO_RIGHT);
595 if (!(fpc & 0x30))
596 fpc |= 0x30; /*
597 * Ensure that at least one chn is enabled
599 opl3_command(map->ioaddr, FEEDBACK_CONNECTION + map->voice_num, fpc);
602 * If the voice is a 4 OP one, initialize the operators 3 and 4 also
605 if (voice_mode == 4)
608 * Set Sound Characteristics
611 opl3_command(map->ioaddr, AM_VIB + map->op[2], instr->operators[OFFS_4OP + 0]);
612 opl3_command(map->ioaddr, AM_VIB + map->op[3], instr->operators[OFFS_4OP + 1]);
615 * Set Attack/Decay
618 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[2], instr->operators[OFFS_4OP + 4]);
619 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[3], instr->operators[OFFS_4OP + 5]);
622 * Set Sustain/Release
625 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[2], instr->operators[OFFS_4OP + 6]);
626 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[3], instr->operators[OFFS_4OP + 7]);
629 * Set Wave Select
632 opl3_command(map->ioaddr, WAVE_SELECT + map->op[2], instr->operators[OFFS_4OP + 8]);
633 opl3_command(map->ioaddr, WAVE_SELECT + map->op[3], instr->operators[OFFS_4OP + 9]);
636 * Set Feedback/Connection
639 fpc = instr->operators[OFFS_4OP + 10];
640 if (!(fpc & 0x30))
641 fpc |= 0x30; /*
642 * Ensure that at least one chn is enabled
644 opl3_command(map->ioaddr, FEEDBACK_CONNECTION + map->voice_num + 3, fpc);
647 devc->voc[voice].mode = voice_mode;
648 set_voice_volume(voice, volume, devc->voc[voice].volume);
650 freq = devc->voc[voice].orig_freq = note_to_freq(note) / 1000;
653 * Since the pitch bender may have been set before playing the note, we
654 * have to calculate the bending now.
657 freq = compute_finetune(devc->voc[voice].orig_freq, devc->voc[voice].bender, devc->voc[voice].bender_range, 0);
658 devc->voc[voice].current_freq = freq;
660 freq_to_fnum(freq, &block, &fnum);
663 * Play note
666 data = fnum & 0xff; /*
667 * Least significant bits of fnumber
669 opl3_command(map->ioaddr, FNUM_LOW + map->voice_num, data);
671 data = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
672 devc->voc[voice].keyon_byte = data;
673 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, data);
674 if (voice_mode == 4)
675 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num + 3, data);
677 return 0;
680 static void freq_to_fnum (int freq, int *block, int *fnum)
682 int f, octave;
685 * Converts the note frequency to block and fnum values for the FM chip
688 * First try to compute the block -value (octave) where the note belongs
691 f = freq;
693 octave = 5;
695 if (f == 0)
696 octave = 0;
697 else if (f < 261)
699 while (f < 261)
701 octave--;
702 f <<= 1;
705 else if (f > 493)
707 while (f > 493)
709 octave++;
710 f >>= 1;
714 if (octave > 7)
715 octave = 7;
717 *fnum = freq * (1 << (20 - octave)) / 49716;
718 *block = octave;
721 static void opl3_command (int io_addr, unsigned int addr, unsigned int val)
723 int i;
726 * The original 2-OP synth requires a quite long delay after writing to a
727 * register. The OPL-3 survives with just two INBs
730 outb(((unsigned char) (addr & 0xff)), io_addr);
732 if (devc->model != 2)
733 udelay(10);
734 else
735 for (i = 0; i < 2; i++)
736 inb(io_addr);
738 outb(((unsigned char) (val & 0xff)), io_addr + 1);
740 if (devc->model != 2)
741 udelay(30);
742 else
743 for (i = 0; i < 2; i++)
744 inb(io_addr);
747 static void opl3_reset(int devno)
749 int i;
751 for (i = 0; i < 18; i++)
752 devc->lv_map[i] = i;
754 for (i = 0; i < devc->nr_voice; i++)
756 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
757 KSL_LEVEL + pv_map[devc->lv_map[i]].op[0], 0xff);
759 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
760 KSL_LEVEL + pv_map[devc->lv_map[i]].op[1], 0xff);
762 if (pv_map[devc->lv_map[i]].voice_mode == 4)
764 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
765 KSL_LEVEL + pv_map[devc->lv_map[i]].op[2], 0xff);
767 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
768 KSL_LEVEL + pv_map[devc->lv_map[i]].op[3], 0xff);
771 opl3_kill_note(devno, i, 0, 64);
774 if (devc->model == 2)
776 devc->v_alloc->max_voice = devc->nr_voice = 18;
778 for (i = 0; i < 18; i++)
779 pv_map[i].voice_mode = 2;
784 static int opl3_open(int dev, int mode)
786 int i;
788 if (devc->busy)
789 return -EBUSY;
790 devc->busy = 1;
792 devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
793 devc->v_alloc->timestamp = 0;
795 for (i = 0; i < 18; i++)
797 devc->v_alloc->map[i] = 0;
798 devc->v_alloc->alloc_times[i] = 0;
801 devc->cmask = 0x00; /*
802 * Just 2 OP mode
804 if (devc->model == 2)
805 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
806 return 0;
809 static void opl3_close(int dev)
811 devc->busy = 0;
812 devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
814 devc->fm_info.nr_drums = 0;
815 devc->fm_info.perc_mode = 0;
817 opl3_reset(dev);
820 static void opl3_hw_control(int dev, unsigned char *event)
824 static int opl3_load_patch(int dev, int format, const char __user *addr,
825 int offs, int count, int pmgr_flag)
827 struct sbi_instrument ins;
829 if (count <sizeof(ins))
831 printk(KERN_WARNING "FM Error: Patch record too short\n");
832 return -EINVAL;
836 * What the fuck is going on here? We leave junk in the beginning
837 * of ins and then check the field pretty close to that beginning?
839 if(copy_from_user(&((char *) &ins)[offs], addr + offs, sizeof(ins) - offs))
840 return -EFAULT;
842 if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR)
844 printk(KERN_WARNING "FM Error: Invalid instrument number %d\n", ins.channel);
845 return -EINVAL;
847 ins.key = format;
849 return store_instr(ins.channel, &ins);
852 static void opl3_panning(int dev, int voice, int value)
854 devc->voc[voice].panning = value;
857 static void opl3_volume_method(int dev, int mode)
861 #define SET_VIBRATO(cell) { \
862 tmp = instr->operators[(cell-1)+(((cell-1)/2)*OFFS_4OP)]; \
863 if (pressure > 110) \
864 tmp |= 0x40; /* Vibrato on */ \
865 opl3_command (map->ioaddr, AM_VIB + map->op[cell-1], tmp);}
867 static void opl3_aftertouch(int dev, int voice, int pressure)
869 int tmp;
870 struct sbi_instrument *instr;
871 struct physical_voice_info *map;
873 if (voice < 0 || voice >= devc->nr_voice)
874 return;
876 map = &pv_map[devc->lv_map[voice]];
878 DEB(printk("Aftertouch %d\n", voice));
880 if (map->voice_mode == 0)
881 return;
884 * Adjust the amount of vibrato depending the pressure
887 instr = devc->act_i[voice];
889 if (!instr)
890 instr = &devc->i_map[0];
892 if (devc->voc[voice].mode == 4)
894 int connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
896 switch (connection)
898 case 0:
899 SET_VIBRATO(4);
900 break;
902 case 1:
903 SET_VIBRATO(2);
904 SET_VIBRATO(4);
905 break;
907 case 2:
908 SET_VIBRATO(1);
909 SET_VIBRATO(4);
910 break;
912 case 3:
913 SET_VIBRATO(1);
914 SET_VIBRATO(3);
915 SET_VIBRATO(4);
916 break;
920 * Not implemented yet
923 else
925 SET_VIBRATO(1);
927 if ((instr->operators[10] & 0x01)) /*
928 * Additive synthesis
930 SET_VIBRATO(2);
934 #undef SET_VIBRATO
936 static void bend_pitch(int dev, int voice, int value)
938 unsigned char data;
939 int block, fnum, freq;
940 struct physical_voice_info *map;
942 map = &pv_map[devc->lv_map[voice]];
944 if (map->voice_mode == 0)
945 return;
947 devc->voc[voice].bender = value;
948 if (!value)
949 return;
950 if (!(devc->voc[voice].keyon_byte & 0x20))
951 return; /*
952 * Not keyed on
955 freq = compute_finetune(devc->voc[voice].orig_freq, devc->voc[voice].bender, devc->voc[voice].bender_range, 0);
956 devc->voc[voice].current_freq = freq;
958 freq_to_fnum(freq, &block, &fnum);
960 data = fnum & 0xff; /*
961 * Least significant bits of fnumber
963 opl3_command(map->ioaddr, FNUM_LOW + map->voice_num, data);
965 data = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
966 devc->voc[voice].keyon_byte = data;
967 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, data);
970 static void opl3_controller (int dev, int voice, int ctrl_num, int value)
972 if (voice < 0 || voice >= devc->nr_voice)
973 return;
975 switch (ctrl_num)
977 case CTRL_PITCH_BENDER:
978 bend_pitch(dev, voice, value);
979 break;
981 case CTRL_PITCH_BENDER_RANGE:
982 devc->voc[voice].bender_range = value;
983 break;
985 case CTL_MAIN_VOLUME:
986 devc->voc[voice].volume = value / 128;
987 break;
989 case CTL_PAN:
990 devc->voc[voice].panning = (value * 2) - 128;
991 break;
995 static void opl3_bender(int dev, int voice, int value)
997 if (voice < 0 || voice >= devc->nr_voice)
998 return;
1000 bend_pitch(dev, voice, value - 8192);
1003 static int opl3_alloc_voice(int dev, int chn, int note, struct voice_alloc_info *alloc)
1005 int i, p, best, first, avail, best_time = 0x7fffffff;
1006 struct sbi_instrument *instr;
1007 int is4op;
1008 int instr_no;
1010 if (chn < 0 || chn > 15)
1011 instr_no = 0;
1012 else
1013 instr_no = devc->chn_info[chn].pgm_num;
1015 instr = &devc->i_map[instr_no];
1016 if (instr->channel < 0 || /* Instrument not loaded */
1017 devc->nr_voice != 12) /* Not in 4 OP mode */
1018 is4op = 0;
1019 else if (devc->nr_voice == 12) /* 4 OP mode */
1020 is4op = (instr->key == OPL3_PATCH);
1021 else
1022 is4op = 0;
1024 if (is4op)
1026 first = p = 0;
1027 avail = 6;
1029 else
1031 if (devc->nr_voice == 12) /* 4 OP mode. Use the '2 OP only' operators first */
1032 first = p = 6;
1033 else
1034 first = p = 0;
1035 avail = devc->nr_voice;
1039 * Now try to find a free voice
1041 best = first;
1043 for (i = 0; i < avail; i++)
1045 if (alloc->map[p] == 0)
1047 return p;
1049 if (alloc->alloc_times[p] < best_time) /* Find oldest playing note */
1051 best_time = alloc->alloc_times[p];
1052 best = p;
1054 p = (p + 1) % avail;
1058 * Insert some kind of priority mechanism here.
1061 if (best < 0)
1062 best = 0;
1063 if (best > devc->nr_voice)
1064 best -= devc->nr_voice;
1066 return best; /* All devc->voc in use. Select the first one. */
1069 static void opl3_setup_voice(int dev, int voice, int chn)
1071 struct channel_info *info =
1072 &synth_devs[dev]->chn_info[chn];
1074 opl3_set_instr(dev, voice, info->pgm_num);
1076 devc->voc[voice].bender = 0;
1077 devc->voc[voice].bender_range = info->bender_range;
1078 devc->voc[voice].volume = info->controllers[CTL_MAIN_VOLUME];
1079 devc->voc[voice].panning = (info->controllers[CTL_PAN] * 2) - 128;
1082 static struct synth_operations opl3_operations =
1084 .owner = THIS_MODULE,
1085 .id = "OPL",
1086 .info = NULL,
1087 .midi_dev = 0,
1088 .synth_type = SYNTH_TYPE_FM,
1089 .synth_subtype = FM_TYPE_ADLIB,
1090 .open = opl3_open,
1091 .close = opl3_close,
1092 .ioctl = opl3_ioctl,
1093 .kill_note = opl3_kill_note,
1094 .start_note = opl3_start_note,
1095 .set_instr = opl3_set_instr,
1096 .reset = opl3_reset,
1097 .hw_control = opl3_hw_control,
1098 .load_patch = opl3_load_patch,
1099 .aftertouch = opl3_aftertouch,
1100 .controller = opl3_controller,
1101 .panning = opl3_panning,
1102 .volume_method = opl3_volume_method,
1103 .bender = opl3_bender,
1104 .alloc_voice = opl3_alloc_voice,
1105 .setup_voice = opl3_setup_voice
1108 int opl3_init(int ioaddr, int *osp, struct module *owner)
1110 int i;
1111 int me;
1113 if (devc == NULL)
1115 printk(KERN_ERR "opl3: Device control structure not initialized.\n");
1116 return -1;
1119 if ((me = sound_alloc_synthdev()) == -1)
1121 printk(KERN_WARNING "opl3: Too many synthesizers\n");
1122 return -1;
1125 devc->nr_voice = 9;
1127 devc->fm_info.device = 0;
1128 devc->fm_info.synth_type = SYNTH_TYPE_FM;
1129 devc->fm_info.synth_subtype = FM_TYPE_ADLIB;
1130 devc->fm_info.perc_mode = 0;
1131 devc->fm_info.nr_voices = 9;
1132 devc->fm_info.nr_drums = 0;
1133 devc->fm_info.instr_bank_size = SBFM_MAXINSTR;
1134 devc->fm_info.capabilities = 0;
1135 devc->left_io = ioaddr;
1136 devc->right_io = ioaddr + 2;
1138 if (detected_model <= 2)
1139 devc->model = 1;
1140 else
1142 devc->model = 2;
1143 if (detected_model == 4)
1144 devc->is_opl4 = 1;
1147 opl3_operations.info = &devc->fm_info;
1149 synth_devs[me] = &opl3_operations;
1151 if (owner)
1152 synth_devs[me]->owner = owner;
1154 sequencer_init();
1155 devc->v_alloc = &opl3_operations.alloc;
1156 devc->chn_info = &opl3_operations.chn_info[0];
1158 if (devc->model == 2)
1160 if (devc->is_opl4)
1161 strcpy(devc->fm_info.name, "Yamaha OPL4/OPL3 FM");
1162 else
1163 strcpy(devc->fm_info.name, "Yamaha OPL3");
1165 devc->v_alloc->max_voice = devc->nr_voice = 18;
1166 devc->fm_info.nr_drums = 0;
1167 devc->fm_info.synth_subtype = FM_TYPE_OPL3;
1168 devc->fm_info.capabilities |= SYNTH_CAP_OPL3;
1170 for (i = 0; i < 18; i++)
1172 if (pv_map[i].ioaddr == USE_LEFT)
1173 pv_map[i].ioaddr = devc->left_io;
1174 else
1175 pv_map[i].ioaddr = devc->right_io;
1177 opl3_command(devc->right_io, OPL3_MODE_REGISTER, OPL3_ENABLE);
1178 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, 0x00);
1180 else
1182 strcpy(devc->fm_info.name, "Yamaha OPL2");
1183 devc->v_alloc->max_voice = devc->nr_voice = 9;
1184 devc->fm_info.nr_drums = 0;
1186 for (i = 0; i < 18; i++)
1187 pv_map[i].ioaddr = devc->left_io;
1189 conf_printf2(devc->fm_info.name, ioaddr, 0, -1, -1);
1191 for (i = 0; i < SBFM_MAXINSTR; i++)
1192 devc->i_map[i].channel = -1;
1194 return me;
1197 EXPORT_SYMBOL(opl3_init);
1198 EXPORT_SYMBOL(opl3_detect);
1200 static int me;
1202 static int io = -1;
1204 module_param(io, int, 0);
1206 static int __init init_opl3 (void)
1208 printk(KERN_INFO "YM3812 and OPL-3 driver Copyright (C) by Hannu Savolainen, Rob Hooft 1993-1996\n");
1210 if (io != -1) /* User loading pure OPL3 module */
1212 if (!opl3_detect(io, NULL))
1214 return -ENODEV;
1217 me = opl3_init(io, NULL, THIS_MODULE);
1220 return 0;
1223 static void __exit cleanup_opl3(void)
1225 if (devc && io != -1)
1227 if (devc->base) {
1228 release_region(devc->base,4);
1229 if (devc->is_opl4)
1230 release_region(devc->base - 8, 2);
1232 kfree(devc);
1233 devc = NULL;
1234 sound_unload_synthdev(me);
1238 module_init(init_opl3);
1239 module_exit(cleanup_opl3);
1241 #ifndef MODULE
1242 static int __init setup_opl3(char *str)
1244 /* io */
1245 int ints[2];
1247 str = get_options(str, ARRAY_SIZE(ints), ints);
1249 io = ints[1];
1251 return 1;
1254 __setup("opl3=", setup_opl3);
1255 #endif
1256 MODULE_LICENSE("GPL");