1 files changed, 122 insertions, 137 deletions

diff --git a/drivers/net/wireless/rtlwifi/rtl8188ee/fw.c b/drivers/net/wireless/rtlwifi/rtl8188ee/fw.c
index 4f9376ad4739..c8058aa73ecf 100644
--- a/drivers/net/wireless/rtlwifi/rtl8188ee/fw.c
+++ b/drivers/net/wireless/rtlwifi/rtl8188ee/fw.c
@@ -11,10 +11,6 @@
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  * more details.
  *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
- *
  * The full GNU General Public License is included in this distribution in the
  * file called LICENSE.
  *
@@ -30,12 +26,11 @@
 #include "../wifi.h"
 #include "../pci.h"
 #include "../base.h"
+#include "../core.h"
 #include "reg.h"
 #include "def.h"
 #include "fw.h"
 
-#include <linux/kmemleak.h>
-
 static void _rtl88e_enable_fw_download(struct ieee80211_hw *hw, bool enable)
 {
         struct rtl_priv *rtlpriv = rtl_priv(hw);
@@ -62,26 +57,26 @@ static void _rtl88e_fw_block_write(struct ieee80211_hw *hw,
                                    const u8 *buffer, u32 size)
 {
         struct rtl_priv *rtlpriv = rtl_priv(hw);
-        u32 blk_sz = sizeof(u32);
-        u8 *buf_ptr = (u8 *)buffer;
+        u32 blocksize = sizeof(u32);
+        u8 *bufferptr = (u8 *)buffer;
         u32 *pu4BytePtr = (u32 *)buffer;
-        u32 i, offset, blk_cnt, remain;
+        u32 i, offset, blockcount, remainsize;
 
-        blk_cnt = size / blk_sz;
-        remain = size % blk_sz;
+        blockcount = size / blocksize;
+        remainsize = size % blocksize;
 
-        for (i = 0; i < blk_cnt; i++) {
-                offset = i * blk_sz;
+        for (i = 0; i < blockcount; i++) {
+                offset = i * blocksize;
                 rtl_write_dword(rtlpriv, (FW_8192C_START_ADDRESS + offset),
                                 *(pu4BytePtr + i));
         }
 
-        if (remain) {
-                offset = blk_cnt * blk_sz;
-                buf_ptr += offset;
-                for (i = 0; i < remain; i++) {
+        if (remainsize) {
+                offset = blockcount * blocksize;
+                bufferptr += offset;
+                for (i = 0; i < remainsize; i++) {
                         rtl_write_byte(rtlpriv, (FW_8192C_START_ADDRESS +
-                                                 offset + i), *(buf_ptr + i));
+                                                 offset + i), *(bufferptr + i));
                 }
         }
 }
@@ -119,32 +114,33 @@ static void _rtl88e_write_fw(struct ieee80211_hw *hw,
                              enum version_8188e version, u8 *buffer, u32 size)
 {
         struct rtl_priv *rtlpriv = rtl_priv(hw);
-        u8 *buf_ptr = buffer;
-        u32 page_no, remain;
+        u8 *bufferptr = (u8 *)buffer;
+        u32 pagenums, remainsize;
         u32 page, offset;
 
         RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD, "FW size is %d bytes,\n", size);
 
-        _rtl88e_fill_dummy(buf_ptr, &size);
+        _rtl88e_fill_dummy(bufferptr, &size);
 
-        page_no = size / FW_8192C_PAGE_SIZE;
-        remain = size % FW_8192C_PAGE_SIZE;
+        pagenums = size / FW_8192C_PAGE_SIZE;
+        remainsize = size % FW_8192C_PAGE_SIZE;
 
-        if (page_no > 8) {
+        if (pagenums > 8) {
                 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
                          "Page numbers should not greater then 8\n");
         }
 
-        for (page = 0; page < page_no; page++) {
+        for (page = 0; page < pagenums; page++) {
                 offset = page * FW_8192C_PAGE_SIZE;
-                _rtl88e_fw_page_write(hw, page, (buf_ptr + offset),
+                _rtl88e_fw_page_write(hw, page, (bufferptr + offset),
                                       FW_8192C_PAGE_SIZE);
         }
 
-        if (remain) {
-                offset = page_no * FW_8192C_PAGE_SIZE;
-                page = page_no;
-                _rtl88e_fw_page_write(hw, page, (buf_ptr + offset), remain);
+        if (remainsize) {
+                offset = pagenums * FW_8192C_PAGE_SIZE;
+                page = pagenums;
+                _rtl88e_fw_page_write(hw, page, (bufferptr + offset),
+                                      remainsize);
         }
 }
 
@@ -199,7 +195,8 @@ exit:
         return err;
 }
 
-int rtl88e_download_fw(struct ieee80211_hw *hw, bool buse_wake_on_wlan_fw)
+int rtl88e_download_fw(struct ieee80211_hw *hw,
+                       bool buse_wake_on_wlan_fw)
 {
         struct rtl_priv *rtlpriv = rtl_priv(hw);
         struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
@@ -221,8 +218,8 @@ int rtl88e_download_fw(struct ieee80211_hw *hw, bool buse_wake_on_wlan_fw)
         if (IS_FW_HEADER_EXIST(pfwheader)) {
                 RT_TRACE(rtlpriv, COMP_FW, DBG_DMESG,
                          "Firmware Version(%d), Signature(%#x), Size(%d)\n",
-                         pfwheader->version, pfwheader->signature,
-                         (int)sizeof(struct rtl92c_firmware_header));
+                          pfwheader->version, pfwheader->signature,
+                          (int)sizeof(struct rtl92c_firmware_header));
 
                 pfwdata = pfwdata + sizeof(struct rtl92c_firmware_header);
                 fwsize = fwsize - sizeof(struct rtl92c_firmware_header);
@@ -237,9 +234,14 @@ int rtl88e_download_fw(struct ieee80211_hw *hw, bool buse_wake_on_wlan_fw)
         _rtl88e_enable_fw_download(hw, false);
 
         err = _rtl88e_fw_free_to_go(hw);
+        if (err) {
+                RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
+                         "Firmware is not ready to run!\n");
+        } else {
+                RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD,
+                         "Firmware is ready to run!\n");
+        }
 
-        RT_TRACE(rtlpriv, COMP_FW, DBG_DMESG,
-                 "Firmware is%s ready to run!\n", err ? " not" : "");
         return 0;
 }
 
@@ -266,9 +268,9 @@ static void _rtl88e_fill_h2c_command(struct ieee80211_hw *hw,
         bool isfw_read = false;
         u8 buf_index = 0;
         bool write_sucess = false;
-        u8 wait_h2c_limit = 100;
+        u8 wait_h2c_limmit = 100;
         u8 wait_writeh2c_limit = 100;
-        u8 boxc[4], boxext[2];
+        u8 boxcontent[4], boxextcontent[4];
         u32 h2c_waitcounter = 0;
         unsigned long flag;
         u8 idx;
@@ -331,18 +333,17 @@ static void _rtl88e_fill_h2c_command(struct ieee80211_hw *hw,
                         box_extreg = REG_HMEBOX_EXT_3;
                         break;
                 default:
-                        RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
-                                 "switch case not processed\n");
+                        RT_TRACE(rtlpriv, COMP_ERR, DBG_LOUD,
+                                 "switch case not process\n");
                         break;
                 }
-
                 isfw_read = _rtl88e_check_fw_read_last_h2c(hw, boxnum);
                 while (!isfw_read) {
-                        wait_h2c_limit--;
-                        if (wait_h2c_limit == 0) {
+                        wait_h2c_limmit--;
+                        if (wait_h2c_limmit == 0) {
                                 RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD,
-                                         "Waiting too long for FW read "
-                                         "clear HMEBox(%d)!\n", boxnum);
+                                         "Waiting too long for FW read clear HMEBox(%d)!\n",
+                                         boxnum);
                                 break;
                         }
 
@@ -351,20 +352,20 @@ static void _rtl88e_fill_h2c_command(struct ieee80211_hw *hw,
                         isfw_read = _rtl88e_check_fw_read_last_h2c(hw, boxnum);
                         u1b_tmp = rtl_read_byte(rtlpriv, 0x130);
                         RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD,
-                                 "Waiting for FW read clear HMEBox(%d)!!! "
-                                 "0x130 = %2x\n", boxnum, u1b_tmp);
+                                 "Waiting for FW read clear HMEBox(%d)!!! 0x130 = %2x\n",
+                                 boxnum, u1b_tmp);
                 }
 
                 if (!isfw_read) {
                         RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD,
-                                 "Write H2C register BOX[%d] fail!!!!! "
-                                 "Fw do not read.\n", boxnum);
+                                 "Write H2C register BOX[%d] fail!!!!! Fw do not read.\n",
+                                 boxnum);
                         break;
                 }
 
