// SPDX-License-Identifier: GPL-2.0
|
|
/******************************************************************************
|
*
|
* Copyright (C) 2020 SeekWave Technology Co.,Ltd.
|
*
|
* This program is free software; you can redistribute it and/or modify
|
* it under the terms of version 2 of the GNU General Public License as
|
* published by the Free Software Foundation;
|
*
|
* 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 <linux/version.h>
|
#include <linux/uaccess.h>
|
#include <linux/ctype.h>
|
#include <linux/if_arp.h>
|
|
#include "skw_compat.h"
|
#include "skw_log.h"
|
#include "skw_dentry.h"
|
#include "skw_cfg80211.h"
|
#include "skw_iface.h"
|
#include "skw_rx.h"
|
|
#define SKW_LL_MASK 0xffff
|
|
#if defined(CONFIG_SWT6621S_LOG_ERROR)
|
#define SKW_LOG_LEVEL SKW_ERROR
|
#elif defined(CONFIG_SWT6621S_LOG_WARN)
|
#define SKW_LOG_LEVEL SKW_WARN
|
#elif defined(CONFIG_SWT6621S_LOG_INFO)
|
#define SKW_LOG_LEVEL SKW_INFO
|
#elif defined(CONFIG_SWT6621S_LOG_DEBUG)
|
#define SKW_LOG_LEVEL SKW_DEBUG
|
#elif defined(CONFIG_SWT6621S_LOG_DETAIL)
|
#define SKW_LOG_LEVEL SKW_DETAIL
|
#else
|
#define SKW_LOG_LEVEL SKW_INFO
|
#endif
|
|
static unsigned long skw_dbg_level;
|
|
unsigned long skw_log_level(void)
|
{
|
return skw_dbg_level;
|
}
|
|
static void skw_set_log_level(int level)
|
{
|
unsigned long dbg_level;
|
|
dbg_level = skw_log_level() & (~SKW_LL_MASK);
|
dbg_level |= ((level << 1) - 1);
|
|
xchg(&skw_dbg_level, dbg_level);
|
}
|
|
static void skw_enable_func_log(int func, bool enable)
|
{
|
unsigned long dbg_level = skw_log_level();
|
|
if (enable)
|
dbg_level |= func;
|
else
|
dbg_level &= (~func);
|
|
xchg(&skw_dbg_level, dbg_level);
|
}
|
|
|
static struct skw_monitor_dbg_iface *g_skw_dbg_iface;
|
static DEFINE_MUTEX(skw_dbg_mutex);
|
|
void skw_dump_frame(u8 *frame, u16 frame_len)
|
{
|
struct skw_radiotap_desc *radio_desc;
|
struct sk_buff *skb;
|
|
mutex_lock(&skw_dbg_mutex);
|
if (g_skw_dbg_iface == NULL) {
|
mutex_unlock(&skw_dbg_mutex);
|
return;
|
}
|
|
skb = alloc_skb(frame_len + sizeof(struct skw_radiotap_desc), GFP_KERNEL);
|
if (skb == NULL) {
|
mutex_unlock(&skw_dbg_mutex);
|
return;
|
}
|
|
radio_desc = (struct skw_radiotap_desc *)skb_put(skb,
|
sizeof(struct skw_radiotap_desc));
|
radio_desc->radiotap_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
|
radio_desc->radiotap_hdr.it_pad = 0;
|
radio_desc->radiotap_hdr.it_len = sizeof(struct skw_radiotap_desc);
|
radio_desc->radiotap_hdr.it_present = BIT(IEEE80211_RADIOTAP_FLAGS);
|
radio_desc->radiotap_flag = 0;
|
|
skw_put_skb_data(skb, frame, frame_len);
|
|
__skb_trim(skb, frame_len + radio_desc->radiotap_hdr.it_len);
|
skb_reset_mac_header(skb);
|
|
skb->dev = g_skw_dbg_iface->ndev;
|
skb->ip_summed = CHECKSUM_NONE;
|
skb->pkt_type = PACKET_OTHERHOST;
|
skb->protocol = htons(ETH_P_80211_RAW);
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 18, 0)
|
netif_rx_ni(skb);
|
#else
|
netif_rx(skb);
|
#endif
|
|
mutex_unlock(&skw_dbg_mutex);
|
}
|
|
static netdev_tx_t skw_monitor_xmit(struct sk_buff *skb, struct net_device *ndev)
|
{
|
dev_kfree_skb_any(skb);
|
return NETDEV_TX_OK;
|
}
|
|
static const struct net_device_ops skw_monitor_netdev_ops = {
|
.ndo_start_xmit = skw_monitor_xmit,
|
};
|
|
static void skw_add_dbg_iface(void)
|
{
|
int priv_size, ret;
|
struct net_device *ndev = NULL;
|
struct skw_monitor_dbg_iface *iface;
|
u8 mac[6] = {0xFe, 0xfd, 0xfc, 0x12, 0x11, 0x88};
|
|
if (g_skw_dbg_iface) {
|
skw_err("already add dbg iface\n");
|
return;
|
}
|
|
priv_size = sizeof(struct skw_monitor_dbg_iface);
|
ndev = alloc_netdev_mqs(priv_size, "skw_dbg",
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 16, 0)
|
NET_NAME_ENUM,
|
#endif
|
ether_setup, SKW_WMM_AC_MAX, 1);
|
if (!ndev) {
|
skw_err("alloc ndev fail\n");
|
return;
|
}
|
|
iface = netdev_priv(ndev);
|
iface->ndev = ndev;
|
|
skw_ether_copy(iface->addr, mac);
|
ndev->type = ARPHRD_IEEE80211_RADIOTAP;
|
|
ndev->netdev_ops = &skw_monitor_netdev_ops;
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 0, 0)
|
eth_hw_addr_set(ndev, mac);
|
#else
|
skw_ether_copy(ndev->dev_addr, mac);
|
#endif
|
rtnl_lock();
|
ret = skw_register_netdevice(ndev);
|
rtnl_unlock();
|
if (ret) {
|
skw_err("register netdev failed\n");
|
goto free_iface;
|
}
|
|
mutex_lock(&skw_dbg_mutex);
|
g_skw_dbg_iface = iface;
|
mutex_unlock(&skw_dbg_mutex);
|
|
return;
|
|
free_iface:
|
if (ndev)
|
free_netdev(ndev);
|
}
|
|
void skw_del_dbg_iface(void)
|
{
|
struct skw_monitor_dbg_iface *iface;
|
|
if (!g_skw_dbg_iface)
|
return;
|
|
mutex_lock(&skw_dbg_mutex);
|
|
iface = g_skw_dbg_iface;
|
g_skw_dbg_iface = NULL;
|
|
mutex_unlock(&skw_dbg_mutex);
|
|
rtnl_lock();
|
skw_unregister_netdevice(iface->ndev);
|
rtnl_unlock();
|
}
|
|
static void skw_set_dump_frame(bool enable)
|
{
|
if (enable)
|
skw_add_dbg_iface();
|
else
|
skw_del_dbg_iface();
|
}
|
|
static char *skw_dump_frame_status(void)
|
{
|
if (g_skw_dbg_iface)
|
return "enable";
|
else
|
return "disable";
|
}
|
|
static int skw_log_show(struct seq_file *seq, void *data)
|
{
|
int i;
|
u32 level = skw_log_level();
|
const char *log_level;
|
static const char *log_name[] = {"NONE", "ERROR", "WARN", "INFO", "DEBUG", "DETAIL"};
|
|
i = ffs((level & SKW_LL_MASK) + 1) - 1;
|
if (i >= 0 && i < ARRAY_SIZE(log_name))
|
log_level = log_name[i];
|
else
|
log_level = "INVALID";
|
|
seq_puts(seq, "\n");
|
seq_printf(seq, "Log Level: %s [ERROR|WARN|INFO|DEBUG|DETAIL]\n", log_name[i]);
|
|
#define SKW_LOG_STATUS(s) (level & (s) ? "enable" : "disable")
|
seq_puts(seq, "\n");
|
seq_printf(seq, "command log: %s\n", SKW_LOG_STATUS(SKW_CMD));
|
seq_printf(seq, "event log: %s\n", SKW_LOG_STATUS(SKW_EVENT));
|
seq_printf(seq, "dump log: %s\n", SKW_LOG_STATUS(SKW_DUMP));
|
seq_printf(seq, "scan log: %s\n", SKW_LOG_STATUS(SKW_SCAN));
|
seq_printf(seq, "timer log: %s\n", SKW_LOG_STATUS(SKW_TIMER));
|
seq_printf(seq, "state log: %s\n", SKW_LOG_STATUS(SKW_STATE));
|
seq_printf(seq, "work log: %s\n", SKW_LOG_STATUS(SKW_WORK));
|
seq_printf(seq, "dump frame: %s\n", skw_dump_frame_status());
|
seq_printf(seq, "DFS log: %s\n", SKW_LOG_STATUS(SKW_DFS));
|
#undef SKW_LOG_STATUS
|
|
return 0;
|
}
|
|
static int skw_log_open(struct inode *inode, struct file *file)
|
{
|
// return single_open(file, &skw_log_show, inode->i_private);
|
return single_open(file, &skw_log_show, skw_pde_data(inode));
|
}
|
|
static int skw_log_control(const char *cmd, bool enable)
|
{
|
if (!strcmp("command", cmd))
|
skw_enable_func_log(SKW_CMD, enable);
|
else if (!strcmp("event", cmd))
|
skw_enable_func_log(SKW_EVENT, enable);
|
else if (!strcmp("dump", cmd))
|
skw_enable_func_log(SKW_DUMP, enable);
|
else if (!strcmp("scan", cmd))
|
skw_enable_func_log(SKW_SCAN, enable);
|
else if (!strcmp("timer", cmd))
|
skw_enable_func_log(SKW_TIMER, enable);
|
else if (!strcmp("state", cmd))
|
skw_enable_func_log(SKW_STATE, enable);
|
else if (!strcmp("work", cmd))
|
skw_enable_func_log(SKW_WORK, enable);
|
else if (!strcmp("dfs", cmd))
|
skw_enable_func_log(SKW_DFS, enable);
|
else if (!strcmp("detail", cmd))
|
skw_set_log_level(SKW_DETAIL);
|
else if (!strcmp("debug", cmd))
|
skw_set_log_level(SKW_DEBUG);
|
else if (!strcmp("info", cmd))
|
skw_set_log_level(SKW_INFO);
|
else if (!strcmp("warn", cmd))
|
skw_set_log_level(SKW_WARN);
|
else if (!strcmp("error", cmd))
|
skw_set_log_level(SKW_ERROR);
|
else if (!strcmp("dumpframe", cmd))
|
skw_set_dump_frame(enable);
|
else
|
return -EINVAL;
|
|
return 0;
|
}
|
|
static ssize_t skw_log_write(struct file *fp, const char __user *buffer,
|
size_t len, loff_t *offset)
|
{
|
int i, idx;
|
char cmd[32];
|
bool enable = false;
|
|
for (idx = 0, i = 0; i < len; i++) {
|
char c;
|
|
if (get_user(c, buffer))
|
return -EFAULT;
|
|
switch (c) {
|
case ' ':
|
break;
|
|
case ':':
|
cmd[idx] = 0;
|
if (!strcmp("enable", cmd))
|
enable = true;
|
else
|
enable = false;
|
|
idx = 0;
|
break;
|
|
case '|':
|
case '\0':
|
case '\n':
|
cmd[idx] = 0;
|
skw_log_control(cmd, enable);
|
idx = 0;
|
break;
|
|
default:
|
cmd[idx++] = tolower(c);
|
idx %= 32;
|
|
break;
|
}
|
|
buffer++;
|
}
|
|
return len;
|
}
|
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 6, 0)
|
static const struct proc_ops skw_log_fops = {
|
.proc_open = skw_log_open,
|
.proc_read = seq_read,
|
.proc_release = single_release,
|
.proc_write = skw_log_write,
|
};
|
#else
|
static const struct file_operations skw_log_fops = {
|
.owner = THIS_MODULE,
|
.open = skw_log_open,
|
.read = seq_read,
|
.release = single_release,
|
.write = skw_log_write,
|
};
|
#endif
|
|
void skw_log_level_init(void)
|
{
|
skw_set_log_level(SKW_LOG_LEVEL);
|
|
skw_enable_func_log(SKW_CMD, false);
|
skw_enable_func_log(SKW_EVENT, false);
|
skw_enable_func_log(SKW_DUMP, false);
|
skw_enable_func_log(SKW_SCAN, false);
|
skw_enable_func_log(SKW_TIMER, false);
|
skw_enable_func_log(SKW_STATE, true);
|
skw_enable_func_log(SKW_WORK, false);
|
skw_enable_func_log(SKW_DFS, false);
|
|
skw_procfs_file(NULL, "log_level", 0666, &skw_log_fops, NULL);
|
}
|
|
void skw_log_level_deinit(void)
|
{
|
}
|
