/*

 *  EMU10k1 loader

 *

 *  Copyright (c) 2003,2004 by Peter Zubaj

 *

 *   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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <alsa/asoundlib.h>

#include <signal.h>

#include "ld10k1.h"

#include "ld10k1_fnc.h"

#include "ld10k1_fnc_int.h"

#include "ld10k1_debug.h"

#include "ld10k1_error.h"

#include "ld10k1_dump.h"

#include "ld10k1_driver.h"

#include "ld10k1_mixer.h"

#include "comm.h"

void ld10k1_fnc_prepare_free();

int ld10k1_fnc_patch_add(int data_conn, int op, int size);

int ld10k1_fnc_patch_del(int data_conn, int op, int size);

int ld10k1_fnc_patch_conn(int data_conn, int op, int size);

int ld10k1_fnc_name_find(int data_conn, int op, int size);

int ld10k1_fnc_name_rename(int data_conn, int op, int size);

int ld10k1_fnc_dsp_init(int data_conn, int op, int size);

int ld10k1_fnc_get_io_count(int data_conn, int op, int size);

int ld10k1_fnc_get_io(int data_conn, int op, int size);

int ld10k1_fnc_get_pio_count(int data_conn, int op, int size);

int ld10k1_fnc_get_pio(int data_conn, int op, int size);

int ld10k1_fnc_get_patches_info(int data_conn, int op, int size);

int ld10k1_fnc_get_patch(int data_conn, int op, int size);

int ld10k1_fnc_dump(int data_conn, int op, int size);

int ld10k1_fnc_version(int data_conn, int op, int size);

int ld10k1_fnc_get_points_info(int data_conn, int op, int size);

int ld10k1_fnc_get_point_info(int data_conn, int op, int size);

int ld10k1_fnc_get_dsp_info(int data_conn, int op, int size);

ld10k1_dsp_mgr_t dsp_mgr;

struct fnc_table_t

{

	int fnc;

	int min_size;

	int max_size;

	int (*fnc_code)(int data_conn, int op, int size);

};

struct fnc_table_t fnc_table[] =

{

	{FNC_PATCH_ADD, sizeof(ld10k1_fnc_patch_add_t), sizeof(ld10k1_fnc_patch_add_t), ld10k1_fnc_patch_add},

	{FNC_PATCH_DEL, sizeof(ld10k1_fnc_patch_del_t), sizeof(ld10k1_fnc_patch_del_t), ld10k1_fnc_patch_del},

	{FNC_CONNECTION_ADD, sizeof(ld10k1_fnc_connection_t), sizeof(ld10k1_fnc_connection_t), ld10k1_fnc_patch_conn},

	{FNC_CONNECTION_DEL, sizeof(ld10k1_fnc_connection_t), sizeof(ld10k1_fnc_connection_t), ld10k1_fnc_patch_conn},

	{FNC_DEBUG, sizeof(ld10k1_fnc_debug_t), sizeof(ld10k1_fnc_debug_t), ld10k1_fnc_debug},

	{FNC_PATCH_RENAME, sizeof(ld10k1_fnc_name_t), sizeof(ld10k1_fnc_name_t), ld10k1_fnc_name_rename},

	{FNC_PATCH_FIND, sizeof(ld10k1_fnc_name_t), sizeof(ld10k1_fnc_name_t), ld10k1_fnc_name_find},

	{FNC_FX_FIND, sizeof(ld10k1_fnc_name_t), sizeof(ld10k1_fnc_name_t), ld10k1_fnc_name_find},

	{FNC_IN_FIND, sizeof(ld10k1_fnc_name_t), sizeof(ld10k1_fnc_name_t), ld10k1_fnc_name_find},

	{FNC_OUT_FIND, sizeof(ld10k1_fnc_name_t), sizeof(ld10k1_fnc_name_t), ld10k1_fnc_name_find},

	{FNC_PATCH_IN_FIND, sizeof(ld10k1_fnc_name_t), sizeof(ld10k1_fnc_name_t), ld10k1_fnc_name_find},

	{FNC_PATCH_OUT_FIND, sizeof(ld10k1_fnc_name_t), sizeof(ld10k1_fnc_name_t), ld10k1_fnc_name_find},

	{FNC_FX_RENAME, sizeof(ld10k1_fnc_name_t), sizeof(ld10k1_fnc_name_t), ld10k1_fnc_name_rename},

	{FNC_IN_RENAME, sizeof(ld10k1_fnc_name_t), sizeof(ld10k1_fnc_name_t), ld10k1_fnc_name_rename},

	{FNC_OUT_RENAME, sizeof(ld10k1_fnc_name_t), sizeof(ld10k1_fnc_name_t), ld10k1_fnc_name_rename},

	{FNC_PATCH_IN_RENAME, sizeof(ld10k1_fnc_name_t), sizeof(ld10k1_fnc_name_t), ld10k1_fnc_name_rename},

	{FNC_PATCH_OUT_RENAME, sizeof(ld10k1_fnc_name_t), sizeof(ld10k1_fnc_name_t), ld10k1_fnc_name_rename},

	{FNC_GET_FX_COUNT, 0, 0, ld10k1_fnc_get_io_count},

	{FNC_GET_IN_COUNT, 0, 0, ld10k1_fnc_get_io_count},

	{FNC_GET_OUT_COUNT, 0, 0, ld10k1_fnc_get_io_count},

	{FNC_GET_PIN_COUNT, sizeof(int), sizeof(int), ld10k1_fnc_get_pio_count},

	{FNC_GET_POUT_COUNT, sizeof(int), sizeof(int), ld10k1_fnc_get_pio_count},

	{FNC_GET_FX, sizeof(int), sizeof(int), ld10k1_fnc_get_io},

	{FNC_GET_IN, sizeof(int), sizeof(int), ld10k1_fnc_get_io},

	{FNC_GET_OUT, sizeof(int), sizeof(int), ld10k1_fnc_get_io},

	{FNC_GET_PIN, sizeof(int) * 2, sizeof(int) * 2, ld10k1_fnc_get_pio},

	{FNC_GET_POUT, sizeof(int) * 2, sizeof(int) * 2, ld10k1_fnc_get_pio},

	{FNC_GET_PATCHES_INFO, 0, 0, ld10k1_fnc_get_patches_info},

	{FNC_GET_PATCH, sizeof(int), sizeof(int), ld10k1_fnc_get_patch},

	{FNC_DSP_INIT, 0, 0, ld10k1_fnc_dsp_init},

	{FNC_DUMP, 0, 0, ld10k1_fnc_dump},

	{FNC_VERSION, 0, 0, ld10k1_fnc_version},

	{FNC_GET_POINTS_INFO, 0, 0, ld10k1_fnc_get_points_info},

	{FNC_GET_POINT_INFO, sizeof(int), sizeof(int), ld10k1_fnc_get_point_info},

	{FNC_GET_DSP_INFO, 0, 0, ld10k1_fnc_get_dsp_info},

	{-1, 0, 0, NULL}

};

ld10k1_dsp_mgr_t dsp_mgr;

int send_response_ok(int conn_num)

{

	return send_response(conn_num, FNC_OK, 0, NULL, 0);

}

int send_response_err(int conn_num, int err)

{

	return send_response(conn_num, FNC_ERR, err, NULL, 0);

}

int send_response_wd(int conn_num, void *data, int data_size)

{

	return send_response(conn_num, FNC_OK, 0, data, data_size);

}

struct ClientDefTag

{

	int used;

	int socket;

};

typedef struct ClientDefTag ClientDef;

#define MAX_CLIENTS 10

ClientDef clients[MAX_CLIENTS];

int clients_count = 0;

static void client_init()

{

	int i;

	for (i = 0; i < MAX_CLIENTS; i++)

		clients[i].used = 0;

	clients_count = 0;

}

static int client_add()

{

	int i;

	for (i = 0; i < MAX_CLIENTS; i++)

		if (clients[i].used == 0) {

			clients[i].used = 1;

			clients_count++;

			return i;

		}

	return -1;

}

static void client_del(int client)

{

    if (client >= 0 && client < MAX_CLIENTS && clients[client].used == 1) {

	clients[client].used = 0;

	clients_count--;

    }

}

static int client_find_by_socket(int socket)

{

	int i;

	for (i = 0; i < MAX_CLIENTS; i++)

		if (clients[i].socket == socket)

			return i;

	return -1;

}

int main_loop(comm_param *param, int audigy, const char *card_id, int tram_size, snd_ctl_t *ctlp)

{

	fd_set active_fd_set/*, read_fd_set*/;

	int i, j, res = 0;

	__sighandler_t old_sig_pipe;

	int main_sock = 0;

	int data_sock = 0;

	int new_client = 0;

	int op = 0;

	int data_size = 0;

	int retval = 0;

	dsp_mgr.audigy = audigy;

	dsp_mgr.card_id = card_id;

	if (ld10k1_dsp_mgr_init(&dsp_mgr))

		return -1;

	/* initialize id generators */

	ld10k1_dsp_mgr_init_id_gen(&dsp_mgr);

	if (ld10k1_init_driver(&dsp_mgr, tram_size) < 0) {

		ld10k1_dsp_mgr_free(&dsp_mgr);

		return -1;

	}

	if (ld10k1_init_reserved_ctls(&dsp_mgr, ctlp) < 0) {

		ld10k1_dsp_mgr_free(&dsp_mgr);

		return -1;

	}

	old_sig_pipe = signal(SIGPIPE, SIG_IGN);

	param->server = 1;

	if ((main_sock = setup_comm(param)) < 0)

		goto error;

	if (listen_comm(main_sock))

		goto error;

	/* Initialize the set of active sockets. */

	client_init();

	while (1) {

		/* Block until input arrives on one or more active sockets. */

		FD_ZERO (&active_fd_set);

		FD_SET (main_sock, &active_fd_set);

		for (i = 0; i < MAX_CLIENTS; i++)

			if (clients[i].used)

				FD_SET(clients[i].socket, &active_fd_set);

		if (select(FD_SETSIZE, &active_fd_set, NULL, NULL, NULL) < 0)

			goto error;

		for (i = 0; i < FD_SETSIZE; i++)

			if (FD_ISSET (i, &active_fd_set))	{

				if (i == main_sock)	{

					/* Connection request on original socket. */

					if ((data_sock = accept_comm(main_sock)) < 0)

						goto error;

					new_client = client_add();

					if (new_client < 0)

						free_comm(data_sock);

					else

						clients[new_client].socket = data_sock;

						/*FD_SET(data_sock, &active_fd_set);*/

				} else {

					/* Data arriving on an already-connected socket. */

					if (receive_request(i, &op, &data_size))

						/*goto error;*/

						op = -1; /* probably client closes */

					if (op == FNC_CLOSE_CONN) {

						/* wait some time */

						usleep(10000);

						goto e_close;

					}

					if (op >= 0) {

						/* search in function table */

						res = 1;

						for (j = 0; fnc_table[j].fnc >= 0; j++)	{

							if ((fnc_table[j].fnc == op) &&

								(data_size >= fnc_table[j].min_size) &&

								(data_size <= fnc_table[j].max_size)) {

								res = (*fnc_table[j].fnc_code)(i, op, data_size);

								break;

							}

						}

						if (!res) {

							if (send_response(i, FNC_OK, 0, NULL, 0) < 0)

								goto e_close;

						} else {

							if (send_response(i, FNC_ERR, res, NULL, 0) < 0)

								goto e_close;

						}

					} else {

e_close:

						if (op != FNC_CLOSE_CONN)

							printf("error protocol fnc:%d - %d\n", op, res);

						client_del(client_find_by_socket(i));

						/*FD_CLR (i, &active_fd_set);*/

						/* close connection */

						if (free_comm(i))

							data_sock = 0;

					}

				}

			}

	}

