static int WIFI_open(struct inode *inode, struct file *file)
{
WIFI_INFO_FUNC("%s: major %d minor %d (pid %d)\n", __func__,
imajor(inode),
iminor(inode),
current->pid
);
//TODO
//Disable EINT(external interrupt), and set the GPIO to EINT mode.
#if 1 /* turn on WIFI */
if (MTK_WCN_BOOL_FALSE == mtk_wcn_wmt_func_on(WMTDRV_TYPE_WIFI)) {
WIFI_WARN_FUNC("WMT turn on WIFI fail!\n");
return -ENODEV;
}else{
retflag = 0;
WIFI_INFO_FUNC("WMT register WIFI rst cb!\n");
}
#endif
return 0;
}
/*-----------------------------------------------------------------*/
INT32 wifi_reset_start(VOID)
{
struct net_device *netdev = NULL;
PARAM_CUSTOM_P2P_SET_STRUC_T p2pmode;
down(&wr_mtx);
if (powered == 1) {
netdev = dev_get_by_name(&init_net, ifname);
if (netdev == NULL) {
WIFI_ERR_FUNC("Fail to get %s net device\n", ifname);
}
else {
p2pmode.u4Enable = 0;
p2pmode.u4Mode = 0;
if (pf_set_p2p_mode) {
if (pf_set_p2p_mode(netdev, p2pmode) != 0){
WIFI_ERR_FUNC("Turn off p2p/ap mode fail");
} else {
WIFI_INFO_FUNC("Turn off p2p/ap mode");
}
}
dev_put(netdev);
netdev = NULL;
}
}
else {
/* WIFI is off before whole chip reset, do nothing */
}
return 0;
}
static int WIFI_open(struct inode *inode, struct file *file)
{
WIFI_INFO_FUNC("%s: major %d minor %d (pid %d)\n", __func__,
imajor(inode), iminor(inode), current->pid);
return 0;
}
static int WIFI_init(void)
{
dev_t dev = MKDEV(WIFI_major, 0);
int alloc_ret = 0;
int cdev_err = 0;
#if REMOVE_MK_NODE
struct device * wmtWifi_dev = NULL;
#endif
/*static allocate chrdev*/
alloc_ret = register_chrdev_region(dev, 1, WIFI_DRIVER_NAME);
if (alloc_ret) {
WIFI_ERR_FUNC("fail to register chrdev\n");
return alloc_ret;
}
cdev_init(&WIFI_cdev, &WIFI_fops);
WIFI_cdev.owner = THIS_MODULE;
cdev_err = cdev_add(&WIFI_cdev, dev, WIFI_devs);
if (cdev_err) {
goto error;
}
#if REMOVE_MK_NODE //mknod replace
wmtWifi_class = class_create(THIS_MODULE,"wmtWifi");
if(IS_ERR(wmtWifi_class))
goto error;
wmtWifi_dev = device_create(wmtWifi_class,NULL,dev,NULL,"wmtWifi");
if(IS_ERR(wmtWifi_dev))
goto error;
#endif
sema_init(&wr_mtx, 1);
WIFI_INFO_FUNC("%s driver(major %d) installed.\n", WIFI_DRIVER_NAME, WIFI_major);
retflag_wifi = 0;
wlan_mode = WLAN_MODE_HALT;
pf_set_p2p_mode = NULL;
return 0;
error:
#if REMOVE_MK_NODE
if(!IS_ERR(wmtWifi_dev))
device_destroy(wmtWifi_class,dev);
if(!IS_ERR(wmtWifi_class)){
class_destroy(wmtWifi_class);
wmtWifi_class = NULL;
}
#endif
if (cdev_err == 0) {
cdev_del(&WIFI_cdev);
}
if (alloc_ret == 0) {
unregister_chrdev_region(dev, WIFI_devs);
}
return -1;
}
static int WIFI_init(void)
{
dev_t dev = MKDEV(WIFI_major, 0);
int alloc_ret = 0;
int cdev_err = 0;
/*static allocate chrdev*/
alloc_ret = register_chrdev_region(dev, 1, WIFI_DRIVER_NAME);
if (alloc_ret) {
WIFI_ERR_FUNC("fail to register chrdev\n");
return alloc_ret;
}
cdev_init(&WIFI_cdev, &WIFI_fops);
WIFI_cdev.owner = THIS_MODULE;
cdev_err = cdev_add(&WIFI_cdev, dev, WIFI_devs);
if (cdev_err)
goto error;
WIFI_INFO_FUNC("%s driver(major %d) installed.\n", WIFI_DRIVER_NAME, WIFI_major);
retflag = 0;
return 0;
error:
if (cdev_err == 0)
cdev_del(&WIFI_cdev);
if (alloc_ret == 0)
unregister_chrdev_region(dev, WIFI_devs);
return -1;
}
ssize_t WIFI_write(struct file * filp,
const char __user * buf, size_t count, loff_t * f_pos)
{
int retval = -EIO;
char local[4] = { 0 };
static int opened = 0;
down(&wr_mtx);
if (count > 0) {
if (0 == copy_from_user(local, buf, (count > 4) ? 4 : count)) {
WIFI_INFO_FUNC("WIFI_write %c\n", local[0]);
if (local[0] == '0' && opened == 1) {
/* TODO */
/* Configure the EINT pin to GPIO mode. */
if (MTK_WCN_BOOL_FALSE ==
mtk_wcn_wmt_func_off(WMTDRV_TYPE_WIFI)) {
WIFI_INFO_FUNC
("WMT turn off WIFI fail!\n");
} else {
WIFI_INFO_FUNC
("WMT turn off WIFI OK!\n");
opened = 0;
retval = count;
}
} else if (local[0] == '1') {
/* TODO */
/* Disable EINT(external interrupt), and set the GPIO to EINT mode. */
if (MTK_WCN_BOOL_FALSE ==
mtk_wcn_wmt_func_on(WMTDRV_TYPE_WIFI)) {
WIFI_WARN_FUNC
("WMT turn on WIFI fail!\n");
} else {
opened = 1;
retval = count;
WIFI_INFO_FUNC
("WMT turn on WIFI success!\n");
}
}
}
}
up(&wr_mtx);
return retval;
}
static int WIFI_init(void)
{
dev_t devID = MKDEV(WIFI_major, 0);
int alloc_ret = 0;
int cdev_err = 0;
/*static allocate chrdev*/
alloc_ret = alloc_chrdev_region(&devID, 0, 1, WIFI_DRIVER_NAME);
if (alloc_ret) {
WIFI_ERR_FUNC("fail to allocate chrdev\n");
return alloc_ret;
}
cdev_init(&WIFI_cdev, &WIFI_fops);
WIFI_cdev.owner = THIS_MODULE;
cdev_err = cdev_add(&WIFI_cdev, devID, WIFI_devs);
if (cdev_err) {
goto error;
}
pWIFIClass = class_create(THIS_MODULE, WIFI_DRIVER_NAME);
if(IS_ERR(pWIFIClass))
{
WIFI_ERR_FUNC("class create fail, error code(%ld)\n",PTR_ERR(pWIFIClass));
goto err1;
}
pWIFIDev = device_create(pWIFIClass,NULL,devID,NULL,WIFI_NODE);
if(IS_ERR(pWIFIDev))
{
WIFI_ERR_FUNC("device create fail, error code(%ld)\n",PTR_ERR(pWIFIDev));
goto err2;
}
sema_init(&wr_mtx, 1);
WIFI_INFO_FUNC("%s driver(major %d) installed.\n", WIFI_DRIVER_NAME, WIFI_major);
// retflag = 0;
return 0;
err2:
if(pWIFIClass)
{
class_destroy(pWIFIClass);
pWIFIClass = NULL;
}
err1:
error:
if (cdev_err == 0) {
cdev_del(&WIFI_cdev);
}
if (alloc_ret == 0) {
unregister_chrdev_region(devID, WIFI_devs);
}
return -1;
}
static void WIFI_exit(void)
{
dev_t dev = MKDEV(WIFI_major, 0);
retflag = 0;
cdev_del(&WIFI_cdev);
unregister_chrdev_region(dev, WIFI_devs);
WIFI_INFO_FUNC("%s driver removed.\n", WIFI_DRIVER_NAME);
}
static int WIFI_close(struct inode *inode, struct file *file)
{
WIFI_INFO_FUNC("%s: major %d minor %d (pid %d)\n", __func__,
imajor(inode),
iminor(inode),
current->pid
);
retflag = 0;
//TODO
//Configure the EINT pin to GPIO mode.
if (MTK_WCN_BOOL_FALSE == mtk_wcn_wmt_func_off(WMTDRV_TYPE_WIFI)) {
WIFI_INFO_FUNC("WMT turn off WIFI fail!\n");
return -EIO; //mostly, native programmer will not check this return value.
}
else {
WIFI_INFO_FUNC("WMT turn off WIFI OK!\n");
}
return 0;
}
static void WIFI_exit(void)
{
dev_t dev = MKDEV(WIFI_major, 0);
retflag = 0;
#if WMT_CREATE_NODE_DYNAMIC
device_destroy(wmtwifi_class,dev);
class_destroy(wmtwifi_class);
wmtwifi_class = NULL;
#endif
cdev_del(&WIFI_cdev);
unregister_chrdev_region(dev, WIFI_devs);
WIFI_INFO_FUNC("%s driver removed.\n", WIFI_DRIVER_NAME);
}
static void __exit WIFI_exit(void)
{
dev_t dev = MKDEV(WIFI_major, 0);
retflag_wifi = 0;
#if REMOVE_MK_NODE
device_destroy(wmtWifi_class,dev);
class_destroy(wmtWifi_class);
wmtWifi_class = NULL;
#endif
cdev_del(&WIFI_cdev);
unregister_chrdev_region(dev, WIFI_devs);
WIFI_INFO_FUNC("%s driver removed.\n", WIFI_DRIVER_NAME);
}
static int WIFI_init(void)
{
dev_t dev = MKDEV(WIFI_major, 0);
int alloc_ret = 0;
int cdev_err = 0;
/*static allocate chrdev*/
alloc_ret = register_chrdev_region(dev, 1, WIFI_DRIVER_NAME);
if (alloc_ret) {
WIFI_ERR_FUNC("fail to register chrdev\n");
return alloc_ret;
}
cdev_init(&WIFI_cdev, &WIFI_fops);
WIFI_cdev.owner = THIS_MODULE;
cdev_err = cdev_add(&WIFI_cdev, dev, WIFI_devs);
if (cdev_err) {
goto error;
}
sema_init(&wr_mtx, 1);
WIFI_INFO_FUNC("%s driver(major %d) installed.\n", WIFI_DRIVER_NAME, WIFI_major);
retflag = 0;
cls = class_create(THIS_MODULE, "wmtwifidrv");
if (IS_ERR(cls)) {
WIFI_ERR_FUNC("Unable to create class, err = %d\n", (int)PTR_ERR(cls));
goto error;
}
device_create(cls,NULL,dev,NULL,"wmtWifi");
return 0;
error:
if (cdev_err == 0) {
cdev_del(&WIFI_cdev);
}
if (alloc_ret == 0) {
unregister_chrdev_region(dev, WIFI_devs);
}
return -1;
}
static int WIFI_init(void)
{
dev_t dev = MKDEV(WIFI_major, 0);
int alloc_ret = 0;
int cdev_err = 0;
/*static allocate chrdev */
alloc_ret = register_chrdev_region(dev, 1, WIFI_DRIVER_NAME);
if (alloc_ret) {
WIFI_ERR_FUNC("fail to register chrdev\n");
return alloc_ret;
}
cdev_init(&WIFI_cdev, &WIFI_fops);
WIFI_cdev.owner = THIS_MODULE;
cdev_err = cdev_add(&WIFI_cdev, dev, WIFI_devs);
if (cdev_err) {
goto error;
}
sema_init(&wr_mtx, 1);
WIFI_INFO_FUNC("%s driver(major %d) installed.\n", WIFI_DRIVER_NAME, WIFI_major);
retflag = 0;
wlan_mode = WLAN_MODE_HALT;
pf_set_p2p_mode = NULL;
return 0;
error:
if (cdev_err == 0) {
cdev_del(&WIFI_cdev);
}
if (alloc_ret == 0) {
unregister_chrdev_region(dev, WIFI_devs);
}
return -1;
}
static void WIFI_exit(void)
{
dev_t dev = MKDEV(WIFI_major, 0);
// retflag = 0;
if(pWIFIDev)
{
device_destroy(pWIFIClass, dev);
pWIFIDev = NULL;
}
if(pWIFIClass)
{
class_destroy(pWIFIClass);
pWIFIClass = NULL;
}
cdev_del(&WIFI_cdev);
unregister_chrdev_region(dev, WIFI_devs);
WIFI_INFO_FUNC("%s driver removed.\n", WIFI_DRIVER_NAME);
}
ssize_t WIFI_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
int retval = -EIO;
char local[12] = {0};
static int opened = 0;
int ret = -1;
struct net_device *netdev = NULL;
PARAM_CUSTOM_P2P_SET_STRUC_T p2pmode;
int wait_cnt = 0;
down(&wr_mtx);
if (count <= 0) {
WIFI_INFO_FUNC("WIFI_write invalid param \n");
goto done;
}
if (0 == copy_from_user(local, buf, (count > sizeof(local)) ? sizeof(local) : count)) {
/*mtk80707 rollback aosp hal*/
local[11] = 0;
WIFI_INFO_FUNC("WIFI_write %s\n", local);
if (local[0] == '0' && opened == 1) {
//TODO
//Configure the EINT pin to GPIO mode.
p2pmode.u4Enable = 0;
p2pmode.u4Mode = 0;
/*IF power off already*/
if (power_state == 0) {
WIFI_INFO_FUNC("WMT turn off WIFI OK!\n");
opened = 0;
retval = count;
wlan_mode = WLAN_MODE_HALT;
goto done;
}
if (flagIsIFchanged==1)
{
netdev = dev_get_by_name(&init_net, WLAN_LEG_IFACE_NAME);}
else
{netdev = dev_get_by_name(&init_net, WLAN_IFACE_NAME);}
while (netdev == NULL && wait_cnt < 10) {
WIFI_WARN_FUNC("WMT fail to get wlan0 net device, sleep 300ms\n");
msleep(300);
wait_cnt ++;
if (flagIsIFchanged==1)
{ netdev = dev_get_by_name(&init_net, WLAN_LEG_IFACE_NAME);}
else
{ netdev = dev_get_by_name(&init_net, WLAN_IFACE_NAME);}
}
if (wait_cnt >= 10) {
WIFI_WARN_FUNC("WMT get wlan0 net device time out\n");
goto done;
}
if (pf_set_p2p_mode) {
ret = pf_set_p2p_mode(netdev, p2pmode);
if (ret != 0) {
WIFI_WARN_FUNC("WMT trun off p2p & ap mode ret = %d", ret);
goto done;
}
//msleep(300);
}
dev_put(netdev);
netdev = NULL;
if (MTK_WCN_BOOL_FALSE == mtk_wcn_wmt_func_off(WMTDRV_TYPE_WIFI)) {
WIFI_INFO_FUNC("WMT turn off WIFI fail!\n");
}
else {
WIFI_INFO_FUNC("WMT turn off WIFI OK!\n");
opened = 0;
retval = count;
wlan_mode = WLAN_MODE_HALT;
power_state = 0;
flagIsIFchanged=0;
PowerOnIFname = 0;
}
}
else if (local[0] == '1') {
//TODO
//Disable EINT(external interrupt), and set the GPIO to EINT mode.
if (power_state == 1){
WIFI_INFO_FUNC("WIFI is already on!\n");
retval = count;
}
else {
pf_set_p2p_mode = NULL;
if (MTK_WCN_BOOL_FALSE == mtk_wcn_wmt_func_on(WMTDRV_TYPE_WIFI)) {
WIFI_WARN_FUNC("WMT turn on WIFI fail!\n");
}
else {
opened = 1;
retval = count;
WIFI_INFO_FUNC("WMT turn on WIFI success!\n");
wlan_mode = WLAN_MODE_HALT;
power_state = 1;
//msleep(300);
}
}
}
else if (local[0] == 'S' || local[0] == 'P' || local[0] == 'A') {
p2pmode.u4Enable = 1;
p2pmode.u4Mode = 0;
ret = -1;
if (power_state ==0) {
WIFI_INFO_FUNC("Turn on WIFI first if WIFI is off\n");
if(local[0] == 'A')
{
PowerOnIFname = 1; //legacy_wlan0
printk("change PoweronIFname\n");
}
pf_set_p2p_mode = NULL;
if (MTK_WCN_BOOL_FALSE == mtk_wcn_wmt_func_on(WMTDRV_TYPE_WIFI)) {
WIFI_WARN_FUNC("WMT turn on WIFI fail!\n");
}
else {
opened = 1;
retval = count;
WIFI_INFO_FUNC("WMT turn on WIFI success!\n");
wlan_mode = WLAN_MODE_HALT;
power_state = 1;
if (local[0] == 'A'){
flagIsIFchanged=1;}
}
}
if (flagIsIFchanged==1)
{netdev = dev_get_by_name(&init_net, WLAN_LEG_IFACE_NAME);
}
else {
netdev = dev_get_by_name(&init_net, WLAN_IFACE_NAME);
if (local[0] == 'A'&&netdev!=NULL)
{
rtnl_lock();
ret = dev_change_name(netdev,WLAN_LEG_IFACE_NAME);
rtnl_unlock();
flagIsIFchanged=1;
printk("change_leagcy_name, ret = %d",ret);
}
}
while (netdev == NULL && wait_cnt < 10) {
WIFI_WARN_FUNC("WMT fail to get wlan0 net device, sleep 300ms\n");
msleep(300);
wait_cnt ++;
if (flagIsIFchanged==1)
{netdev = dev_get_by_name(&init_net, WLAN_LEG_IFACE_NAME);}
else {
netdev = dev_get_by_name(&init_net, WLAN_IFACE_NAME);
if (local[0] == 'A'&&netdev!=NULL)
{
rtnl_lock();
ret = dev_change_name(netdev,WLAN_LEG_IFACE_NAME);
rtnl_unlock();
flagIsIFchanged=1;
printk("change_leagcy_name, ret = %d",ret);
}
}
}
if (wait_cnt >= 10) {
WIFI_WARN_FUNC("WMT get wlan0 net device time out\n");
goto done;
}
if (pf_set_p2p_mode == NULL) {
WIFI_INFO_FUNC("set p2p handler is NULL\n");
goto done;
}
if (wlan_mode == WLAN_MODE_AP&&(local[0] == 'S' || local[0] == 'P') )
{
p2pmode.u4Enable = 0;
p2pmode.u4Mode = 0;
ret = pf_set_p2p_mode(netdev, p2pmode);
// msleep(300);
WIFI_INFO_FUNC("success to turn off p2p/AP mode\n");
}
p2pmode.u4Enable = 1;
p2pmode.u4Mode = 0;
ret = -1;
if (local[0] == 'A') {
p2pmode.u4Mode = 1;
}
ret = pf_set_p2p_mode(netdev, p2pmode);
//msleep(300);
dev_put(netdev);
netdev = NULL;
WIFI_INFO_FUNC("WMT WIFI set p2p mode ret=%d\n", ret);
if (ret == 0 && (local[0] == 'S' || local[0] == 'P')) {
WIFI_INFO_FUNC("wlan mode %d --> %d\n", wlan_mode, WLAN_MODE_STA_P2P);
wlan_mode = WLAN_MODE_STA_P2P;
retval = count;
} else if (ret == 0 && local[0] == 'A') {
WIFI_INFO_FUNC("wlan mode %d --> %d\n", wlan_mode, WLAN_MODE_AP);
wlan_mode = WLAN_MODE_AP;
retval = count;
} else {
WIFI_INFO_FUNC("fail to set wlan mode\n");
}
}
}
done:
up(&wr_mtx);
if (netdev != NULL) {
dev_put(netdev);
}
return (retval);
}
/*-----------------------------------------------------------------*/
INT32 wifi_reset_end(ENUM_RESET_STATUS_T status)
{
struct net_device *netdev = NULL;
PARAM_CUSTOM_P2P_SET_STRUC_T p2pmode;
INT32 wait_cnt = 0;
INT32 ret = -1;
if (status == RESET_FAIL) {
/* whole chip reset fail, donot recover WIFI */
ret = 0;
up(&wr_mtx);
}
else if (status == RESET_SUCCESS) {
WIFI_WARN_FUNC("WIFI state recovering...\n");
if (powered == 1) {
/* WIFI is on before whole chip reset, reopen it now */
if (MTK_WCN_BOOL_FALSE == mtk_wcn_wmt_func_on(WMTDRV_TYPE_WIFI)) {
WIFI_ERR_FUNC("WMT turn on WIFI fail!\n");
goto done;
}
else {
WIFI_INFO_FUNC("WMT turn on WIFI success!\n");
}
if (pf_set_p2p_mode == NULL) {
WIFI_ERR_FUNC("Set p2p mode handler is NULL\n");
goto done;
}
netdev = dev_get_by_name(&init_net, ifname);
while (netdev == NULL && wait_cnt < 10) {
WIFI_ERR_FUNC("Fail to get %s net device, sleep 300ms\n", ifname);
msleep(300);
wait_cnt ++;
netdev = dev_get_by_name(&init_net, ifname);
}
if (wait_cnt >= 10) {
WIFI_ERR_FUNC("Get %s net device timeout\n", ifname);
goto done;
}
if (wlan_mode == WLAN_MODE_STA_P2P){
p2pmode.u4Enable = 1;
p2pmode.u4Mode = 0;
if (pf_set_p2p_mode(netdev, p2pmode) != 0){
WIFI_ERR_FUNC("Set wlan mode fail\n");
}
else{
WIFI_WARN_FUNC("Set wlan mode %d\n", WLAN_MODE_STA_P2P);
ret = 0;
}
} else if (wlan_mode == WLAN_MODE_AP){
p2pmode.u4Enable = 1;
p2pmode.u4Mode = 1;
if (pf_set_p2p_mode(netdev, p2pmode) != 0){
WIFI_ERR_FUNC("Set wlan mode fail\n");
}
else{
WIFI_WARN_FUNC("Set wlan mode %d\n", WLAN_MODE_AP);
ret = 0;
}
}
done:
if (netdev != NULL){
dev_put(netdev);
}
}
else {
/* WIFI is off before whole chip reset, do nothing */
ret = 0;
}
up(&wr_mtx);
}
return ret;
}
ssize_t WIFI_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
INT32 retval = -EIO;
INT8 local[12] = {0};
struct net_device *netdev = NULL;
PARAM_CUSTOM_P2P_SET_STRUC_T p2pmode;
INT32 wait_cnt = 0;
down(&wr_mtx);
if (count <= 0) {
WIFI_ERR_FUNC("WIFI_write invalid param\n");
goto done;
}
if (0 == copy_from_user(local, buf, (count > sizeof(local)) ? sizeof(local) : count)) {
local[11] = 0;
WIFI_INFO_FUNC("WIFI_write %s\n", local);
if (local[0] == '0') {
if (powered == 0) {
WIFI_INFO_FUNC("WIFI is already power off!\n");
retval = count;
wlan_mode = WLAN_MODE_HALT;
goto done;
}
netdev = dev_get_by_name(&init_net, ifname);
if (netdev == NULL) {
WIFI_ERR_FUNC("Fail to get %s net device\n", ifname);
}
else {
p2pmode.u4Enable = 0;
p2pmode.u4Mode = 0;
if (pf_set_p2p_mode) {
if (pf_set_p2p_mode(netdev, p2pmode) != 0){
WIFI_ERR_FUNC("Turn off p2p/ap mode fail");
} else {
WIFI_INFO_FUNC("Turn off p2p/ap mode");
wlan_mode = WLAN_MODE_HALT;
}
}
dev_put(netdev);
netdev = NULL;
}
if (MTK_WCN_BOOL_FALSE == mtk_wcn_wmt_func_off(WMTDRV_TYPE_WIFI)) {
WIFI_ERR_FUNC("WMT turn off WIFI fail!\n");
powered = 2;
}
else {
WIFI_INFO_FUNC("WMT turn off WIFI OK!\n");
powered = 0;
retval = count;
wlan_mode = WLAN_MODE_HALT;
#if CFG_TC1_FEATURE
ifname = WLAN_IFACE_NAME;
wlan_if_changed = 0;
#endif
}
}
else if (local[0] == '1') {
if (powered == 1) {
WIFI_INFO_FUNC("WIFI is already power on!\n");
retval = count;
goto done;
}
if (MTK_WCN_BOOL_FALSE == mtk_wcn_wmt_func_on(WMTDRV_TYPE_WIFI)) {
WIFI_ERR_FUNC("WMT turn on WIFI fail!\n");
}
else {
powered = 1;
retval = count;
WIFI_INFO_FUNC("WMT turn on WIFI success!\n");
wlan_mode = WLAN_MODE_HALT;
}
}
else if (local[0] == 'D') {
INT32 k = 0;
/*
* 0: no debug
* 1: common debug output
* 2: more detials
* 3: verbose
*/
switch (local[1]) {
case '0':
for (k = 0; k < DBG_MODULE_NUM; k++) {
wlan_dbg_level[k] = 0;
}
if (pf_set_dbg_level) {
pf_set_dbg_level(wlan_dbg_level);
}
break;
case '1':
for (k = 0; k < DBG_MODULE_NUM; k++) {
wlan_dbg_level[k] = DBG_CLASS_ERROR | \
DBG_CLASS_WARN | \
DBG_CLASS_STATE | \
DBG_CLASS_EVENT | \
DBG_CLASS_TRACE | \
DBG_CLASS_INFO;
}
wlan_dbg_level[DBG_TX_IDX] &= ~(DBG_CLASS_EVENT | \
DBG_CLASS_TRACE | \
DBG_CLASS_INFO);
wlan_dbg_level[DBG_RX_IDX] &= ~(DBG_CLASS_EVENT | \
DBG_CLASS_TRACE | \
DBG_CLASS_INFO);
wlan_dbg_level[DBG_REQ_IDX] &= ~(DBG_CLASS_EVENT | \
DBG_CLASS_TRACE | \
DBG_CLASS_INFO);
wlan_dbg_level[DBG_INTR_IDX] = 0;
wlan_dbg_level[DBG_MEM_IDX] = 0;
if (pf_set_dbg_level) {
pf_set_dbg_level(wlan_dbg_level);
}
break;
case '2':
for (k = 0; k < DBG_MODULE_NUM; k++) {
wlan_dbg_level[k] = DBG_CLASS_ERROR | \
DBG_CLASS_WARN | \
DBG_CLASS_STATE | \
DBG_CLASS_EVENT | \
DBG_CLASS_TRACE | \
DBG_CLASS_INFO;
}
wlan_dbg_level[DBG_INTR_IDX] = 0;
wlan_dbg_level[DBG_MEM_IDX] = 0;
if (pf_set_dbg_level) {
pf_set_dbg_level(wlan_dbg_level);
}
break;
case '3':
for (k = 0; k < DBG_MODULE_NUM; k++) {
wlan_dbg_level[k] = DBG_CLASS_ERROR | \
DBG_CLASS_WARN | \
DBG_CLASS_STATE | \
DBG_CLASS_EVENT | \
DBG_CLASS_TRACE | \
DBG_CLASS_INFO | \
DBG_CLASS_LOUD;
}
if (pf_set_dbg_level) {
pf_set_dbg_level(wlan_dbg_level);
}
break;
default:
break;
}
}
else if (local[0] == 'S' || local[0] == 'P' || local[0] == 'A') {
if (powered == 0) {
/* If WIFI is off, turn on WIFI first */
if (MTK_WCN_BOOL_FALSE == mtk_wcn_wmt_func_on(WMTDRV_TYPE_WIFI)) {
WIFI_ERR_FUNC("WMT turn on WIFI fail!\n");
goto done;
}
else {
powered = 1;
WIFI_INFO_FUNC("WMT turn on WIFI success!\n");
wlan_mode = WLAN_MODE_HALT;
}
}
if (pf_set_p2p_mode == NULL) {
WIFI_ERR_FUNC("Set p2p mode handler is NULL\n");
goto done;
}
netdev = dev_get_by_name(&init_net, ifname);
while (netdev == NULL && wait_cnt < 10) {
WIFI_ERR_FUNC("Fail to get %s net device, sleep 300ms\n", ifname);
msleep(300);
wait_cnt ++;
netdev = dev_get_by_name(&init_net, ifname);
}
if (wait_cnt >= 10) {
WIFI_ERR_FUNC("Get %s net device timeout\n", ifname);
goto done;
}
if ((wlan_mode == WLAN_MODE_STA_P2P && (local[0] == 'S' || local[0] == 'P')) ||
(wlan_mode == WLAN_MODE_AP && (local[0] == 'A'))){
WIFI_INFO_FUNC("WIFI is already in mode %d!\n", wlan_mode);
retval = count;
goto done;
}
if ((wlan_mode == WLAN_MODE_AP && (local[0] == 'S' || local[0] == 'P')) ||
(wlan_mode == WLAN_MODE_STA_P2P && (local[0] == 'A'))){
p2pmode.u4Enable = 0;
p2pmode.u4Mode = 0;
if (pf_set_p2p_mode(netdev, p2pmode) != 0){
WIFI_ERR_FUNC("Turn off p2p/ap mode fail");
goto done;
}
}
if (local[0] == 'S' || local[0] == 'P'){
#if CFG_TC1_FEATURE
/* Restore NIC name to wlan0 */
rtnl_lock();
if (strcmp(ifname, WLAN_IFACE_NAME) != 0){
if (dev_change_name(netdev, WLAN_IFACE_NAME) != 0){
WIFI_ERR_FUNC("netdev name change to %s fail\n", WLAN_IFACE_NAME);
rtnl_unlock();
goto done;
}
else{
WIFI_INFO_FUNC("netdev name changed %s --> %s\n", ifname, WLAN_IFACE_NAME);
ifname = WLAN_IFACE_NAME;
wlan_if_changed = 0;
}
}
rtnl_unlock();
#endif
p2pmode.u4Enable = 1;
p2pmode.u4Mode = 0;
if (pf_set_p2p_mode(netdev, p2pmode) != 0){
WIFI_ERR_FUNC("Set wlan mode fail\n");
}
else{
WIFI_INFO_FUNC("Set wlan mode %d --> %d\n", wlan_mode, WLAN_MODE_STA_P2P);
wlan_mode = WLAN_MODE_STA_P2P;
retval = count;
}
} else if (local[0] == 'A'){
#if CFG_TC1_FEATURE
/* Change NIC name to legacy0, since wlan0 is used for AP */
rtnl_lock();
if (strcmp(ifname, LEGACY_IFACE_NAME) != 0){
if (dev_change_name(netdev, LEGACY_IFACE_NAME) != 0){
WIFI_ERR_FUNC("netdev name change to %s fail\n", LEGACY_IFACE_NAME);
rtnl_unlock();
goto done;
}
else{
WIFI_INFO_FUNC("netdev name changed %s --> %s\n", ifname, LEGACY_IFACE_NAME);
ifname = LEGACY_IFACE_NAME;
wlan_if_changed = 1;
}
}
rtnl_unlock();
#endif
p2pmode.u4Enable = 1;
p2pmode.u4Mode = 1;
if (pf_set_p2p_mode(netdev, p2pmode) != 0){
WIFI_ERR_FUNC("Set wlan mode fail\n");
}
else{
WIFI_INFO_FUNC("Set wlan mode %d --> %d\n", wlan_mode, WLAN_MODE_AP);
wlan_mode = WLAN_MODE_AP;
retval = count;
}
}
dev_put(netdev);
netdev = NULL;
}
}
done:
if (netdev != NULL){
dev_put(netdev);
}
up(&wr_mtx);
return (retval);
}
ssize_t WIFI_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
int retval = -EIO;
struct net_device *netdev = NULL;
char local[12] = {0};
int wait_cnt = 0;
down(&wr_mtx);
if (count <= 0) {
WIFI_ERR_FUNC("WIFI_write invalid param\n");
goto done;
}
if (0 == copy_from_user(local, buf, (count > sizeof(local)) ? sizeof(local) : count)) {
local[11] = 0;
WIFI_INFO_FUNC("WIFI_write %s\n", local);
if (local[0] == '0') {
if (powered == 0) {
WIFI_INFO_FUNC("WIFI is already power off!\n");
retval = count;
goto done;
} else {
/* WIFI FUNCTION OFF */
WIFI_func_ctrl(0);
WIFI_INFO_FUNC("WMT turn off WIFI OK!\n");
powered = 0;
retval = count;
}
}
else if (local[0] == '1') {
/* WIFI FUNCTION ON */
if (powered == 1) {
WIFI_INFO_FUNC("WIFI is already power on!\n");
retval = count;
goto done;
} else {
WIFI_func_ctrl(1);
WIFI_INFO_FUNC("WMT turn on WIFI success!\n");
powered = 1;
retval = count;
}
}
else if (local[0] == 'S' || local[0] == 'P' || local[0] == 'A') {
if (powered == 0) {
WIFI_func_ctrl(1);
WIFI_INFO_FUNC("WMT turn on WIFI success!\n");
powered = 1;
}
/* Polling NET DEV if exist */
netdev = dev_get_by_name(&init_net, WLAN_IFACE_NAME);
while (netdev == NULL && wait_cnt < 10) {
WIFI_ERR_FUNC("Fail to get wlan0 net device, sleep %d ms(%d)\n", WLAN_QUERYDEV_TIME,wait_cnt);
msleep(WLAN_QUERYDEV_TIME);
wait_cnt++;
netdev = dev_get_by_name(&init_net, WLAN_IFACE_NAME);
}
if (wait_cnt >= 10) {
WIFI_ERR_FUNC("Get wlan0 net device timeout\n");
goto done;
}
WIFI_INFO_FUNC("wlan0 net device created\n");
dev_put(netdev);
netdev = NULL;
}
}
done:
if (netdev != NULL){
dev_put(netdev);
}
up(&wr_mtx);
return (retval);
}
VOID register_set_p2p_mode_handler(set_p2p_mode handler) {
WIFI_INFO_FUNC("(pid %d) register set p2p mode handler %p\n", current->pid, handler);
pf_set_p2p_mode = handler;
}
ssize_t WIFI_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
int retval = -EIO;
char local[12] = { 0 };
struct net_device *netdev = NULL;
PARAM_CUSTOM_P2P_SET_STRUC_T p2pmode;
int wait_cnt = 0;
down(&wr_mtx);
if (count <= 0) {
WIFI_ERR_FUNC("WIFI_write invalid param\n");
goto done;
}
if (0 == copy_from_user(local, buf, (count > sizeof(local)) ? sizeof(local) : count)) {
local[11] = 0;
WIFI_INFO_FUNC("WIFI_write %s\n", local);
if (local[0] == '0') {
/* TODO */
/* Configure the EINT pin to GPIO mode. */
if (powered == 0) {
WIFI_INFO_FUNC("WIFI is already power off!\n");
retval = count;
wlan_mode = WLAN_MODE_HALT;
goto done;
}
netdev = dev_get_by_name(&init_net, WLAN_IFACE_NAME);
if (netdev == NULL) {
WIFI_ERR_FUNC("Fail to get wlan0 net device\n");
} else {
p2pmode.u4Enable = 0;
p2pmode.u4Mode = 0;
if (pf_set_p2p_mode) {
if (pf_set_p2p_mode(netdev, p2pmode) != 0) {
WIFI_ERR_FUNC("Turn off p2p/ap mode fail");
} else {
WIFI_INFO_FUNC("Turn off p2p/ap mode");
wlan_mode = WLAN_MODE_HALT;
}
}
dev_put(netdev);
netdev = NULL;
}
if (MTK_WCN_BOOL_FALSE == mtk_wcn_wmt_func_off(WMTDRV_TYPE_WIFI)) {
WIFI_ERR_FUNC("WMT turn off WIFI fail!\n");
} else {
WIFI_INFO_FUNC("WMT turn off WIFI OK!\n");
powered = 0;
retval = count;
wlan_mode = WLAN_MODE_HALT;
}
} else if (local[0] == '1') {
/* TODO */
/* Disable EINT(external interrupt), and set the GPIO to EINT mode. */
if (powered == 1) {
WIFI_INFO_FUNC("WIFI is already power on!\n");
retval = count;
goto done;
}
if (MTK_WCN_BOOL_FALSE == mtk_wcn_wmt_func_on(WMTDRV_TYPE_WIFI)) {
WIFI_ERR_FUNC("WMT turn on WIFI fail!\n");
} else {
powered = 1;
retval = count;
WIFI_INFO_FUNC("WMT turn on WIFI success!\n");
wlan_mode = WLAN_MODE_HALT;
}
} else if (local[0] == 'D') {
int k = 0;
/*
* 0: no debug
* 1: common debug output
* 2: more detials
* 3: verbose
*/
switch (local[1]) {
case '0':
for (k = 0; k < DBG_MODULE_NUM; k++) {
wlan_dbg_level[k] = 0;
}
if (pf_set_dbg_level) {
pf_set_dbg_level(wlan_dbg_level);
}
break;
case '1':
for (k = 0; k < DBG_MODULE_NUM; k++) {
wlan_dbg_level[k] = DBG_CLASS_ERROR |
DBG_CLASS_WARN |
DBG_CLASS_STATE |
DBG_CLASS_EVENT | DBG_CLASS_TRACE | DBG_CLASS_INFO;
}
wlan_dbg_level[DBG_TX_IDX] &= ~(DBG_CLASS_EVENT |
DBG_CLASS_TRACE | DBG_CLASS_INFO);
wlan_dbg_level[DBG_RX_IDX] &= ~(DBG_CLASS_EVENT |
DBG_CLASS_TRACE | DBG_CLASS_INFO);
wlan_dbg_level[DBG_REQ_IDX] &= ~(DBG_CLASS_EVENT |
DBG_CLASS_TRACE | DBG_CLASS_INFO);
wlan_dbg_level[DBG_INTR_IDX] = 0;
wlan_dbg_level[DBG_MEM_IDX] = 0;
if (pf_set_dbg_level) {
pf_set_dbg_level(wlan_dbg_level);
}
break;
case '2':
for (k = 0; k < DBG_MODULE_NUM; k++) {
wlan_dbg_level[k] = DBG_CLASS_ERROR |
DBG_CLASS_WARN |
DBG_CLASS_STATE |
DBG_CLASS_EVENT | DBG_CLASS_TRACE | DBG_CLASS_INFO;
}
wlan_dbg_level[DBG_INTR_IDX] = 0;
wlan_dbg_level[DBG_MEM_IDX] = 0;
if (pf_set_dbg_level) {
pf_set_dbg_level(wlan_dbg_level);
}
break;
case '3':
for (k = 0; k < DBG_MODULE_NUM; k++) {
wlan_dbg_level[k] = DBG_CLASS_ERROR |
DBG_CLASS_WARN |
DBG_CLASS_STATE |
DBG_CLASS_EVENT |
DBG_CLASS_TRACE | DBG_CLASS_INFO | DBG_CLASS_LOUD;
}
if (pf_set_dbg_level) {
pf_set_dbg_level(wlan_dbg_level);
}
break;
default:
break;
}
} else if (local[0] == 'S' || local[0] == 'P' || local[0] == 'A') {
if (powered == 0) {
/* If WIFI is off, turn on WIFI first */
if (MTK_WCN_BOOL_FALSE == mtk_wcn_wmt_func_on(WMTDRV_TYPE_WIFI)) {
WIFI_ERR_FUNC("WMT turn on WIFI fail!\n");
goto done;
} else {
powered = 1;
WIFI_INFO_FUNC("WMT turn on WIFI success!\n");
wlan_mode = WLAN_MODE_HALT;
}
}
if (pf_set_p2p_mode == NULL) {
WIFI_ERR_FUNC("Set p2p mode handler is NULL\n");
goto done;
}
netdev = dev_get_by_name(&init_net, WLAN_IFACE_NAME);
while (netdev == NULL && wait_cnt < 10) {
WIFI_ERR_FUNC("Fail to get wlan0 net device, sleep 300ms\n");
msleep(300);
wait_cnt++;
netdev = dev_get_by_name(&init_net, WLAN_IFACE_NAME);
}
if (wait_cnt >= 10) {
WIFI_ERR_FUNC("Get wlan0 net device timeout\n");
goto done;
}
if ((wlan_mode == WLAN_MODE_AP && (local[0] == 'S' || local[0] == 'P')) ||
(wlan_mode == WLAN_MODE_STA_P2P && (local[0] == 'A'))) {
p2pmode.u4Enable = 0;
p2pmode.u4Mode = 0;
if (pf_set_p2p_mode(netdev, p2pmode) != 0) {
WIFI_ERR_FUNC("Turn off p2p/ap mode fail");
goto done;
}
}
if (local[0] == 'S' || local[0] == 'P') {
p2pmode.u4Enable = 1;
p2pmode.u4Mode = 0;
if (pf_set_p2p_mode(netdev, p2pmode) != 0) {
WIFI_ERR_FUNC("Set wlan mode fail\n");
} else {
WIFI_INFO_FUNC("Set wlan mode %d --> %d\n", wlan_mode,
WLAN_MODE_STA_P2P);
wlan_mode = WLAN_MODE_STA_P2P;
retval = count;
}
} else if (local[0] == 'A') {
p2pmode.u4Enable = 1;
p2pmode.u4Mode = 1;
if (pf_set_p2p_mode(netdev, p2pmode) != 0) {
WIFI_ERR_FUNC("Set wlan mode fail\n");
} else {
WIFI_INFO_FUNC("Set wlan mode %d --> %d\n", wlan_mode,
WLAN_MODE_AP);
wlan_mode = WLAN_MODE_AP;
retval = count;
}
}
dev_put(netdev);
netdev = NULL;
}
}
done:
if (netdev != NULL) {
dev_put(netdev);
}
up(&wr_mtx);
return (retval);
}
