dhdutil: Update to support driver 1.88.X

Change-Id: I1534b89fb483fd7d28c8ed1219bcbe1d1e7c4f45
Signed-off-by: Dmitry Shmidt <dimitrysh@google.com>

1 files changed, 263 insertions, 0 deletions

diff --git a/bcmdhd/dhdutil/ucode_download.c b/bcmdhd/dhdutil/ucode_download.c
new file mode 100644
index 0000000..0dd08af
--- /dev/null
+++ b/bcmdhd/dhdutil/ucode_download.c
@@ -0,0 +1,263 @@
+/*
+ * Ucode download related utility functions
+ *
+ * Copyright (C) 1999-2013, Broadcom Corporation
+ * 
+ * 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.
+ *
+ * $Id: ucode_download.c 297277 2011-11-18 14:10:09Z $
+ */
+
+#include <unistd.h>
+#include <errno.h>
+#include <trxhdr.h>
+#include <bcmendian.h>
+#include <wlu_common.h>
+
+#define DEVPRESENT_DELAY  10000	/* in microsecs */
+#define DEVPRESENT_RETRIES   100
+
+extern int wl_validatedev(void *dev_handle);
+
+int
+dload_generic_data(void *wl, uint16 dload_type, unsigned char *dload_buf, int len)
+{
+	struct wl_dload_data *dload_ptr = (struct wl_dload_data *)dload_buf;
+	int err = 0;
+	int actual_data_offset;
+	char *buf;
+
+	actual_data_offset = OFFSETOF(struct wl_dload_data, data);
+	dload_ptr->flag = (DLOAD_HANDLER_VER << DLOAD_FLAG_VER_SHIFT);
+	dload_ptr->flag |= DL_CRC_NOT_INUSE;
+	dload_ptr->dload_type = dload_type;
+	dload_ptr->len = htod32(len - actual_data_offset);
+	dload_ptr->crc = 0;
+
+	len = len + 8 - (len%8);
+
+	buf = malloc(WLC_IOCTL_MEDLEN);
+	if (buf) {
+		bzero(buf, WLC_IOCTL_MEDLEN);
+		err = wlu_iovar_setbuf(wl, "generic_dload", dload_buf, len, buf,
+			WLC_IOCTL_MEDLEN);
+	}
+	free(buf);
+	return err;
+}
+
+int
+dload_ucode_part(void *wl, uint8 ucode_type, uint32 datalen, unsigned char *org_buf)
+{
+	int num_chunks, chunk_len, cumulative_len = 0;
+	int size2alloc, ucode_chunk_len = 0;
+	unsigned char *new_buf;
+	struct wl_ucode_info *ucode_ptr;
+	int err = 0, ucode_offset, chunk_offset;
+
+	ucode_offset = OFFSETOF(wl_dload_data_t, data);
+	chunk_offset = OFFSETOF(wl_ucode_info_t, data_chunk);
+
+	err = wlu_iovar_getint(wl, "ucdload_chunk_len",
+		&ucode_chunk_len);
+	if (err) {
+		printf("err in getting ucode chunk len, exiting\n");
+		return err;
+	}
+
+	num_chunks = datalen/ucode_chunk_len;
+	if (datalen % ucode_chunk_len != 0)
+		num_chunks++;
+	size2alloc = ucode_offset + chunk_offset + ucode_chunk_len;
+
+	/* single chunk buffer */
+	new_buf = (unsigned char *)malloc(size2alloc);
+	memset(new_buf, 0, size2alloc);
+	ucode_ptr = (struct wl_ucode_info *)((uint8 *)new_buf+ucode_offset);
+	ucode_ptr->ucode_type = ucode_type;
+	ucode_ptr->num_chunks = num_chunks;
+	do {
+		if (datalen >= ucode_chunk_len)
+			chunk_len = ucode_chunk_len;
+		else
+			chunk_len = datalen;
+		memset(new_buf+ucode_offset+chunk_offset, 0, size2alloc-ucode_offset-chunk_offset);
+		ucode_ptr->chunk_len = htod32(chunk_len);
+		ucode_ptr->chunk_num++;
+		memcpy(&ucode_ptr->data_chunk[0], org_buf + cumulative_len, chunk_len);
+		cumulative_len += chunk_len;
+		err = dload_generic_data(wl, DL_TYPE_UCODE, new_buf, size2alloc);
+		if (err) {
+			printf("error while writing %s to the memory\n",
+				(ucode_type == UCODE_FW)? "ucode" : "initvals");
+			break;
+		}
+		datalen = datalen - chunk_len;
+	} while (datalen > 0);
+	free(new_buf);
+
+	return err;
+}
+
+static int
+check_ucode_file(unsigned char *headers)
+{
+	struct trx_header *trx;
+	int actual_data_len = -1;
+
+	/* Extract trx header */
+	trx = (struct trx_header *)headers;
+	if (trx->magic != TRX_MAGIC) {
+		printf("Error: trx bad hdr\n");
+		goto err;
+	}
+	actual_data_len = ROUNDUP(trx->offsets[0], 4) + ROUNDUP(trx->offsets[1], 4);
+err:
+	return actual_data_len;
+}
+
+int
+proc_ucode_download(char* fw_filename, void *dev_handle)
+{
+	FILE *fp = NULL;
+	int ret = 0, loopcnt = 0;
+	struct trx_header main_trx_hdr, *ucode_trx_hdr;
+	uint32 maintrx_hdr_len, tmp_len;
+	uint32 fw_size, second_offset, ucode_trx_offset;
+	long ucode_pos;
+	unsigned long ucode_info_len = 0, status;
+	unsigned char *ucodetrx_buf, *initvals_ptr;
+	int ucode_len, initvals_len;
+	int ucdload_status = 0;
+	int is_devpresent;
+
+	/* read the file and push blocks down to memory */
+	if ((fp = fopen(fw_filename, "rb")) == NULL) {
+		fprintf(stderr, "%s: unable to open %s: %s\n",
+		        __FUNCTION__, fw_filename, strerror(errno));
+		ret = -1;
+		goto exit;
+	}
+
+	maintrx_hdr_len = sizeof(struct trx_header);
+	tmp_len = fread(&main_trx_hdr, sizeof(uint8), maintrx_hdr_len, fp);
+
+	if (tmp_len == maintrx_hdr_len) {
+		if (main_trx_hdr.magic == TRX_MAGIC) {
+			fw_size = main_trx_hdr.offsets[0];
+			second_offset = main_trx_hdr.offsets[2];
+
+			if (second_offset == maintrx_hdr_len) {
+				second_offset = 0;
+			}
+			ucode_trx_offset = maintrx_hdr_len +
+				ROUNDUP(fw_size, 4) + ROUNDUP(second_offset, 4);
+			ucode_pos = fseek(fp, ucode_trx_offset, SEEK_SET);
+			BCM_REFERENCE(ucode_pos);
+
+			if ((ucode_trx_hdr = malloc(sizeof(struct trx_header)))
+				== NULL) {
+				printf("Unable to allocate %d bytes!\n", maintrx_hdr_len);
+				ret = -ENOMEM;
+				goto exit;
+			}
+
+			/* Read ONLY the firmware-file-header into the new_buffer */
+			status = fread(ucode_trx_hdr, sizeof(uint8),
+				maintrx_hdr_len, fp);
+			if (status < sizeof(struct trx_header)) {
+				printf("Short read in hdr read for %s!\n", fw_filename);
+				ret = -EINVAL;
+				goto exit;
+			}
+
+			if ((ucode_info_len = check_ucode_file(
+				(unsigned char *)ucode_trx_hdr)) <= 0) {
+				printf("not a valid ucode.trx\n");
+				ret = -1;
+				goto exit;
+			}
+
+			ucodetrx_buf = (unsigned char *)malloc(ucode_info_len *
+				sizeof(char));
+			tmp_len = fread(ucodetrx_buf, sizeof(uint8),
+				ucode_info_len, fp);
+			if (ucode_info_len > 0) {
+				ucode_len = ucode_trx_hdr->offsets[0];
+				initvals_ptr = ucodetrx_buf +
+					ROUNDUP(ucode_trx_hdr->offsets[0], 4);
+				initvals_len = ucode_trx_hdr->offsets[1];
+			}
+			free(ucode_trx_hdr);
+
+			init_cmd_batchingmode();
+			do {
+				is_devpresent = wl_validatedev(dev_handle);
+				loopcnt++;
+				/* in USB after dongle fw starts running wl interface
+				might not appear in the list of interfaces immediately, hence try
+				after some delay of 10ms
+				*/
+				if (!is_devpresent)
+					usleep(DEVPRESENT_DELAY);
+				else {
+						/* below iovar to verify if the for foundout
+						interface has already ucode been downloaded
+						*/
+						ret = wlu_iovar_getint(dev_handle, "ucdload_status",
+							&ucdload_status);
+						if (ret) {
+							printf("err in ucdload_status, exiting\n");
+							goto exit;
+						}
+						if (ucdload_status) {
+							/* Number of 'wl' interfaces to skip
+							in the next round of going thru wl_find
+							*/
+							printf("ucode is already downloaded\n");
+						}
+				}
+			/* usb seems to take some time to come up, hence the
+			loop value of 100
+			*/
+			} while (loopcnt < DEVPRESENT_RETRIES && !is_devpresent);
+
+			if (loopcnt < DEVPRESENT_RETRIES) {
+				/* download the ucode fw */
+				ret = dload_ucode_part(dev_handle, UCODE_FW, ucode_len,
+					ucodetrx_buf);
+				if (ret) {
+					printf("error while downloading ucode, exiting\n");
+					goto exit;
+				}
+				/* download the initvals to the dongle */
+				ret = dload_ucode_part(dev_handle, INIT_VALS,
+					initvals_len, initvals_ptr);
+
+				if (ret) {
+					printf("error while downloading initvals, exiting\n");
+					goto exit;
+				}
+			}
+			else {
+				printf("wl device is not present\n");
+			}
+			free(ucodetrx_buf);
+		}
+	}
+
+exit:
+	if (fp)
+		fclose(fp);
+	return ret;
+}