/*

 * Copyright (C) 2009-2010 Felipe Contreras

 *

 * Author: Felipe Contreras <felipe.contreras@gmail.com>

 *

 * This file may be used under the terms of the GNU Lesser General Public

 * License version 2.1, a copy of which is found in LICENSE included in the

 * packaging of this file.

 */

#ifndef DSP_BRIDGE_H

#define DSP_BRIDGE_H

#include <stdbool.h>

#include <stdint.h>

#include <stdlib.h>

#define ALLOCATE_HEAP

#define DSP_MMUFAULT 0x00000010

#define DSP_SYSERROR 0x00000020

#define DSP_NODEMESSAGEREADY 0x00000200

#define MAX_PROFILES 16

#define DSP_MAXNAMELEN 32

struct dsp_uuid {

	uint32_t field_1;

	uint16_t field_2;

	uint16_t field_3;

	uint8_t field_4;

	uint8_t field_5;

	uint8_t field_6[6];

};

struct dsp_node {

	void *handle;

	void *heap;

	void *msgbuf_addr;

	size_t msgbuf_size;

};

/* note: cmd = 0x20000000 has special handling */

struct dsp_msg {

	uint32_t cmd;

	uint32_t arg_1;

	uint32_t arg_2;

};

struct dsp_notification {

	char *name;

	void *handle;

};

struct dsp_node_attr_in {

	unsigned long cb;

	int priority;

	unsigned int timeout;

	unsigned int profile_id;

	unsigned int heap_size;

	void *gpp_va;

};

enum dsp_dcd_object_type {

	DSP_DCD_NODETYPE,

	DSP_DCD_PROCESSORTYPE,

	DSP_DCD_LIBRARYTYPE,

	DSP_DCD_CREATELIBTYPE,

	DSP_DCD_EXECUTELIBTYPE,

	DSP_DCD_DELETELIBTYPE,

};

enum dsp_node_type {

	DSP_NODE_DEVICE,

	DSP_NODE_TASK,

	DSP_NODE_DAISSOCKET,

	DSP_NODE_MESSAGE,

};

#ifdef ALLOCATE_HEAP

/* The dsp_resourcereqmts structure for node's resource requirements */

struct dsp_resourcereqmts {

	uint32_t cb_struct;

	uint32_t static_data_size;

	uint32_t global_data_size;

	uint32_t program_mem_size;

	uint32_t uwc_execution_time;

	uint32_t uwc_period;

	uint32_t uwc_deadline;

	uint32_t avg_exection_time;

	uint32_t minimum_period;

};

struct dsp_nodeprofs {

	uint32_t heap_size;

};

/* The dsp_ndb_props structure reports the attributes of a node */

struct dsp_ndb_props {

	uint32_t cb_struct;

	struct dsp_uuid node_id;

	char ac_name[DSP_MAXNAMELEN];

	enum dsp_node_type ntype;

	uint32_t cache_on_gpp;

	struct dsp_resourcereqmts dsp_resource_reqmts;

	int32_t prio;

	uint32_t stack_size;

	uint32_t sys_stack_size;

	uint32_t stack_seg;

	uint32_t message_depth;

	uint32_t num_input_streams;

	uint32_t num_output_streams;

	uint32_t timeout;

	uint32_t count_profiles; /* Number of supported profiles */

	struct dsp_nodeprofs node_profiles[MAX_PROFILES]; /* Array of profiles */

	uint32_t stack_seg_name; /* Stack Segment Name */

};

#endif

enum dsp_resource {

	DSP_RESOURCE_DYNDARAM = 0,

	DSP_RESOURCE_DYNSARAM,

	DSP_RESOURCE_DYNEXTERNAL,

	DSP_RESOURCE_DYNSRAM,

	DSP_RESOURCE_PROCLOAD,

};

struct dsp_info {

	unsigned long cb;

	enum dsp_resource type;

	union {

		unsigned long resource;

		struct {

			unsigned long size;

			unsigned long total_free_size;

			unsigned long len_max_free_block;

			unsigned long free_blocks;

			unsigned long alloc_blocks;

		} mem;

		struct {

			unsigned long load;

			unsigned long pred_load;

			unsigned long freq;

			unsigned long pred_freq;

		} proc;

	} result;

};

enum dsp_connect_type {

	CONNECTTYPE_NODEOUTPUT,

	CONNECTTYPE_GPPOUTPUT,

	CONNECTTYPE_NODEINPUT,

	CONNECTTYPE_GPPINPUT

};

struct dsp_stream_connect {

	unsigned long cb;

	enum dsp_connect_type type;

	unsigned int index;

	void *node_handle;

	struct dsp_uuid node_id;

	unsigned int stream_index;

};

enum dsp_stream_mode {

	STRMMODE_PROCCOPY,

	STRMMODE_ZEROCOPY,

	STRMMODE_LDMA,

	STRMMODE_RDMA

};

struct dsp_stream_attr {

	unsigned int seg_id;

	unsigned int buf_size;

	unsigned int num_bufs;

	unsigned int alignment;

	unsigned int timeout;

	enum dsp_stream_mode mode;

	unsigned int dma_chnl_id;

	unsigned int dma_priority;

};

struct dsp_stream_attr_in {

	unsigned long cb;

	unsigned int timeout;

	unsigned int segment;

	unsigned int alignment;

	unsigned int num_bufs;

	enum dsp_stream_mode mode;

	unsigned int dma_chnl_id;

	unsigned int dma_priority;

};

enum dsp_stream_state {

	STREAM_IDLE,

	STREAM_READY,

	STREAM_PENDING,

	STREAM_DONE

};

struct dsp_stream_info {

	unsigned long cb;

	unsigned int num_bufs_allowed;

	unsigned int num_bufs_in_stream;