end:

	signal(SIGPIPE, old_sig_pipe);

	for (i = 0; i < MAX_CLIENTS; i++)

		if (clients[i].used) {

			client_del(i);

			free_comm(clients[i].socket);

		}

	free_comm(main_sock);

	ld10k1_free_reserved_ctls(&dsp_mgr);

	ld10k1_dsp_mgr_free(&dsp_mgr);

	return retval;

error:

	retval = -1;

	goto end;

}

int ld10k1_fnc_receive_patch_info(int data_conn, ld10k1_dsp_patch_t *new_patch, int *where)

{

	ld10k1_fnc_patch_add_t tmp_info;

	if (receive_msg_data(data_conn, &tmp_info, sizeof(ld10k1_fnc_patch_add_t)) < 0)

		return LD10K1_ERR_PROTOCOL;

	memcpy(new_patch, &(tmp_info.patch), sizeof(ld10k1_dsp_patch_t));

	*where = tmp_info.where;

	new_patch->patch_name[MAX_NAME_LEN - 1] = '\n';

	if (new_patch->in_count < 0 || new_patch->in_count > 32)

		return LD10K1_ERR_PROTOCOL_IN_COUNT;

	if (new_patch->out_count < 0 || new_patch->out_count > 32)

		return LD10K1_ERR_PROTOCOL_OUT_COUNT;

	if (new_patch->const_count < 0 || new_patch->const_count > 255)

		return LD10K1_ERR_PROTOCOL_CONST_COUNT;

	if (new_patch->static_count < 0 || new_patch->static_count > 255)

		return LD10K1_ERR_PROTOCOL_STATIC_COUNT;

	if (new_patch->dynamic_count < 0 || new_patch->dynamic_count > 255)

		return LD10K1_ERR_PROTOCOL_DYNAMIC_COUNT;

	if (new_patch->hw_count < 0 || new_patch->hw_count > 255)

		return LD10K1_ERR_PROTOCOL_HW_COUNT;

	if (new_patch->tram_count < 0 || new_patch->tram_count > 255)

		return LD10K1_ERR_PROTOCOL_TRAM_COUNT;

	if (new_patch->tram_acc_count < 0 || new_patch->tram_acc_count > 255)

		return LD10K1_ERR_PROTOCOL_TRAM_ACC_COUNT;

	if (new_patch->ctl_count < 0 || new_patch->ctl_count > 255)

		return LD10K1_ERR_PROTOCOL_CTL_COUNT;

	if (new_patch->instr_count < 0 || new_patch->instr_count > 512)

		return LD10K1_ERR_PROTOCOL_INSTR_COUNT;

	return send_response_ok(data_conn);

}

