kernel/sound/oss/opl3.c

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