drivers/net/wireless/ath/ath6kl/bmi.c - nest-cam/v366/kernel_backports - Git at Google

 /*
  * Copyright (c) 2004-2011 Atheros Communications Inc.
  * Copyright (c) 2011-2012 Qualcomm Atheros, Inc.
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */

 #include "core.h"
 #include "hif-ops.h"
 #include "target.h"
 #include "debug.h"

 int ath6kl_bmi_done(struct ath6kl *ar)
 {
 	int ret;
 	u32 cid = BMI_DONE;

 	if (ar->bmi.done_sent) {
 		ath6kl_dbg(ATH6KL_DBG_BMI, "bmi done skipped\n");
 		return 0;
 	}

 	ar->bmi.done_sent = true;

 	ret = ath6kl_hif_bmi_write(ar, (u8 *)&cid, sizeof(cid));
 	if (ret) {
 		ath6kl_err("Unable to send bmi done: %d\n", ret);
 		return ret;
 	}

 	return 0;
 }

 int ath6kl_bmi_get_target_info(struct ath6kl *ar,
 			       struct ath6kl_bmi_target_info *targ_info)
 {
 	int ret;
 	u32 cid = BMI_GET_TARGET_INFO;

 	if (ar->bmi.done_sent) {
 		ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
 		return -EACCES;
 	}

 	ret = ath6kl_hif_bmi_write(ar, (u8 *)&cid, sizeof(cid));
 	if (ret) {
 		ath6kl_err("Unable to send get target info: %d\n", ret);
 		return ret;
 	}

 	if (ar->hif_type == ATH6KL_HIF_TYPE_USB) {
 		ret = ath6kl_hif_bmi_read(ar, (u8 *)targ_info,
 					  sizeof(*targ_info));
 	} else {
 		ret = ath6kl_hif_bmi_read(ar, (u8 *)&targ_info->version,
 				sizeof(targ_info->version));
 	}

 	if (ret) {
 		ath6kl_err("Unable to recv target info: %d\n", ret);
 		return ret;
 	}

 	if (le32_to_cpu(targ_info->version) == TARGET_VERSION_SENTINAL) {
 		/* Determine how many bytes are in the Target's targ_info */
 		ret = ath6kl_hif_bmi_read(ar,
 				   (u8 *)&targ_info->byte_count,
 				   sizeof(targ_info->byte_count));
 		if (ret) {
 			ath6kl_err("unable to read target info byte count: %d\n",
 				   ret);
 			return ret;
 		}

 		/*
 		 * The target's targ_info doesn't match the host's targ_info.
 		 * We need to do some backwards compatibility to make this work.
 		 */
 		if (le32_to_cpu(targ_info->byte_count) != sizeof(*targ_info)) {
 			WARN_ON(1);
 			return -EINVAL;
 		}

 		/* Read the remainder of the targ_info */
 		ret = ath6kl_hif_bmi_read(ar,
 				   ((u8 *)targ_info) +
 				   sizeof(targ_info->byte_count),
 				   sizeof(*targ_info) -
 				   sizeof(targ_info->byte_count));

 		if (ret) {
 			ath6kl_err("Unable to read target info (%d bytes): %d\n",
 				   targ_info->byte_count, ret);
 			return ret;
 		}
 	}

 	ath6kl_dbg(ATH6KL_DBG_BMI, "target info (ver: 0x%x type: 0x%x)\n",
 		   targ_info->version, targ_info->type);

 	return 0;
 }

 int ath6kl_bmi_read(struct ath6kl *ar, u32 addr, u8 *buf, u32 len)
 {
 	u32 cid = BMI_READ_MEMORY;
 	int ret;
 	u32 offset;
 	u32 len_remain, rx_len;
 	u16 size;

 	if (ar->bmi.done_sent) {
 		ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
 		return -EACCES;
 	}

 	size = ar->bmi.max_data_size + sizeof(cid) + sizeof(addr) + sizeof(len);
 	if (size > ar->bmi.max_cmd_size) {
 		WARN_ON(1);
 		return -EINVAL;
 	}
 	memset(ar->bmi.cmd_buf, 0, size);

 	ath6kl_dbg(ATH6KL_DBG_BMI,
 		   "bmi read memory: device: addr: 0x%x, len: %d\n",
 		   addr, len);

 	len_remain = len;

 	while (len_remain) {
 		rx_len = (len_remain < ar->bmi.max_data_size) ?
 					len_remain : ar->bmi.max_data_size;
 		offset = 0;
 		memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
 		offset += sizeof(cid);
 		memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
 		offset += sizeof(addr);
 		memcpy(&(ar->bmi.cmd_buf[offset]), &rx_len, sizeof(rx_len));
 		offset += sizeof(len);

 		ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
 		if (ret) {
 			ath6kl_err("Unable to write to the device: %d\n",
 				   ret);
 			return ret;
 		}
 		ret = ath6kl_hif_bmi_read(ar, ar->bmi.cmd_buf, rx_len);
 		if (ret) {
 			ath6kl_err("Unable to read from the device: %d\n",
 				   ret);
 			return ret;
 		}
 		memcpy(&buf[len - len_remain], ar->bmi.cmd_buf, rx_len);
 		len_remain -= rx_len; addr += rx_len;
 	}

 	return 0;
 }

 int ath6kl_bmi_write(struct ath6kl *ar, u32 addr, u8 *buf, u32 len)
 {
 	u32 cid = BMI_WRITE_MEMORY;
 	int ret;
 	u32 offset;
 	u32 len_remain, tx_len;
 	const u32 header = sizeof(cid) + sizeof(addr) + sizeof(len);
 	u8 aligned_buf[400];
 	u8 *src;

 	if (ar->bmi.done_sent) {
 		ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
 		return -EACCES;
 	}

 	if ((ar->bmi.max_data_size + header) > ar->bmi.max_cmd_size) {
 		WARN_ON(1);
 		return -EINVAL;
 	}

 	if (WARN_ON(ar->bmi.max_data_size > sizeof(aligned_buf)))
 		return -E2BIG;

 	memset(ar->bmi.cmd_buf, 0, ar->bmi.max_data_size + header);

 	ath6kl_dbg(ATH6KL_DBG_BMI,
 		   "bmi write memory: addr: 0x%x, len: %d\n", addr, len);

 	len_remain = len;
 	while (len_remain) {
 		src = &buf[len - len_remain];

 		if (len_remain < (ar->bmi.max_data_size - header)) {
 			if (len_remain & 3) {
 				/* align it with 4 bytes */
 				len_remain = len_remain +
 					     (4 - (len_remain & 3));
 				memcpy(aligned_buf, src, len_remain);
 				src = aligned_buf;
 			}
 			tx_len = len_remain;
 		} else {
 			tx_len = (ar->bmi.max_data_size - header);
 		}

 		offset = 0;
 		memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
 		offset += sizeof(cid);
 		memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
 		offset += sizeof(addr);
 		memcpy(&(ar->bmi.cmd_buf[offset]), &tx_len, sizeof(tx_len));
 		offset += sizeof(tx_len);
 		memcpy(&(ar->bmi.cmd_buf[offset]), src, tx_len);
 		offset += tx_len;

 		ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
 		if (ret) {
 			ath6kl_err("Unable to write to the device: %d\n",
 				   ret);
 			return ret;
 		}
 		len_remain -= tx_len; addr += tx_len;
 	}

 	return 0;
 }

 int ath6kl_bmi_execute(struct ath6kl *ar, u32 addr, u32 *param)
 {
 	u32 cid = BMI_EXECUTE;
 	int ret;
 	u32 offset;
 	u16 size;

 	if (ar->bmi.done_sent) {
 		ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
 		return -EACCES;
 	}

 	size = sizeof(cid) + sizeof(addr) + sizeof(param);
 	if (size > ar->bmi.max_cmd_size) {
 		WARN_ON(1);
 		return -EINVAL;
 	}
 	memset(ar->bmi.cmd_buf, 0, size);

 	ath6kl_dbg(ATH6KL_DBG_BMI, "bmi execute: addr: 0x%x, param: %d)\n",
 		   addr, *param);

 	offset = 0;
 	memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
 	offset += sizeof(cid);
 	memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
 	offset += sizeof(addr);
 	memcpy(&(ar->bmi.cmd_buf[offset]), param, sizeof(*param));
 	offset += sizeof(*param);

 	ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
 	if (ret) {
 		ath6kl_err("Unable to write to the device: %d\n", ret);
 		return ret;
 	}

 	ret = ath6kl_hif_bmi_read(ar, ar->bmi.cmd_buf, sizeof(*param));
 	if (ret) {
 		ath6kl_err("Unable to read from the device: %d\n", ret);
 		return ret;
 	}

 	memcpy(param, ar->bmi.cmd_buf, sizeof(*param));

 	return 0;
 }

 int ath6kl_bmi_set_app_start(struct ath6kl *ar, u32 addr)
 {
 	u32 cid = BMI_SET_APP_START;
 	int ret;
 	u32 offset;
 	u16 size;

 	if (ar->bmi.done_sent) {
 		ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
 		return -EACCES;
 	}

 	size = sizeof(cid) + sizeof(addr);
 	if (size > ar->bmi.max_cmd_size) {
 		WARN_ON(1);
 		return -EINVAL;
 	}
 	memset(ar->bmi.cmd_buf, 0, size);

 	ath6kl_dbg(ATH6KL_DBG_BMI, "bmi set app start: addr: 0x%x\n", addr);

 	offset = 0;
 	memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
 	offset += sizeof(cid);
 	memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
 	offset += sizeof(addr);

 	ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
 	if (ret) {
 		ath6kl_err("Unable to write to the device: %d\n", ret);
 		return ret;
 	}

 	return 0;
 }

 int ath6kl_bmi_reg_read(struct ath6kl *ar, u32 addr, u32 *param)
 {
 	u32 cid = BMI_READ_SOC_REGISTER;
 	int ret;
 	u32 offset;
 	u16 size;

 	if (ar->bmi.done_sent) {
 		ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
 		return -EACCES;
 	}

 	size = sizeof(cid) + sizeof(addr);
 	if (size > ar->bmi.max_cmd_size) {
 		WARN_ON(1);
 		return -EINVAL;
 	}
 	memset(ar->bmi.cmd_buf, 0, size);

 	ath6kl_dbg(ATH6KL_DBG_BMI, "bmi read SOC reg: addr: 0x%x\n", addr);

 	offset = 0;
 	memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
 	offset += sizeof(cid);
 	memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
 	offset += sizeof(addr);

 	ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
 	if (ret) {
 		ath6kl_err("Unable to write to the device: %d\n", ret);
 		return ret;
 	}

 	ret = ath6kl_hif_bmi_read(ar, ar->bmi.cmd_buf, sizeof(*param));
 	if (ret) {
 		ath6kl_err("Unable to read from the device: %d\n", ret);
 		return ret;
 	}
 	memcpy(param, ar->bmi.cmd_buf, sizeof(*param));

 	return 0;
 }

 int ath6kl_bmi_reg_write(struct ath6kl *ar, u32 addr, u32 param)
 {
 	u32 cid = BMI_WRITE_SOC_REGISTER;
 	int ret;
 	u32 offset;
 	u16 size;

 	if (ar->bmi.done_sent) {
 		ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
 		return -EACCES;
 	}

 	size = sizeof(cid) + sizeof(addr) + sizeof(param);
 	if (size > ar->bmi.max_cmd_size) {
 		WARN_ON(1);
 		return -EINVAL;
 	}
 	memset(ar->bmi.cmd_buf, 0, size);

 	ath6kl_dbg(ATH6KL_DBG_BMI,
 		   "bmi write SOC reg: addr: 0x%x, param: %d\n",
 		    addr, param);

 	offset = 0;
 	memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
 	offset += sizeof(cid);
 	memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
 	offset += sizeof(addr);
 	memcpy(&(ar->bmi.cmd_buf[offset]), &param, sizeof(param));
 	offset += sizeof(param);

 	ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
 	if (ret) {
 		ath6kl_err("Unable to write to the device: %d\n", ret);
 		return ret;
 	}

 	return 0;
 }

 int ath6kl_bmi_lz_data(struct ath6kl *ar, u8 *buf, u32 len)
 {
 	u32 cid = BMI_LZ_DATA;
 	int ret;
 	u32 offset;
 	u32 len_remain, tx_len;
 	const u32 header = sizeof(cid) + sizeof(len);
 	u16 size;

 	if (ar->bmi.done_sent) {
 		ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
 		return -EACCES;
 	}

 	size = ar->bmi.max_data_size + header;
 	if (size > ar->bmi.max_cmd_size) {
 		WARN_ON(1);
 		return -EINVAL;
 	}
 	memset(ar->bmi.cmd_buf, 0, size);

 	ath6kl_dbg(ATH6KL_DBG_BMI, "bmi send LZ data: len: %d)\n",
 		   len);

 	len_remain = len;
 	while (len_remain) {
 		tx_len = (len_remain < (ar->bmi.max_data_size - header)) ?
 			  len_remain : (ar->bmi.max_data_size - header);

 		offset = 0;
 		memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
 		offset += sizeof(cid);
 		memcpy(&(ar->bmi.cmd_buf[offset]), &tx_len, sizeof(tx_len));
 		offset += sizeof(tx_len);
 		memcpy(&(ar->bmi.cmd_buf[offset]), &buf[len - len_remain],
 		       tx_len);
 		offset += tx_len;

 		ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
 		if (ret) {
 			ath6kl_err("Unable to write to the device: %d\n",
 				   ret);
 			return ret;
 		}

 		len_remain -= tx_len;
 	}

 	return 0;
 }

 int ath6kl_bmi_lz_stream_start(struct ath6kl *ar, u32 addr)
 {
 	u32 cid = BMI_LZ_STREAM_START;
 	int ret;
 	u32 offset;
 	u16 size;

 	if (ar->bmi.done_sent) {
 		ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
 		return -EACCES;
 	}

 	size = sizeof(cid) + sizeof(addr);
 	if (size > ar->bmi.max_cmd_size) {
 		WARN_ON(1);
 		return -EINVAL;
 	}
 	memset(ar->bmi.cmd_buf, 0, size);

 	ath6kl_dbg(ATH6KL_DBG_BMI,
 		   "bmi LZ stream start: addr: 0x%x)\n",
 		    addr);

 	offset = 0;
 	memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
 	offset += sizeof(cid);
 	memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
 	offset += sizeof(addr);

 	ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
 	if (ret) {
 		ath6kl_err("Unable to start LZ stream to the device: %d\n",
 			   ret);
 		return ret;
 	}

 	return 0;
 }

 int ath6kl_bmi_fast_download(struct ath6kl *ar, u32 addr, u8 *buf, u32 len)
 {
 	int ret;
 	u32 last_word = 0;
 	u32 last_word_offset = len & ~0x3;
 	u32 unaligned_bytes = len & 0x3;

 	ret = ath6kl_bmi_lz_stream_start(ar, addr);
 	if (ret)
 		return ret;

 	if (unaligned_bytes) {
 		/* copy the last word into a zero padded buffer */
 		memcpy(&last_word, &buf[last_word_offset], unaligned_bytes);
 	}

 	ret = ath6kl_bmi_lz_data(ar, buf, last_word_offset);
 	if (ret)
 		return ret;

 	if (unaligned_bytes)
 		ret = ath6kl_bmi_lz_data(ar, (u8 *)&last_word, 4);

 	if (!ret) {
 		/* Close compressed stream and open a new (fake) one.
 		 * This serves mainly to flush Target caches. */
 		ret = ath6kl_bmi_lz_stream_start(ar, 0x00);
 	}
 	return ret;
 }

 void ath6kl_bmi_reset(struct ath6kl *ar)
 {
 	ar->bmi.done_sent = false;
 }

 int ath6kl_bmi_init(struct ath6kl *ar)
 {
 	if (WARN_ON(ar->bmi.max_data_size == 0))
 		return -EINVAL;

 	/* cmd + addr + len + data_size */
 	ar->bmi.max_cmd_size = ar->bmi.max_data_size + (sizeof(u32) * 3);

 	ar->bmi.cmd_buf = kzalloc(ar->bmi.max_cmd_size, GFP_ATOMIC);
 	if (!ar->bmi.cmd_buf)
 		return -ENOMEM;

 	return 0;
 }

 void ath6kl_bmi_cleanup(struct ath6kl *ar)
 {
 	kfree(ar->bmi.cmd_buf);
 	ar->bmi.cmd_buf = NULL;
 }
	/*
	* Copyright (c) 2004-2011 Atheros Communications Inc.
	* Copyright (c) 2011-2012 Qualcomm Atheros, Inc.
	*
	* Permission to use, copy, modify, and/or distribute this software for any
	* purpose with or without fee is hereby granted, provided that the above
	* copyright notice and this permission notice appear in all copies.
	*
	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	*/

	#include "core.h"
	#include "hif-ops.h"
	#include "target.h"
	#include "debug.h"

	int ath6kl_bmi_done(struct ath6kl *ar)
	{
	int ret;
	u32 cid = BMI_DONE;

	if (ar->bmi.done_sent) {
	ath6kl_dbg(ATH6KL_DBG_BMI, "bmi done skipped\n");
	return 0;
	}

	ar->bmi.done_sent = true;

	ret = ath6kl_hif_bmi_write(ar, (u8 *)&cid, sizeof(cid));
	if (ret) {
	ath6kl_err("Unable to send bmi done: %d\n", ret);
	return ret;
	}

	return 0;
	}

	int ath6kl_bmi_get_target_info(struct ath6kl *ar,
	struct ath6kl_bmi_target_info *targ_info)
	{
	int ret;
	u32 cid = BMI_GET_TARGET_INFO;

	if (ar->bmi.done_sent) {
	ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
	return -EACCES;
	}

	ret = ath6kl_hif_bmi_write(ar, (u8 *)&cid, sizeof(cid));
	if (ret) {
	ath6kl_err("Unable to send get target info: %d\n", ret);
	return ret;
	}

	if (ar->hif_type == ATH6KL_HIF_TYPE_USB) {
	ret = ath6kl_hif_bmi_read(ar, (u8 *)targ_info,
	sizeof(*targ_info));
	} else {
	ret = ath6kl_hif_bmi_read(ar, (u8 *)&targ_info->version,
	sizeof(targ_info->version));
	}

	if (ret) {
	ath6kl_err("Unable to recv target info: %d\n", ret);
	return ret;
	}

	if (le32_to_cpu(targ_info->version) == TARGET_VERSION_SENTINAL) {
	/* Determine how many bytes are in the Target's targ_info */
	ret = ath6kl_hif_bmi_read(ar,
	(u8 *)&targ_info->byte_count,
	sizeof(targ_info->byte_count));
	if (ret) {
	ath6kl_err("unable to read target info byte count: %d\n",
	ret);
	return ret;
	}

	/*
	* The target's targ_info doesn't match the host's targ_info.
	* We need to do some backwards compatibility to make this work.
	*/
	if (le32_to_cpu(targ_info->byte_count) != sizeof(*targ_info)) {
	WARN_ON(1);
	return -EINVAL;
	}

	/* Read the remainder of the targ_info */
	ret = ath6kl_hif_bmi_read(ar,
	((u8 *)targ_info) +
	sizeof(targ_info->byte_count),
	sizeof(*targ_info) -
	sizeof(targ_info->byte_count));

	if (ret) {
	ath6kl_err("Unable to read target info (%d bytes): %d\n",
	targ_info->byte_count, ret);
	return ret;
	}
	}

	ath6kl_dbg(ATH6KL_DBG_BMI, "target info (ver: 0x%x type: 0x%x)\n",
	targ_info->version, targ_info->type);

	return 0;
	}

	int ath6kl_bmi_read(struct ath6kl ar, u32 addr, u8 buf, u32 len)
	{
	u32 cid = BMI_READ_MEMORY;
	int ret;
	u32 offset;
	u32 len_remain, rx_len;
	u16 size;

	if (ar->bmi.done_sent) {
	ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
	return -EACCES;
	}

	size = ar->bmi.max_data_size + sizeof(cid) + sizeof(addr) + sizeof(len);
	if (size > ar->bmi.max_cmd_size) {
	WARN_ON(1);
	return -EINVAL;
	}
	memset(ar->bmi.cmd_buf, 0, size);

	ath6kl_dbg(ATH6KL_DBG_BMI,
	"bmi read memory: device: addr: 0x%x, len: %d\n",
	addr, len);

	len_remain = len;

	while (len_remain) {
	rx_len = (len_remain < ar->bmi.max_data_size) ?
	len_remain : ar->bmi.max_data_size;
	offset = 0;
	memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
	offset += sizeof(cid);
	memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
	offset += sizeof(addr);
	memcpy(&(ar->bmi.cmd_buf[offset]), &rx_len, sizeof(rx_len));
	offset += sizeof(len);

	ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
	if (ret) {
	ath6kl_err("Unable to write to the device: %d\n",
	ret);
	return ret;
	}
	ret = ath6kl_hif_bmi_read(ar, ar->bmi.cmd_buf, rx_len);
	if (ret) {
	ath6kl_err("Unable to read from the device: %d\n",
	ret);
	return ret;
	}
	memcpy(&buf[len - len_remain], ar->bmi.cmd_buf, rx_len);
	len_remain -= rx_len; addr += rx_len;
	}

	return 0;
	}

	int ath6kl_bmi_write(struct ath6kl ar, u32 addr, u8 buf, u32 len)
	{
	u32 cid = BMI_WRITE_MEMORY;
	int ret;
	u32 offset;
	u32 len_remain, tx_len;
	const u32 header = sizeof(cid) + sizeof(addr) + sizeof(len);
	u8 aligned_buf[400];
	u8 *src;

	if (ar->bmi.done_sent) {
	ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
	return -EACCES;
	}

	if ((ar->bmi.max_data_size + header) > ar->bmi.max_cmd_size) {
	WARN_ON(1);
	return -EINVAL;
	}

	if (WARN_ON(ar->bmi.max_data_size > sizeof(aligned_buf)))
	return -E2BIG;

	memset(ar->bmi.cmd_buf, 0, ar->bmi.max_data_size + header);

	ath6kl_dbg(ATH6KL_DBG_BMI,
	"bmi write memory: addr: 0x%x, len: %d\n", addr, len);

	len_remain = len;
	while (len_remain) {
	src = &buf[len - len_remain];

	if (len_remain < (ar->bmi.max_data_size - header)) {
	if (len_remain & 3) {
	/* align it with 4 bytes */
	len_remain = len_remain +
	(4 - (len_remain & 3));
	memcpy(aligned_buf, src, len_remain);
	src = aligned_buf;
	}
	tx_len = len_remain;
	} else {
	tx_len = (ar->bmi.max_data_size - header);
	}

	offset = 0;
	memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
	offset += sizeof(cid);
	memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
	offset += sizeof(addr);
	memcpy(&(ar->bmi.cmd_buf[offset]), &tx_len, sizeof(tx_len));
	offset += sizeof(tx_len);
	memcpy(&(ar->bmi.cmd_buf[offset]), src, tx_len);
	offset += tx_len;

	ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
	if (ret) {
	ath6kl_err("Unable to write to the device: %d\n",
	ret);
	return ret;
	}
	len_remain -= tx_len; addr += tx_len;
	}

	return 0;
	}

	int ath6kl_bmi_execute(struct ath6kl ar, u32 addr, u32 param)
	{
	u32 cid = BMI_EXECUTE;
	int ret;
	u32 offset;
	u16 size;

	if (ar->bmi.done_sent) {
	ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
	return -EACCES;
	}

	size = sizeof(cid) + sizeof(addr) + sizeof(param);
	if (size > ar->bmi.max_cmd_size) {
	WARN_ON(1);
	return -EINVAL;
	}
	memset(ar->bmi.cmd_buf, 0, size);

	ath6kl_dbg(ATH6KL_DBG_BMI, "bmi execute: addr: 0x%x, param: %d)\n",
	addr, *param);

	offset = 0;
	memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
	offset += sizeof(cid);
	memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
	offset += sizeof(addr);
	memcpy(&(ar->bmi.cmd_buf[offset]), param, sizeof(*param));
	offset += sizeof(*param);

	ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
	if (ret) {
	ath6kl_err("Unable to write to the device: %d\n", ret);
	return ret;
	}

	ret = ath6kl_hif_bmi_read(ar, ar->bmi.cmd_buf, sizeof(*param));
	if (ret) {
	ath6kl_err("Unable to read from the device: %d\n", ret);
	return ret;
	}

	memcpy(param, ar->bmi.cmd_buf, sizeof(*param));

	return 0;
	}

	int ath6kl_bmi_set_app_start(struct ath6kl *ar, u32 addr)
	{
	u32 cid = BMI_SET_APP_START;
	int ret;
	u32 offset;
	u16 size;

	if (ar->bmi.done_sent) {
	ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
	return -EACCES;
	}

	size = sizeof(cid) + sizeof(addr);
	if (size > ar->bmi.max_cmd_size) {
	WARN_ON(1);
	return -EINVAL;
	}
	memset(ar->bmi.cmd_buf, 0, size);

	ath6kl_dbg(ATH6KL_DBG_BMI, "bmi set app start: addr: 0x%x\n", addr);

	offset = 0;
	memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
	offset += sizeof(cid);
	memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
	offset += sizeof(addr);

	ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
	if (ret) {
	ath6kl_err("Unable to write to the device: %d\n", ret);
	return ret;
	}

	return 0;
	}

	int ath6kl_bmi_reg_read(struct ath6kl ar, u32 addr, u32 param)
	{
	u32 cid = BMI_READ_SOC_REGISTER;
	int ret;
	u32 offset;
	u16 size;

	if (ar->bmi.done_sent) {
	ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
	return -EACCES;
	}

	size = sizeof(cid) + sizeof(addr);
	if (size > ar->bmi.max_cmd_size) {
	WARN_ON(1);
	return -EINVAL;
	}
	memset(ar->bmi.cmd_buf, 0, size);

	ath6kl_dbg(ATH6KL_DBG_BMI, "bmi read SOC reg: addr: 0x%x\n", addr);

	offset = 0;
	memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
	offset += sizeof(cid);
	memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
	offset += sizeof(addr);

	ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
	if (ret) {
	ath6kl_err("Unable to write to the device: %d\n", ret);
	return ret;
	}

	ret = ath6kl_hif_bmi_read(ar, ar->bmi.cmd_buf, sizeof(*param));
	if (ret) {
	ath6kl_err("Unable to read from the device: %d\n", ret);
	return ret;
	}
	memcpy(param, ar->bmi.cmd_buf, sizeof(*param));

	return 0;
	}

	int ath6kl_bmi_reg_write(struct ath6kl *ar, u32 addr, u32 param)
	{
	u32 cid = BMI_WRITE_SOC_REGISTER;
	int ret;
	u32 offset;
	u16 size;

	if (ar->bmi.done_sent) {
	ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
	return -EACCES;
	}

	size = sizeof(cid) + sizeof(addr) + sizeof(param);
	if (size > ar->bmi.max_cmd_size) {
	WARN_ON(1);
	return -EINVAL;
	}
	memset(ar->bmi.cmd_buf, 0, size);

	ath6kl_dbg(ATH6KL_DBG_BMI,
	"bmi write SOC reg: addr: 0x%x, param: %d\n",
	addr, param);

	offset = 0;
	memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
	offset += sizeof(cid);
	memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
	offset += sizeof(addr);
	memcpy(&(ar->bmi.cmd_buf[offset]), &param, sizeof(param));
	offset += sizeof(param);

	ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
	if (ret) {
	ath6kl_err("Unable to write to the device: %d\n", ret);
	return ret;
	}

	return 0;
	}

	int ath6kl_bmi_lz_data(struct ath6kl ar, u8 buf, u32 len)
	{
	u32 cid = BMI_LZ_DATA;
	int ret;
	u32 offset;
	u32 len_remain, tx_len;
	const u32 header = sizeof(cid) + sizeof(len);
	u16 size;

	if (ar->bmi.done_sent) {
	ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
	return -EACCES;
	}

	size = ar->bmi.max_data_size + header;
	if (size > ar->bmi.max_cmd_size) {
	WARN_ON(1);
	return -EINVAL;
	}
	memset(ar->bmi.cmd_buf, 0, size);

	ath6kl_dbg(ATH6KL_DBG_BMI, "bmi send LZ data: len: %d)\n",
	len);

	len_remain = len;
	while (len_remain) {
	tx_len = (len_remain < (ar->bmi.max_data_size - header)) ?
	len_remain : (ar->bmi.max_data_size - header);

	offset = 0;
	memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
	offset += sizeof(cid);
	memcpy(&(ar->bmi.cmd_buf[offset]), &tx_len, sizeof(tx_len));
	offset += sizeof(tx_len);
	memcpy(&(ar->bmi.cmd_buf[offset]), &buf[len - len_remain],
	tx_len);
	offset += tx_len;

	ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
	if (ret) {
	ath6kl_err("Unable to write to the device: %d\n",
	ret);
	return ret;
	}

	len_remain -= tx_len;
	}

	return 0;
	}

	int ath6kl_bmi_lz_stream_start(struct ath6kl *ar, u32 addr)
	{
	u32 cid = BMI_LZ_STREAM_START;
	int ret;
	u32 offset;
	u16 size;

	if (ar->bmi.done_sent) {
	ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
	return -EACCES;
	}

	size = sizeof(cid) + sizeof(addr);
	if (size > ar->bmi.max_cmd_size) {
	WARN_ON(1);
	return -EINVAL;
	}
	memset(ar->bmi.cmd_buf, 0, size);

	ath6kl_dbg(ATH6KL_DBG_BMI,
	"bmi LZ stream start: addr: 0x%x)\n",
	addr);

	offset = 0;
	memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
	offset += sizeof(cid);
	memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
	offset += sizeof(addr);

	ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
	if (ret) {
	ath6kl_err("Unable to start LZ stream to the device: %d\n",
	ret);
	return ret;
	}

	return 0;
	}

	int ath6kl_bmi_fast_download(struct ath6kl ar, u32 addr, u8 buf, u32 len)
	{
	int ret;
	u32 last_word = 0;
	u32 last_word_offset = len & ~0x3;
	u32 unaligned_bytes = len & 0x3;

	ret = ath6kl_bmi_lz_stream_start(ar, addr);
	if (ret)
	return ret;

	if (unaligned_bytes) {
	/* copy the last word into a zero padded buffer */
	memcpy(&last_word, &buf[last_word_offset], unaligned_bytes);
	}

	ret = ath6kl_bmi_lz_data(ar, buf, last_word_offset);
	if (ret)
	return ret;

	if (unaligned_bytes)
	ret = ath6kl_bmi_lz_data(ar, (u8 *)&last_word, 4);

	if (!ret) {
	/* Close compressed stream and open a new (fake) one.
	* This serves mainly to flush Target caches. */
	ret = ath6kl_bmi_lz_stream_start(ar, 0x00);
	}
	return ret;
	}

	void ath6kl_bmi_reset(struct ath6kl *ar)
	{
	ar->bmi.done_sent = false;
	}

	int ath6kl_bmi_init(struct ath6kl *ar)
	{
	if (WARN_ON(ar->bmi.max_data_size == 0))
	return -EINVAL;

	/* cmd + addr + len + data_size */
	ar->bmi.max_cmd_size = ar->bmi.max_data_size + (sizeof(u32) * 3);

	ar->bmi.cmd_buf = kzalloc(ar->bmi.max_cmd_size, GFP_ATOMIC);
	if (!ar->bmi.cmd_buf)
	return -ENOMEM;

	return 0;
	}

	void ath6kl_bmi_cleanup(struct ath6kl *ar)
	{
	kfree(ar->bmi.cmd_buf);
	ar->bmi.cmd_buf = NULL;
	}