serial: xilinx_uartps: fix bad register write in console_write
[linux-2.6-xlnx.git] / sound / oss / opl3.c
blob407cd677950bccb68059fdcd1abec6da914b7a38
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/slab.h>
28 #include <linux/module.h>
29 #include <linux/delay.h>
32 * Major improvements to the FM handling 30AUG92 by Rob Hooft,
33 * hooft@chem.ruu.nl
36 #include "sound_config.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 } opl_devinfo;
78 static struct opl_devinfo *devc = NULL;
80 static int detected_model;
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);
87 static void enter_4op_mode(void)
89 int i;
90 static int v4op[MAX_VOICE] = {
91 0, 1, 2, 9, 10, 11, 6, 7, 8, 15, 16, 17
94 devc->cmask = 0x3f; /* Connect all possible 4 OP voice operators */
95 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, 0x3f);
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;
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;
107 for (i = 0; i < 12; i++)
108 devc->lv_map[i] = v4op[i];
109 devc->v_alloc->max_voice = devc->nr_voice = 12;
112 static int opl3_ioctl(int dev, unsigned int cmd, void __user * arg)
114 struct sbi_instrument ins;
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;
125 return store_instr(ins.channel, &ins);
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;
133 case SNDCTL_SYNTH_MEMAVL:
134 return 0x7fffffff;
136 case SNDCTL_FM_4OP_ENABLE:
137 if (devc->model == 2)
138 enter_4op_mode();
139 return 0;
141 default:
142 return -EINVAL;
146 static int opl3_detect(int ioaddr)
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.
153 * Note! The timers of the FM chip are not connected to AdLib (and compatible)
154 * boards.
156 * Note2! The chip is initialized if detected.
159 unsigned char stat1, signature;
160 int i;
162 if (devc != NULL)
164 printk(KERN_ERR "opl3: Only one OPL3 supported.\n");
165 return 0;
168 devc = kzalloc(sizeof(*devc), GFP_KERNEL);
170 if (devc == NULL)
172 printk(KERN_ERR "opl3: Can't allocate memory for the device control "
173 "structure \n ");
174 return 0;
177 strcpy(devc->fm_info.name, "OPL2");
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;
184 devc->base = ioaddr;
186 /* Reset timers 1 and 2 */
187 opl3_command(ioaddr, TIMER_CONTROL_REGISTER, TIMER1_MASK | TIMER2_MASK);
189 /* Reset the IRQ of the FM chip */
190 opl3_command(ioaddr, TIMER_CONTROL_REGISTER, IRQ_RESET);
192 signature = stat1 = inb(ioaddr); /* Status register */
194 if (signature != 0x00 && signature != 0x06 && signature != 0x02 &&
195 signature != 0x0f)
197 MDB(printk(KERN_INFO "OPL3 not detected %x\n", signature));
198 goto cleanup_region;
201 if (signature == 0x06) /* OPL2 */
203 detected_model = 2;
205 else if (signature == 0x00 || signature == 0x0f) /* OPL3 or OPL4 */
207 unsigned char tmp;
209 detected_model = 3;
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.
217 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, 0x00);
218 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, OPL3_ENABLE | OPL4_ENABLE);
220 if ((tmp = inb(ioaddr)) == 0x02) /* Have a OPL4 */
222 detected_model = 4;
225 if (request_region(ioaddr - 8, 2, "OPL4")) /* OPL4 port was free */
227 int tmp;
229 outb((0x02), ioaddr - 8); /* Select OPL4 ID register */
230 udelay(10);
231 tmp = inb(ioaddr - 7); /* Read it */
232 udelay(10);
234 if (tmp == 0x20) /* OPL4 should return 0x20 here */
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);
242 else
243 { /* release OPL4 port */
244 release_region(ioaddr - 8, 2);
245 detected_model = 3;
248 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, 0);
250 for (i = 0; i < 9; i++)
251 opl3_command(ioaddr, KEYON_BLOCK + i, 0); /*
252 * Note off
255 opl3_command(ioaddr, TEST_REGISTER, ENABLE_WAVE_SELECT);
256 opl3_command(ioaddr, PERCOSSION_REGISTER, 0x00); /*
257 * Melodic mode.
259 return 1;
260 cleanup_region:
261 release_region(ioaddr, 4);
262 cleanup_devc:
263 kfree(devc);
264 devc = NULL;
265 return 0;
268 static int opl3_kill_note (int devno, int voice, int note, int velocity)
270 struct physical_voice_info *map;
272 if (voice < 0 || voice >= devc->nr_voice)
273 return 0;
275 devc->v_alloc->map[voice] = 0;
277 map = &pv_map[devc->lv_map[voice]];
278 DEB(printk("Kill note %d\n", voice));
280 if (map->voice_mode == 0)
281 return 0;
283 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, devc->voc[voice].keyon_byte & ~0x20);
284 devc->voc[voice].keyon_byte = 0;
285 devc->voc[voice].bender = 0;
286 devc->voc[voice].volume = 64;
287 devc->voc[voice].panning = 0xffff; /* Not set */
288 devc->voc[voice].bender_range = 200;
289 devc->voc[voice].orig_freq = 0;
290 devc->voc[voice].current_freq = 0;
291 devc->voc[voice].mode = 0;
292 return 0;
295 #define HIHAT 0
296 #define CYMBAL 1
297 #define TOMTOM 2
298 #define SNARE 3
299 #define BDRUM 4
300 #define UNDEFINED TOMTOM
301 #define DEFAULT TOMTOM
303 static int store_instr(int instr_no, struct sbi_instrument *instr)
305 if (instr->key != FM_PATCH && (instr->key != OPL3_PATCH || devc->model != 2))
306 printk(KERN_WARNING "FM warning: Invalid patch format field (key) 0x%x\n", instr->key);
307 memcpy((char *) &(devc->i_map[instr_no]), (char *) instr, sizeof(*instr));
308 return 0;
311 static int opl3_set_instr (int dev, int voice, int instr_no)
313 if (voice < 0 || voice >= devc->nr_voice)
314 return 0;
315 if (instr_no < 0 || instr_no >= SBFM_MAXINSTR)
316 instr_no = 0; /* Acoustic piano (usually) */
318 devc->act_i[voice] = &devc->i_map[instr_no];
319 return 0;
323 * The next table looks magical, but it certainly is not. Its values have
324 * been calculated as table[i]=8*log(i/64)/log(2) with an obvious exception
325 * for i=0. This log-table converts a linear volume-scaling (0..127) to a
326 * logarithmic scaling as present in the FM-synthesizer chips. so : Volume
327 * 64 = 0 db = relative volume 0 and: Volume 32 = -6 db = relative
328 * volume -8 it was implemented as a table because it is only 128 bytes and
329 * it saves a lot of log() calculations. (RH)
332 static char fm_volume_table[128] =
334 -64, -48, -40, -35, -32, -29, -27, -26,
335 -24, -23, -21, -20, -19, -18, -18, -17,
336 -16, -15, -15, -14, -13, -13, -12, -12,
337 -11, -11, -10, -10, -10, -9, -9, -8,
338 -8, -8, -7, -7, -7, -6, -6, -6,
339 -5, -5, -5, -5, -4, -4, -4, -4,
340 -3, -3, -3, -3, -2, -2, -2, -2,
341 -2, -1, -1, -1, -1, 0, 0, 0,
342 0, 0, 0, 1, 1, 1, 1, 1,
343 1, 2, 2, 2, 2, 2, 2, 2,
344 3, 3, 3, 3, 3, 3, 3, 4,
345 4, 4, 4, 4, 4, 4, 4, 5,
346 5, 5, 5, 5, 5, 5, 5, 5,
347 6, 6, 6, 6, 6, 6, 6, 6,
348 6, 7, 7, 7, 7, 7, 7, 7,
349 7, 7, 7, 8, 8, 8, 8, 8
352 static void calc_vol(unsigned char *regbyte, int volume, int main_vol)
354 int level = (~*regbyte & 0x3f);
356 if (main_vol > 127)
357 main_vol = 127;
358 volume = (volume * main_vol) / 127;
360 if (level)
361 level += fm_volume_table[volume];
363 if (level > 0x3f)
364 level = 0x3f;
365 if (level < 0)
366 level = 0;
368 *regbyte = (*regbyte & 0xc0) | (~level & 0x3f);
371 static void set_voice_volume(int voice, int volume, int main_vol)
373 unsigned char vol1, vol2, vol3, vol4;
374 struct sbi_instrument *instr;
375 struct physical_voice_info *map;
377 if (voice < 0 || voice >= devc->nr_voice)
378 return;
380 map = &pv_map[devc->lv_map[voice]];
381 instr = devc->act_i[voice];
383 if (!instr)
384 instr = &devc->i_map[0];
386 if (instr->channel < 0)
387 return;
389 if (devc->voc[voice].mode == 0)
390 return;
392 if (devc->voc[voice].mode == 2)
394 vol1 = instr->operators[2];
395 vol2 = instr->operators[3];
396 if ((instr->operators[10] & 0x01))
398 calc_vol(&vol1, volume, main_vol);
399 calc_vol(&vol2, volume, main_vol);
401 else
403 calc_vol(&vol2, volume, main_vol);
405 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], vol1);
406 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], vol2);
408 else
409 { /*
410 * 4 OP voice
412 int connection;
414 vol1 = instr->operators[2];
415 vol2 = instr->operators[3];
416 vol3 = instr->operators[OFFS_4OP + 2];
417 vol4 = instr->operators[OFFS_4OP + 3];
420 * The connection method for 4 OP devc->voc is defined by the rightmost
421 * bits at the offsets 10 and 10+OFFS_4OP
424 connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
426 switch (connection)
428 case 0:
429 calc_vol(&vol4, volume, main_vol);
430 break;
432 case 1:
433 calc_vol(&vol2, volume, main_vol);
434 calc_vol(&vol4, volume, main_vol);
435 break;
437 case 2:
438 calc_vol(&vol1, volume, main_vol);
439 calc_vol(&vol4, volume, main_vol);
440 break;
442 case 3:
443 calc_vol(&vol1, volume, main_vol);
444 calc_vol(&vol3, volume, main_vol);
445 calc_vol(&vol4, volume, main_vol);
446 break;
448 default:
451 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], vol1);
452 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], vol2);
453 opl3_command(map->ioaddr, KSL_LEVEL + map->op[2], vol3);
454 opl3_command(map->ioaddr, KSL_LEVEL + map->op[3], vol4);
458 static int opl3_start_note (int dev, int voice, int note, int volume)
460 unsigned char data, fpc;
461 int block, fnum, freq, voice_mode, pan;
462 struct sbi_instrument *instr;
463 struct physical_voice_info *map;
465 if (voice < 0 || voice >= devc->nr_voice)
466 return 0;
468 map = &pv_map[devc->lv_map[voice]];
469 pan = devc->voc[voice].panning;
471 if (map->voice_mode == 0)
472 return 0;
474 if (note == 255) /*
475 * Just change the volume
478 set_voice_volume(voice, volume, devc->voc[voice].volume);
479 return 0;
483 * Kill previous note before playing
486 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], 0xff); /*
487 * Carrier
488 * volume to
489 * min
491 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], 0xff); /*
492 * Modulator
493 * volume to
496 if (map->voice_mode == 4)
498 opl3_command(map->ioaddr, KSL_LEVEL + map->op[2], 0xff);
499 opl3_command(map->ioaddr, KSL_LEVEL + map->op[3], 0xff);
502 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, 0x00); /*
503 * Note
504 * off
507 instr = devc->act_i[voice];
509 if (!instr)
510 instr = &devc->i_map[0];
512 if (instr->channel < 0)
514 printk(KERN_WARNING "opl3: Initializing voice %d with undefined instrument\n", voice);
515 return 0;
518 if (map->voice_mode == 2 && instr->key == OPL3_PATCH)
519 return 0; /*
520 * Cannot play
523 voice_mode = map->voice_mode;
525 if (voice_mode == 4)
527 int voice_shift;
529 voice_shift = (map->ioaddr == devc->left_io) ? 0 : 3;
530 voice_shift += map->voice_num;
532 if (instr->key != OPL3_PATCH) /*
533 * Just 2 OP patch
536 voice_mode = 2;
537 devc->cmask &= ~(1 << voice_shift);
539 else
541 devc->cmask |= (1 << voice_shift);
544 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
548 * Set Sound Characteristics
551 opl3_command(map->ioaddr, AM_VIB + map->op[0], instr->operators[0]);
552 opl3_command(map->ioaddr, AM_VIB + map->op[1], instr->operators[1]);
555 * Set Attack/Decay
558 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[0], instr->operators[4]);
559 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[1], instr->operators[5]);
562 * Set Sustain/Release
565 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[0], instr->operators[6]);
566 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[1], instr->operators[7]);
569 * Set Wave Select
572 opl3_command(map->ioaddr, WAVE_SELECT + map->op[0], instr->operators[8]);
573 opl3_command(map->ioaddr, WAVE_SELECT + map->op[1], instr->operators[9]);
576 * Set Feedback/Connection
579 fpc = instr->operators[10];
581 if (pan != 0xffff)
583 fpc &= ~STEREO_BITS;
584 if (pan < -64)
585 fpc |= VOICE_TO_LEFT;
586 else
587 if (pan > 64)
588 fpc |= VOICE_TO_RIGHT;
589 else
590 fpc |= (VOICE_TO_LEFT | VOICE_TO_RIGHT);
593 if (!(fpc & 0x30))
594 fpc |= 0x30; /*
595 * Ensure that at least one chn is enabled
597 opl3_command(map->ioaddr, FEEDBACK_CONNECTION + map->voice_num, fpc);
600 * If the voice is a 4 OP one, initialize the operators 3 and 4 also
603 if (voice_mode == 4)
606 * Set Sound Characteristics
609 opl3_command(map->ioaddr, AM_VIB + map->op[2], instr->operators[OFFS_4OP + 0]);
610 opl3_command(map->ioaddr, AM_VIB + map->op[3], instr->operators[OFFS_4OP + 1]);
613 * Set Attack/Decay
616 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[2], instr->operators[OFFS_4OP + 4]);
617 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[3], instr->operators[OFFS_4OP + 5]);
620 * Set Sustain/Release
623 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[2], instr->operators[OFFS_4OP + 6]);
624 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[3], instr->operators[OFFS_4OP + 7]);
627 * Set Wave Select
630 opl3_command(map->ioaddr, WAVE_SELECT + map->op[2], instr->operators[OFFS_4OP + 8]);
631 opl3_command(map->ioaddr, WAVE_SELECT + map->op[3], instr->operators[OFFS_4OP + 9]);
634 * Set Feedback/Connection
637 fpc = instr->operators[OFFS_4OP + 10];
638 if (!(fpc & 0x30))
639 fpc |= 0x30; /*
640 * Ensure that at least one chn is enabled
642 opl3_command(map->ioaddr, FEEDBACK_CONNECTION + map->voice_num + 3, fpc);
645 devc->voc[voice].mode = voice_mode;
646 set_voice_volume(voice, volume, devc->voc[voice].volume);
648 freq = devc->voc[voice].orig_freq = note_to_freq(note) / 1000;
651 * Since the pitch bender may have been set before playing the note, we
652 * have to calculate the bending now.
655 freq = compute_finetune(devc->voc[voice].orig_freq, devc->voc[voice].bender, devc->voc[voice].bender_range, 0);
656 devc->voc[voice].current_freq = freq;
658 freq_to_fnum(freq, &block, &fnum);
661 * Play note
664 data = fnum & 0xff; /*
665 * Least significant bits of fnumber
667 opl3_command(map->ioaddr, FNUM_LOW + map->voice_num, data);
669 data = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
670 devc->voc[voice].keyon_byte = data;
671 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, data);
672 if (voice_mode == 4)
673 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num + 3, data);
675 return 0;
678 static void freq_to_fnum (int freq, int *block, int *fnum)
680 int f, octave;
683 * Converts the note frequency to block and fnum values for the FM chip
686 * First try to compute the block -value (octave) where the note belongs
689 f = freq;
691 octave = 5;
693 if (f == 0)
694 octave = 0;
695 else if (f < 261)
697 while (f < 261)
699 octave--;
700 f <<= 1;
703 else if (f > 493)
705 while (f > 493)
707 octave++;
708 f >>= 1;
712 if (octave > 7)
713 octave = 7;
715 *fnum = freq * (1 << (20 - octave)) / 49716;
716 *block = octave;
719 static void opl3_command (int io_addr, unsigned int addr, unsigned int val)
721 int i;
724 * The original 2-OP synth requires a quite long delay after writing to a
725 * register. The OPL-3 survives with just two INBs
728 outb(((unsigned char) (addr & 0xff)), io_addr);
730 if (devc->model != 2)
731 udelay(10);
732 else
733 for (i = 0; i < 2; i++)
734 inb(io_addr);
736 outb(((unsigned char) (val & 0xff)), io_addr + 1);
738 if (devc->model != 2)
739 udelay(30);
740 else
741 for (i = 0; i < 2; i++)
742 inb(io_addr);
745 static void opl3_reset(int devno)
747 int i;
749 for (i = 0; i < 18; i++)
750 devc->lv_map[i] = i;
752 for (i = 0; i < devc->nr_voice; i++)
754 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
755 KSL_LEVEL + pv_map[devc->lv_map[i]].op[0], 0xff);
757 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
758 KSL_LEVEL + pv_map[devc->lv_map[i]].op[1], 0xff);
760 if (pv_map[devc->lv_map[i]].voice_mode == 4)
762 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
763 KSL_LEVEL + pv_map[devc->lv_map[i]].op[2], 0xff);
765 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
766 KSL_LEVEL + pv_map[devc->lv_map[i]].op[3], 0xff);
769 opl3_kill_note(devno, i, 0, 64);
772 if (devc->model == 2)
774 devc->v_alloc->max_voice = devc->nr_voice = 18;
776 for (i = 0; i < 18; i++)
777 pv_map[i].voice_mode = 2;
782 static int opl3_open(int dev, int mode)
784 int i;
786 if (devc->busy)
787 return -EBUSY;
788 devc->busy = 1;
790 devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
791 devc->v_alloc->timestamp = 0;
793 for (i = 0; i < 18; i++)
795 devc->v_alloc->map[i] = 0;
796 devc->v_alloc->alloc_times[i] = 0;
799 devc->cmask = 0x00; /*
800 * Just 2 OP mode
802 if (devc->model == 2)
803 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
804 return 0;
807 static void opl3_close(int dev)
809 devc->busy = 0;
810 devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
812 devc->fm_info.nr_drums = 0;
813 devc->fm_info.perc_mode = 0;
815 opl3_reset(dev);
818 static void opl3_hw_control(int dev, unsigned char *event)
822 static int opl3_load_patch(int dev, int format, const char __user *addr,
823 int count, int pmgr_flag)
825 struct sbi_instrument ins;
827 if (count <sizeof(ins))
829 printk(KERN_WARNING "FM Error: Patch record too short\n");
830 return -EINVAL;
833 if (copy_from_user(&ins, addr, sizeof(ins)))
834 return -EFAULT;
836 if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR)
838 printk(KERN_WARNING "FM Error: Invalid instrument number %d\n", ins.channel);
839 return -EINVAL;
841 ins.key = format;
843 return store_instr(ins.channel, &ins);
846 static void opl3_panning(int dev, int voice, int value)
849 if (voice < 0 || voice >= devc->nr_voice)
850 return;
852 devc->voc[voice].panning = value;
855 static void opl3_volume_method(int dev, int mode)
859 #define SET_VIBRATO(cell) { \
860 tmp = instr->operators[(cell-1)+(((cell-1)/2)*OFFS_4OP)]; \
861 if (pressure > 110) \
862 tmp |= 0x40; /* Vibrato on */ \
863 opl3_command (map->ioaddr, AM_VIB + map->op[cell-1], tmp);}
865 static void opl3_aftertouch(int dev, int voice, int pressure)
867 int tmp;
868 struct sbi_instrument *instr;
869 struct physical_voice_info *map;
871 if (voice < 0 || voice >= devc->nr_voice)
872 return;
874 map = &pv_map[devc->lv_map[voice]];
876 DEB(printk("Aftertouch %d\n", voice));
878 if (map->voice_mode == 0)
879 return;
882 * Adjust the amount of vibrato depending the pressure
885 instr = devc->act_i[voice];
887 if (!instr)
888 instr = &devc->i_map[0];
890 if (devc->voc[voice].mode == 4)
892 int connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
894 switch (connection)
896 case 0:
897 SET_VIBRATO(4);
898 break;
900 case 1:
901 SET_VIBRATO(2);
902 SET_VIBRATO(4);
903 break;
905 case 2:
906 SET_VIBRATO(1);
907 SET_VIBRATO(4);
908 break;
910 case 3:
911 SET_VIBRATO(1);
912 SET_VIBRATO(3);
913 SET_VIBRATO(4);
914 break;
918 * Not implemented yet
921 else
923 SET_VIBRATO(1);
925 if ((instr->operators[10] & 0x01)) /*
926 * Additive synthesis
928 SET_VIBRATO(2);
932 #undef SET_VIBRATO
934 static void bend_pitch(int dev, int voice, int value)
936 unsigned char data;
937 int block, fnum, freq;
938 struct physical_voice_info *map;
940 map = &pv_map[devc->lv_map[voice]];
942 if (map->voice_mode == 0)
943 return;
945 devc->voc[voice].bender = value;
946 if (!value)
947 return;
948 if (!(devc->voc[voice].keyon_byte & 0x20))
949 return; /*
950 * Not keyed on
953 freq = compute_finetune(devc->voc[voice].orig_freq, devc->voc[voice].bender, devc->voc[voice].bender_range, 0);
954 devc->voc[voice].current_freq = freq;
956 freq_to_fnum(freq, &block, &fnum);
958 data = fnum & 0xff; /*
959 * Least significant bits of fnumber
961 opl3_command(map->ioaddr, FNUM_LOW + map->voice_num, data);
963 data = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
964 devc->voc[voice].keyon_byte = data;
965 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, data);
968 static void opl3_controller (int dev, int voice, int ctrl_num, int value)
970 if (voice < 0 || voice >= devc->nr_voice)
971 return;
973 switch (ctrl_num)
975 case CTRL_PITCH_BENDER:
976 bend_pitch(dev, voice, value);
977 break;
979 case CTRL_PITCH_BENDER_RANGE:
980 devc->voc[voice].bender_range = value;
981 break;
983 case CTL_MAIN_VOLUME:
984 devc->voc[voice].volume = value / 128;
985 break;
987 case CTL_PAN:
988 devc->voc[voice].panning = (value * 2) - 128;
989 break;
993 static void opl3_bender(int dev, int voice, int value)
995 if (voice < 0 || voice >= devc->nr_voice)
996 return;
998 bend_pitch(dev, voice, value - 8192);
1001 static int opl3_alloc_voice(int dev, int chn, int note, struct voice_alloc_info *alloc)
1003 int i, p, best, first, avail, best_time = 0x7fffffff;
1004 struct sbi_instrument *instr;
1005 int is4op;
1006 int instr_no;
1008 if (chn < 0 || chn > 15)
1009 instr_no = 0;
1010 else
1011 instr_no = devc->chn_info[chn].pgm_num;
1013 instr = &devc->i_map[instr_no];
1014 if (instr->channel < 0 || /* Instrument not loaded */
1015 devc->nr_voice != 12) /* Not in 4 OP mode */
1016 is4op = 0;
1017 else if (devc->nr_voice == 12) /* 4 OP mode */
1018 is4op = (instr->key == OPL3_PATCH);
1019 else
1020 is4op = 0;
1022 if (is4op)
1024 first = p = 0;
1025 avail = 6;
1027 else
1029 if (devc->nr_voice == 12) /* 4 OP mode. Use the '2 OP only' operators first */
1030 first = p = 6;
1031 else
1032 first = p = 0;
1033 avail = devc->nr_voice;
1037 * Now try to find a free voice
1039 best = first;
1041 for (i = 0; i < avail; i++)
1043 if (alloc->map[p] == 0)
1045 return p;
1047 if (alloc->alloc_times[p] < best_time) /* Find oldest playing note */
1049 best_time = alloc->alloc_times[p];
1050 best = p;
1052 p = (p + 1) % avail;
1056 * Insert some kind of priority mechanism here.
1059 if (best < 0)
1060 best = 0;
1061 if (best > devc->nr_voice)
1062 best -= devc->nr_voice;
1064 return best; /* All devc->voc in use. Select the first one. */
1067 static void opl3_setup_voice(int dev, int voice, int chn)
1069 struct channel_info *info;
1071 if (voice < 0 || voice >= devc->nr_voice)
1072 return;
1074 if (chn < 0 || chn > 15)
1075 return;
1077 info = &synth_devs[dev]->chn_info[chn];
1079 opl3_set_instr(dev, voice, info->pgm_num);
1081 devc->voc[voice].bender = 0;
1082 devc->voc[voice].bender_range = info->bender_range;
1083 devc->voc[voice].volume = info->controllers[CTL_MAIN_VOLUME];
1084 devc->voc[voice].panning = (info->controllers[CTL_PAN] * 2) - 128;
1087 static struct synth_operations opl3_operations =
1089 .owner = THIS_MODULE,
1090 .id = "OPL",
1091 .info = NULL,
1092 .midi_dev = 0,
1093 .synth_type = SYNTH_TYPE_FM,
1094 .synth_subtype = FM_TYPE_ADLIB,
1095 .open = opl3_open,
1096 .close = opl3_close,
1097 .ioctl = opl3_ioctl,
1098 .kill_note = opl3_kill_note,
1099 .start_note = opl3_start_note,
1100 .set_instr = opl3_set_instr,
1101 .reset = opl3_reset,
1102 .hw_control = opl3_hw_control,
1103 .load_patch = opl3_load_patch,
1104 .aftertouch = opl3_aftertouch,
1105 .controller = opl3_controller,
1106 .panning = opl3_panning,
1107 .volume_method = opl3_volume_method,
1108 .bender = opl3_bender,
1109 .alloc_voice = opl3_alloc_voice,
1110 .setup_voice = opl3_setup_voice
1113 static int opl3_init(int ioaddr, struct module *owner)
1115 int i;
1116 int me;
1118 if (devc == NULL)
1120 printk(KERN_ERR "opl3: Device control structure not initialized.\n");
1121 return -1;
1124 if ((me = sound_alloc_synthdev()) == -1)
1126 printk(KERN_WARNING "opl3: Too many synthesizers\n");
1127 return -1;
1130 devc->nr_voice = 9;
1132 devc->fm_info.device = 0;
1133 devc->fm_info.synth_type = SYNTH_TYPE_FM;
1134 devc->fm_info.synth_subtype = FM_TYPE_ADLIB;
1135 devc->fm_info.perc_mode = 0;
1136 devc->fm_info.nr_voices = 9;
1137 devc->fm_info.nr_drums = 0;
1138 devc->fm_info.instr_bank_size = SBFM_MAXINSTR;
1139 devc->fm_info.capabilities = 0;
1140 devc->left_io = ioaddr;
1141 devc->right_io = ioaddr + 2;
1143 if (detected_model <= 2)
1144 devc->model = 1;
1145 else
1147 devc->model = 2;
1148 if (detected_model == 4)
1149 devc->is_opl4 = 1;
1152 opl3_operations.info = &devc->fm_info;
1154 synth_devs[me] = &opl3_operations;
1156 if (owner)
1157 synth_devs[me]->owner = owner;
1159 sequencer_init();
1160 devc->v_alloc = &opl3_operations.alloc;
1161 devc->chn_info = &opl3_operations.chn_info[0];
1163 if (devc->model == 2)
1165 if (devc->is_opl4)
1166 strcpy(devc->fm_info.name, "Yamaha OPL4/OPL3 FM");
1167 else
1168 strcpy(devc->fm_info.name, "Yamaha OPL3");
1170 devc->v_alloc->max_voice = devc->nr_voice = 18;
1171 devc->fm_info.nr_drums = 0;
1172 devc->fm_info.synth_subtype = FM_TYPE_OPL3;
1173 devc->fm_info.capabilities |= SYNTH_CAP_OPL3;
1175 for (i = 0; i < 18; i++)
1177 if (pv_map[i].ioaddr == USE_LEFT)
1178 pv_map[i].ioaddr = devc->left_io;
1179 else
1180 pv_map[i].ioaddr = devc->right_io;
1182 opl3_command(devc->right_io, OPL3_MODE_REGISTER, OPL3_ENABLE);
1183 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, 0x00);
1185 else
1187 strcpy(devc->fm_info.name, "Yamaha OPL2");
1188 devc->v_alloc->max_voice = devc->nr_voice = 9;
1189 devc->fm_info.nr_drums = 0;
1191 for (i = 0; i < 18; i++)
1192 pv_map[i].ioaddr = devc->left_io;
1194 conf_printf2(devc->fm_info.name, ioaddr, 0, -1, -1);
1196 for (i = 0; i < SBFM_MAXINSTR; i++)
1197 devc->i_map[i].channel = -1;
1199 return me;
1202 static int me;
1204 static int io = -1;
1206 module_param(io, int, 0);
1208 static int __init init_opl3 (void)
1210 printk(KERN_INFO "YM3812 and OPL-3 driver Copyright (C) by Hannu Savolainen, Rob Hooft 1993-1996\n");
1212 if (io != -1) /* User loading pure OPL3 module */
1214 if (!opl3_detect(io))
1216 return -ENODEV;
1219 me = opl3_init(io, THIS_MODULE);
1222 return 0;
1225 static void __exit cleanup_opl3(void)
1227 if (devc && io != -1)
1229 if (devc->base) {
1230 release_region(devc->base,4);
1231 if (devc->is_opl4)
1232 release_region(devc->base - 8, 2);
1234 kfree(devc);
1235 devc = NULL;
1236 sound_unload_synthdev(me);
1240 module_init(init_opl3);
1241 module_exit(cleanup_opl3);
1243 #ifndef MODULE
1244 static int __init setup_opl3(char *str)
1246 /* io */
1247 int ints[2];
1249 str = get_options(str, ARRAY_SIZE(ints), ints);
1251 io = ints[1];
1253 return 1;
1256 __setup("opl3=", setup_opl3);
1257 #endif
1258 MODULE_LICENSE("GPL");