You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
264 lines
7.4 KiB
264 lines
7.4 KiB
/*
|
|
* 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;
|
|
}
|