?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Force this on for -next/mm testing purposes.
[linux-2.6/next.git] / sound / oss / opl3.c
blob407cd677950bccb68059fdcd1abec6da914b7a38
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 typedef 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 } opl_devinfo;
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 DEB(printk("Kill note %d\n", voice));
279
280 if (map->voice_mode == 0)
281 return 0;
282
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;
293 }
294
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
302
303 static int store_instr(int instr_no, struct sbi_instrument *instr)
304 {
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;
309 }
310
311 static int opl3_set_instr (int dev, int voice, int instr_no)
312 {
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) */
317
318 devc->act_i[voice] = &devc->i_map[instr_no];
319 return 0;
320 }
321
322 /*
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)
330 */
331
332 static char fm_volume_table[128] =
333 {
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
350 };
351
352 static void calc_vol(unsigned char *regbyte, int volume, int main_vol)
353 {
354 int level = (~*regbyte & 0x3f);
355
356 if (main_vol > 127)
357 main_vol = 127;
358 volume = (volume * main_vol) / 127;
359
360 if (level)
361 level += fm_volume_table[volume];
362
363 if (level > 0x3f)
364 level = 0x3f;
365 if (level < 0)
366 level = 0;
367
368 *regbyte = (*regbyte & 0xc0) | (~level & 0x3f);
369 }
370
371 static void set_voice_volume(int voice, int volume, int main_vol)
372 {
373 unsigned char vol1, vol2, vol3, vol4;
374 struct sbi_instrument *instr;
375 struct physical_voice_info *map;
376
377 if (voice < 0 || voice >= devc->nr_voice)
378 return;
379
380 map = &pv_map[devc->lv_map[voice]];
381 instr = devc->act_i[voice];
382
383 if (!instr)
384 instr = &devc->i_map[0];
385
386 if (instr->channel < 0)
387 return;
388
389 if (devc->voc[voice].mode == 0)
390 return;
391
392 if (devc->voc[voice].mode == 2)
393 {
394 vol1 = instr->operators[2];
395 vol2 = instr->operators[3];
396 if ((instr->operators[10] & 0x01))
397 {
398 calc_vol(&vol1, volume, main_vol);
399 calc_vol(&vol2, volume, main_vol);
400 }
401 else
402 {
403 calc_vol(&vol2, volume, main_vol);
404 }
405 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], vol1);
406 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], vol2);
407 }
408 else
409 { /*
410 * 4 OP voice
411 */
412 int connection;
413
414 vol1 = instr->operators[2];
415 vol2 = instr->operators[3];
416 vol3 = instr->operators[OFFS_4OP + 2];
417 vol4 = instr->operators[OFFS_4OP + 3];
418
419 /*
420 * The connection method for 4 OP devc->voc is defined by the rightmost
421 * bits at the offsets 10 and 10+OFFS_4OP
422 */
423
424 connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
425
426 switch (connection)
427 {
428 case 0:
429 calc_vol(&vol4, volume, main_vol);
430 break;
431
432 case 1:
433 calc_vol(&vol2, volume, main_vol);
434 calc_vol(&vol4, volume, main_vol);
435 break;
436
437 case 2:
438 calc_vol(&vol1, volume, main_vol);
439 calc_vol(&vol4, volume, main_vol);
440 break;
441
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;
447
448 default:
449 ;
450 }
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);
455 }
456 }
457
458 static int opl3_start_note (int dev, int voice, int note, int volume)
459 {
460 unsigned char data, fpc;
461 int block, fnum, freq, voice_mode, pan;
462 struct sbi_instrument *instr;
463 struct physical_voice_info *map;
464
465 if (voice < 0 || voice >= devc->nr_voice)
466 return 0;
467
468 map = &pv_map[devc->lv_map[voice]];
469 pan = devc->voc[voice].panning;
470
471 if (map->voice_mode == 0)
472 return 0;
473
474 if (note == 255) /*
475 * Just change the volume
476 */
477 {
478 set_voice_volume(voice, volume, devc->voc[voice].volume);
479 return 0;
480 }
481
482 /*
483 * Kill previous note before playing
484 */
485
486 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], 0xff); /*
487 * Carrier
488 * volume to
489 * min
490 */
491 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], 0xff); /*
492 * Modulator
493 * volume to
494 */
495
496 if (map->voice_mode == 4)
497 {
498 opl3_command(map->ioaddr, KSL_LEVEL + map->op[2], 0xff);
499 opl3_command(map->ioaddr, KSL_LEVEL + map->op[3], 0xff);
500 }
501
502 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, 0x00); /*
503 * Note
504 * off
505 */
506
507 instr = devc->act_i[voice];
508
509 if (!instr)
510 instr = &devc->i_map[0];
511
512 if (instr->channel < 0)
513 {
514 printk(KERN_WARNING "opl3: Initializing voice %d with undefined instrument\n", voice);
515 return 0;
516 }
517
518 if (map->voice_mode == 2 && instr->key == OPL3_PATCH)
519 return 0; /*
520 * Cannot play
521 */
522
523 voice_mode = map->voice_mode;
524
525 if (voice_mode == 4)
526 {
527 int voice_shift;
528
529 voice_shift = (map->ioaddr == devc->left_io) ? 0 : 3;
530 voice_shift += map->voice_num;
531
532 if (instr->key != OPL3_PATCH) /*
533 * Just 2 OP patch
534 */
535 {
536 voice_mode = 2;
537 devc->cmask &= ~(1 << voice_shift);
538 }
539 else
540 {
541 devc->cmask |= (1 << voice_shift);
542 }
543
544 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
545 }
546
547 /*
548 * Set Sound Characteristics
549 */
550
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]);
553
554 /*
555 * Set Attack/Decay
556 */
557
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]);
560
561 /*
562 * Set Sustain/Release
563 */
564
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]);
567
568 /*
569 * Set Wave Select
570 */
571
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]);
574
575 /*
576 * Set Feedback/Connection
577 */
578
579 fpc = instr->operators[10];
580
581 if (pan != 0xffff)
582 {
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);
591 }
592
593 if (!(fpc & 0x30))
594 fpc |= 0x30; /*
595 * Ensure that at least one chn is enabled
596 */
597 opl3_command(map->ioaddr, FEEDBACK_CONNECTION + map->voice_num, fpc);
598
599 /*
600 * If the voice is a 4 OP one, initialize the operators 3 and 4 also
601 */
602
603 if (voice_mode == 4)
604 {
605 /*
606 * Set Sound Characteristics
607 */
608
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]);
611
612 /*
613 * Set Attack/Decay
614 */
615
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]);
618
619 /*
620 * Set Sustain/Release
621 */
622
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]);
625
626 /*
627 * Set Wave Select
628 */
629
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]);
632
633 /*
634 * Set Feedback/Connection
635 */
636
637 fpc = instr->operators[OFFS_4OP + 10];
638 if (!(fpc & 0x30))
639 fpc |= 0x30; /*
640 * Ensure that at least one chn is enabled
641 */
642 opl3_command(map->ioaddr, FEEDBACK_CONNECTION + map->voice_num + 3, fpc);
643 }
644
645 devc->voc[voice].mode = voice_mode;
646 set_voice_volume(voice, volume, devc->voc[voice].volume);
647
648 freq = devc->voc[voice].orig_freq = note_to_freq(note) / 1000;
649
650 /*
651 * Since the pitch bender may have been set before playing the note, we
652 * have to calculate the bending now.
653 */
654
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;
657
658 freq_to_fnum(freq, &block, &fnum);
659
660 /*
661 * Play note
662 */
663
664 data = fnum & 0xff; /*
665 * Least significant bits of fnumber
666 */
667 opl3_command(map->ioaddr, FNUM_LOW + map->voice_num, data);
668
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);
674
675 return 0;
676 }
677
678 static void freq_to_fnum (int freq, int *block, int *fnum)
679 {
680 int f, octave;
681
682 /*
683 * Converts the note frequency to block and fnum values for the FM chip
684 */
685 /*
686 * First try to compute the block -value (octave) where the note belongs
687 */
688
689 f = freq;
690
691 octave = 5;
692
693 if (f == 0)
694 octave = 0;
695 else if (f < 261)
696 {
697 while (f < 261)
698 {
699 octave--;
700 f <<= 1;
701 }
702 }
703 else if (f > 493)
704 {
705 while (f > 493)
706 {
707 octave++;
708 f >>= 1;
709 }
710 }
711
712 if (octave > 7)
713 octave = 7;
714
715 *fnum = freq * (1 << (20 - octave)) / 49716;
716 *block = octave;
717 }
718
719 static void opl3_command (int io_addr, unsigned int addr, unsigned int val)
720 {
721 int i;
722
723 /*
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
726 */
727
728 outb(((unsigned char) (addr & 0xff)), io_addr);
729
730 if (devc->model != 2)
731 udelay(10);
732 else
733 for (i = 0; i < 2; i++)
734 inb(io_addr);
735
736 outb(((unsigned char) (val & 0xff)), io_addr + 1);
737
738 if (devc->model != 2)
739 udelay(30);
740 else
741 for (i = 0; i < 2; i++)
742 inb(io_addr);
743 }
744
745 static void opl3_reset(int devno)
746 {
747 int i;
748
749 for (i = 0; i < 18; i++)
750 devc->lv_map[i] = i;
751
752 for (i = 0; i < devc->nr_voice; i++)
753 {
754 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
755 KSL_LEVEL + pv_map[devc->lv_map[i]].op[0], 0xff);
756
757 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
758 KSL_LEVEL + pv_map[devc->lv_map[i]].op[1], 0xff);
759
760 if (pv_map[devc->lv_map[i]].voice_mode == 4)
761 {
762 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
763 KSL_LEVEL + pv_map[devc->lv_map[i]].op[2], 0xff);
764
765 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
766 KSL_LEVEL + pv_map[devc->lv_map[i]].op[3], 0xff);
767 }
768
769 opl3_kill_note(devno, i, 0, 64);
770 }
771
772 if (devc->model == 2)
773 {
774 devc->v_alloc->max_voice = devc->nr_voice = 18;
775
776 for (i = 0; i < 18; i++)
777 pv_map[i].voice_mode = 2;
778
779 }
780 }
781
782 static int opl3_open(int dev, int mode)
783 {
784 int i;
785
786 if (devc->busy)
787 return -EBUSY;
788 devc->busy = 1;
789
790 devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
791 devc->v_alloc->timestamp = 0;
792
793 for (i = 0; i < 18; i++)
794 {
795 devc->v_alloc->map[i] = 0;
796 devc->v_alloc->alloc_times[i] = 0;
797 }
798
799 devc->cmask = 0x00; /*
800 * Just 2 OP mode
801 */
802 if (devc->model == 2)
803 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
804 return 0;
805 }
806
807 static void opl3_close(int dev)
808 {
809 devc->busy = 0;
810 devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
811
812 devc->fm_info.nr_drums = 0;
813 devc->fm_info.perc_mode = 0;
814
815 opl3_reset(dev);
816 }
817
818 static void opl3_hw_control(int dev, unsigned char *event)
819 {
820 }
821
822 static int opl3_load_patch(int dev, int format, const char __user *addr,
823 int count, int pmgr_flag)
824 {
825 struct sbi_instrument ins;
826
827 if (count <sizeof(ins))
828 {
829 printk(KERN_WARNING "FM Error: Patch record too short\n");
830 return -EINVAL;
831 }
832
833 if (copy_from_user(&ins, addr, sizeof(ins)))
834 return -EFAULT;
835
836 if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR)
837 {
838 printk(KERN_WARNING "FM Error: Invalid instrument number %d\n", ins.channel);
839 return -EINVAL;
840 }
841 ins.key = format;
842
843 return store_instr(ins.channel, &ins);
844 }
845
846 static void opl3_panning(int dev, int voice, int value)
847 {
848
849 if (voice < 0 || voice >= devc->nr_voice)
850 return;
851
852 devc->voc[voice].panning = value;
853 }
854
855 static void opl3_volume_method(int dev, int mode)
856 {
857 }
858
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);}
864
865 static void opl3_aftertouch(int dev, int voice, int pressure)
866 {
867 int tmp;
868 struct sbi_instrument *instr;
869 struct physical_voice_info *map;
870
871 if (voice < 0 || voice >= devc->nr_voice)
872 return;
873
874 map = &pv_map[devc->lv_map[voice]];
875
876 DEB(printk("Aftertouch %d\n", voice));
877
878 if (map->voice_mode == 0)
879 return;
880
881 /*
882 * Adjust the amount of vibrato depending the pressure
883 */
884
885 instr = devc->act_i[voice];
886
887 if (!instr)
888 instr = &devc->i_map[0];
889
890 if (devc->voc[voice].mode == 4)
891 {
892 int connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
893
894 switch (connection)
895 {
896 case 0:
897 SET_VIBRATO(4);
898 break;
899
900 case 1:
901 SET_VIBRATO(2);
902 SET_VIBRATO(4);
903 break;
904
905 case 2:
906 SET_VIBRATO(1);
907 SET_VIBRATO(4);
908 break;
909
910 case 3:
911 SET_VIBRATO(1);
912 SET_VIBRATO(3);
913 SET_VIBRATO(4);
914 break;
915
916 }
917 /*
918 * Not implemented yet
919 */
920 }
921 else
922 {
923 SET_VIBRATO(1);
924
925 if ((instr->operators[10] & 0x01)) /*
926 * Additive synthesis
927 */
928 SET_VIBRATO(2);
929 }
930 }
931
932 #undef SET_VIBRATO
933
934 static void bend_pitch(int dev, int voice, int value)
935 {
936 unsigned char data;
937 int block, fnum, freq;
938 struct physical_voice_info *map;
939
940 map = &pv_map[devc->lv_map[voice]];
941
942 if (map->voice_mode == 0)
943 return;
944
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
951 */
952
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;
955
956 freq_to_fnum(freq, &block, &fnum);
957
958 data = fnum & 0xff; /*
959 * Least significant bits of fnumber
960 */
961 opl3_command(map->ioaddr, FNUM_LOW + map->voice_num, data);
962
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);
966 }
967
968 static void opl3_controller (int dev, int voice, int ctrl_num, int value)
969 {
970 if (voice < 0 || voice >= devc->nr_voice)
971 return;
972
973 switch (ctrl_num)
974 {
975 case CTRL_PITCH_BENDER:
976 bend_pitch(dev, voice, value);
977 break;
978
979 case CTRL_PITCH_BENDER_RANGE:
980 devc->voc[voice].bender_range = value;
981 break;
982
983 case CTL_MAIN_VOLUME:
984 devc->voc[voice].volume = value / 128;
985 break;
986
987 case CTL_PAN:
988 devc->voc[voice].panning = (value * 2) - 128;
989 break;
990 }
991 }
992
993 static void opl3_bender(int dev, int voice, int value)
994 {
995 if (voice < 0 || voice >= devc->nr_voice)
996 return;
997
998 bend_pitch(dev, voice, value - 8192);
999 }
1000
1001 static int opl3_alloc_voice(int dev, int chn, int note, struct voice_alloc_info *alloc)
1002 {
1003 int i, p, best, first, avail, best_time = 0x7fffffff;
1004 struct sbi_instrument *instr;
1005 int is4op;
1006 int instr_no;
1007
1008 if (chn < 0 || chn > 15)
1009 instr_no = 0;
1010 else
1011 instr_no = devc->chn_info[chn].pgm_num;
1012
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;
1021
1022 if (is4op)
1023 {
1024 first = p = 0;
1025 avail = 6;
1026 }
1027 else
1028 {
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;
1034 }
1035
1036 /*
1037 * Now try to find a free voice
1038 */
1039 best = first;
1040
1041 for (i = 0; i < avail; i++)
1042 {
1043 if (alloc->map[p] == 0)
1044 {
1045 return p;
1046 }
1047 if (alloc->alloc_times[p] < best_time) /* Find oldest playing note */
1048 {
1049 best_time = alloc->alloc_times[p];
1050 best = p;
1051 }
1052 p = (p + 1) % avail;
1053 }
1054
1055 /*
1056 * Insert some kind of priority mechanism here.
1057 */
1058
1059 if (best < 0)
1060 best = 0;
1061 if (best > devc->nr_voice)
1062 best -= devc->nr_voice;
1063
1064 return best; /* All devc->voc in use. Select the first one. */
1065 }
1066
1067 static void opl3_setup_voice(int dev, int voice, int chn)
1068 {
1069 struct channel_info *info;
1070
1071 if (voice < 0 || voice >= devc->nr_voice)
1072 return;
1073
1074 if (chn < 0 || chn > 15)
1075 return;
1076
1077 info = &synth_devs[dev]->chn_info[chn];
1078
1079 opl3_set_instr(dev, voice, info->pgm_num);
1080
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;
1085 }
1086
1087 static struct synth_operations opl3_operations =
1088 {
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
1111 };
1112
1113 static int opl3_init(int ioaddr, struct module *owner)
1114 {
1115 int i;
1116 int me;
1117
1118 if (devc == NULL)
1119 {
1120 printk(KERN_ERR "opl3: Device control structure not initialized.\n");
1121 return -1;
1122 }
1123
1124 if ((me = sound_alloc_synthdev()) == -1)
1125 {
1126 printk(KERN_WARNING "opl3: Too many synthesizers\n");
1127 return -1;
1128 }
1129
1130 devc->nr_voice = 9;
1131
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;
1142
1143 if (detected_model <= 2)
1144 devc->model = 1;
1145 else
1146 {
1147 devc->model = 2;
1148 if (detected_model == 4)
1149 devc->is_opl4 = 1;
1150 }
1151
1152 opl3_operations.info = &devc->fm_info;
1153
1154 synth_devs[me] = &opl3_operations;
1155
1156 if (owner)
1157 synth_devs[me]->owner = owner;
1158
1159 sequencer_init();
1160 devc->v_alloc = &opl3_operations.alloc;
1161 devc->chn_info = &opl3_operations.chn_info[0];
1162
1163 if (devc->model == 2)
1164 {
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");
1169
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;
1174
1175 for (i = 0; i < 18; i++)
1176 {
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;
1181 }
1182 opl3_command(devc->right_io, OPL3_MODE_REGISTER, OPL3_ENABLE);
1183 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, 0x00);
1184 }
1185 else
1186 {
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;
1190
1191 for (i = 0; i < 18; i++)
1192 pv_map[i].ioaddr = devc->left_io;
1193 };
1194 conf_printf2(devc->fm_info.name, ioaddr, 0, -1, -1);
1195
1196 for (i = 0; i < SBFM_MAXINSTR; i++)
1197 devc->i_map[i].channel = -1;
1198
1199 return me;
1200 }
1201
1202 static int me;
1203
1204 static int io = -1;
1205
1206 module_param(io, int, 0);
1207
1208 static int __init init_opl3 (void)
1209 {
1210 printk(KERN_INFO "YM3812 and OPL-3 driver Copyright (C) by Hannu Savolainen, Rob Hooft 1993-1996\n");
1211
1212 if (io != -1) /* User loading pure OPL3 module */
1213 {
1214 if (!opl3_detect(io))
1215 {
1216 return -ENODEV;
1217 }
1218
1219 me = opl3_init(io, THIS_MODULE);
1220 }
1221
1222 return 0;
1223 }
1224
1225 static void __exit cleanup_opl3(void)
1226 {
1227 if (devc && io != -1)
1228 {
1229 if (devc->base) {
1230 release_region(devc->base,4);
1231 if (devc->is_opl4)
1232 release_region(devc->base - 8, 2);
1233 }
1234 kfree(devc);
1235 devc = NULL;
1236 sound_unload_synthdev(me);
1237 }
1238 }
1239
1240 module_init(init_opl3);
1241 module_exit(cleanup_opl3);
1242
1243 #ifndef MODULE
1244 static int __init setup_opl3(char *str)
1245 {
1246 /* io */
1247 int ints[2];
1248
1249 str = get_options(str, ARRAY_SIZE(ints), ints);
1250
1251 io = ints[1];
1252
1253 return 1;
1254 }
1255
1256 __setup("opl3=", setup_opl3);
1257 #endif
1258 MODULE_LICENSE("GPL");
linux-next