int ld10k1_fnc_receive_patch_in(int data_conn, ld10k1_patch_t *new_patch)

{

	ld10k1_dsp_p_in_out_t *new_in = NULL;

	int i;

	int err;

 	if (!new_patch->in_count)

		return 0;

 	if (!(new_in = (ld10k1_dsp_p_in_out_t *)receive_msg_data_malloc(data_conn, sizeof(ld10k1_dsp_p_in_out_t) * new_patch->in_count)))

		return LD10K1_ERR_PROTOCOL;

	/* copy values */

	for (i = 0; i < new_patch->in_count; i++) {

		if (!ld10k1_dsp_mgr_name_new(&(new_patch->ins[i].name), new_in[i].name)) {

			err = LD10K1_ERR_NO_MEM;

			goto error;

		}

	}

	return send_response_ok(data_conn);

error:

	free(new_in);

	return err;

}

int ld10k1_fnc_receive_patch_out(int data_conn, ld10k1_patch_t *new_patch)

{

	ld10k1_dsp_p_in_out_t *new_out = NULL;

	int i;

	int err;

 	if (!new_patch->out_count)

		return 0;

 	if (!(new_out = (ld10k1_dsp_p_in_out_t *)receive_msg_data_malloc(data_conn, sizeof(ld10k1_dsp_p_in_out_t) * new_patch->out_count)))

		return LD10K1_ERR_PROTOCOL;

	/* copy values */

	for (i = 0; i < new_patch->out_count; i++) {

		if (!ld10k1_dsp_mgr_name_new(&(new_patch->outs[i].name), new_out[i].name)) {

			err = LD10K1_ERR_NO_MEM;

			goto error;

		}

	}

	return send_response_ok(data_conn);

error:

	free(new_out);

	return err;

}

