Logo Search packages:      
Sourcecode: alsa-driver version File versions

seq_instr.c

/*
 *   Generic Instrument routines for ALSA sequencer
 *   Copyright (c) 1999 by Jaroslav Kysela <perex@perex.cz>
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 */
 
#include <sound/driver.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <sound/core.h>
#include "seq_clientmgr.h"
#include <sound/seq_instr.h>
#include <sound/initval.h>

MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
MODULE_DESCRIPTION("Advanced Linux Sound Architecture sequencer instrument library.");
MODULE_LICENSE("GPL");


static void snd_instr_lock_ops(struct snd_seq_kinstr_list *list)
{
      if (!(list->flags & SNDRV_SEQ_INSTR_FLG_DIRECT)) {
            spin_lock_irqsave(&list->ops_lock, list->ops_flags);
      } else {
            mutex_lock(&list->ops_mutex);
      }
}

static void snd_instr_unlock_ops(struct snd_seq_kinstr_list *list)
{
      if (!(list->flags & SNDRV_SEQ_INSTR_FLG_DIRECT)) {
            spin_unlock_irqrestore(&list->ops_lock, list->ops_flags);
      } else {
            mutex_unlock(&list->ops_mutex);
      }
}

static struct snd_seq_kinstr *snd_seq_instr_new(int add_len, int atomic)
{
      struct snd_seq_kinstr *instr;
      
      instr = kzalloc(sizeof(struct snd_seq_kinstr) + add_len, atomic ? GFP_ATOMIC : GFP_KERNEL);
      if (instr == NULL)
            return NULL;
      instr->add_len = add_len;
      return instr;
}

static int snd_seq_instr_free(struct snd_seq_kinstr *instr, int atomic)
{
      int result = 0;

      if (instr == NULL)
            return -EINVAL;
      if (instr->ops && instr->ops->remove)
            result = instr->ops->remove(instr->ops->private_data, instr, 1);
      if (!result)
            kfree(instr);
      return result;
}

struct snd_seq_kinstr_list *snd_seq_instr_list_new(void)
{
      struct snd_seq_kinstr_list *list;

      list = kzalloc(sizeof(struct snd_seq_kinstr_list), GFP_KERNEL);
      if (list == NULL)
            return NULL;
      spin_lock_init(&list->lock);
      spin_lock_init(&list->ops_lock);
      mutex_init(&list->ops_mutex);
      list->owner = -1;
      return list;
}

void snd_seq_instr_list_free(struct snd_seq_kinstr_list **list_ptr)
{
      struct snd_seq_kinstr_list *list;
      struct snd_seq_kinstr *instr;
      struct snd_seq_kcluster *cluster;
      int idx;
      unsigned long flags;

      if (list_ptr == NULL)
            return;
      list = *list_ptr;
      *list_ptr = NULL;
      if (list == NULL)
            return;
      
      for (idx = 0; idx < SNDRV_SEQ_INSTR_HASH_SIZE; idx++) {           
            while ((instr = list->hash[idx]) != NULL) {
                  list->hash[idx] = instr->next;
                  list->count--;
                  spin_lock_irqsave(&list->lock, flags);
                  while (instr->use) {
                        spin_unlock_irqrestore(&list->lock, flags);
                        schedule_timeout_uninterruptible(1);
                        spin_lock_irqsave(&list->lock, flags);
                  }                       
                  spin_unlock_irqrestore(&list->lock, flags);
                  if (snd_seq_instr_free(instr, 0)<0)
                        snd_printk(KERN_WARNING "instrument free problem\n");
            }
            while ((cluster = list->chash[idx]) != NULL) {
                  list->chash[idx] = cluster->next;
                  list->ccount--;
                  kfree(cluster);
            }
      }
      kfree(list);
}

static int instr_free_compare(struct snd_seq_kinstr *instr,
                        struct snd_seq_instr_header *ifree,
                        unsigned int client)
{
      switch (ifree->cmd) {
      case SNDRV_SEQ_INSTR_FREE_CMD_ALL:
            /* all, except private for other clients */
            if ((instr->instr.std & 0xff000000) == 0)
                  return 0;
            if (((instr->instr.std >> 24) & 0xff) == client)
                  return 0;
            return 1;
      case SNDRV_SEQ_INSTR_FREE_CMD_PRIVATE:
            /* all my private instruments */
            if ((instr->instr.std & 0xff000000) == 0)
                  return 1;
            if (((instr->instr.std >> 24) & 0xff) == client)
                  return 0;
            return 1;
      case SNDRV_SEQ_INSTR_FREE_CMD_CLUSTER:
            /* all my private instruments */
            if ((instr->instr.std & 0xff000000) == 0) {
                  if (instr->instr.cluster == ifree->id.cluster)
                        return 0;
                  return 1;
            }
            if (((instr->instr.std >> 24) & 0xff) == client) {
                  if (instr->instr.cluster == ifree->id.cluster)
                        return 0;
            }
            return 1;
      }
      return 1;
}

