usb_write32(adapt, regaddr, data);
 }
 
-static u32 rf_serial_read(struct adapter *adapt,
-                       enum rf_radio_path rfpath, u32 offset)
+static u32 rf_serial_read(struct adapter *adapt, enum rf_radio_path rfpath, u32 offset)
 {
        u32 ret = 0;
        struct bb_reg_def *phyreg = &adapt->HalData->PHYRegDef[rfpath];
 }
 
 u32 rtw_hal_read_rfreg(struct adapter *adapt, enum rf_radio_path rf_path,
-                    u32 reg_addr, u32 bit_mask)
+                      u32 reg_addr, u32 bit_mask)
 {
        u32 original_value, bit_shift;
 
 }
 
 void phy_set_rf_reg(struct adapter *adapt, enum rf_radio_path rf_path,
-                    u32 reg_addr, u32 bit_mask, u32 data)
+                   u32 reg_addr, u32 bit_mask, u32 data)
 {
        u32 original_value, bit_shift;
 
 
        rtl88eu_phy_rf6052_set_cck_txpower(adapt, &cck_pwr[0]);
        rtl88eu_phy_rf6052_set_ofdm_txpower(adapt, &ofdm_pwr[0], &bw20_pwr[0],
-                                         &bw40_pwr[0], channel);
+                                           &bw40_pwr[0], channel);
 }
 
 static void phy_set_bw_mode_callback(struct adapter *adapt)
                 * These settings are required only for 40MHz
                 */
                phy_set_bb_reg(adapt, rCCK0_System, bCCKSideBand,
-                   (hal_data->nCur40MhzPrimeSC >> 1));
+                              (hal_data->nCur40MhzPrimeSC >> 1));
                phy_set_bb_reg(adapt, rOFDM1_LSTF, 0xC00,
                               hal_data->nCur40MhzPrimeSC);
                phy_set_bb_reg(adapt, 0x818, (BIT(26) | BIT(27)),
-                  (hal_data->nCur40MhzPrimeSC == HAL_PRIME_CHNL_OFFSET_LOWER) ? 2 : 1);
+                              (hal_data->nCur40MhzPrimeSC == HAL_PRIME_CHNL_OFFSET_LOWER) ? 2 : 1);
                break;
        default:
                break;
 }
 
 void rtw_hal_set_bwmode(struct adapter *adapt, enum ht_channel_width bandwidth,
-                    unsigned char offset)
+                       unsigned char offset)
 {
        struct hal_data_8188e *hal_data = adapt->HalData;
        enum ht_channel_width tmp_bw = hal_data->CurrentChannelBW;
                        thermal_val = (u8)(thermal_avg / thermal_avg_count);
 
                if (dm_odm->RFCalibrateInfo.bDoneTxpower &&
-                       !dm_odm->RFCalibrateInfo.bReloadtxpowerindex) {
+                   !dm_odm->RFCalibrateInfo.bReloadtxpowerindex) {
                        delta = abs(thermal_val - dm_odm->RFCalibrateInfo.ThermalValue);
                } else {
                        delta = abs(thermal_val - hal_data->EEPROMThermalMeter);
                /* 1. Read original RF mode */
                /* Path-A */
                rf_a_mode = rtw_hal_read_rfreg(adapt, RF_PATH_A, RF_AC,
-                                            bMask12Bits);
+                                              bMask12Bits);
 
                /* Path-B */
                if (is2t)
                        rf_b_mode = rtw_hal_read_rfreg(adapt, RF_PATH_B, RF_AC,
-                                                    bMask12Bits);
+                                                      bMask12Bits);
 
                /* 2. Set RF mode = standby mode */
                /* Path-A */
 
 typedef unsigned char   NDIS_802_11_RATES_EX[NDIS_802_11_LENGTH_RATES_EX];
 
 static int rtw_wx_get_name(struct net_device *dev,
-                            struct iw_request_info *info,
-                            union iwreq_data *wrqu, char *extra)
+                          struct iw_request_info *info,
+                          union iwreq_data *wrqu, char *extra)
 {
        struct adapter *padapter = rtw_netdev_priv(dev);
        u32 ht_ielen = 0;
 }
 
 static int rtw_wx_set_freq(struct net_device *dev,
-                            struct iw_request_info *info,
-                            union iwreq_data *wrqu, char *extra)
+                          struct iw_request_info *info,
+                          union iwreq_data *wrqu, char *extra)
 {
        RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_, ("+%s\n", __func__));
        return 0;
 }
 
 static int rtw_wx_get_freq(struct net_device *dev,
-                            struct iw_request_info *info,
-                            union iwreq_data *wrqu, char *extra)
+                          struct iw_request_info *info,
+                          union iwreq_data *wrqu, char *extra)
 {
        struct adapter *padapter = rtw_netdev_priv(dev);
        struct  mlme_priv       *pmlmepriv = &padapter->mlmepriv;
 }
 
 static int rtw_wx_set_mode(struct net_device *dev, struct iw_request_info *a,
-                            union iwreq_data *wrqu, char *b)
+                          union iwreq_data *wrqu, char *b)
 {
        struct adapter *padapter = rtw_netdev_priv(dev);
        enum ndis_802_11_network_infra networkType;
 }
 
 static int rtw_wx_get_mode(struct net_device *dev, struct iw_request_info *a,
-                            union iwreq_data *wrqu, char *b)
+                          union iwreq_data *wrqu, char *b)
 {
        struct adapter *padapter = rtw_netdev_priv(dev);
        struct  mlme_priv       *pmlmepriv = &padapter->mlmepriv;
 }
 
 static int rtw_wx_get_sens(struct net_device *dev,
-                            struct iw_request_info *info,
-                            union iwreq_data *wrqu, char *extra)
+                          struct iw_request_info *info,
+                          union iwreq_data *wrqu, char *extra)
 {
        wrqu->sens.value = 0;
        wrqu->sens.fixed = 0;   /* no auto select */
 }
 
 static int rtw_wx_get_range(struct net_device *dev,
-                               struct iw_request_info *info,
-                               union iwreq_data *wrqu, char *extra)
+                           struct iw_request_info *info,
+                           union iwreq_data *wrqu, char *extra)
 {
        struct iw_range *range = (struct iw_range *)extra;
        struct adapter *padapter = rtw_netdev_priv(dev);
 /* s3. set_802_11_encryption_mode() */
 /* s4. rtw_set_802_11_bssid() */
 static int rtw_wx_set_wap(struct net_device *dev,
-                        struct iw_request_info *info,
-                        union iwreq_data *awrq,
-                        char *extra)
+                         struct iw_request_info *info,
+                         union iwreq_data *awrq, char *extra)
 {
        uint ret = 0;
        struct adapter *padapter = rtw_netdev_priv(dev);
 }
 
 static int rtw_wx_get_wap(struct net_device *dev,
-                           struct iw_request_info *info,
-                           union iwreq_data *wrqu, char *extra)
+                         struct iw_request_info *info,
+                         union iwreq_data *wrqu, char *extra)
 {
        struct adapter *padapter = rtw_netdev_priv(dev);
        struct  mlme_priv       *pmlmepriv = &padapter->mlmepriv;
 }
 
 static int rtw_wx_set_mlme(struct net_device *dev,
-                            struct iw_request_info *info,
-                            union iwreq_data *wrqu, char *extra)
+                          struct iw_request_info *info,
+                          union iwreq_data *wrqu, char *extra)
 {
        int ret = 0;
        u16 reason;
 }
 
 static int rtw_wx_set_scan(struct net_device *dev, struct iw_request_info *a,
-                            union iwreq_data *wrqu, char *extra)
+                          union iwreq_data *wrqu, char *extra)
 {
        u8 _status = false;
        int ret = 0;
 }
 
 static int rtw_wx_get_scan(struct net_device *dev, struct iw_request_info *a,
-                            union iwreq_data *wrqu, char *extra)
+                          union iwreq_data *wrqu, char *extra)
 {
        struct list_head *plist, *phead;
        struct adapter *padapter = rtw_netdev_priv(dev);
 /* s3. set_802_11_encryption_mode() */
 /* s4. rtw_set_802_11_ssid() */
 static int rtw_wx_set_essid(struct net_device *dev,
-                             struct iw_request_info *a,
-                             union iwreq_data *wrqu, char *extra)
+                           struct iw_request_info *a,
+                           union iwreq_data *wrqu, char *extra)
 {
        struct adapter *padapter = rtw_netdev_priv(dev);
        struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 }
 
 static int rtw_wx_get_essid(struct net_device *dev,
-                             struct iw_request_info *a,
-                             union iwreq_data *wrqu, char *extra)
+                           struct iw_request_info *a,
+                           union iwreq_data *wrqu, char *extra)
 {
        u32 len;
        struct adapter *padapter = rtw_netdev_priv(dev);
 }
 
 static int rtw_wx_set_rate(struct net_device *dev,
-                             struct iw_request_info *a,
-                             union iwreq_data *wrqu, char *extra)
+                          struct iw_request_info *a,
+                          union iwreq_data *wrqu, char *extra)
 {
        int i;
        u8 datarates[NumRates];
 }
 
 static int rtw_wx_get_rate(struct net_device *dev,
-                            struct iw_request_info *info,
-                            union iwreq_data *wrqu, char *extra)
+                          struct iw_request_info *info,
+                          union iwreq_data *wrqu, char *extra)
 {
        u16 max_rate = 0;
 
 }
 
 static int rtw_wx_set_rts(struct net_device *dev,
-                            struct iw_request_info *info,
-                            union iwreq_data *wrqu, char *extra)
+                         struct iw_request_info *info,
+                         union iwreq_data *wrqu, char *extra)
 {
        struct adapter *padapter = rtw_netdev_priv(dev);
 
 }
 
 static int rtw_wx_get_rts(struct net_device *dev,
-                            struct iw_request_info *info,
-                            union iwreq_data *wrqu, char *extra)
+                         struct iw_request_info *info,
+                         union iwreq_data *wrqu, char *extra)
 {
        struct adapter *padapter = rtw_netdev_priv(dev);
 
 }
 
 static int rtw_wx_set_frag(struct net_device *dev,
-                            struct iw_request_info *info,
-                            union iwreq_data *wrqu, char *extra)
+                          struct iw_request_info *info,
+                          union iwreq_data *wrqu, char *extra)
 {
        struct adapter *padapter = rtw_netdev_priv(dev);
 
 }
 
 static int rtw_wx_get_frag(struct net_device *dev,
-                            struct iw_request_info *info,
-                            union iwreq_data *wrqu, char *extra)
+                          struct iw_request_info *info,
+                          union iwreq_data *wrqu, char *extra)
 {
        struct adapter *padapter = rtw_netdev_priv(dev);
 
 }
 
 static int rtw_wx_get_retry(struct net_device *dev,
-                            struct iw_request_info *info,
-                            union iwreq_data *wrqu, char *extra)
+                           struct iw_request_info *info,
+                           union iwreq_data *wrqu, char *extra)
 {
        wrqu->retry.value = 7;
        wrqu->retry.fixed = 0;  /* no auto select */
 }
 
 static int rtw_wx_set_enc(struct net_device *dev,
-                           struct iw_request_info *info,
-                           union iwreq_data *wrqu, char *keybuf)
+                         struct iw_request_info *info,
+                         union iwreq_data *wrqu, char *keybuf)
 {
        u32 key, ret = 0;
        u32 keyindex_provided;
 }
 
 static int rtw_wx_get_enc(struct net_device *dev,
-                           struct iw_request_info *info,
-                           union iwreq_data *wrqu, char *keybuf)
+                         struct iw_request_info *info,
+                         union iwreq_data *wrqu, char *keybuf)
 {
        uint key;
        struct adapter *padapter = rtw_netdev_priv(dev);
 }
 
 static int rtw_wx_get_power(struct net_device *dev,
-                            struct iw_request_info *info,
-                            union iwreq_data *wrqu, char *extra)
+                           struct iw_request_info *info,
+                           union iwreq_data *wrqu, char *extra)
 {
        wrqu->power.value = 0;
        wrqu->power.fixed = 0;  /* no auto select */
 }
 
 static int rtw_wx_set_auth(struct net_device *dev,
-                            struct iw_request_info *info,
-                            union iwreq_data *wrqu, char *extra)
+                          struct iw_request_info *info,
+                          union iwreq_data *wrqu, char *extra)
 {
        struct adapter *padapter = rtw_netdev_priv(dev);
        struct iw_param *param = (struct iw_param *)&wrqu->param;
 }
 
 static int rtw_wx_set_enc_ext(struct net_device *dev,
-                            struct iw_request_info *info,
-                            union iwreq_data *wrqu, char *extra)
+                             struct iw_request_info *info,
+                             union iwreq_data *wrqu, char *extra)
 {
        char *alg_name;
        u32 param_len;
                                DBG_88E("%s, set group_key, WEP\n", __func__);
 
                                memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
-                                           param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
+                                      param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
 
                                psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
                                if (param->u.crypt.key_len == 13)
                                DBG_88E("%s, set group_key, TKIP\n", __func__);
                                psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
                                memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
-                                           param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
+                                      param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
                                /* set mic key */
                                memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, ¶m->u.crypt.key[16], 8);
                                memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, ¶m->u.crypt.key[24], 8);
                                DBG_88E("%s, set group_key, CCMP\n", __func__);
                                psecuritypriv->dot118021XGrpPrivacy = _AES_;
                                memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
