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