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