/*****************************************************************
|
*Copyright (C) 2021 Seekwave Tech Inc.
|
*Filename : skw_boot.c
|
*Authors:seekwave platform
|
*
|
* This software is licensed under the terms of the the GNU
|
* General Public License version 2, as published by the Free
|
* Software Foundation, and may be copied, distributed, and
|
* modified under those terms.
|
*
|
* This program is distributed in the hope that it will be usefull,
|
* but without any warranty;without even the implied warranty of
|
* merchantability or fitness for a partcular purpose. See the
|
* GUN General Public License for more details.
|
* **************************************************************/
|
|
#include <linux/kernel.h>
|
#include <linux/irq.h>
|
#include <linux/interrupt.h>
|
#include <linux/module.h>
|
#include <linux/gpio.h>
|
#include <linux/delay.h>
|
#include <linux/slab.h>
|
#include <linux/of_gpio.h>
|
#include <linux/completion.h>
|
#include <linux/moduleparam.h>
|
#include <linux/workqueue.h>
|
#include <linux/of.h>
|
#include <linux/device.h>
|
#include <linux/version.h>
|
#include <linux/debugfs.h>
|
#include <linux/fs.h>
|
#include <linux/ctype.h>
|
#include <linux/errno.h>
|
#include <linux/firmware.h>
|
#include <linux/mmc/sdio_func.h>
|
#include <linux/dma-mapping.h>
|
#include <linux/cdev.h>
|
#include <linux/uaccess.h>
|
#include <linux/workqueue.h>
|
#include <linux/scatterlist.h>
|
#include <linux/platform_device.h>
|
#include <linux/pci.h>
|
#include "skw_mem_map.h"
|
#include "skw_boot.h"
|
#include "boot_config.h"
|
/**************************sdio boot start******************************/
|
extern int cp_exception_sts;
|
unsigned int test_debug = 0;
|
unsigned char dl_signal_acount=0;
|
struct platform_device *btboot_pdev;
|
static u64 port_dmamask = DMA_BIT_MASK(32);
|
static struct mutex boot_mutex;
|
static char *local_chip_id = "SV6160LITE";
|
int g_chipen_pin = -1;//default chipen -1,need update by dts or CHIPEN MACRO
|
int skw_use_sdma = 0;//default use adma, 0:adma 1:sdma
|
|
|
//static char iram_image_buffer[360448];
|
//static char dram_image_buffer[206848];
|
#ifdef CONFIG_OF
|
#undef CONFIG_OF
|
#endif
|
//#define SDIO_BUFFER_SIZE (16*1024)
|
/*
|
*add the little endian
|
* */
|
#define _LITTLE_ENDIAN 1
|
|
#define CP_IMG_HEAD0 "kees" //"6B656573"
|
#define CP_IMG_HEAD1 "0616" //"30363136"
|
#define CP_IMG_TAIL0 "evaw" //"65766177"
|
#define CP_IMG_TAIL1 "0616" //"30363136" //ASCII code 36 31 36 30
|
#define CP_NV_HEAD "TSVN" //"5453564E" //ASCII code 36 31 36 30
|
#define CP_NV_TAIL "DEVN" //"4445564E" //ASCII code 36 31 36 30
|
|
#define CHIP_DEV_NAME "sv6160lite" //same with dts device
|
#define CHIP_DEV_NAME_COM "seekwave," CHIP_DEV_NAME
|
|
#define IMG_HEAD_OPS_LEN 4
|
#define RAM_ADDR_OPS_LEN 8
|
#define MODULE_INFO_LEN 12
|
|
#define IMG_HEAD_INFOR_RANGE 0x200 //10K Byte
|
|
static unsigned int EndianConv_32(unsigned int value);
|
/***********sdio drv extern interface **************/
|
/* driect mode,reg access.etc */
|
//extern int skw_get_chipid(char *chip_id);
|
extern int skw_boot_loader(struct seekwave_device *boot_data);
|
extern void *skw_get_bus_dev(void);
|
extern int skw_reset_bus_dev(void);
|
static int skw_first_boot(struct seekwave_device *boot_data);
|
static int skw_boot_init(struct seekwave_device *boot_data);
|
static int skw_download_signal_ops(void);
|
static int get_sleep_status(int portno, char *buffer, int size);
|
static int set_sleep_status(int portno, char *buffer, int size);
|
//int skw_cp_exception_reboot(void);
|
static int skw_start_bt_service(void);
|
static int skw_stop_bt_service(void);
|
/**************************sdio boot end********************************/
|
struct seekwave_device *boot_data;
|
|
//=======================================================
|
//debug sdio macro and Variable
|
//int glb_wifiready_done;
|
#define SKW_CPBOOT_DEBUG 0
|
//=======================================================
|
/***************************************************************************
|
*Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
**************************************************************************/
|
static unsigned int crc_16_l_calc(char *buf_ptr,unsigned int len)
|
{
|
unsigned int i;
|
unsigned short crc=0;
|
|
while(len--!=0)
|
{
|
for(i= CRC_16_L_SEED;i!=0;i=i>>1)
|
{
|
if((crc &CRC_16_L_POLYNOMIAL)!=0)
|
{
|
crc= crc<<1;
|
crc= crc ^ CRC_16_POLYNOMIAL;
|
}else{
|
crc = crc <<1;
|
}
|
|
if((*buf_ptr &i)!=0)
|
{
|
crc = crc ^ CRC_16_POLYNOMIAL;
|
}
|
}
|
buf_ptr++;
|
}
|
return (crc);
|
}
|
|
|
static int skw_request_firmwares(struct seekwave_device *boot_data,
|
const char *dram_image_name, const char *iram_image_name, const char *nv_mem_name)
|
{
|
int ret;
|
const struct firmware *fw = NULL;
|
|
skwboot_log("request_firmware %s\n", dram_image_name);
|
ret = request_firmware(&fw, dram_image_name, NULL);
|
if (ret < 0) {
|
skwboot_err("request_firmware %s fail\n", dram_image_name);
|
goto ret;
|
}
|
if(!boot_data->first_boot_flag && !boot_data->dram_img_data){
|
boot_data->dram_img_data = (char *)vmalloc( fw->size);
|
if (!boot_data->dram_img_data) {
|
skwboot_err("%s,line:%d the dram img data malloc fail \n",
|
__func__, __LINE__);
|
return -ENOMEM;
|
}
|
}
|
skwboot_log("boot data dram_img_data %p\n",boot_data->dram_img_data);
|
memset(boot_data->dram_img_data, 0, fw->size);
|
memcpy(boot_data->dram_img_data, fw->data, fw->size);
|
boot_data->dram_dl_size = fw->size;
|
release_firmware(fw);
|
//dram crc16
|
boot_data->dram_crc_en = 1;
|
boot_data->dram_crc_offset=0;
|
boot_data->dram_crc_val = crc_16_l_calc(boot_data->dram_img_data + boot_data->dram_crc_offset, boot_data->dram_dl_size);
|
|
skwboot_log("request_firmware %s\n", iram_image_name);
|
ret = request_firmware(&fw, iram_image_name, NULL);
|
if (ret < 0) {
|
skwboot_err("request_firmware %s fail\n", iram_image_name);
|
goto ret;
|
}
|
if(!boot_data->first_boot_flag &&!boot_data->iram_img_data){
|
boot_data->iram_img_data = (char *)vmalloc(fw->size);
|
if (!boot_data->iram_img_data) {
|
vfree(boot_data->dram_img_data);
|
boot_data->dram_img_data = NULL;
|
skwboot_err("%s,line:%d the iram img data malloc fail \n",
|
__func__, __LINE__);
|
return -ENOMEM;
|
}
|
}
|
memset(boot_data->iram_img_data, 0, fw->size);
|
memcpy(boot_data->iram_img_data, fw->data, fw->size);
|
boot_data->iram_dl_size = fw->size;
|
release_firmware(fw);
|
//iram crc16
|
boot_data->iram_crc_en = 1;
|
boot_data->iram_crc_offset=0;
|
boot_data->iram_crc_val = crc_16_l_calc(boot_data->iram_img_data + boot_data->iram_crc_offset, boot_data->iram_dl_size);
|
|
skwboot_log("boot data iram_img_data %p\n",boot_data->iram_img_data);
|
if(nv_mem_name == NULL) {
|
ret = 0;
|
skwboot_warn("nv_mem_name is NULL\n");
|
goto ret;
|
}
|
skwboot_log("request_firmware %s\n", nv_mem_name);
|
ret = request_firmware(&fw, nv_mem_name, NULL);
|
if (ret < 0) {
|
skwboot_err("request_firmware %s fail\n", nv_mem_name);
|
ret = ENOENT;
|
goto ret;
|
}
|
|
boot_data->nv_mem_data = (char *)kzalloc(fw->size, GFP_KERNEL);
|
if (boot_data->nv_mem_data == NULL) {
|
skwboot_err("alloc nv memory failed\n");
|
goto relese_fw;
|
}
|
memcpy(boot_data->nv_mem_data, fw->data, fw->size);
|
boot_data->nv_mem_size = fw->size;
|
if (boot_data->nv_mem_size > 20) {//new nv
|
boot_data->nv_mem_cmfg_data = boot_data->nv_mem_data + *(u32 *)(boot_data->nv_mem_data + NV_CMFG_OFFSET);
|
boot_data->nv_mem_cmfg_size = *(u32 *)(boot_data->nv_mem_data + NV_CMFG_SIZE);
|
|
if (*(u32 *)(boot_data->nv_mem_data + NV_PNFG_OFFSET) != 0)
|
boot_data->nv_mem_pnfg_data = boot_data->nv_mem_data + *(u32 *)(boot_data->nv_mem_data + NV_PNFG_OFFSET);
|
else
|
boot_data->nv_mem_pnfg_data = NULL;
|
boot_data->nv_mem_pnfg_size = *(u32 *)(boot_data->nv_mem_data + NV_PNFG_SIZE);
|
}
|
ret=0;
|
boot_data->nvmem_crc_en = 1;
|
boot_data->nvmem_crc_offset=0;
|
boot_data->nvmem_crc_val = crc_16_l_calc(boot_data->nv_mem_data + boot_data->nvmem_crc_offset, boot_data->nv_mem_size);
|
//print_hex_dump(KERN_ERR, "nvdata:", 0, 16, 1, boot_data->nv_mem_data, boot_data->nv_mem_size, 1);
|
|
relese_fw:
|
release_firmware(fw);
|
ret:
|
return ret;
|
}
|
static int skw_of_property_read(const struct device_node *np,
|
const char *propname, u32 *out_value)
|
{
|
#if KERNEL_VERSION(3, 1, 0) <= LINUX_VERSION_CODE
|
return of_property_read_u32(np, propname, out_value);
|
#else
|
#if 0
|
const unsigned int *value=NULL;
|
value = of_get_property(np, propname,out_value);
|
if (value == NULL){
|
return ENXIO;
|
}else{
|
return 0;
|
}
|
#endif
|
return ENXIO;
|
#endif
|
}
|
static int seekwave_boot_parse_dt(struct platform_device *pdev, struct seekwave_device *boot_data)
|
{
|
int ret = 0;
|
enum of_gpio_flags flags;
|
int tmp_gpio;
|
struct device_node *np = pdev->dev.of_node;
|
/*add the dma type dts config*/
|
if (skw_of_property_read(np, "bt_antenna", &(boot_data->bt_antenna))){
|
skwboot_warn("no BT_antenna setting\n");
|
boot_data->bt_antenna = SKW_BT_ANTENNA_CFG;
|
} else
|
skwboot_log("BT_antenna setting: %d\n", boot_data->bt_antenna);
|
|
if (skw_of_property_read(np, "dma_type", &(boot_data->dma_type))){
|
boot_data->dma_type = SKW_DMA_TYPE_CFG;
|
g_chipen_pin = boot_data->chip_en = MODEM_ENABLE_GPIO;
|
boot_data->host_gpio = HOST_WAKEUP_GPIO_IN;
|
boot_data->chip_gpio = MODEM_WAKEUP_GPIO_OUT;
|
skwboot_warn("no DTS setting\n");
|
} else {
|
#if KERNEL_VERSION(3, 1, 0) <= LINUX_VERSION_CODE
|
boot_data->host_gpio = of_get_named_gpio_flags(np, "gpio_host_wake", 0, &flags);
|
boot_data->chip_gpio = of_get_named_gpio_flags(np, "gpio_chip_wake",0, &flags);
|
g_chipen_pin = boot_data->chip_en = of_get_named_gpio_flags(np, "gpio_chip_en",0, &flags);
|
#endif
|
}
|
boot_data->dma_type = skw_use_sdma?SDMA:ADMA;
|
skwboot_log("%s,modem boot setting::=>\n", __func__);
|
skwboot_log("chipen=%d\n", boot_data->chip_en);
|
skwboot_log("hst_wak_wf=%d\n", boot_data->chip_gpio);
|
skwboot_log("wf_wak_hst=%d\n", boot_data->host_gpio);
|
skwboot_log("dma_type=%d\n", boot_data->dma_type);
|
skwboot_log("bt_antenna=%d\n", boot_data->bt_antenna);
|
|
if (test_debug) {
|
if ((test_debug & 0xF) == 0x1) {
|
boot_data->chip_gpio = -1;
|
boot_data->host_gpio = -1;
|
} else if (test_debug == 5)
|
boot_data->host_gpio = -1;
|
#if KERNEL_VERSION(3, 1, 0) <= LINUX_VERSION_CODE
|
if (boot_data->host_gpio >= 0) {
|
if ((test_debug & 0xF) == 0x2) {
|
skwboot_log("gpio in out swap\n");
|
tmp_gpio = boot_data->chip_gpio;
|
boot_data->chip_gpio = boot_data->host_gpio;
|
boot_data->host_gpio = tmp_gpio;
|
ret = devm_gpio_request_one(
|
&pdev->dev, boot_data->host_gpio,
|
GPIOF_IN, "WL_WAKE_HOST");
|
} else if ((test_debug & 0xF) == 0x3) {
|
skwboot_log("test_debug 3 = gpio in high\n");
|
ret = devm_gpio_request_one(
|
&pdev->dev, boot_data->host_gpio,
|
GPIOF_OUT_INIT_HIGH, "WL_WAKE_HOST");
|
} else if ((test_debug & 0xF) == 0x4) {
|
skwboot_log(
|
"test_debug 4 = gpio in out swap out low\n");
|
tmp_gpio = boot_data->chip_gpio;
|
boot_data->chip_gpio = boot_data->host_gpio;
|
boot_data->host_gpio = tmp_gpio;
|
ret = devm_gpio_request_one(
|
&pdev->dev, boot_data->host_gpio,
|
GPIOF_OUT_INIT_LOW, "WL_WAKE_HOST");
|
} else {
|
ret = devm_gpio_request_one(
|
&pdev->dev, boot_data->host_gpio,
|
GPIOF_IN, "WL_WAKE_HOST");
|
}
|
if (boot_data->chip_gpio >= 0)
|
ret = devm_gpio_request_one(
|
&pdev->dev, boot_data->chip_gpio,
|
GPIOF_OUT_INIT_HIGH, "HOST_WAKE_WL");
|
}
|
#endif
|
if (boot_data->chip_gpio >= 0 && boot_data->host_gpio >= 0) {
|
if (test_debug & 0xF0)
|
boot_data->slp_disable = 1;
|
else
|
boot_data->slp_disable = 0;
|
} else {
|
boot_data->slp_disable = 1;
|
}
|
} else {
|
#if KERNEL_VERSION(3, 1, 0) <= LINUX_VERSION_CODE
|
if (boot_data->host_gpio >= 0)
|
ret = devm_gpio_request_one(&pdev->dev,
|
boot_data->host_gpio,
|
GPIOF_IN, "WL_WAKE_HOST");
|
if (boot_data->chip_gpio >= 0)
|
ret = devm_gpio_request_one(&pdev->dev,
|
boot_data->chip_gpio,
|
GPIOF_OUT_INIT_HIGH,
|
"HOST_WAKE_WL");
|
#endif
|
if (boot_data->chip_gpio >= 0 && boot_data->host_gpio >= 0) {
|
boot_data->slp_disable = 0;
|
} else {
|
boot_data->slp_disable = 1;
|
}
|
}
|
skwboot_log("%s,chipen=%d, gpio_out:%d gpio_in:%d ret = %d\n", __func__,
|
boot_data->chip_en, boot_data->chip_gpio,
|
boot_data->host_gpio, ret);
|
#if KERNEL_VERSION(3, 1, 0) <= LINUX_VERSION_CODE
|
if (boot_data->chip_en >= 0)
|
ret = devm_gpio_request_one(&pdev->dev, boot_data->chip_en, GPIOF_OUT_INIT_HIGH,"CHIP_EN");
|
#endif
|
return ret;
|
}
|
|
/************************************************************************/
|
//Description: BT start service
|
//Func: BT start service
|
//Call：
|
//Author:junwei.jiang
|
//Date:2021-110
|
//Modify:
|
/************************************************************************/
|
static int bt_start_service(int id, void *callback, void *data)
|
{
|
int ret=0;
|
if(cp_exception_sts)
|
return -1;
|
|
skwboot_log("%s pid:%d %s\n", current->comm, current->pid, __func__);
|
ret = skw_start_bt_service();
|
if(ret < 0){
|
skwboot_err("%s boot bt fail \n", __func__);
|
return -1;
|
}
|
return 0;
|
}
|
|
/************************************************************************/
|
//Description: BT stop service
|
//Func: BT stop service
|
//Call：
|
//Author:junwei.jiang
|
//Date:2021-11-1
|
//Modify:
|
/************************************************************************/
|
static int bt_stop_service(int id)
|
{
|
int ret=0;
|
|
if(cp_exception_sts)
|
return 0;
|
|
ret = skw_stop_bt_service();
|
if(ret < 0){
|
skwboot_err("%s boot bt fail \n", __func__);
|
return -1;
|
}
|
skwboot_log("%s OK\n",__func__);
|
return 0;
|
}
|
static void seekwave_release(struct device *dev)
|
|
{
|
}
|
static struct platform_device seekwave_device ={
|
.name = CHIP_DEV_NAME,
|
.dev = {
|
.release = seekwave_release,
|
}
|
};
|
|
/***************************************************************************
|
*Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
**************************************************************************/
|
static int seekwave_boot_probe(struct platform_device *pdev)
|
{
|
int ret;
|
int time_count=0;
|
struct device *io_bus;
|
|
if (pdev != &seekwave_device)
|
seekwave_device.name = NULL;
|
boot_data = devm_kzalloc(&pdev->dev, sizeof(struct seekwave_device), GFP_KERNEL);
|
if (!boot_data) {
|
skwboot_err("%s :kzalloc error !\n", __func__);
|
return -ENOMEM;
|
}
|
mutex_init(&boot_mutex);
|
seekwave_boot_parse_dt(pdev, boot_data);
|
io_bus = skw_get_bus_dev();
|
if (!io_bus) {
|
skwboot_log("%s :CHIP_RESET AGAIN!\n", __func__);
|
skw_chip_power_reset();
|
do {
|
msleep(10);
|
io_bus = skw_get_bus_dev();
|
} while(!io_bus && time_count++ < 50);
|
}
|
if (!io_bus) {
|
devm_kfree(&pdev->dev, boot_data);
|
skwboot_err("%s get bus dev fail !\n",__func__);
|
return -ENODEV;
|
}
|
//get chip id
|
if (!strncmp(local_chip_id,"SV6160LITE",10)) {
|
if (!strncmp(io_bus->bus->name, "usb", 3)) {
|
boot_data->iram_file_path = "SWT6621S_IRAM_USB.bin";
|
boot_data->dram_file_path = "SWT6621S_DRAM_USB.bin";
|
boot_data->skw_nv_name = "SWT6621S_NV_USB.bin";
|
} else {
|
boot_data->iram_file_path = "SWT6621S_IRAM_SDIO.bin";
|
boot_data->dram_file_path = "SWT6621S_DRAM_SDIO.bin";
|
boot_data->skw_nv_name = "SWT6621S_NV_SDIO.bin";
|
}
|
} else if (!strncmp(local_chip_id,"SV6160",6)) {
|
if (!strncmp(io_bus->bus->name, "usb", 3)) {
|
boot_data->iram_file_path = "SWT6621_IRAM_USB.bin";
|
boot_data->dram_file_path = "SWT6621_DRAM_USB.bin";
|
} else {
|
boot_data->iram_file_path = "SWT6621_IRAM_SDIO.bin";
|
boot_data->dram_file_path = "SWT6621_DRAM_SDIO.bin";
|
}
|
boot_data->skw_nv_name = NULL;
|
} else if (!strncmp(local_chip_id,"SV6316",6)) {
|
if (!strncmp(io_bus->bus->name, "usb", 3)) {
|
boot_data->iram_file_path = "SWT6652_IRAM_USB.bin";
|
boot_data->dram_file_path = "SWT6652_DRAM_USB.bin";
|
} else if (!strncmp(io_bus->bus->name, "pci", 3)) {
|
boot_data->pdev = pdev;
|
if (container_of(io_bus, struct pci_dev, dev)->device == 0x6316) {
|
boot_data->iram_file_path = "SWT6652_IRAM_PCIE.bin";
|
boot_data->dram_file_path = "SWT6652_DRAM_PCIE.bin";
|
} else if (container_of(io_bus, struct pci_dev, dev)->device == 0x6315) {
|
boot_data->iram_file_path = "SWT6652S_IRAM_PCIE.bin";
|
boot_data->dram_file_path = "SWT6652S_DRAM_PCIE.bin";
|
}
|
} else {
|
boot_data->iram_file_path = "SWT6652_IRAM_SDIO.bin";
|
boot_data->dram_file_path = "SWT6652_DRAM_SDIO.bin";
|
}
|
boot_data->skw_nv_name = "SEEKWAVE_NV_SWT6652.bin";
|
} else {
|
skwboot_warn("%s:get chip id is NULL!!!\n", __func__);
|
}
|
ret = skw_boot_init(boot_data);
|
if (ret < 0) {
|
skwboot_err("%s:boot init fail\n", __func__);
|
return -1;
|
}
|
boot_data->pdev = pdev;
|
ret = skw_first_boot(boot_data);
|
if (strncmp(io_bus->bus->name, "usb", 3))
|
skw_bind_boot_driver(io_bus);
|
return ret;
|
}
|
/***************************************************************************
|
*Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
**************************************************************************/
|
static int seekwave_boot_remove(struct platform_device *pdev)
|
{
|
skwboot_log("%s the Enter \n", __func__);
|
|
if (btboot_pdev) {
|
platform_device_unregister(btboot_pdev);
|
btboot_pdev = NULL;
|
}
|
if (boot_data) {
|
if (!boot_data->iram_img_data) {
|
skwboot_log(":iram_img_data is NULL\n");
|
} else {
|
vfree(boot_data->iram_img_data);
|
boot_data->iram_img_data = NULL;
|
}
|
if (!boot_data->dram_img_data) {
|
skwboot_err(":dram_img_data is NULL\n");
|
} else {
|
vfree(boot_data->dram_img_data);
|
boot_data->dram_img_data = NULL;
|
}
|
if (boot_data->nv_mem_size > 20) { //new nv
|
skwboot_log(":free nv_mem_data\n");
|
if (boot_data->nv_mem_data) {
|
skwboot_log(":free 2 nv_mem_data\n");
|
kfree(boot_data->nv_mem_data);
|
boot_data->nv_mem_data = NULL;
|
}
|
}
|
boot_data->dl_base_img = NULL;
|
boot_data->skw_nv_name = NULL;
|
boot_data->iram_file_path = NULL;
|
boot_data->dram_file_path = NULL;
|
boot_data->wifi_start = NULL;
|
boot_data->wifi_stop = NULL;
|
boot_data->bt_start = NULL;
|
boot_data->bt_stop = NULL;
|
boot_data->skw_dloader_module = NULL;
|
devm_kfree(&pdev->dev, boot_data);
|
boot_data = NULL;
|
} else {
|
skwboot_err("%s:boot_data is NULL\n", __func__);
|
}
|
mutex_destroy(&boot_mutex);
|
return 0;
|
}
|
extern void skw_modem_log_stop_rec(void);
|
static void seekwave_boot_shutdown(struct platform_device *pdev)
|
{
|
skwboot_log("%s enter ...\n", __func__);
|
skw_modem_log_stop_rec();
|
skw_reset_bus_dev();
|
}
|
static const struct of_device_id seekwave_match_table[] ={
|
|
{ .compatible = CHIP_DEV_NAME_COM},
|
{ },
|
};
|
|
static struct platform_driver seekwave_driver ={
|
|
.driver = {
|
.owner = THIS_MODULE,
|
.name = CHIP_DEV_NAME,
|
.of_match_table = seekwave_match_table,
|
},
|
.probe = seekwave_boot_probe,
|
.remove = seekwave_boot_remove,
|
.shutdown = seekwave_boot_shutdown,
|
};
|
|
/***********************************************************************
|
*Description:chipen gpio pin reset
|
*Seekwave tech LTD
|
*Author:zongqiang.cheng
|
*Date:2025-3-18
|
*Modify:
|
***********************************************************************/
|
int skw_chipen_gpio_reset(int on)
|
{
|
int chip_en = g_chipen_pin;
|
if (chip_en < 0){
|
printk("chip_en need set !!\n");
|
return -1;
|
}
|
|
if(on) {
|
gpio_set_value(chip_en, 1);
|
printk("seekwave power on !!\n");
|
} else {
|
gpio_set_value(chip_en, 0);
|
printk("seekwave power down !!\n");
|
}
|
return 0;
|
}
|
|
/***********************************************************************
|
*Description:BT download boot pdata
|
*Seekwave tech LTD
|
*Author:junwei.jiang
|
*Date:2021-11-3
|
*Modify:
|
***********************************************************************/
|
static int get_sleep_status(int portno, char *buffer, int size)
|
{
|
memcpy(buffer, "WAKE", 4);
|
if (boot_data->host_gpio >=0) {
|
if (gpio_get_value(boot_data->host_gpio) == 0)
|
memcpy(buffer, "DOWN", 4);
|
}
|
return 4;
|
}
|
static int set_sleep_status(int portno, char *buffer, int size)
|
{
|
int i, count;
|
|
for(i=0; i<2; i++) {
|
if (gpio_get_value(boot_data->host_gpio))
|
return 1;
|
if(buffer && !strncmp(buffer, "WAKE", 4)) {
|
gpio_set_value(boot_data->chip_gpio, 0);
|
udelay(10);
|
gpio_set_value(boot_data->chip_gpio, 1);
|
}
|
count = 0;
|
do {
|
if (count++ < 100)
|
udelay(20);
|
} while(gpio_get_value(boot_data->host_gpio) ==0);
|
if (gpio_get_value(boot_data->host_gpio))
|
return 1;
|
udelay(100);
|
}
|
if (gpio_get_value(boot_data->host_gpio)==0)
|
skwboot_log("wakeup CHIP timeout!!! \n");
|
return 1;
|
}
|
struct sv6160_platform_data boot_pdata = {
|
.data_port = 8,
|
.bus_type = SDIO_LINK,
|
.max_buffer_size = 0x800,
|
.align_value = 4,
|
.hw_sdma_rx = get_sleep_status,
|
.hw_sdma_tx = set_sleep_status,
|
.open_port = bt_start_service,
|
.close_port = bt_stop_service,
|
};
|
|
/***************************************************************
|
*Description:BT bind boot driver
|
*Seekwave tech LTD
|
*Author:junwei.jiang
|
*Date:2021-11-3
|
*Modify:
|
***************************************************************/
|
int skw_bind_boot_driver(struct device *dev)
|
{
|
struct platform_device *pdev;
|
char pdev_name[32];
|
int ret = 0;
|
sprintf(pdev_name, "skw_ucom");
|
if(!dev){
|
skwboot_err("%s the dev fail \n", __func__);
|
return -1;
|
}
|
if (btboot_pdev)
|
return ret;
|
|
pdev = platform_device_alloc(pdev_name, PLATFORM_DEVID_AUTO);
|
if(!pdev)
|
return -ENOMEM;
|
pdev->dev.parent = dev;
|
pdev->dev.dma_mask = &port_dmamask;
|
pdev->dev.coherent_dma_mask = port_dmamask;
|
boot_pdata.port_name = "BTBOOT";
|
boot_pdata.data_port = 8;
|
//skw_get_chipid((char *)&boot_data->chip_id);
|
ret = platform_device_add_data(pdev, &boot_pdata, sizeof(boot_pdata));
|
if(ret) {
|
dev_err(dev, "failed to add boot data \n");
|
platform_device_put(pdev);
|
return ret;
|
}
|
ret = platform_device_add(pdev);
|
if(ret) {
|
platform_device_put(pdev);
|
skwboot_err("%s,line:%d the device add fail \n",__func__,__LINE__);
|
return ret;
|
}
|
btboot_pdev = pdev;
|
return ret;
|
}
|
/****************************************************************
|
*Description:the data Little Endian process interface
|
*Func:EndianConv_32
|
*Calls:None
|
*Call By:The img data process
|
*Input:value
|
*Output:the Endian data
|
*Return：value
|
*Others:
|
*Author：JUNWEI.JIANG
|
*Date:2021-08-26
|
* **************************************************************/
|
static unsigned int EndianConv_32(unsigned int value)
|
{
|
#ifdef _LITTLE_ENDIAN
|
unsigned int nTmp = (value >>24 | value <<24);
|
nTmp |= ((value >> 8) & 0x0000FF00);
|
nTmp |= ((value << 8) & 0x00FF0000);
|
return nTmp;
|
#else
|
return value;
|
#endif
|
}
|
|
/****************************************************************
|
*Description:dram read the double img file
|
*Func:
|
*Calls:
|
*Call By:
|
*Input:the file path
|
*Output:download data and the data size dl_data image_size
|
*Return：0:pass other fail
|
*Others:
|
*Author：JUNWEI.JIANG
|
*Date:2022-02-07
|
* **************************************************************/
|
static int skw_download_signal_ops(void)
|
{
|
unsigned int tmp_signal = 0;
|
//download done flag ++
|
boot_data->dl_done_signal ++;
|
tmp_signal = boot_data->dl_done_signal;
|
boot_data->dl_done_signal = 0xff&tmp_signal;
|
boot_data->dl_acount_addr = SKW_SDIO_PD_DL_AP2CP_BSP;
|
|
//gpio need set high or low power interrupt to cp wakeup
|
boot_data->gpio_out = boot_data->chip_gpio;
|
if(boot_data->gpio_val)
|
boot_data->gpio_val =0;
|
else
|
boot_data->gpio_val =1;
|
skwboot_log("%s line:%d download data ops done the dl_count=%d \n", __func__, __LINE__,boot_data->dl_done_signal);
|
return 0;
|
}
|
/****************************************************************
|
*Description:analysis the double img dram iram
|
*Func:
|
*Calls:
|
*Call By:
|
*Input:the file path
|
*Output:download data and the data size dl_data image_size
|
*Return：0:pass other fail
|
*Others:
|
*Author：JUNWEI.JIANG
|
*Date:2022-02-07
|
* **************************************************************/
|
static int skw_boot_init(struct seekwave_device *boot_data)
|
{
|
int i =0;
|
int k =0;
|
unsigned int head_offset=0;
|
unsigned int tail_offset=0;
|
int ret = 0;
|
struct img_head_data_t dl_data_info;
|
unsigned int *data=NULL;
|
unsigned int *nvdata=NULL;
|
unsigned int *dl_addr_data=NULL;
|
|
ret = skw_request_firmwares(boot_data, boot_data->dram_file_path,
|
boot_data->iram_file_path,
|
boot_data->skw_nv_name);
|
if (ret == ENOENT) {
|
ret = skw_request_firmwares(boot_data,
|
boot_data->dram_file_path,
|
boot_data->iram_file_path,
|
SEEKWAVE_NV_NAME);
|
}
|
skwboot_log("image_size=%d,%d, ret=%d\n", boot_data->iram_dl_size,
|
boot_data->dram_dl_size, ret);
|
if (ret < 0){
|
skwboot_err("request image fail\n");
|
return ret;
|
}
|
boot_data->head_addr = 0;
|
boot_data->tail_addr = 0;
|
boot_data->bsp_head_addr = 0;
|
boot_data->bsp_tail_addr = 0;
|
boot_data->wifi_head_addr =0;
|
boot_data->wifi_tail_addr = 0;
|
boot_data->bt_head_addr = 0;
|
boot_data->bt_tail_addr = 0;
|
boot_data->nv_head_addr = 0;
|
boot_data->nv_tail_addr = 0;
|
boot_data->nv_data_size = 0;
|
|
if(boot_data->iram_img_data!=NULL){
|
/*analysis the img*/
|
for(i=0; i*IMG_HEAD_OPS_LEN<IMG_HEAD_INFOR_RANGE; i++)
|
{
|
if(!head_offset)
|
{
|
if((0==memcmp(CP_IMG_HEAD0, boot_data->iram_img_data+i*IMG_HEAD_OPS_LEN,IMG_HEAD_OPS_LEN))&&
|
(0==memcmp(CP_IMG_HEAD1,boot_data->iram_img_data+(i+1)*IMG_HEAD_OPS_LEN,IMG_HEAD_OPS_LEN)))
|
head_offset = (i+1)*IMG_HEAD_OPS_LEN;
|
}else if(!tail_offset){
|
if((0==memcmp(CP_IMG_TAIL0, boot_data->iram_img_data+i*IMG_HEAD_OPS_LEN, IMG_HEAD_OPS_LEN))&&
|
(0==memcmp(CP_IMG_TAIL1, boot_data->iram_img_data+(i+1)*IMG_HEAD_OPS_LEN, IMG_HEAD_OPS_LEN))){
|
tail_offset = (i-1)*IMG_HEAD_OPS_LEN;
|
break;
|
}
|
}
|
}
|
|
/*analysis the nv*/
|
for(k=0; k*IMG_HEAD_OPS_LEN<IMG_HEAD_INFOR_RANGE; k++)
|
{
|
if(!boot_data->nv_head_addr)
|
{
|
if(0==memcmp(CP_NV_HEAD, boot_data->iram_img_data+k*IMG_HEAD_OPS_LEN,IMG_HEAD_OPS_LEN))
|
boot_data->nv_head_addr = k*IMG_HEAD_OPS_LEN;
|
}else if(!boot_data->nv_tail_addr){
|
if((0==memcmp(CP_NV_TAIL, boot_data->iram_img_data+k*IMG_HEAD_OPS_LEN, IMG_HEAD_OPS_LEN))){
|
boot_data->nv_tail_addr = k*IMG_HEAD_OPS_LEN;
|
boot_data->nv_data_size = boot_data->nv_tail_addr - boot_data->nv_head_addr - IMG_HEAD_OPS_LEN;
|
nvdata = (u32 *) &boot_data->iram_img_data[boot_data->nv_head_addr];
|
break;
|
}
|
}
|
}
|
if(!tail_offset){
|
skwboot_err("%s,%d,the iram_img not need analysis!!! or Fail!! \n",__func__,__LINE__);
|
return -1;
|
}else{
|
//get the iram img addr and dram img addr
|
dl_addr_data = (unsigned int *)(boot_data->iram_img_data+head_offset+IMG_HEAD_OPS_LEN);
|
boot_data->iram_dl_addr = dl_addr_data[0];
|
boot_data->dram_dl_addr = dl_addr_data[1];
|
head_offset = head_offset+RAM_ADDR_OPS_LEN;//jump the ram addr data;
|
|
skwboot_log("%s line:%d,the tail_offset ---0x%x, the head_offset --0x%x ,iram_addr=0x%x,dram_addr=0x%x, \
|
nv_head_addr:0x%x,nv_tail_addr:0x%x,nv_size=%d\n",__func__, __LINE__,tail_offset, head_offset,
|
boot_data->iram_dl_addr,boot_data->dram_dl_addr,boot_data->nv_head_addr,boot_data->nv_tail_addr,
|
boot_data->nv_data_size);
|
}
|
/*need download the img bin for WIFI or BT service dl_module >0*/
|
head_offset = head_offset +IMG_HEAD_OPS_LEN;
|
/*get the img head tail offset*/
|
boot_data->head_addr = head_offset;
|
boot_data->tail_addr = tail_offset;
|
|
skwboot_log("%s line:%d analysis the img module\n", __func__, __LINE__);
|
for(i=0; i*MODULE_INFO_LEN<=(tail_offset-head_offset); i++)
|
{
|
data = (unsigned int *)(boot_data->iram_img_data +head_offset+i*MODULE_INFO_LEN);
|
dl_data_info.dl_addr=data[0];
|
dl_data_info.write_addr =data[2];
|
dl_data_info.index = 0x000000FF&EndianConv_32(data[1]);
|
dl_data_info.data_size = 0x00FFFFFF&data[1];
|
if(dl_data_info.index==1){
|
boot_data->bsp_index_count +=1;
|
}else if(dl_data_info.index ==2){
|
boot_data->wifi_index_count +=1;
|
}else if(dl_data_info.index ==3){
|
boot_data->bt_index_count +=1;
|
}
|
skwboot_log("%s line:%d dl_addr=0x%x, write_addr=0x%x, index=0x%x,data_size=0x%x\n", __func__,
|
__LINE__, dl_data_info.dl_addr,dl_data_info.write_addr,dl_data_info.index,dl_data_info.data_size);
|
}
|
skwboot_log("%s line:%d bsp_index count:%d, bt_index_count=%d, wifi_index_count=%d \n",
|
__func__, __LINE__,boot_data->bsp_index_count,boot_data->bt_index_count,boot_data->wifi_index_count);
|
//get the dl count for the service download module img
|
boot_data->wifi_dl_count = boot_data->bsp_index_count + boot_data->wifi_index_count;
|
boot_data->all_dl_count = boot_data->bsp_index_count + boot_data->wifi_index_count + boot_data->bt_index_count;
|
boot_data->bt_dl_count = boot_data->bsp_index_count + boot_data->bt_index_count;
|
|
if (boot_data->nv_mem_size > 20) {//new nv
|
if(boot_data->nv_mem_cmfg_size && (boot_data->nv_mem_cmfg_size <= boot_data->nv_data_size)){
|
memcpy((boot_data->iram_img_data+boot_data->nv_head_addr+4),boot_data->nv_mem_cmfg_data,boot_data->nv_mem_cmfg_size);
|
//kfree(boot_data->nv_mem_data);
|
//boot_data->nv_mem_data = NULL;
|
}
|
} else {//old nv
|
if(boot_data->nv_mem_size && (boot_data->nv_mem_size <= boot_data->nv_data_size)){
|
memcpy((boot_data->iram_img_data+boot_data->nv_head_addr+4),boot_data->nv_mem_data,boot_data->nv_mem_size);
|
kfree(boot_data->nv_mem_data);
|
boot_data->nv_mem_data = NULL;
|
}
|
}
|
//print_hex_dump(KERN_ERR, "nvcom ", 0, 16, 1,boot_data->iram_img_data+boot_data->nv_head_addr, boot_data->nv_data_size+8, 1);
|
}
|
return 0;
|
}
|
//debug cp boot for setvalue
|
int gbl_count_flag=0;
|
/****************************************************************
|
*Description:download the wifi bt service img,
|
*Func:
|
*Calls:
|
*Call By:
|
*Input:the service index
|
*Output:download data
|
*Return：0:pass other fail
|
*Others:
|
*Author：JUNWEI.JIANG
|
*Date:2024-02-07
|
* **************************************************************/
|
static int skw_dloader_module(int service_index)
|
{
|
int i =0;
|
int ret = 0;
|
struct img_head_data_t dl_data_info;
|
unsigned int *data=NULL;
|
int tmp_count=0;
|
int total_count=0;
|
#if SKW_CPBOOT_DEBUG//for wifionly debug cp boot sleep no dl img setvalue 1;
|
skwboot_log("%s:the debug skw_dloader Enter \n",__func__);
|
return 0;
|
#endif
|
//dl count flag setvalue
|
if(service_index==SKW_WIFI){
|
tmp_count = boot_data->wifi_dl_count;
|
}else if(service_index == SKW_BT){
|
tmp_count = boot_data->bt_dl_count;
|
}else if(service_index == SKW_ALL){
|
tmp_count = boot_data->all_dl_count;
|
}else{
|
skwboot_warn("%s No service index ops!!!\n",__func__);
|
}
|
#if 1//debug cp boot for setvalue 1
|
if(gbl_count_flag==0){
|
boot_data->dl_done_signal=0;
|
gbl_count_flag=1;
|
}
|
#endif
|
skwboot_log("the dl_count ---dl_bin_counts ===%d\n",tmp_count);
|
boot_data->service_ops = SKW_NO_SERVICE;
|
if(boot_data->iram_img_data!=NULL){
|
for(i=0; i*MODULE_INFO_LEN<=(boot_data->tail_addr-boot_data->head_addr); i++)
|
{
|
data = (unsigned int *)(boot_data->iram_img_data +boot_data->head_addr+i*MODULE_INFO_LEN);
|
dl_data_info.dl_addr=data[0];
|
dl_data_info.write_addr =data[2];
|
dl_data_info.index = 0x000000FF&EndianConv_32(data[1]);
|
dl_data_info.data_size = 0x00FFFFFF&data[1];
|
skwboot_log("%s line:%d dl_addr=0x%x, write_addr=0x%x, index=0x%x,data_size=0x%x\n", __func__,
|
__LINE__, dl_data_info.dl_addr,dl_data_info.write_addr,dl_data_info.index,dl_data_info.data_size);
|
if(service_index ==dl_data_info.index || SKW_BSP== dl_data_info.index || service_index == SKW_ALL){
|
total_count +=1;
|
boot_data->dl_base_addr = dl_data_info.write_addr;
|
boot_data->dl_size = dl_data_info.data_size;
|
if(dl_data_info.dl_addr >= boot_data->dram_dl_addr){
|
//iram data dload img
|
boot_data->dl_offset_addr =dl_data_info.dl_addr- boot_data->dram_dl_addr;
|
boot_data->dl_base_img = boot_data->dram_img_data;
|
}else {
|
//dram data dload img
|
boot_data->dl_offset_addr =dl_data_info.dl_addr- boot_data->iram_dl_addr;
|
boot_data->dl_base_img = boot_data->iram_img_data;
|
}
|
if(tmp_count == total_count){
|
skw_download_signal_ops();
|
}
|
ret=skw_boot_loader(boot_data);
|
if(ret){
|
skwboot_err("%s the load module=%d, fail,ret=%d \n", __func__, dl_data_info.index, ret);
|
break;
|
}
|
}else{
|
skwboot_err("%s not need to load module_index=%d,ret=%d \n", __func__, dl_data_info.index, ret);
|
}
|
}
|
|
}
|
return ret;
|
}
|
|
/***************************************************************************
|
*Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
**************************************************************************/
|
int skw_start_wifi_service(void)
|
{
|
int ret =0;
|
|
skwboot_log("%s Enter cp_state =%d \n",__func__, cp_exception_sts);
|
mutex_lock(&boot_mutex);
|
boot_data->service_ops = SKW_WIFI_START;
|
#if defined(SKW_BOOT_MEMPOWERON)
|
boot_data->dl_module = NONE_BOOT;
|
boot_data->first_boot_flag =1;
|
boot_data->dl_base_img = NULL;
|
#else
|
boot_data->first_dl_flag = 1;
|
boot_data->dl_module = SKW_WIFI_BOOT;
|
//download done flag ++
|
skw_download_signal_ops();
|
#endif
|
ret = skw_boot_loader(boot_data);
|
mutex_unlock(&boot_mutex);
|
if(ret !=0)
|
{
|
skwboot_err("%s,line:%d boot fail \n", __func__,__LINE__);
|
return -1;
|
}
|
|
skwboot_log("%s wifi boot sucessfull\n", __func__);
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(skw_start_wifi_service);
|
/***************************************************************************
|
*Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
**************************************************************************/
|
int skw_stop_wifi_service(void)
|
{
|
int ret =0;
|
skwboot_log("%s Enter cp_state =%d \n",__func__, cp_exception_sts);
|
mutex_lock(&boot_mutex);
|
boot_data->service_ops = SKW_WIFI_STOP;
|
#if defined(SKW_BOOT_MEMPOWERON)
|
boot_data->dl_module = NONE_BOOT;
|
boot_data->first_boot_flag =1;
|
boot_data->dl_base_img = NULL;
|
#else
|
boot_data->dl_module = 0;
|
boot_data->first_dl_flag = 1;
|
#endif
|
//download done flag ++
|
//gpio need set high or low power interrupt to cp wakeup
|
boot_data->gpio_out = boot_data->chip_gpio;
|
if(boot_data->gpio_val)
|
boot_data->gpio_val =0;
|
else
|
boot_data->gpio_val =1;
|
ret = skw_boot_loader(boot_data);
|
mutex_unlock(&boot_mutex);
|
if(ret !=0)
|
{
|
skwboot_warn("dload the img fail \n");
|
return -1;
|
}
|
skwboot_log("seekwave boot stop done:%s\n",__func__);
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(skw_stop_wifi_service);
|
/***************************************************************************
|
*Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
**************************************************************************/
|
static int skw_start_bt_service(void)
|
{
|
int ret=0;
|
skwboot_log("%s Enter cp_state =%d \n",__func__, cp_exception_sts);
|
mutex_lock(&boot_mutex);
|
boot_data->service_ops = SKW_BT_START;
|
#if defined(SKW_BOOT_MEMPOWERON)
|
boot_data->first_boot_flag =1;
|
boot_data->dl_base_img = NULL;
|
boot_data->dl_module = NONE_BOOT;
|
#else
|
boot_data->first_dl_flag = 1;
|
boot_data->dl_module = SKW_BT_BOOT;
|
//download done flag ++
|
skw_download_signal_ops();
|
#endif
|
ret = skw_boot_loader(boot_data);
|
mutex_unlock(&boot_mutex);
|
if(ret !=0)
|
{
|
skwboot_err("%s boot fail \n", __func__);
|
return -1;
|
}
|
|
skwboot_log("%s line:%d , boot bt sucessfully!\n", __func__,__LINE__);
|
return 0;
|
}
|
|
/***************************************************************************
|
*Description:
|
*Seekwave tech LTD
|
*Author:
|
*Date:
|
*Modify:
|
**************************************************************************/
|
static int skw_stop_bt_service(void)
|
{
|
int ret =0;
|
skwboot_log("%s Enter cp_state =%d \n",__func__, cp_exception_sts);
|
mutex_lock(&boot_mutex);
|
boot_data->service_ops = SKW_BT_STOP;
|
#if defined(SKW_BOOT_MEMPOWERON)
|
boot_data->first_boot_flag = 1;
|
boot_data->dl_base_img = NULL;
|
#else
|
boot_data->dl_module = 0;
|
boot_data->first_dl_flag = 1;
|
#endif
|
//download done flag ++
|
boot_data->dl_module = NONE_BOOT;
|
//gpio need set high or low power interrupt to cp wakeup
|
boot_data->gpio_out = boot_data->chip_gpio;
|
if(boot_data->gpio_val)
|
boot_data->gpio_val =0;
|
else
|
boot_data->gpio_val =1;
|
ret = skw_boot_loader(boot_data);
|
mutex_unlock(&boot_mutex);
|
if(ret !=0)
|
{
|
skwboot_warn("dload the img fail \n");
|
return -1;
|
}
|
skwboot_log("seekwave boot stop done:%s\n",__func__);
|
return 0;
|
}
|
|
/****************************************************************
|
*Description:double iram dram img first boot cp
|
*Func:
|
*Calls:
|
*Call By:skw_first_boot
|
*Input:the file path
|
*Output:download data and the data size dl_data image_size
|
*Return：0:pass other fail
|
*Others:
|
*Author：JUNWEI.JIANG
|
*Date:2022-02-07
|
* **************************************************************/
|
static int skw_first_boot(struct seekwave_device *boot_data)
|
{
|
int ret =0;
|
//get the img data
|
#ifdef DEBUG_SKWBOOT_TIME
|
ktime_t cur_time,last_time;
|
cur_time = ktime_get();
|
#endif
|
//set download the value;
|
boot_data->service_ops = SKW_NO_SERVICE;
|
boot_data->save_setup_addr = SKW_SDIO_PD_DL_AP2CP_BSP; //160
|
boot_data->gpio_out = boot_data->chip_gpio;
|
boot_data->gpio_val = 0;
|
boot_data->dl_module = 0;
|
boot_data->first_dl_flag =0;
|
boot_data->gpio_in = boot_data->host_gpio;
|
boot_data->dma_type_addr = SKW_SDIO_PLD_DMA_TYPE;
|
boot_data->slp_disable_addr = SKW_SDIO_CP_SLP_SWITCH;
|
boot_data->wifi_start = skw_start_wifi_service;
|
boot_data->wifi_stop = skw_stop_wifi_service;
|
boot_data->bt_start = skw_start_bt_service;
|
boot_data->bt_stop = skw_stop_bt_service;
|
boot_data->skw_dloader_module = skw_dloader_module;
|
ret = skw_boot_loader(boot_data);
|
if(ret < 0){
|
skwboot_err("%s firt boot cp fail \n", __func__);
|
return -1;
|
}
|
//download done set the download flag;
|
boot_data->first_dl_flag =1;
|
boot_data->first_boot_flag =1;
|
|
//download done tall cp acount;
|
boot_data->dl_done_signal &= 0xFF;
|
boot_data->dl_done_signal +=1;
|
skwboot_log("%s first boot pass\n", __func__);
|
#ifdef DEBUG_SKWBOOT_TIME
|
last_time = ktime_get();
|
skwboot_log("%s,the download time start time %llu and the over time %llu \n",
|
__func__, cur_time, last_time);
|
#endif
|
return ret;
|
}
|
int seekwave_boot_init(char *chip_id)
|
{
|
int ret;
|
|
skwboot_log("%s: enter chip_id=%s\n",__func__,chip_id);
|
if(chip_id != NULL && strlen(chip_id)!=0){
|
local_chip_id = chip_id;
|
}
|
btboot_pdev = NULL;
|
skw_ucom_init();
|
ret = platform_driver_register(&seekwave_driver);
|
if (seekwave_device.name)
|
platform_device_register(&seekwave_device);
|
return ret;
|
}
|
void seekwave_boot_exit(void)
|
{
|
skw_ucom_exit();
|
|
if (seekwave_device.name)
|
platform_device_unregister(&seekwave_device);
|
platform_driver_unregister(&seekwave_driver);
|
}
|