-                memset(boxc, 0, sizeof(boxc));
-                memset(boxext, 0, sizeof(boxext));
-                boxc[0] = element_id;
+                memset(boxcontent, 0, sizeof(boxcontent));
+                memset(boxextcontent, 0, sizeof(boxextcontent));
+                boxcontent[0] = element_id;
                 RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD,
                          "Write element_id box_reg(%4x) = %2x\n",
                          box_reg, element_id);
@@ -373,33 +374,38 @@ static void _rtl88e_fill_h2c_command(struct ieee80211_hw *hw,
                 case 1:
                 case 2:
                 case 3:
-                        /*boxc[0] &= ~(BIT(7));*/
-                        memcpy((u8 *)(boxc) + 1, cmd_b + buf_index, cmd_len);
+                        /*boxcontent[0] &= ~(BIT(7));*/
+                        memcpy((u8 *)(boxcontent) + 1,
+                               cmd_b + buf_index, cmd_len);
 
-                        for (idx = 0; idx < 4; idx++)
-                                rtl_write_byte(rtlpriv, box_reg+idx, boxc[idx]);
+                        for (idx = 0; idx < 4; idx++) {
+                                rtl_write_byte(rtlpriv, box_reg + idx,
+                                               boxcontent[idx]);
+                        }
                         break;
                 case 4:
                 case 5:
                 case 6:
                 case 7:
-                        /*boxc[0] |= (BIT(7));*/
-                        memcpy((u8 *)(boxext), cmd_b + buf_index+3, cmd_len-3);
-                        memcpy((u8 *)(boxc) + 1, cmd_b + buf_index, 3);
+                        /*boxcontent[0] |= (BIT(7));*/
+                        memcpy((u8 *)(boxextcontent),
+                               cmd_b + buf_index+3, cmd_len-3);
+                        memcpy((u8 *)(boxcontent) + 1,
+                               cmd_b + buf_index, 3);
 
                         for (idx = 0; idx < 2; idx++) {
                                 rtl_write_byte(rtlpriv, box_extreg + idx,
-                                               boxext[idx]);
+                                               boxextcontent[idx]);
                         }
 
                         for (idx = 0; idx < 4; idx++) {
                                 rtl_write_byte(rtlpriv, box_reg + idx,
-                                               boxc[idx]);
+                                               boxcontent[idx]);
                         }
                         break;
                 default:
