static int hwwep = 1;  /* default use hw. set 0 to use software security */
 static int channels = 0x3fff;
 
-
-
 module_param(ifname, charp, 0644);
 module_param(hwwep, int, 0644);
 module_param(channels, int, 0644);
                             const struct usb_device_id *id);
 static void rtl8192_usb_disconnect(struct usb_interface *intf);
 
-
 static struct usb_driver rtl8192_usb_driver = {
        .name           = RTL819XU_MODULE_NAME,           /* Driver name   */
        .id_table       = rtl8192_usb_id_tbl,             /* PCI_ID table  */
        .resume         = NULL,                           /* PM resume fn  */
 };
 
-
 struct CHANNEL_LIST {
        u8      Channel[32];
        u8      Len;
        }
 }
 
-
-
-
 static void CamResetAllEntry(struct net_device *dev)
 {
        u32 ulcommand = 0;
        return 0;
 }
 
-
 int write_nic_word(struct net_device *dev, int indx, u16 data)
 {
        int status;
        return 0;
 }
 
-
 int write_nic_dword(struct net_device *dev, int indx, u32 data)
 {
        int status;
                                 usbdata, 4, HZ / 2);
        kfree(usbdata);
 
-
        if (status < 0) {
                netdev_err(dev, "%s TimeOut! status: %d\n", __func__, status);
                return status;
        return 0;
 }
 
-
-
 int read_nic_byte(struct net_device *dev, int indx, u8 *data)
 {
        int status;
        return 0;
 }
 
-
-
 int read_nic_word(struct net_device *dev, int indx, u16 *data)
 {
        int status;
                rxconf = rxconf | RCR_CBSSID;
        }
 
-
        if (priv->ieee80211->iw_mode == IW_MODE_MONITOR) {
                rxconf = rxconf | RCR_AICV;
                rxconf = rxconf | RCR_APWRMGT;
        if (priv->crcmon == 1 && priv->ieee80211->iw_mode == IW_MODE_MONITOR)
                rxconf = rxconf | RCR_ACRC32;
 
-
        rxconf = rxconf & ~RX_FIFO_THRESHOLD_MASK;
        rxconf = rxconf | (RX_FIFO_THRESHOLD_NONE << RX_FIFO_THRESHOLD_SHIFT);
        rxconf = rxconf & ~MAX_RX_DMA_MASK;
        return status;
 }
 
-
 static void rtl8192_data_hard_stop(struct net_device *dev)
 {
        /* FIXME !! */
 }
 
-
 static void rtl8192_data_hard_resume(struct net_device *dev)
 {
        /* FIXME !! */
        struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
        u8 queue_index = tcb_desc->queue_index;
 
-
        spin_lock_irqsave(&priv->tx_lock, flags);
 
        memcpy((unsigned char *)(skb->cb), &dev, sizeof(dev));
        }
 }
 
-
 #define SHORT_SLOT_TIME 9
 #define NON_SHORT_SLOT_TIME 20
 
  */
 void rtl819xusb_beacon_tx(struct net_device *dev, u16  tx_rate)
 {
-
 }
 
 short rtl819xU_tx_cmd(struct net_device *dev, struct sk_buff *skb)
        return ret;
 }
 
-
 static u8 QueryIsShort(u8 TxHT, u8 TxRate, struct cb_desc *tcb_desc)
 {
        u8   tmp_Short;
        {0, 0, 0, 0} /* tx_op_limit */
 };
 
