?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libata: clean up SFF init mess
[linux-2.6/mini2440.git] / sound / oss / opl3.c
blobfc273e55094480db93f3ad351c4e6aea49137c28
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/module.h>
28 #include <linux/delay.h>
29
30 /*
31 * Major improvements to the FM handling 30AUG92 by Rob Hooft,
32 * hooft@chem.ruu.nl
33 */
34
35 #include "sound_config.h"
36
37 #include "opl3.h"
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 int *osp;
77 } opl_devinfo;
78
79 static struct opl_devinfo *devc = NULL;
80
81 static int detected_model;
82
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);
87
88 static void enter_4op_mode(void)
89 {
90 int i;
91 static int v4op[MAX_VOICE] = {
92 0, 1, 2, 9, 10, 11, 6, 7, 8, 15, 16, 17
93 };
94
95 devc->cmask = 0x3f; /* Connect all possible 4 OP voice operators */
96 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, 0x3f);
97
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;
102
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;
107
108 for (i = 0; i < 12; i++)
109 devc->lv_map[i] = v4op[i];
110 devc->v_alloc->max_voice = devc->nr_voice = 12;
111 }
112
113 static int opl3_ioctl(int dev, unsigned int cmd, void __user * arg)
114 {
115 struct sbi_instrument ins;
116
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;
125 }
126 return store_instr(ins.channel, &ins);
127
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;
133
134 case SNDCTL_SYNTH_MEMAVL:
135 return 0x7fffffff;
136
137 case SNDCTL_FM_4OP_ENABLE:
138 if (devc->model == 2)
139 enter_4op_mode();
140 return 0;
141
142 default:
143 return -EINVAL;
144 }
145 }
146
147 int opl3_detect(int ioaddr, int *osp)
148 {
149 /*
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.
153 *
154 * Note! The timers of the FM chip are not connected to AdLib (and compatible)
155 * boards.
156 *
157 * Note2! The chip is initialized if detected.
158 */
159
160 unsigned char stat1, signature;
161 int i;
162
163 if (devc != NULL)
164 {
165 printk(KERN_ERR "opl3: Only one OPL3 supported.\n");
166 return 0;
167 }
168
169 devc = kzalloc(sizeof(*devc), GFP_KERNEL);
170
171 if (devc == NULL)
172 {
173 printk(KERN_ERR "opl3: Can't allocate memory for the device control "
174 "structure \n ");
175 return 0;
176 }
177
178 strcpy(devc->fm_info.name, "OPL2");
179
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;
183 }
184
185 devc->osp = osp;
186 devc->base = ioaddr;
187
188 /* Reset timers 1 and 2 */
189 opl3_command(ioaddr, TIMER_CONTROL_REGISTER, TIMER1_MASK | TIMER2_MASK);
190
191 /* Reset the IRQ of the FM chip */
192 opl3_command(ioaddr, TIMER_CONTROL_REGISTER, IRQ_RESET);
193
194 signature = stat1 = inb(ioaddr); /* Status register */
195
196 if (signature != 0x00 && signature != 0x06 && signature != 0x02 &&
197 signature != 0x0f)
198 {
199 MDB(printk(KERN_INFO "OPL3 not detected %x\n", signature));
200 goto cleanup_region;
201 }
202
203 if (signature == 0x06) /* OPL2 */
204 {
205 detected_model = 2;
206 }
207 else if (signature == 0x00 || signature == 0x0f) /* OPL3 or OPL4 */
208 {
209 unsigned char tmp;
210
211 detected_model = 3;
212
213 /*
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.
217 */
218
219 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, 0x00);
220 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, OPL3_ENABLE | OPL4_ENABLE);
221
222 if ((tmp = inb(ioaddr)) == 0x02) /* Have a OPL4 */
223 {
224 detected_model = 4;
225 }
226
227 if (request_region(ioaddr - 8, 2, "OPL4")) /* OPL4 port was free */
228 {
229 int tmp;
230
231 outb((0x02), ioaddr - 8); /* Select OPL4 ID register */
232 udelay(10);
233 tmp = inb(ioaddr - 7); /* Read it */
234 udelay(10);
235
236 if (tmp == 0x20) /* OPL4 should return 0x20 here */
237 {
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);
243 }
244 else
245 { /* release OPL4 port */
246 release_region(ioaddr - 8, 2);
247 detected_model = 3;
248 }
249 }
250 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, 0);
251 }
252 for (i = 0; i < 9; i++)
253 opl3_command(ioaddr, KEYON_BLOCK + i, 0); /*
254 * Note off
255 */
256
257 opl3_command(ioaddr, TEST_REGISTER, ENABLE_WAVE_SELECT);
258 opl3_command(ioaddr, PERCOSSION_REGISTER, 0x00); /*
259 * Melodic mode.
260 */
261 return 1;
262 cleanup_region:
263 release_region(ioaddr, 4);
264 cleanup_devc:
265 kfree(devc);
266 devc = NULL;
267 return 0;
268 }
269
270 static int opl3_kill_note (int devno, int voice, int note, int velocity)
271 {
272 struct physical_voice_info *map;
273
274 if (voice < 0 || voice >= devc->nr_voice)
275 return 0;
276
277 devc->v_alloc->map[voice] = 0;
278
279 map = &pv_map[devc->lv_map[voice]];
280 DEB(printk("Kill note %d\n", voice));
281
282 if (map->voice_mode == 0)
283 return 0;
284
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;
295 }
296
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
304
305 static int store_instr(int instr_no, struct sbi_instrument *instr)
306 {
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;
311 }
312
313 static int opl3_set_instr (int dev, int voice, int instr_no)
314 {
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) */
319
320 devc->act_i[voice] = &devc->i_map[instr_no];
321 return 0;
322 }
323
324 /*
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)
332 */
333
334 static char fm_volume_table[128] =
335 {
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
352 };
353
354 static void calc_vol(unsigned char *regbyte, int volume, int main_vol)
355 {
356 int level = (~*regbyte & 0x3f);
357
358 if (main_vol > 127)
359 main_vol = 127;
360 volume = (volume * main_vol) / 127;
361
362 if (level)
363 level += fm_volume_table[volume];
364
365 if (level > 0x3f)
366 level = 0x3f;
367 if (level < 0)
368 level = 0;
369
370 *regbyte = (*regbyte & 0xc0) | (~level & 0x3f);
371 }
372
373 static void set_voice_volume(int voice, int volume, int main_vol)
374 {
375 unsigned char vol1, vol2, vol3, vol4;
376 struct sbi_instrument *instr;
377 struct physical_voice_info *map;
378
379 if (voice < 0 || voice >= devc->nr_voice)
380 return;
381
382 map = &pv_map[devc->lv_map[voice]];
383 instr = devc->act_i[voice];
384
385 if (!instr)
386 instr = &devc->i_map[0];
387
388 if (instr->channel < 0)
389 return;
390
391 if (devc->voc[voice].mode == 0)
392 return;
393
394 if (devc->voc[voice].mode == 2)
395 {
396 vol1 = instr->operators[2];
397 vol2 = instr->operators[3];
398 if ((instr->operators[10] & 0x01))
399 {
400 calc_vol(&vol1, volume, main_vol);
401 calc_vol(&vol2, volume, main_vol);
402 }
403 else
404 {
405 calc_vol(&vol2, volume, main_vol);
406 }
407 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], vol1);
408 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], vol2);
409 }
410 else
411 { /*
412 * 4 OP voice
413 */
414 int connection;
415
416 vol1 = instr->operators[2];
417 vol2 = instr->operators[3];
418 vol3 = instr->operators[OFFS_4OP + 2];
419 vol4 = instr->operators[OFFS_4OP + 3];
420
421 /*
422 * The connection method for 4 OP devc->voc is defined by the rightmost
423 * bits at the offsets 10 and 10+OFFS_4OP
424 */
425
426 connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
427
428 switch (connection)
429 {
430 case 0:
431 calc_vol(&vol4, volume, main_vol);
432 break;
433
434 case 1:
435 calc_vol(&vol2, volume, main_vol);
436 calc_vol(&vol4, volume, main_vol);
437 break;
438
439 case 2:
440 calc_vol(&vol1, volume, main_vol);
441 calc_vol(&vol4, volume, main_vol);
442 break;
443
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;
449
450 default:
451 ;
452 }
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);
457 }
458 }
459
460 static int opl3_start_note (int dev, int voice, int note, int volume)
461 {
462 unsigned char data, fpc;
463 int block, fnum, freq, voice_mode, pan;
464 struct sbi_instrument *instr;
465 struct physical_voice_info *map;
466
467 if (voice < 0 || voice >= devc->nr_voice)
468 return 0;
469
470 map = &pv_map[devc->lv_map[voice]];
471 pan = devc->voc[voice].panning;
472
473 if (map->voice_mode == 0)
474 return 0;
475
476 if (note == 255) /*
477 * Just change the volume
478 */
479 {
480 set_voice_volume(voice, volume, devc->voc[voice].volume);
481 return 0;
482 }
483
484 /*
485 * Kill previous note before playing
486 */
487
488 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], 0xff); /*
489 * Carrier
490 * volume to
491 * min
492 */
493 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], 0xff); /*
494 * Modulator
495 * volume to
496 */
497
498 if (map->voice_mode == 4)
499 {
500 opl3_command(map->ioaddr, KSL_LEVEL + map->op[2], 0xff);
501 opl3_command(map->ioaddr, KSL_LEVEL + map->op[3], 0xff);
502 }
503
504 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, 0x00); /*
505 * Note
506 * off
507 */
508
509 instr = devc->act_i[voice];
510
511 if (!instr)
512 instr = &devc->i_map[0];
513
514 if (instr->channel < 0)
515 {
516 printk(KERN_WARNING "opl3: Initializing voice %d with undefined instrument\n", voice);
517 return 0;
518 }
519
520 if (map->voice_mode == 2 && instr->key == OPL3_PATCH)
521 return 0; /*
522 * Cannot play
523 */
524
525 voice_mode = map->voice_mode;
526
527 if (voice_mode == 4)
528 {
529 int voice_shift;
530
531 voice_shift = (map->ioaddr == devc->left_io) ? 0 : 3;
532 voice_shift += map->voice_num;
533
534 if (instr->key != OPL3_PATCH) /*
535 * Just 2 OP patch
536 */
537 {
538 voice_mode = 2;
539 devc->cmask &= ~(1 << voice_shift);
540 }
541 else
542 {
543 devc->cmask |= (1 << voice_shift);
544 }
545
546 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
547 }
548
549 /*
550 * Set Sound Characteristics
551 */
552
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]);
555
556 /*
557 * Set Attack/Decay
558 */
559
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]);
562
563 /*
564 * Set Sustain/Release
565 */
566
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]);
569
570 /*
571 * Set Wave Select
572 */
573
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]);
576
577 /*
578 * Set Feedback/Connection
579 */
580
581 fpc = instr->operators[10];
582
583 if (pan != 0xffff)
584 {
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);
593 }
594
595 if (!(fpc & 0x30))
596 fpc |= 0x30; /*
597 * Ensure that at least one chn is enabled
598 */
599 opl3_command(map->ioaddr, FEEDBACK_CONNECTION + map->voice_num, fpc);
600
601 /*
602 * If the voice is a 4 OP one, initialize the operators 3 and 4 also
603 */
604
605 if (voice_mode == 4)
606 {
607 /*
608 * Set Sound Characteristics
609 */
610
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]);
613
614 /*
615 * Set Attack/Decay
616 */
617
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]);
620
621 /*
622 * Set Sustain/Release
623 */
624
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]);
627
628 /*
629 * Set Wave Select
630 */
631
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]);
634
635 /*
636 * Set Feedback/Connection
637 */
638
639 fpc = instr->operators[OFFS_4OP + 10];
640 if (!(fpc & 0x30))
641 fpc |= 0x30; /*
642 * Ensure that at least one chn is enabled
643 */
644 opl3_command(map->ioaddr, FEEDBACK_CONNECTION + map->voice_num + 3, fpc);
645 }
646
647 devc->voc[voice].mode = voice_mode;
648 set_voice_volume(voice, volume, devc->voc[voice].volume);
649
650 freq = devc->voc[voice].orig_freq = note_to_freq(note) / 1000;
651
652 /*
653 * Since the pitch bender may have been set before playing the note, we
654 * have to calculate the bending now.
655 */
656
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;
659
660 freq_to_fnum(freq, &block, &fnum);
661
662 /*
663 * Play note
664 */
665
666 data = fnum & 0xff; /*
667 * Least significant bits of fnumber
668 */
669 opl3_command(map->ioaddr, FNUM_LOW + map->voice_num, data);
670
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);
676
677 return 0;
678 }
679
680 static void freq_to_fnum (int freq, int *block, int *fnum)
681 {
682 int f, octave;
683
684 /*
685 * Converts the note frequency to block and fnum values for the FM chip
686 */
687 /*
688 * First try to compute the block -value (octave) where the note belongs
689 */
690
691 f = freq;
692
693 octave = 5;
694
695 if (f == 0)
696 octave = 0;
697 else if (f < 261)
698 {
699 while (f < 261)
700 {
701 octave--;
702 f <<= 1;
703 }
704 }
705 else if (f > 493)
706 {
707 while (f > 493)
708 {
709 octave++;
710 f >>= 1;
711 }
712 }
713
714 if (octave > 7)
715 octave = 7;
716
717 *fnum = freq * (1 << (20 - octave)) / 49716;
718 *block = octave;
719 }
720
721 static void opl3_command (int io_addr, unsigned int addr, unsigned int val)
722 {
723 int i;
724
725 /*
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
728 */
729
730 outb(((unsigned char) (addr & 0xff)), io_addr);
731
732 if (devc->model != 2)
733 udelay(10);
734 else
735 for (i = 0; i < 2; i++)
736 inb(io_addr);
737
738 outb(((unsigned char) (val & 0xff)), io_addr + 1);
739
740 if (devc->model != 2)
741 udelay(30);
742 else
743 for (i = 0; i < 2; i++)
744 inb(io_addr);
745 }
746
747 static void opl3_reset(int devno)
748 {
749 int i;
750
751 for (i = 0; i < 18; i++)
752 devc->lv_map[i] = i;
753
754 for (i = 0; i < devc->nr_voice; i++)
755 {
756 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
757 KSL_LEVEL + pv_map[devc->lv_map[i]].op[0], 0xff);
758
759 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
760 KSL_LEVEL + pv_map[devc->lv_map[i]].op[1], 0xff);
761
762 if (pv_map[devc->lv_map[i]].voice_mode == 4)
763 {
764 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
765 KSL_LEVEL + pv_map[devc->lv_map[i]].op[2], 0xff);
766
767 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
768 KSL_LEVEL + pv_map[devc->lv_map[i]].op[3], 0xff);
769 }
770
771 opl3_kill_note(devno, i, 0, 64);
772 }
773
774 if (devc->model == 2)
775 {
776 devc->v_alloc->max_voice = devc->nr_voice = 18;
777
778 for (i = 0; i < 18; i++)
779 pv_map[i].voice_mode = 2;
780
781 }
782 }
783
784 static int opl3_open(int dev, int mode)
785 {
786 int i;
787
788 if (devc->busy)
789 return -EBUSY;
790 devc->busy = 1;
791
792 devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
793 devc->v_alloc->timestamp = 0;
794
795 for (i = 0; i < 18; i++)
796 {
797 devc->v_alloc->map[i] = 0;
798 devc->v_alloc->alloc_times[i] = 0;
799 }
800
801 devc->cmask = 0x00; /*
802 * Just 2 OP mode
803 */
804 if (devc->model == 2)
805 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
806 return 0;
807 }
808
809 static void opl3_close(int dev)
810 {
811 devc->busy = 0;
812 devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
813
814 devc->fm_info.nr_drums = 0;
815 devc->fm_info.perc_mode = 0;
816
817 opl3_reset(dev);
818 }
819
820 static void opl3_hw_control(int dev, unsigned char *event)
821 {
822 }
823
824 static int opl3_load_patch(int dev, int format, const char __user *addr,
825 int offs, int count, int pmgr_flag)
826 {
827 struct sbi_instrument ins;
828
829 if (count <sizeof(ins))
830 {
831 printk(KERN_WARNING "FM Error: Patch record too short\n");
832 return -EINVAL;
833 }
834
835 /*
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?
838 */
839 if(copy_from_user(&((char *) &ins)[offs], addr + offs, sizeof(ins) - offs))
840 return -EFAULT;
841
842 if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR)
843 {
844 printk(KERN_WARNING "FM Error: Invalid instrument number %d\n", ins.channel);
845 return -EINVAL;
846 }
847 ins.key = format;
848
849 return store_instr(ins.channel, &ins);
850 }
851
852 static void opl3_panning(int dev, int voice, int value)
853 {
854 devc->voc[voice].panning = value;
855 }
856
857 static void opl3_volume_method(int dev, int mode)
858 {
859 }
860
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);}
866
867 static void opl3_aftertouch(int dev, int voice, int pressure)
868 {
869 int tmp;
870 struct sbi_instrument *instr;
871 struct physical_voice_info *map;
872
873 if (voice < 0 || voice >= devc->nr_voice)
874 return;
875
876 map = &pv_map[devc->lv_map[voice]];
877
878 DEB(printk("Aftertouch %d\n", voice));
879
880 if (map->voice_mode == 0)
881 return;
882
883 /*
884 * Adjust the amount of vibrato depending the pressure
885 */
886
887 instr = devc->act_i[voice];
888
889 if (!instr)
890 instr = &devc->i_map[0];
891
892 if (devc->voc[voice].mode == 4)
893 {
894 int connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
895
896 switch (connection)
897 {
898 case 0:
899 SET_VIBRATO(4);
900 break;
901
902 case 1:
903 SET_VIBRATO(2);
904 SET_VIBRATO(4);
905 break;
906
907 case 2:
908 SET_VIBRATO(1);
909 SET_VIBRATO(4);
910 break;
911
912 case 3:
913 SET_VIBRATO(1);
914 SET_VIBRATO(3);
915 SET_VIBRATO(4);
916 break;
917
918 }
919 /*
920 * Not implemented yet
921 */
922 }
923 else
924 {
925 SET_VIBRATO(1);
926
927 if ((instr->operators[10] & 0x01)) /*
928 * Additive synthesis
929 */
930 SET_VIBRATO(2);
931 }
932 }
933
934 #undef SET_VIBRATO
935
936 static void bend_pitch(int dev, int voice, int value)
937 {
938 unsigned char data;
939 int block, fnum, freq;
940 struct physical_voice_info *map;
941
942 map = &pv_map[devc->lv_map[voice]];
943
944 if (map->voice_mode == 0)
945 return;
946
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
953 */
954
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;
957
958 freq_to_fnum(freq, &block, &fnum);
959
960 data = fnum & 0xff; /*
961 * Least significant bits of fnumber
962 */
963 opl3_command(map->ioaddr, FNUM_LOW + map->voice_num, data);
964
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);
968 }
969
970 static void opl3_controller (int dev, int voice, int ctrl_num, int value)
971 {
972 if (voice < 0 || voice >= devc->nr_voice)
973 return;
974
975 switch (ctrl_num)
976 {
977 case CTRL_PITCH_BENDER:
978 bend_pitch(dev, voice, value);
979 break;
980
981 case CTRL_PITCH_BENDER_RANGE:
982 devc->voc[voice].bender_range = value;
983 break;
984
985 case CTL_MAIN_VOLUME:
986 devc->voc[voice].volume = value / 128;
987 break;
988
989 case CTL_PAN:
990 devc->voc[voice].panning = (value * 2) - 128;
991 break;
992 }
993 }
994
995 static void opl3_bender(int dev, int voice, int value)
996 {
997 if (voice < 0 || voice >= devc->nr_voice)
998 return;
999
1000 bend_pitch(dev, voice, value - 8192);
1001 }
1002
1003 static int opl3_alloc_voice(int dev, int chn, int note, struct voice_alloc_info *alloc)
1004 {
1005 int i, p, best, first, avail, best_time = 0x7fffffff;
1006 struct sbi_instrument *instr;
1007 int is4op;
1008 int instr_no;
1009
1010 if (chn < 0 || chn > 15)
1011 instr_no = 0;
1012 else
1013 instr_no = devc->chn_info[chn].pgm_num;
1014
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;
1023
1024 if (is4op)
1025 {
1026 first = p = 0;
1027 avail = 6;
1028 }
1029 else
1030 {
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;
1036 }
1037
1038 /*
1039 * Now try to find a free voice
1040 */
1041 best = first;
1042
1043 for (i = 0; i < avail; i++)
1044 {
1045 if (alloc->map[p] == 0)
1046 {
1047 return p;
1048 }
1049 if (alloc->alloc_times[p] < best_time) /* Find oldest playing note */
1050 {
1051 best_time = alloc->alloc_times[p];
1052 best = p;
1053 }
1054 p = (p + 1) % avail;
1055 }
1056
1057 /*
1058 * Insert some kind of priority mechanism here.
1059 */
1060
1061 if (best < 0)
1062 best = 0;
1063 if (best > devc->nr_voice)
1064 best -= devc->nr_voice;
1065
1066 return best; /* All devc->voc in use. Select the first one. */
1067 }
1068
1069 static void opl3_setup_voice(int dev, int voice, int chn)
1070 {
1071 struct channel_info *info =
1072 &synth_devs[dev]->chn_info[chn];
1073
1074 opl3_set_instr(dev, voice, info->pgm_num);
1075
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;
1080 }
1081
1082 static struct synth_operations opl3_operations =
1083 {
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
1106 };
1107
1108 int opl3_init(int ioaddr, int *osp, struct module *owner)
1109 {
1110 int i;
1111 int me;
1112
1113 if (devc == NULL)
1114 {
1115 printk(KERN_ERR "opl3: Device control structure not initialized.\n");
1116 return -1;
1117 }
1118
1119 if ((me = sound_alloc_synthdev()) == -1)
1120 {
1121 printk(KERN_WARNING "opl3: Too many synthesizers\n");
1122 return -1;
1123 }
1124
1125 devc->nr_voice = 9;
1126
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;
1137
1138 if (detected_model <= 2)
1139 devc->model = 1;
1140 else
1141 {
1142 devc->model = 2;
1143 if (detected_model == 4)
1144 devc->is_opl4 = 1;
1145 }
1146
1147 opl3_operations.info = &devc->fm_info;
1148
1149 synth_devs[me] = &opl3_operations;
1150
1151 if (owner)
1152 synth_devs[me]->owner = owner;
1153
1154 sequencer_init();
1155 devc->v_alloc = &opl3_operations.alloc;
1156 devc->chn_info = &opl3_operations.chn_info[0];
1157
1158 if (devc->model == 2)
1159 {
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");
1164
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;
1169
1170 for (i = 0; i < 18; i++)
1171 {
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;
1176 }
1177 opl3_command(devc->right_io, OPL3_MODE_REGISTER, OPL3_ENABLE);
1178 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, 0x00);
1179 }
1180 else
1181 {
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;
1185
1186 for (i = 0; i < 18; i++)
1187 pv_map[i].ioaddr = devc->left_io;
1188 };
1189 conf_printf2(devc->fm_info.name, ioaddr, 0, -1, -1);
1190
1191 for (i = 0; i < SBFM_MAXINSTR; i++)
1192 devc->i_map[i].channel = -1;
1193
1194 return me;
1195 }
1196
1197 EXPORT_SYMBOL(opl3_init);
1198 EXPORT_SYMBOL(opl3_detect);
1199
1200 static int me;
1201
1202 static int io = -1;
1203
1204 module_param(io, int, 0);
1205
1206 static int __init init_opl3 (void)
1207 {
1208 printk(KERN_INFO "YM3812 and OPL-3 driver Copyright (C) by Hannu Savolainen, Rob Hooft 1993-1996\n");
1209
1210 if (io != -1) /* User loading pure OPL3 module */
1211 {
1212 if (!opl3_detect(io, NULL))
1213 {
1214 return -ENODEV;
1215 }
1216
1217 me = opl3_init(io, NULL, THIS_MODULE);
1218 }
1219
1220 return 0;
1221 }
1222
1223 static void __exit cleanup_opl3(void)
1224 {
1225 if (devc && io != -1)
1226 {
1227 if (devc->base) {
1228 release_region(devc->base,4);
1229 if (devc->is_opl4)
1230 release_region(devc->base - 8, 2);
1231 }
1232 kfree(devc);
1233 devc = NULL;
1234 sound_unload_synthdev(me);
1235 }
1236 }
1237
1238 module_init(init_opl3);
1239 module_exit(cleanup_opl3);
1240
1241 #ifndef MODULE
1242 static int __init setup_opl3(char *str)
1243 {
1244 /* io */
1245 int ints[2];
1246
1247 str = get_options(str, ARRAY_SIZE(ints), ints);
1248
1249 io = ints[1];
1250
1251 return 1;
1252 }
1253
1254 __setup("opl3=", setup_opl3);
1255 #endif
1256 MODULE_LICENSE("GPL");
Support for the Chinese Samsung S3C2440 based development boards