-                        RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
-                                 "switch case not processed\n");
+                        RT_TRACE(rtlpriv, COMP_ERR, DBG_LOUD,
+                                 "switch case not process\n");
                         break;
                 }
 
@@ -411,7 +417,7 @@ static void _rtl88e_fill_h2c_command(struct ieee80211_hw *hw,
 
                 RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD,
                          "pHalData->last_hmeboxnum  = %d\n",
-                         rtlhal->last_hmeboxnum);
+                          rtlhal->last_hmeboxnum);
         }
 
         spin_lock_irqsave(&rtlpriv->locks.h2c_lock, flag);
@@ -422,18 +428,19 @@ static void _rtl88e_fill_h2c_command(struct ieee80211_hw *hw,
 }
 
 void rtl88e_fill_h2c_cmd(struct ieee80211_hw *hw,
-                         u8 element_id, u32 cmd_len, u8 *cmd_b)
+                         u8 element_id, u32 cmd_len, u8 *cmdbuffer)
 {
         struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
         u32 tmp_cmdbuf[2];
 
-        if (rtlhal->fw_ready == false) {
-                RT_ASSERT(false, "fail H2C cmd - Fw download fail!!!\n");
+        if (!rtlhal->fw_ready) {
+                RT_ASSERT(false,
+                          "return H2C cmd because of Fw download fail!!!\n");
                 return;
         }
 
         memset(tmp_cmdbuf, 0, 8);
-        memcpy(tmp_cmdbuf, cmd_b, cmd_len);
+        memcpy(tmp_cmdbuf, cmdbuffer, cmd_len);
         _rtl88e_fill_h2c_command(hw, element_id, cmd_len, (u8 *)&tmp_cmdbuf);
 
         return;
@@ -448,7 +455,8 @@ void rtl88e_firmware_selfreset(struct ieee80211_hw *hw)
         rtl_write_byte(rtlpriv, REG_SYS_FUNC_EN+1, (u1b_tmp & (~BIT(2))));
         rtl_write_byte(rtlpriv, REG_SYS_FUNC_EN+1, (u1b_tmp | BIT(2)));
         RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
-                 "8051Reset88E(): 8051 reset success.\n");
+                 "8051Reset88E(): 8051 reset success\n");
+
 }
 
 void rtl88e_set_fw_pwrmode_cmd(struct ieee80211_hw *hw, u8 mode)
