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 55typedef 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 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 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 303static 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 311static 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 332static 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 352static 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 371static 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 458static 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 678static 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 719static 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 745static 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 782static 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 807static 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 818static void opl3_hw_control(int dev, unsigned char *event) 819{ 820} 821 822static int opl3_load_patch(int dev, int format, const char __user *addr, 823 int offs, 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 /* 834 * What the fuck is going on here? We leave junk in the beginning 835 * of ins and then check the field pretty close to that beginning? 836 */ 837 if(copy_from_user(&((char *) &ins)[offs], addr + offs, sizeof(ins) - offs)) 838 return -EFAULT; 839 840 if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR) 841 { 842 printk(KERN_WARNING "FM Error: Invalid instrument number %d\n", ins.channel); 843 return -EINVAL; 844 } 845 ins.key = format; 846 847 return store_instr(ins.channel, &ins); 848} 849 850static void opl3_panning(int dev, int voice, int value) 851{ 852 devc->voc[voice].panning = value; 853} 854 855static void opl3_volume_method(int dev, int mode) 856{ 857} 858 859#define SET_VIBRATO(cell) { \ 860 tmp = instr->operators[(cell-1)+(((cell-1)/2)*OFFS_4OP)]; \ 861 if (pressure > 110) \ 862 tmp |= 0x40; /* Vibrato on */ \ 863 opl3_command (map->ioaddr, AM_VIB + map->op[cell-1], tmp);} 864 865static void opl3_aftertouch(int dev, int voice, int pressure) 866{ 867 int tmp; 868 struct sbi_instrument *instr; 869 struct physical_voice_info *map; 870 871 if (voice < 0 || voice >= devc->nr_voice) 872 return; 873 874 map = &pv_map[devc->lv_map[voice]]; 875 876 DEB(printk("Aftertouch %d\n", voice)); 877 878 if (map->voice_mode == 0) 879 return; 880 881 /* 882 * Adjust the amount of vibrato depending the pressure 883 */ 884 885 instr = devc->act_i[voice]; 886 887 if (!instr) 888 instr = &devc->i_map[0]; 889 890 if (devc->voc[voice].mode == 4) 891 { 892 int connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01); 893 894 switch (connection) 895 { 896 case 0: 897 SET_VIBRATO(4); 898 break; 899 900 case 1: 901 SET_VIBRATO(2); 902 SET_VIBRATO(4); 903 break; 904 905 case 2: 906 SET_VIBRATO(1); 907 SET_VIBRATO(4); 908 break; 909 910 case 3: 911 SET_VIBRATO(1); 912 SET_VIBRATO(3); 913 SET_VIBRATO(4); 914 break; 915 916 } 917 /* 918 * Not implemented yet 919 */ 920 } 921 else 922 { 923 SET_VIBRATO(1); 924 925 if ((instr->operators[10] & 0x01)) /* 926 * Additive synthesis 927 */ 928 SET_VIBRATO(2); 929 } 930} 931 932#undef SET_VIBRATO 933 934static void bend_pitch(int dev, int voice, int value) 935{ 936 unsigned char data; 937 int block, fnum, freq; 938 struct physical_voice_info *map; 939 940 map = &pv_map[devc->lv_map[voice]]; 941 942 if (map->voice_mode == 0) 943 return; 944 945 devc->voc[voice].bender = value; 946 if (!value) 947 return; 948 if (!(devc->voc[voice].keyon_byte & 0x20)) 949 return; /* 950 * Not keyed on 951 */ 952 953 freq = compute_finetune(devc->voc[voice].orig_freq, devc->voc[voice].bender, devc->voc[voice].bender_range, 0); 954 devc->voc[voice].current_freq = freq; 955 956 freq_to_fnum(freq, &block, &fnum); 957 958 data = fnum & 0xff; /* 959 * Least significant bits of fnumber 960 */ 961 opl3_command(map->ioaddr, FNUM_LOW + map->voice_num, data); 962 963 data = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3); 964 devc->voc[voice].keyon_byte = data; 965 opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, data); 966} 967 968static void opl3_controller (int dev, int voice, int ctrl_num, int value) 969{ 970 if (voice < 0 || voice >= devc->nr_voice) 971 return; 972 973 switch (ctrl_num) 974 { 975 case CTRL_PITCH_BENDER: 976 bend_pitch(dev, voice, value); 977 break; 978 979 case CTRL_PITCH_BENDER_RANGE: 980 devc->voc[voice].bender_range = value; 981 break; 982 983 case CTL_MAIN_VOLUME: 984 devc->voc[voice].volume = value / 128; 985 break; 986 987 case CTL_PAN: 988 devc->voc[voice].panning = (value * 2) - 128; 989 break; 990 } 991} 992 993static void opl3_bender(int dev, int voice, int value) 994{ 995 if (voice < 0 || voice >= devc->nr_voice) 996 return; 997 998 bend_pitch(dev, voice, value - 8192); 999} 1000 1001static int opl3_alloc_voice(int dev, int chn, int note, struct voice_alloc_info *alloc) 1002{ 1003 int i, p, best, first, avail, best_time = 0x7fffffff; 1004 struct sbi_instrument *instr; 1005 int is4op; 1006 int instr_no; 1007 1008 if (chn < 0 || chn > 15) 1009 instr_no = 0; 1010 else 1011 instr_no = devc->chn_info[chn].pgm_num; 1012 1013 instr = &devc->i_map[instr_no]; 1014 if (instr->channel < 0 || /* Instrument not loaded */ 1015 devc->nr_voice != 12) /* Not in 4 OP mode */ 1016 is4op = 0; 1017 else if (devc->nr_voice == 12) /* 4 OP mode */ 1018 is4op = (instr->key == OPL3_PATCH); 1019 else 1020 is4op = 0; 1021 1022 if (is4op) 1023 { 1024 first = p = 0; 1025 avail = 6; 1026 } 1027 else 1028 { 1029 if (devc->nr_voice == 12) /* 4 OP mode. Use the '2 OP only' operators first */ 1030 first = p = 6; 1031 else 1032 first = p = 0; 1033 avail = devc->nr_voice; 1034 } 1035 1036 /* 1037 * Now try to find a free voice 1038 */ 1039 best = first; 1040 1041 for (i = 0; i < avail; i++) 1042 { 1043 if (alloc->map[p] == 0) 1044 { 1045 return p; 1046 } 1047 if (alloc->alloc_times[p] < best_time) /* Find oldest playing note */ 1048 { 1049 best_time = alloc->alloc_times[p]; 1050 best = p; 1051 } 1052 p = (p + 1) % avail; 1053 } 1054 1055 /* 1056 * Insert some kind of priority mechanism here. 1057 */ 1058 1059 if (best < 0) 1060 best = 0; 1061 if (best > devc->nr_voice) 1062 best -= devc->nr_voice; 1063 1064 return best; /* All devc->voc in use. Select the first one. */ 1065} 1066 1067static void opl3_setup_voice(int dev, int voice, int chn) 1068{ 1069 struct channel_info *info = 1070 &synth_devs[dev]->chn_info[chn]; 1071 1072 opl3_set_instr(dev, voice, info->pgm_num); 1073 1074 devc->voc[voice].bender = 0; 1075 devc->voc[voice].bender_range = info->bender_range; 1076 devc->voc[voice].volume = info->controllers[CTL_MAIN_VOLUME]; 1077 devc->voc[voice].panning = (info->controllers[CTL_PAN] * 2) - 128; 1078} 1079 1080static struct synth_operations opl3_operations = 1081{ 1082 .owner = THIS_MODULE, 1083 .id = "OPL", 1084 .info = NULL, 1085 .midi_dev = 0, 1086 .synth_type = SYNTH_TYPE_FM, 1087 .synth_subtype = FM_TYPE_ADLIB, 1088 .open = opl3_open, 1089 .close = opl3_close, 1090 .ioctl = opl3_ioctl, 1091 .kill_note = opl3_kill_note, 1092 .start_note = opl3_start_note, 1093 .set_instr = opl3_set_instr, 1094 .reset = opl3_reset, 1095 .hw_control = opl3_hw_control, 1096 .load_patch = opl3_load_patch, 1097 .aftertouch = opl3_aftertouch, 1098 .controller = opl3_controller, 1099 .panning = opl3_panning, 1100 .volume_method = opl3_volume_method, 1101 .bender = opl3_bender, 1102 .alloc_voice = opl3_alloc_voice, 1103 .setup_voice = opl3_setup_voice 1104}; 1105 1106static int opl3_init(int ioaddr, struct module *owner) 1107{ 1108 int i; 1109 int me; 1110 1111 if (devc == NULL) 1112 { 1113 printk(KERN_ERR "opl3: Device control structure not initialized.\n"); 1114 return -1; 1115 } 1116 1117 if ((me = sound_alloc_synthdev()) == -1) 1118 { 1119 printk(KERN_WARNING "opl3: Too many synthesizers\n"); 1120 return -1; 1121 } 1122 1123 devc->nr_voice = 9; 1124 1125 devc->fm_info.device = 0; 1126 devc->fm_info.synth_type = SYNTH_TYPE_FM; 1127 devc->fm_info.synth_subtype = FM_TYPE_ADLIB; 1128 devc->fm_info.perc_mode = 0; 1129 devc->fm_info.nr_voices = 9; 1130 devc->fm_info.nr_drums = 0; 1131 devc->fm_info.instr_bank_size = SBFM_MAXINSTR; 1132 devc->fm_info.capabilities = 0; 1133 devc->left_io = ioaddr; 1134 devc->right_io = ioaddr + 2; 1135 1136 if (detected_model <= 2) 1137 devc->model = 1; 1138 else 1139 { 1140 devc->model = 2; 1141 if (detected_model == 4) 1142 devc->is_opl4 = 1; 1143 } 1144 1145 opl3_operations.info = &devc->fm_info; 1146 1147 synth_devs[me] = &opl3_operations; 1148 1149 if (owner) 1150 synth_devs[me]->owner = owner; 1151 1152 sequencer_init(); 1153 devc->v_alloc = &opl3_operations.alloc; 1154 devc->chn_info = &opl3_operations.chn_info[0]; 1155 1156 if (devc->model == 2) 1157 { 1158 if (devc->is_opl4) 1159 strcpy(devc->fm_info.name, "Yamaha OPL4/OPL3 FM"); 1160 else 1161 strcpy(devc->fm_info.name, "Yamaha OPL3"); 1162 1163 devc->v_alloc->max_voice = devc->nr_voice = 18; 1164 devc->fm_info.nr_drums = 0; 1165 devc->fm_info.synth_subtype = FM_TYPE_OPL3; 1166 devc->fm_info.capabilities |= SYNTH_CAP_OPL3; 1167 1168 for (i = 0; i < 18; i++) 1169 { 1170 if (pv_map[i].ioaddr == USE_LEFT) 1171 pv_map[i].ioaddr = devc->left_io; 1172 else 1173 pv_map[i].ioaddr = devc->right_io; 1174 } 1175 opl3_command(devc->right_io, OPL3_MODE_REGISTER, OPL3_ENABLE); 1176 opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, 0x00); 1177 } 1178 else 1179 { 1180 strcpy(devc->fm_info.name, "Yamaha OPL2"); 1181 devc->v_alloc->max_voice = devc->nr_voice = 9; 1182 devc->fm_info.nr_drums = 0; 1183 1184 for (i = 0; i < 18; i++) 1185 pv_map[i].ioaddr = devc->left_io; 1186 }; 1187 conf_printf2(devc->fm_info.name, ioaddr, 0, -1, -1); 1188 1189 for (i = 0; i < SBFM_MAXINSTR; i++) 1190 devc->i_map[i].channel = -1; 1191 1192 return me; 1193} 1194 1195static int me; 1196 1197static int io = -1; 1198 1199module_param(io, int, 0); 1200 1201static int __init init_opl3 (void) 1202{ 1203 printk(KERN_INFO "YM3812 and OPL-3 driver Copyright (C) by Hannu Savolainen, Rob Hooft 1993-1996\n"); 1204 1205 if (io != -1) /* User loading pure OPL3 module */ 1206 { 1207 if (!opl3_detect(io)) 1208 { 1209 return -ENODEV; 1210 } 1211 1212 me = opl3_init(io, THIS_MODULE); 1213 } 1214 1215 return 0; 1216} 1217 1218static void __exit cleanup_opl3(void) 1219{ 1220 if (devc && io != -1) 1221 { 1222 if (devc->base) { 1223 release_region(devc->base,4); 1224 if (devc->is_opl4) 1225 release_region(devc->base - 8, 2); 1226 } 1227 kfree(devc); 1228 devc = NULL; 1229 sound_unload_synthdev(me); 1230 } 1231} 1232 1233module_init(init_opl3); 1234module_exit(cleanup_opl3); 1235 1236#ifndef MODULE 1237static int __init setup_opl3(char *str) 1238{ 1239 /* io */ 1240 int ints[2]; 1241 1242 str = get_options(str, ARRAY_SIZE(ints), ints); 1243 1244 io = ints[1]; 1245 1246 return 1; 1247} 1248 1249__setup("opl3=", setup_opl3); 1250#endif 1251MODULE_LICENSE("GPL"); 1252