drivers/mxc/hdp/util.c - linux-imx - Git at Google

 /******************************************************************************
  *
  * Copyright (C) 2016-2017 Cadence Design Systems, Inc.
  * All rights reserved worldwide.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *
  * 1. Redistributions of source code must retain the above copyright notice,
  * this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright notice,
  * this list of conditions and the following disclaimer in the documentation and/or
  * other materials provided with the distribution.
  *
  * 3. Neither the name of the copyright holder nor the names of its contributors
  * may be used to endorse or promote products derived from this software without
  * specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
  * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
  * Copyright 2017-2018 NXP
  *
  ******************************************************************************
  *
  * util.c
  *
  ******************************************************************************
  */
 #include "util.h"
 #include "API_General.h"
 #include "apb_cfg.h"
 #include "opcodes.h"

 int cdn_apb_read(state_struct *state, u32 addr, u32 *value)
 {
 	struct hdp_mem *mem = state->mem;
 	state->rw->read_reg(mem, addr, value);
 	return 0;
 }

 int cdn_apb_write(state_struct *state, u32 addr, u32 value)
 {
 	struct hdp_mem *mem = state->mem;
 	state->rw->write_reg(mem, addr, value);
 	return 0;
 }

 int cdn_sapb_read(state_struct *state, u32 addr, u32 *value)
 {
 	struct hdp_mem *mem = state->mem;
 	state->rw->sread_reg(mem, addr, value);
 	return 0;
 }

 int cdn_sapb_write(state_struct *state, u32 addr, u32 value)
 {
 	struct hdp_mem *mem = state->mem;
 	state->rw->swrite_reg(mem, addr, value);
 	return 0;
 }

 void cdn_sleep(u32 ms)
 {
 	mdelay(ms);
 }

 void cdn_usleep(u32 us)
 {
 	udelay(us);
 }

 int cdn_bus_read(state_struct *state, u32 addr, u32 *value)
 {
 	return state->bus_type ?
 	    cdn_sapb_read(state, addr, value) : cdn_apb_read(state, addr,
 							     value);
 }

 int cdn_bus_write(state_struct *state, u32 addr, u32 value)
 {
 	return state->bus_type ?
 	    cdn_sapb_write(state, addr, value) : cdn_apb_write(state, addr,
 							       value);
 }

 void internal_itobe(int val, volatile u8 *dest, int bytes)
 {
 	int i;
 	for (i = bytes - 1; i >= 0; --i) {
 		dest[i] = (u8) val;
 		val >>= 8;
 	}
 }

 u32 internal_betoi(volatile u8 const *src, u8 bytes)
 {
 	u32 ret = 0;
 	int i;

 	if (bytes > sizeof(ret)) {
 		printk
 		    ("Warning. Read request for payload larger then supported.\n");
 		bytes = sizeof(ret);

 	}

 	for (i = 0; i < bytes; ++i) {
 		ret <<= 8;
 		ret |= (u32) src[i];
 	}

 	return ret;
 }

 u32 internal_mkmsg(volatile u8 *dest, int valNo, ...)
 {
 	va_list vl;
 	u32 len = 0;
 	va_start(vl, valNo);
 	len = internal_vmkmsg(dest, valNo, vl);
 	va_end(vl);
 	return len;
 }

 u32 internal_vmkmsg(volatile u8 *dest, int valNo, va_list vl)
 {
 	u32 len = 0;
 	int i;
 	for (i = 0; i < valNo; ++i) {
 		int size = va_arg(vl, int);
 		if (size > 0) {
 			internal_itobe(va_arg(vl, int), dest, size);
 			dest += size;
 			len += size;;
 		} else {
 			memcpy((void *)dest, va_arg(vl, void *), -size);
 			dest -= size;
 			len -= size;
 		}
 	}
 	return len;
 }

 void internal_tx_mkfullmsg(state_struct *state, u8 module, u8 opcode,
 			   int valNo, ...)
 {
 	va_list vl;
 	va_start(vl, valNo);
 	internal_vtx_mkfullmsg(state, module, opcode, valNo, vl);
 	va_end(vl);
 }

 void internal_vtx_mkfullmsg(state_struct *state, u8 module, u8 opcode,
 			    int valNo, va_list vl)
 {
 	u32 len =
 	    internal_vmkmsg(state->txBuffer + INTERNAL_CMD_HEAD_SIZE, valNo,
 			    vl);
 	internal_mbox_tx_enable(state, module, opcode, len);
 	state->txEnable = 1;
 	state->running = 1;
 }

 void internal_readmsg(state_struct *state, int valNo, ...)
 {
 	va_list vl;
 	va_start(vl, valNo);
 	internal_vreadmsg(state, valNo, vl);
 	va_end(vl);
 }

 void internal_vreadmsg(state_struct *state, int valNo, va_list vl)
 {
 	u8 *src = state->rxBuffer + INTERNAL_CMD_HEAD_SIZE;
 	size_t i;

 	for (i = 0; i < (size_t) valNo; ++i) {
 		int size = va_arg(vl, int);
 		void *ptr = va_arg(vl, void *);

 		if (!ptr) {
 			src += size;
 		} else if (!size) {
 			*((u8 **) ptr) = src;
 		} else if (size > 0) {
 			switch ((size_t) size) {
 			case sizeof(u8):
 				*((u8 *) ptr) = internal_betoi(src, size);
 				break;
 			case sizeof(u16):
 				*((u16 *) ptr) = internal_betoi(src, size);
 				break;
 			case 3:	// 3-byte value (e.g. DPCD address) can be safely converted from BE
 			case sizeof(u32):
 				*((u32 *) ptr) = internal_betoi(src, size);
 				break;
 			default:
 				pr_warn("Warning. Unsupported variable size.\n");
 				memcpy(ptr, src, size);
 			};

 			src += size;
 		} else {
 			memcpy(ptr, src, -size);
 			src -= size;
 		}
 	}
 }

 INTERNAL_MBOX_STATUS mailbox_write(state_struct *state, u8 val)
 {
 	INTERNAL_MBOX_STATUS ret = { 0, 0, 0, 0 };
 	u32 full;
 	if (cdn_bus_read(state, MAILBOX_FULL_ADDR << 2, &full)) {
 		ret.tx_status = CDN_TX_APB_ERROR;
 		return ret;
 	}
 	if (full) {
 		ret.tx_status = CDN_TX_FULL;
 		return ret;
 	}
 	if (cdn_bus_write(state, MAILBOX0_WR_DATA << 2, val)) {
 		ret.tx_status = CDN_TX_APB_ERROR;
 		return ret;
 	}
 	ret.tx_status = CDN_TX_WRITE;
 	return ret;
 }

 INTERNAL_MBOX_STATUS mailbox_read(state_struct *state, volatile u8 *val)
 {
 	INTERNAL_MBOX_STATUS ret = { 0, 0, 0, 0 };
 	u32 empty;
 	u32 rd;
 	if (cdn_bus_read(state, MAILBOX_EMPTY_ADDR << 2, &empty)) {
 		ret.rx_status = CDN_RX_APB_ERROR;
 		return ret;
 	}
 	if (empty) {
 		ret.rx_status = CDN_RX_EMPTY;
 		return ret;
 	}
 	if (cdn_bus_read(state, MAILBOX0_RD_DATA << 2, &rd)) {
 		ret.rx_status = CDN_RX_APB_ERROR;
 		return ret;
 	}
 	*val = (u8) rd;
 	ret.rx_status = CDN_RX_READ;
 	return ret;
 }

 INTERNAL_MBOX_STATUS internal_mbox_tx_process(state_struct *state)
 {
 	u32 txCount = 0;
 	u32 length = (u32) state->txBuffer[2] << 8 | (u32) state->txBuffer[3];
 	INTERNAL_MBOX_STATUS ret = {.txend = 0 };
 	INTERNAL_MBOX_STATUS tx_ret;

 	ret.tx_status = CDN_TX_NOTHING;
 	if (!state->txEnable)
 		return ret;
 	while ((tx_ret.tx_status =
 		mailbox_write(state, state->txBuffer[state->txi]).tx_status) ==
 	       CDN_TX_WRITE) {
 		txCount++;
 		if (++state->txi >= length + 4) {
 			state->txEnable = 0;
 			state->txi = 0;
 			ret.txend = 1;
 			break;
 		}
 	}
 	if (txCount && tx_ret.tx_status == CDN_TX_FULL)
 		ret.tx_status = CDN_TX_WRITE;
 	else
 		ret.tx_status = tx_ret.tx_status;
 	return ret;
 }

 INTERNAL_MBOX_STATUS internal_mbox_rx_process(state_struct *state)
 {
 	u32 rxCount = 0;
 	INTERNAL_MBOX_STATUS ret = { 0, 0, 0, 0 };
 	INTERNAL_MBOX_STATUS rx_ret;
 	while ((rx_ret.rx_status =
 		mailbox_read(state, state->rxBuffer + state->rxi).rx_status) ==
 	       CDN_RX_READ) {
 		rxCount++;
 		if (++state->rxi >=
 		    4 +
 		    ((u32) state->rxBuffer[2] << 8 | (u32) state->
 		     rxBuffer[3])) {
 			state->rxi = 0;
 			ret.rxend = 1;
 			state->rxEnable = 0;
 			break;
 		}
 	}
 	ret.rx_status = rxCount ? CDN_RX_READ : CDN_RX_EMPTY;
 	return ret;
 }

 u32 internal_apb_available(state_struct *state)
 {
 	return !(state->rxEnable || state->txEnable);
 }

 void internal_mbox_tx_enable(state_struct *state, u8 module, u8 opcode,
 			     u16 length)
 {
 	state->txBuffer[0] = opcode;
 	state->txBuffer[1] = module;
 	state->txBuffer[2] = (u8) (length >> 8);
 	state->txBuffer[3] = (u8) length;
 	state->txEnable = 1;
 }

 CDN_API_STATUS internal_test_rx_head(state_struct *state, u8 module, u8 opcode)
 {
 	if (opcode != state->rxBuffer[0])
 		return CDN_BAD_OPCODE;
 	if (module != state->rxBuffer[1])
 		return CDN_BAD_MODULE;
 	return CDN_OK;
 }

 CDN_API_STATUS internal_test_rx_head_match(state_struct *state)
 {
 	return internal_test_rx_head(state, state->txBuffer[1],
 				     state->txBuffer[0]);
 }

 void print_fw_ver(state_struct *state)
 {
 	u16 ver, verlib;
 	CDN_API_General_getCurVersion(state, &ver, &verlib);
 	printk("FIRMWARE VERSION: %d, LIB VERSION: %d\n", ver, verlib);
 }

 u16 internal_get_msg_len(state_struct *state)
 {
 	return ((u16) state->rxBuffer[2] << 8) | (u16) state->rxBuffer[3];
 }
	/******************************************************************************
	*
	* Copyright (C) 2016-2017 Cadence Design Systems, Inc.
	* All rights reserved worldwide.
	*
	* Redistribution and use in source and binary forms, with or without modification,
	* are permitted provided that the following conditions are met:
	*
	* 1. Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	*
	* 2. Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation and/or
	* other materials provided with the distribution.
	*
	* 3. Neither the name of the copyright holder nor the names of its contributors
	* may be used to endorse or promote products derived from this software without
	* specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
	* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
	* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
	* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
	* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
	* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	*
	* Copyright 2017-2018 NXP
	*
	******************************************************************************
	*
	* util.c
	*
	******************************************************************************
	*/
	#include "util.h"
	#include "API_General.h"
	#include "apb_cfg.h"
	#include "opcodes.h"

	int cdn_apb_read(state_struct state, u32 addr, u32 value)
	{
	struct hdp_mem *mem = state->mem;
	state->rw->read_reg(mem, addr, value);
	return 0;
	}

	int cdn_apb_write(state_struct *state, u32 addr, u32 value)
	{
	struct hdp_mem *mem = state->mem;
	state->rw->write_reg(mem, addr, value);
	return 0;
	}

	int cdn_sapb_read(state_struct state, u32 addr, u32 value)
	{
	struct hdp_mem *mem = state->mem;
	state->rw->sread_reg(mem, addr, value);
	return 0;
	}

	int cdn_sapb_write(state_struct *state, u32 addr, u32 value)
	{
	struct hdp_mem *mem = state->mem;
	state->rw->swrite_reg(mem, addr, value);
	return 0;
	}

	void cdn_sleep(u32 ms)
	{
	mdelay(ms);
	}

	void cdn_usleep(u32 us)
	{
	udelay(us);
	}

	int cdn_bus_read(state_struct state, u32 addr, u32 value)
	{
	return state->bus_type ?
	cdn_sapb_read(state, addr, value) : cdn_apb_read(state, addr,
	value);
	}

	int cdn_bus_write(state_struct *state, u32 addr, u32 value)
	{
	return state->bus_type ?
	cdn_sapb_write(state, addr, value) : cdn_apb_write(state, addr,
	value);
	}

	void internal_itobe(int val, volatile u8 *dest, int bytes)
	{
	int i;
	for (i = bytes - 1; i >= 0; --i) {
	dest[i] = (u8) val;
	val >>= 8;
	}
	}

	u32 internal_betoi(volatile u8 const *src, u8 bytes)
	{
	u32 ret = 0;
	int i;

	if (bytes > sizeof(ret)) {
	printk
	("Warning. Read request for payload larger then supported.\n");
	bytes = sizeof(ret);

	}

	for (i = 0; i < bytes; ++i) {
	ret <<= 8;
	ret \|= (u32) src[i];
	}

	return ret;
	}

	u32 internal_mkmsg(volatile u8 *dest, int valNo, ...)
	{
	va_list vl;
	u32 len = 0;
	va_start(vl, valNo);
	len = internal_vmkmsg(dest, valNo, vl);
	va_end(vl);
	return len;
	}

	u32 internal_vmkmsg(volatile u8 *dest, int valNo, va_list vl)
	{
	u32 len = 0;
	int i;
	for (i = 0; i < valNo; ++i) {
	int size = va_arg(vl, int);
	if (size > 0) {
	internal_itobe(va_arg(vl, int), dest, size);
	dest += size;
	len += size;;
	} else {
	memcpy((void )dest, va_arg(vl, void ), -size);
	dest -= size;
	len -= size;
	}
	}
	return len;
	}

	void internal_tx_mkfullmsg(state_struct *state, u8 module, u8 opcode,
	int valNo, ...)
	{
	va_list vl;
	va_start(vl, valNo);
	internal_vtx_mkfullmsg(state, module, opcode, valNo, vl);
	va_end(vl);
	}

	void internal_vtx_mkfullmsg(state_struct *state, u8 module, u8 opcode,
	int valNo, va_list vl)
	{
	u32 len =
	internal_vmkmsg(state->txBuffer + INTERNAL_CMD_HEAD_SIZE, valNo,
	vl);
	internal_mbox_tx_enable(state, module, opcode, len);
	state->txEnable = 1;
	state->running = 1;
	}

	void internal_readmsg(state_struct *state, int valNo, ...)
	{
	va_list vl;
	va_start(vl, valNo);
	internal_vreadmsg(state, valNo, vl);
	va_end(vl);
	}

	void internal_vreadmsg(state_struct *state, int valNo, va_list vl)
	{
	u8 *src = state->rxBuffer + INTERNAL_CMD_HEAD_SIZE;
	size_t i;

	for (i = 0; i < (size_t) valNo; ++i) {
	int size = va_arg(vl, int);
	void ptr = va_arg(vl, void );

	if (!ptr) {
	src += size;
	} else if (!size) {
	((u8 *) ptr) = src;
	} else if (size > 0) {
	switch ((size_t) size) {
	case sizeof(u8):
	((u8 ) ptr) = internal_betoi(src, size);
	break;
	case sizeof(u16):
	((u16 ) ptr) = internal_betoi(src, size);
	break;
	case 3: // 3-byte value (e.g. DPCD address) can be safely converted from BE
	case sizeof(u32):
	((u32 ) ptr) = internal_betoi(src, size);
	break;
	default:
	pr_warn("Warning. Unsupported variable size.\n");
	memcpy(ptr, src, size);
	};

	src += size;
	} else {
	memcpy(ptr, src, -size);
	src -= size;
	}
	}
	}

	INTERNAL_MBOX_STATUS mailbox_write(state_struct *state, u8 val)
	{
	INTERNAL_MBOX_STATUS ret = { 0, 0, 0, 0 };
	u32 full;
	if (cdn_bus_read(state, MAILBOX_FULL_ADDR << 2, &full)) {
	ret.tx_status = CDN_TX_APB_ERROR;
	return ret;
	}
	if (full) {
	ret.tx_status = CDN_TX_FULL;
	return ret;
	}
	if (cdn_bus_write(state, MAILBOX0_WR_DATA << 2, val)) {
	ret.tx_status = CDN_TX_APB_ERROR;
	return ret;
	}
	ret.tx_status = CDN_TX_WRITE;
	return ret;
	}

	INTERNAL_MBOX_STATUS mailbox_read(state_struct state, volatile u8 val)
	{
	INTERNAL_MBOX_STATUS ret = { 0, 0, 0, 0 };
	u32 empty;
	u32 rd;
	if (cdn_bus_read(state, MAILBOX_EMPTY_ADDR << 2, &empty)) {
	ret.rx_status = CDN_RX_APB_ERROR;
	return ret;
	}
	if (empty) {
	ret.rx_status = CDN_RX_EMPTY;
	return ret;
	}
	if (cdn_bus_read(state, MAILBOX0_RD_DATA << 2, &rd)) {
	ret.rx_status = CDN_RX_APB_ERROR;
	return ret;
	}
	*val = (u8) rd;
	ret.rx_status = CDN_RX_READ;
	return ret;
	}

	INTERNAL_MBOX_STATUS internal_mbox_tx_process(state_struct *state)
	{
	u32 txCount = 0;
	u32 length = (u32) state->txBuffer[2] << 8 \| (u32) state->txBuffer[3];
	INTERNAL_MBOX_STATUS ret = {.txend = 0 };
	INTERNAL_MBOX_STATUS tx_ret;

	ret.tx_status = CDN_TX_NOTHING;
	if (!state->txEnable)
	return ret;
	while ((tx_ret.tx_status =
	mailbox_write(state, state->txBuffer[state->txi]).tx_status) ==
	CDN_TX_WRITE) {
	txCount++;
	if (++state->txi >= length + 4) {
	state->txEnable = 0;
	state->txi = 0;
	ret.txend = 1;
	break;
	}
	}
	if (txCount && tx_ret.tx_status == CDN_TX_FULL)
	ret.tx_status = CDN_TX_WRITE;
	else
	ret.tx_status = tx_ret.tx_status;
	return ret;
	}

	INTERNAL_MBOX_STATUS internal_mbox_rx_process(state_struct *state)
	{
	u32 rxCount = 0;
	INTERNAL_MBOX_STATUS ret = { 0, 0, 0, 0 };
	INTERNAL_MBOX_STATUS rx_ret;
	while ((rx_ret.rx_status =
	mailbox_read(state, state->rxBuffer + state->rxi).rx_status) ==
	CDN_RX_READ) {
	rxCount++;
	if (++state->rxi >=
	4 +
	((u32) state->rxBuffer[2] << 8 \| (u32) state->
	rxBuffer[3])) {
	state->rxi = 0;
	ret.rxend = 1;
	state->rxEnable = 0;
	break;
	}
	}
	ret.rx_status = rxCount ? CDN_RX_READ : CDN_RX_EMPTY;
	return ret;
	}

	u32 internal_apb_available(state_struct *state)
	{
	return !(state->rxEnable \|\| state->txEnable);
	}

	void internal_mbox_tx_enable(state_struct *state, u8 module, u8 opcode,
	u16 length)
	{
	state->txBuffer[0] = opcode;
	state->txBuffer[1] = module;
	state->txBuffer[2] = (u8) (length >> 8);
	state->txBuffer[3] = (u8) length;
	state->txEnable = 1;
	}

	CDN_API_STATUS internal_test_rx_head(state_struct *state, u8 module, u8 opcode)
	{
	if (opcode != state->rxBuffer[0])
	return CDN_BAD_OPCODE;
	if (module != state->rxBuffer[1])
	return CDN_BAD_MODULE;
	return CDN_OK;
	}

	CDN_API_STATUS internal_test_rx_head_match(state_struct *state)
	{
	return internal_test_rx_head(state, state->txBuffer[1],
	state->txBuffer[0]);
	}

	void print_fw_ver(state_struct *state)
	{
	u16 ver, verlib;
	CDN_API_General_getCurVersion(state, &ver, &verlib);
	printk("FIRMWARE VERSION: %d, LIB VERSION: %d\n", ver, verlib);
	}

	u16 internal_get_msg_len(state_struct *state)
	{
	return ((u16) state->rxBuffer[2] << 8) \| (u16) state->rxBuffer[3];
	}