@@ -456,28 +464,29 @@ void rtl88e_set_fw_pwrmode_cmd(struct ieee80211_hw *hw, u8 mode)
         struct rtl_priv *rtlpriv = rtl_priv(hw);
         u8 u1_h2c_set_pwrmode[H2C_88E_PWEMODE_LENGTH] = { 0 };
         struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
-        u8 power_state = 0;
-
+        u8 rlbm, power_state = 0;
         RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, "FW LPS mode = %d\n", mode);
+
         SET_H2CCMD_PWRMODE_PARM_MODE(u1_h2c_set_pwrmode, ((mode) ? 1 : 0));
-        SET_H2CCMD_PWRMODE_PARM_RLBM(u1_h2c_set_pwrmode, 0);
+        rlbm = 0;/*YJ, temp, 120316. FW now not support RLBM=2.*/
+        SET_H2CCMD_PWRMODE_PARM_RLBM(u1_h2c_set_pwrmode, rlbm);
         SET_H2CCMD_PWRMODE_PARM_SMART_PS(u1_h2c_set_pwrmode,
-                                         (rtlpriv->mac80211.p2p) ?
-                                         ppsc->smart_ps : 1);
+                (rtlpriv->mac80211.p2p) ? ppsc->smart_ps : 1);
         SET_H2CCMD_PWRMODE_PARM_AWAKE_INTERVAL(u1_h2c_set_pwrmode,
-                                               ppsc->reg_max_lps_awakeintvl);
+                ppsc->reg_max_lps_awakeintvl);
         SET_H2CCMD_PWRMODE_PARM_ALL_QUEUE_UAPSD(u1_h2c_set_pwrmode, 0);
         if (mode == FW_PS_ACTIVE_MODE)
                 power_state |= FW_PWR_STATE_ACTIVE;
         else
                 power_state |= FW_PWR_STATE_RF_OFF;
