| /* |
| * 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; |
| } |