/*************************************************************************************
|
*Description: usb download
|
*Seekwave tech LTD
|
*Author: jiayong.yang/junwei.jiang
|
*Date:20210527
|
*Modify:
|
* ***********************************************************************************/
|
#include <linux/kernel.h>
|
#include <linux/version.h>
|
#include <linux/module.h>
|
#include <linux/moduleparam.h>
|
#include <linux/slab.h>
|
#include <linux/proc_fs.h>
|
#include <linux/errno.h>
|
#ifdef CONFIG_DEBUG_FS
|
#include <linux/debugfs.h>
|
#endif
|
#include <linux/fs.h>
|
#include <linux/buffer_head.h>
|
#include <linux/ctype.h>
|
#include "skw_usb_log.h"
|
#include "usb_boot.h"
|
/***************************************************************************
|
* Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
* ************************************************************************/
|
static int dl_mps;
|
static int dloader_port = 0;
|
|
/***************************************************************************
|
* Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
* ************************************************************************/
|
static int check_modem_status_from_connect_message(void)
|
{
|
struct connect_ack *ack = (void *)&connect_ack[12];
|
memcpy(skw_chipid,ack->chip_id,16);
|
dl_mps = ack->packet_size;
|
if(ack->flags.bitmap.boot)
|
return NORMAL_BOOT;
|
else
|
return NORMAL_BOOT;
|
}
|
|
/***************************************************************************
|
* Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
* ************************************************************************/
|
static int dloader_write(char *msg, int msg_len, int *actual, int timeout)
|
{
|
return bulkout_write_timeout(dloader_port, msg, msg_len, actual, timeout);
|
}
|
|
/***************************************************************************
|
* Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
* ************************************************************************/
|
static int dloader_read(char *msg, int msg_len, int *actual, int timeout)
|
{
|
return bulkin_read_timeout(dloader_port, msg, msg_len, actual, timeout);
|
}
|
|
/***************************************************************************
|
* Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
* ************************************************************************/
|
static int compare_msg(const char *src, const char *dst, size_t count)
|
{
|
unsigned char c1, c2;
|
|
while (count) {
|
c1 = *src++;
|
c2 = *dst++;
|
if (c1 != c2)
|
return c1 < c2 ? -1 : 1;
|
count--;
|
}
|
return 0;
|
}
|
|
static int dloader_send_data(const char *command, int command_len, const char *ack, int ack_len)
|
{
|
int actual_len = 0;
|
int ret;
|
void *data;
|
int data_size = 128;
|
|
data = kzalloc(data_size, GFP_KERNEL);
|
|
if (!data)
|
return -ENOMEM;
|
/* send command */
|
ret = dloader_write((char *)command, command_len, &actual_len, 3000);
|
if (ret <0 || actual_len != command_len) {
|
skw_usb_err(" send cmd error ret %d actual_len %d command_len %d\n",
|
ret, actual_len, command_len);
|
} else {
|
if (ack == NULL)
|
goto OUT;
|
|
/* read ack and check it */
|
ret = dloader_read(data, data_size, &actual_len, 3000);
|
if (ret <0 || ack_len > actual_len || compare_msg(ack, data, ack_len)) {
|
skw_usb_err(" ack is NACK:ret == %d\n", ret);
|
print_hex_dump(KERN_ERR, "ACK ERR:", 0, 16, 1, data, ack_len, 1);
|
ret = -EIO;
|
}
|
}
|
OUT:
|
kfree(data);
|
return ret;
|
}
|
|
/***************************************************************************
|
* Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
* ************************************************************************/
|
static int dloader_send_command(const char *command, int command_len, const char *ack, int ack_len)
|
{
|
int actual_len = 0;
|
int ret;
|
void *data;
|
int data_size = 128;
|
|
data = kzalloc(data_size, GFP_KERNEL);
|
if (!data)
|
return -ENOMEM;
|
/* send command */
|
memcpy(data, (char*)command, command_len);
|
ret = dloader_write(data, command_len, &actual_len, 3000);
|
if (ret <0 || actual_len != command_len) {
|
skw_usb_err(" send cmd error ret %d actual_len %d command_len %d\n",
|
ret, actual_len, command_len);
|
} else {
|
/* read ack */
|
ret = dloader_read(data, data_size, &actual_len, 3000);
|
if (ret <0) {
|
skw_usb_warn(" ack is NACK: acklen ===%d- actual_len ==%d--ret == %d\n",
|
ret, ack_len, actual_len);
|
}
|
}
|
if ((command_len > 8) &&(0 == command[8])){
|
if(actual_len > sizeof(connect_ack))
|
actual_len = sizeof(connect_ack);
|
memcpy(connect_ack, data, actual_len);
|
}
|
kfree(data);
|
return ret;
|
}
|
|
/***************************************************************************
|
* Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
* ************************************************************************/
|
static unsigned short crc16_calculate(unsigned char *buf, int len)
|
{
|
unsigned int i;
|
unsigned short crc = 0;
|
|
while (len-- != 0) {
|
for (i = 0x80; i != 0; i = i >> 1) {
|
if ((crc & 0x8000) != 0) {
|
crc = crc << 1;
|
crc = crc ^ 0x1021;
|
} else {
|
crc = crc << 1;
|
}
|
if ((*buf & i) != 0)
|
crc = crc ^ 0x1021;
|
}
|
buf++;
|
}
|
return crc;
|
}
|
|
/***************************************************************************
|
* Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
* ************************************************************************/
|
int dloader_command_start_download(unsigned int addr, unsigned int len)
|
{
|
|
int command_len = 20;
|
char command[20] = {0x7E, 0x7E, 0x7E, 0x7E,/* head */
|
0x08, 0x00, 0x00, 0x00, /*length */
|
0x01, 0x00, /* message type, 01: start command */
|
0x00, 0x00, /*crc for data body, excludes message header */
|
0x00, 0x00, 0x10, 0x00,/*addr*/
|
0x60, 0xb3, 0x06, 0x00 /*image size*/};
|
|
*((u32 *)&command[12]) = addr;
|
*((u32 *)&command[16]) = len;
|
|
*((u16 *)&command[10]) = cpu_to_be16(crc16_calculate(&command[12], command_len - 12));
|
return dloader_send_command(command, command_len, common_ack, sizeof(common_ack));
|
}
|
|
/***************************************************************************
|
* Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
* ************************************************************************/
|
int dloader_command_exec(unsigned int addr)
|
{
|
unsigned short command_len = 16;
|
|
char command[16] = {0x7E,0x7E,0x7E,0x7E, /* head */
|
0x04, 0x00, 0x00, 0x00,
|
0x04, 0x00, /*command type */
|
0x43, 0x63, /*command len */
|
0x00, 0x00, 0x10, 0x00 /*addr*/
|
};
|
*((u32 *)&command[12]) = addr;
|
*((u16 *)&command[10]) = crc16_calculate(&command[12], 4);
|
return dloader_send_command(command, command_len, exec_ack, sizeof(exec_ack));
|
}
|
|
/***************************************************************************
|
* Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
* ************************************************************************/
|
int dloader_setup_usb_connection(struct usb_port_struct *port)
|
{
|
int ret;
|
|
dloader_command_client_probe();
|
if (ret < 0) {
|
dev_err(&port->udev->dev, "get version error\n");
|
return ret;
|
}
|
dloader_command_connect();
|
if (ret < 0) {
|
dev_err(&port->udev->dev, "connection error\n");
|
return ret;
|
}
|
dev_info(&port->udev->dev,"dloader connect susscess...\n");
|
return 0;
|
}
|
|
/***************************************************************************
|
* Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
* ************************************************************************/
|
int dloader_execute_image(struct usb_port_struct *port,unsigned int addr)
|
{
|
int ret;
|
|
ret = dloader_command_exec(addr);
|
if (ret < 0) {
|
dev_err(&port->udev->dev, "exec command is error\n");
|
return ret;
|
}
|
return 0;
|
}
|
/***************************************************************************
|
* Description:
|
*Seekwave tech LTD
|
*Author:junwei.jiang
|
*Date:
|
*Modify:
|
* ************************************************************************/
|
static unsigned int dloader_send_pdata(char* buf, const void *pdata, unsigned int len)
|
{
|
PACKET_T *packet_ptr = (PACKET_T *)buf;
|
int command_len = len + PACKET_HEADER_SIZE;
|
|
packet_ptr->magic = PACKET_MAGIC;
|
packet_ptr->type = 0x0002;
|
packet_ptr->size = len;
|
packet_ptr->crc = 0x0000;
|
memset(packet_ptr->content, 0 , len);
|
memcpy(packet_ptr->content,pdata, len);
|
|
//crc check sum
|
packet_ptr->crc = cpu_to_be16(crc16_calculate((char*)(&(packet_ptr->content)), command_len));
|
|
return command_len;
|
}
|
|
/***************************************************************************
|
* Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
* ************************************************************************/
|
int usb_download_image(struct usb_port_struct *port, unsigned int addr, unsigned int len)
|
{
|
int ret;
|
int size;
|
int offset = 0;
|
int img_size = 0;
|
int temp_size = 0;
|
|
/*the first command connect*/
|
ret = dloader_command_start_download(addr, len);
|
if (ret < 0) {
|
dev_err(&port->udev->dev,"start download command failed\n");
|
return ret;
|
}
|
/*get the data and the sv6160.bin size*/
|
img_size = len;
|
|
while (img_size > 0) {
|
temp_size = MIN(dl_mps, img_size-offset);
|
if(!temp_size)
|
return 0;
|
size = dloader_send_pdata(port->read_buffer, (void*)(firmware_data)+offset, temp_size);
|
if (size%512==0 && temp_size < dl_mps) {
|
temp_size = temp_size>>1;
|
size = dloader_send_pdata(port->read_buffer, (void*)(firmware_data)+offset, temp_size);
|
}
|
ret = dloader_send_data(port->read_buffer, size, common_ack, sizeof(common_ack));
|
if (ret < 0) {
|
dev_err(&port->udev->dev, "donwload img error\n");
|
return ret;
|
}
|
offset += temp_size;
|
}
|
return 0;
|
}
|
|
/***************************************************************************
|
* Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
* ************************************************************************/
|
int dloader_get_chip_id(void *buf, unsigned int buf_size)
|
{
|
int len = strlen(usb_ports[0]->udev->product);
|
memcpy(buf, usb_ports[0]->udev->product, strlen(usb_ports[0]->udev->product));
|
return len;
|
}
|
|
/***************************************************************************
|
* Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
* ************************************************************************/
|
int dloader_dump_from_romcode_usb(unsigned int addr, void *buf, int len)
|
{
|
int ret;
|
unsigned short command_len = 16;
|
char command[20] = {0x7E, 0x7E, 0x7E, 0x7E,/* head */
|
0x08, 0x00, 0x00, 0x00, /*for command data len */
|
0x00, 0x09, /*command type */
|
0x00, 0x00, /*for crc*/
|
0x00, 0x00, 0x00, 0x00,/*addr*/
|
0x00, 0x00, 0x00, 0x00,/*data len*/
|
};
|
int actual_len = 0;
|
int size;
|
|
//*((u32 *)&command[12]) = cpu_to_be32(addr);
|
//*((u32 *)&command[16]) = cpu_to_be32(len);
|
*((u32 *)&command[12]) = addr;
|
*((u32 *)&command[16]) = len;
|
|
*((u16 *)&command[10]) = cpu_to_be16(crc16_calculate(&command[1], command_len - 4));
|
|
|
ret = dloader_send_command(command, command_len, NULL, 0);
|
if (ret < 0) {
|
skw_usb_err(" send command error\n");
|
return -EIO;
|
}
|
|
size = dl_mps;
|
while(len > 0) {
|
if (len < size)
|
size = len;
|
ret = dloader_read(buf, size, &actual_len, 3000);
|
if (ret < 0)
|
skw_usb_err("dloader_read_ack dump memory error\n");
|
else len -= actual_len;
|
}
|
return ret;
|
}
|
|
/***************************************************************************
|
* Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
* ************************************************************************/
|
static int dloader_dump_read_usb(struct usb_port_struct *port)
|
{
|
int ret;
|
ret = dloader_dump_from_romcode_usb(START_ADDR, port->read_buffer, MAX_IMAGE_SIZE);
|
return ret;
|
}
|
|
/***************************************************************************
|
* Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
* ************************************************************************/
|
static void dloader_work(struct work_struct *work)
|
{
|
struct usb_port_struct *port = container_of(work, struct usb_port_struct, work);
|
int ret;
|
dloader_port = port->portno;
|
dloader_setup_usb_connection(port);
|
|
ret = check_modem_status_from_connect_message();
|
if (ret == HANG_REBOOT){
|
dloader_dump_read_usb(port);
|
}
|
if(usb_boot_data->dram_dl_size > 0){
|
firmware_data = usb_boot_data->dram_img_data;
|
ret = usb_download_image(port, usb_boot_data->dram_dl_addr, usb_boot_data->dram_dl_size);
|
if(ret <0)
|
skw_usb_warn(" dram download img fail !!!!\n");
|
}
|
|
if(!ret && usb_boot_data->iram_dl_size > 0){
|
firmware_data = usb_boot_data->iram_img_data;
|
ret = usb_download_image(port, usb_boot_data->iram_dl_addr, usb_boot_data->iram_dl_size);
|
}
|
modem_notify_event(DEVICE_BOOTUP_EVENT);
|
if (!ret)
|
ret = dloader_execute_image(port, START_ADDR);
|
|
if (ret < 0 && chip_en_gpio >= 0) {
|
modem_status = MODEM_DOWNLOAD_FAILED;
|
skw_usb_info("download failed! power off device\n");
|
gpio_set_value(chip_en_gpio, 0);
|
msleep(10);
|
}
|
}
|
