/* SPDX-License-Identifier: GPL-2.0 */
|
#include <linux/completion.h>
|
#include <linux/workqueue.h>
|
#include <linux/timer.h>
|
|
#include "wcn_glb.h"
|
#include "wcn_procfs.h"
|
|
#define LOOPCHECK_TIMER_INTERVAL 5
|
#define WCN_LOOPCHECK_INIT 1
|
#define WCN_LOOPCHECK_OPEN 2
|
|
#ifdef CONFIG_WCN_LOOPCHECK
|
struct wcn_loopcheck {
|
unsigned long status;
|
struct completion completion;
|
struct delayed_work work;
|
struct workqueue_struct *workqueue;
|
};
|
|
static struct wcn_loopcheck loopcheck;
|
#endif
|
static struct completion atcmd_completion;
|
static struct mutex atcmd_lock;
|
|
int at_cmd_send(char *buf, unsigned int len)
|
{
|
unsigned char *send_buf = NULL;
|
struct mbuf_t *head, *tail;
|
int num = 1;
|
|
WCN_DEBUG("%s len=%d\n", __func__, len);
|
if (unlikely(marlin_get_module_status() != true)) {
|
WCN_ERR("WCN module have not open\n");
|
return -EIO;
|
}
|
|
send_buf = kzalloc(len + PUB_HEAD_RSV + 1, GFP_KERNEL);
|
if (!send_buf)
|
return -ENOMEM;
|
memcpy(send_buf + PUB_HEAD_RSV, buf, len);
|
|
if (!sprdwcn_bus_list_alloc(mdbg_proc_ops[MDBG_AT_TX_OPS].channel,
|
&head, &tail, &num)) {
|
head->buf = send_buf;
|
head->len = len;
|
head->next = NULL;
|
sprdwcn_bus_push_list(mdbg_proc_ops[MDBG_AT_TX_OPS].channel,
|
head, tail, num);
|
}
|
return 0;
|
}
|
|
#ifdef CONFIG_WCN_LOOPCHECK
|
|
static void loopcheck_work_queue(struct work_struct *work)
|
{
|
int ret;
|
unsigned long timeleft;
|
char a[] = "at+loopcheck\r\n";
|
|
if (!test_bit(WCN_LOOPCHECK_OPEN, &loopcheck.status))
|
return;
|
mutex_lock(&atcmd_lock);
|
at_cmd_send(a, sizeof(a));
|
|
timeleft = wait_for_completion_timeout(&loopcheck.completion,
|
(3 * HZ));
|
mutex_unlock(&atcmd_lock);
|
if (!test_bit(WCN_LOOPCHECK_OPEN, &loopcheck.status))
|
return;
|
if (!timeleft) {
|
stop_loopcheck();
|
WCN_ERR("didn't get loopcheck ack\n");
|
WCN_INFO("start dump CP2 mem\n");
|
mdbg_assert_interface("loopcheck fail");
|
return;
|
}
|
|
ret = queue_delayed_work(loopcheck.workqueue, &loopcheck.work,
|
LOOPCHECK_TIMER_INTERVAL * HZ);
|
}
|
#endif
|
|
void switch_cp2_log(bool flag)
|
{
|
unsigned long timeleft;
|
char a[32];
|
unsigned char ret;
|
|
WCN_INFO("%s - %s entry!\n", __func__, (flag ? "open" : "close"));
|
mutex_lock(&atcmd_lock);
|
sprintf(a, "at+armlog=%d\r\n", (flag ? 1 : 0));
|
ret = at_cmd_send(a, sizeof(a));
|
if (ret) {
|
mutex_unlock(&atcmd_lock);
|
WCN_ERR("%s fail!\n", __func__);
|
return;
|
}
|
timeleft = wait_for_completion_timeout(&atcmd_completion, (3 * HZ));
|
mutex_unlock(&atcmd_lock);
|
if (!timeleft)
|
WCN_ERR("didn't get %s ack\n", __func__);
|
}
|
|
int get_board_ant_num(void)
|
{
|
unsigned long timeleft;
|
char a[] = "at+getantnum\r\n";
|
unsigned char *at_cmd_buf;
|
unsigned char ret;
|
|
WCN_DEBUG("%s entry!\n", __func__);
|
|
/* 1. uwe5621 module on RK board(rk3368):
|
* Antenna num is fixed to one.
|
*/
|
#ifdef CONFIG_RK_BOARD
|
#ifndef CONFIG_CHECK_DRIVER_BY_CHIPID
|
#ifdef CONFIG_UWE5621
|
WCN_INFO("%s [one_ant]\n", __func__);
|
return MARLIN_ONE_ANT;
|
#endif
|
#else /*CONFIG_CHECK_DRIVER_BY_CHIPID*/
|
if (wcn_get_chip_model() == WCN_CHIP_MARLIN3) {
|
WCN_INFO("%s [one_ant]\n", __func__);
|
return MARLIN_ONE_ANT;
|
}
|
#endif
|
#endif /* CONFIG_RK_BOARD */
|
|
/* 2. uwe5622 module:
|
* Antenna num is fixed to one.
|
*/
|
#ifndef CONFIG_CHECK_DRIVER_BY_CHIPID
|
#ifdef CONFIG_UWE5622
|
WCN_INFO("%s [one_ant]\n", __func__);
|
return MARLIN_ONE_ANT;
|
#endif
|
#else /*CONFIG_CHECK_DRIVER_BY_CHIPID*/
|
if (wcn_get_chip_model() == WCN_CHIP_MARLIN3L) {
|
WCN_INFO("%s [one_ant]\n", __func__);
|
return MARLIN_ONE_ANT;
|
}
|
#endif
|
|
/* 3. Other situations:
|
* send at cmd to get antenna num.
|
*/
|
mutex_lock(&atcmd_lock);
|
ret = at_cmd_send(a, sizeof(a));
|
if (ret) {
|
mutex_unlock(&atcmd_lock);
|
WCN_ERR("%s fail!\n", __func__);
|
return ret;
|
}
|
timeleft = wait_for_completion_timeout(&atcmd_completion, (3 * HZ));
|
if (!timeleft) {
|
mutex_unlock(&atcmd_lock);
|
WCN_ERR("didn't get board ant num, default:[three_ant]\n");
|
return MARLIN_THREE_ANT;
|
}
|
at_cmd_buf = mdbg_get_at_cmd_buf();
|
mutex_unlock(&atcmd_lock);
|
if (at_cmd_buf[0] == '2') {
|
WCN_INFO("%s [two_ant]\n", __func__);
|
return MARLIN_TWO_ANT;
|
} else if (at_cmd_buf[0] == '3') {
|
WCN_INFO("%s [three_ant]\n", __func__);
|
return MARLIN_THREE_ANT;
|
}
|
WCN_ERR("%s read err:%s, default:[three_ant]\n",
|
__func__, at_cmd_buf);
|
return MARLIN_THREE_ANT;
|
}
|
|
void get_cp2_version(void)
|
{
|
unsigned long timeleft;
|
char a[] = "at+spatgetcp2info\r\n";
|
unsigned char ret;
|
|
WCN_INFO("%s entry!\n", __func__);
|
mutex_lock(&atcmd_lock);
|
ret = at_cmd_send(a, sizeof(a));
|
if (ret) {
|
mutex_unlock(&atcmd_lock);
|
WCN_ERR("%s fail!\n", __func__);
|
return;
|
}
|
timeleft = wait_for_completion_timeout(&atcmd_completion, (3 * HZ));
|
mutex_unlock(&atcmd_lock);
|
if (!timeleft)
|
WCN_ERR("didn't get CP2 version\n");
|
}
|
|
#ifdef CONFIG_WCN_LOOPCHECK
|
void start_loopcheck(void)
|
{
|
if (!test_bit(WCN_LOOPCHECK_INIT, &loopcheck.status) ||
|
test_and_set_bit(WCN_LOOPCHECK_OPEN, &loopcheck.status))
|
return;
|
WCN_INFO("%s\n", __func__);
|
reinit_completion(&loopcheck.completion);
|
queue_delayed_work(loopcheck.workqueue, &loopcheck.work, HZ);
|
}
|
|
void stop_loopcheck(void)
|
{
|
if (!test_bit(WCN_LOOPCHECK_INIT, &loopcheck.status) ||
|
!test_and_clear_bit(WCN_LOOPCHECK_OPEN, &loopcheck.status))
|
return;
|
WCN_INFO("%s\n", __func__);
|
complete_all(&loopcheck.completion);
|
cancel_delayed_work_sync(&loopcheck.work);
|
}
|
|
void complete_kernel_loopcheck(void)
|
{
|
complete(&loopcheck.completion);
|
}
|
#endif
|
|
void complete_kernel_atcmd(void)
|
{
|
complete(&atcmd_completion);
|
}
|
|
int loopcheck_init(void)
|
{
|
#ifdef CONFIG_WCN_LOOPCHECK
|
WCN_DEBUG("loopcheck_init\n");
|
loopcheck.status = 0;
|
init_completion(&loopcheck.completion);
|
loopcheck.workqueue =
|
create_singlethread_workqueue("WCN_LOOPCHECK_QUEUE");
|
if (!loopcheck.workqueue) {
|
WCN_ERR("WCN_LOOPCHECK_QUEUE create failed");
|
return -ENOMEM;
|
}
|
set_bit(WCN_LOOPCHECK_INIT, &loopcheck.status);
|
INIT_DELAYED_WORK(&loopcheck.work, loopcheck_work_queue);
|
#endif
|
init_completion(&atcmd_completion);
|
mutex_init(&atcmd_lock);
|
|
return 0;
|
}
|
|
int loopcheck_deinit(void)
|
{
|
#ifdef CONFIG_WCN_LOOPCHECK
|
stop_loopcheck();
|
destroy_workqueue(loopcheck.workqueue);
|
loopcheck.status = 0;
|
#endif
|
mutex_destroy(&atcmd_lock);
|
|
return 0;
|
}
|
