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