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 43struct 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 55struct 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 78static struct opl_devinfo *devc = NULL; 79 80static int detected_model; 81 82static int store_instr(int instr_no, struct sbi_instrument *instr); 83static void freq_to_fnum(int freq, int *block, int *fnum); 84static void opl3_command(int io_addr, unsigned int addr, unsigned int val); 85static int opl3_kill_note(int dev, int voice, int note, int velocity); 86 87static 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 112static 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 146static 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; 260cleanup_region: 261 release_region(ioaddr, 4); 262cleanup_devc: 263 kfree(devc); 264 devc = NULL; 265 return 0; 266} 267 268static 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 302static 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 310static 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 331static 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 351static 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 370static 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 457static 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 677static 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 718static 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 744static 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 781static 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 806static 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 817static void opl3_hw_control(int dev, unsigned char *event) 818{ 819} 820 821static 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 845static 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 854static 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 864static 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 931static 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 965static 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 990static 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 998static 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 1064static 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 1084static 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 1110static 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 1199static int me; 1200 1201static int io = -1; 1202 1203module_param(io, int, 0); 1204 1205static 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 1222static 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 1237module_init(init_opl3); 1238module_exit(cleanup_opl3); 1239 1240#ifndef MODULE 1241static 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 1255MODULE_LICENSE("GPL"); 1256