+
         SET_H2CCMD_PWRMODE_PARM_PWR_STATE(u1_h2c_set_pwrmode, power_state);
 
         RT_PRINT_DATA(rtlpriv, COMP_CMD, DBG_DMESG,
                       "rtl92c_set_fw_pwrmode(): u1_h2c_set_pwrmode\n",
                       u1_h2c_set_pwrmode, H2C_88E_PWEMODE_LENGTH);
-        rtl88e_fill_h2c_cmd(hw, H2C_88E_SETPWRMODE, H2C_88E_PWEMODE_LENGTH,
-                            u1_h2c_set_pwrmode);
+        rtl88e_fill_h2c_cmd(hw, H2C_88E_SETPWRMODE,
+                            H2C_88E_PWEMODE_LENGTH, u1_h2c_set_pwrmode);
 }
 
 void rtl88e_set_fw_joinbss_report_cmd(struct ieee80211_hw *hw, u8 mstatus)
@@ -499,39 +508,9 @@ void rtl88e_set_fw_ap_off_load_cmd(struct ieee80211_hw *hw,
         SET_H2CCMD_AP_OFFLOAD_HIDDEN(u1_apoffload_parm, mac->hiddenssid);
         SET_H2CCMD_AP_OFFLOAD_DENYANY(u1_apoffload_parm, 0);
 
-        rtl88e_fill_h2c_cmd(hw, H2C_88E_AP_OFFLOAD, H2C_88E_AP_OFFLOAD_LENGTH,
-                            u1_apoffload_parm);
-}
+        rtl88e_fill_h2c_cmd(hw, H2C_88E_AP_OFFLOAD,
+                            H2C_88E_AP_OFFLOAD_LENGTH, u1_apoffload_parm);
 
-static bool _rtl88e_cmd_send_packet(struct ieee80211_hw *hw,
-                                    struct sk_buff *skb)
-{
-        struct rtl_priv *rtlpriv = rtl_priv(hw);
-        struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
-        struct rtl8192_tx_ring *ring;
-        struct rtl_tx_desc *pdesc;
-        struct sk_buff *pskb = NULL;
-        unsigned long flags;
-
-        ring = &rtlpci->tx_ring[BEACON_QUEUE];
-
-        pskb = __skb_dequeue(&ring->queue);
-        if (pskb)
-                kfree_skb(pskb);
-
-        spin_lock_irqsave(&rtlpriv->locks.irq_th_lock, flags);
-
-        pdesc = &ring->desc[0];
-
-        rtlpriv->cfg->ops->fill_tx_cmddesc(hw, (u8 *)pdesc, 1, 1, skb);
-
-        __skb_queue_tail(&ring->queue, skb);
-
-        spin_unlock_irqrestore(&rtlpriv->locks.irq_th_lock, flags);
-
-        rtlpriv->cfg->ops->tx_polling(hw, BEACON_QUEUE);
-
-        return true;
 }
 
 #define BEACON_PG               0 /* ->1 */
@@ -656,14 +635,15 @@ void rtl88e_set_fw_rsvdpagepkt(struct ieee80211_hw *hw, bool b_dl_finished)
         struct rtl_priv *rtlpriv = rtl_priv(hw);
         struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
         struct sk_buff *skb = NULL;
-
         u32 totalpacketlen;
-        u8 u1RsvdPageLoc[5] = { 0 };
-
+        bool rtstatus;
+        u8 u1rsvdpageloc[5] = { 0 };
+        bool b_dlok = false;
         u8 *beacon;
-        u8 *pspoll;
+        u8 *p_pspoll;
         u8 *nullfunc;
-        u8 *probersp;
+        u8 *p_probersp;
+
         /*---------------------------------------------------------
          *                      (1) beacon
          *---------------------------------------------------------
@@ -676,12 +656,12 @@ void rtl88e_set_fw_rsvdpagepkt(struct ieee80211_hw *hw, bool b_dl_finished)
          *                      (2) ps-poll
          *--------------------------------------------------------
          */