-                                           param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
+                                      param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
                        } else {
                                DBG_88E("%s, set group_key, none\n", __func__);
                                psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
                        } else { /* group key??? */
                                if (strcmp(param->u.crypt.alg, "WEP") == 0) {
                                        memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
-                                                   param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
+                                              param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
                                        psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
                                        if (param->u.crypt.key_len == 13)
                                                psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
                                        psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
 
                                        memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
-                                                   param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
+                                              param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
 
                                        /* set mic key */
                                        memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, ¶m->u.crypt.key[16], 8);
                                        psecuritypriv->dot118021XGrpPrivacy = _AES_;
 
                                        memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
-                                                   param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
+                                              param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
                                } else {
                                        psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
                                }
 
 #include <rtw_android.h>
 static int rtw_wx_set_priv(struct net_device *dev,
-                               struct iw_request_info *info,
-                               union iwreq_data *awrq,
-                               char *extra)
+                          struct iw_request_info *info,
+                          union iwreq_data *awrq, char *extra)
 {
        int ret = 0;
        int len = 0;
 
        if (dvobj) {
                /* Modify condition for 92DU DMDP 2010.11.18, by Thomas */
                if ((dvobj->NumInterfaces != 2 &&
-                   dvobj->NumInterfaces != 3) ||
+                    dvobj->NumInterfaces != 3) ||
                    (dvobj->InterfaceNumber == 1)) {
                        if (interface_to_usbdev(usb_intf)->state !=
                            USB_STATE_NOTATTACHED) {
        if ((!padapter->bup) || (padapter->bDriverStopped) ||
            (padapter->bSurpriseRemoved)) {
                pr_debug("padapter->bup=%d bDriverStopped=%d bSurpriseRemoved = %d\n",
-                       padapter->bup, padapter->bDriverStopped,
-                       padapter->bSurpriseRemoved);
+                        padapter->bup, padapter->bDriverStopped,
+                        padapter->bSurpriseRemoved);
                goto exit;
        }
 
        if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) &&
            check_fwstate(pmlmepriv, _FW_LINKED)) {
                pr_debug("%s:%d %s(%pM), length:%d assoc_ssid.length:%d\n",
-                       __func__, __LINE__,
-                       pmlmepriv->cur_network.network.ssid.ssid,
-                       pmlmepriv->cur_network.network.MacAddress,
-                       pmlmepriv->cur_network.network.ssid.ssid_length,
-                       pmlmepriv->assoc_ssid.ssid_length);
+                        __func__, __LINE__,
+                        pmlmepriv->cur_network.network.ssid.ssid,
+                        pmlmepriv->cur_network.network.MacAddress,
+                        pmlmepriv->cur_network.network.ssid.ssid_length,
+                        pmlmepriv->assoc_ssid.ssid_length);
 
                pmlmepriv->to_roaming = 1;
        }
        if (pwrpriv)
                pwrpriv->bInSuspend = false;
        pr_debug("<===  %s return %d.............. in %dms\n", __func__,
-               ret, jiffies_to_msecs(jiffies - start_time));
+                ret, jiffies_to_msecs(jiffies - start_time));
 
        return ret;
 }
  */
 
 static struct adapter *rtw_usb_if1_init(struct dvobj_priv *dvobj,
-       struct usb_interface *pusb_intf, const struct usb_device_id *pdid)
+                                       struct usb_interface *pusb_intf,
+                                       const struct usb_device_id *pdid)
 {
        struct adapter *padapter = NULL;
        struct net_device *pnetdev = NULL;
                device_init_wakeup(&pusb_intf->dev, 1);
                pr_debug("\n  padapter->pwrctrlpriv.bSupportRemoteWakeup~~~~~~\n");
                pr_debug("\n  padapter->pwrctrlpriv.bSupportRemoteWakeup~~~[%d]~~~\n",
-                       device_may_wakeup(&pusb_intf->dev));
+                        device_may_wakeup(&pusb_intf->dev));
        }
 #endif
 
        rtw_macaddr_cfg(padapter->eeprompriv.mac_addr);
        memcpy(pnetdev->dev_addr, padapter->eeprompriv.mac_addr, ETH_ALEN);
        pr_debug("MAC Address from pnetdev->dev_addr =  %pM\n",
-               pnetdev->dev_addr);
+                pnetdev->dev_addr);
 
        /* step 6. Tell the network stack we exist */
        if (register_netdev(pnetdev) != 0) {
 
        rtw_dev_unload(if1);
        pr_debug("+r871xu_dev_remove, hw_init_completed=%d\n",
-               if1->hw_init_completed);
+                if1->hw_init_completed);
        rtw_free_drv_sw(if1);
        rtw_free_netdev(pnetdev);
 }