sound/core/seq/instr/ainstr_fm.c

   1 /*
   2  *  FM (OPL2/3) Instrument routines
   3  *  Copyright (c) 2000 Uros Bizjak <uros@kss-loka.si>
   4  *
   5  *   This program is free software; you can redistribute it and/or modify
   6  *   it under the terms of the GNU General Public License as published by
   7  *   the Free Software Foundation; either version 2 of the License, or
   8  *   (at your option) any later version.
   9  *
  10  *   This program is distributed in the hope that it will be useful,
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *   GNU General Public License for more details.
  14  *
  15  *   You should have received a copy of the GNU General Public License
  16  *   along with this program; if not, write to the Free Software
  17  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18  *
  19  */
  20
  21 #include <sound/driver.h>
  22 #include <linux/init.h>
  23 #include <linux/sched.h>
  24 #include <sound/core.h>
  25 #include <sound/ainstr_fm.h>
  26 #include <sound/initval.h>
  27 #include <asm/uaccess.h>
  28
  29 MODULE_AUTHOR("Uros Bizjak <uros@kss-loka.si>");
  30 MODULE_DESCRIPTION("Advanced Linux Sound Architecture FM Instrument support.");
  31 MODULE_LICENSE("GPL");
  32
  33 char *snd_seq_fm_id = SNDRV_SEQ_INSTR_ID_OPL2_3;
  34
  35 static int snd_seq_fm_put(void *private_data, snd_seq_kinstr_t *instr,
  36                           char __user *instr_data, long len, int atomic, int cmd)
  37 {
  38         fm_instrument_t *ip;
  39         fm_xinstrument_t ix;
  40         int idx;
  41
  42         if (cmd != SNDRV_SEQ_INSTR_PUT_CMD_CREATE)
  43                 return -EINVAL;
  44         /* copy instrument data */
  45         if (len < (long)sizeof(ix))
  46                 return -EINVAL;
  47         if (copy_from_user(&ix, instr_data, sizeof(ix)))
  48                 return -EFAULT;
  49         if (ix.stype != FM_STRU_INSTR)
  50                 return -EINVAL;
  51         ip = (fm_instrument_t *)KINSTR_DATA(instr);
  52         ip->share_id[0] = le32_to_cpu(ix.share_id[0]);
  53         ip->share_id[1] = le32_to_cpu(ix.share_id[1]);
  54         ip->share_id[2] = le32_to_cpu(ix.share_id[2]);
  55         ip->share_id[3] = le32_to_cpu(ix.share_id[3]);
  56         ip->type = ix.type;
  57         for (idx = 0; idx < 4; idx++) {
  58                 ip->op[idx].am_vib = ix.op[idx].am_vib;
  59                 ip->op[idx].ksl_level = ix.op[idx].ksl_level;
  60                 ip->op[idx].attack_decay = ix.op[idx].attack_decay;
  61                 ip->op[idx].sustain_release = ix.op[idx].sustain_release;
  62                 ip->op[idx].wave_select = ix.op[idx].wave_select;
  63         }
  64         for (idx = 0; idx < 2; idx++) {
  65                 ip->feedback_connection[idx] = ix.feedback_connection[idx];
  66         }
  67         ip->echo_delay = ix.echo_delay;
  68         ip->echo_atten = ix.echo_atten;
  69         ip->chorus_spread = ix.chorus_spread;
  70         ip->trnsps = ix.trnsps;
  71         ip->fix_dur = ix.fix_dur;
  72         ip->modes = ix.modes;
  73         ip->fix_key = ix.fix_key;
  74         return 0;
  75 }
  76
  77 static int snd_seq_fm_get(void *private_data, snd_seq_kinstr_t *instr,
  78                           char __user *instr_data, long len, int atomic,
  79                           int cmd)
  80 {
  81         fm_instrument_t *ip;
  82         fm_xinstrument_t ix;
  83         int idx;
  84
  85         if (cmd != SNDRV_SEQ_INSTR_GET_CMD_FULL)
  86                 return -EINVAL;
  87         if (len < (long)sizeof(ix))
  88                 return -ENOMEM;
  89         memset(&ix, 0, sizeof(ix));
  90         ip = (fm_instrument_t *)KINSTR_DATA(instr);
  91         ix.stype = FM_STRU_INSTR;
  92         ix.share_id[0] = cpu_to_le32(ip->share_id[0]);
  93         ix.share_id[1] = cpu_to_le32(ip->share_id[1]);
  94         ix.share_id[2] = cpu_to_le32(ip->share_id[2]);
  95         ix.share_id[3] = cpu_to_le32(ip->share_id[3]);
  96         ix.type = ip->type;
  97         for (idx = 0; idx < 4; idx++) {
  98                 ix.op[idx].am_vib = ip->op[idx].am_vib;
  99                 ix.op[idx].ksl_level = ip->op[idx].ksl_level;
 100                 ix.op[idx].attack_decay = ip->op[idx].attack_decay;
 101                 ix.op[idx].sustain_release = ip->op[idx].sustain_release;
 102                 ix.op[idx].wave_select = ip->op[idx].wave_select;
 103         }
 104         for (idx = 0; idx < 2; idx++) {
 105                 ix.feedback_connection[idx] = ip->feedback_connection[idx];
 106         }
 107         if (copy_to_user(instr_data, &ix, sizeof(ix)))
 108                 return -EFAULT;
 109         ix.echo_delay = ip->echo_delay;
 110         ix.echo_atten = ip->echo_atten;
 111         ix.chorus_spread = ip->chorus_spread;
 112         ix.trnsps = ip->trnsps;
 113         ix.fix_dur = ip->fix_dur;
 114         ix.modes = ip->modes;
 115         ix.fix_key = ip->fix_key;
 116         return 0;
 117 }
 118
 119 static int snd_seq_fm_get_size(void *private_data, snd_seq_kinstr_t *instr,
 120                                long *size)
 121 {
 122         *size = sizeof(fm_xinstrument_t);
 123         return 0;
 124 }
 125
 126 int snd_seq_fm_init(snd_seq_kinstr_ops_t *ops,
 127                     snd_seq_kinstr_ops_t *next)
 128 {
 129         memset(ops, 0, sizeof(*ops));
 130         // ops->private_data = private_data;
 131         ops->add_len = sizeof(fm_instrument_t);
 132         ops->instr_type = snd_seq_fm_id;
 133         ops->put = snd_seq_fm_put;
 134         ops->get = snd_seq_fm_get;
 135         ops->get_size = snd_seq_fm_get_size;
 136         // ops->remove = snd_seq_fm_remove;
 137         // ops->notify = snd_seq_fm_notify;
 138         ops->next = next;
 139         return 0;
 140 }
 141
 142 /*
 143  *  Init part
 144  */
 145
 146 static int __init alsa_ainstr_fm_init(void)
 147 {
 148         return 0;
 149 }
 150
 151 static void __exit alsa_ainstr_fm_exit(void)
 152 {
 153 }
 154
 155 module_init(alsa_ainstr_fm_init)
 156 module_exit(alsa_ainstr_fm_exit)
 157
 158 EXPORT_SYMBOL(snd_seq_fm_id);
 159 EXPORT_SYMBOL(snd_seq_fm_init);