projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
sound/oss: remove offset from load_patch callbacks
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / sound / oss / opl3.c
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 devc->voc[voice].panning = value;
849 }
850
851 static void opl3_volume_method(int dev, int mode)
852 {
853 }
854
855 #define SET_VIBRATO(cell) { \
856 tmp = instr->operators[(cell-1)+(((cell-1)/2)*OFFS_4OP)]; \
857 if (pressure > 110) \
858 tmp |= 0x40; /* Vibrato on */ \
859 opl3_command (map->ioaddr, AM_VIB + map->op[cell-1], tmp);}
860
861 static void opl3_aftertouch(int dev, int voice, int pressure)
862 {
863 int tmp;
864 struct sbi_instrument *instr;
865 struct physical_voice_info *map;
866
867 if (voice < 0 || voice >= devc->nr_voice)
868 return;
869
870 map = &pv_map[devc->lv_map[voice]];
871
872 DEB(printk("Aftertouch %d\n", voice));
873
874 if (map->voice_mode == 0)
875 return;
876
877 /*
878 * Adjust the amount of vibrato depending the pressure
879 */
880
881 instr = devc->act_i[voice];
882
883 if (!instr)
884 instr = &devc->i_map[0];
885
886 if (devc->voc[voice].mode == 4)
887 {
888 int connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
889
890 switch (connection)
891 {
892 case 0:
893 SET_VIBRATO(4);
894 break;
895
896 case 1:
897 SET_VIBRATO(2);
898 SET_VIBRATO(4);
899 break;
900
901 case 2:
902 SET_VIBRATO(1);
903 SET_VIBRATO(4);
904 break;
905
906 case 3:
907 SET_VIBRATO(1);
908 SET_VIBRATO(3);
909 SET_VIBRATO(4);
910 break;
911
912 }
913 /*
914 * Not implemented yet
915 */
916 }
917 else
918 {
919 SET_VIBRATO(1);
920
921 if ((instr->operators[10] & 0x01)) /*
922 * Additive synthesis
923 */
924 SET_VIBRATO(2);
925 }
926 }
927
928 #undef SET_VIBRATO
929
930 static void bend_pitch(int dev, int voice, int value)
931 {
932 unsigned char data;
933 int block, fnum, freq;
934 struct physical_voice_info *map;
935
936 map = &pv_map[devc->lv_map[voice]];
937
938 if (map->voice_mode == 0)
939 return;
940
941 devc->voc[voice].bender = value;
942 if (!value)
943 return;
944 if (!(devc->voc[voice].keyon_byte & 0x20))
945 return; /*
946 * Not keyed on
947 */
948
949 freq = compute_finetune(devc->voc[voice].orig_freq, devc->voc[voice].bender, devc->voc[voice].bender_range, 0);
950 devc->voc[voice].current_freq = freq;
951
952 freq_to_fnum(freq, &block, &fnum);
953
954 data = fnum & 0xff; /*
955 * Least significant bits of fnumber
956 */
957 opl3_command(map->ioaddr, FNUM_LOW + map->voice_num, data);
958
959 data = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
960 devc->voc[voice].keyon_byte = data;
961 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, data);
962 }
963
964 static void opl3_controller (int dev, int voice, int ctrl_num, int value)
965 {
966 if (voice < 0 || voice >= devc->nr_voice)
967 return;
968
969 switch (ctrl_num)
970 {
971 case CTRL_PITCH_BENDER:
972 bend_pitch(dev, voice, value);
973 break;
974
975 case CTRL_PITCH_BENDER_RANGE:
976 devc->voc[voice].bender_range = value;
977 break;
978
979 case CTL_MAIN_VOLUME:
980 devc->voc[voice].volume = value / 128;
981 break;
982
983 case CTL_PAN:
984 devc->voc[voice].panning = (value * 2) - 128;
985 break;
986 }
987 }
988
989 static void opl3_bender(int dev, int voice, int value)
990 {
991 if (voice < 0 || voice >= devc->nr_voice)
992 return;
993
994 bend_pitch(dev, voice, value - 8192);
995 }
996
997 static int opl3_alloc_voice(int dev, int chn, int note, struct voice_alloc_info *alloc)
998 {
999 int i, p, best, first, avail, best_time = 0x7fffffff;
1000 struct sbi_instrument *instr;
1001 int is4op;
1002 int instr_no;
1003
1004 if (chn < 0 || chn > 15)
1005 instr_no = 0;
1006 else
1007 instr_no = devc->chn_info[chn].pgm_num;
1008
1009 instr = &devc->i_map[instr_no];
1010 if (instr->channel < 0 || /* Instrument not loaded */
1011 devc->nr_voice != 12) /* Not in 4 OP mode */
1012 is4op = 0;
1013 else if (devc->nr_voice == 12) /* 4 OP mode */
1014 is4op = (instr->key == OPL3_PATCH);
1015 else
1016 is4op = 0;
1017
1018 if (is4op)
1019 {
1020 first = p = 0;
1021 avail = 6;
1022 }
1023 else
1024 {
1025 if (devc->nr_voice == 12) /* 4 OP mode. Use the '2 OP only' operators first */
1026 first = p = 6;
1027 else
1028 first = p = 0;
1029 avail = devc->nr_voice;
1030 }
1031
1032 /*
1033 * Now try to find a free voice
1034 */
1035 best = first;
1036
1037 for (i = 0; i < avail; i++)
1038 {
1039 if (alloc->map[p] == 0)
1040 {
1041 return p;
1042 }
1043 if (alloc->alloc_times[p] < best_time) /* Find oldest playing note */
1044 {
1045 best_time = alloc->alloc_times[p];
1046 best = p;
1047 }
1048 p = (p + 1) % avail;
1049 }
1050
1051 /*
1052 * Insert some kind of priority mechanism here.
1053 */
1054
1055 if (best < 0)
1056 best = 0;
1057 if (best > devc->nr_voice)
1058 best -= devc->nr_voice;
1059
1060 return best; /* All devc->voc in use. Select the first one. */
1061 }
1062
1063 static void opl3_setup_voice(int dev, int voice, int chn)
1064 {
1065 struct channel_info *info =
1066 &synth_devs[dev]->chn_info[chn];
1067
1068 opl3_set_instr(dev, voice, info->pgm_num);
1069
1070 devc->voc[voice].bender = 0;
1071 devc->voc[voice].bender_range = info->bender_range;
1072 devc->voc[voice].volume = info->controllers[CTL_MAIN_VOLUME];
1073 devc->voc[voice].panning = (info->controllers[CTL_PAN] * 2) - 128;
1074 }
1075
1076 static struct synth_operations opl3_operations =
1077 {
1078 .owner = THIS_MODULE,
1079 .id = "OPL",
1080 .info = NULL,
1081 .midi_dev = 0,
1082 .synth_type = SYNTH_TYPE_FM,
1083 .synth_subtype = FM_TYPE_ADLIB,
1084 .open = opl3_open,
1085 .close = opl3_close,
1086 .ioctl = opl3_ioctl,
1087 .kill_note = opl3_kill_note,
1088 .start_note = opl3_start_note,
1089 .set_instr = opl3_set_instr,
1090 .reset = opl3_reset,
1091 .hw_control = opl3_hw_control,
1092 .load_patch = opl3_load_patch,
1093 .aftertouch = opl3_aftertouch,
1094 .controller = opl3_controller,
1095 .panning = opl3_panning,
1096 .volume_method = opl3_volume_method,
1097 .bender = opl3_bender,
1098 .alloc_voice = opl3_alloc_voice,
1099 .setup_voice = opl3_setup_voice
1100 };
1101
1102 static int opl3_init(int ioaddr, struct module *owner)
1103 {
1104 int i;
1105 int me;
1106
1107 if (devc == NULL)
1108 {
1109 printk(KERN_ERR "opl3: Device control structure not initialized.\n");
1110 return -1;
1111 }
1112
1113 if ((me = sound_alloc_synthdev()) == -1)
1114 {
1115 printk(KERN_WARNING "opl3: Too many synthesizers\n");
1116 return -1;
1117 }
1118
1119 devc->nr_voice = 9;
1120
1121 devc->fm_info.device = 0;
1122 devc->fm_info.synth_type = SYNTH_TYPE_FM;
1123 devc->fm_info.synth_subtype = FM_TYPE_ADLIB;
1124 devc->fm_info.perc_mode = 0;
1125 devc->fm_info.nr_voices = 9;
1126 devc->fm_info.nr_drums = 0;
1127 devc->fm_info.instr_bank_size = SBFM_MAXINSTR;
1128 devc->fm_info.capabilities = 0;
1129 devc->left_io = ioaddr;
1130 devc->right_io = ioaddr + 2;
1131
1132 if (detected_model <= 2)
1133 devc->model = 1;
1134 else
1135 {
1136 devc->model = 2;
1137 if (detected_model == 4)
1138 devc->is_opl4 = 1;
1139 }
1140
1141 opl3_operations.info = &devc->fm_info;
1142
1143 synth_devs[me] = &opl3_operations;
1144
1145 if (owner)
1146 synth_devs[me]->owner = owner;
1147
1148 sequencer_init();
1149 devc->v_alloc = &opl3_operations.alloc;
1150 devc->chn_info = &opl3_operations.chn_info[0];
1151
1152 if (devc->model == 2)
1153 {
1154 if (devc->is_opl4)
1155 strcpy(devc->fm_info.name, "Yamaha OPL4/OPL3 FM");
1156 else
1157 strcpy(devc->fm_info.name, "Yamaha OPL3");
1158
1159 devc->v_alloc->max_voice = devc->nr_voice = 18;
1160 devc->fm_info.nr_drums = 0;
1161 devc->fm_info.synth_subtype = FM_TYPE_OPL3;
1162 devc->fm_info.capabilities |= SYNTH_CAP_OPL3;
1163
1164 for (i = 0; i < 18; i++)
1165 {
1166 if (pv_map[i].ioaddr == USE_LEFT)
1167 pv_map[i].ioaddr = devc->left_io;
1168 else
1169 pv_map[i].ioaddr = devc->right_io;
1170 }
1171 opl3_command(devc->right_io, OPL3_MODE_REGISTER, OPL3_ENABLE);
1172 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, 0x00);
1173 }
1174 else
1175 {
1176 strcpy(devc->fm_info.name, "Yamaha OPL2");
1177 devc->v_alloc->max_voice = devc->nr_voice = 9;
1178 devc->fm_info.nr_drums = 0;
1179
1180 for (i = 0; i < 18; i++)
1181 pv_map[i].ioaddr = devc->left_io;
1182 };
1183 conf_printf2(devc->fm_info.name, ioaddr, 0, -1, -1);
1184
1185 for (i = 0; i < SBFM_MAXINSTR; i++)
1186 devc->i_map[i].channel = -1;
1187
1188 return me;
1189 }
1190
1191 static int me;
1192
1193 static int io = -1;
1194
1195 module_param(io, int, 0);
1196
1197 static int __init init_opl3 (void)
1198 {
1199 printk(KERN_INFO "YM3812 and OPL-3 driver Copyright (C) by Hannu Savolainen, Rob Hooft 1993-1996\n");
1200
1201 if (io != -1) /* User loading pure OPL3 module */
1202 {
1203 if (!opl3_detect(io))
1204 {
1205 return -ENODEV;
1206 }
1207
1208 me = opl3_init(io, THIS_MODULE);
1209 }
1210
1211 return 0;
1212 }
1213
1214 static void __exit cleanup_opl3(void)
1215 {
1216 if (devc && io != -1)
1217 {
1218 if (devc->base) {
1219 release_region(devc->base,4);
1220 if (devc->is_opl4)
1221 release_region(devc->base - 8, 2);
1222 }
1223 kfree(devc);
1224 devc = NULL;
1225 sound_unload_synthdev(me);
1226 }
1227 }
1228
1229 module_init(init_opl3);
1230 module_exit(cleanup_opl3);
1231
1232 #ifndef MODULE
1233 static int __init setup_opl3(char *str)
1234 {
1235 /* io */
1236 int ints[2];
1237
1238 str = get_options(str, ARRAY_SIZE(ints), ints);
1239
1240 io = ints[1];
1241
1242 return 1;
1243 }
1244
1245 __setup("opl3=", setup_opl3);
1246 #endif
1247 MODULE_LICENSE("GPL");
kernel source for telekom puls (alcatel/mediatek)