int ld10k1_fnc_receive_patch_const(int data_conn, ld10k1_patch_t *new_patch)

{

	ld10k1_dsp_p_const_static_t *new_const = NULL;

	int i;

 	if (!new_patch->const_count)

		return 0;

 	if (!(new_const = (ld10k1_dsp_p_const_static_t *)receive_msg_data_malloc(data_conn, sizeof(ld10k1_dsp_p_const_static_t) * new_patch->const_count)))

		return LD10K1_ERR_PROTOCOL;

	/* copy values */

	for (i = 0; i < new_patch->const_count; i++)

		new_patch->consts[i].const_val = new_const[i].const_val;

	return send_response_ok(data_conn);

}

int ld10k1_fnc_receive_patch_sta(int data_conn, ld10k1_patch_t *new_patch)

{

	ld10k1_dsp_p_const_static_t *new_sta = NULL;

	int i;

 	if (!new_patch->sta_count)

		return 0;

 	if (!(new_sta = (ld10k1_dsp_p_const_static_t *)receive_msg_data_malloc(data_conn, sizeof(ld10k1_dsp_p_const_static_t) * new_patch->sta_count)))

		return LD10K1_ERR_PROTOCOL;

	/* copy values */

	for (i = 0; i < new_patch->sta_count; i++)

		new_patch->stas[i].const_val = new_sta[i].const_val;

	return send_response_ok(data_conn);

}