-        pspoll = &reserved_page_packet[PSPOLL_PG * 128];
-        SET_80211_PS_POLL_AID(pspoll, (mac->assoc_id | 0xc000));
-        SET_80211_PS_POLL_BSSID(pspoll, mac->bssid);
-        SET_80211_PS_POLL_TA(pspoll, mac->mac_addr);
+        p_pspoll = &reserved_page_packet[PSPOLL_PG * 128];
+        SET_80211_PS_POLL_AID(p_pspoll, (mac->assoc_id | 0xc000));
+        SET_80211_PS_POLL_BSSID(p_pspoll, mac->bssid);
+        SET_80211_PS_POLL_TA(p_pspoll, mac->mac_addr);
 
-        SET_H2CCMD_RSVDPAGE_LOC_PSPOLL(u1RsvdPageLoc, PSPOLL_PG);
+        SET_H2CCMD_RSVDPAGE_LOC_PSPOLL(u1rsvdpageloc, PSPOLL_PG);
 
         /*--------------------------------------------------------
          *                      (3) null data
@@ -692,18 +672,18 @@ void rtl88e_set_fw_rsvdpagepkt(struct ieee80211_hw *hw, bool b_dl_finished)
         SET_80211_HDR_ADDRESS2(nullfunc, mac->mac_addr);
         SET_80211_HDR_ADDRESS3(nullfunc, mac->bssid);
 
-        SET_H2CCMD_RSVDPAGE_LOC_NULL_DATA(u1RsvdPageLoc, NULL_PG);
+        SET_H2CCMD_RSVDPAGE_LOC_NULL_DATA(u1rsvdpageloc, NULL_PG);
 
         /*---------------------------------------------------------
          *                      (4) probe response
          *----------------------------------------------------------
          */
-        probersp = &reserved_page_packet[PROBERSP_PG * 128];
-        SET_80211_HDR_ADDRESS1(probersp, mac->bssid);
-        SET_80211_HDR_ADDRESS2(probersp, mac->mac_addr);
-        SET_80211_HDR_ADDRESS3(probersp, mac->bssid);
+        p_probersp = &reserved_page_packet[PROBERSP_PG * 128];
+        SET_80211_HDR_ADDRESS1(p_probersp, mac->bssid);
+        SET_80211_HDR_ADDRESS2(p_probersp, mac->mac_addr);
+        SET_80211_HDR_ADDRESS3(p_probersp, mac->bssid);
 
-        SET_H2CCMD_RSVDPAGE_LOC_PROBE_RSP(u1RsvdPageLoc, PROBERSP_PG);
+        SET_H2CCMD_RSVDPAGE_LOC_PROBE_RSP(u1rsvdpageloc, PROBERSP_PG);
 
         totalpacketlen = TOTAL_RESERVED_PKT_LEN;
 
@@ -712,33 +692,36 @@ void rtl88e_set_fw_rsvdpagepkt(struct ieee80211_hw *hw, bool b_dl_finished)
                       &reserved_page_packet[0], totalpacketlen);
         RT_PRINT_DATA(rtlpriv, COMP_CMD, DBG_DMESG,
                       "rtl88e_set_fw_rsvdpagepkt(): HW_VAR_SET_TX_CMD: ALL\n",
-                      u1RsvdPageLoc, 3);
+                      u1rsvdpageloc, 3);
 
         skb = dev_alloc_skb(totalpacketlen);
-        if (!skb)
-                return;
-        kmemleak_not_leak(skb);
         memcpy(skb_put(skb, totalpacketlen),
                &reserved_page_packet, totalpacketlen);
 