-
 static void rtl8192_update_beacon(struct work_struct *work)
 {
        struct r8192_priv *priv = container_of(work, struct r8192_priv,
        if (set_qos_param == 1)
                schedule_work(&priv->qos_activate);
 
-
        return 0;
 }
 
-
 static int rtl8192_handle_assoc_response(
                struct net_device *dev,
                struct ieee80211_assoc_response_frame *resp,
        return 0;
 }
 
-
 static void rtl8192_update_ratr_table(struct net_device *dev)
 {
        struct r8192_priv *priv = ieee80211_priv(dev);
 {
        struct r8192_priv *priv = ieee80211_priv(dev);
 
-
        INIT_WORK(&priv->reset_wq, rtl8192_restart);
 
        INIT_DELAYED_WORK(&priv->watch_dog_wq,
                break;
        }
 
-
        if (priv->rf_type == RF_1T2R)
                RT_TRACE(COMP_EPROM, "\n1T2R config\n");
        else
        /* Set Auto Rate fallback control */
 }
 
-
 /* InitializeAdapter and PhyCfg */
 static bool rtl8192_adapter_start(struct net_device *dev)
 {
                RT_TRACE(COMP_INIT, "%s():after phy RF config\n", __func__);
        }
 
-
        if (priv->ieee80211->FwRWRF)
                /* We can force firmware to do RF-R/W */
                priv->Rf_Mode = RF_OP_By_FW;
        else
                priv->Rf_Mode = RF_OP_By_SW_3wire;
 
-
        rtl8192_phy_updateInitGain(dev);
        /*--set CCK and OFDM Block "ON"--*/
        rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
        }
        write_nic_byte(dev, 0x87, 0x0);
 
-
        return init_status;
 }
 
        return RESET_TYPE_NORESET;
 }
 
-
 /**
  * This function is called by Checkforhang to check whether we should
  * ask OS to reset driver
 static int _rtl8192_up(struct net_device *dev);
 static int rtl8192_close(struct net_device *dev);
 
-
-
 static void CamRestoreAllEntry(struct net_device *dev)
 {
        u8 EntryId = 0;
 
        RT_TRACE(COMP_SEC, "%s:\n", __func__);
 
-
        if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40) ||
            (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104)) {
                for (EntryId = 0; EntryId < 4; EntryId++) {
                               MacAddr, 0, NULL);
        }
 
-
-
        if (priv->ieee80211->group_key_type == KEY_TYPE_TKIP) {
                MacAddr = CAM_CONST_BROAD;
                for (EntryId = 1; EntryId < 4; EntryId++) {
        int reset_status = 0;
        struct ieee80211_device *ieee = priv->ieee80211;
 
-
        /* If we need to check CCK stop, please uncomment this line. */
        /* bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter); */
 
        }
 }
 
-
 static void rtl819x_watchdog_wqcallback(struct work_struct *work)
 {
        struct delayed_work *dwork = to_delayed_work(work);
        return 0;
 }
 
-
 static int rtl8192_open(struct net_device *dev)
 {
        struct r8192_priv *priv = ieee80211_priv(dev);
        return ret;
 }
 
-
 int rtl8192_up(struct net_device *dev)
 {
        struct r8192_priv *priv = ieee80211_priv(dev);
        return _rtl8192_up(dev);
 }
 
-
 static int rtl8192_close(struct net_device *dev)
 {
        struct r8192_priv *priv = ieee80211_priv(dev);
        deinit_hal_dm(dev);
        del_timer_sync(&priv->watch_dog_timer);
 
-
        ieee80211_softmac_stop_protocol(priv->ieee80211);
        memset(&priv->ieee80211->current_network, 0,
               offsetof(struct ieee80211_network, list));
        return 0;
 }
 
-
 void rtl8192_commit(struct net_device *dev)
 {
        struct r8192_priv *priv = ieee80211_priv(dev);
                priv->promisc = promisc;
 }
 
-
 static int r8192_set_mac_adr(struct net_device *dev, void *mac)
 {
        struct r8192_priv *priv = ieee80211_priv(dev);
 
        mutex_lock(&priv->wx_mutex);
 
-
        if (p->length < sizeof(struct ieee_param) || !p->pointer) {
                ret = -EINVAL;
                goto out;
        return signal_power;
 }
 
-
 /* We can not declare RSSI/EVM total value of sliding window to
  * be a local static. Otherwise, it may increase when we return from S3/S4. The
  * value will be kept in memory or disk. Declare the value in the adaptor
        if (!bcheck)
                return;
 
-
        /* only rtl8190 supported
         * rtl8190_process_cck_rxpathsel(priv,pprevious_stats);
         */
 
        /* record the general signal strength to the sliding window. */
 
-
        /* <2> Showed on UI for engineering
         * hardware does not provide rssi information for each rf path in CCK
         */
                }
        }
 
