?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sound/oss/opl3: validate voice and channel indexes
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / sound / oss / opl3.c
blobc828a340c1bd942fb1867396f4d53fd290728ded
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_hw.h"
38
39 #define MAX_VOICE 18
40 #define OFFS_4OP 11
41
42 struct voice_info
43 {
44 unsigned char keyon_byte;
45 long bender;
46 long bender_range;
47 unsigned long orig_freq;
48 unsigned long current_freq;
49 int volume;
50 int mode;
51 int panning; /* 0xffff means not set */
52 };
53
54 typedef struct opl_devinfo
55 {
56 int base;
57 int left_io, right_io;
58 int nr_voice;
59 int lv_map[MAX_VOICE];
60
61 struct voice_info voc[MAX_VOICE];
62 struct voice_alloc_info *v_alloc;
63 struct channel_info *chn_info;
64
65 struct sbi_instrument i_map[SBFM_MAXINSTR];
66 struct sbi_instrument *act_i[MAX_VOICE];
67
68 struct synth_info fm_info;
69
70 int busy;
71 int model;
72 unsigned char cmask;
73
74 int is_opl4;
75 } opl_devinfo;
76
77 static struct opl_devinfo *devc = NULL;
78
79 static int detected_model;
80
81 static int store_instr(int instr_no, struct sbi_instrument *instr);
82 static void freq_to_fnum(int freq, int *block, int *fnum);
83 static void opl3_command(int io_addr, unsigned int addr, unsigned int val);
84 static int opl3_kill_note(int dev, int voice, int note, int velocity);
85
86 static void enter_4op_mode(void)
87 {
88 int i;
89 static int v4op[MAX_VOICE] = {
90 0, 1, 2, 9, 10, 11, 6, 7, 8, 15, 16, 17
91 };
92
93 devc->cmask = 0x3f; /* Connect all possible 4 OP voice operators */
94 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, 0x3f);
95
96 for (i = 0; i < 3; i++)
97 pv_map[i].voice_mode = 4;
98 for (i = 3; i < 6; i++)
99 pv_map[i].voice_mode = 0;
100
101 for (i = 9; i < 12; i++)
102 pv_map[i].voice_mode = 4;
103 for (i = 12; i < 15; i++)
104 pv_map[i].voice_mode = 0;
105
106 for (i = 0; i < 12; i++)
107 devc->lv_map[i] = v4op[i];
108 devc->v_alloc->max_voice = devc->nr_voice = 12;
109 }
110
111 static int opl3_ioctl(int dev, unsigned int cmd, void __user * arg)
112 {
113 struct sbi_instrument ins;
114
115 switch (cmd) {
116 case SNDCTL_FM_LOAD_INSTR:
117 printk(KERN_WARNING "Warning: Obsolete ioctl(SNDCTL_FM_LOAD_INSTR) used. Fix the program.\n");
118 if (copy_from_user(&ins, arg, sizeof(ins)))
119 return -EFAULT;
120 if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR) {
121 printk(KERN_WARNING "FM Error: Invalid instrument number %d\n", ins.channel);
122 return -EINVAL;
123 }
124 return store_instr(ins.channel, &ins);
125
126 case SNDCTL_SYNTH_INFO:
127 devc->fm_info.nr_voices = (devc->nr_voice == 12) ? 6 : devc->nr_voice;
128 if (copy_to_user(arg, &devc->fm_info, sizeof(devc->fm_info)))
129 return -EFAULT;
130 return 0;
131
132 case SNDCTL_SYNTH_MEMAVL:
133 return 0x7fffffff;
134
135 case SNDCTL_FM_4OP_ENABLE:
136 if (devc->model == 2)
137 enter_4op_mode();
138 return 0;
139
140 default:
141 return -EINVAL;
142 }
143 }
144
145 static int opl3_detect(int ioaddr)
146 {
147 /*
148 * This function returns 1 if the FM chip is present at the given I/O port
149 * The detection algorithm plays with the timer built in the FM chip and
150 * looks for a change in the status register.
151 *
152 * Note! The timers of the FM chip are not connected to AdLib (and compatible)
153 * boards.
154 *
155 * Note2! The chip is initialized if detected.
156 */
157
158 unsigned char stat1, signature;
159 int i;
160
161 if (devc != NULL)
162 {
163 printk(KERN_ERR "opl3: Only one OPL3 supported.\n");
164 return 0;
165 }
166
167 devc = kzalloc(sizeof(*devc), GFP_KERNEL);
168
169 if (devc == NULL)
170 {
171 printk(KERN_ERR "opl3: Can't allocate memory for the device control "
172 "structure \n ");
173 return 0;
174 }
175
176 strcpy(devc->fm_info.name, "OPL2");
177
178 if (!request_region(ioaddr, 4, devc->fm_info.name)) {
179 printk(KERN_WARNING "opl3: I/O port 0x%x already in use\n", ioaddr);
180 goto cleanup_devc;
181 }
182
183 devc->base = ioaddr;
184
185 /* Reset timers 1 and 2 */
186 opl3_command(ioaddr, TIMER_CONTROL_REGISTER, TIMER1_MASK | TIMER2_MASK);
187
188 /* Reset the IRQ of the FM chip */
189 opl3_command(ioaddr, TIMER_CONTROL_REGISTER, IRQ_RESET);
190
191 signature = stat1 = inb(ioaddr); /* Status register */
192
193 if (signature != 0x00 && signature != 0x06 && signature != 0x02 &&
194 signature != 0x0f)
195 {
196 MDB(printk(KERN_INFO "OPL3 not detected %x\n", signature));
197 goto cleanup_region;
198 }
199
200 if (signature == 0x06) /* OPL2 */
201 {
202 detected_model = 2;
203 }
204 else if (signature == 0x00 || signature == 0x0f) /* OPL3 or OPL4 */
205 {
206 unsigned char tmp;
207
208 detected_model = 3;
209
210 /*
211 * Detect availability of OPL4 (_experimental_). Works probably
212 * only after a cold boot. In addition the OPL4 port
213 * of the chip may not be connected to the PC bus at all.
214 */
215
216 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, 0x00);
217 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, OPL3_ENABLE | OPL4_ENABLE);
218
219 if ((tmp = inb(ioaddr)) == 0x02) /* Have a OPL4 */
220 {
221 detected_model = 4;
222 }
223
224 if (request_region(ioaddr - 8, 2, "OPL4")) /* OPL4 port was free */
225 {
226 int tmp;
227
228 outb((0x02), ioaddr - 8); /* Select OPL4 ID register */
229 udelay(10);
230 tmp = inb(ioaddr - 7); /* Read it */
231 udelay(10);
232
233 if (tmp == 0x20) /* OPL4 should return 0x20 here */
234 {
235 detected_model = 4;
236 outb((0xF8), ioaddr - 8); /* Select OPL4 FM mixer control */
237 udelay(10);
238 outb((0x1B), ioaddr - 7); /* Write value */
239 udelay(10);
240 }
241 else
242 { /* release OPL4 port */
243 release_region(ioaddr - 8, 2);
244 detected_model = 3;
245 }
246 }
247 opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, 0);
248 }
249 for (i = 0; i < 9; i++)
250 opl3_command(ioaddr, KEYON_BLOCK + i, 0); /*
251 * Note off
252 */
253
254 opl3_command(ioaddr, TEST_REGISTER, ENABLE_WAVE_SELECT);
255 opl3_command(ioaddr, PERCOSSION_REGISTER, 0x00); /*
256 * Melodic mode.
257 */
258 return 1;
259 cleanup_region:
260 release_region(ioaddr, 4);
261 cleanup_devc:
262 kfree(devc);
263 devc = NULL;
264 return 0;
265 }
266
267 static int opl3_kill_note (int devno, int voice, int note, int velocity)
268 {
269 struct physical_voice_info *map;
270
271 if (voice < 0 || voice >= devc->nr_voice)
272 return 0;
273
274 devc->v_alloc->map[voice] = 0;
275
276 map = &pv_map[devc->lv_map[voice]];
277 DEB(printk("Kill note %d\n", voice));
278
279 if (map->voice_mode == 0)
280 return 0;
281
282 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, devc->voc[voice].keyon_byte & ~0x20);
283 devc->voc[voice].keyon_byte = 0;
284 devc->voc[voice].bender = 0;
285 devc->voc[voice].volume = 64;
286 devc->voc[voice].panning = 0xffff; /* Not set */
287 devc->voc[voice].bender_range = 200;
288 devc->voc[voice].orig_freq = 0;
289 devc->voc[voice].current_freq = 0;
290 devc->voc[voice].mode = 0;
291 return 0;
292 }
293
294 #define HIHAT 0
295 #define CYMBAL 1
296 #define TOMTOM 2
297 #define SNARE 3
298 #define BDRUM 4
299 #define UNDEFINED TOMTOM
300 #define DEFAULT TOMTOM
301
302 static int store_instr(int instr_no, struct sbi_instrument *instr)
303 {
304 if (instr->key != FM_PATCH && (instr->key != OPL3_PATCH || devc->model != 2))
305 printk(KERN_WARNING "FM warning: Invalid patch format field (key) 0x%x\n", instr->key);
306 memcpy((char *) &(devc->i_map[instr_no]), (char *) instr, sizeof(*instr));
307 return 0;
308 }
309
310 static int opl3_set_instr (int dev, int voice, int instr_no)
311 {
312 if (voice < 0 || voice >= devc->nr_voice)
313 return 0;
314 if (instr_no < 0 || instr_no >= SBFM_MAXINSTR)
315 instr_no = 0; /* Acoustic piano (usually) */
316
317 devc->act_i[voice] = &devc->i_map[instr_no];
318 return 0;
319 }
320
321 /*
322 * The next table looks magical, but it certainly is not. Its values have
323 * been calculated as table[i]=8*log(i/64)/log(2) with an obvious exception
324 * for i=0. This log-table converts a linear volume-scaling (0..127) to a
325 * logarithmic scaling as present in the FM-synthesizer chips. so : Volume
326 * 64 = 0 db = relative volume 0 and: Volume 32 = -6 db = relative
327 * volume -8 it was implemented as a table because it is only 128 bytes and
328 * it saves a lot of log() calculations. (RH)
329 */
330
331 static char fm_volume_table[128] =
332 {
333 -64, -48, -40, -35, -32, -29, -27, -26,
334 -24, -23, -21, -20, -19, -18, -18, -17,
335 -16, -15, -15, -14, -13, -13, -12, -12,
336 -11, -11, -10, -10, -10, -9, -9, -8,
337 -8, -8, -7, -7, -7, -6, -6, -6,
338 -5, -5, -5, -5, -4, -4, -4, -4,
339 -3, -3, -3, -3, -2, -2, -2, -2,
340 -2, -1, -1, -1, -1, 0, 0, 0,
341 0, 0, 0, 1, 1, 1, 1, 1,
342 1, 2, 2, 2, 2, 2, 2, 2,
343 3, 3, 3, 3, 3, 3, 3, 4,
344 4, 4, 4, 4, 4, 4, 4, 5,
345 5, 5, 5, 5, 5, 5, 5, 5,
346 6, 6, 6, 6, 6, 6, 6, 6,
347 6, 7, 7, 7, 7, 7, 7, 7,
348 7, 7, 7, 8, 8, 8, 8, 8
349 };
350
351 static void calc_vol(unsigned char *regbyte, int volume, int main_vol)
352 {
353 int level = (~*regbyte & 0x3f);
354
355 if (main_vol > 127)
356 main_vol = 127;
357 volume = (volume * main_vol) / 127;
358
359 if (level)
360 level += fm_volume_table[volume];
361
362 if (level > 0x3f)
363 level = 0x3f;
364 if (level < 0)
365 level = 0;
366
367 *regbyte = (*regbyte & 0xc0) | (~level & 0x3f);
368 }
369
370 static void set_voice_volume(int voice, int volume, int main_vol)
371 {
372 unsigned char vol1, vol2, vol3, vol4;
373 struct sbi_instrument *instr;
374 struct physical_voice_info *map;
375
376 if (voice < 0 || voice >= devc->nr_voice)
377 return;
378
379 map = &pv_map[devc->lv_map[voice]];
380 instr = devc->act_i[voice];
381
382 if (!instr)
383 instr = &devc->i_map[0];
384
385 if (instr->channel < 0)
386 return;
387
388 if (devc->voc[voice].mode == 0)
389 return;
390
391 if (devc->voc[voice].mode == 2)
392 {
393 vol1 = instr->operators[2];
394 vol2 = instr->operators[3];
395 if ((instr->operators[10] & 0x01))
396 {
397 calc_vol(&vol1, volume, main_vol);
398 calc_vol(&vol2, volume, main_vol);
399 }
400 else
401 {
402 calc_vol(&vol2, volume, main_vol);
403 }
404 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], vol1);
405 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], vol2);
406 }
407 else
408 { /*
409 * 4 OP voice
410 */
411 int connection;
412
413 vol1 = instr->operators[2];
414 vol2 = instr->operators[3];
415 vol3 = instr->operators[OFFS_4OP + 2];
416 vol4 = instr->operators[OFFS_4OP + 3];
417
418 /*
419 * The connection method for 4 OP devc->voc is defined by the rightmost
420 * bits at the offsets 10 and 10+OFFS_4OP
421 */
422
423 connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
424
425 switch (connection)
426 {
427 case 0:
428 calc_vol(&vol4, volume, main_vol);
429 break;
430
431 case 1:
432 calc_vol(&vol2, volume, main_vol);
433 calc_vol(&vol4, volume, main_vol);
434 break;
435
436 case 2:
437 calc_vol(&vol1, volume, main_vol);
438 calc_vol(&vol4, volume, main_vol);
439 break;
440
441 case 3:
442 calc_vol(&vol1, volume, main_vol);
443 calc_vol(&vol3, volume, main_vol);
444 calc_vol(&vol4, volume, main_vol);
445 break;
446
447 default:
448 ;
449 }
450 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], vol1);
451 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], vol2);
452 opl3_command(map->ioaddr, KSL_LEVEL + map->op[2], vol3);
453 opl3_command(map->ioaddr, KSL_LEVEL + map->op[3], vol4);
454 }
455 }
456
457 static int opl3_start_note (int dev, int voice, int note, int volume)
458 {
459 unsigned char data, fpc;
460 int block, fnum, freq, voice_mode, pan;
461 struct sbi_instrument *instr;
462 struct physical_voice_info *map;
463
464 if (voice < 0 || voice >= devc->nr_voice)
465 return 0;
466
467 map = &pv_map[devc->lv_map[voice]];
468 pan = devc->voc[voice].panning;
469
470 if (map->voice_mode == 0)
471 return 0;
472
473 if (note == 255) /*
474 * Just change the volume
475 */
476 {
477 set_voice_volume(voice, volume, devc->voc[voice].volume);
478 return 0;
479 }
480
481 /*
482 * Kill previous note before playing
483 */
484
485 opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], 0xff); /*
486 * Carrier
487 * volume to
488 * min
489 */
490 opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], 0xff); /*
491 * Modulator
492 * volume to
493 */
494
495 if (map->voice_mode == 4)
496 {
497 opl3_command(map->ioaddr, KSL_LEVEL + map->op[2], 0xff);
498 opl3_command(map->ioaddr, KSL_LEVEL + map->op[3], 0xff);
499 }
500
501 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, 0x00); /*
502 * Note
503 * off
504 */
505
506 instr = devc->act_i[voice];
507
508 if (!instr)
509 instr = &devc->i_map[0];
510
511 if (instr->channel < 0)
512 {
513 printk(KERN_WARNING "opl3: Initializing voice %d with undefined instrument\n", voice);
514 return 0;
515 }
516
517 if (map->voice_mode == 2 && instr->key == OPL3_PATCH)
518 return 0; /*
519 * Cannot play
520 */
521
522 voice_mode = map->voice_mode;
523
524 if (voice_mode == 4)
525 {
526 int voice_shift;
527
528 voice_shift = (map->ioaddr == devc->left_io) ? 0 : 3;
529 voice_shift += map->voice_num;
530
531 if (instr->key != OPL3_PATCH) /*
532 * Just 2 OP patch
533 */
534 {
535 voice_mode = 2;
536 devc->cmask &= ~(1 << voice_shift);
537 }
538 else
539 {
540 devc->cmask |= (1 << voice_shift);
541 }
542
543 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
544 }
545
546 /*
547 * Set Sound Characteristics
548 */
549
550 opl3_command(map->ioaddr, AM_VIB + map->op[0], instr->operators[0]);
551 opl3_command(map->ioaddr, AM_VIB + map->op[1], instr->operators[1]);
552
553 /*
554 * Set Attack/Decay
555 */
556
557 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[0], instr->operators[4]);
558 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[1], instr->operators[5]);
559
560 /*
561 * Set Sustain/Release
562 */
563
564 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[0], instr->operators[6]);
565 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[1], instr->operators[7]);
566
567 /*
568 * Set Wave Select
569 */
570
571 opl3_command(map->ioaddr, WAVE_SELECT + map->op[0], instr->operators[8]);
572 opl3_command(map->ioaddr, WAVE_SELECT + map->op[1], instr->operators[9]);
573
574 /*
575 * Set Feedback/Connection
576 */
577
578 fpc = instr->operators[10];
579
580 if (pan != 0xffff)
581 {
582 fpc &= ~STEREO_BITS;
583 if (pan < -64)
584 fpc |= VOICE_TO_LEFT;
585 else
586 if (pan > 64)
587 fpc |= VOICE_TO_RIGHT;
588 else
589 fpc |= (VOICE_TO_LEFT | VOICE_TO_RIGHT);
590 }
591
592 if (!(fpc & 0x30))
593 fpc |= 0x30; /*
594 * Ensure that at least one chn is enabled
595 */
596 opl3_command(map->ioaddr, FEEDBACK_CONNECTION + map->voice_num, fpc);
597
598 /*
599 * If the voice is a 4 OP one, initialize the operators 3 and 4 also
600 */
601
602 if (voice_mode == 4)
603 {
604 /*
605 * Set Sound Characteristics
606 */
607
608 opl3_command(map->ioaddr, AM_VIB + map->op[2], instr->operators[OFFS_4OP + 0]);
609 opl3_command(map->ioaddr, AM_VIB + map->op[3], instr->operators[OFFS_4OP + 1]);
610
611 /*
612 * Set Attack/Decay
613 */
614
615 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[2], instr->operators[OFFS_4OP + 4]);
616 opl3_command(map->ioaddr, ATTACK_DECAY + map->op[3], instr->operators[OFFS_4OP + 5]);
617
618 /*
619 * Set Sustain/Release
620 */
621
622 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[2], instr->operators[OFFS_4OP + 6]);
623 opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[3], instr->operators[OFFS_4OP + 7]);
624
625 /*
626 * Set Wave Select
627 */
628
629 opl3_command(map->ioaddr, WAVE_SELECT + map->op[2], instr->operators[OFFS_4OP + 8]);
630 opl3_command(map->ioaddr, WAVE_SELECT + map->op[3], instr->operators[OFFS_4OP + 9]);
631
632 /*
633 * Set Feedback/Connection
634 */
635
636 fpc = instr->operators[OFFS_4OP + 10];
637 if (!(fpc & 0x30))
638 fpc |= 0x30; /*
639 * Ensure that at least one chn is enabled
640 */
641 opl3_command(map->ioaddr, FEEDBACK_CONNECTION + map->voice_num + 3, fpc);
642 }
643
644 devc->voc[voice].mode = voice_mode;
645 set_voice_volume(voice, volume, devc->voc[voice].volume);
646
647 freq = devc->voc[voice].orig_freq = note_to_freq(note) / 1000;
648
649 /*
650 * Since the pitch bender may have been set before playing the note, we
651 * have to calculate the bending now.
652 */
653
654 freq = compute_finetune(devc->voc[voice].orig_freq, devc->voc[voice].bender, devc->voc[voice].bender_range, 0);
655 devc->voc[voice].current_freq = freq;
656
657 freq_to_fnum(freq, &block, &fnum);
658
659 /*
660 * Play note
661 */
662
663 data = fnum & 0xff; /*
664 * Least significant bits of fnumber
665 */
666 opl3_command(map->ioaddr, FNUM_LOW + map->voice_num, data);
667
668 data = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
669 devc->voc[voice].keyon_byte = data;
670 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, data);
671 if (voice_mode == 4)
672 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num + 3, data);
673
674 return 0;
675 }
676
677 static void freq_to_fnum (int freq, int *block, int *fnum)
678 {
679 int f, octave;
680
681 /*
682 * Converts the note frequency to block and fnum values for the FM chip
683 */
684 /*
685 * First try to compute the block -value (octave) where the note belongs
686 */
687
688 f = freq;
689
690 octave = 5;
691
692 if (f == 0)
693 octave = 0;
694 else if (f < 261)
695 {
696 while (f < 261)
697 {
698 octave--;
699 f <<= 1;
700 }
701 }
702 else if (f > 493)
703 {
704 while (f > 493)
705 {
706 octave++;
707 f >>= 1;
708 }
709 }
710
711 if (octave > 7)
712 octave = 7;
713
714 *fnum = freq * (1 << (20 - octave)) / 49716;
715 *block = octave;
716 }
717
718 static void opl3_command (int io_addr, unsigned int addr, unsigned int val)
719 {
720 int i;
721
722 /*
723 * The original 2-OP synth requires a quite long delay after writing to a
724 * register. The OPL-3 survives with just two INBs
725 */
726
727 outb(((unsigned char) (addr & 0xff)), io_addr);
728
729 if (devc->model != 2)
730 udelay(10);
731 else
732 for (i = 0; i < 2; i++)
733 inb(io_addr);
734
735 outb(((unsigned char) (val & 0xff)), io_addr + 1);
736
737 if (devc->model != 2)
738 udelay(30);
739 else
740 for (i = 0; i < 2; i++)
741 inb(io_addr);
742 }
743
744 static void opl3_reset(int devno)
745 {
746 int i;
747
748 for (i = 0; i < 18; i++)
749 devc->lv_map[i] = i;
750
751 for (i = 0; i < devc->nr_voice; i++)
752 {
753 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
754 KSL_LEVEL + pv_map[devc->lv_map[i]].op[0], 0xff);
755
756 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
757 KSL_LEVEL + pv_map[devc->lv_map[i]].op[1], 0xff);
758
759 if (pv_map[devc->lv_map[i]].voice_mode == 4)
760 {
761 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
762 KSL_LEVEL + pv_map[devc->lv_map[i]].op[2], 0xff);
763
764 opl3_command(pv_map[devc->lv_map[i]].ioaddr,
765 KSL_LEVEL + pv_map[devc->lv_map[i]].op[3], 0xff);
766 }
767
768 opl3_kill_note(devno, i, 0, 64);
769 }
770
771 if (devc->model == 2)
772 {
773 devc->v_alloc->max_voice = devc->nr_voice = 18;
774
775 for (i = 0; i < 18; i++)
776 pv_map[i].voice_mode = 2;
777
778 }
779 }
780
781 static int opl3_open(int dev, int mode)
782 {
783 int i;
784
785 if (devc->busy)
786 return -EBUSY;
787 devc->busy = 1;
788
789 devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
790 devc->v_alloc->timestamp = 0;
791
792 for (i = 0; i < 18; i++)
793 {
794 devc->v_alloc->map[i] = 0;
795 devc->v_alloc->alloc_times[i] = 0;
796 }
797
798 devc->cmask = 0x00; /*
799 * Just 2 OP mode
800 */
801 if (devc->model == 2)
802 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
803 return 0;
804 }
805
806 static void opl3_close(int dev)
807 {
808 devc->busy = 0;
809 devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
810
811 devc->fm_info.nr_drums = 0;
812 devc->fm_info.perc_mode = 0;
813
814 opl3_reset(dev);
815 }
816
817 static void opl3_hw_control(int dev, unsigned char *event)
818 {
819 }
820
821 static int opl3_load_patch(int dev, int format, const char __user *addr,
822 int offs, int count, int pmgr_flag)
823 {
824 struct sbi_instrument ins;
825
826 if (count <sizeof(ins))
827 {
828 printk(KERN_WARNING "FM Error: Patch record too short\n");
829 return -EINVAL;
830 }
831
832 /*
833 * What the fuck is going on here? We leave junk in the beginning
834 * of ins and then check the field pretty close to that beginning?
835 */
836 if(copy_from_user(&((char *) &ins)[offs], addr + offs, sizeof(ins) - offs))
837 return -EFAULT;
838
839 if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR)
840 {
841 printk(KERN_WARNING "FM Error: Invalid instrument number %d\n", ins.channel);
842 return -EINVAL;
843 }
844 ins.key = format;
845
846 return store_instr(ins.channel, &ins);
847 }
848
849 static void opl3_panning(int dev, int voice, int value)
850 {
851
852 if (voice < 0 || voice >= devc->nr_voice)
853 return;
854
855 devc->voc[voice].panning = value;
856 }
857
858 static void opl3_volume_method(int dev, int mode)
859 {
860 }
861
862 #define SET_VIBRATO(cell) { \
863 tmp = instr->operators[(cell-1)+(((cell-1)/2)*OFFS_4OP)]; \
864 if (pressure > 110) \
865 tmp |= 0x40; /* Vibrato on */ \
866 opl3_command (map->ioaddr, AM_VIB + map->op[cell-1], tmp);}
867
868 static void opl3_aftertouch(int dev, int voice, int pressure)
869 {
870 int tmp;
871 struct sbi_instrument *instr;
872 struct physical_voice_info *map;
873
874 if (voice < 0 || voice >= devc->nr_voice)
875 return;
876
877 map = &pv_map[devc->lv_map[voice]];
878
879 DEB(printk("Aftertouch %d\n", voice));
880
881 if (map->voice_mode == 0)
882 return;
883
884 /*
885 * Adjust the amount of vibrato depending the pressure
886 */
887
888 instr = devc->act_i[voice];
889
890 if (!instr)
891 instr = &devc->i_map[0];
892
893 if (devc->voc[voice].mode == 4)
894 {
895 int connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
896
897 switch (connection)
898 {
899 case 0:
900 SET_VIBRATO(4);
901 break;
902
903 case 1:
904 SET_VIBRATO(2);
905 SET_VIBRATO(4);
906 break;
907
908 case 2:
909 SET_VIBRATO(1);
910 SET_VIBRATO(4);
911 break;
912
913 case 3:
914 SET_VIBRATO(1);
915 SET_VIBRATO(3);
916 SET_VIBRATO(4);
917 break;
918
919 }
920 /*
921 * Not implemented yet
922 */
923 }
924 else
925 {
926 SET_VIBRATO(1);
927
928 if ((instr->operators[10] & 0x01)) /*
929 * Additive synthesis
930 */
931 SET_VIBRATO(2);
932 }
933 }
934
935 #undef SET_VIBRATO
936
937 static void bend_pitch(int dev, int voice, int value)
938 {
939 unsigned char data;
940 int block, fnum, freq;
941 struct physical_voice_info *map;
942
943 map = &pv_map[devc->lv_map[voice]];
944
945 if (map->voice_mode == 0)
946 return;
947
948 devc->voc[voice].bender = value;
949 if (!value)
950 return;
951 if (!(devc->voc[voice].keyon_byte & 0x20))
952 return; /*
953 * Not keyed on
954 */
955
956 freq = compute_finetune(devc->voc[voice].orig_freq, devc->voc[voice].bender, devc->voc[voice].bender_range, 0);
957 devc->voc[voice].current_freq = freq;
958
959 freq_to_fnum(freq, &block, &fnum);
960
961 data = fnum & 0xff; /*
962 * Least significant bits of fnumber
963 */
964 opl3_command(map->ioaddr, FNUM_LOW + map->voice_num, data);
965
966 data = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
967 devc->voc[voice].keyon_byte = data;
968 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, data);
969 }
970
971 static void opl3_controller (int dev, int voice, int ctrl_num, int value)
972 {
973 if (voice < 0 || voice >= devc->nr_voice)
974 return;
975
976 switch (ctrl_num)
977 {
978 case CTRL_PITCH_BENDER:
979 bend_pitch(dev, voice, value);
980 break;
981
982 case CTRL_PITCH_BENDER_RANGE:
983 devc->voc[voice].bender_range = value;
984 break;
985
986 case CTL_MAIN_VOLUME:
987 devc->voc[voice].volume = value / 128;
988 break;
989
990 case CTL_PAN:
991 devc->voc[voice].panning = (value * 2) - 128;
992 break;
993 }
994 }
995
996 static void opl3_bender(int dev, int voice, int value)
997 {
998 if (voice < 0 || voice >= devc->nr_voice)
999 return;
1000
1001 bend_pitch(dev, voice, value - 8192);
1002 }
1003
1004 static int opl3_alloc_voice(int dev, int chn, int note, struct voice_alloc_info *alloc)
1005 {
1006 int i, p, best, first, avail, best_time = 0x7fffffff;
1007 struct sbi_instrument *instr;
1008 int is4op;
1009 int instr_no;
1010
1011 if (chn < 0 || chn > 15)
1012 instr_no = 0;
1013 else
1014 instr_no = devc->chn_info[chn].pgm_num;
1015
1016 instr = &devc->i_map[instr_no];
1017 if (instr->channel < 0 || /* Instrument not loaded */
1018 devc->nr_voice != 12) /* Not in 4 OP mode */
1019 is4op = 0;
1020 else if (devc->nr_voice == 12) /* 4 OP mode */
1021 is4op = (instr->key == OPL3_PATCH);
1022 else
1023 is4op = 0;
1024
1025 if (is4op)
1026 {
1027 first = p = 0;
1028 avail = 6;
1029 }
1030 else
1031 {
1032 if (devc->nr_voice == 12) /* 4 OP mode. Use the '2 OP only' operators first */
1033 first = p = 6;
1034 else
1035 first = p = 0;
1036 avail = devc->nr_voice;
1037 }
1038
1039 /*
1040 * Now try to find a free voice
1041 */
1042 best = first;
1043
1044 for (i = 0; i < avail; i++)
1045 {
1046 if (alloc->map[p] == 0)
1047 {
1048 return p;
1049 }
1050 if (alloc->alloc_times[p] < best_time) /* Find oldest playing note */
1051 {
1052 best_time = alloc->alloc_times[p];
1053 best = p;
1054 }
1055 p = (p + 1) % avail;
1056 }
1057
1058 /*
1059 * Insert some kind of priority mechanism here.
1060 */
1061
1062 if (best < 0)
1063 best = 0;
1064 if (best > devc->nr_voice)
1065 best -= devc->nr_voice;
1066
1067 return best; /* All devc->voc in use. Select the first one. */
1068 }
1069
1070 static void opl3_setup_voice(int dev, int voice, int chn)
1071 {
1072 struct channel_info *info;
1073
1074 if (voice < 0 || voice >= devc->nr_voice)
1075 return;
1076
1077 if (chn < 0 || chn > 15)
1078 return;
1079
1080 info = &synth_devs[dev]->chn_info[chn];
1081
1082 opl3_set_instr(dev, voice, info->pgm_num);
1083
1084 devc->voc[voice].bender = 0;
1085 devc->voc[voice].bender_range = info->bender_range;
1086 devc->voc[voice].volume = info->controllers[CTL_MAIN_VOLUME];
1087 devc->voc[voice].panning = (info->controllers[CTL_PAN] * 2) - 128;
1088 }
1089
1090 static struct synth_operations opl3_operations =
1091 {
1092 .owner = THIS_MODULE,
1093 .id = "OPL",
1094 .info = NULL,
1095 .midi_dev = 0,
1096 .synth_type = SYNTH_TYPE_FM,
1097 .synth_subtype = FM_TYPE_ADLIB,
1098 .open = opl3_open,
1099 .close = opl3_close,
1100 .ioctl = opl3_ioctl,
1101 .kill_note = opl3_kill_note,
1102 .start_note = opl3_start_note,
1103 .set_instr = opl3_set_instr,
1104 .reset = opl3_reset,
1105 .hw_control = opl3_hw_control,
1106 .load_patch = opl3_load_patch,
1107 .aftertouch = opl3_aftertouch,
1108 .controller = opl3_controller,
1109 .panning = opl3_panning,
1110 .volume_method = opl3_volume_method,
1111 .bender = opl3_bender,
1112 .alloc_voice = opl3_alloc_voice,
1113 .setup_voice = opl3_setup_voice
1114 };
1115
1116 static int opl3_init(int ioaddr, struct module *owner)
1117 {
1118 int i;
1119 int me;
1120
1121 if (devc == NULL)
1122 {
1123 printk(KERN_ERR "opl3: Device control structure not initialized.\n");
1124 return -1;
1125 }
1126
1127 if ((me = sound_alloc_synthdev()) == -1)
1128 {
1129 printk(KERN_WARNING "opl3: Too many synthesizers\n");
1130 return -1;
1131 }
1132
1133 devc->nr_voice = 9;
1134
1135 devc->fm_info.device = 0;
1136 devc->fm_info.synth_type = SYNTH_TYPE_FM;
1137 devc->fm_info.synth_subtype = FM_TYPE_ADLIB;
1138 devc->fm_info.perc_mode = 0;
1139 devc->fm_info.nr_voices = 9;
1140 devc->fm_info.nr_drums = 0;
1141 devc->fm_info.instr_bank_size = SBFM_MAXINSTR;
1142 devc->fm_info.capabilities = 0;
1143 devc->left_io = ioaddr;
1144 devc->right_io = ioaddr + 2;
1145
1146 if (detected_model <= 2)
1147 devc->model = 1;
1148 else
1149 {
1150 devc->model = 2;
1151 if (detected_model == 4)
1152 devc->is_opl4 = 1;
1153 }
1154
1155 opl3_operations.info = &devc->fm_info;
1156
1157 synth_devs[me] = &opl3_operations;
1158
1159 if (owner)
1160 synth_devs[me]->owner = owner;
1161
1162 sequencer_init();
1163 devc->v_alloc = &opl3_operations.alloc;
1164 devc->chn_info = &opl3_operations.chn_info[0];
1165
1166 if (devc->model == 2)
1167 {
1168 if (devc->is_opl4)
1169 strcpy(devc->fm_info.name, "Yamaha OPL4/OPL3 FM");
1170 else
1171 strcpy(devc->fm_info.name, "Yamaha OPL3");
1172
1173 devc->v_alloc->max_voice = devc->nr_voice = 18;
1174 devc->fm_info.nr_drums = 0;
1175 devc->fm_info.synth_subtype = FM_TYPE_OPL3;
1176 devc->fm_info.capabilities |= SYNTH_CAP_OPL3;
1177
1178 for (i = 0; i < 18; i++)
1179 {
1180 if (pv_map[i].ioaddr == USE_LEFT)
1181 pv_map[i].ioaddr = devc->left_io;
1182 else
1183 pv_map[i].ioaddr = devc->right_io;
1184 }
1185 opl3_command(devc->right_io, OPL3_MODE_REGISTER, OPL3_ENABLE);
1186 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, 0x00);
1187 }
1188 else
1189 {
1190 strcpy(devc->fm_info.name, "Yamaha OPL2");
1191 devc->v_alloc->max_voice = devc->nr_voice = 9;
1192 devc->fm_info.nr_drums = 0;
1193
1194 for (i = 0; i < 18; i++)
1195 pv_map[i].ioaddr = devc->left_io;
1196 };
1197 conf_printf2(devc->fm_info.name, ioaddr, 0, -1, -1);
1198
1199 for (i = 0; i < SBFM_MAXINSTR; i++)
1200 devc->i_map[i].channel = -1;
1201
1202 return me;
1203 }
1204
1205 static int me;
1206
1207 static int io = -1;
1208
1209 module_param(io, int, 0);
1210
1211 static int __init init_opl3 (void)
1212 {
1213 printk(KERN_INFO "YM3812 and OPL-3 driver Copyright (C) by Hannu Savolainen, Rob Hooft 1993-1996\n");
1214
1215 if (io != -1) /* User loading pure OPL3 module */
1216 {
1217 if (!opl3_detect(io))
1218 {
1219 return -ENODEV;
1220 }
1221
1222 me = opl3_init(io, THIS_MODULE);
1223 }
1224
1225 return 0;
1226 }
1227
1228 static void __exit cleanup_opl3(void)
1229 {
1230 if (devc && io != -1)
1231 {
1232 if (devc->base) {
1233 release_region(devc->base,4);
1234 if (devc->is_opl4)
1235 release_region(devc->base - 8, 2);
1236 }
1237 kfree(devc);
1238 devc = NULL;
1239 sound_unload_synthdev(me);
1240 }
1241 }
1242
1243 module_init(init_opl3);
1244 module_exit(cleanup_opl3);
1245
1246 #ifndef MODULE
1247 static int __init setup_opl3(char *str)
1248 {
1249 /* io */
1250 int ints[2];
1251
1252 str = get_options(str, ARRAY_SIZE(ints), ints);
1253
1254 io = ints[1];
1255
1256 return 1;
1257 }
1258
1259 __setup("opl3=", setup_opl3);
1260 #endif
1261 MODULE_LICENSE("GPL");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree