/*
|
* Copyright (c) 2015 South Silicon Valley Microelectronics Inc.
|
* Copyright (c) 2015 iComm Corporation
|
*
|
* This program is free software: you can redistribute it and/or modify
|
* it under the terms of the GNU General Public License as published by
|
* the Free Software Foundation, either version 3 of the License, or
|
* (at your option) any later version.
|
* 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.
|
* You should have received a copy of the GNU General Public License
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
*/
|
|
#include <linux/module.h>
|
#include <linux/kernel.h>
|
#include <linux/init.h>
|
#include <net/sock.h>
|
#include <linux/socket.h>
|
#include <linux/net.h>
|
#include <asm/types.h>
|
#include <linux/netlink.h>
|
#include <linux/skbuff.h>
|
#include <linux/version.h>
|
#include <ssv6200.h>
|
#include "lib.h"
|
#include "dev.h"
|
#define NETLINK_SMARTLINK (31)
|
#define MAX_PAYLOAD (2048)
|
static struct sock *nl_sk = NULL;
|
struct ssv_softc *ssv_smartlink_sc = NULL;
|
EXPORT_SYMBOL(ssv_smartlink_sc);
|
u32 ssv_smartlink_status=0;
|
static int _ksmartlink_start_smartlink(u8 *pInBuf, u32 inBufLen, u8 *pOutBuf, u32 *pOutBufLen)
|
{
|
#ifdef KSMARTLINK_DEBUG
|
printk(KERN_INFO "%s\n", __FUNCTION__);
|
#endif
|
ssv_smartlink_status = 1;
|
*pOutBufLen = 0;
|
return 0;
|
}
|
int ksmartlink_smartlink_started(void)
|
{
|
return ssv_smartlink_status;
|
}
|
EXPORT_SYMBOL(ksmartlink_smartlink_started);
|
static int _ksmartlink_stop_smartlink(u8 *pInBuf, u32 inBufLen, u8 *pOutBuf, u32 *pOutBufLen)
|
{
|
#ifdef KSMARTLINK_DEBUG
|
printk(KERN_INFO "%s\n", __FUNCTION__);
|
#endif
|
ssv_smartlink_status = 0;
|
*pOutBufLen = 0;
|
return 0;
|
}
|
static int _ksmartlink_set_channel(u8 *pInBuf, u32 inBufLen, u8 *pOutBuf, u32 *pOutBufLen)
|
{
|
int ret=-10;
|
int ch=(int)(*pInBuf);
|
struct ssv_softc *sc=ssv_smartlink_sc;
|
#ifdef KSMARTLINK_DEBUG
|
printk(KERN_INFO "%s %d\n", __FUNCTION__, ch);
|
#endif
|
if (!sc)
|
{
|
goto out;
|
}
|
mutex_lock(&sc->mutex);
|
ret = ssv6xxx_set_channel(sc, ch);
|
mutex_unlock(&sc->mutex);
|
*pOutBufLen = 0;
|
out:
|
return ret;
|
}
|
static int _ksmartlink_get_channel(u8 *pInBuf, u32 inBufLen, u8 *pOutBuf, u32 *pOutBufLen)
|
{
|
int ret=-10;
|
int ch=0;
|
struct ssv_softc *sc=ssv_smartlink_sc;
|
#ifdef KSMARTLINK_DEBUG
|
printk(KERN_INFO "%s\n", __FUNCTION__);
|
#endif
|
if (!sc)
|
{
|
goto out;
|
}
|
mutex_lock(&sc->mutex);
|
ret = ssv6xxx_get_channel(sc, &ch);
|
mutex_unlock(&sc->mutex);
|
*pOutBuf = ch;
|
*pOutBufLen = 1;
|
#ifdef KSMARTLINK_DEBUG
|
printk(KERN_INFO "%s %d\n", __FUNCTION__, ch);
|
#endif
|
out:
|
return ret;
|
}
|
static int _ksmartlink_set_promisc(u8 *pInBuf, u32 inBufLen, u8 *pOutBuf, u32 *pOutBufLen)
|
{
|
int ret=-10;
|
int accept=(int)(*pInBuf);
|
struct ssv_softc *sc=ssv_smartlink_sc;
|
#ifdef KSMARTLINK_DEBUG
|
printk(KERN_INFO "%s %d\n", __FUNCTION__, accept);
|
#endif
|
if (!sc)
|
{
|
goto out;
|
}
|
mutex_lock(&sc->mutex);
|
ret = ssv6xxx_set_promisc(sc, accept);
|
mutex_unlock(&sc->mutex);
|
*pOutBufLen = 0;
|
out:
|
return ret;
|
}
|
static int _ksmartlink_get_promisc(u8 *pInBuf, u32 inBufLen, u8 *pOutBuf, u32 *pOutBufLen)
|
{
|
int ret=-10;
|
int accept=(int)(*pInBuf);
|
struct ssv_softc *sc=ssv_smartlink_sc;
|
#ifdef KSMARTLINK_DEBUG
|
printk(KERN_INFO "%s\n", __FUNCTION__);
|
#endif
|
if (!sc)
|
{
|
goto out;
|
}
|
mutex_lock(&sc->mutex);
|
ret = ssv6xxx_get_promisc(sc, &accept);
|
mutex_unlock(&sc->mutex);
|
*pOutBuf = accept;
|
*pOutBufLen = 1;
|
#ifdef KSMARTLINK_DEBUG
|
printk(KERN_INFO "%s %d\n", __FUNCTION__, accept);
|
#endif
|
out:
|
return ret;
|
}
|
#define SMARTLINK_CMD_FIXED_LEN (10)
|
#define SMARTLINK_CMD_FIXED_TOT_LEN (SMARTLINK_CMD_FIXED_LEN+1)
|
#define SMARTLINK_RES_FIXED_LEN (SMARTLINK_CMD_FIXED_LEN)
|
#define SMARTLINK_RES_FIXED_TOT_LEN (SMARTLINK_RES_FIXED_LEN+2)
|
struct ksmartlink_cmd
|
{
|
char *cmd;
|
int (*process_func)(u8 *, u32, u8 *, u32 *);
|
};
|
static struct ksmartlink_cmd _ksmartlink_cmd_table[] =
|
{
|
{"startairki", _ksmartlink_start_smartlink},
|
{"stopairkis", _ksmartlink_stop_smartlink},
|
{"setchannel", _ksmartlink_set_channel},
|
{"getchannel", _ksmartlink_get_channel},
|
{"setpromisc", _ksmartlink_set_promisc},
|
{"getpromisc", _ksmartlink_get_promisc},
|
};
|
static u32 _ksmartlink_cmd_table_size=sizeof(_ksmartlink_cmd_table)/sizeof(struct ksmartlink_cmd);
|
#ifdef KSMARTLINK_DEBUG
|
static void _ksmartlink_hex_dump(u8 *pInBuf, u32 inBufLen)
|
{
|
u32 i=0;
|
printk(KERN_INFO "\nKernel Hex Dump(len=%d):\n", inBufLen);
|
printk(KERN_INFO ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
|
for (i=0; i<inBufLen; i++)
|
{
|
if ((i) && ((i & 0xf) == 0))
|
{
|
printk("\n");
|
}
|
printk("%02x ", pInBuf[i]);
|
}
|
printk(KERN_INFO "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
|
}
|
#endif
|
static int _ksmartlink_process_msg(u8 *pInBuf, u32 inBufLen, u8 *pOutBuf, u32 *pOutBufLen)
|
{
|
int ret=0;
|
u32 i=0;
|
struct ksmartlink_cmd *pCmd;
|
if (!pInBuf || !pOutBuf || !pOutBufLen)
|
{
|
printk(KERN_ERR "NULL pointer\n");
|
return -1;
|
}
|
for (i=0; i<_ksmartlink_cmd_table_size; i++)
|
{
|
if (!strncmp(_ksmartlink_cmd_table[i].cmd, pInBuf, SMARTLINK_CMD_FIXED_LEN))
|
{
|
break;
|
}
|
}
|
if (i < _ksmartlink_cmd_table_size)
|
{
|
pCmd = &_ksmartlink_cmd_table[i];
|
if (!pCmd->process_func)
|
{
|
printk(KERN_ERR "CMD %s has NULL process_func\n", pCmd->cmd);
|
return -3;
|
}
|
ret = pCmd->process_func(pInBuf+SMARTLINK_CMD_FIXED_LEN, inBufLen, pOutBuf, pOutBufLen);
|
#ifdef CONFIG_SSV_NETLINK_RESPONSE
|
if (ret < 0)
|
{
|
*pOutBufLen = SMARTLINK_RES_FIXED_TOT_LEN;
|
}
|
else
|
{
|
if (*pOutBufLen > 0)
|
{
|
pOutBuf[SMARTLINK_RES_FIXED_LEN] = (u8)ret;
|
pOutBuf[SMARTLINK_RES_FIXED_LEN+1]= *pOutBuf;
|
}
|
else
|
{
|
pOutBuf[SMARTLINK_RES_FIXED_LEN] = (u8)ret;
|
pOutBuf[SMARTLINK_RES_FIXED_LEN+1]= 0;
|
}
|
*pOutBufLen = SMARTLINK_RES_FIXED_TOT_LEN;
|
}
|
memcpy(pOutBuf, pCmd->cmd, SMARTLINK_RES_FIXED_LEN);
|
#else
|
(void)pOutBuf;
|
(void)pOutBufLen;
|
#endif
|
return 0;
|
}
|
else
|
{
|
printk(KERN_INFO "Unknow CMD or Packet?\n");
|
}
|
return 0;
|
}
|
static u8 gkBuf[MAX_PAYLOAD]={0};
|
static int ssv_usr_pid=0;
|
void smartlink_nl_recv_msg(struct sk_buff *skb)
|
{
|
struct nlmsghdr *nlh;
|
#ifdef CONFIG_SSV_NETLINK_RESPONSE
|
struct sk_buff *skb_out;
|
#endif
|
int ret=0;
|
u8 *pInBuf=NULL;
|
u32 inBufLen=0;
|
u32 outBufLen=0;
|
nlh = (struct nlmsghdr *)skb->data;
|
ssv_usr_pid = nlh->nlmsg_pid;
|
pInBuf = (u8 *)nlmsg_data(nlh);
|
inBufLen = nlmsg_len(nlh);
|
#ifdef KSMARTLINK_DEBUG
|
_ksmartlink_hex_dump(pInBuf, inBufLen);
|
#endif
|
outBufLen = 0;
|
memset(gkBuf, 0, MAX_PAYLOAD);
|
ret = _ksmartlink_process_msg(pInBuf, inBufLen, gkBuf, &outBufLen);
|
#ifdef CONFIG_SSV_NETLINK_RESPONSE
|
if (outBufLen == 0)
|
{
|
memcpy(gkBuf, "Nothing", 8);
|
outBufLen = strlen(gkBuf);
|
}
|
skb_out = nlmsg_new(outBufLen, 0);
|
if (!skb_out)
|
{
|
printk(KERN_ERR "Failed to allocate new skb\n");
|
return;
|
}
|
nlh = nlmsg_put(skb_out, 0, 0, NLMSG_DONE, outBufLen, 0);
|
NETLINK_CB(skb_out).dst_group = 0;
|
memcpy(nlmsg_data(nlh), gkBuf, outBufLen);
|
ret = nlmsg_unicast(nl_sk, skb_out, ssv_usr_pid);
|
if (ret < 0)
|
{
|
printk(KERN_ERR "Error while sending bak to user\n");
|
}
|
#endif
|
return;
|
}
|
void smartlink_nl_send_msg(struct sk_buff *skb)
|
{
|
struct nlmsghdr *nlh;
|
struct sk_buff *skb_out;
|
int ret=0;
|
u8 *pOutBuf=skb->data;
|
u32 outBufLen=skb->len;
|
#ifdef KSMARTLINK_DEBUG
|
#endif
|
skb_out = nlmsg_new(outBufLen, 0);
|
if (!skb_out)
|
{
|
printk(KERN_ERR "Allocate new skb failed!\n");
|
return;
|
}
|
nlh = nlmsg_put(skb_out, 0, 0, NLMSG_DONE, outBufLen, 0);
|
NETLINK_CB(skb_out).dst_group = 0;
|
memcpy(nlmsg_data(nlh), pOutBuf, outBufLen);
|
ret = nlmsg_unicast(nl_sk, skb_out, ssv_usr_pid);
|
if (ret < 0)
|
{
|
printk(KERN_ERR "nlmsg_unicast failed!\n");
|
}
|
kfree_skb(skb);
|
return;
|
}
|
EXPORT_SYMBOL(smartlink_nl_send_msg);
|
int ksmartlink_init(void)
|
{
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0)
|
nl_sk = netlink_kernel_create(&init_net,
|
NETLINK_SMARTLINK,
|
0,
|
smartlink_nl_recv_msg,
|
NULL,
|
THIS_MODULE);
|
#else
|
struct netlink_kernel_cfg cfg =
|
{
|
.groups = 0,
|
.input = smartlink_nl_recv_msg,
|
};
|
nl_sk = netlink_kernel_create(&init_net,
|
NETLINK_SMARTLINK,
|
&cfg);
|
#endif
|
printk(KERN_INFO "***************SmartLink Init-S**************\n");
|
if(!nl_sk)
|
{
|
printk(KERN_ERR "Error creating socket.\n");
|
return -10;
|
}
|
printk(KERN_INFO "***************SmartLink Init-E**************\n");
|
return 0;
|
}
|
void ksmartlink_exit(void)
|
{
|
printk(KERN_INFO "%s\n", __FUNCTION__);
|
if (nl_sk)
|
{
|
netlink_kernel_release(nl_sk);
|
nl_sk = NULL;
|
}
|
}
|
#if (defined(CONFIG_SSV_SUPPORT_ANDROID)||defined(CONFIG_SSV_BUILD_AS_ONE_KO))
|
EXPORT_SYMBOL(ksmartlink_init);
|
EXPORT_SYMBOL(ksmartlink_exit);
|
#else
|
module_init(ksmartlink_init);
|
module_exit(ksmartlink_exit);
|
#endif
|
