开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
opl3.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：27k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

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