	unsigned long num_bytes;

	void *sync_handle;

	enum dsp_stream_state state;

};

enum dsp_node_state {

	NODE_ALLOCATED,

	NODE_CREATED,

	NODE_RUNNING,

	NODE_PAUSED,

	NODE_DONE

};

struct dsp_node_info {

	unsigned long cb;

	struct dsp_ndb_props props;

	unsigned int priority;

	enum dsp_node_state state;

	void *owner;

	unsigned int num_streams;

	struct dsp_stream_connect streams[16];

	unsigned int node_env;

};

struct dsp_node_attr {

	unsigned long cb;

	struct dsp_node_attr_in attr_in;

	unsigned long inputs;

	unsigned long outputs;

	struct dsp_node_info info;

};

int dsp_open(void);

int dsp_close(int handle);

bool dsp_attach(int handle,

		unsigned int num,

		const void *info,

		void **ret_handle);

bool dsp_detach(int handle,

		void *proc_handle);

bool dsp_start(int handle,

		void *proc_handle);

bool dsp_stop(int handle,

		void *proc_handle);

bool dsp_load(int handle,

		void *proc_handle,

		int argc, char **argv,

		char **env);

bool dsp_node_allocate(int handle,

		void *proc_handle,

		const struct dsp_uuid *node_uuid,

		const void *cb_data,

		struct dsp_node_attr_in *attrs,

		struct dsp_node **ret_node);

bool dsp_node_free(int handle,

		struct dsp_node *node);

bool dsp_node_connect(int handle,

		struct dsp_node *node,

		unsigned int stream,

		struct dsp_node *other_node,

		unsigned int other_stream,

		struct dsp_stream_attr *attrs,

		void *params);

bool dsp_node_create(int handle,

		struct dsp_node *node);

bool dsp_node_run(int handle,

		struct dsp_node *node);

bool dsp_node_terminate(int handle,

		struct dsp_node *node,

		unsigned long *status);

bool dsp_node_put_message(int handle,

		struct dsp_node *node,

		const struct dsp_msg *message,

		unsigned int timeout);

bool dsp_node_get_message(int handle,

		struct dsp_node *node,

		struct dsp_msg *message,

		unsigned int timeout);

bool dsp_reserve(int handle,

		void *proc_handle,

		unsigned long size,

		void **addr);

bool dsp_unreserve(int handle,

		void *proc_handle,

		void *addr);

bool dsp_map(int handle,

		void *proc_handle,

		void *mpu_addr,

		unsigned long size,

		void *req_addr,

		void *ret_map_addr,

		unsigned long attr);

bool dsp_unmap(int handle,

		void *proc_handle,

		void *map_addr);

bool dsp_flush(int handle,

		void *proc_handle,

		void *mpu_addr,

		unsigned long size,

		unsigned long flags);

bool dsp_invalidate(int handle,

		void *proc_handle,

		void *mpu_addr,

		unsigned long size);

bool dsp_register_notify(int handle,

		void *proc_handle,

		unsigned int event_mask,

		unsigned int notify_type,

		struct dsp_notification *info);

bool dsp_node_register_notify(int handle,

		struct dsp_node *node,

		unsigned int event_mask,

		unsigned int notify_type,

		struct dsp_notification *info);

bool dsp_wait_for_events(int handle,

		struct dsp_notification **notifications,

		unsigned int count,

		unsigned int *ret_index,

		unsigned int timeout);

bool dsp_enum(int handle,

		unsigned int num,

		struct dsp_ndb_props *info,

		size_t info_size,

		unsigned int *ret_num);

bool dsp_register(int handle,

		const struct dsp_uuid *uuid,

		enum dsp_dcd_object_type type,

		const char *path);

bool dsp_unregister(int handle,

		const struct dsp_uuid *uuid,

		enum dsp_dcd_object_type type);

bool dsp_proc_get_info(int handle,

		void *proc_handle,

		enum dsp_resource type,

		struct dsp_info *info,

		unsigned size);

static inline bool

dsp_send_message(int handle,

		struct dsp_node *node,

		uint32_t cmd,

		uint32_t arg_1,

		uint32_t arg_2)

{

	struct dsp_msg msg;

	msg.cmd = cmd;

	msg.arg_1 = arg_1;

	msg.arg_2 = arg_2;

	return dsp_node_put_message(handle, node, &msg, -1);

}

bool dsp_node_get_attr(int handle,

		struct dsp_node *node,

		struct dsp_node_attr *attr,

		size_t attr_size);

bool dsp_enum_nodes(int handle,

		void *proc_handle,

		void **node_table,

		unsigned node_table_size,

		unsigned *num_nodes,

		unsigned *allocated);

bool dsp_stream_open(int handle,

		struct dsp_node *node,

		unsigned int direction,

		unsigned int index,

		struct dsp_stream_attr_in *attrin,

		void *stream);

bool dsp_stream_close(int handle,

		void *stream);

bool dsp_stream_idle(int handle,

		void *stream,

		bool flush);

bool dsp_stream_reclaim(int handle,

		void *stream,

		unsigned char **buff,

		unsigned long *data_size,

		unsigned long *buff_size,

		unsigned long *args);

bool dsp_stream_issue(int handle,

		void *stream,

		unsigned char *buff,

		unsigned long data_size,

		unsigned long buff_size,

		unsigned long arg);

bool dsp_stream_get_info(int handle,

		void *stream,

		struct dsp_stream_info *info,

		unsigned int size);

bool dsp_stream_allocate_buffers(int handle,

		void *stream,

		unsigned int size,

		unsigned char **buff,

		unsigned int num_buf);

bool dsp_stream_free_buffers(int handle,

		void *stream,

		unsigned char **buff,

		unsigned int num_buf);

#endif /* DSP_BRIDGE_H */