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