~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/oss/opl3.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp