relms/hgicf
0
0
Fork 0
Code Activity
hgicf/utils/fwdl.c

438 lines
13 KiB
C
Raw Blame History

#ifdef __RTOS__
#include <linux/module.h>
#include <linux/types.h>
#include <linux/skbuff.h>
#else
#include <linux/version.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <linux/net.h>
#include <linux/etherdevice.h>
#include <linux/wireless.h>
#include <linux/firmware.h>
#endif
#include "../hgic_def.h"
#include "fwinfo.h"
#include "fwctrl.h"
#include "fwdl.h"
#include "utils.h"
#define BOOT_CMD_KEY "@huge-ic"
#define BOOT_CMD_KEY_SIZE 8
void hgic_bootdl_release(struct hgic_bootdl *hg, int mode)
{
if (hg == NULL) {
return;
}
hgic_dbg("Enter ...\n");
hgic_dbg("Leave ...\n");
}
u32 hgic_bootdl_init(struct hgic_bootdl *hg_fwdl, struct hgic_bus *bus, struct hgic_fwctrl *ctrl)
{
if (hg_fwdl == NULL) {
printk("%s:%d:Input para error!\n", __FUNCTION__, __LINE__);
return EINVAL;
}
hgic_dbg("Enter ...\n");
memset(hg_fwdl, 0, sizeof(struct hgic_bootdl));
hg_fwdl->checksum_mode = bus->bootdl_cksum;
hg_fwdl->frag_size = bus->bootdl_pktlen;
hg_fwdl->ctrl = ctrl;
hg_fwdl->bus = bus;
hgic_dbg("Leave ...each packet len:%d\n", hg_fwdl->frag_size);
return 0;
}
static u8 crc8(char *p_buf, u32 len)
{
return 0;
}
static struct sk_buff *hgic_bootdl_alloc_cmd_skb(struct hgic_bootdl *hg, u8 cmd_id)
{
struct sk_buff *skb = NULL;
struct hgic_bootdl_cmd_hdr *cmd_hdr = NULL;
skb = dev_alloc_skb(sizeof(struct hgic_bootdl_cmd_hdr) + 4);
if (!skb) {
return skb;
}
cmd_hdr = (struct hgic_bootdl_cmd_hdr *)skb->data;
cmd_hdr->cmd = cmd_id;
cmd_hdr->cmd_len = 12;
cmd_hdr->cmd_flag = hg->checksum_mode;
skb_put(skb, sizeof(struct hgic_bootdl_cmd_hdr));
return skb;
}
static u8 hgic_bootdl_cmd_check_val(u8 check_mode, u8 *p_buf, u32 len)
{
u8 check_value = 0;
u32 i = 0;
if (HGIC_BUS_BOOTDL_CHECK_SUM == check_mode) {
for (i = 0; i < len; i++) {
check_value += *p_buf++;
}
} else if (HGIC_BUS_BOOTDL_CHECK_CRC8 == check_mode) {
check_value = crc8(p_buf, len);
} else if (HGIC_BUS_BOOTDL_CHECK_0XFD == check_mode) {
check_value = 0xFD;
} else {
return 0;
}
return check_value;
}
static int hgic_bootdl_cmd_rsp_handle(unsigned char cmd_flag, unsigned char cmd, struct hgic_bootdl_resp_hdr *resp)
{
if (resp->check != hgic_bootdl_cmd_check_val(cmd_flag, (u8 *)&resp->cmd, 8)) {
hgic_dbg("Checksum error,return HG_BOOTDL_ERR_RSP_PACKET!\r\n");
return HG_BOOTDL_ERR_RSP_PACKET;
}
if (resp->cmd != cmd) {
hgic_dbg("Cmd not match,resp_cmd:<%d>,cmd:<%d>\n", resp->cmd, cmd);
return HG_BOOTDL_ERR_RSP_PACKET;
}
return resp->rsp;
}
struct sk_buff *hgic_bootdl_send_cmd(struct hgic_bootdl *hg_fwdl, struct sk_buff *skb, u32 timeout)
{
struct hgic_bootdl_cmd_hdr *hdr = NULL;
struct hgic_cmd_response resp;
hdr = (struct hgic_bootdl_cmd_hdr *)skb->data;
hdr->hdr.magic = HGIC_HDR_TX_MAGIC;
hdr->hdr.type = HGIC_HDR_TYPE_BOOTDL;
hdr->hdr.length = skb->len;
hdr->hdr.cookie = hgic_ctrl_cookie(hg_fwdl->ctrl);
//printk("hg_fwdl->ctrl=%p\r\n", hg_fwdl->ctrl);
memset(&resp, 0, sizeof(resp));
resp.cookie = hdr->hdr.cookie;
hg_fwdl->last_cookie = resp.cookie;
return hgic_fwctrl_send_data(hg_fwdl->ctrl, skb, &resp, timeout);
}
struct sk_buff *hgic_bootdl_send_data(struct hgic_bootdl *hg_fwdl, struct sk_buff *skb, u32 timeout)
{
struct hgic_bootdl_cmd_hdr *hdr = NULL;
struct hgic_cmd_response resp;
hdr = (struct hgic_bootdl_cmd_hdr *)skb_push(skb, sizeof(struct hgic_bootdl_cmd_hdr));
hdr->hdr.magic = HGIC_HDR_TX_MAGIC;
hdr->hdr.type = HGIC_HDR_TYPE_BOOTDL_DATA;
memset(&resp, 0, sizeof(struct hgic_cmd_response));
resp.cookie = hg_fwdl->last_cookie;
return hgic_fwctrl_send_data(hg_fwdl->ctrl, skb, &resp, timeout);
}
static int hgic_bootdl_parse_fw(struct hgic_bootdl *hg, const char *fw_name)
{
const struct firmware *fw;
int ret = 0;
s32 err_code = 0;
ret = request_firmware(&fw, fw_name, hg->ctrl->dev);
if (ret) {
printk("%s,%d:request_firmware failed!ret:%d\n", __FUNCTION__, __LINE__, ret);
return ret;
}
hg->fw = (struct firmware *)fw;
hg->fw_info.write_addr = hgic_get_fw_dl_addr(fw->data, &err_code);
if (err_code) {
hgic_dbg("hgic_get_fw_dl_addr error!\n");
return err_code;
}
hg->fw_info.aes_en = hgic_get_fw_aes_en(fw->data, &err_code);
if (err_code) {
hgic_dbg("hgic_get_aes_en error!\n");
return err_code;
}
hg->fw_info.crc_en = hgic_get_fw_crc_en(fw->data, &err_code);
if (err_code) {
hgic_dbg("hgic_get_fw_crc_en error!\n");
return err_code;
}
hg->fw_info.local_crc32 = hgic_get_fw_local_crc32(fw->data, &err_code);
if (err_code) {
hgic_dbg("hgic_get_fw_local_crc32 error!\n");
return err_code;
}
hg->fw_info.hdr_len = hgic_get_fw_code_offset(fw->data, &err_code);
if (err_code) {
hgic_dbg("hgic_get_fw_code_offset error!\n");
return err_code;
}
hg->fw_info.sp_cfg = 1;
hg->fw_info.fw_len = fw->size - hg->fw_info.hdr_len;
hgic_dbg("firmware hdr len : %d\r\n", hg->fw_info.hdr_len);
hgic_dbg("firmware run addr : %x\r\n", hg->fw_info.write_addr);
hgic_dbg("firmware size : %d\r\n", hg->fw_info.fw_len);
hgic_dbg("firmware aes_en:%d,crc_en:%d\r\n", hg->fw_info.aes_en, hg->fw_info.crc_en);
return 0;
}
static int hgic_bootdl_send_fw(struct hgic_bootdl *hg, struct sk_buff *skb, u32 tmo)
{
struct sk_buff *resp_skb = NULL;
struct hgic_bootdl_resp_hdr *data_resp = NULL;
int ret = 0;
if (skb == NULL || hg == NULL) {
hgic_dbg("input para error\n");
return EINVAL;
}
resp_skb = hgic_bootdl_send_data(hg, skb, tmo);
if (resp_skb) {
data_resp = (struct hgic_bootdl_resp_hdr *)resp_skb->data;
ret = data_resp->rsp;
if (ret != 0) {
hgic_dbg("Send fw data error!ret:<%d>\n", ret);
} else {
hgic_dbg("Send fw data success!\n");
}
dev_kfree_skb_any(resp_skb);
return ret;
} else {
hgic_dbg("send fw data error, no resp!\n");
return EFAULT;
}
}
static int hgic_bootdl_send_cmd_tmo(struct hgic_bootdl *hg,
struct sk_buff *skb,
u32 timeout,
u32 *resp_data)
{
struct sk_buff *resp = NULL;
struct hgic_bootdl_cmd_hdr *cmd_hdr = (struct hgic_bootdl_cmd_hdr *)skb->data;
struct hgic_bootdl_resp_hdr *boot_resp = NULL;
int ret = 0;
unsigned char cmd_flag = 0;
unsigned char cmd = 0;
if (hg == NULL || skb == NULL) {
return -EINVAL;
}
cmd_flag = cmd_hdr->cmd_flag;
cmd = cmd_hdr->cmd;
resp = hgic_bootdl_send_cmd(hg, skb, timeout);
if (resp) {
boot_resp = (struct hgic_bootdl_resp_hdr *)resp->data;
ret = hgic_bootdl_cmd_rsp_handle(cmd_flag, cmd, boot_resp);
if (ret != 0 && ret != HG_BOOTDL_RSP_ERR_IN_FW) {
hgic_err("cmd %d, error:%d\n", cmd, ret);
dev_kfree_skb_any(resp);
return ret;
}
if (resp_data != NULL) {
*resp_data = get_unaligned_le32(boot_resp->rsp_data);
}
dev_kfree_skb_any(resp);
} else {
hgic_err("cmd: %d, no responce!!\r\n", cmd);
ret = -1;
}
return ret;
}
int hgic_bootdl_cmd_enter(struct hgic_bootdl *hg)
{
struct sk_buff *skb = NULL;
struct hgic_bootdl_cmd_hdr *cmd_hdr = NULL;
int ret = 0;
skb = hgic_bootdl_alloc_cmd_skb(hg, HG_BOOTDL_CMD_ENTER);
if (skb) {
cmd_hdr = (struct hgic_bootdl_cmd_hdr *)skb->data;
memcpy((void *)cmd_hdr->addr, (void *)BOOT_CMD_KEY, sizeof(cmd_hdr->addr));
cmd_hdr->check = hgic_bootdl_cmd_check_val(hg->checksum_mode, (u8 *)&cmd_hdr->cmd, 11);
} else {
hgic_err("malloc skb failed!\n");
return ENOMEM;
}
ret = hgic_bootdl_send_cmd_tmo(hg, skb, HG_BOOTDL_CMD_NORMAL_TMO, NULL);
if (ret == 0 || ret == HG_BOOTDL_RSP_ERR_IN_FW) {
if (ret == HG_BOOTDL_RSP_ERR_IN_FW) {
//hgic_err("In firmware state\n");
return STATE_FW;
} else {
//hgic_err("In bootdl state\n");
return STATE_BOOT;
}
} else {
hgic_err("failed! ret:%d\n", ret);
return ret;
}
}
static int hgic_bootdl_cmd_write_memory(struct hgic_bootdl *hg, u32 write_addr, u32 data_len)
{
struct sk_buff *skb = NULL;
struct hgic_bootdl_cmd_hdr *cmd_hdr = NULL;
skb = hgic_bootdl_alloc_cmd_skb(hg, HG_BOOTDL_CMD_WRITE_MEM);
if (skb) {
cmd_hdr = (struct hgic_bootdl_cmd_hdr *)skb->data;
put_unaligned_le32(write_addr, cmd_hdr->addr);
if (hg->bus->type == HGIC_BUS_SDIO) {
put_unaligned_le32(data_len, cmd_hdr->len);
} else {
put_unaligned_le32((data_len + 1024), cmd_hdr->len);
}
cmd_hdr->check = hgic_bootdl_cmd_check_val(hg->checksum_mode, (u8 *)&cmd_hdr->cmd, 11);
} else {
hgic_dbg("malloc skb failed!\n");
return ENOMEM;
}
return hgic_bootdl_send_cmd_tmo(hg, skb, HG_BOOTDL_CMD_NORMAL_TMO, NULL);
}
static int hgic_bootdl_cmd_run(struct hgic_bootdl *hg)
{
struct sk_buff *skb = NULL;
struct hgic_bootdl_cmd_hdr *cmd_hdr = NULL;
u32 temp = 0;
skb = hgic_bootdl_alloc_cmd_skb(hg, HG_BOOTDL_CMD_RUN);
if (skb) {
cmd_hdr = (struct hgic_bootdl_cmd_hdr *)skb->data;
put_unaligned_le32(hg->fw_info.write_addr, cmd_hdr->addr);
temp = hg->fw_info.fw_len;
if (hg->fw_info.aes_en) {
temp |= HG_BOOT_CMD_RUN_PREACT_AES_DEC;
}
if (hg->fw_info.crc_en) {
temp |= HG_BOOT_CMD_RUN_PREACT_CRC_CHK;
}
if (hg->fw_info.sp_cfg) {
temp |= HG_BOOT_CMD_RUN_PREACT_SP_CFG;
}
put_unaligned_le32(temp, cmd_hdr->len);
cmd_hdr->check = hgic_bootdl_cmd_check_val(hg->checksum_mode, (u8 *)&cmd_hdr->cmd, 11);
} else {
hgic_dbg("malloc skb failed!\n");
return ENOMEM;
}
return hgic_bootdl_send_cmd_tmo(hg, skb, HG_BOOTDL_CMD_NORMAL_TMO, NULL);
}
static unsigned int hgic_bootdl_fragment_proc(struct hgic_bootdl *hg, unsigned int copy_len)
{
unsigned int xfer_len = 0;
unsigned int blk = 0;
if (hg->bus->type == HGIC_BUS_SDIO) {
if (copy_len < hg->frag_size) {
blk = copy_len / hg->bus->blk_size;
if (blk) {
xfer_len = blk * hg->bus->blk_size;
} else {
//xfer_len = copy_len;
xfer_len = ALIGN(copy_len, 4);
}
} else {
xfer_len = hg->frag_size;
}
} else {
xfer_len = copy_len > hg->frag_size ? hg->frag_size : copy_len;
}
return xfer_len;
}
int hgic_bootdl_download(struct hgic_bootdl *hg, const char *fw_path)
{
int ret = 0;
struct sk_buff *skb = NULL;
u32 write_addr = 0;
u32 copy_len = 0;
u32 xfer_len = 0;
u32 addr_offset = 0;
char *data = NULL;
if (hg == NULL || fw_path == NULL) {
printk("%s,%d:input para error!\n", __FUNCTION__, __LINE__);
return EINVAL;
}
hgic_enter();
ret = hgic_bootdl_parse_fw(hg, fw_path);
if (ret != 0 || !hg->fw) {
hgic_dbg("hgic_bootdl_parse_fw error,ret:<%d>,path:%s\n", ret, fw_path);
goto __finish;
}
copy_len = hg->fw_info.fw_len;
write_addr = hg->fw_info.write_addr;
data = (char *)(hg->fw->data + hg->fw_info.hdr_len);
while (copy_len) {
//xfer_len = copy_len > hg->frag_size ? hg->frag_size : copy_len;
xfer_len = hgic_bootdl_fragment_proc(hg, copy_len);
skb = dev_alloc_skb(xfer_len + sizeof(struct hgic_bootdl_cmd_hdr));
if (skb == NULL) {
printk("%s: no memory\r\n", __FUNCTION__);
ret = -ENOMEM;
goto __finish;
}
skb_reserve(skb, sizeof(struct hgic_bootdl_cmd_hdr));
memcpy(skb->data, data + addr_offset, xfer_len);
skb_put(skb, xfer_len);
ret = hgic_bootdl_cmd_write_memory(hg, write_addr, skb->len);
if (ret != 0) {
hgic_dbg("hgic_bootdl_cmd_write_memory error!\n");
dev_kfree_skb_any(skb);
goto __finish;
}
ret = hgic_bootdl_send_fw(hg, skb, HG_BOOTDL_CMD_WRITE_MEM_TMO);
if (ret != 0) {
hgic_dbg("hgic_bootdl_send_fw error!\n");
goto __finish;
}
write_addr += xfer_len;
copy_len -= xfer_len;
addr_offset += xfer_len;
skb = NULL;
}
ret = hgic_bootdl_cmd_run(hg);
if (ret) {
printk("%s: Cmd run failed:%d\r\n", __FUNCTION__, ret);
}
__finish:
if (hg->fw) {
hgic_dbg("Release boot download firmware...\n");
release_firmware(hg->fw);
hg->fw = NULL;
}
hgic_leave();
return ret;
}
View git blame Copy permalink