drivers/omap_hsi/hsi_protocol_cmd.c - kernel/omap - Git at Google

 /*
  * File -  hsi_protocol_if_cmd.c
  *
  * Implements HSI protocol for Infineon Modem.
  *
  * Copyright (C) 2011 Samsung Electronics. All rights reserved.
  *
  * Author: Rupesh Gujare <rupesh.g@samsung.com>
  *
  * This package is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */


 #include <linux/errno.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/init.h>
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/delay.h>
 #include <linux/wait.h>
 #include <linux/sched.h>

 #include <linux/hsi_driver_if.h>
 #include "hsi-protocol-if.h"

 extern struct if_hsi_iface hsi_protocol_iface;
 extern wait_queue_head_t ipc_read_wait, ipc_write_wait;
 int if_hsi_openchannel(struct if_hsi_channel *channel);
 int if_hsi_closechannel(struct if_hsi_channel *channel);

 extern struct if_hsi_cmd hsi_cmd_history;
 extern int tx_cmd_history_p;
 extern int rx_cmd_history_p;

 /*Decode command from received PDU on channle 0*/
 int hsi_decode_cmd(u32 *cmd_data, u32 *cmd, u32 *ch, u32 *param)
 {
 	int ret = 0;
 	u32 data = *cmd_data;
 	u8 lrc_cal, lrc_act;
 	u8 val1, val2, val3;

 	*cmd = ((data & 0xF0000000) >> 28);

 	switch (*cmd) {
 	case    HSI_LL_MSG_BREAK:
 		pr_err("Command MSG_BREAK Received.\n");
 		break;

 	case    HSI_LL_MSG_OPEN_CONN:
 		*ch = ((data & 0x0F000000) >> 24);
 		*param   = ((data & 0x00FFFF00) >> 8);
 		/*Check LRC*/
 		val1 = ((data & 0xFF000000) >> 24);
 		val2 = ((data & 0x00FF0000) >> 16);
 		val3 = ((data & 0x0000FF00) >>  8);
 		lrc_act = (data & 0x000000FF);
 		lrc_cal = val1 ^ val2 ^ val3;
 		if (lrc_cal != lrc_act)
 			ret = -1;
 		break;

 	case HSI_LL_MSG_CONN_READY:
 	case HSI_LL_MSG_CONN_CLOSED:
 	case HSI_LL_MSG_CANCEL_CONN:
 	case HSI_LL_MSG_NAK:
 		*ch = ((data & 0x0F000000) >> 24);
 		break;

 	case HSI_LL_MSG_ACK:
 		*ch = ((data & 0x0F000000) >> 24);
 		*param = (data & 0x00FFFFFF);
 		//printk(KERN_INFO "ACK Received ch=%d, param=%d\n",*ch, *param);
 		break;

 	case HSI_LL_MSG_CONF_RATE:
 		*ch = ((data & 0x0F000000) >> 24);
 		*param   = ((data & 0x0F000000) >> 24);
 		break;

 	case HSI_LL_MSG_OPEN_CONN_OCTET:
 		*ch = ((data & 0x0F000000) >> 24);
 		*param   = (data & 0x00FFFFFF);
 		break;

 	case HSI_LL_MSG_ECHO:
 	case HSI_LL_MSG_INFO_REQ:
 	case HSI_LL_MSG_INFO:
 	case HSI_LL_MSG_CONFIGURE:
 	case HSI_LL_MSG_ALLOCATE_CH:
 	case HSI_LL_MSG_RELEASE_CH:
 	case HSI_LL_MSG_INVALID:
 		*cmd = HSI_LL_MSG_INVALID;
 		*ch  = HSI_LL_INVALID_CHANNEL;
 		ret = -1;
 		break;
 	}
 	return ret;
 }

 int protocol_create_cmd(int cmd_type, unsigned int channel, void *arg)
 {
 	unsigned int command = 0;
 	int ret = 0;

 	switch (cmd_type) {
 	case HSI_LL_MSG_BREAK:
 		{
 			command = 0;
 		}
 		break;

 	case HSI_LL_MSG_OPEN_CONN:
 		{
 			unsigned int size = *(unsigned int *)arg;
 			unsigned int lcr  = 0;

 /*       if(size > 4)
 	 size = (size & 0x3) ? ((size >> 2) + 1):(size >> 2);
        else
 	 size = 1;*/

 			command = ((HSI_LL_MSG_OPEN_CONN & 0x0000000F) << 28) |
 				  ((channel              & 0x000000FF) << 24) |
 				  ((size                 & 0x0000FFFF) << 8);

 			lcr = ((command & 0xFF000000) >> 24) ^
 			      ((command & 0x00FF0000) >> 16) ^
 			      ((command & 0x0000FF00) >>  8);

 			command = command | (lcr & 0x000000FF);
 		}
 		break;

 	case HSI_LL_MSG_CONN_READY:
 		{
 			command = ((HSI_LL_MSG_CONN_READY & 0x0000000F) << 28) |
 				  ((channel               & 0x000000FF) << 24);
 		}
 		break;

 	case HSI_LL_MSG_CONN_CLOSED:
 		{
 			command = ((HSI_LL_MSG_CONN_CLOSED & 0x0000000F) << 28) |
 				  ((channel                & 0x000000FF) << 24);
 		}
 		break;

 	case HSI_LL_MSG_CANCEL_CONN:
 		{
 			unsigned int role = *(unsigned int *)arg;

 			command = ((HSI_LL_MSG_CANCEL_CONN & 0x0000000F) << 28) |
 				  ((channel                & 0x000000FF) << 24) |
 				  ((role                   & 0x000000FF) << 16);
 		}
 		break;

 	case HSI_LL_MSG_ACK:
 		{
 			unsigned int echo_params = *(unsigned int *)arg;

 			command = ((HSI_LL_MSG_ACK & 0x0000000F) << 28) |
 				  ((channel        & 0x000000FF) << 24) |
 				  ((echo_params    & 0x00FFFFFF));
 		}
 		break;

 	case HSI_LL_MSG_NAK:
 		{
 			command = ((HSI_LL_MSG_NAK & 0x0000000F) << 28) |
 				  ((channel        & 0x000000FF) << 24);
 		}
 		break;

 	case HSI_LL_MSG_CONF_RATE:
 		{
 			unsigned int baud_rate = *(unsigned int *)arg;

 			command = ((HSI_LL_MSG_CONF_RATE & 0x0000000F) << 28) |
 				  ((channel              & 0x000000FF) << 24) |
 				  ((baud_rate            & 0x00FFFFFF));
 		}
 		break;

 	case HSI_LL_MSG_OPEN_CONN_OCTET:
 		{
 			unsigned int size = *(unsigned int *)arg;

 			command = ((HSI_LL_MSG_OPEN_CONN_OCTET & 0x0000000F) << 28) |
 				  ((channel                    & 0x000000FF) << 24) |
 				  ((size                       & 0x00FFFFFF));

 		}
 		break;

 	case HSI_LL_MSG_ECHO:
 	case HSI_LL_MSG_INFO_REQ:
 	case HSI_LL_MSG_INFO:
 	case HSI_LL_MSG_CONFIGURE:
 	case HSI_LL_MSG_ALLOCATE_CH:
 	case HSI_LL_MSG_RELEASE_CH:
 	case HSI_LL_MSG_INVALID:
 		ret = -1;
 		break;
 	}
 	return command;
 }

 int set_tx_config(struct if_hsi_channel *ch, u32 mode, u32 max_channels)
 {
 	struct hst_ctx tx_config;
 	int ret;

 	hsi_ioctl(ch->dev, HSI_IOCTL_GET_TX, &tx_config);
 	tx_config.mode = mode;
 	tx_config.channels = max_channels;
 	ret = hsi_ioctl(ch->dev, HSI_IOCTL_SET_TX, &tx_config);
 	return ret;
 }

 static int saved_cmd_queue = 0;
 static u32 cmd_saved[5];
 int hsi_protocol_send_command(u32 cmd, u32 channel, u32 param)
 {
 	struct if_hsi_channel *channel_zero;
 	u32 cmd_array[4] = {0x00000000, 0xAAAAAAAA, 0xBBBBBBBB, 0xCCCCCCCC}, ret = -1;

 	channel_zero = &hsi_protocol_iface.channels[0];
 	cmd_array[0] = protocol_create_cmd(cmd, channel, &param);
 	pr_debug("[%s] CMD = %08x\n",__func__, cmd_array[0]);
 	while (channel_zero->tx_state != HSI_LL_TX_STATE_IDLE) {
 		cmd_saved[saved_cmd_queue] = cmd_array[0];
 		saved_cmd_queue++;
 		pr_debug("(%s) cmd_saved : %x(%d)\n", __func__, cmd_array[0], saved_cmd_queue);

 		return 0;
 	}

 send_retry:

 	channel_zero->tx_state = HSI_LL_TX_STATE_TX;

 	// For es 2.1 ver.
 	ret = hsi_proto_write(0, cmd_array, 4);
 	if (ret < 0) {
 		pr_err("(%s) Command Write failed, CMD->%X\n", __func__, cmd_array[0]);
 		channel_zero->tx_state = HSI_LL_TX_STATE_IDLE;
 		return -1;
 	} else {
 		channel_zero->tx_state = HSI_LL_TX_STATE_IDLE;

 		pr_debug("[%s] CMD = %08x\n", __func__, cmd_array[0]);

 		hsi_cmd_history.tx_cmd[tx_cmd_history_p] = cmd_array[0];
 		hsi_cmd_history.tx_cmd_time[tx_cmd_history_p] = CURRENT_TIME;
 		tx_cmd_history_p++;
 		if (tx_cmd_history_p >= 50)
 			tx_cmd_history_p = 0;

 		if (saved_cmd_queue) {
 			saved_cmd_queue--;
 			cmd_array[0] = cmd_saved[saved_cmd_queue];

 			goto send_retry;
 		}

 		return 0;
 	}
 }

 void rx_stm(u32 cmd, u32 ch, u32 param)
 {
 	struct if_hsi_channel *channel;
 	u32 size = 0, tmp_cmd = 0, ret, i;
 	channel = &hsi_protocol_iface.channels[ch];

 	switch (cmd) {
 	case HSI_LL_MSG_OPEN_CONN:
 		pr_err("ERROR... OPEN_CONN Not supported. Should use OPEN_CONN_OCTECT instead.\n");
 		break;

 	case HSI_LL_MSG_ECHO:
 		pr_err("ERROR... HSI_LL_MSG_ECHO not supported.\n");
 		break;

 	case HSI_LL_MSG_CONN_CLOSED:
 		switch (channel->tx_state) {
 		case HSI_LL_TX_STATE_WAIT_FOR_CONN_CLOSED:
 			channel->tx_state = HSI_LL_TX_STATE_IDLE;

 			/* ACWAKE ->LOW */
 			ret = hsi_ioctl(hsi_protocol_iface.channels[0].dev, HSI_IOCTL_ACWAKE_DOWN, NULL);
 			if (ret == 0)
 				pr_debug("ACWAKE pulled low in %s()\n", __func__);
 			else
 				pr_err("ACWAKE pulled low in %s() ERROR : %d\n", __func__, ret);

 			pr_debug("[%s] Received CONN_CLOSED. ch-> %d\n", __func__,ch);
 			break;

 		default:
 			pr_err("Wrong STATE for CONN_CLOSED\n");
 		}
 		break;

 	case HSI_LL_MSG_CANCEL_CONN:
 		pr_debug("Received CANCEL_CONN\n");
 		break;

 	case HSI_LL_MSG_ACK:
 		switch (channel->tx_state) {
 		case HSI_LL_TX_STATE_WAIT_FOR_ACK:
 		case HSI_LL_TX_STATE_SEND_OPEN_CONN:
 			//printk(KERN_INFO "ACK received %s()\n",__func__);

 			channel->tx_state = HSI_LL_TX_STATE_TX;
 			size = param;
 #if 0
 			// TEMP: send/read by 16 byte unit for v.11A(CP)
 			if ((size > 16) && (size % 16))
 				size += (16 - (size % 16));
 			else if (size < 16)
 				size = 16;
 #endif

 			// For es 2.1 ver.
 			if (size % 4)
 				size += (4 - (size % 4));

 			pr_debug("Writing %d bytes data on channel %d, tx_buf = %x,  in %s()\n", size, ch, channel->tx_buf, __func__);
 			ret = hsi_proto_write(ch, channel->tx_buf, size);
 			channel->tx_state = HSI_LL_TX_STATE_WAIT_FOR_CONN_CLOSED;
 			wake_up_interruptible(&ipc_write_wait);
 			channel->tx_nak_count = 0;
 			break;

 		case HSI_LL_TX_STATE_CLOSED:/* ACK as response to CANCEL_CONN */
 			if (channel->rx_state == HSI_LL_RX_STATE_WAIT_FOR_CANCEL_CONN_ACK)
 				channel->rx_state = HSI_LL_RX_STATE_IDLE;
 			break;

 		case HSI_LL_TX_STATE_WAIT_FOR_CONF_ACK:	/* ACK as response to CONF_RATE */
 			//TODO: SET CONF RATE
 			pr_debug("ACK Received for CONF_RATE\n");
 			break;

 		default:
 			pr_err("ACK Received for Unknown state\n");
 		}
 		break;

 	case HSI_LL_MSG_NAK:
 		switch (channel->tx_state) {
 		case HSI_LL_TX_STATE_WAIT_FOR_ACK:
 			printk(KERN_INFO "(%s) NAK received. ch->%d\n", __func__, ch);
 			//channel->tx_state = HSI_LL_TX_STATE_NACK;
 			if (channel->tx_nak_count < 10) {
 				msleep(10);

 				tmp_cmd = ((HSI_LL_MSG_OPEN_CONN_OCTET & 0x0000000F) << 28) |
 					  ((ch                         & 0x000000FF) << 24);
 				for (i = 49; i >= 0; i--) {
 					if ((hsi_cmd_history.tx_cmd[i] & 0xFFF00000) == tmp_cmd)
 						break;
 				}
 				size = (hsi_cmd_history.tx_cmd[i] & 0x000FFFFF);

 				pr_debug("(%s) Re Send OPEN CONN ch->%d, size->%d, count->%d\n", __func__, ch, size, channel->tx_nak_count);

 				hsi_protocol_send_command(HSI_LL_MSG_OPEN_CONN_OCTET, ch, size);
 				channel->tx_nak_count++;
 			} else {
 				hsi_protocol_send_command(HSI_LL_MSG_BREAK, ch, size);
 				pr_debug("(%s) Sending MSG_BREAK. ch->%d\n", __func__, ch);
 				//TODO Reset All channels and inform IPC write about failure (Possibly by sending signal)
 			}
 			break;

 		case HSI_LL_TX_STATE_WAIT_FOR_CONF_ACK:	/* NAK as response to CONF_RATE */
 			channel->tx_state = HSI_LL_TX_STATE_IDLE;
 			break;

 		default:
 			pr_err("ERROR - Received NAK in invalid state. state->%d\n", channel->tx_state);
 		}
 		break;

 	case HSI_LL_MSG_CONF_RATE:
 		//TODO: Set Conf Rate
 		pr_debug("CONF_RATE Received\n");
 		break;

 	case HSI_LL_MSG_OPEN_CONN_OCTET:
 		switch (channel->rx_state) {
 		/* case HSI_LL_RX_STATE_CLOSED: */
 		case HSI_LL_RX_STATE_IDLE:
 			pr_debug("OPEN_CONN_OCTET in %s(), ch-> %d\n", __func__, ch);
 			channel->rx_state = HSI_LL_RX_STATE_TO_ACK;
 			hsi_protocol_send_command(HSI_LL_MSG_ACK, ch, param);

 			channel->rx_count = param;
 			channel->rx_state = HSI_LL_RX_STATE_RX;
 			wake_up_interruptible(&ipc_read_wait);
 			break;

 		case HSI_LL_RX_STATE_BLOCKED:
 			/* TODO */
 			break;

 		default:
 			pr_err("OPEN_CONN_OCTET in invalid state, Current State -> %d\n", channel->rx_state);
 			pr_info("Sending NAK to channel-> %d\n", ch);
 			hsi_protocol_send_command(HSI_LL_MSG_NAK, ch, param);
 		}
 		break;

 	default:
 		pr_err("Invalid Command encountered in rx_state()\n");
 	}

 }
	/*
	* File - hsi_protocol_if_cmd.c
	*
	* Implements HSI protocol for Infineon Modem.
	*
	* Copyright (C) 2011 Samsung Electronics. All rights reserved.
	*
	* Author: Rupesh Gujare <rupesh.g@samsung.com>
	*
	* This package is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 as
	* published by the Free Software Foundation.
	*
	* THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
	* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
	* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	*/


	#include <linux/errno.h>
	#include <linux/module.h>
	#include <linux/types.h>
	#include <linux/init.h>
	#include <linux/device.h>
	#include <linux/err.h>
	#include <linux/delay.h>
	#include <linux/wait.h>
	#include <linux/sched.h>

	#include <linux/hsi_driver_if.h>
	#include "hsi-protocol-if.h"

	extern struct if_hsi_iface hsi_protocol_iface;
	extern wait_queue_head_t ipc_read_wait, ipc_write_wait;
	int if_hsi_openchannel(struct if_hsi_channel *channel);
	int if_hsi_closechannel(struct if_hsi_channel *channel);

	extern struct if_hsi_cmd hsi_cmd_history;
	extern int tx_cmd_history_p;
	extern int rx_cmd_history_p;

	/Decode command from received PDU on channle 0/
	int hsi_decode_cmd(u32 cmd_data, u32 cmd, u32 ch, u32 param)
	{
	int ret = 0;
	u32 data = *cmd_data;
	u8 lrc_cal, lrc_act;
	u8 val1, val2, val3;

	*cmd = ((data & 0xF0000000) >> 28);

	switch (*cmd) {
	case HSI_LL_MSG_BREAK:
	pr_err("Command MSG_BREAK Received.\n");
	break;

	case HSI_LL_MSG_OPEN_CONN:
	*ch = ((data & 0x0F000000) >> 24);
	*param = ((data & 0x00FFFF00) >> 8);
	/Check LRC/
	val1 = ((data & 0xFF000000) >> 24);
	val2 = ((data & 0x00FF0000) >> 16);
	val3 = ((data & 0x0000FF00) >> 8);
	lrc_act = (data & 0x000000FF);
	lrc_cal = val1 ^ val2 ^ val3;
	if (lrc_cal != lrc_act)
	ret = -1;
	break;

	case HSI_LL_MSG_CONN_READY:
	case HSI_LL_MSG_CONN_CLOSED:
	case HSI_LL_MSG_CANCEL_CONN:
	case HSI_LL_MSG_NAK:
	*ch = ((data & 0x0F000000) >> 24);
	break;

	case HSI_LL_MSG_ACK:
	*ch = ((data & 0x0F000000) >> 24);
	*param = (data & 0x00FFFFFF);
	//printk(KERN_INFO "ACK Received ch=%d, param=%d\n",ch, param);
	break;

	case HSI_LL_MSG_CONF_RATE:
	*ch = ((data & 0x0F000000) >> 24);
	*param = ((data & 0x0F000000) >> 24);
	break;

	case HSI_LL_MSG_OPEN_CONN_OCTET:
	*ch = ((data & 0x0F000000) >> 24);
	*param = (data & 0x00FFFFFF);
	break;

	case HSI_LL_MSG_ECHO:
	case HSI_LL_MSG_INFO_REQ:
	case HSI_LL_MSG_INFO:
	case HSI_LL_MSG_CONFIGURE:
	case HSI_LL_MSG_ALLOCATE_CH:
	case HSI_LL_MSG_RELEASE_CH:
	case HSI_LL_MSG_INVALID:
	*cmd = HSI_LL_MSG_INVALID;
	*ch = HSI_LL_INVALID_CHANNEL;
	ret = -1;
	break;
	}
	return ret;
	}

	int protocol_create_cmd(int cmd_type, unsigned int channel, void *arg)
	{
	unsigned int command = 0;
	int ret = 0;

	switch (cmd_type) {
	case HSI_LL_MSG_BREAK:
	{
	command = 0;
	}
	break;

	case HSI_LL_MSG_OPEN_CONN:
	{
	unsigned int size = (unsigned int )arg;
	unsigned int lcr = 0;

	/* if(size > 4)
	size = (size & 0x3) ? ((size >> 2) + 1):(size >> 2);
	else
	size = 1;*/

	command = ((HSI_LL_MSG_OPEN_CONN & 0x0000000F) << 28) \|
	((channel & 0x000000FF) << 24) \|
	((size & 0x0000FFFF) << 8);

	lcr = ((command & 0xFF000000) >> 24) ^
	((command & 0x00FF0000) >> 16) ^
	((command & 0x0000FF00) >> 8);

	command = command \| (lcr & 0x000000FF);
	}
	break;

	case HSI_LL_MSG_CONN_READY:
	{
	command = ((HSI_LL_MSG_CONN_READY & 0x0000000F) << 28) \|
	((channel & 0x000000FF) << 24);
	}
	break;

	case HSI_LL_MSG_CONN_CLOSED:
	{
	command = ((HSI_LL_MSG_CONN_CLOSED & 0x0000000F) << 28) \|
	((channel & 0x000000FF) << 24);
	}
	break;

	case HSI_LL_MSG_CANCEL_CONN:
	{
	unsigned int role = (unsigned int )arg;

	command = ((HSI_LL_MSG_CANCEL_CONN & 0x0000000F) << 28) \|
	((channel & 0x000000FF) << 24) \|
	((role & 0x000000FF) << 16);
	}
	break;

	case HSI_LL_MSG_ACK:
	{
	unsigned int echo_params = (unsigned int )arg;

	command = ((HSI_LL_MSG_ACK & 0x0000000F) << 28) \|
	((channel & 0x000000FF) << 24) \|
	((echo_params & 0x00FFFFFF));
	}
	break;

	case HSI_LL_MSG_NAK:
	{
	command = ((HSI_LL_MSG_NAK & 0x0000000F) << 28) \|
	((channel & 0x000000FF) << 24);
	}
	break;

	case HSI_LL_MSG_CONF_RATE:
	{
	unsigned int baud_rate = (unsigned int )arg;

	command = ((HSI_LL_MSG_CONF_RATE & 0x0000000F) << 28) \|
	((channel & 0x000000FF) << 24) \|
	((baud_rate & 0x00FFFFFF));
	}
	break;

	case HSI_LL_MSG_OPEN_CONN_OCTET:
	{
	unsigned int size = (unsigned int )arg;

	command = ((HSI_LL_MSG_OPEN_CONN_OCTET & 0x0000000F) << 28) \|
	((channel & 0x000000FF) << 24) \|
	((size & 0x00FFFFFF));

	}
	break;

	case HSI_LL_MSG_ECHO:
	case HSI_LL_MSG_INFO_REQ:
	case HSI_LL_MSG_INFO:
	case HSI_LL_MSG_CONFIGURE:
	case HSI_LL_MSG_ALLOCATE_CH:
	case HSI_LL_MSG_RELEASE_CH:
	case HSI_LL_MSG_INVALID:
	ret = -1;
	break;
	}
	return command;
	}

	int set_tx_config(struct if_hsi_channel *ch, u32 mode, u32 max_channels)
	{
	struct hst_ctx tx_config;
	int ret;

	hsi_ioctl(ch->dev, HSI_IOCTL_GET_TX, &tx_config);
	tx_config.mode = mode;
	tx_config.channels = max_channels;
	ret = hsi_ioctl(ch->dev, HSI_IOCTL_SET_TX, &tx_config);
	return ret;
	}

	static int saved_cmd_queue = 0;
	static u32 cmd_saved[5];
	int hsi_protocol_send_command(u32 cmd, u32 channel, u32 param)
	{
	struct if_hsi_channel *channel_zero;
	u32 cmd_array[4] = {0x00000000, 0xAAAAAAAA, 0xBBBBBBBB, 0xCCCCCCCC}, ret = -1;

	channel_zero = &hsi_protocol_iface.channels[0];
	cmd_array[0] = protocol_create_cmd(cmd, channel, &param);
	pr_debug("[%s] CMD = %08x\n",__func__, cmd_array[0]);
	while (channel_zero->tx_state != HSI_LL_TX_STATE_IDLE) {
	cmd_saved[saved_cmd_queue] = cmd_array[0];
	saved_cmd_queue++;
	pr_debug("(%s) cmd_saved : %x(%d)\n", __func__, cmd_array[0], saved_cmd_queue);

	return 0;
	}

	send_retry:

	channel_zero->tx_state = HSI_LL_TX_STATE_TX;

	// For es 2.1 ver.
	ret = hsi_proto_write(0, cmd_array, 4);
	if (ret < 0) {
	pr_err("(%s) Command Write failed, CMD->%X\n", __func__, cmd_array[0]);
	channel_zero->tx_state = HSI_LL_TX_STATE_IDLE;
	return -1;
	} else {
	channel_zero->tx_state = HSI_LL_TX_STATE_IDLE;

	pr_debug("[%s] CMD = %08x\n", __func__, cmd_array[0]);

	hsi_cmd_history.tx_cmd[tx_cmd_history_p] = cmd_array[0];
	hsi_cmd_history.tx_cmd_time[tx_cmd_history_p] = CURRENT_TIME;
	tx_cmd_history_p++;
	if (tx_cmd_history_p >= 50)
	tx_cmd_history_p = 0;

	if (saved_cmd_queue) {
	saved_cmd_queue--;
	cmd_array[0] = cmd_saved[saved_cmd_queue];

	goto send_retry;
	}

	return 0;
	}
	}

	void rx_stm(u32 cmd, u32 ch, u32 param)
	{
	struct if_hsi_channel *channel;
	u32 size = 0, tmp_cmd = 0, ret, i;
	channel = &hsi_protocol_iface.channels[ch];

	switch (cmd) {
	case HSI_LL_MSG_OPEN_CONN:
	pr_err("ERROR... OPEN_CONN Not supported. Should use OPEN_CONN_OCTECT instead.\n");
	break;

	case HSI_LL_MSG_ECHO:
	pr_err("ERROR... HSI_LL_MSG_ECHO not supported.\n");
	break;

	case HSI_LL_MSG_CONN_CLOSED:
	switch (channel->tx_state) {
	case HSI_LL_TX_STATE_WAIT_FOR_CONN_CLOSED:
	channel->tx_state = HSI_LL_TX_STATE_IDLE;

	/* ACWAKE ->LOW */
	ret = hsi_ioctl(hsi_protocol_iface.channels[0].dev, HSI_IOCTL_ACWAKE_DOWN, NULL);
	if (ret == 0)
	pr_debug("ACWAKE pulled low in %s()\n", __func__);
	else
	pr_err("ACWAKE pulled low in %s() ERROR : %d\n", __func__, ret);

	pr_debug("[%s] Received CONN_CLOSED. ch-> %d\n", __func__,ch);
	break;

	default:
	pr_err("Wrong STATE for CONN_CLOSED\n");
	}
	break;

	case HSI_LL_MSG_CANCEL_CONN:
	pr_debug("Received CANCEL_CONN\n");
	break;

	case HSI_LL_MSG_ACK:
	switch (channel->tx_state) {
	case HSI_LL_TX_STATE_WAIT_FOR_ACK:
	case HSI_LL_TX_STATE_SEND_OPEN_CONN:
	//printk(KERN_INFO "ACK received %s()\n",__func__);

	channel->tx_state = HSI_LL_TX_STATE_TX;
	size = param;
	#if 0
	// TEMP: send/read by 16 byte unit for v.11A(CP)
	if ((size > 16) && (size % 16))
	size += (16 - (size % 16));
	else if (size < 16)
	size = 16;
	#endif

	// For es 2.1 ver.
	if (size % 4)
	size += (4 - (size % 4));

	pr_debug("Writing %d bytes data on channel %d, tx_buf = %x, in %s()\n", size, ch, channel->tx_buf, __func__);
	ret = hsi_proto_write(ch, channel->tx_buf, size);
	channel->tx_state = HSI_LL_TX_STATE_WAIT_FOR_CONN_CLOSED;
	wake_up_interruptible(&ipc_write_wait);
	channel->tx_nak_count = 0;
	break;

	case HSI_LL_TX_STATE_CLOSED:/* ACK as response to CANCEL_CONN */
	if (channel->rx_state == HSI_LL_RX_STATE_WAIT_FOR_CANCEL_CONN_ACK)
	channel->rx_state = HSI_LL_RX_STATE_IDLE;
	break;

	case HSI_LL_TX_STATE_WAIT_FOR_CONF_ACK: /* ACK as response to CONF_RATE */
	//TODO: SET CONF RATE
	pr_debug("ACK Received for CONF_RATE\n");
	break;

	default:
	pr_err("ACK Received for Unknown state\n");
	}
	break;

	case HSI_LL_MSG_NAK:
	switch (channel->tx_state) {
	case HSI_LL_TX_STATE_WAIT_FOR_ACK:
	printk(KERN_INFO "(%s) NAK received. ch->%d\n", __func__, ch);
	//channel->tx_state = HSI_LL_TX_STATE_NACK;
	if (channel->tx_nak_count < 10) {
	msleep(10);

	tmp_cmd = ((HSI_LL_MSG_OPEN_CONN_OCTET & 0x0000000F) << 28) \|
	((ch & 0x000000FF) << 24);
	for (i = 49; i >= 0; i--) {
	if ((hsi_cmd_history.tx_cmd[i] & 0xFFF00000) == tmp_cmd)
	break;
	}
	size = (hsi_cmd_history.tx_cmd[i] & 0x000FFFFF);

	pr_debug("(%s) Re Send OPEN CONN ch->%d, size->%d, count->%d\n", __func__, ch, size, channel->tx_nak_count);

	hsi_protocol_send_command(HSI_LL_MSG_OPEN_CONN_OCTET, ch, size);
	channel->tx_nak_count++;
	} else {
	hsi_protocol_send_command(HSI_LL_MSG_BREAK, ch, size);
	pr_debug("(%s) Sending MSG_BREAK. ch->%d\n", __func__, ch);
	//TODO Reset All channels and inform IPC write about failure (Possibly by sending signal)
	}
	break;

	case HSI_LL_TX_STATE_WAIT_FOR_CONF_ACK: /* NAK as response to CONF_RATE */
	channel->tx_state = HSI_LL_TX_STATE_IDLE;
	break;

	default:
	pr_err("ERROR - Received NAK in invalid state. state->%d\n", channel->tx_state);
	}
	break;

	case HSI_LL_MSG_CONF_RATE:
	//TODO: Set Conf Rate
	pr_debug("CONF_RATE Received\n");
	break;

	case HSI_LL_MSG_OPEN_CONN_OCTET:
	switch (channel->rx_state) {
	/* case HSI_LL_RX_STATE_CLOSED: */
	case HSI_LL_RX_STATE_IDLE:
	pr_debug("OPEN_CONN_OCTET in %s(), ch-> %d\n", __func__, ch);
	channel->rx_state = HSI_LL_RX_STATE_TO_ACK;
	hsi_protocol_send_command(HSI_LL_MSG_ACK, ch, param);

	channel->rx_count = param;
	channel->rx_state = HSI_LL_RX_STATE_RX;
	wake_up_interruptible(&ipc_read_wait);
	break;

	case HSI_LL_RX_STATE_BLOCKED:
	/* TODO */
	break;

	default:
	pr_err("OPEN_CONN_OCTET in invalid state, Current State -> %d\n", channel->rx_state);
	pr_info("Sending NAK to channel-> %d\n", ch);
	hsi_protocol_send_command(HSI_LL_MSG_NAK, ch, param);
	}
	break;

	default:
	pr_err("Invalid Command encountered in rx_state()\n");
	}

	}