int snd_seq_instr_list_free_cond(struct snd_seq_kinstr_list *list,
                           struct snd_seq_instr_header *ifree,
                           int client,
                           int atomic)
{
      struct snd_seq_kinstr *instr, *prev, *next, *flist;
      int idx;
      unsigned long flags;

      snd_instr_lock_ops(list);
      for (idx = 0; idx < SNDRV_SEQ_INSTR_HASH_SIZE; idx++) {
            spin_lock_irqsave(&list->lock, flags);
            instr = list->hash[idx];
            prev = flist = NULL;
            while (instr) {
                  while (instr && instr_free_compare(instr, ifree, (unsigned int)client)) {
                        prev = instr;
                        instr = instr->next;
                  }
                  if (instr == NULL)
                        continue;
                  if (instr->ops && instr->ops->notify)
                        instr->ops->notify(instr->ops->private_data, instr, SNDRV_SEQ_INSTR_NOTIFY_REMOVE);
                  next = instr->next;
                  if (prev == NULL) {
                        list->hash[idx] = next;
                  } else {
                        prev->next = next;
                  }
                  list->count--;
                  instr->next = flist;
                  flist = instr;
                  instr = next;
            }
            spin_unlock_irqrestore(&list->lock, flags);
            while (flist) {
                  instr = flist;
                  flist = instr->next;
                  while (instr->use) {
                        schedule_timeout_uninterruptible(1);
                        barrier();
                  }
                  if (snd_seq_instr_free(instr, atomic)<0)
                        snd_printk(KERN_WARNING "instrument free problem\n");
                  instr = next;
            }
      }
      snd_instr_unlock_ops(list);
      return 0;   
}

static int compute_hash_instr_key(struct snd_seq_instr *instr)
{
      int result;
      
      result = instr->bank | (instr->prg << 16);
      result += result >> 24;
      result += result >> 16;
      result += result >> 8;
      return result & (SNDRV_SEQ_INSTR_HASH_SIZE-1);
}

#if 0
static int compute_hash_cluster_key(snd_seq_instr_cluster_t cluster)
{
      int result;
      
      result = cluster;
      result += result >> 24;
      result += result >> 16;
      result += result >> 8;
      return result & (SNDRV_SEQ_INSTR_HASH_SIZE-1);
}
#endif

static int compare_instr(struct snd_seq_instr *i1, struct snd_seq_instr *i2, int exact)
{
      if (exact) {
            if (i1->cluster != i2->cluster ||
                i1->bank != i2->bank ||
                i1->prg != i2->prg)
                  return 1;
            if ((i1->std & 0xff000000) != (i2->std & 0xff000000))
                  return 1;
            if (!(i1->std & i2->std))
                  return 1;
            return 0;
      } else {
            unsigned int client_check;
            
            if (i2->cluster && i1->cluster != i2->cluster)
                  return 1;
            client_check = i2->std & 0xff000000;
            if (client_check) {
                  if ((i1->std & 0xff000000) != client_check)
                        return 1;
            } else {
                  if ((i1->std & i2->std) != i2->std)
                        return 1;
            }
            return i1->bank != i2->bank || i1->prg != i2->prg;
      }
}

struct snd_seq_kinstr *snd_seq_instr_find(struct snd_seq_kinstr_list *list,
                                struct snd_seq_instr *instr,
                                int exact,
                                int follow_alias)
{
      unsigned long flags;
      int depth = 0;
      struct snd_seq_kinstr *result;

      if (list == NULL || instr == NULL)
            return NULL;
      spin_lock_irqsave(&list->lock, flags);
      __again:
      result = list->hash[compute_hash_instr_key(instr)];
      while (result) {
            if (!compare_instr(&result->instr, instr, exact)) {
                  if (follow_alias && (result->type == SNDRV_SEQ_INSTR_ATYPE_ALIAS)) {
                        instr = (struct snd_seq_instr *)KINSTR_DATA(result);
                        if (++depth > 10)
                              goto __not_found;
                        goto __again;
                  }
                  result->use++;
                  spin_unlock_irqrestore(&list->lock, flags);
                  return result;
            }
            result = result->next;
      }
      __not_found:
      spin_unlock_irqrestore(&list->lock, flags);
      return NULL;
}