int ld10k1_fnc_receive_patch_hw(int data_conn, ld10k1_patch_t *new_patch)

{

	ld10k1_dsp_p_hw_t *new_hw = NULL;

	int i;

 	if (!new_patch->hw_count)

		return 0;

 	if (!(new_hw = (ld10k1_dsp_p_hw_t *)receive_msg_data_malloc(data_conn, sizeof(ld10k1_dsp_p_hw_t) * new_patch->hw_count)))

		return LD10K1_ERR_PROTOCOL;

	/* copy values */

	for (i = 0; i < new_patch->hw_count; i++)

		new_patch->hws[i].reg_idx = new_hw[i].hw_val;

	return send_response_ok(data_conn);

}

int ld10k1_fnc_receive_patch_tram_grp(int data_conn, ld10k1_patch_t *new_patch)

{

	ld10k1_dsp_tram_grp_t *new_tram_grp = NULL;

	int i;

 	if (!new_patch->tram_count)

		return 0;

 	if (!(new_tram_grp = (ld10k1_dsp_tram_grp_t *)receive_msg_data_malloc(data_conn, sizeof(ld10k1_dsp_tram_grp_t) * new_patch->tram_count)))

		return LD10K1_ERR_PROTOCOL;

	/* copy values */

	for (i = 0; i < new_patch->tram_count; i++) {

		new_patch->tram_grp[i].grp_type = new_tram_grp[i].grp_type;

		new_patch->tram_grp[i].grp_size = new_tram_grp[i].grp_size;

		new_patch->tram_grp[i].grp_pos = new_tram_grp[i].grp_pos;

	}

	return send_response_ok(data_conn);

}

int ld10k1_fnc_receive_patch_tram_acc(int data_conn, ld10k1_patch_t *new_patch)

{

	ld10k1_dsp_tram_acc_t *new_tram_acc = NULL;

	int i;

 	if (!new_patch->tram_acc_count)

		return 0;

 	if (!(new_tram_acc = (ld10k1_dsp_tram_acc_t *)receive_msg_data_malloc(data_conn, sizeof(ld10k1_dsp_tram_acc_t) * new_patch->tram_acc_count)))

		return LD10K1_ERR_PROTOCOL;

	/* copy values */

	for (i = 0; i < new_patch->tram_acc_count; i++) {

		new_patch->tram_acc[i].acc_type = new_tram_acc[i].acc_type;

		new_patch->tram_acc[i].acc_offset = new_tram_acc[i].acc_offset;

		new_patch->tram_acc[i].grp = new_tram_acc[i].grp;

	}

	return send_response_ok(data_conn);

}

int ld10k1_fnc_receive_patch_ctl(int data_conn, ld10k1_patch_t *new_patch)

{

	ld10k1_dsp_ctl_t *new_ctl = NULL;

	int i, j;

 	if (!new_patch->ctl_count)

		return 0;

 	if (!(new_ctl = (ld10k1_dsp_ctl_t *)receive_msg_data_malloc(data_conn, sizeof(ld10k1_dsp_ctl_t) * new_patch->ctl_count)))

		return LD10K1_ERR_PROTOCOL;

	/* copy values */

	for (i = 0; i < new_patch->ctl_count; i++) {

		strncpy(new_patch->ctl[i].name, new_ctl[i].name, 43);

		new_patch->ctl[i].name[43] = '\0';

		new_patch->ctl[i].index = -1;

		new_patch->ctl[i].want_index = new_ctl[i].index;

		new_patch->ctl[i].count = new_ctl[i].count;

		new_patch->ctl[i].vcount = new_ctl[i].vcount;

		new_patch->ctl[i].min = new_ctl[i].min;

		new_patch->ctl[i].max = new_ctl[i].max;

		new_patch->ctl[i].translation = new_ctl[i].translation;

		for (j = 0; j < new_patch->ctl[i].count; j++)

			new_patch->ctl[i].value[j] = new_ctl[i].value[j];

	}

	return send_response_ok(data_conn);

}

int ld10k1_fnc_receive_patch_instr(int data_conn, ld10k1_patch_t *new_patch)

{

	ld10k1_dsp_instr_t *new_instr = NULL;

	int i, j;

 	if (!new_patch->instr_count)

		return 0;

 	if (!(new_instr = (ld10k1_dsp_instr_t *)receive_msg_data_malloc(data_conn, sizeof(ld10k1_dsp_instr_t) * new_patch->instr_count)))

		return LD10K1_ERR_PROTOCOL;

	/* copy values */

	for (i = 0; i < new_patch->instr_count; i++) {

		new_patch->instr[i].op_code = new_instr[i].op_code;

		for (j = 0; j < 4; j++)

			new_patch->instr[i].arg[j] = new_instr[i].arg[j];

		new_patch->instr[i].used = 1;

		new_patch->instr[i].modified = 1;

	}

	return send_response_ok(data_conn);

}

