sound/core/seq/instr/ainstr_simple.c

   1 /*
   2  *   Simple (MOD player) - Instrument routines
   3  *   Copyright (c) 1999 by Jaroslav Kysela <perex@suse.cz>
   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 <linux/slab.h>
  25 #include <sound/core.h>
  26 #include <sound/ainstr_simple.h>
  27 #include <sound/initval.h>
  28 #include <asm/uaccess.h>
  29
  30 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
  31 MODULE_DESCRIPTION("Advanced Linux Sound Architecture Simple Instrument support.");
  32 MODULE_LICENSE("GPL");
  33 MODULE_CLASSES("{sound}");
  34 MODULE_SUPPORTED_DEVICE("sound");
  35
  36 char *snd_seq_simple_id = SNDRV_SEQ_INSTR_ID_SIMPLE;
  37
  38 static unsigned int snd_seq_simple_size(unsigned int size, unsigned int format)
  39 {
  40         unsigned int result = size;
  41
  42         if (format & SIMPLE_WAVE_16BIT)
  43                 result <<= 1;
  44         if (format & SIMPLE_WAVE_STEREO)
  45                 result <<= 1;
  46         return result;
  47 }
  48
  49 static void snd_seq_simple_instr_free(snd_simple_ops_t *ops,
  50                                       simple_instrument_t *ip,
  51                                       int atomic)
  52 {
  53         if (ops->remove_sample)
  54                 ops->remove_sample(ops->private_data, ip, atomic);
  55 }
  56
  57 static int snd_seq_simple_put(void *private_data, snd_seq_kinstr_t *instr,
  58                               char __user *instr_data, long len,
  59                               int atomic, int cmd)
  60 {
  61         snd_simple_ops_t *ops = (snd_simple_ops_t *)private_data;
  62         simple_instrument_t *ip;
  63         simple_xinstrument_t ix;
  64         int err, gfp_mask;
  65         unsigned int real_size;
  66
  67         if (cmd != SNDRV_SEQ_INSTR_PUT_CMD_CREATE)
  68                 return -EINVAL;
  69         gfp_mask = atomic ? GFP_ATOMIC : GFP_KERNEL;
  70         /* copy instrument data */
  71         if (len < (long)sizeof(ix))
  72                 return -EINVAL;
  73         if (copy_from_user(&ix, instr_data, sizeof(ix)))
  74                 return -EFAULT;
  75         if (ix.stype != SIMPLE_STRU_INSTR)
  76                 return -EINVAL;
  77         instr_data += sizeof(ix);
  78         len -= sizeof(ix);
  79         ip = (simple_instrument_t *)KINSTR_DATA(instr);
  80         ip->share_id[0] = le32_to_cpu(ix.share_id[0]);
  81         ip->share_id[1] = le32_to_cpu(ix.share_id[1]);
  82         ip->share_id[2] = le32_to_cpu(ix.share_id[2]);
  83         ip->share_id[3] = le32_to_cpu(ix.share_id[3]);
  84         ip->format = le32_to_cpu(ix.format);
  85         ip->size = le32_to_cpu(ix.size);
  86         ip->start = le32_to_cpu(ix.start);
  87         ip->loop_start = le32_to_cpu(ix.loop_start);
  88         ip->loop_end = le32_to_cpu(ix.loop_end);
  89         ip->loop_repeat = le16_to_cpu(ix.loop_repeat);
  90         ip->effect1 = ix.effect1;
  91         ip->effect1_depth = ix.effect1_depth;
  92         ip->effect2 = ix.effect2;
  93         ip->effect2_depth = ix.effect2_depth;
  94         real_size = snd_seq_simple_size(ip->size, ip->format);
  95         if (len < (long)real_size)
  96                 return -EINVAL;
  97         if (ops->put_sample) {
  98                 err = ops->put_sample(ops->private_data, ip,
  99                                       instr_data, real_size, atomic);
 100                 if (err < 0)
 101                         return err;
 102         }
 103         return 0;
 104 }
 105
 106 static int snd_seq_simple_get(void *private_data, snd_seq_kinstr_t *instr,
 107                               char __user *instr_data, long len,
 108                               int atomic, int cmd)
 109 {
 110         snd_simple_ops_t *ops = (snd_simple_ops_t *)private_data;
 111         simple_instrument_t *ip;
 112         simple_xinstrument_t ix;
 113         int err;
 114         unsigned int real_size;
 115
 116         if (cmd != SNDRV_SEQ_INSTR_GET_CMD_FULL)
 117                 return -EINVAL;
 118         if (len < (long)sizeof(ix))
 119                 return -ENOMEM;
 120         memset(&ix, 0, sizeof(ix));
 121         ip = (simple_instrument_t *)KINSTR_DATA(instr);
 122         ix.stype = SIMPLE_STRU_INSTR;
 123         ix.share_id[0] = cpu_to_le32(ip->share_id[0]);
 124         ix.share_id[1] = cpu_to_le32(ip->share_id[1]);
 125         ix.share_id[2] = cpu_to_le32(ip->share_id[2]);
 126         ix.share_id[3] = cpu_to_le32(ip->share_id[3]);
 127         ix.format = cpu_to_le32(ip->format);
 128         ix.size = cpu_to_le32(ip->size);
 129         ix.start = cpu_to_le32(ip->start);
 130         ix.loop_start = cpu_to_le32(ip->loop_start);
 131         ix.loop_end = cpu_to_le32(ip->loop_end);
 132         ix.loop_repeat = cpu_to_le32(ip->loop_repeat);
 133         ix.effect1 = cpu_to_le16(ip->effect1);
 134         ix.effect1_depth = cpu_to_le16(ip->effect1_depth);
 135         ix.effect2 = ip->effect2;
 136         ix.effect2_depth = ip->effect2_depth;
 137         if (copy_to_user(instr_data, &ix, sizeof(ix)))
 138                 return -EFAULT;
 139         instr_data += sizeof(ix);
 140         len -= sizeof(ix);
 141         real_size = snd_seq_simple_size(ip->size, ip->format);
 142         if (len < (long)real_size)
 143                 return -ENOMEM;
 144         if (ops->get_sample) {
 145                 err = ops->get_sample(ops->private_data, ip,
 146                                       instr_data, real_size, atomic);
 147                 if (err < 0)
 148                         return err;
 149         }
 150         return 0;
 151 }
 152
 153 static int snd_seq_simple_get_size(void *private_data, snd_seq_kinstr_t *instr,
 154                                    long *size)
 155 {
 156         simple_instrument_t *ip;
 157
 158         ip = (simple_instrument_t *)KINSTR_DATA(instr);
 159         *size = sizeof(simple_xinstrument_t) + snd_seq_simple_size(ip->size, ip->format);
 160         return 0;
 161 }
 162
 163 static int snd_seq_simple_remove(void *private_data,
 164                                  snd_seq_kinstr_t *instr,
 165                                  int atomic)
 166 {
 167         snd_simple_ops_t *ops = (snd_simple_ops_t *)private_data;
 168         simple_instrument_t *ip;
 169
 170         ip = (simple_instrument_t *)KINSTR_DATA(instr);
 171         snd_seq_simple_instr_free(ops, ip, atomic);
 172         return 0;
 173 }
 174
 175 static void snd_seq_simple_notify(void *private_data,
 176                                   snd_seq_kinstr_t *instr,
 177                                   int what)
 178 {
 179         snd_simple_ops_t *ops = (snd_simple_ops_t *)private_data;
 180
 181         if (ops->notify)
 182                 ops->notify(ops->private_data, instr, what);
 183 }
 184
 185 int snd_seq_simple_init(snd_simple_ops_t *ops,
 186                         void *private_data,
 187                         snd_seq_kinstr_ops_t *next)
 188 {
 189         memset(ops, 0, sizeof(*ops));
 190         ops->private_data = private_data;
 191         ops->kops.private_data = ops;
 192         ops->kops.add_len = sizeof(simple_instrument_t);
 193         ops->kops.instr_type = snd_seq_simple_id;
 194         ops->kops.put = snd_seq_simple_put;
 195         ops->kops.get = snd_seq_simple_get;
 196         ops->kops.get_size = snd_seq_simple_get_size;
 197         ops->kops.remove = snd_seq_simple_remove;
 198         ops->kops.notify = snd_seq_simple_notify;
 199         ops->kops.next = next;
 200         return 0;
 201 }
 202
 203 /*
 204  *  Init part
 205  */
 206
 207 static int __init alsa_ainstr_simple_init(void)
 208 {
 209         return 0;
 210 }
 211
 212 static void __exit alsa_ainstr_simple_exit(void)
 213 {
 214 }
 215
 216 module_init(alsa_ainstr_simple_init)
 217 module_exit(alsa_ainstr_simple_exit)
 218
 219 EXPORT_SYMBOL(snd_seq_simple_id);
 220 EXPORT_SYMBOL(snd_seq_simple_init);