void snd_seq_instr_free_use(struct snd_seq_kinstr_list *list,
                      struct snd_seq_kinstr *instr)
{
      unsigned long flags;

      if (list == NULL || instr == NULL)
            return;
      spin_lock_irqsave(&list->lock, flags);
      if (instr->use <= 0) {
            snd_printk(KERN_ERR "free_use: fatal!!! use = %i, name = '%s'\n", instr->use, instr->name);
      } else {
            instr->use--;
      }
      spin_unlock_irqrestore(&list->lock, flags);
}

static struct snd_seq_kinstr_ops *instr_ops(struct snd_seq_kinstr_ops *ops,
                                  char *instr_type)
{
      while (ops) {
            if (!strcmp(ops->instr_type, instr_type))
                  return ops;
            ops = ops->next;
      }
      return NULL;
}

static int instr_result(struct snd_seq_event *ev,
                  int type, int result,
                  int atomic)
{
      struct snd_seq_event sev;
      
      memset(&sev, 0, sizeof(sev));
      sev.type = SNDRV_SEQ_EVENT_RESULT;
      sev.flags = SNDRV_SEQ_TIME_STAMP_REAL | SNDRV_SEQ_EVENT_LENGTH_FIXED |
                  SNDRV_SEQ_PRIORITY_NORMAL;
      sev.source = ev->dest;
      sev.dest = ev->source;
      sev.data.result.event = type;
      sev.data.result.result = result;
#if 0
      printk("instr result - type = %i, result = %i, queue = %i, source.client:port = %i:%i, dest.client:port = %i:%i\n",
                        type, result,
                        sev.queue,
                        sev.source.client, sev.source.port,
                        sev.dest.client, sev.dest.port);
#endif
      return snd_seq_kernel_client_dispatch(sev.source.client, &sev, atomic, 0);
}

static int instr_begin(struct snd_seq_kinstr_ops *ops,
                   struct snd_seq_kinstr_list *list,
                   struct snd_seq_event *ev,
                   int atomic, int hop)
{
      unsigned long flags;

      spin_lock_irqsave(&list->lock, flags);
      if (list->owner >= 0 && list->owner != ev->source.client) {
            spin_unlock_irqrestore(&list->lock, flags);
            return instr_result(ev, SNDRV_SEQ_EVENT_INSTR_BEGIN, -EBUSY, atomic);
      }
      list->owner = ev->source.client;
      spin_unlock_irqrestore(&list->lock, flags);
      return instr_result(ev, SNDRV_SEQ_EVENT_INSTR_BEGIN, 0, atomic);
}

static int instr_end(struct snd_seq_kinstr_ops *ops,
                 struct snd_seq_kinstr_list *list,
                 struct snd_seq_event *ev,
                 int atomic, int hop)
{
      unsigned long flags;

      /* TODO: timeout handling */
      spin_lock_irqsave(&list->lock, flags);
      if (list->owner == ev->source.client) {
            list->owner = -1;
            spin_unlock_irqrestore(&list->lock, flags);
            return instr_result(ev, SNDRV_SEQ_EVENT_INSTR_END, 0, atomic);
      }
      spin_unlock_irqrestore(&list->lock, flags);
      return instr_result(ev, SNDRV_SEQ_EVENT_INSTR_END, -EINVAL, atomic);
}

static int instr_info(struct snd_seq_kinstr_ops *ops,
                  struct snd_seq_kinstr_list *list,
                  struct snd_seq_event *ev,
                  int atomic, int hop)
{
      return -ENXIO;
}

static int instr_format_info(struct snd_seq_kinstr_ops *ops,
                       struct snd_seq_kinstr_list *list,
                       struct snd_seq_event *ev,
                       int atomic, int hop)
{
      return -ENXIO;
}

static int instr_reset(struct snd_seq_kinstr_ops *ops,
                   struct snd_seq_kinstr_list *list,
                   struct snd_seq_event *ev,
                   int atomic, int hop)
{
      return -ENXIO;
}

static int instr_status(struct snd_seq_kinstr_ops *ops,
                  struct snd_seq_kinstr_list *list,
                  struct snd_seq_event *ev,
                  int atomic, int hop)
{
      return -ENXIO;
}