int ld10k1_fnc_patch_add(int data_conn, int op, int size)

{

	int err;

	int loaded[2];

	int where;

	ld10k1_dsp_patch_t new_patch_info;

	/* allocate new patch */

	ld10k1_patch_t *new_patch = NULL;

	if ((err = ld10k1_fnc_receive_patch_info(data_conn, &new_patch_info, &where)) < 0)

		goto error;

	if (!(new_patch = ld10k1_dsp_mgr_patch_new())) {

		err = LD10K1_ERR_NO_MEM;

		goto error;

	}

	/* name */

	if (!ld10k1_dsp_mgr_name_new(&(new_patch->patch_name), new_patch_info.patch_name)) {

		err = LD10K1_ERR_NO_MEM;

		goto error;

	}

	/* set sizes */

	if (new_patch_info.in_count)

		if (!ld10k1_dsp_mgr_patch_in_new(new_patch, new_patch_info.in_count)) {

			err = LD10K1_ERR_NO_MEM;

			goto error;

		}

	if (new_patch_info.out_count)

		if (!ld10k1_dsp_mgr_patch_out_new(new_patch, new_patch_info.out_count)) {

			err = LD10K1_ERR_NO_MEM;

			goto error;

		}

	if (new_patch_info.const_count)

		if (!ld10k1_dsp_mgr_patch_const_new(new_patch, new_patch_info.const_count)) {

			err = LD10K1_ERR_NO_MEM;

			goto error;

		}

	if (new_patch_info.static_count)

		if (!ld10k1_dsp_mgr_patch_sta_new(new_patch, new_patch_info.static_count)) {

			err = LD10K1_ERR_NO_MEM;

			goto error;

		}

	if (new_patch_info.dynamic_count)

		if (!ld10k1_dsp_mgr_patch_dyn_new(new_patch, new_patch_info.dynamic_count)) {

			err = LD10K1_ERR_NO_MEM;

			goto error;

		}

	if (new_patch_info.hw_count)

		if (!ld10k1_dsp_mgr_patch_hw_new(new_patch, new_patch_info.hw_count)) {

			err = LD10K1_ERR_NO_MEM;

			goto error;

		}

	if (new_patch_info.tram_count)

		if (!ld10k1_dsp_mgr_patch_tram_new(new_patch, new_patch_info.tram_count)) {

			err = LD10K1_ERR_NO_MEM;

			goto error;

		}

	if (new_patch_info.tram_acc_count)

		if (!ld10k1_dsp_mgr_patch_tram_acc_new(new_patch, new_patch_info.tram_acc_count)) {

			err = LD10K1_ERR_NO_MEM;

			goto error;

		}

	if (new_patch_info.ctl_count)

		if (!ld10k1_dsp_mgr_patch_ctl_new(new_patch,new_patch_info.ctl_count)) {

			err = LD10K1_ERR_NO_MEM;

			goto error;

		}

	if (!ld10k1_dsp_mgr_patch_instr_new(new_patch, new_patch_info.instr_count)) {

		err = LD10K1_ERR_NO_MEM;

		goto error;

	}

	/* receive next parts */

	if (new_patch_info.in_count)

		if ((err = ld10k1_fnc_receive_patch_in(data_conn, new_patch)) < 0)

			goto error;

	if (new_patch_info.out_count)

		if ((err = ld10k1_fnc_receive_patch_out(data_conn, new_patch)) < 0)

			goto error;

	if (new_patch_info.const_count)

		if ((err = ld10k1_fnc_receive_patch_const(data_conn, new_patch)) < 0)

			goto error;

	if (new_patch_info.static_count)

		if ((err = ld10k1_fnc_receive_patch_sta(data_conn, new_patch)) < 0)

			goto error;

	if (new_patch_info.hw_count)

		if ((err = ld10k1_fnc_receive_patch_hw(data_conn, new_patch)) < 0)

			goto error;

	if (new_patch_info.tram_count)

		if ((err = ld10k1_fnc_receive_patch_tram_grp(data_conn, new_patch)) < 0)

			goto error;

	if (new_patch_info.tram_acc_count)

		if ((err = ld10k1_fnc_receive_patch_tram_acc(data_conn, new_patch)) < 0)

			goto error;

	if (new_patch_info.ctl_count)

		if ((err = ld10k1_fnc_receive_patch_ctl(data_conn, new_patch)) < 0)

			goto error;

	if ((err = ld10k1_fnc_receive_patch_instr(data_conn, new_patch)) < 0)

		goto error;

	/* check patch */

	if ((err = ld10k1_patch_fnc_check_patch(&dsp_mgr, new_patch)) < 0)

		goto error;

	/* load patch */

	if ((err = ld10k1_dsp_mgr_patch_load(&dsp_mgr, new_patch, where, loaded)) < 0)

		goto error;

	if ((err = send_response_wd(data_conn, loaded, sizeof(loaded))) < 0)

		return err;

	return 0;

error:

	if (new_patch)

		ld10k1_dsp_mgr_patch_free(new_patch);

	return err;

}

