return 0;
 }
 
-
 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
 static int dev_state_ev_handler(struct notifier_block *this, unsigned long event, void *ptr);
 
                if (g_linux_wlan->oup.wlan_cleanup != NULL) \
                        g_linux_wlan->oup.wlan_cleanup(); }
 
-
 #ifndef STA_FIRMWARE
 #define STA_FIRMWARE   "wifi_firmware.bin"
 #endif
 #define P2P_CONCURRENCY_FIRMWARE       "wifi_firmware_p2p_concurrency.bin"
 #endif
 
-
-
 typedef struct android_wifi_priv_cmd {
        char *buf;
        int used_len;
        int total_len;
 } android_wifi_priv_cmd;
 
-
 #define IRQ_WAIT       1
 #define IRQ_NO_WAIT    0
 /*
 extern void WILC_WFI_monitor_rx(uint8_t *buff, uint32_t size);
 extern void WILC_WFI_p2p_rx(struct net_device *dev, uint8_t *buff, uint32_t size);
 
-
 static void *internal_alloc(uint32_t size, uint32_t flag);
 static void linux_wlan_tx_complete(void *priv, int status);
 void frmw_to_linux(uint8_t *buff, uint32_t size, uint32_t pkt_offset);
 static int  mac_ioctl(struct net_device *ndev, struct ifreq *req, int cmd);
 static void wilc_set_multicast_list(struct net_device *dev);
 
-
-
 /*
  * for now - in frmw_to_linux there should be private data to be passed to it
  * and this data should be pointer to net device
 char DebugBuffer[DEGUG_BUFFER_LENGTH + 20] = {0};
 static char *ps8current = DebugBuffer;
 
-
-
 void printk_later(const char *format, ...)
 {
        va_list args;
 
 }
 
-
 void dump_logs()
 {
        if (DebugBuffer[0]) {
                WatchDogdebuggerCounter = 0;
        }
 }
-
-
 #endif
 
-
 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
 static int dev_state_ev_handler(struct notifier_block *this, unsigned long event, void *ptr)
 {
 
                PRINT_INFO(GENERIC_DBG, "\n ============== IP Address Obtained ===============\n\n");
 
-
                /*If we are in station mode or client mode*/
                if (nic->iftype == STATION_MODE || nic->iftype == CLIENT_MODE) {
                        pstrWFIDrv->IFC_UP = 1;
                        PRINT_D(GENERIC_DBG, "IP obtained , enable scan\n");
                }
 
-
-
                if (bEnablePS)
                        host_int_set_power_mgmt((WILC_WFIDrvHandle)pstrWFIDrv, 1, 0);
 
 
                resolve_disconnect_aberration(pstrWFIDrv);
 
-
                PRINT_D(GENERIC_DBG, "[%s] Down IP\n", dev_iface->ifa_label);
 
                pIP_Add_buff = null_ip;
 #if (defined WILC_SPI) || (defined WILC_SDIO_IRQ_GPIO)
 static irqreturn_t isr_uh_routine(int irq, void *user_data)
 {
-
-
        int_rcvdU++;
 #if (RX_BH_TYPE != RX_BH_THREADED_IRQ)
        linux_wlan_disable_irq(IRQ_NO_WAIT);
        #else
                return;
        #endif
-
-
-
        }
 
        int_rcvdB++;
                PRINT_ER("wlan_handle_rx_isr() hasn't been initialized\n");
        }
 
-
 #if (RX_BH_TYPE == RX_BH_THREADED_IRQ)
        return IRQ_HANDLED;
 #endif
 }
 #endif
 
-
 #if (defined WILC_SPI) || (defined WILC_SDIO_IRQ_GPIO)
 static int init_irq(linux_wlan_t *p_nic)
 {
                PRINT_ER("could not obtain gpio for WILC_INTR\n");
        }
 
-
 #if (RX_BH_TYPE == RX_BH_THREADED_IRQ)
        if ((ret != -1) && (request_threaded_irq(nic->dev_irq_num, isr_uh_routine, isr_bh_routine,
                                                  IRQF_TRIGGER_LOW | IRQF_ONESHOT,               /*Without IRQF_ONESHOT the uh will remain kicked in and dont gave a chance to bh*/
 #endif
 }
 
-
 /*
  *      OS functions
  */
        }
 }
 
-
 static void *internal_alloc(uint32_t size, uint32_t flag)
 {
        char *pntr = NULL;
        return (void *)pntr;
 }
 