static int instr_put(struct snd_seq_kinstr_ops *ops,
                 struct snd_seq_kinstr_list *list,
                 struct snd_seq_event *ev,
                 int atomic, int hop)
{
      unsigned long flags;
      struct snd_seq_instr_header put;
      struct snd_seq_kinstr *instr;
      int result = -EINVAL, len, key;

      if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARUSR)
            goto __return;

      if (ev->data.ext.len < sizeof(struct snd_seq_instr_header))
            goto __return;
      if (copy_from_user(&put, (void __user *)ev->data.ext.ptr,
                     sizeof(struct snd_seq_instr_header))) {
            result = -EFAULT;
            goto __return;
      }
      snd_instr_lock_ops(list);
      if (put.id.instr.std & 0xff000000) {      /* private instrument */
            put.id.instr.std &= 0x00ffffff;
            put.id.instr.std |= (unsigned int)ev->source.client << 24;
      }
      if ((instr = snd_seq_instr_find(list, &put.id.instr, 1, 0))) {
            snd_seq_instr_free_use(list, instr);
            snd_instr_unlock_ops(list);
            result = -EBUSY;
            goto __return;
      }
      ops = instr_ops(ops, put.data.data.format);
      if (ops == NULL) {
            snd_instr_unlock_ops(list);
            goto __return;
      }
      len = ops->add_len;
      if (put.data.type == SNDRV_SEQ_INSTR_ATYPE_ALIAS)
            len = sizeof(struct snd_seq_instr);
      instr = snd_seq_instr_new(len, atomic);
      if (instr == NULL) {
            snd_instr_unlock_ops(list);
            result = -ENOMEM;
            goto __return;
      }
      instr->ops = ops;
      instr->instr = put.id.instr;
      strlcpy(instr->name, put.data.name, sizeof(instr->name));
      instr->type = put.data.type;
      if (instr->type == SNDRV_SEQ_INSTR_ATYPE_DATA) {
            result = ops->put(ops->private_data,
                          instr,
                          (void __user *)ev->data.ext.ptr + sizeof(struct snd_seq_instr_header),
                          ev->data.ext.len - sizeof(struct snd_seq_instr_header),
                          atomic,
                          put.cmd);
            if (result < 0) {
                  snd_seq_instr_free(instr, atomic);
                  snd_instr_unlock_ops(list);
                  goto __return;
            }
      }
      key = compute_hash_instr_key(&instr->instr);
      spin_lock_irqsave(&list->lock, flags);
      instr->next = list->hash[key];
      list->hash[key] = instr;
      list->count++;
      spin_unlock_irqrestore(&list->lock, flags);
      snd_instr_unlock_ops(list);
      result = 0;
      __return:
      instr_result(ev, SNDRV_SEQ_EVENT_INSTR_PUT, result, atomic);
      return result;
}

static int instr_get(struct snd_seq_kinstr_ops *ops,
                 struct snd_seq_kinstr_list *list,
                 struct snd_seq_event *ev,
                 int atomic, int hop)
{
      return -ENXIO;
}

static int instr_free(struct snd_seq_kinstr_ops *ops,
                  struct snd_seq_kinstr_list *list,
                  struct snd_seq_event *ev,
                  int atomic, int hop)
{
      struct snd_seq_instr_header ifree;
      struct snd_seq_kinstr *instr, *prev;
      int result = -EINVAL;
      unsigned long flags;
      unsigned int hash;

      if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARUSR)
            goto __return;

      if (ev->data.ext.len < sizeof(struct snd_seq_instr_header))
            goto __return;
      if (copy_from_user(&ifree, (void __user *)ev->data.ext.ptr,
                     sizeof(struct snd_seq_instr_header))) {
            result = -EFAULT;
            goto __return;
      }
      if (ifree.cmd == SNDRV_SEQ_INSTR_FREE_CMD_ALL ||
          ifree.cmd == SNDRV_SEQ_INSTR_FREE_CMD_PRIVATE ||
          ifree.cmd == SNDRV_SEQ_INSTR_FREE_CMD_CLUSTER) {
            result = snd_seq_instr_list_free_cond(list, &ifree, ev->dest.client, atomic);
            goto __return;
      }
      if (ifree.cmd == SNDRV_SEQ_INSTR_FREE_CMD_SINGLE) {
            if (ifree.id.instr.std & 0xff000000) {
                  ifree.id.instr.std &= 0x00ffffff;
                  ifree.id.instr.std |= (unsigned int)ev->source.client << 24;
            }
            hash = compute_hash_instr_key(&ifree.id.instr);
            snd_instr_lock_ops(list);
            spin_lock_irqsave(&list->lock, flags);
            instr = list->hash[hash];
            prev = NULL;
            while (instr) {
                  if (!compare_instr(&instr->instr, &ifree.id.instr, 1))
                        goto __free_single;
                  prev = instr;
                  instr = instr->next;
            }
            result = -ENOENT;
            spin_unlock_irqrestore(&list->lock, flags);
            snd_instr_unlock_ops(list);
            goto __return;
            
            __free_single:
            if (prev) {
                  prev->next = instr->next;
            } else {
                  list->hash[hash] = instr->next;
            }
            if (instr->ops && instr->ops->notify)
                  instr->ops->notify(instr->ops->private_data, instr,
                                 SNDRV_SEQ_INSTR_NOTIFY_REMOVE);
            while (instr->use) {
                  spin_unlock_irqrestore(&list->lock, flags);
                  schedule_timeout_uninterruptible(1);
                  spin_lock_irqsave(&list->lock, flags);
            }                       
            spin_unlock_irqrestore(&list->lock, flags);
            result = snd_seq_instr_free(instr, atomic);
            snd_instr_unlock_ops(list);
            goto __return;
      }

      __return:
      instr_result(ev, SNDRV_SEQ_EVENT_INSTR_FREE, result, atomic);
      return result;
}

