static int WIFI_func_ctrl(unsigned int on)
{
WIFI_ERR_FUNC("WIFI_func_ctrl GPIO_COMBO_PMU_EN_PIN(%d)\n", GPIO_COMBO_PMU_EN_PIN);
if (on == 1) {
io_set_output_mode(GPIO_COMBO_RST_PIN);
io_set_output_high(GPIO_COMBO_RST_PIN);
/* PMU_EN_WIFI RST_N */
io_set_output_mode(GPIO_COMBO_PMU_EN_PIN);
io_set_output_low(GPIO_COMBO_PMU_EN_PIN);
//io_set_output_mode(GPIO_COMBO_RST_PIN);
//io_set_output_low(GPIO_COMBO_RST_PIN);
//mdelay(10);
//io_set_output_high(GPIO_COMBO_RST_PIN);
//mdelay(5);
io_set_output_high(GPIO_COMBO_PMU_EN_PIN); //GPIO_GPS_SYNC_PIN
mdelay(5);
mt_wifi_register_to_sdio();
board_sdio_ctrl(1, 3);
} else if (on == 0) {
board_sdio_ctrl(1, 2);
mt_wifi_unregister_to_sdio();
io_set_output_low(GPIO_COMBO_PMU_EN_PIN);
} else {
WIFI_ERR_FUNC("Control Not support (%d)\n",on);
}
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_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 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;
}
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;
}
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;
}
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);
}
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);
}
/*-----------------------------------------------------------------*/
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)
{
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);
}