-
 static void linux_wlan_init_lock(char *lockName, void *plock, int count)
 {
        sema_init((struct semaphore *)plock, count);
        }
 }
 
-
 static void linux_wlan_init_mutex(char *lockName, void *plock, int count)
 {
        mutex_init((struct mutex *)plock);
        }
 }
 
-
 /*Added by Amr - BugID_4720*/
 static void linux_wlan_init_spin_lock(char *lockName, void *plock, int count)
 {
        const struct firmware *wilc_firmware;
        char *firmware;
 
-
        if (nic->iftype == AP_MODE)
                firmware = AP_FIRMWARE;
        else if (nic->iftype == STATION_MODE)
                firmware = P2P_CONCURRENCY_FIRMWARE;
        }
 
-
-
        if (nic == NULL) {
                PRINT_ER("NIC is NULL\n");
                goto _fail_;
                goto _fail_;
        }
 
-
        /*      the firmare should be located in /lib/firmware in
         *      root file system with the name specified above */
 
        return ret;
 }
 
-
 /* startup configuration - could be changed later using iconfig*/
 static int linux_wlan_init_test_config(struct net_device *dev, linux_wlan_t *p_nic)
 {
        PRINT_D(INIT_DBG, "MAC address is : %02x-%02x-%02x-%02x-%02x-%02x\n", mac_add[0], mac_add[1], mac_add[2], mac_add[3], mac_add[4], mac_add[5]);
        wilc_get_chipid(0);
 
-
        if (g_linux_wlan->oup.wlan_cfg_set == NULL) {
                PRINT_D(INIT_DBG, "Null p[ointer\n");
                goto _fail_;
        if (!g_linux_wlan->oup.wlan_cfg_set(0, WID_BSS_TYPE, c_val, 1, 0, 0))
                goto _fail_;
 
-
        /* c_val[0] = RATE_AUTO; / * bug 4275: Enable autorate and limit it to 24Mbps * / */
        c_val[0] = RATE_AUTO;
        if (!g_linux_wlan->oup.wlan_cfg_set(0, WID_CURRENT_TX_RATE, c_val, 1, 0, 0))
        return -1;
 }
 
-
 /**************************/
 void wilc1000_wlan_deinit(linux_wlan_t *nic)
 {
                  #endif
                #endif
 
-
                /* not sure if the following unlocks are needed or not*/
                if (&g_linux_wlan->rxq_event != NULL)
                        linux_wlan_unlock(&g_linux_wlan->rxq_event);
                if (&g_linux_wlan->txq_event != NULL)
                        linux_wlan_unlock(&g_linux_wlan->txq_event);
 
-
        #if (RX_BH_TYPE == RX_BH_WORK_QUEUE)
                /*Removing the work struct from the linux kernel workqueue*/
                if (&g_linux_wlan->rx_work_queue != NULL)
                PRINT_D(INIT_DBG, "Deinitializing IRQ\n");
                deinit_irq(g_linux_wlan);
 
-
                if (&g_linux_wlan->oup != NULL) {
                        if (g_linux_wlan->oup.wlan_stop != NULL)
                                g_linux_wlan->oup.wlan_stop();
        if (&g_linux_wlan->rxq_event != NULL)
                linux_wlan_unlock(&g_linux_wlan->rxq_event);
 
-
        if (g_linux_wlan->rxq_thread != NULL) {
                kthread_stop(g_linux_wlan->rxq_thread);
                g_linux_wlan->rxq_thread = NULL;
        }
 
-
        if (&g_linux_wlan->txq_event != NULL)
                linux_wlan_unlock(&g_linux_wlan->txq_event);
 
-
        if (g_linux_wlan->txq_thread != NULL) {
                kthread_stop(g_linux_wlan->txq_thread);
                g_linux_wlan->txq_thread = NULL;
                /*Save the oup structre into global pointer*/
                gpstrWlanOps = &g_linux_wlan->oup;
 
-
                ret = wlan_initialize_threads(nic);
                if (ret < 0) {
                        PRINT_ER("Initializing Threads FAILED\n");
                        goto _fail_irq_enable_;
                }
 
-
                /*Download firmware*/
                ret = linux_wlan_firmware_download(g_linux_wlan);
                if (ret < 0) {
                g_linux_wlan->wilc1000_initialized = 1;
                return 0; /*success*/
 
-
 _fail_fw_start_:
                if (&g_linux_wlan->oup != NULL) {
                        if (g_linux_wlan->oup.wlan_stop != NULL)
        return ret;
 }
 
-
 /*
  *      - this function will be called automatically by OS when module inserted.
  */
 }
 #endif
 
-
 void    WILC_WFI_frame_register(struct wiphy *wiphy, struct net_device *dev,
                                u16 frame_type, bool reg);
 
                goto _err_;
        }
 
-
        WILC_WFI_frame_register(nic->wilc_netdev->ieee80211_ptr->wiphy, nic->wilc_netdev,
                                nic->g_struct_frame_reg[0].frame_type, nic->g_struct_frame_reg[0].reg);
        WILC_WFI_frame_register(nic->wilc_netdev->ieee80211_ptr->wiphy, nic->wilc_netdev,
 {
        perInterface_wlan_t *nic = netdev_priv(dev);
 
-
        return &nic->netstats;
 }
 
        priv = wiphy_priv(dev->ieee80211_ptr->wiphy);
        pstrWFIDrv = (tstrWILC_WFIDrv *)priv->hWILCWFIDrv;
 
-
        if (!dev)
                return;
 
        QueueCount = WILC_Xmit_data((void *)tx_data, HOST_TO_WLAN);
        #endif /* WILC_FULLY_HOSTING_AP */
 
-
        if (QueueCount > FLOW_CONTROL_UPPER_THRESHOLD) {
                netif_stop_queue(g_linux_wlan->strInterfaceInfo[0].wilc_netdev);
                netif_stop_queue(g_linux_wlan->strInterfaceInfo[1].wilc_netdev);
        return 0;
 }
 
-
 int mac_close(struct net_device *ndev)
 {
        struct WILC_WFI_priv *priv;
 
        pstrWFIDrv = (tstrWILC_WFIDrv *)priv->hWILCWFIDrv;
 
-
-
        PRINT_D(GENERIC_DBG, "Mac close\n");
 
        if (g_linux_wlan == NULL) {
        return 0;
 }
 
-
 int mac_ioctl(struct net_device *ndev, struct ifreq *req, int cmd)
 {
 
        struct WILC_WFI_priv *priv;
        s32 s32Error = WILC_SUCCESS;
 
-
-
        /* struct iwreq *wrq = (struct iwreq *) req;    // tony moved to case SIOCSIWPRIV */
        #ifdef USE_WIRELESS
        nic = netdev_priv(ndev);
                frame_len = size;
                buff_to_send = buff;
 
-
                /* Need to send the packet up to the host, allocate a skb buffer */
                skb = dev_alloc_skb(frame_len);
                if (skb == NULL) {
                }
                #endif
 
-
                if (register_netdev(ndev)) {
                        PRINT_ER("Device couldn't be registered - %s\n", ndev->name);
                        return -1; /* ERROR */
        return 0;
 }
 
-
 /*The 1st function called after module inserted*/
 static int __init init_wilc_driver(void)
 {
-
-
 #if defined (WILC_DEBUGFS)
        if (wilc_debugfs_init() < 0) {
                PRINT_D(GENERIC_DBG, "fail to create debugfs for wilc driver\n");
                        nic[i] = netdev_priv(g_linux_wlan->strInterfaceInfo[i].wilc_netdev);
        }
 
-
        if ((g_linux_wlan != NULL) && g_linux_wlan->wilc_firmware != NULL) {
                release_firmware(g_linux_wlan->wilc_firmware);
                g_linux_wlan->wilc_firmware = NULL;
        }
 
-
        if ((g_linux_wlan != NULL) && (((g_linux_wlan->strInterfaceInfo[0].wilc_netdev) != NULL)
                                       || ((g_linux_wlan->strInterfaceInfo[1].wilc_netdev) != NULL))) {
                PRINT_D(INIT_DBG, "Waiting for mac_close ....\n");
                else
                        PRINT_D(INIT_DBG, "mac_closed\n");
 
-
                for (i = 0; i < NUM_CONCURRENT_IFC; i++) {
                        /* close all opened interfaces */
                        if (g_linux_wlan->strInterfaceInfo[i].wilc_netdev != NULL) {
                }
        }
 
-
 #ifdef USE_WIRELESS
 #ifdef WILC_AP_EXTERNAL_MLME
        /* Bug 4600 : WILC_WFI_deinit_mon_interface was already called at mac_close */