static int instr_list(struct snd_seq_kinstr_ops *ops,
                  struct snd_seq_kinstr_list *list,
                  struct snd_seq_event *ev,
                  int atomic, int hop)
{
      return -ENXIO;
}

static int instr_cluster(struct snd_seq_kinstr_ops *ops,
                   struct snd_seq_kinstr_list *list,
                   struct snd_seq_event *ev,
                   int atomic, int hop)
{
      return -ENXIO;
}

int snd_seq_instr_event(struct snd_seq_kinstr_ops *ops,
                  struct snd_seq_kinstr_list *list,
                  struct snd_seq_event *ev,
                  int client,
                  int atomic,
                  int hop)
{
      int direct = 0;

      snd_assert(ops != NULL && list != NULL && ev != NULL, return -EINVAL);
      if (snd_seq_ev_is_direct(ev)) {
            direct = 1;
            switch (ev->type) {
            case SNDRV_SEQ_EVENT_INSTR_BEGIN:
                  return instr_begin(ops, list, ev, atomic, hop);
            case SNDRV_SEQ_EVENT_INSTR_END:
                  return instr_end(ops, list, ev, atomic, hop);
            }
      }
      if ((list->flags & SNDRV_SEQ_INSTR_FLG_DIRECT) && !direct)
            return -EINVAL;
      switch (ev->type) {
      case SNDRV_SEQ_EVENT_INSTR_INFO:
            return instr_info(ops, list, ev, atomic, hop);
      case SNDRV_SEQ_EVENT_INSTR_FINFO:
            return instr_format_info(ops, list, ev, atomic, hop);
      case SNDRV_SEQ_EVENT_INSTR_RESET:
            return instr_reset(ops, list, ev, atomic, hop);
      case SNDRV_SEQ_EVENT_INSTR_STATUS:
            return instr_status(ops, list, ev, atomic, hop);
      case SNDRV_SEQ_EVENT_INSTR_PUT:
            return instr_put(ops, list, ev, atomic, hop);
      case SNDRV_SEQ_EVENT_INSTR_GET:
            return instr_get(ops, list, ev, atomic, hop);
      case SNDRV_SEQ_EVENT_INSTR_FREE:
            return instr_free(ops, list, ev, atomic, hop);
      case SNDRV_SEQ_EVENT_INSTR_LIST:
            return instr_list(ops, list, ev, atomic, hop);
      case SNDRV_SEQ_EVENT_INSTR_CLUSTER:
            return instr_cluster(ops, list, ev, atomic, hop);
      }
      return -EINVAL;
}
                  
/*
 *  Init part
 */

static int __init alsa_seq_instr_init(void)
{
      return 0;
}

static void __exit alsa_seq_instr_exit(void)
{
}

module_init(alsa_seq_instr_init)
module_exit(alsa_seq_instr_exit)

EXPORT_SYMBOL(snd_seq_instr_list_new);
EXPORT_SYMBOL(snd_seq_instr_list_free);
EXPORT_SYMBOL(snd_seq_instr_list_free_cond);
EXPORT_SYMBOL(snd_seq_instr_find);
EXPORT_SYMBOL(snd_seq_instr_free_use);
EXPORT_SYMBOL(snd_seq_instr_event);

Generated by  Doxygen 1.6.0   Back to index