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