-
        /* Check PWDB. */
        RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
                 pprevious_stats->bIsCCK ? "CCK" : "OFDM",
                 pprevious_stats->bIsCCK ? "CCK" : "OFDM",
                 pprevious_stats->RxPWDBAll);
 
-
        if (pprevious_stats->bPacketToSelf ||
            pprevious_stats->bPacketBeacon ||
            pprevious_stats->bToSelfBA) {
        u8      rf_rx_num = 0;
        u8      sq;
 
-
        priv->stats.numqry_phystatus++;
 
        is_cck_rate = rx_hal_is_cck_rate(pdrvinfo);
                        precord_stats->RxMIMOSignalStrength[i] = (u8)RSSI;
                }
 
-
                /* (2)PWDB, Average PWDB calculated by hardware
                 * (for rate adaptive)
                 */
                                evm & 0xff;
                }
 
-
                /* record rx statistics for debug */
                rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
                prxsc = (struct phy_ofdm_rx_status_rxsc_sgien_exintfflag *)
        ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
 }
 
-
 static void TranslateRxSignalStuff819xUsb(struct sk_buff *skb,
                                          struct ieee80211_rx_stats *pstats,
                                          struct rx_drvinfo_819x_usb  *pdrvinfo)
                        bToSelfBA = true;
        }
 
-
-
        if (bpacket_match_bssid)
                priv->stats.numpacket_matchbssid++;
        if (bpacket_toself)
        /* 1: short preamble/GI, 0: long preamble/GI */
        u32 preamble_guardinterval;
 
-
        if (stats->bCRC)
                rcvType = 2;
        else if (stats->bICV)
        priv->stats.received_rate_histogram[rcvType][rateIndex]++;
 }
 
-
 static void query_rxdesc_status(struct sk_buff *skb,
                                struct ieee80211_rx_stats *stats,
                                bool bIsRxAggrSubframe)
 
                stats->bShortPreamble = driver_info->SPLCP;
 
-
                UpdateReceivedRateHistogramStatistics8190(dev, stats);
 
                stats->bIsAMPDU = (driver_info->PartAggr == 1);
 #ifdef SW_CRC_CHECK
        SwCrcCheck();
 #endif
-
-
 }
 
 static void query_rx_cmdpkt_desc_status(struct sk_buff *skb,
        stats->ntotalfrag = 1;
 }
 
-
 static void rtl8192_rx_cmd(struct sk_buff *skb)
 {
        struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
        .ndo_start_xmit         = ieee80211_xmit,
 };
 
-
 /****************************************************************************
  *    ---------------------------- USB_STUFF---------------------------
  *****************************************************************************/
        RT_TRACE(COMP_INIT, "dev name=======> %s\n", dev->name);
        rtl8192_proc_init_one(dev);
 
-
        RT_TRACE(COMP_INIT, "Driver probe completed\n");
        return 0;
 
        cancel_work_sync(&priv->qos_activate);
 }
 
-
 static void rtl8192_usb_disconnect(struct usb_interface *intf)
 {
        struct net_device *dev = usb_get_intfdata(intf);
        return usb_register(&rtl8192_usb_driver);
 }
 
-
 static void __exit rtl8192_usb_module_exit(void)
 {
        usb_deregister(&rtl8192_usb_driver);
        write_nic_byte(dev, SECR,  SECR_value);
 }
 
-
 void setKey(struct net_device *dev, u8 EntryNo, u8 KeyIndex, u16 KeyType,
            u8 *MacAddr, u8 DefaultKey, u32 *KeyContent)
 {
        else
                usConfig |= BIT(15) | (KeyType << 2) | KeyIndex;
 
-
        for (i = 0; i < CAM_CONTENT_COUNT; i++) {
                TargetCommand  = i + CAM_CONTENT_COUNT * EntryNo;
                TargetCommand |= BIT(31) | BIT(16);