/*****************************************************************
|
*Copyright (C) 2021 Seekwave Tech Inc.
|
*Filename : skw_log_process.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.
|
* **************************************************************/
|
|
/* #define DEBUG */
|
/* #define VERBOSE_DEBUG */
|
|
#include <linux/kernel.h>
|
#include <linux/cdev.h>
|
#include <linux/fs.h>
|
#include <linux/slab.h>
|
#include <linux/uaccess.h>
|
#include <linux/workqueue.h>
|
#include <linux/scatterlist.h>
|
#include <linux/platform_device.h>
|
#include <linux/poll.h>
|
#include <linux/delay.h>
|
#include <linux/wait.h>
|
#include <linux/err.h>
|
#include <linux/version.h>
|
#include <linux/types.h>
|
#include <linux/file.h>
|
#include <linux/device.h>
|
#include <linux/miscdevice.h>
|
#include "skw_boot.h"
|
|
#include "skw_log_to_file.h"
|
#include "skw_mem_map.h"
|
extern int cp_exception_sts;
|
static char *log_path = "/data";
|
module_param(log_path, charp, 0644);
|
|
int skw_log_num = 2;
|
#ifdef MIN_LOG_SIZE
|
int skw_log_size = (1*1024*1024);
|
#else
|
int skw_log_size = (100*1024*1024);
|
#endif
|
#define SKW_LOG_READ_BUFFER_SIZE (8*1024)
|
|
#ifndef CONFIG_NO_GKI
|
#define CONFIG_NO_GKI
|
#endif
|
|
module_param(skw_log_size, int, 0644);
|
module_param(skw_log_num, int, 0644);
|
|
struct skw_log_data {
|
spinlock_t lock;
|
|
int state;
|
|
/* synchronize access to our device file */
|
atomic_t open_excl;
|
/* to enforce only one ioctl at a time */
|
atomic_t ioctl_excl;
|
|
|
int rx_done;
|
/* for processing MTP_SEND_FILE, MTP_RECEIVE_FILE and
|
* MTP_SEND_FILE_WITH_HEADER ioctls on a work queue
|
*/
|
struct workqueue_struct *wq;
|
struct work_struct log_to_file_work;
|
struct file *xfer_file;
|
loff_t xfer_file_offset;
|
int64_t xfer_file_length;
|
unsigned xfer_send_header;
|
uint16_t xfer_command;
|
uint32_t xfer_transaction_id;
|
int xfer_result;
|
};
|
|
struct log_com_dev {
|
atomic_t open;
|
spinlock_t lock;
|
int rx_busy;
|
int tx_busy;
|
int devno;
|
int portno;
|
struct sv6160_platform_data *pdata;
|
wait_queue_head_t wq;
|
struct cdev cdev;
|
char *rx_buf;
|
char *tx_buf;
|
struct notifier_block notifier;
|
};
|
struct skw_log_read_buffer {
|
int lenth;
|
char *buffer;
|
};
|
|
|
void skw_modem_log_to_file_work(struct work_struct *data);
|
extern int skw_cp_exception_reboot(void);
|
|
int skw_modem_save_dumpmem(void);
|
static uint32_t record_flag = 0;
|
static uint32_t cp_assert_status = 0;
|
struct file *log_fp = NULL;
|
struct log_com_dev *log_com = NULL;
|
struct sv6160_platform_data *port_data = NULL;
|
struct skw_log_data *skw_log_dev = NULL;
|
struct skw_log_read_buffer log_read_buffer;
|
|
char *log0_file = "log000";
|
char *log1_file = "log111";
|
char *log_file;
|
|
char* skw_code_mem = "code_mem_100000_7a000";
|
char* skw_data_mem = "data_mem_20200000_40000";
|
char* skw_cscb_mem = "cscb_mem_e000ed00_300";
|
char* skw_wreg_mem = "wreg_mem_40820000_4000";
|
char* skw_phyr_mem = "phyr_mem_40830000_4000";
|
char* skw_smem_mem = "smem_mem_40a00000_58000";
|
char* skw_umem_mem = "umem_mem_40b00000_c000";
|
char* skw_modem_mem = "sdio_mem_401e0000_800";
|
char* skw_btdm_mem = "btdm_mem_41000000_400";
|
char* skw_btbt_mem = "btbt_mem_41000400_400";
|
char* skw_btle_mem = "btle_mem_41000800_400";
|
char* skw_btem_mem = "btem_mem_41022000_c000";
|
|
int modem_event_notifier(struct notifier_block *nb, unsigned long action, void *data)
|
{
|
unsigned long flags;
|
skwboot_log("%s event = %d\n", __func__, (int)action);
|
switch(action)
|
{
|
case DEVICE_ASSERT_EVENT:
|
{
|
struct log_com_dev *ucom = log_com;
|
skwboot_log("the BSPASSERT EVENT Comming in !!!!\n");
|
skw_modem_log_start_rec();
|
spin_lock_irqsave(&ucom->lock, flags);
|
if(ucom->tx_busy) {
|
spin_unlock_irqrestore(&ucom->lock, flags);
|
skwboot_err("%s error 0\n", __func__);
|
return NOTIFY_OK;
|
}
|
ucom->tx_busy = 1;
|
spin_unlock_irqrestore(&ucom->lock, flags);
|
skw_modem_log_set_assert_status(1);
|
}
|
break;
|
case DEVICE_BSPREADY_EVENT:
|
{
|
skwboot_log("the BSPREADY EVENT Comming in !!!!\n");
|
skw_modem_log_start_rec();
|
}
|
break;
|
case DEVICE_DUMPDONE_EVENT:
|
{
|
skwboot_log("the DUMPDONE EVENT Comming in !!!!\n");
|
skw_modem_log_stop_rec();
|
skw_modem_log_set_assert_status(0);
|
}
|
break;
|
case DEVICE_BLOCKED_EVENT:
|
{
|
skwboot_log("the BLOCKED EVENT Comming in !!!!\n");
|
//skw_modem_dumpmodem_start_rec();
|
}
|
break;
|
case DEVICE_DUMPMEM_EVENT:
|
{
|
//skw_modem_dumpmodem_start_rec();
|
}
|
break;
|
default:
|
{
|
|
}
|
break;
|
|
}
|
return NOTIFY_OK;
|
}
|
|
void skw_modem_log_to_file_work(struct work_struct *data)
|
{
|
#ifdef CONFIG_NO_GKI
|
//int log_len = 0;
|
struct file *fp = log_fp;
|
struct file *log_store_fp = NULL;
|
loff_t offset =0;
|
loff_t log_store_offset =0;
|
unsigned long flags;
|
uint32_t *rx_data;
|
size_t count = 0;
|
int ret = 0;
|
int i = 0;
|
int log_cnt = 0;
|
int sdma_rx_error_cnt = 0;
|
char *log_store;
|
int log_path_len;
|
char rd_buff[50];
|
|
if(record_flag)
|
return;
|
record_flag = 1;
|
|
skwlog_log("log path = %s \n", log_path);
|
log_path_len = strlen(log_path);
|
|
log_file = kzalloc(log_path_len + 16, GFP_KERNEL);
|
|
if(log_file == NULL)
|
return;
|
log_store = kzalloc(log_path_len + 16, GFP_KERNEL);
|
if(log_store == NULL) {
|
kfree(log_file);
|
return;
|
}
|
|
sprintf(log_store, "%s/log_store", log_path);
|
log_store_fp = filp_open(log_store, O_RDWR, 0777);
|
while(IS_ERR(log_store_fp))
|
{
|
skwlog_err("open log_store %s failed:%d \n", log_store, (int)PTR_ERR(log_store_fp));
|
msleep(1000);
|
i++;
|
if(i > 8) {
|
kfree(log_store);
|
kfree(log_file);
|
return;
|
}
|
if(i > 5){
|
skwlog_err("%s open log_store file failed, create file:%s\n",__func__, log_store);
|
log_store_fp = filp_open(log_store, O_CREAT | O_RDWR | O_TRUNC, 0777);
|
}
|
else{
|
log_store_fp = filp_open(log_store, O_RDWR, 0777);
|
}
|
}
|
|
ret = skw_read_file(log_store_fp, rd_buff, 30, &log_store_offset);
|
if(ret < 0){
|
skwlog_err("%s Read file:%s failed, err:%d \n",__func__, log_store, ret);
|
}
|
|
rd_buff[0] = rd_buff[0]+1;
|
if(rd_buff[0] > skw_log_num) {
|
rd_buff[0] = 0;
|
}
|
sprintf(log_file, "%s/%s", log_path, log0_file);
|
log_path_len = strlen(log_file);
|
*(log_file + log_path_len - 1) = ((rd_buff[0]%10) | 0x30);
|
*(log_file + log_path_len - 2) = (((rd_buff[0]/10)%10) | 0x30);
|
|
log_store_offset = 0;
|
ret = skw_write_file(log_store_fp, rd_buff, 1, &log_store_offset);
|
if(ret < 0){
|
skwlog_err("%s write file:%s failed, err:%d \n",__func__, log_store, ret);
|
}
|
ret = skw_write_file(log_store_fp, log_file, strlen(log_file), &log_store_offset);
|
if(ret < 0){
|
skwlog_err("%s write f name to file:%s failed, err:%d \n",__func__, log_store, ret);
|
}
|
|
log_fp = filp_open(log_file, O_CREAT | O_RDWR | O_TRUNC, 0777);
|
fp = log_fp;
|
|
while(IS_ERR(fp))
|
{
|
skwlog_err("open rec file %s failed :%d \n",log_file, (int)PTR_ERR(fp));
|
msleep(500);
|
i++;
|
if(i > 10) {
|
kfree(log_store);
|
kfree(log_file);
|
return;
|
}
|
|
log_fp = filp_open(log_file, O_CREAT | O_RDWR | O_TRUNC, 0777);
|
fp = log_fp;
|
}
|
atomic_inc(&log_com->open);
|
if (atomic_read(&log_com->open)==1) {
|
init_waitqueue_head(&log_com->wq);
|
spin_lock_init(&log_com->lock);
|
log_com->pdata->open_port(log_com->portno, NULL, NULL);
|
}
|
|
log_read_buffer.lenth = 0;
|
log_read_buffer.buffer = kzalloc(SKW_LOG_READ_BUFFER_SIZE, GFP_KERNEL);
|
if(!log_read_buffer.buffer){
|
kfree(log_store);
|
kfree(log_file);
|
return;
|
}
|
skwlog_log(" open %s for CP log record \n", log_file);
|
while(record_flag || cp_assert_status)
|
{
|
ret = 0;
|
// if(log_com){
|
check_rx_busy:
|
spin_lock_irqsave(&log_com->lock, flags);
|
if(log_com->rx_busy) {
|
spin_unlock_irqrestore(&log_com->lock, flags);
|
mdelay(5);
|
goto check_rx_busy;
|
}
|
log_com->rx_busy = 1;
|
count = log_com->pdata->max_buffer_size;
|
spin_unlock_irqrestore(&log_com->lock, flags);
|
ret = log_com->pdata->hw_sdma_rx(log_com->portno, (log_read_buffer.buffer + log_read_buffer.lenth), count);
|
|
if(ret > 0){
|
log_cnt++;
|
sdma_rx_error_cnt = 0;
|
log_read_buffer.lenth = log_read_buffer.lenth + ret;
|
//skwlog_log("hw_sdma_rx:%s read len:%d buffer len:%d \n", skw_log, ret, log_read_buffer.lenth);
|
if(ret >= 0x1000)
|
skwlog_err("%s get too long data , err:%d \n",__func__, ret);
|
|
if(log_cnt > 1000){
|
skwlog_log("%s log_file:%s offset:%lld data:0x%x 0x%x 0x%x 0x%x 0x%x \n",__func__, log_file, offset, *(log_read_buffer.buffer),
|
*(log_read_buffer.buffer+1), *(log_read_buffer.buffer+2), *(log_read_buffer.buffer+3), *(log_read_buffer.buffer+4));
|
log_cnt = 0;
|
}
|
}
|
else{
|
skwlog_err("%s read log data err:%d \n",__func__, ret);
|
sdma_rx_error_cnt++;
|
if(sdma_rx_error_cnt > 5){
|
skwlog_err("%s sdma_rx_error_cnt over:%d, stop log work \n",__func__, sdma_rx_error_cnt);
|
skw_modem_log_set_assert_status(0);
|
skw_modem_log_stop_rec();
|
}
|
}
|
|
if (port_data->bus_type == USB_LINK) {
|
if(ret < 0){
|
skwlog_err("%s read log data err:%d, stop log work \n",__func__, ret);
|
skw_modem_log_set_assert_status(0);
|
skw_modem_log_stop_rec();
|
}
|
}
|
else if (port_data->bus_type == SDIO_LINK) {
|
if(ret == -ENOTCONN){
|
skw_modem_log_set_assert_status(0);
|
skw_modem_log_stop_rec();
|
}
|
}
|
//skwlog_log("read log from SDIO len:%d ----- \n", log_read_buffer.lenth);
|
log_com->rx_busy = 0;
|
rx_data = (uint32_t *)log_read_buffer.buffer;
|
// }
|
|
if(((log_read_buffer.lenth > 0) && cp_assert_status)
|
|| ((SKW_LOG_READ_BUFFER_SIZE - log_read_buffer.lenth) <= (log_com->pdata->max_buffer_size))){
|
//skwlog_log("skw_write_file:%s offset:%lld lenth:%d \n", skw_log, offset, log_read_buffer.lenth);
|
ret = skw_write_file(fp, log_read_buffer.buffer, log_read_buffer.lenth, &offset);
|
if(ret < 0){
|
skwlog_err("%s write file failed, err:%d \n",__func__, ret);
|
}
|
|
log_read_buffer.lenth = 0;
|
if(ret == -ENOSPC){
|
skwlog_err("%s no space, stop CP log record \n",__func__);
|
skw_modem_log_stop_rec();
|
}
|
|
if(offset > skw_log_size && (!cp_assert_status)){
|
if(!IS_ERR(fp))
|
filp_close(fp, NULL);
|
|
rd_buff[0] = rd_buff[0]+1;
|
if(rd_buff[0] > skw_log_num) {
|
rd_buff[0] = 0;
|
}
|
sprintf(log_file, "%s/%s", log_path, log0_file);
|
log_path_len = strlen(log_file);
|
*(log_file + log_path_len - 1) = ((rd_buff[0]%10) | 0x30);
|
*(log_file + log_path_len - 2) = (((rd_buff[0]/10)%10) | 0x30);
|
|
log_store_offset = 0;
|
ret = skw_write_file(log_store_fp, rd_buff, 1, &log_store_offset);
|
if(ret < 0){
|
skwlog_err("%s write file:%s failed, err:%d \n",__func__, log_store, ret);
|
}
|
ret = skw_write_file(log_store_fp, log_file, strlen(log_file), &log_store_offset);
|
if(ret < 0){
|
skwlog_err("%s write f name to file:%s failed, err:%d \n",__func__, log_store, ret);
|
}
|
|
log_fp = filp_open(log_file, O_CREAT | O_RDWR | O_TRUNC, 0777);
|
fp = log_fp;
|
if(IS_ERR(fp)){
|
skwlog_err("%s switch record file to:%s failed: %d \n",__func__, log_file, (int)PTR_ERR(fp));
|
kfree(log_file);
|
kfree(log_store);
|
kfree(log_read_buffer.buffer);
|
return;
|
}
|
else{
|
skwlog_err("%s switch record file to:%s sucess \n",__func__, log_file);
|
}
|
|
offset = 0;
|
}
|
}
|
}
|
atomic_dec(&log_com->open);
|
log_com->pdata->close_port(log_com->portno);
|
|
if(!IS_ERR(fp)){
|
filp_close(fp, NULL);
|
skwlog_log("%s close file %s before stop work.\n",__func__, log_file);
|
log_fp = NULL;
|
fp = log_fp;
|
}
|
|
if(!IS_ERR(log_store_fp)){
|
filp_close(log_store_fp, NULL);
|
skwlog_log("%s close file %s before stop work.\n",__func__, log_store);
|
log_store_fp = NULL;
|
}
|
kfree(log_file);
|
kfree(log_store);
|
kfree(log_read_buffer.buffer);
|
skwlog_log("%s work exit\n",__func__);
|
#endif
|
return;
|
}
|
|
/***************************************************************************
|
*Description:dump modem memory
|
*Seekwave tech LTD
|
*Author:JunWei Jiang
|
*Date:2022-11-14
|
*Modify:
|
**************************************************************************/
|
int skw_modem_save_mem(char *mem_path,unsigned int mem_len, unsigned int mem_addr)
|
{
|
int ret =0;
|
#ifdef CONFIG_NO_GKI
|
char dump_mem_file[128];
|
//dump code data
|
char *data_mem = NULL;
|
struct file *fp =NULL;
|
loff_t pos = 0;
|
int nwrite = 0;
|
unsigned int read_len=0;
|
unsigned int mem_size = mem_len;
|
|
memset(dump_mem_file, 0, sizeof(dump_mem_file));
|
sprintf(dump_mem_file,"%s/%s", log_path, mem_path);
|
data_mem = kzalloc(SKW_MAX_BUF_SIZE, GFP_KERNEL);
|
if(!data_mem){
|
skwlog_log("the kzalloc dump buffer fail");
|
return -2;
|
}
|
/* open file to write */
|
fp = filp_open(dump_mem_file, O_CREAT | O_RDWR | O_TRUNC, 0777);
|
if (IS_ERR(fp)) {
|
skwlog_log("open file %s fail try again!!!\n", dump_mem_file);
|
fp = filp_open(mem_path, O_CREAT | O_RDWR | O_TRUNC, 0777);
|
if(IS_ERR(fp)){
|
skwlog_log("open file error\n");
|
ret = -1;
|
goto exit;
|
}
|
}
|
|
while(mem_size)
|
{
|
if(mem_size<SKW_MAX_BUF_SIZE)
|
{
|
read_len = mem_size;
|
}else{
|
read_len = SKW_MAX_BUF_SIZE;
|
}
|
//skwlog_log("the read_len =0x%x mem_size= 0x%x\n", read_len, mem_size);
|
ret = log_com->pdata->skw_dump_mem(mem_addr+(mem_len-mem_size),(void *)data_mem,read_len);
|
if(ret< 0)
|
break;
|
|
//print_hex_dump(KERN_ERR, "img data ", 0, 16, 1,data_mem, 32, 1);
|
//pos=(unsigned long)offset;
|
/* Write buf to file */
|
nwrite=skw_write_file(fp, data_mem,read_len, &pos);
|
//offset +=nwrite;
|
|
if(mem_size>=SKW_MAX_BUF_SIZE)
|
{
|
mem_size=mem_size-SKW_MAX_BUF_SIZE;
|
}else{
|
mem_size =0;
|
}
|
}
|
skwlog_log("Dump %s memory done !!\n", mem_path);
|
if(fp)
|
{
|
filp_close(fp,NULL);
|
skwlog_log("the file close!!!\n");
|
}
|
exit:
|
if (fp)
|
filp_close(fp, NULL);
|
kfree(data_mem);
|
#endif
|
return ret;
|
}
|
|
/***************************************************************************
|
*Description:dump modem memory
|
*Seekwave tech LTD
|
*Author:JunWei Jiang
|
*Date:2022-11-14
|
*Modify:
|
**************************************************************************/
|
int skw_modem_save_dumpmem(void)
|
{
|
int ret =0;
|
if (!log_com->pdata->skw_dump_mem)
|
return 0;
|
skwlog_log("%s [Enter]\n",__func__);
|
//DATA MEM
|
ret = skw_modem_save_mem(skw_data_mem,DATA_MEM_SIZE, DATA_MEM_BASE_ADDR);
|
if(ret !=0)
|
{
|
skwlog_log("%s dump fail ret: %d\n", skw_data_mem, ret);
|
return -1;
|
}
|
//CODE MEM
|
ret = skw_modem_save_mem(skw_code_mem,CODE_MEM_SIZE, CODE_MEM_BASE_ADDR);
|
if(ret !=0)
|
{
|
skwlog_log("%s dump fail ret: %d\n", skw_code_mem,ret);
|
return -1;
|
}
|
//CSCB MEM
|
ret = skw_modem_save_mem(skw_cscb_mem,CSCB_MEM_SIZE, CSCB_MEM_BASE_ADDR);
|
if(ret !=0)
|
{
|
skwlog_log("%s dump fail ret: %d\n", skw_cscb_mem,ret);
|
return -1;
|
}
|
|
//UMEM MEM
|
ret = skw_modem_save_mem(skw_umem_mem,UMEM_MEM_SIZE, UMEM_MEM_BASE_ADDR);
|
if(ret !=0)
|
{
|
skwlog_log("%s dump fail ret: %d\n", skw_umem_mem,ret);
|
return -1;
|
}
|
//SDIO MEM
|
ret = skw_modem_save_mem(skw_modem_mem,SDIO_MEM_SIZE, SDIO_MEM_BASE_ADDR);
|
if(ret !=0)
|
{
|
skwlog_log("%s dump fail ret: %d\n",skw_modem_mem,ret);
|
return -1;
|
}
|
//BTDM MEM
|
ret = skw_modem_save_mem(skw_btdm_mem,BTDM_MEM_SIZE, BTDM_MEM_BASE_ADDR);
|
if(ret !=0)
|
{
|
skwlog_log("%s dump fail ret: %d\n", skw_btdm_mem,ret);
|
return -1;
|
}
|
//BTBT MEM
|
ret = skw_modem_save_mem(skw_btbt_mem,BTBT_MEM_SIZE, BTBT_MEM_BASE_ADDR);
|
if(ret !=0)
|
{
|
skwlog_log("%s dump fail ret: %d\n", skw_btbt_mem,ret);
|
return -1;
|
}
|
//BTLE MEM
|
ret = skw_modem_save_mem(skw_btle_mem,BTLE_MEM_SIZE, BTLE_MEM_BASE_ADDR);
|
if(ret !=0)
|
{
|
skwlog_log("%s dump fail ret: %d\n", skw_btle_mem,ret);
|
return -1;
|
}
|
//BTEM MEM
|
ret = skw_modem_save_mem(skw_btem_mem,BTEM_MEM_SIZE, BTEM_MEM_BASE_ADDR);
|
if(ret !=0){
|
skwlog_log("%s dump fail ret: %d\n",skw_btem_mem,ret);
|
return -1;
|
}
|
//WREG MEM
|
ret = skw_modem_save_mem(skw_wreg_mem,WREG_MEM_SIZE, WREG_MEM_BASE_ADDR);
|
if(ret !=0)
|
{
|
skwlog_log("%s dump fail ret: %d\n", skw_wreg_mem,ret);
|
return -1;
|
}
|
//PHYR MEM
|
ret = skw_modem_save_mem(skw_phyr_mem,PHYR_MEM_SIZE, PHYR_MEM_BASE_ADDR);
|
if(ret !=0)
|
{
|
skwlog_log("%s dump fail ret: %d\n", skw_phyr_mem,ret);
|
return -1;
|
}
|
//SMEM MEM
|
ret = skw_modem_save_mem(skw_smem_mem,SMEM_MEM_SIZE, SMEM_MEM_BASE_ADDR);
|
if(ret !=0)
|
{
|
skwlog_log("%s dump fail ret: %d\n", skw_smem_mem,ret);
|
return -1;
|
}
|
return ret;
|
}
|
|
int skw_modem_log_init(struct sv6160_platform_data *p_data, struct file *fp, void *ucom)
|
{
|
|
int ret = 0;
|
#ifdef CONFIG_NO_GKI
|
if (skw_log_dev)
|
return ret;
|
if(skw_log_size > (200*1024*1024))
|
skw_log_size = (200*1024*1024);
|
if(skw_log_size < (512*1024))
|
skw_log_size = (512*1024);
|
if((skw_log_size*skw_log_num) > (1024*1024*1024))
|
skw_log_num = (1024*1024*1024)/skw_log_size;
|
if(skw_log_num > 99)
|
skw_log_num = 99;
|
|
skwlog_log("%s enter skw_log_num:%d skw_log_size:%d \n",__func__, skw_log_num, skw_log_size);
|
log_fp = fp;
|
log_com = ucom;
|
port_data = p_data;
|
|
skw_log_dev = (struct skw_log_data *)kzalloc(sizeof(*skw_log_dev), GFP_KERNEL);
|
if (!skw_log_dev){
|
ret = -ENOMEM;
|
skwlog_err("%s line:%d,can't malloc \n", __func__, __LINE__);
|
goto err1;
|
}
|
|
spin_lock_init(&skw_log_dev->lock);
|
atomic_set(&skw_log_dev->open_excl, 0);
|
atomic_set(&skw_log_dev->ioctl_excl, 0);
|
//INIT_LIST_HEAD(&skw_log_dev->tx_idle);
|
|
|
skw_log_dev->wq = create_singlethread_workqueue("skw_log");
|
if (!skw_log_dev->wq) {
|
ret = -ENOMEM;
|
goto err2;
|
}
|
INIT_WORK(&skw_log_dev->log_to_file_work, skw_modem_log_to_file_work);
|
|
if (log_com->pdata->modem_register_notify) {
|
if(log_com->notifier.notifier_call == NULL){
|
log_com->notifier.notifier_call = modem_event_notifier;
|
log_com->pdata->modem_register_notify(&log_com->notifier);
|
}
|
}
|
|
skw_modem_log_start_rec();
|
return 1;
|
|
err2:
|
if (skw_log_dev->wq) {
|
destroy_workqueue(skw_log_dev->wq);
|
skw_log_dev->wq = NULL;
|
}
|
kfree(skw_log_dev);
|
skwlog_err("mtp gadget driver failed to initialize\n");
|
|
err1:
|
#else
|
skwlog_warn("GKI Not support log2file!\n");
|
#endif
|
return ret;
|
}
|
|
void skw_modem_log_set_assert_status(uint32_t cp_assert)
|
{
|
cp_assert_status = cp_assert;
|
if(cp_assert_status){
|
skwlog_log("%s CP in ASSERT, dump log in %s \n",__func__, log_file);
|
}
|
}
|
|
void skw_modem_log_start_rec(void)
|
{
|
#ifdef CONFIG_NO_GKI
|
skwlog_log("%s enter \n",__func__);
|
if(atomic_read(&log_com->open) > 1){
|
skwlog_warn("%s:log port is busy\n",__func__);
|
return;
|
}
|
if(!skw_log_dev){
|
skwlog_warn("%s no mem ready, can't start \n",__func__);
|
return;
|
}
|
if(record_flag){
|
skwlog_warn("%s lof2file already \n",__func__);
|
return;
|
}
|
cp_assert_status = 0;
|
queue_work(skw_log_dev->wq, &skw_log_dev->log_to_file_work);
|
#else
|
skwlog_warn("GKI Not support log2file!\n");
|
#endif
|
|
}
|
|
/***************************************************************************
|
*Description:dump modem memory
|
*Seekwave tech LTD
|
*Author:JunWei Jiang
|
*Date:2022-11-14
|
*Modify:
|
**************************************************************************/
|
void skw_modem_dumpmodem_start_rec(void)
|
{
|
#ifdef CONFIG_NO_GKI
|
skw_modem_save_dumpmem();
|
#else
|
skwlog_warn("GKI Not support dump!\n");
|
#endif
|
|
}
|
|
/***************************************************************************
|
*Description:dump modem memory
|
*Seekwave tech LTD
|
*Author:JunWei Jiang
|
*Date:2022-11-14
|
*Modify:
|
**************************************************************************/
|
|
void skw_modem_log_stop_rec(void)
|
{
|
skwlog_log("%s enter \n",__func__);
|
if(record_flag)
|
record_flag = 0;
|
if(log_com && log_com->pdata && log_com->pdata->close_port)
|
log_com->pdata->close_port(log_com->portno);
|
return;
|
}
|
|
void skw_modem_log_exit(void)
|
{
|
#ifdef CONFIG_NO_GKI
|
skwlog_log("%s enter\n",__func__);
|
if(!log_com) return;
|
log_com->pdata->modem_unregister_notify(&log_com->notifier);
|
skw_modem_log_stop_rec();
|
cancel_work_sync(&skw_log_dev->log_to_file_work);
|
destroy_workqueue(skw_log_dev->wq);
|
kfree(skw_log_dev);
|
skw_log_dev = NULL;
|
log_com = NULL;
|
#endif
|
}
|
|
//DECLARE_USB_FUNCTION_INIT(mtp, mtp_alloc_inst, mtp_alloc);
|
MODULE_LICENSE("GPL");
|
