/*
   * dsp_pipeline.c: pipelined audio processing
   *
   * Copyright (C) 2007, Nadi Sarrar
   *
   * Nadi Sarrar <nadi@beronet.com>
   *
   * 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.
   *
   * The full GNU General Public License is included in this distribution in the
   * file called LICENSE.
   *
   */
  
  #include <linux/kernel.h>
  #include <linux/list.h>
  #include <linux/string.h>
  #include <linux/mISDNif.h>
  #include <linux/mISDNdsp.h>
  #include "dsp.h"
  #include "dsp_hwec.h"
  
  /* uncomment for debugging */
  /*#define PIPELINE_DEBUG*/
  
  struct dsp_pipeline_entry {
  	struct mISDN_dsp_element *elem;
  	void                *p;
  	struct list_head     list;
  };
  struct dsp_element_entry {
  	struct mISDN_dsp_element *elem;
  	struct device	     dev;
  	struct list_head     list;
  };
  
  static LIST_HEAD(dsp_elements);
  
  /* sysfs */
  static struct class *elements_class;
  
  static ssize_t
  attr_show_args(struct device *dev, struct device_attribute *attr, char *buf)
  {
  	struct mISDN_dsp_element *elem = dev_get_drvdata(dev);

  	int i;
  	char *p = buf;

  
  	*buf = 0;

  	for (i = 0; i < elem->num_args; i++)
  		p += sprintf(p, "Name:        %s
  %s%s%sDescription: %s
  
  ",

  			  elem->args[i].name,
  			  elem->args[i].def ? "Default:     " : "",
  			  elem->args[i].def ? elem->args[i].def : "",
  			  elem->args[i].def ? "
  " : "",
  			  elem->args[i].desc);

  	return p - buf;

  }
  
  static struct device_attribute element_attributes[] = {
  	__ATTR(args, 0444, attr_show_args, NULL),
  };

  static void
  mISDN_dsp_dev_release(struct device *dev)
  {
  	struct dsp_element_entry *entry =
  		container_of(dev, struct dsp_element_entry, dev);
  	list_del(&entry->list);
  	kfree(entry);
  }

  int mISDN_dsp_element_register(struct mISDN_dsp_element *elem)
  {
  	struct dsp_element_entry *entry;
  	int ret, i;
  
  	if (!elem)
  		return -EINVAL;

  	entry = kzalloc(sizeof(struct dsp_element_entry), GFP_ATOMIC);

  	if (!entry)
  		return -ENOMEM;
  
  	entry->elem = elem;
  
  	entry->dev.class = elements_class;

  	entry->dev.release = mISDN_dsp_dev_release;

  	dev_set_drvdata(&entry->dev, elem);

  	dev_set_name(&entry->dev, elem->name);

  	ret = device_register(&entry->dev);
  	if (ret) {
  		printk(KERN_ERR "%s: failed to register %s
  ",
  			__func__, elem->name);
  		goto err1;
  	}

  	list_add_tail(&entry->list, &dsp_elements);

  	for (i = 0; i < ARRAY_SIZE(element_attributes); ++i) {

  		ret = device_create_file(&entry->dev,
  				&element_attributes[i]);
  		if (ret) {
  			printk(KERN_ERR "%s: failed to create device file
  ",
  				__func__);
  			goto err2;
  		}

  	}

  #ifdef PIPELINE_DEBUG

  	printk(KERN_DEBUG "%s: %s registered
  ", __func__, elem->name);

  #endif

  
  	return 0;
  
  err2:
  	device_unregister(&entry->dev);

  	return ret;

  err1:
  	kfree(entry);
  	return ret;
  }
  EXPORT_SYMBOL(mISDN_dsp_element_register);
  
  void mISDN_dsp_element_unregister(struct mISDN_dsp_element *elem)
  {
  	struct dsp_element_entry *entry, *n;
  
  	if (!elem)
  		return;
  
  	list_for_each_entry_safe(entry, n, &dsp_elements, list)
  		if (entry->elem == elem) {

  			device_unregister(&entry->dev);

  #ifdef PIPELINE_DEBUG

  			printk(KERN_DEBUG "%s: %s unregistered
  ",
  				__func__, elem->name);

  #endif

  			return;
  		}
  	printk(KERN_ERR "%s: element %s not in list.
  ", __func__, elem->name);
  }
  EXPORT_SYMBOL(mISDN_dsp_element_unregister);
  
  int dsp_pipeline_module_init(void)
  {
  	elements_class = class_create(THIS_MODULE, "dsp_pipeline");
  	if (IS_ERR(elements_class))
  		return PTR_ERR(elements_class);
  
  #ifdef PIPELINE_DEBUG
  	printk(KERN_DEBUG "%s: dsp pipeline module initialized
  ", __func__);
  #endif
  
  	dsp_hwec_init();
  
  	return 0;
  }
  
  void dsp_pipeline_module_exit(void)
  {
  	struct dsp_element_entry *entry, *n;
  
  	dsp_hwec_exit();
  
  	class_destroy(elements_class);
  
  	list_for_each_entry_safe(entry, n, &dsp_elements, list) {
  		list_del(&entry->list);
  		printk(KERN_WARNING "%s: element was still registered: %s
  ",
  			__func__, entry->elem->name);
  		kfree(entry);
  	}

  #ifdef PIPELINE_DEBUG

  	printk(KERN_DEBUG "%s: dsp pipeline module exited
  ", __func__);

  #endif

  }
  
  int dsp_pipeline_init(struct dsp_pipeline *pipeline)
  {
  	if (!pipeline)
  		return -EINVAL;
  
  	INIT_LIST_HEAD(&pipeline->list);
  
  #ifdef PIPELINE_DEBUG
  	printk(KERN_DEBUG "%s: dsp pipeline ready
  ", __func__);
  #endif
  
  	return 0;
  }
  
  static inline void _dsp_pipeline_destroy(struct dsp_pipeline *pipeline)
  {
  	struct dsp_pipeline_entry *entry, *n;
  
  	list_for_each_entry_safe(entry, n, &pipeline->list, list) {
  		list_del(&entry->list);
  		if (entry->elem == dsp_hwec)
  			dsp_hwec_disable(container_of(pipeline, struct dsp,
  				pipeline));
  		else
  			entry->elem->free(entry->p);
  		kfree(entry);
  	}
  }
  
  void dsp_pipeline_destroy(struct dsp_pipeline *pipeline)
  {
  
  	if (!pipeline)
  		return;
  
  	_dsp_pipeline_destroy(pipeline);
  
  #ifdef PIPELINE_DEBUG
  	printk(KERN_DEBUG "%s: dsp pipeline destroyed
  ", __func__);
  #endif
  }
  
  int dsp_pipeline_build(struct dsp_pipeline *pipeline, const char *cfg)
  {
  	int len, incomplete = 0, found = 0;
  	char *dup, *tok, *name, *args;
  	struct dsp_element_entry *entry, *n;
  	struct dsp_pipeline_entry *pipeline_entry;
  	struct mISDN_dsp_element *elem;
  
  	if (!pipeline)
  		return -EINVAL;
  
  	if (!list_empty(&pipeline->list))
  		_dsp_pipeline_destroy(pipeline);
  
  	if (!cfg)
  		return 0;
  
  	len = strlen(cfg);
  	if (!len)
  		return 0;

  	dup = kmalloc(len + 1, GFP_ATOMIC);

  	if (!dup)
  		return 0;
  	strcpy(dup, cfg);
  	while ((tok = strsep(&dup, "|"))) {
  		if (!strlen(tok))
  			continue;
  		name = strsep(&tok, "(");
  		args = strsep(&tok, ")");
  		if (args && !*args)

  			args = NULL;

  
  		list_for_each_entry_safe(entry, n, &dsp_elements, list)
  			if (!strcmp(entry->elem->name, name)) {
  				elem = entry->elem;
  
  				pipeline_entry = kmalloc(sizeof(struct

  					dsp_pipeline_entry), GFP_ATOMIC);

  				if (!pipeline_entry) {

  					printk(KERN_ERR "%s: failed to add "

  					    "entry to pipeline: %s (out of "
  					    "memory)
  ", __func__, elem->name);
  					incomplete = 1;
  					goto _out;
  				}
  				pipeline_entry->elem = elem;
  
  				if (elem == dsp_hwec) {
  					/* This is a hack to make the hwec
  					   available as a pipeline module */
  					dsp_hwec_enable(container_of(pipeline,
  						struct dsp, pipeline), args);
  					list_add_tail(&pipeline_entry->list,
  						&pipeline->list);
  				} else {
  					pipeline_entry->p = elem->new(args);
  					if (pipeline_entry->p) {
  						list_add_tail(&pipeline_entry->
  							list, &pipeline->list);
  #ifdef PIPELINE_DEBUG
  						printk(KERN_DEBUG "%s: created "
  						    "instance of %s%s%s
  ",
  						    __func__, name, args ?
  						    " with args " : "", args ?
  						    args : "");
  #endif
  					} else {

  						printk(KERN_ERR "%s: failed "

  						  "to add entry to pipeline: "
  						  "%s (new() returned NULL)
  ",
  						  __func__, elem->name);
  						kfree(pipeline_entry);
  						incomplete = 1;
  					}
  				}
  				found = 1;
  				break;
  			}
  
  		if (found)
  			found = 0;
  		else {

  			printk(KERN_ERR "%s: element not found, skipping: "

  				"%s
  ", __func__, name);
  			incomplete = 1;
  		}
  	}
  
  _out:
  	if (!list_empty(&pipeline->list))
  		pipeline->inuse = 1;
  	else
  		pipeline->inuse = 0;
  
  #ifdef PIPELINE_DEBUG
  	printk(KERN_DEBUG "%s: dsp pipeline built%s: %s
  ",
  		__func__, incomplete ? " incomplete" : "", cfg);
  #endif
  	kfree(dup);
  	return 0;
  }
  
  void dsp_pipeline_process_tx(struct dsp_pipeline *pipeline, u8 *data, int len)
  {
  	struct dsp_pipeline_entry *entry;
  
  	if (!pipeline)
  		return;
  
  	list_for_each_entry(entry, &pipeline->list, list)
  		if (entry->elem->process_tx)
  			entry->elem->process_tx(entry->p, data, len);
  }

  void dsp_pipeline_process_rx(struct dsp_pipeline *pipeline, u8 *data, int len,
  	unsigned int txlen)

  {
  	struct dsp_pipeline_entry *entry;
  
  	if (!pipeline)
  		return;
  
  	list_for_each_entry_reverse(entry, &pipeline->list, list)
  		if (entry->elem->process_rx)

  			entry->elem->process_rx(entry->p, data, len, txlen);

  }