int ld10k1_fnc_patch_del(int data_conn, int op, int size)

{

	ld10k1_fnc_patch_del_t patch_info;

	int err;

	if ((err = receive_msg_data(data_conn, &patch_info, sizeof(ld10k1_fnc_patch_del_t))) < 0)

		return err;

	return ld10k1_patch_fnc_del(&dsp_mgr, &patch_info);

}

int ld10k1_fnc_patch_conn(int data_conn, int op, int size)

{

	ld10k1_fnc_connection_t connection_info;

	int err;

	int conn_id;

	if ((err = receive_msg_data(data_conn, &connection_info, sizeof(ld10k1_fnc_connection_t))) < 0)

		return err;

	if ((err = ld10k1_connection_fnc(&dsp_mgr, &connection_info, &conn_id)) < 0)

		return err;

	return send_response_wd(data_conn, &conn_id, sizeof(conn_id));

}

int ld10k1_fnc_name_find(int data_conn, int op, int size)

{

	ld10k1_fnc_name_t name_info;

	int i;

	static int ret;

	int err;

	ld10k1_patch_t *patch;

	ret = -1;

	if ((err = receive_msg_data(data_conn, &name_info, sizeof(ld10k1_fnc_name_t))) < 0)

		return err;

	name_info.name[MAX_NAME_LEN - 1] = '\0';

	switch (op)	{

		case FNC_PATCH_FIND:

			for (i = 0; i < EMU10K1_PATCH_MAX ; i++)

				if (dsp_mgr.patch_ptr[i])

					if (strcmp(dsp_mgr.patch_ptr[i]->patch_name, name_info.name) == 0) {

						ret = i;

						break;

					}

			break;

		case FNC_FX_FIND:

			for (i = 0; i < dsp_mgr.fx_count ; i++)

				if (dsp_mgr.fxs[i].name)

					if (strcmp(dsp_mgr.fxs[i].name, name_info.name) == 0) {

						ret = i;

						break;

					}

			break;

		case FNC_IN_FIND:

			for (i = 0; i < dsp_mgr.in_count ; i++)

				if (dsp_mgr.ins[i].name)

					if (strcmp(dsp_mgr.ins[i].name, name_info.name) == 0) {

						ret = i;

						break;

					}

			break;

		case FNC_OUT_FIND:

			for (i = 0; i < dsp_mgr.out_count ; i++)

				if (dsp_mgr.outs[i].name)

					if (strcmp(dsp_mgr.outs[i].name, name_info.name) == 0) {

						ret = i;

						break;

					}

			break;

		case FNC_PATCH_IN_FIND :

			if (name_info.patch_num >= 0 || name_info.patch_num < EMU10K1_PATCH_MAX) {

				patch = dsp_mgr.patch_ptr[name_info.patch_num];

				if (patch)

					for (i = 0; i < patch->in_count ; i++)

						if (patch->ins[i].name)

							if (strcmp(patch->ins[i].name, name_info.name) == 0) {

								ret = i;

								break;

							}

			}

			break;

		case FNC_PATCH_OUT_FIND :

			if (name_info.patch_num >= 0 || name_info.patch_num < EMU10K1_PATCH_MAX) {

				patch = dsp_mgr.patch_ptr[name_info.patch_num];

				if (patch)

					for (i = 0; i < patch->out_count ; i++)

						if (patch->outs[i].name)

							if (strcmp(patch->outs[i].name, name_info.name) == 0) {

								ret = i;

								break;

							}

			}

			break;

	}

	return send_response_wd(data_conn, &ret, sizeof(ret));

}

