sound/oss/opl3.c

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