-        if (_rtl88e_cmd_send_packet(hw, skb)) {
+        rtstatus = rtl_cmd_send_packet(hw, skb);
+
+        if (rtstatus)
+                b_dlok = true;
+
+        if (b_dlok) {
                 RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD,
                          "Set RSVD page location to Fw.\n");
                 RT_PRINT_DATA(rtlpriv, COMP_CMD, DBG_DMESG,
-                              "H2C_RSVDPAGE:\n", u1RsvdPageLoc, 3);
+                              "H2C_RSVDPAGE:\n", u1rsvdpageloc, 3);
                 rtl88e_fill_h2c_cmd(hw, H2C_88E_RSVDPAGE,
-                                    sizeof(u1RsvdPageLoc), u1RsvdPageLoc);
+                                    sizeof(u1rsvdpageloc), u1rsvdpageloc);
         } else
                 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
                          "Set RSVD page location to Fw FAIL!!!!!!.\n");
 }
 
-/*Shoud check FW support p2p or not.*/
+/*Should check FW support p2p or not.*/
 static void rtl88e_set_p2p_ctw_period_cmd(struct ieee80211_hw *hw, u8 ctwindow)
 {
-        u8 u1_ctwindow_period[1] = {ctwindow};
+        u8 u1_ctwindow_period[1] = { ctwindow};
 
         rtl88e_fill_h2c_cmd(hw, H2C_88E_P2P_PS_CTW_CMD, 1, u1_ctwindow_period);
+
 }
 
 void rtl88e_set_p2p_ps_offload_cmd(struct ieee80211_hw *hw, u8 p2p_ps_state)
@@ -755,7 +738,7 @@ void rtl88e_set_p2p_ps_offload_cmd(struct ieee80211_hw *hw, u8 p2p_ps_state)
         switch (p2p_ps_state) {
         case P2P_PS_DISABLE:
                 RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD, "P2P_PS_DISABLE\n");
-                memset(p2p_ps_offload, 0, sizeof(struct p2p_ps_offload_t));
+                memset(p2p_ps_offload, 0, sizeof(*p2p_ps_offload));
                 break;
         case P2P_PS_ENABLE:
                 RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD, "P2P_PS_ENABLE\n");
@@ -765,8 +748,9 @@ void rtl88e_set_p2p_ps_offload_cmd(struct ieee80211_hw *hw, u8 p2p_ps_state)
                         ctwindow = p2pinfo->ctwindow;
                         rtl88e_set_p2p_ctw_period_cmd(hw, ctwindow);
                 }
+
                 /* hw only support 2 set of NoA */
-                for (i = 0; i < p2pinfo->noa_num; i++) {
+                for (i = 0 ; i < p2pinfo->noa_num; i++) {
                         /* To control the register setting for which NOA*/
                         rtl_write_byte(rtlpriv, 0x5cf, (i << 4));
                         if (i == 0)
@@ -785,7 +769,7 @@ void rtl88e_set_p2p_ps_offload_cmd(struct ieee80211_hw *hw, u8 p2p_ps_state)
 
                         start_time = p2pinfo->noa_start_time[i];
                         if (p2pinfo->noa_count_type[i] != 1) {
-                                while (start_time <= (tsf_low + (50 * 1024))) {
+                                while (start_time <= (tsf_low+(50*1024))) {
                                         start_time += p2pinfo->noa_interval[i];
                                         if (p2pinfo->noa_count_type[i] != 255)
                                                 p2pinfo->noa_count_type[i]--;
@@ -804,7 +788,7 @@ void rtl88e_set_p2p_ps_offload_cmd(struct ieee80211_hw *hw, u8 p2p_ps_state)
 
                         if (P2P_ROLE_GO == rtlpriv->mac80211.p2p) {
                                 p2p_ps_offload->role = 1;
-                                p2p_ps_offload->allstasleep = 0;
+                                p2p_ps_offload->allstasleep = -1;
                         } else {
                                 p2p_ps_offload->role = 0;
                         }
@@ -827,4 +811,5 @@ void rtl88e_set_p2p_ps_offload_cmd(struct ieee80211_hw *hw, u8 p2p_ps_state)
 
         rtl88e_fill_h2c_cmd(hw, H2C_88E_P2P_PS_OFFLOAD, 1,
                             (u8 *)p2p_ps_offload);
+
 }