int ld10k1_fnc_name_rename(int data_conn, int op, int size)

{

	ld10k1_fnc_name_t name_info;

	int ret;

	int err;

	ld10k1_patch_t *patch;

	ret = -1;

	if ((err = receive_msg_data(data_conn, &name_info, sizeof(ld10k1_fnc_name_t))) < 0)

		return err;

	name_info.name[MAX_NAME_LEN - 1] = '\0';

	switch (op)	{

		case FNC_PATCH_RENAME:

			if (name_info.patch_num >= 0 || name_info.patch_num < EMU10K1_PATCH_MAX) {

				patch = dsp_mgr.patch_ptr[name_info.patch_num];

				if (patch) {

					if (!ld10k1_dsp_mgr_name_new(&(patch->patch_name), name_info.name))

						return LD10K1_ERR_PATCH_RENAME;

				} else

					return LD10K1_ERR_UNKNOWN_PATCH_NUM;

			} else

				return LD10K1_ERR_UNKNOWN_PATCH_NUM;

			break;

		case FNC_FX_RENAME:

			if (name_info.gpr < 0 || name_info.gpr >= dsp_mgr.fx_count)

				return LD10K1_ERR_UNKNOWN_REG_NUM;

			if (!ld10k1_dsp_mgr_name_new(&(dsp_mgr.fxs[name_info.gpr].name), name_info.name))

				return LD10K1_ERR_REG_RENAME;

			break;

		case FNC_IN_RENAME:

			if (name_info.gpr < 0 || name_info.gpr >= dsp_mgr.in_count)

				return LD10K1_ERR_UNKNOWN_REG_NUM;

			if (!ld10k1_dsp_mgr_name_new(&(dsp_mgr.ins[name_info.gpr].name), name_info.name))

				return LD10K1_ERR_REG_RENAME;

			break;

		case FNC_OUT_RENAME:

			if (name_info.gpr < 0 || name_info.gpr >= dsp_mgr.out_count)

				return LD10K1_ERR_UNKNOWN_REG_NUM;

			if (!ld10k1_dsp_mgr_name_new(&(dsp_mgr.outs[name_info.gpr].name), name_info.name))

				return LD10K1_ERR_REG_RENAME;

			break;

		case FNC_PATCH_IN_RENAME:

			if (name_info.patch_num >= 0 || name_info.patch_num < EMU10K1_PATCH_MAX) {

				patch = dsp_mgr.patch_ptr[name_info.patch_num];

				if (patch) {

					if (name_info.gpr < 0 || name_info.gpr >= patch->in_count)

						return LD10K1_ERR_UNKNOWN_PATCH_REG_NUM;

					if (!ld10k1_dsp_mgr_name_new(&(patch->ins[name_info.gpr].name), name_info.name))

						return LD10K1_ERR_PATCH_REG_RENAME;

				} else

					return LD10K1_ERR_UNKNOWN_PATCH_NUM;

			} else

				return LD10K1_ERR_UNKNOWN_PATCH_NUM;

			break;

		case FNC_PATCH_OUT_RENAME:

			if (name_info.patch_num >= 0 || name_info.patch_num < EMU10K1_PATCH_MAX) {

				patch = dsp_mgr.patch_ptr[name_info.patch_num];

				if (patch) {

					if (name_info.gpr < 0 || name_info.gpr >= patch->out_count)

						return LD10K1_ERR_UNKNOWN_PATCH_REG_NUM;

					if (!ld10k1_dsp_mgr_name_new(&(patch->outs[name_info.gpr].name), name_info.name))

						return LD10K1_ERR_PATCH_REG_RENAME;

				} else

					return LD10K1_ERR_UNKNOWN_PATCH_NUM;

			} else

				return LD10K1_ERR_UNKNOWN_PATCH_NUM;

			break;

	}

	return 0;

}

int ld10k1_fnc_dsp_init(int data_conn, int op, int size)

{

	int audigy;

	int err, i;

	ld10k1_reserved_ctl_list_item_t *rlist;

	int save_ids[EMU10K1_PATCH_MAX];

	audigy = dsp_mgr.audigy;

	rlist = dsp_mgr.reserved_ctl_list; /* FIXME - hack to save reserved ctls and ids */

	for (i = 0; i < EMU10K1_PATCH_MAX; i++)

		save_ids[i] = dsp_mgr.patch_id_gens[i];

	ld10k1_dsp_mgr_free(&dsp_mgr);