/*
|
* Copyright (C) 2015 Spreadtrum Communications Inc.
|
* This software is licensed under the terms of 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 useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*/
|
#include "bufring.h"
|
#include "wcn_glb.h"
|
#include "wcn_log.h"
|
#include "wcn_misc.h"
|
|
/* units is ms, 2500ms */
|
#define WCN_DUMP_TIMEOUT 2500
|
|
static struct mdbg_ring_t *mdev_ring;
|
gnss_dump_callback gnss_dump_handle;
|
|
static int mdbg_snap_shoot_iram_data(void *buf, u32 addr, u32 len)
|
{
|
struct regmap *regmap;
|
u32 i;
|
u8 *ptr = NULL;
|
|
WCN_INFO("start snap_shoot iram data!addr:%x,len:%d", addr, len);
|
if (marlin_get_module_status() == 0) {
|
WCN_ERR("module status off:can not get iram data!\n");
|
return -1;
|
}
|
|
if (wcn_platform_chip_type() == WCN_PLATFORM_TYPE_SHARKL3)
|
regmap = wcn_get_btwf_regmap(REGMAP_WCN_REG);
|
else
|
regmap = wcn_get_btwf_regmap(REGMAP_ANLG_WRAP_WCN);
|
wcn_regmap_raw_write_bit(regmap, 0XFF4, addr);
|
for (i = 0; i < len / 4; i++) {
|
ptr = buf + i * 4;
|
wcn_regmap_read(regmap, 0XFFC, (u32 *)ptr);
|
}
|
WCN_INFO("snap_shoot iram data success\n");
|
|
return 0;
|
}
|
|
int mdbg_snap_shoot_iram(void *buf)
|
{
|
u32 ret;
|
|
ret = mdbg_snap_shoot_iram_data(buf,
|
0x18000000, 1024 * 32);
|
|
return ret;
|
}
|
|
struct wcn_dump_mem_reg {
|
/* some CP regs can't dump */
|
bool do_dump;
|
u32 addr;
|
/* 4 btyes align */
|
u32 len;
|
};
|
|
/* magic number, not change it */
|
#define WCN_DUMP_VERSION_NAME "WCN_DUMP_HEAD__"
|
/* SUB_NAME len not more than 15 bytes */
|
#define WCN_DUMP_VERSION_SUB_NAME "SIPC_23xx"
|
/* CP2 iram start and end */
|
#define WCN_DUMP_CP2_IRAM_START 1
|
#define WCN_DUMP_CP2_IRAM_END 2
|
/* AP regs start and end */
|
#define WCN_DUMP_AP_REGS_START (WCN_DUMP_CP2_IRAM_END + 1)
|
#define WCN_DUMP_AP_REGS_END 9
|
/* CP2 regs start and end */
|
#define WCN_DUMP_CP2_REGS_START (WCN_DUMP_AP_REGS_END + 1)
|
#define WCN_DUMP_CP2_REGS_END (ARRAY_SIZE(s_wcn_dump_regs) - 1)
|
|
#define WCN_DUMP_ALIGN(x) (((x) + 3) & ~3)
|
/* used for HEAD, so all dump mem in this array.
|
* if new member added, please modify the macor XXX_START XXX_end above.
|
*/
|
static struct wcn_dump_mem_reg s_wcn_dump_regs[] = {
|
/* share mem */
|
{1, 0, 0x300000},
|
/* iram mem */
|
{1, 0x10000000, 0x8000}, /* wcn iram */
|
{1, 0x18004000, 0x4000}, /* gnss iram */
|
/* ap regs */
|
{1, 0x402B00CC, 4}, /* PMU_SLEEP_CTRL */
|
{1, 0x402B00D4, 4}, /* PMU_SLEEP_STATUS */
|
{1, 0x402B0100, 4}, /* PMU_PD_WCN_SYS_CFG */
|
{1, 0x402B0104, 4}, /* PMU_PD_WIFI_WRAP_CFG */
|
{1, 0x402B0244, 4}, /* PMU_WCN_SYS_DSLP_ENA */
|
{1, 0x402B0248, 4}, /* PMU_WIFI_WRAP_DSLP_ENA */
|
{1, 0x402E057C, 4}, /* AON_APB_WCN_SYS_CFG2 */
|
/* cp regs */
|
{0, 0x40060000, 0x300}, /* BTWF_CTRL */
|
{0, 0x60300000, 0x400}, /* BTWF_AHB_CTRL */
|
{0, 0x40010000, 0x38}, /* BTWF_INTC */
|
{0, 0x40020000, 0x10}, /* BTWF_SYSTEM_TIMER */
|
{0, 0x40030000, 0x20}, /* BTWF_TIMER0 */
|
{0, 0x40030020, 0x20}, /* BTWF_TIMER1 */
|
{0, 0x40030040, 0x20}, /* BTWF_TIMER2 */
|
{0, 0x40040000, 0x24}, /* BTWF_WATCHDOG */
|
{0, 0xd0010000, 0xb4}, /* COM_AHB_CTRL */
|
{0, 0xd0020800, 0xc}, /* MANU_CLK_CTRL */
|
{0, 0x70000000, 0x10000}, /* WIFI */
|
{0, 0x400b0000, 0x850}, /* FM */
|
{0, 0x60700000, 0x400}, /* BT_CMD */
|
{0, 0x60740000, 0xa400} /* BT */
|
};
|
|
struct wcn_dump_section_info {
|
/* cp load start addr */
|
__le32 start;
|
/* cp load end addr */
|
__le32 end;
|
/* load from file offset */
|
__le32 off;
|
__le32 reserv;
|
} __packed;
|
|
struct wcn_dump_head_info {
|
/* WCN_DUMP_VERSION_NAME */
|
u8 version[16];
|
/* WCN_DUMP_VERSION_SUB_NAME */
|
u8 sub_version[16];
|
/* numbers of wcn_dump_section_info */
|
__le32 n_sec;
|
/* used to check if dump is full */
|
__le32 file_size;
|
u8 reserv[8];
|
struct wcn_dump_section_info section[0];
|
} __packed;
|
|
static int wcn_fill_dump_head_info(struct wcn_dump_mem_reg *mem_cfg, int cnt)
|
{
|
int i, len, head_len;
|
struct wcn_dump_mem_reg *mem;
|
struct wcn_dump_head_info *head;
|
struct wcn_dump_section_info *sec;
|
|
head_len = sizeof(*head) + sizeof(*sec) * cnt;
|
head = kzalloc(head_len, GFP_KERNEL);
|
if (unlikely(!head)) {
|
WCN_ERR("system has no mem for dump mem\n");
|
return -1;
|
}
|
|
strncpy(head->version, WCN_DUMP_VERSION_NAME,
|
strlen(WCN_DUMP_VERSION_NAME)+1);
|
strncpy(head->sub_version, WCN_DUMP_VERSION_SUB_NAME,
|
strlen(WCN_DUMP_VERSION_SUB_NAME)+1);
|
head->n_sec = cpu_to_le32(cnt);
|
len = head_len;
|
for (i = 0; i < cnt; i++) {
|
sec = head->section + i;
|
mem = mem_cfg + i;
|
sec->off = cpu_to_le32(WCN_DUMP_ALIGN(len));
|
sec->start = cpu_to_le32(mem->addr);
|
sec->end = cpu_to_le32(sec->start + mem->len - 1);
|
len += mem->len;
|
WCN_INFO("section[%d] [0x%x 0x%x 0x%x]\n",
|
i, le32_to_cpu(sec->start),
|
le32_to_cpu(sec->end), le32_to_cpu(sec->off));
|
}
|
head->file_size = cpu_to_le32(len + strlen(WCN_DUMP_END_STRING));
|
|
mdbg_ring_write(mdev_ring, head, head_len);
|
wake_up_log_wait();
|
kfree(head);
|
|
return 0;
|
}
|
|
static void mdbg_dump_str(char *str, int str_len)
|
{
|
if (!str)
|
return;
|
|
mdbg_ring_write_timeout(mdev_ring, str, str_len, WCN_DUMP_TIMEOUT);
|
wake_up_log_wait();
|
WCN_INFO("dump str finish!");
|
}
|
|
static int mdbg_dump_ap_register_data(phys_addr_t addr, u32 len)
|
{
|
u32 value = 0;
|
u8 *ptr = NULL;
|
|
ptr = (u8 *)&value;
|
wcn_read_data_from_phy_addr(addr, &value, len);
|
mdbg_ring_write_timeout(mdev_ring, ptr, len, WCN_DUMP_TIMEOUT);
|
wake_up_log_wait();
|
|
return 0;
|
}
|
|
static int mdbg_dump_cp_register_data(u32 addr, u32 len)
|
{
|
struct regmap *regmap;
|
u32 i;
|
u32 count, trans_size;
|
u8 *buf = NULL;
|
u8 *ptr = NULL;
|
|
WCN_INFO("start dump cp register!addr:%x,len:%d", addr, len);
|
if (unlikely(!mdbg_dev->ring_dev)) {
|
WCN_ERR("ring_dev is NULL\n");
|
return -1;
|
}
|
|
buf = kzalloc(len, GFP_KERNEL);
|
if (!buf)
|
return -ENOMEM;
|
|
if (wcn_platform_chip_type() == WCN_PLATFORM_TYPE_SHARKL3)
|
regmap = wcn_get_btwf_regmap(REGMAP_WCN_REG);
|
else
|
regmap = wcn_get_btwf_regmap(REGMAP_ANLG_WRAP_WCN);
|
|
wcn_regmap_raw_write_bit(regmap, 0XFF4, addr);
|
for (i = 0; i < len / 4; i++) {
|
ptr = buf + i * 4;
|
wcn_regmap_read(regmap, 0XFFC, (u32 *)ptr);
|
}
|
count = 0;
|
while (count < len) {
|
trans_size = (len - count) > DUMP_PACKET_SIZE ?
|
DUMP_PACKET_SIZE : (len - count);
|
mdbg_ring_write_timeout(mdev_ring, buf + count,
|
trans_size, WCN_DUMP_TIMEOUT);
|
count += trans_size;
|
wake_up_log_wait();
|
}
|
|
kfree(buf);
|
WCN_INFO("dump cp register finish count %u\n", count);
|
|
return count;
|
}
|
|
static void mdbg_dump_ap_register(struct wcn_dump_mem_reg *mem)
|
{
|
int i;
|
|
for (i = WCN_DUMP_AP_REGS_START; i <= WCN_DUMP_AP_REGS_END; i++) {
|
mdbg_dump_ap_register_data(mem[i].addr, mem[i].len);
|
WCN_INFO("dump ap reg section[%d] ok!\n", i);
|
}
|
}
|
|
static void mdbg_dump_cp_register(struct wcn_dump_mem_reg *mem)
|
{
|
int i, count;
|
|
for (i = WCN_DUMP_CP2_REGS_START; i <= WCN_DUMP_CP2_REGS_END; i++) {
|
count = mdbg_dump_cp_register_data(mem[i].addr, mem[i].len);
|
WCN_INFO("dump cp reg section[%d] %d ok!\n", i, count);
|
}
|
}
|
|
static void mdbg_dump_iram(struct wcn_dump_mem_reg *mem)
|
{
|
int i, count;
|
|
for (i = WCN_DUMP_CP2_IRAM_START; i <= WCN_DUMP_CP2_IRAM_END; i++) {
|
count = mdbg_dump_cp_register_data(mem[i].addr, mem[i].len);
|
WCN_INFO("dump iram section[%d] %d ok!\n", i, count);
|
}
|
}
|
|
static int mdbg_dump_share_memory(struct wcn_dump_mem_reg *mem)
|
{
|
u32 count, len, trans_size;
|
void *virt_addr;
|
phys_addr_t base_addr;
|
unsigned int cnt;
|
unsigned long timeout;
|
|
if (unlikely(!mdbg_dev->ring_dev)) {
|
WCN_ERR("ring_dev is NULL\n");
|
return -1;
|
}
|
len = mem[0].len;
|
base_addr = wcn_get_btwf_base_addr();
|
WCN_INFO("dump sharememory start!");
|
WCN_INFO("ring->pbuff=%p, ring->end=%p.\n",
|
mdev_ring->pbuff, mdev_ring->end);
|
virt_addr = wcn_mem_ram_vmap_nocache(base_addr, len, &cnt);
|
if (!virt_addr) {
|
WCN_ERR("wcn_mem_ram_vmap_nocache fail\n");
|
return -1;
|
}
|
count = 0;
|
/* 10s timeout */
|
timeout = jiffies + msecs_to_jiffies(10000);
|
while (count < len) {
|
trans_size = (len - count) > DUMP_PACKET_SIZE ?
|
DUMP_PACKET_SIZE : (len - count);
|
/* copy data from ddr to ring buf */
|
|
mdbg_ring_write_timeout(mdev_ring, virt_addr + count,
|
trans_size, WCN_DUMP_TIMEOUT);
|
count += trans_size;
|
wake_up_log_wait();
|
if (time_after(jiffies, timeout)) {
|
WCN_ERR("Dump share mem timeout:count:%u\n", count);
|
break;
|
}
|
}
|
wcn_mem_ram_unmap(virt_addr, cnt);
|
WCN_INFO("share memory dump finish! total count %u\n", count);
|
|
return 0;
|
}
|
|
void mdbg_dump_gnss_register(gnss_dump_callback callback_func, void *para)
|
{
|
gnss_dump_handle = (gnss_dump_callback)callback_func;
|
WCN_INFO("gnss_dump register success!\n");
|
}
|
|
void mdbg_dump_gnss_unregister(void)
|
{
|
gnss_dump_handle = NULL;
|
}
|
|
static int btwf_dump_mem(void)
|
{
|
u32 cp2_status = 0;
|
phys_addr_t sleep_addr;
|
|
if (wcn_get_btwf_power_status() == WCN_POWER_STATUS_OFF) {
|
WCN_INFO("wcn power status off:can not dump btwf!\n");
|
return -1;
|
}
|
|
mdbg_send_atcmd("at+sleep_switch=0\r",
|
strlen("at+sleep_switch=0\r"),
|
WCN_ATCMD_KERNEL);
|
msleep(500);
|
sleep_addr = wcn_get_btwf_sleep_addr();
|
wcn_read_data_from_phy_addr(sleep_addr, &cp2_status, sizeof(u32));
|
mdev_ring = mdbg_dev->ring_dev->ring;
|
mdbg_hold_cpu();
|
msleep(100);
|
mdbg_ring_reset(mdev_ring);
|
mdbg_atcmd_clean();
|
if (wcn_fill_dump_head_info(s_wcn_dump_regs,
|
ARRAY_SIZE(s_wcn_dump_regs)))
|
return -1;
|
mdbg_dump_share_memory(s_wcn_dump_regs);
|
mdbg_dump_iram(s_wcn_dump_regs);
|
mdbg_dump_ap_register(s_wcn_dump_regs);
|
if (cp2_status == WCN_CP2_STATUS_DUMP_REG) {
|
mdbg_dump_cp_register(s_wcn_dump_regs);
|
WCN_INFO("dump register ok!\n");
|
}
|
|
mdbg_dump_str(WCN_DUMP_END_STRING, strlen(WCN_DUMP_END_STRING));
|
|
return 0;
|
}
|
|
void mdbg_dump_mem(void)
|
{
|
/* dump gnss */
|
if (gnss_dump_handle) {
|
WCN_INFO("need dump gnss\n");
|
gnss_dump_handle();
|
}
|
|
/* dump btwf */
|
btwf_dump_mem();
|
}
|
|
int dump_arm_reg(void)
|
{
|
mdbg_hold_cpu();
|
|
return 0;
|
}
|
