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 static int snd_seq_fm_put(void *private_data, snd_seq_kinstr_t *instr,
  34                           char __user *instr_data, long len, int atomic, int cmd)
  35 {
  36         fm_instrument_t *ip;
  37         fm_xinstrument_t ix;
  38         int idx;
  39
  40         if (cmd != SNDRV_SEQ_INSTR_PUT_CMD_CREATE)
  41                 return -EINVAL;
  42         /* copy instrument data */
  43         if (len < (long)sizeof(ix))
  44                 return -EINVAL;
  45         if (copy_from_user(&ix, instr_data, sizeof(ix)))
  46                 return -EFAULT;
  47         if (ix.stype != FM_STRU_INSTR)
  48                 return -EINVAL;
  49         ip = (fm_instrument_t *)KINSTR_DATA(instr);
  50         ip->share_id[0] = le32_to_cpu(ix.share_id[0]);
  51         ip->share_id[1] = le32_to_cpu(ix.share_id[1]);
  52         ip->share_id[2] = le32_to_cpu(ix.share_id[2]);
  53         ip->share_id[3] = le32_to_cpu(ix.share_id[3]);
  54         ip->type = ix.type;
  55         for (idx = 0; idx < 4; idx++) {
  56                 ip->op[idx].am_vib = ix.op[idx].am_vib;
  57                 ip->op[idx].ksl_level = ix.op[idx].ksl_level;
  58                 ip->op[idx].attack_decay = ix.op[idx].attack_decay;
  59                 ip->op[idx].sustain_release = ix.op[idx].sustain_release;
  60                 ip->op[idx].wave_select = ix.op[idx].wave_select;
  61         }
  62         for (idx = 0; idx < 2; idx++) {
  63                 ip->feedback_connection[idx] = ix.feedback_connection[idx];
  64         }
  65         ip->echo_delay = ix.echo_delay;
  66         ip->echo_atten = ix.echo_atten;
  67         ip->chorus_spread = ix.chorus_spread;
  68         ip->trnsps = ix.trnsps;
  69         ip->fix_dur = ix.fix_dur;
  70         ip->modes = ix.modes;
  71         ip->fix_key = ix.fix_key;
  72         return 0;
  73 }
  74
  75 static int snd_seq_fm_get(void *private_data, snd_seq_kinstr_t *instr,
  76                           char __user *instr_data, long len, int atomic,
  77                           int cmd)
  78 {
  79         fm_instrument_t *ip;
  80         fm_xinstrument_t ix;
  81         int idx;
  82
  83         if (cmd != SNDRV_SEQ_INSTR_GET_CMD_FULL)
  84                 return -EINVAL;
  85         if (len < (long)sizeof(ix))
  86                 return -ENOMEM;
  87         memset(&ix, 0, sizeof(ix));
  88         ip = (fm_instrument_t *)KINSTR_DATA(instr);
  89         ix.stype = FM_STRU_INSTR;
  90         ix.share_id[0] = cpu_to_le32(ip->share_id[0]);
  91         ix.share_id[1] = cpu_to_le32(ip->share_id[1]);
  92         ix.share_id[2] = cpu_to_le32(ip->share_id[2]);
  93         ix.share_id[3] = cpu_to_le32(ip->share_id[3]);
  94         ix.type = ip->type;
  95         for (idx = 0; idx < 4; idx++) {
  96                 ix.op[idx].am_vib = ip->op[idx].am_vib;
  97                 ix.op[idx].ksl_level = ip->op[idx].ksl_level;
  98                 ix.op[idx].attack_decay = ip->op[idx].attack_decay;
  99                 ix.op[idx].sustain_release = ip->op[idx].sustain_release;
 100                 ix.op[idx].wave_select = ip->op[idx].wave_select;
 101         }
 102         for (idx = 0; idx < 2; idx++) {
 103                 ix.feedback_connection[idx] = ip->feedback_connection[idx];
 104         }
 105         if (copy_to_user(instr_data, &ix, sizeof(ix)))
 106                 return -EFAULT;
 107         ix.echo_delay = ip->echo_delay;
 108         ix.echo_atten = ip->echo_atten;
 109         ix.chorus_spread = ip->chorus_spread;
 110         ix.trnsps = ip->trnsps;
 111         ix.fix_dur = ip->fix_dur;
 112         ix.modes = ip->modes;
 113         ix.fix_key = ip->fix_key;
 114         return 0;
 115 }
 116
 117 static int snd_seq_fm_get_size(void *private_data, snd_seq_kinstr_t *instr,
 118                                long *size)
 119 {
 120         *size = sizeof(fm_xinstrument_t);
 121         return 0;
 122 }
 123
 124 int snd_seq_fm_init(snd_seq_kinstr_ops_t *ops,
 125                     snd_seq_kinstr_ops_t *next)
 126 {
 127         memset(ops, 0, sizeof(*ops));
 128         // ops->private_data = private_data;
 129         ops->add_len = sizeof(fm_instrument_t);
 130         ops->instr_type = SNDRV_SEQ_INSTR_ID_OPL2_3;
 131         ops->put = snd_seq_fm_put;
 132         ops->get = snd_seq_fm_get;
 133         ops->get_size = snd_seq_fm_get_size;
 134         // ops->remove = snd_seq_fm_remove;
 135         // ops->notify = snd_seq_fm_notify;
 136         ops->next = next;
 137         return 0;
 138 }
 139
 140 /*
 141  *  Init part
 142  */
 143
 144 static int __init alsa_ainstr_fm_init(void)
 145 {
 146         return 0;
 147 }
 148
 149 static void __exit alsa_ainstr_fm_exit(void)
 150 {
 151 }
 152
 153 module_init(alsa_ainstr_fm_init)
 154 module_exit(alsa_ainstr_fm_exit)
 155
 156 EXPORT_SYMBOL(snd_seq_fm_init);