]> Git Repo - linux.git/commitdiff
Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
authorJohn W. Linville <[email protected]>
Fri, 16 Mar 2012 17:45:25 +0000 (13:45 -0400)
committerJohn W. Linville <[email protected]>
Fri, 16 Mar 2012 17:45:25 +0000 (13:45 -0400)
Conflicts:
drivers/net/wireless/ath/ath9k/hw.c

1  2 
drivers/net/wireless/ath/ath9k/hw.c
drivers/net/wireless/iwlwifi/iwl-agn-lib.c
drivers/net/wireless/iwlwifi/iwl-trans-pcie-tx.c
drivers/net/wireless/mwifiex/pcie.c
drivers/net/wireless/mwifiex/sdio.c

index 2eb0ef315e315386d499ba702555be6bbdd32e55,3022c4e4d103008657569727b8608ae523eebb53..6c69e4e8b1cb7ca85b6710aecb8fbe3cba1e10c9
@@@ -449,6 -449,7 +449,7 @@@ static void ath9k_hw_init_defaults(stru
        ah->slottime = ATH9K_SLOT_TIME_9;
        ah->globaltxtimeout = (u32) -1;
        ah->power_mode = ATH9K_PM_UNDEFINED;
+       ah->htc_reset_init = true;
  }
  
  static int ath9k_hw_init_macaddr(struct ath_hw *ah)
@@@ -555,7 -556,7 +556,7 @@@ static int __ath9k_hw_init(struct ath_h
                return -EIO;
        }
  
-       if (ah->config.serialize_regmode == SER_REG_MODE_AUTO) {
+       if (NR_CPUS > 1 && ah->config.serialize_regmode == SER_REG_MODE_AUTO) {
                if (ah->hw_version.macVersion == AR_SREV_VERSION_5416_PCI ||
                    ((AR_SREV_9160(ah) || AR_SREV_9280(ah)) &&
                     !ah->is_pciexpress)) {
        if (!ah->is_pciexpress)
                ath9k_hw_disablepcie(ah);
  
-       if (!AR_SREV_9300_20_OR_LATER(ah))
-               ar9002_hw_cck_chan14_spread(ah);
        r = ath9k_hw_post_init(ah);
        if (r)
                return r;
@@@ -1521,17 -1519,81 +1519,81 @@@ bool ath9k_hw_check_alive(struct ath_h
  }
  EXPORT_SYMBOL(ath9k_hw_check_alive);
  
+ /*
+  * Fast channel change:
+  * (Change synthesizer based on channel freq without resetting chip)
+  *
+  * Don't do FCC when
+  *   - Flag is not set
+  *   - Chip is just coming out of full sleep
+  *   - Channel to be set is same as current channel
+  *   - Channel flags are different, (eg.,moving from 2GHz to 5GHz channel)
+  */
+ static int ath9k_hw_do_fastcc(struct ath_hw *ah, struct ath9k_channel *chan)
+ {
+       struct ath_common *common = ath9k_hw_common(ah);
+       int ret;
+       if (AR_SREV_9280(ah) && common->bus_ops->ath_bus_type == ATH_PCI)
+               goto fail;
+       if (ah->chip_fullsleep)
+               goto fail;
+       if (!ah->curchan)
+               goto fail;
+       if (chan->channel == ah->curchan->channel)
+               goto fail;
+       if ((chan->channelFlags & CHANNEL_ALL) !=
+           (ah->curchan->channelFlags & CHANNEL_ALL))
+               goto fail;
+       if (!ath9k_hw_check_alive(ah))
+               goto fail;
+       /*
+        * For AR9462, make sure that calibration data for
+        * re-using are present.
+        */
+       if (AR_SREV_9462(ah) && (!ah->caldata ||
+                                !ah->caldata->done_txiqcal_once ||
+                                !ah->caldata->done_txclcal_once ||
+                                !ah->caldata->rtt_hist.num_readings))
+               goto fail;
+       ath_dbg(common, RESET, "FastChannelChange for %d -> %d\n",
+               ah->curchan->channel, chan->channel);
+       ret = ath9k_hw_channel_change(ah, chan);
+       if (!ret)
+               goto fail;
+       ath9k_hw_loadnf(ah, ah->curchan);
+       ath9k_hw_start_nfcal(ah, true);
+       if ((ah->caps.hw_caps & ATH9K_HW_CAP_MCI) && ar9003_mci_is_ready(ah))
+               ar9003_mci_2g5g_switch(ah, true);
+       if (AR_SREV_9271(ah))
+               ar9002_hw_load_ani_reg(ah, chan);
+       return 0;
+ fail:
+       return -EINVAL;
+ }
  int ath9k_hw_reset(struct ath_hw *ah, struct ath9k_channel *chan,
-                  struct ath9k_hw_cal_data *caldata, bool bChannelChange)
+                  struct ath9k_hw_cal_data *caldata, bool fastcc)
  {
        struct ath_common *common = ath9k_hw_common(ah);
        u32 saveLedState;
-       struct ath9k_channel *curchan = ah->curchan;
        u32 saveDefAntenna;
        u32 macStaId1;
        u64 tsf = 0;
        int i, r;
-       bool allow_fbs = false, start_mci_reset = false;
+       bool start_mci_reset = false;
        bool mci = !!(ah->caps.hw_caps & ATH9K_HW_CAP_MCI);
        bool save_fullsleep = ah->chip_fullsleep;
  
        if (!ath9k_hw_setpower(ah, ATH9K_PM_AWAKE))
                return -EIO;
  
-       if (curchan && !ah->chip_fullsleep)
-               ath9k_hw_getnf(ah, curchan);
+       if (ah->curchan && !ah->chip_fullsleep)
+               ath9k_hw_getnf(ah, ah->curchan);
  
        ah->caldata = caldata;
        if (caldata &&
        }
        ah->noise = ath9k_hw_getchan_noise(ah, chan);
  
-       if (AR_SREV_9280(ah) && common->bus_ops->ath_bus_type == ATH_PCI)
-               bChannelChange = false;
-       if (caldata &&
-           caldata->done_txiqcal_once &&
-           caldata->done_txclcal_once &&
-           caldata->rtt_hist.num_readings)
-               allow_fbs = true;
-       if (bChannelChange &&
-           (!ah->chip_fullsleep) &&
-           (ah->curchan != NULL) &&
-           (chan->channel != ah->curchan->channel) &&
-           (allow_fbs ||
-            ((chan->channelFlags & CHANNEL_ALL) ==
-             (ah->curchan->channelFlags & CHANNEL_ALL)))) {
-               if (ath9k_hw_channel_change(ah, chan)) {
-                       ath9k_hw_loadnf(ah, ah->curchan);
-                       ath9k_hw_start_nfcal(ah, true);
-                       if (mci && ar9003_mci_is_ready(ah))
-                               ar9003_mci_2g5g_switch(ah, true);
-                       if (AR_SREV_9271(ah))
-                               ar9002_hw_load_ani_reg(ah, chan);
-                       return 0;
-               }
+       if (fastcc) {
+               r = ath9k_hw_do_fastcc(ah, chan);
+               if (!r)
+                       return r;
        }
  
        if (mci)
@@@ -1936,7 -1976,8 +1976,7 @@@ static bool ath9k_hw_set_power_awake(st
        if (setChip) {
                if ((REG_READ(ah, AR_RTC_STATUS) &
                     AR_RTC_STATUS_M) == AR_RTC_STATUS_SHUTDOWN) {
 -                      if (ath9k_hw_set_reset_reg(ah,
 -                                         ATH9K_RESET_POWER_ON) != true) {
 +                      if (!ath9k_hw_set_reset_reg(ah, ATH9K_RESET_POWER_ON)) {
                                return false;
                        }
                        if (!AR_SREV_9300_20_OR_LATER(ah))
@@@ -2389,8 -2430,17 +2429,17 @@@ int ath9k_hw_fill_cap_info(struct ath_h
                if (AR_SREV_9485_OR_LATER(ah))
                        ah->enabled_cals |= TX_IQ_ON_AGC_CAL;
        }
-       if (AR_SREV_9462(ah))
-               pCap->hw_caps |= ATH9K_HW_CAP_RTT | ATH9K_HW_CAP_MCI;
+       if (AR_SREV_9462(ah)) {
+               if (!(ah->ent_mode & AR_ENT_OTP_49GHZ_DISABLE))
+                       pCap->hw_caps |= ATH9K_HW_CAP_MCI;
+               if (AR_SREV_9462_20(ah))
+                       pCap->hw_caps |= ATH9K_HW_CAP_RTT;
+       }
  
        return 0;
  }
@@@ -2516,12 -2566,6 +2565,6 @@@ void ath9k_hw_set_gpio(struct ath_hw *a
  }
  EXPORT_SYMBOL(ath9k_hw_set_gpio);
  
- u32 ath9k_hw_getdefantenna(struct ath_hw *ah)
- {
-       return REG_READ(ah, AR_DEF_ANTENNA) & 0x7;
- }
- EXPORT_SYMBOL(ath9k_hw_getdefantenna);
  void ath9k_hw_setantenna(struct ath_hw *ah, u32 antenna)
  {
        REG_WRITE(ah, AR_DEF_ANTENNA, (antenna & 0x7));
@@@ -2579,6 -2623,7 +2622,7 @@@ bool ath9k_hw_phy_disable(struct ath_h
                return false;
  
        ath9k_hw_init_pll(ah, NULL);
+       ah->htc_reset_init = true;
        return true;
  }
  EXPORT_SYMBOL(ath9k_hw_phy_disable);
@@@ -2939,12 -2984,6 +2983,6 @@@ EXPORT_SYMBOL(ath_gen_timer_isr)
  /* HTC  */
  /********/
  
- void ath9k_hw_htc_resetinit(struct ath_hw *ah)
- {
-       ah->htc_reset_init = true;
- }
- EXPORT_SYMBOL(ath9k_hw_htc_resetinit);
  static struct {
        u32 version;
        const char * name;
index f98baaba0c2a219c859f933309f3bd960e6c81e5,3e1698dc995fa32f2bd39499801b665dd9fe09d6..56f41c9409d1ba945ff0ae1138f67683ac89eabe
@@@ -1189,6 -1189,7 +1189,7 @@@ int iwlagn_suspend(struct iwl_priv *pri
  
        memcpy(&rxon, &ctx->active, sizeof(rxon));
  
+       priv->ucode_loaded = false;
        iwl_trans_stop_device(trans(priv));
  
        priv->wowlan = true;
                                .flags = CMD_SYNC,
                                .data[0] = key_data.rsc_tsc,
                                .dataflags[0] = IWL_HCMD_DFL_NOCOPY,
 -                              .len[0] = sizeof(key_data.rsc_tsc),
 +                              .len[0] = sizeof(*key_data.rsc_tsc),
                        };
  
                        ret = iwl_dvm_send_cmd(priv, &rsc_tsc_cmd);
index eb430b6e1cde621e41b25903b4ecdd2b923a4ccb,a66ad9b590a4e2eeac1e43d53935407e0731f3cf..e92972fd6ecfc1e794e32470cdc760b1c668f230
@@@ -530,7 -530,7 +530,7 @@@ void iwl_trans_pcie_tx_agg_setup(struc
        }
  
        txq_id = trans_pcie->agg_txq[sta_id][tid];
 -      if (WARN_ON_ONCE(is_agg_txqid_valid(trans, txq_id) == false)) {
 +      if (WARN_ON_ONCE(!is_agg_txqid_valid(trans, txq_id))) {
                IWL_ERR(trans,
                        "queue number out of range: %d, must be %d to %d\n",
                        txq_id, IWLAGN_FIRST_AMPDU_QUEUE,
@@@ -626,7 -626,7 +626,7 @@@ int iwl_trans_pcie_tx_agg_disable(struc
        struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
        u8 txq_id = trans_pcie->agg_txq[sta_id][tid];
  
 -      if (WARN_ON_ONCE(is_agg_txqid_valid(trans, txq_id) == false)) {
 +      if (WARN_ON_ONCE(!is_agg_txqid_valid(trans, txq_id))) {
                IWL_ERR(trans,
                        "queue number out of range: %d, must be %d to %d\n",
                        txq_id, IWLAGN_FIRST_AMPDU_QUEUE,
@@@ -928,7 -928,7 +928,7 @@@ void iwl_tx_cmd_complete(struct iwl_tra
                clear_bit(STATUS_HCMD_ACTIVE, &trans->shrd->status);
                IWL_DEBUG_INFO(trans, "Clearing HCMD_ACTIVE for command %s\n",
                               get_cmd_string(cmd->hdr.cmd));
-               wake_up(&trans->shrd->wait_command_queue);
+               wake_up(&trans->wait_command_queue);
        }
  
        meta->flags = 0;
@@@ -992,7 -992,7 +992,7 @@@ static int iwl_send_cmd_sync(struct iwl
                return ret;
        }
  
-       ret = wait_event_timeout(trans->shrd->wait_command_queue,
+       ret = wait_event_timeout(trans->wait_command_queue,
                        !test_bit(STATUS_HCMD_ACTIVE, &trans->shrd->status),
                        HOST_COMPLETE_TIMEOUT);
        if (!ret) {
index f4fbad95d3e392fa7ce324566ed9d3634a075071,e1f45ecf39a5ac203090c4f97fe608ef37db77ca..5867facd415d445e1bfd12ae160dd6834ba6aa3e
@@@ -83,11 -83,13 +83,11 @@@ static int mwifiex_pcie_probe(struct pc
        struct pcie_service_card *card;
  
        pr_debug("info: vendor=0x%4.04X device=0x%4.04X rev=%d\n",
-                               pdev->vendor, pdev->device, pdev->revision);
+                pdev->vendor, pdev->device, pdev->revision);
  
        card = kzalloc(sizeof(struct pcie_service_card), GFP_KERNEL);
 -      if (!card) {
 -              pr_err("%s: failed to alloc memory\n", __func__);
 +      if (!card)
                return -ENOMEM;
 -      }
  
        card->dev = pdev;
  
@@@ -108,6 -110,7 +108,7 @@@ static void mwifiex_pcie_remove(struct 
  {
        struct pcie_service_card *card;
        struct mwifiex_adapter *adapter;
+       struct mwifiex_private *priv;
        int i;
  
        card = pci_get_drvdata(pdev);
  
                for (i = 0; i < adapter->priv_num; i++)
                        if ((GET_BSS_ROLE(adapter->priv[i]) ==
-                                               MWIFIEX_BSS_ROLE_STA) &&
-                                       adapter->priv[i]->media_connected)
+                            MWIFIEX_BSS_ROLE_STA) &&
+                           adapter->priv[i]->media_connected)
                                mwifiex_deauthenticate(adapter->priv[i], NULL);
  
-               mwifiex_disable_auto_ds(mwifiex_get_priv(adapter,
-                                                MWIFIEX_BSS_ROLE_ANY));
+               priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
  
-               mwifiex_init_shutdown_fw(mwifiex_get_priv(adapter,
-                                               MWIFIEX_BSS_ROLE_ANY),
-                                        MWIFIEX_FUNC_SHUTDOWN);
+               mwifiex_disable_auto_ds(priv);
+               mwifiex_init_shutdown_fw(priv, MWIFIEX_FUNC_SHUTDOWN);
        }
  
        mwifiex_remove_card(card->adapter, &add_remove_card_sem);
@@@ -219,7 -221,7 +219,7 @@@ static int mwifiex_pcie_resume(struct p
                        netif_carrier_on(adapter->priv[i]->netdev);
  
        mwifiex_cancel_hs(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
-                             MWIFIEX_ASYNC_CMD);
+                         MWIFIEX_ASYNC_CMD);
  
        return 0;
  }
@@@ -286,7 -288,7 +286,7 @@@ static int mwifiex_pm_wakeup_card(struc
  
        while (mwifiex_pcie_ok_to_access_hw(adapter)) {
                i++;
-               udelay(10);
+               usleep_range(10, 20);
                /* 50ms max wait */
                if (i == 50000)
                        break;
@@@ -378,26 -380,26 +378,26 @@@ static int mwifiex_pcie_create_txbd_rin
        /* allocate shared memory for the BD ring and divide the same in to
           several descriptors */
        card->txbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
-                               MWIFIEX_MAX_TXRX_BD;
+                                                       MWIFIEX_MAX_TXRX_BD;
        dev_dbg(adapter->dev, "info: txbd_ring: Allocating %d bytes\n",
-                               card->txbd_ring_size);
+               card->txbd_ring_size);
        card->txbd_ring_vbase = kzalloc(card->txbd_ring_size, GFP_KERNEL);
        if (!card->txbd_ring_vbase) {
-               dev_err(adapter->dev, "Unable to allocate buffer for txbd ring.\n");
+               dev_err(adapter->dev, "Unable to alloc buffer for txbd ring\n");
                return -ENOMEM;
        }
        card->txbd_ring_pbase = virt_to_phys(card->txbd_ring_vbase);
  
-       dev_dbg(adapter->dev, "info: txbd_ring - base: %p, pbase: %#x:%x,"
-                       "len: %x\n", card->txbd_ring_vbase,
-                       (u32)card->txbd_ring_pbase,
-                       (u32)((u64)card->txbd_ring_pbase >> 32),
-                       card->txbd_ring_size);
+       dev_dbg(adapter->dev,
+               "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
+               card->txbd_ring_vbase, (u32)card->txbd_ring_pbase,
+               (u32)((u64)card->txbd_ring_pbase >> 32), card->txbd_ring_size);
  
        for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
                card->txbd_ring[i] = (struct mwifiex_pcie_buf_desc *)
-                               (card->txbd_ring_vbase +
-                               (sizeof(struct mwifiex_pcie_buf_desc) * i));
+                                    (card->txbd_ring_vbase +
+                                     (sizeof(struct mwifiex_pcie_buf_desc)
+                                      * i));
  
                /* Allocate buffer here so that firmware can DMA data from it */
                skb = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
  
                skb_put(skb, MWIFIEX_RX_DATA_BUF_SIZE);
                dev_dbg(adapter->dev, "info: TX ring: add new skb base: %p, "
-                               "buf_base: %p, buf_pbase: %#x:%x, "
-                               "buf_len: %#x\n", skb, skb->data,
-                               (u32)*buf_pa, (u32)(((u64)*buf_pa >> 32)),
-                               skb->len);
+                       "buf_base: %p, buf_pbase: %#x:%x, buf_len: %#x\n",
+                       skb, skb->data, (u32)*buf_pa,
+                       (u32)(((u64)*buf_pa >> 32)), skb->len);
  
                card->tx_buf_list[i] = skb;
                card->txbd_ring[i]->paddr = *buf_pa;
@@@ -467,9 -468,9 +466,9 @@@ static int mwifiex_pcie_create_rxbd_rin
        card->rxbd_rdptr |= MWIFIEX_BD_FLAG_ROLLOVER_IND;
  
        card->rxbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
-                               MWIFIEX_MAX_TXRX_BD;
+                                                       MWIFIEX_MAX_TXRX_BD;
        dev_dbg(adapter->dev, "info: rxbd_ring: Allocating %d bytes\n",
-                               card->rxbd_ring_size);
+               card->rxbd_ring_size);
        card->rxbd_ring_vbase = kzalloc(card->rxbd_ring_size, GFP_KERNEL);
        if (!card->rxbd_ring_vbase) {
                dev_err(adapter->dev, "Unable to allocate buffer for "
        }
        card->rxbd_ring_pbase = virt_to_phys(card->rxbd_ring_vbase);
  
-       dev_dbg(adapter->dev, "info: rxbd_ring - base: %p, pbase: %#x:%x,"
-                       "len: %#x\n", card->rxbd_ring_vbase,
-                       (u32)card->rxbd_ring_pbase,
-                       (u32)((u64)card->rxbd_ring_pbase >> 32),
-                       card->rxbd_ring_size);
+       dev_dbg(adapter->dev,
+               "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
+               card->rxbd_ring_vbase, (u32)card->rxbd_ring_pbase,
+               (u32)((u64)card->rxbd_ring_pbase >> 32),
+               card->rxbd_ring_size);
  
        for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
                card->rxbd_ring[i] = (struct mwifiex_pcie_buf_desc *)
-                               (card->rxbd_ring_vbase +
-                               (sizeof(struct mwifiex_pcie_buf_desc) * i));
+                                    (card->rxbd_ring_vbase +
+                                     (sizeof(struct mwifiex_pcie_buf_desc)
+                                      * i));
  
                /* Allocate skb here so that firmware can DMA data from it */
                skb = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
                if (!skb) {
-                       dev_err(adapter->dev, "Unable to allocate skb for RX ring.\n");
+                       dev_err(adapter->dev,
+                               "Unable to allocate skb for RX ring.\n");
                        kfree(card->rxbd_ring_vbase);
                        return -ENOMEM;
                }
                skb_put(skb, MWIFIEX_RX_DATA_BUF_SIZE);
  
                dev_dbg(adapter->dev, "info: RX ring: add new skb base: %p, "
-                               "buf_base: %p, buf_pbase: %#x:%x, "
-                               "buf_len: %#x\n", skb, skb->data,
-                               (u32)*buf_pa, (u32)((u64)*buf_pa >> 32),
-                               skb->len);
+                       "buf_base: %p, buf_pbase: %#x:%x, buf_len: %#x\n",
+                       skb, skb->data, (u32)*buf_pa, (u32)((u64)*buf_pa >> 32),
+                       skb->len);
  
                card->rx_buf_list[i] = skb;
                card->rxbd_ring[i]->paddr = *buf_pa;
@@@ -560,32 -562,34 +560,34 @@@ static int mwifiex_pcie_create_evtbd_ri
        card->evtbd_rdptr |= MWIFIEX_BD_FLAG_ROLLOVER_IND;
  
        card->evtbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
-                               MWIFIEX_MAX_EVT_BD;
+                                                       MWIFIEX_MAX_EVT_BD;
        dev_dbg(adapter->dev, "info: evtbd_ring: Allocating %d bytes\n",
-                               card->evtbd_ring_size);
+               card->evtbd_ring_size);
        card->evtbd_ring_vbase = kzalloc(card->evtbd_ring_size, GFP_KERNEL);
        if (!card->evtbd_ring_vbase) {
-               dev_err(adapter->dev, "Unable to allocate buffer. "
-                               "Terminating download\n");
+               dev_err(adapter->dev,
+                       "Unable to allocate buffer. Terminating download\n");
                return -ENOMEM;
        }
        card->evtbd_ring_pbase = virt_to_phys(card->evtbd_ring_vbase);
  
-       dev_dbg(adapter->dev, "info: CMDRSP/EVT bd_ring - base: %p, "
-                      "pbase: %#x:%x, len: %#x\n", card->evtbd_ring_vbase,
-                      (u32)card->evtbd_ring_pbase,
-                      (u32)((u64)card->evtbd_ring_pbase >> 32),
-                      card->evtbd_ring_size);
+       dev_dbg(adapter->dev,
+               "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
+               card->evtbd_ring_vbase, (u32)card->evtbd_ring_pbase,
+               (u32)((u64)card->evtbd_ring_pbase >> 32),
+               card->evtbd_ring_size);
  
        for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
                card->evtbd_ring[i] = (struct mwifiex_pcie_buf_desc *)
-                               (card->evtbd_ring_vbase +
-                               (sizeof(struct mwifiex_pcie_buf_desc) * i));
+                                     (card->evtbd_ring_vbase +
+                                      (sizeof(struct mwifiex_pcie_buf_desc)
+                                       * i));
  
                /* Allocate skb here so that firmware can DMA data from it */
                skb = dev_alloc_skb(MAX_EVENT_SIZE);
                if (!skb) {
-                       dev_err(adapter->dev, "Unable to allocate skb for EVENT buf.\n");
+                       dev_err(adapter->dev,
+                               "Unable to allocate skb for EVENT buf.\n");
                        kfree(card->evtbd_ring_vbase);
                        return -ENOMEM;
                }
                skb_put(skb, MAX_EVENT_SIZE);
  
                dev_dbg(adapter->dev, "info: Evt ring: add new skb. base: %p, "
-                              "buf_base: %p, buf_pbase: %#x:%x, "
-                              "buf_len: %#x\n", skb, skb->data,
-                              (u32)*buf_pa, (u32)((u64)*buf_pa >> 32),
-                              skb->len);
+                       "buf_base: %p, buf_pbase: %#x:%x, buf_len: %#x\n",
+                       skb, skb->data, (u32)*buf_pa, (u32)((u64)*buf_pa >> 32),
+                       skb->len);
  
                card->evt_buf_list[i] = skb;
                card->evtbd_ring[i]->paddr = *buf_pa;
@@@ -645,8 -648,8 +646,8 @@@ static int mwifiex_pcie_alloc_cmdrsp_bu
        /* Allocate memory for receiving command response data */
        skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
        if (!skb) {
-               dev_err(adapter->dev, "Unable to allocate skb for command "
-                                     "response data.\n");
+               dev_err(adapter->dev,
+                       "Unable to allocate skb for command response data.\n");
                return -ENOMEM;
        }
        mwifiex_update_sk_buff_pa(skb);
        /* Allocate memory for sending command to firmware */
        skb = dev_alloc_skb(MWIFIEX_SIZE_OF_CMD_BUFFER);
        if (!skb) {
-               dev_err(adapter->dev, "Unable to allocate skb for command "
-                                     "data.\n");
+               dev_err(adapter->dev,
+                       "Unable to allocate skb for command data.\n");
                return -ENOMEM;
        }
        mwifiex_update_sk_buff_pa(skb);
@@@ -700,8 -703,8 +701,8 @@@ static int mwifiex_pcie_alloc_sleep_coo
        /* Allocate memory for sleep cookie */
        skb = dev_alloc_skb(sizeof(u32));
        if (!skb) {
-               dev_err(adapter->dev, "Unable to allocate skb for sleep "
-                                     "cookie!\n");
+               dev_err(adapter->dev,
+                       "Unable to allocate skb for sleep cookie!\n");
                return -ENOMEM;
        }
        mwifiex_update_sk_buff_pa(skb);
        *(u32 *)skb->data = FW_AWAKE_COOKIE;
  
        dev_dbg(adapter->dev, "alloc_scook: sleep cookie=0x%x\n",
-                               *((u32 *)skb->data));
+               *((u32 *)skb->data));
  
        /* Save the sleep cookie */
        card->sleep_cookie = skb;
@@@ -755,15 -758,15 +756,15 @@@ mwifiex_pcie_send_data(struct mwifiex_a
  
        /* Read the TX ring read pointer set by firmware */
        if (mwifiex_read_reg(adapter, REG_TXBD_RDPTR, &rdptr)) {
-               dev_err(adapter->dev, "SEND DATA: failed to read "
-                                     "REG_TXBD_RDPTR\n");
+               dev_err(adapter->dev,
+                       "SEND DATA: failed to read REG_TXBD_RDPTR\n");
                return -1;
        }
  
        wrindx = card->txbd_wrptr & MWIFIEX_TXBD_MASK;
  
        dev_dbg(adapter->dev, "info: SEND DATA: <Rd: %#x, Wr: %#x>\n", rdptr,
-                               card->txbd_wrptr);
+               card->txbd_wrptr);
        if (((card->txbd_wrptr & MWIFIEX_TXBD_MASK) !=
                        (rdptr & MWIFIEX_TXBD_MASK)) ||
            ((card->txbd_wrptr & MWIFIEX_BD_FLAG_ROLLOVER_IND) !=
  
                /* Write the TX ring write pointer in to REG_TXBD_WRPTR */
                if (mwifiex_write_reg(adapter, REG_TXBD_WRPTR,
-                                                       card->txbd_wrptr)) {
-                       dev_err(adapter->dev, "SEND DATA: failed to write "
-                                             "REG_TXBD_WRPTR\n");
+                                     card->txbd_wrptr)) {
+                       dev_err(adapter->dev,
+                               "SEND DATA: failed to write REG_TXBD_WRPTR\n");
                        return 0;
                }
  
                /* Send the TX ready interrupt */
                if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
                                      CPU_INTR_DNLD_RDY)) {
-                       dev_err(adapter->dev, "SEND DATA: failed to assert "
-                                             "door-bell interrupt.\n");
+                       dev_err(adapter->dev,
+                               "SEND DATA: failed to assert door-bell intr\n");
                        return -1;
                }
                dev_dbg(adapter->dev, "info: SEND DATA: Updated <Rd: %#x, Wr: "
-                                     "%#x> and sent packet to firmware "
-                                     "successfully\n", rdptr,
-                                     card->txbd_wrptr);
+                       "%#x> and sent packet to firmware successfully\n",
+                       rdptr, card->txbd_wrptr);
        } else {
-               dev_dbg(adapter->dev, "info: TX Ring full, can't send anymore "
-                                     "packets to firmware\n");
+               dev_dbg(adapter->dev,
+                       "info: TX Ring full, can't send packets to fw\n");
                adapter->data_sent = true;
                /* Send the TX ready interrupt */
                if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
                                      CPU_INTR_DNLD_RDY))
-                       dev_err(adapter->dev, "SEND DATA: failed to assert "
-                                             "door-bell interrupt\n");
+                       dev_err(adapter->dev,
+                               "SEND DATA: failed to assert door-bell intr\n");
                return -EBUSY;
        }
  
@@@ -840,8 -842,8 +840,8 @@@ static int mwifiex_pcie_process_recv_da
  
        /* Read the RX ring Write pointer set by firmware */
        if (mwifiex_read_reg(adapter, REG_RXBD_WRPTR, &wrptr)) {
-               dev_err(adapter->dev, "RECV DATA: failed to read "
-                                     "REG_TXBD_RDPTR\n");
+               dev_err(adapter->dev,
+                       "RECV DATA: failed to read REG_TXBD_RDPTR\n");
                ret = -1;
                goto done;
        }
                /* Get data length from interface header -
                   first byte is len, second byte is type */
                rx_len = *((u16 *)skb_data->data);
-               dev_dbg(adapter->dev, "info: RECV DATA: Rd=%#x, Wr=%#x, "
-                               "Len=%d\n", card->rxbd_rdptr, wrptr, rx_len);
+               dev_dbg(adapter->dev,
+                       "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
+                       card->rxbd_rdptr, wrptr, rx_len);
                skb_tmp = dev_alloc_skb(rx_len);
                if (!skb_tmp) {
-                       dev_dbg(adapter->dev, "info: Failed to alloc skb "
-                                             "for RX\n");
+                       dev_dbg(adapter->dev,
+                               "info: Failed to alloc skb for RX\n");
                        ret = -EBUSY;
                        goto done;
                }
                                            MWIFIEX_BD_FLAG_ROLLOVER_IND);
                }
                dev_dbg(adapter->dev, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
-                               card->rxbd_rdptr, wrptr);
+                       card->rxbd_rdptr, wrptr);
  
                /* Write the RX ring read pointer in to REG_RXBD_RDPTR */
                if (mwifiex_write_reg(adapter, REG_RXBD_RDPTR,
                                      card->rxbd_rdptr)) {
-                       dev_err(adapter->dev, "RECV DATA: failed to "
-                                             "write REG_RXBD_RDPTR\n");
+                       dev_err(adapter->dev,
+                               "RECV DATA: failed to write REG_RXBD_RDPTR\n");
                        ret = -1;
                        goto done;
                }
  
                /* Read the RX ring Write pointer set by firmware */
                if (mwifiex_read_reg(adapter, REG_RXBD_WRPTR, &wrptr)) {
-                       dev_err(adapter->dev, "RECV DATA: failed to read "
-                                             "REG_TXBD_RDPTR\n");
+                       dev_err(adapter->dev,
+                               "RECV DATA: failed to read REG_TXBD_RDPTR\n");
                        ret = -1;
                        goto done;
                }
-               dev_dbg(adapter->dev, "info: RECV DATA: Received packet from "
-                                     "firmware successfully\n");
+               dev_dbg(adapter->dev,
+                       "info: RECV DATA: Rcvd packet from fw successfully\n");
                mwifiex_handle_rx_packet(adapter, skb_tmp);
        }
  
@@@ -917,17 -920,19 +918,19 @@@ mwifiex_pcie_send_boot_cmd(struct mwifi
        phys_addr_t *buf_pa = MWIFIEX_SKB_PACB(skb);
  
        if (!(skb->data && skb->len && *buf_pa)) {
-               dev_err(adapter->dev, "Invalid parameter in %s <%p, %#x:%x, "
-                               "%x>\n", __func__, skb->data, skb->len,
-                               (u32)*buf_pa, (u32)((u64)*buf_pa >> 32));
+               dev_err(adapter->dev,
+                       "Invalid parameter in %s <%p, %#x:%x, %x>\n",
+                       __func__, skb->data, skb->len,
+                       (u32)*buf_pa, (u32)((u64)*buf_pa >> 32));
                return -1;
        }
  
        /* Write the lower 32bits of the physical address to scratch
         * register 0 */
        if (mwifiex_write_reg(adapter, PCIE_SCRATCH_0_REG, (u32)*buf_pa)) {
-               dev_err(adapter->dev, "%s: failed to write download command "
-                                     "to boot code.\n", __func__);
+               dev_err(adapter->dev,
+                       "%s: failed to write download command to boot code.\n",
+                       __func__);
                return -1;
        }
  
         * register 1 */
        if (mwifiex_write_reg(adapter, PCIE_SCRATCH_1_REG,
                              (u32)((u64)*buf_pa >> 32))) {
-               dev_err(adapter->dev, "%s: failed to write download command "
-                                     "to boot code.\n", __func__);
+               dev_err(adapter->dev,
+                       "%s: failed to write download command to boot code.\n",
+                       __func__);
                return -1;
        }
  
        /* Write the command length to scratch register 2 */
        if (mwifiex_write_reg(adapter, PCIE_SCRATCH_2_REG, skb->len)) {
-               dev_err(adapter->dev, "%s: failed to write command length to "
-                                     "scratch register 2\n", __func__);
+               dev_err(adapter->dev,
+                       "%s: failed to write command len to scratch reg 2\n",
+                       __func__);
                return -1;
        }
  
        /* Ring the door bell */
        if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
                              CPU_INTR_DOOR_BELL)) {
-               dev_err(adapter->dev, "%s: failed to assert door-bell "
-                                     "interrupt.\n", __func__);
+               dev_err(adapter->dev,
+                       "%s: failed to assert door-bell intr\n", __func__);
                return -1;
        }
  
@@@ -971,14 -978,14 +976,14 @@@ mwifiex_pcie_send_cmd(struct mwifiex_ad
  
        if (!(skb->data && skb->len)) {
                dev_err(adapter->dev, "Invalid parameter in %s <%p, %#x>\n",
-                                     __func__, skb->data, skb->len);
+                       __func__, skb->data, skb->len);
                return -1;
        }
  
        /* Make sure a command response buffer is available */
        if (!card->cmdrsp_buf) {
-               dev_err(adapter->dev, "No response buffer available, send "
-                                     "command failed\n");
+               dev_err(adapter->dev,
+                       "No response buffer available, send command failed\n");
                return -EBUSY;
        }
  
                /* Write the lower 32bits of the cmdrsp buffer physical
                   address */
                if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_LO,
-                                       (u32)*cmdrsp_buf_pa)) {
-                       dev_err(adapter->dev, "Failed to write download command to boot code.\n");
+                                     (u32)*cmdrsp_buf_pa)) {
+                       dev_err(adapter->dev,
+                               "Failed to write download cmd to boot code.\n");
                        ret = -1;
                        goto done;
                }
                /* Write the upper 32bits of the cmdrsp buffer physical
                   address */
                if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_HI,
-                                       (u32)((u64)*cmdrsp_buf_pa >> 32))) {
-                       dev_err(adapter->dev, "Failed to write download command"
-                                             " to boot code.\n");
+                                     (u32)((u64)*cmdrsp_buf_pa >> 32))) {
+                       dev_err(adapter->dev,
+                               "Failed to write download cmd to boot code.\n");
                        ret = -1;
                        goto done;
                }
  
        cmd_buf_pa = MWIFIEX_SKB_PACB(card->cmd_buf);
        /* Write the lower 32bits of the physical address to REG_CMD_ADDR_LO */
-       if (mwifiex_write_reg(adapter, REG_CMD_ADDR_LO,
-                               (u32)*cmd_buf_pa)) {
-               dev_err(adapter->dev, "Failed to write download command "
-                                     "to boot code.\n");
+       if (mwifiex_write_reg(adapter, REG_CMD_ADDR_LO, (u32)*cmd_buf_pa)) {
+               dev_err(adapter->dev,
+                       "Failed to write download cmd to boot code.\n");
                ret = -1;
                goto done;
        }
        /* Write the upper 32bits of the physical address to REG_CMD_ADDR_HI */
        if (mwifiex_write_reg(adapter, REG_CMD_ADDR_HI,
-                               (u32)((u64)*cmd_buf_pa >> 32))) {
-               dev_err(adapter->dev, "Failed to write download command "
-                                     "to boot code.\n");
+                             (u32)((u64)*cmd_buf_pa >> 32))) {
+               dev_err(adapter->dev,
+                       "Failed to write download cmd to boot code.\n");
                ret = -1;
                goto done;
        }
  
        /* Write the command length to REG_CMD_SIZE */
-       if (mwifiex_write_reg(adapter, REG_CMD_SIZE,
-                               card->cmd_buf->len)) {
-               dev_err(adapter->dev, "Failed to write command length to "
-                                     "REG_CMD_SIZE\n");
+       if (mwifiex_write_reg(adapter, REG_CMD_SIZE, card->cmd_buf->len)) {
+               dev_err(adapter->dev,
+                       "Failed to write cmd len to REG_CMD_SIZE\n");
                ret = -1;
                goto done;
        }
        /* Ring the door bell */
        if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
                              CPU_INTR_DOOR_BELL)) {
-               dev_err(adapter->dev, "Failed to assert door-bell "
-                                     "interrupt.\n");
+               dev_err(adapter->dev,
+                       "Failed to assert door-bell intr\n");
                ret = -1;
                goto done;
        }
@@@ -1074,30 -1080,29 +1078,29 @@@ done
  static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
  {
        struct pcie_service_card *card = adapter->card;
+       struct sk_buff *skb = card->cmdrsp_buf;
        int count = 0;
  
        dev_dbg(adapter->dev, "info: Rx CMD Response\n");
  
        if (!adapter->curr_cmd) {
-               skb_pull(card->cmdrsp_buf, INTF_HEADER_LEN);
+               skb_pull(skb, INTF_HEADER_LEN);
                if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
-                       mwifiex_process_sleep_confirm_resp(adapter,
-                                       card->cmdrsp_buf->data,
-                                       card->cmdrsp_buf->len);
+                       mwifiex_process_sleep_confirm_resp(adapter, skb->data,
+                                                          skb->len);
                        while (mwifiex_pcie_ok_to_access_hw(adapter) &&
                                                        (count++ < 10))
-                               udelay(50);
+                               usleep_range(50, 60);
                } else {
-                       dev_err(adapter->dev, "There is no command but "
-                                             "got cmdrsp\n");
+                       dev_err(adapter->dev,
+                               "There is no command but got cmdrsp\n");
                }
-               memcpy(adapter->upld_buf, card->cmdrsp_buf->data,
-                      min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER,
-                            card->cmdrsp_buf->len));
-               skb_push(card->cmdrsp_buf, INTF_HEADER_LEN);
+               memcpy(adapter->upld_buf, skb->data,
+                      min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, skb->len));
+               skb_push(skb, INTF_HEADER_LEN);
        } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
-               skb_pull(card->cmdrsp_buf, INTF_HEADER_LEN);
-               adapter->curr_cmd->resp_skb = card->cmdrsp_buf;
+               skb_pull(skb, INTF_HEADER_LEN);
+               adapter->curr_cmd->resp_skb = skb;
                adapter->cmd_resp_received = true;
                /* Take the pointer and set it to CMD node and will
                   return in the response complete callback */
                   will prevent firmware from writing to the same response
                   buffer again. */
                if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_LO, 0)) {
-                       dev_err(adapter->dev, "cmd_done: failed to clear "
-                                             "cmd_rsp address.\n");
+                       dev_err(adapter->dev,
+                               "cmd_done: failed to clear cmd_rsp_addr_lo\n");
                        return -1;
                }
                /* Write the upper 32bits of the cmdrsp buffer physical
                   address */
                if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_HI, 0)) {
-                       dev_err(adapter->dev, "cmd_done: failed to clear "
-                                             "cmd_rsp address.\n");
+                       dev_err(adapter->dev,
+                               "cmd_done: failed to clear cmd_rsp_addr_hi\n");
                        return -1;
                }
        }
@@@ -1149,8 -1154,8 +1152,8 @@@ static int mwifiex_pcie_process_event_r
        u32 wrptr, event;
  
        if (adapter->event_received) {
-               dev_dbg(adapter->dev, "info: Event being processed, "\
-                               "do not process this interrupt just yet\n");
+               dev_dbg(adapter->dev, "info: Event being processed, "
+                       "do not process this interrupt just yet\n");
                return 0;
        }
  
  
        /* Read the event ring write pointer set by firmware */
        if (mwifiex_read_reg(adapter, REG_EVTBD_WRPTR, &wrptr)) {
-               dev_err(adapter->dev, "EventReady: failed to read REG_EVTBD_WRPTR\n");
+               dev_err(adapter->dev,
+                       "EventReady: failed to read REG_EVTBD_WRPTR\n");
                return -1;
        }
  
        dev_dbg(adapter->dev, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
-                       card->evtbd_rdptr, wrptr);
-       if (((wrptr & MWIFIEX_EVTBD_MASK) !=
-            (card->evtbd_rdptr & MWIFIEX_EVTBD_MASK)) ||
+               card->evtbd_rdptr, wrptr);
+       if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
+                                             & MWIFIEX_EVTBD_MASK)) ||
            ((wrptr & MWIFIEX_BD_FLAG_ROLLOVER_IND) ==
             (card->evtbd_rdptr & MWIFIEX_BD_FLAG_ROLLOVER_IND))) {
                struct sk_buff *skb_cmd;
@@@ -1228,13 -1234,14 +1232,14 @@@ static int mwifiex_pcie_event_complete(
  
        if (rdptr >= MWIFIEX_MAX_EVT_BD) {
                dev_err(adapter->dev, "event_complete: Invalid rdptr 0x%x\n",
-                                       rdptr);
+                       rdptr);
                return -EINVAL;
        }
  
        /* Read the event ring write pointer set by firmware */
        if (mwifiex_read_reg(adapter, REG_EVTBD_WRPTR, &wrptr)) {
-               dev_err(adapter->dev, "event_complete: failed to read REG_EVTBD_WRPTR\n");
+               dev_err(adapter->dev,
+                       "event_complete: failed to read REG_EVTBD_WRPTR\n");
                return -1;
        }
  
                card->evtbd_ring[rdptr]->flags = 0;
                skb = NULL;
        } else {
-               dev_dbg(adapter->dev, "info: ERROR: Buffer is still valid at "
-                                     "index %d, <%p, %p>\n", rdptr,
-                                     card->evt_buf_list[rdptr], skb);
+               dev_dbg(adapter->dev,
+                       "info: ERROR: buf still valid at index %d, <%p, %p>\n",
+                       rdptr, card->evt_buf_list[rdptr], skb);
        }
  
        if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
        }
  
        dev_dbg(adapter->dev, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
-                               card->evtbd_rdptr, wrptr);
+               card->evtbd_rdptr, wrptr);
  
        /* Write the event ring read pointer in to REG_EVTBD_RDPTR */
        if (mwifiex_write_reg(adapter, REG_EVTBD_RDPTR, card->evtbd_rdptr)) {
-               dev_err(adapter->dev, "event_complete: failed to read REG_EVTBD_RDPTR\n");
+               dev_err(adapter->dev,
+                       "event_complete: failed to read REG_EVTBD_RDPTR\n");
                return -1;
        }
  
@@@ -1297,17 -1305,17 +1303,17 @@@ static int mwifiex_prog_fw_w_helper(str
        }
  
        if (!firmware || !firmware_len) {
-               dev_err(adapter->dev, "No firmware image found! "
-                                     "Terminating download\n");
+               dev_err(adapter->dev,
+                       "No firmware image found! Terminating download\n");
                return -1;
        }
  
        dev_dbg(adapter->dev, "info: Downloading FW image (%d bytes)\n",
-                               firmware_len);
+               firmware_len);
  
        if (mwifiex_pcie_disable_host_int(adapter)) {
-               dev_err(adapter->dev, "%s: Disabling interrupts"
-                                     " failed.\n", __func__);
+               dev_err(adapter->dev,
+                       "%s: Disabling interrupts failed.\n", __func__);
                return -1;
        }
  
                        ret = mwifiex_read_reg(adapter, PCIE_SCRATCH_2_REG,
                                               &len);
                        if (ret) {
-                               dev_warn(adapter->dev, "Failed reading length from boot code\n");
+                               dev_warn(adapter->dev,
+                                        "Failed reading len from boot code\n");
                                goto done;
                        }
                        if (len)
                                break;
-                       udelay(10);
+                       usleep_range(10, 20);
                }
  
                if (!len) {
                        break;
                } else if (len > MWIFIEX_UPLD_SIZE) {
                        pr_err("FW download failure @ %d, invalid length %d\n",
-                               offset, len);
+                              offset, len);
                        ret = -1;
                        goto done;
                }
                                goto done;
                        }
                        dev_err(adapter->dev, "FW CRC error indicated by the "
-                                             "helper: len = 0x%04X, txlen = "
-                                             "%d\n", len, txlen);
+                               "helper: len = 0x%04X, txlen = %d\n",
+                               len, txlen);
                        len &= ~BIT(0);
                        /* Setting this to 0 to resend from same offset */
                        txlen = 0;
  
                        dev_dbg(adapter->dev, ".");
  
-                       tx_blocks =
-                               (txlen + MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD - 1) /
-                               MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD;
+                       tx_blocks = (txlen +
+                                    MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD - 1) /
+                                    MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD;
  
                        /* Copy payload to buffer */
                        memmove(skb->data, &firmware[offset], txlen);
  
                /* Send the boot command to device */
                if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
-                       dev_err(adapter->dev, "Failed to send firmware download command\n");
+                       dev_err(adapter->dev,
+                               "Failed to send firmware download command\n");
                        ret = -1;
                        goto done;
                }
                        if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
                                             &ireg_intr)) {
                                dev_err(adapter->dev, "%s: Failed to read "
-                                                     "interrupt status during "
-                                                     "fw dnld.\n", __func__);
+                                       "interrupt status during fw dnld.\n",
+                                       __func__);
                                ret = -1;
                                goto done;
                        }
        } while (true);
  
        dev_dbg(adapter->dev, "info:\nFW download over, size %d bytes\n",
-                               offset);
+               offset);
  
        ret = 0;
  
@@@ -1428,14 -1438,15 +1436,15 @@@ mwifiex_check_fw_status(struct mwifiex_
  
        /* Mask spurios interrupts */
        if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
-                               HOST_INTR_MASK)) {
+                             HOST_INTR_MASK)) {
                dev_warn(adapter->dev, "Write register failed\n");
                return -1;
        }
  
        dev_dbg(adapter->dev, "Setting driver ready signature\n");
        if (mwifiex_write_reg(adapter, REG_DRV_READY, FIRMWARE_READY_PCIE)) {
-               dev_err(adapter->dev, "Failed to write driver ready signature\n");
+               dev_err(adapter->dev,
+                       "Failed to write driver ready signature\n");
                return -1;
        }
  
                        adapter->winner = 1;
                        ret = -1;
                } else {
-                       dev_err(adapter->dev, "PCI-E is not the winner <%#x, %d>, exit download\n",
-                                       ret, adapter->winner);
+                       dev_err(adapter->dev,
+                               "PCI-E is not the winner <%#x,%d>, exit dnld\n",
+                               ret, adapter->winner);
                        ret = 0;
                }
        }
@@@ -1510,10 -1522,11 +1520,11 @@@ static void mwifiex_interrupt_status(st
                            (adapter->ps_state == PS_STATE_SLEEP)) {
                                mwifiex_pcie_enable_host_int(adapter);
                                if (mwifiex_write_reg(adapter,
-                                               PCIE_CPU_INT_EVENT,
-                                               CPU_INTR_SLEEP_CFM_DONE)) {
-                                       dev_warn(adapter->dev, "Write register"
-                                                              " failed\n");
+                                                     PCIE_CPU_INT_EVENT,
+                                                     CPU_INTR_SLEEP_CFM_DONE)
+                                                     ) {
+                                       dev_warn(adapter->dev,
+                                                "Write register failed\n");
                                        return;
  
                                }
@@@ -1549,7 -1562,7 +1560,7 @@@ static irqreturn_t mwifiex_pcie_interru
        card = (struct pcie_service_card *) pci_get_drvdata(pdev);
        if (!card || !card->adapter) {
                pr_debug("info: %s: card=%p adapter=%p\n", __func__, card,
-                                               card ? card->adapter : NULL);
+                        card ? card->adapter : NULL);
                goto exit;
        }
        adapter = card->adapter;
@@@ -1592,7 -1605,7 +1603,7 @@@ static int mwifiex_process_int_status(s
                if (adapter->int_status & HOST_INTR_DNLD_DONE) {
                        adapter->int_status &= ~HOST_INTR_DNLD_DONE;
                        if (adapter->data_sent) {
-                               dev_dbg(adapter->dev, "info: DATA sent Interrupt\n");
+                               dev_dbg(adapter->dev, "info: DATA sent intr\n");
                                adapter->data_sent = false;
                        }
                }
                if (adapter->int_status & HOST_INTR_CMD_DONE) {
                        adapter->int_status &= ~HOST_INTR_CMD_DONE;
                        if (adapter->cmd_sent) {
-                               dev_dbg(adapter->dev, "info: CMD sent Interrupt\n");
+                               dev_dbg(adapter->dev,
+                                       "info: CMD sent Interrupt\n");
                                adapter->cmd_sent = false;
                        }
                        /* Handle command response */
                if (mwifiex_pcie_ok_to_access_hw(adapter)) {
                        if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
                                             &pcie_ireg)) {
-                               dev_warn(adapter->dev, "Read register failed\n");
+                               dev_warn(adapter->dev,
+                                        "Read register failed\n");
                                return -1;
                        }
  
                        if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
                                if (mwifiex_write_reg(adapter,
-                                       PCIE_HOST_INT_STATUS, ~pcie_ireg)) {
-                                       dev_warn(adapter->dev, "Write register"
-                                                              " failed\n");
+                                                     PCIE_HOST_INT_STATUS,
+                                                     ~pcie_ireg)) {
+                                       dev_warn(adapter->dev,
+                                                "Write register failed\n");
                                        return -1;
                                }
                                adapter->int_status |= pcie_ireg;
                }
        }
        dev_dbg(adapter->dev, "info: cmd_sent=%d data_sent=%d\n",
-              adapter->cmd_sent, adapter->data_sent);
+               adapter->cmd_sent, adapter->data_sent);
        mwifiex_pcie_enable_host_int(adapter);
  
        return 0;
@@@ -1735,8 -1751,9 +1749,9 @@@ static int mwifiex_pcie_init(struct mwi
                goto err_iomap2;
        }
  
-       dev_dbg(adapter->dev, "PCI memory map Virt0: %p PCI memory map Virt2: "
-                             "%p\n", card->pci_mmap, card->pci_mmap1);
+       dev_dbg(adapter->dev,
+               "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
+               card->pci_mmap, card->pci_mmap1);
  
        card->cmdrsp_buf = NULL;
        ret = mwifiex_pcie_create_txbd_ring(adapter);
@@@ -1806,7 -1823,8 +1821,8 @@@ static void mwifiex_pcie_cleanup(struc
        dev_dbg(adapter->dev, "Clearing driver ready signature\n");
        if (user_rmmod) {
                if (mwifiex_write_reg(adapter, REG_DRV_READY, 0x00000000))
-                       dev_err(adapter->dev, "Failed to write driver not-ready signature\n");
+                       dev_err(adapter->dev,
+                               "Failed to write driver not-ready signature\n");
        }
  
        if (pdev) {
index 8359027502313da830a1c73e5c57a82465d51bf3,3f597f4a3f5e42521448f0b218593547916ffd0d..f8012e2b7f7c735c99394f314a314073a330dd87
@@@ -67,11 -67,13 +67,11 @@@ mwifiex_sdio_probe(struct sdio_func *fu
        struct sdio_mmc_card *card = NULL;
  
        pr_debug("info: vendor=0x%4.04X device=0x%4.04X class=%d function=%d\n",
-              func->vendor, func->device, func->class, func->num);
+                func->vendor, func->device, func->class, func->num);
  
        card = kzalloc(sizeof(struct sdio_mmc_card), GFP_KERNEL);
 -      if (!card) {
 -              pr_err("%s: failed to alloc memory\n", __func__);
 +      if (!card)
                return -ENOMEM;
 -      }
  
        card->func = func;
  
@@@ -110,6 -112,7 +110,7 @@@ mwifiex_sdio_remove(struct sdio_func *f
  {
        struct sdio_mmc_card *card;
        struct mwifiex_adapter *adapter;
+       struct mwifiex_private *priv;
        int i;
  
        pr_debug("info: SDIO func num=%d\n", func->num);
                for (i = 0; i < adapter->priv_num; i++)
                        if ((GET_BSS_ROLE(adapter->priv[i]) ==
                                                MWIFIEX_BSS_ROLE_STA) &&
-                                       adapter->priv[i]->media_connected)
+                           adapter->priv[i]->media_connected)
                                mwifiex_deauthenticate(adapter->priv[i], NULL);
  
-               mwifiex_disable_auto_ds(mwifiex_get_priv(adapter,
-                                                        MWIFIEX_BSS_ROLE_ANY));
-               mwifiex_init_shutdown_fw(mwifiex_get_priv(adapter,
-                                               MWIFIEX_BSS_ROLE_ANY),
-                                        MWIFIEX_FUNC_SHUTDOWN);
+               priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
+               mwifiex_disable_auto_ds(priv);
+               mwifiex_init_shutdown_fw(priv, MWIFIEX_FUNC_SHUTDOWN);
        }
  
        mwifiex_remove_card(card->adapter, &add_remove_card_sem);
@@@ -167,7 -167,7 +165,7 @@@ static int mwifiex_sdio_suspend(struct 
        if (func) {
                pm_flag = sdio_get_host_pm_caps(func);
                pr_debug("cmd: %s: suspend: PM flag = 0x%x\n",
-                      sdio_func_id(func), pm_flag);
+                        sdio_func_id(func), pm_flag);
                if (!(pm_flag & MMC_PM_KEEP_POWER)) {
                        pr_err("%s: cannot remain alive while host is"
                                " suspended\n", sdio_func_id(func));
@@@ -361,12 -361,11 +359,11 @@@ static int mwifiex_read_data_sync(struc
  {
        struct sdio_mmc_card *card = adapter->card;
        int ret = -1;
-       u8 blk_mode =
-               (port & MWIFIEX_SDIO_BYTE_MODE_MASK) ? BYTE_MODE : BLOCK_MODE;
+       u8 blk_mode = (port & MWIFIEX_SDIO_BYTE_MODE_MASK) ? BYTE_MODE
+                      : BLOCK_MODE;
        u32 blk_size = (blk_mode == BLOCK_MODE) ? MWIFIEX_SDIO_BLOCK_SIZE : 1;
-       u32 blk_cnt =
-               (blk_mode ==
-                BLOCK_MODE) ? (len / MWIFIEX_SDIO_BLOCK_SIZE) : len;
+       u32 blk_cnt = (blk_mode == BLOCK_MODE) ? (len / MWIFIEX_SDIO_BLOCK_SIZE)
+                       : len;
        u32 ioport = (port & MWIFIEX_SDIO_IO_PORT_MASK);
  
        if (claim)
@@@ -470,8 -469,7 +467,7 @@@ static int mwifiex_write_data_to_card(s
                        i++;
                        dev_err(adapter->dev, "host_to_card, write iomem"
                                        " (%d) failed: %d\n", i, ret);
-                       if (mwifiex_write_reg(adapter,
-                                       CONFIGURATION_REG, 0x04))
+                       if (mwifiex_write_reg(adapter, CONFIGURATION_REG, 0x04))
                                dev_err(adapter->dev, "write CFG reg failed\n");
  
                        ret = -1;
@@@ -505,11 -503,11 +501,11 @@@ static int mwifiex_get_rd_port(struct m
                card->mp_rd_bitmap &= (u16) (~CTRL_PORT_MASK);
                *port = CTRL_PORT;
                dev_dbg(adapter->dev, "data: port=%d mp_rd_bitmap=0x%04x\n",
-                      *port, card->mp_rd_bitmap);
+                       *port, card->mp_rd_bitmap);
        } else {
                if (card->mp_rd_bitmap & (1 << card->curr_rd_port)) {
-                       card->mp_rd_bitmap &=
-                               (u16) (~(1 << card->curr_rd_port));
+                       card->mp_rd_bitmap &= (u16)
+                                               (~(1 << card->curr_rd_port));
                        *port = card->curr_rd_port;
  
                        if (++card->curr_rd_port == MAX_PORT)
  
                dev_dbg(adapter->dev,
                        "data: port=%d mp_rd_bitmap=0x%04x -> 0x%04x\n",
-                      *port, rd_bitmap, card->mp_rd_bitmap);
+                       *port, rd_bitmap, card->mp_rd_bitmap);
        }
        return 0;
  }
@@@ -554,14 -552,14 +550,14 @@@ static int mwifiex_get_wr_port_data(str
  
        if (*port == CTRL_PORT) {
                dev_err(adapter->dev, "invalid data port=%d cur port=%d"
-                               " mp_wr_bitmap=0x%04x -> 0x%04x\n",
-                               *port, card->curr_wr_port, wr_bitmap,
-                               card->mp_wr_bitmap);
+                       " mp_wr_bitmap=0x%04x -> 0x%04x\n",
+                       *port, card->curr_wr_port, wr_bitmap,
+                       card->mp_wr_bitmap);
                return -1;
        }
  
        dev_dbg(adapter->dev, "data: port=%d mp_wr_bitmap=0x%04x -> 0x%04x\n",
-              *port, wr_bitmap, card->mp_wr_bitmap);
+               *port, wr_bitmap, card->mp_wr_bitmap);
  
        return 0;
  }
@@@ -581,11 -579,11 +577,11 @@@ mwifiex_sdio_poll_card_status(struct mw
                else if ((cs & bits) == bits)
                        return 0;
  
-               udelay(10);
+               usleep_range(10, 20);
        }
  
-       dev_err(adapter->dev, "poll card status failed, tries = %d\n",
-              tries);
+       dev_err(adapter->dev, "poll card status failed, tries = %d\n", tries);
        return -1;
  }
  
@@@ -668,14 -666,14 +664,14 @@@ static int mwifiex_sdio_card_to_host(st
  
        if (ret) {
                dev_err(adapter->dev, "%s: read iomem failed: %d\n", __func__,
-                               ret);
+                       ret);
                return -1;
        }
  
        nb = le16_to_cpu(*(__le16 *) (buffer));
        if (nb > npayload) {
-               dev_err(adapter->dev, "%s: invalid packet, nb=%d, npayload=%d\n",
-                               __func__, nb, npayload);
+               dev_err(adapter->dev, "%s: invalid packet, nb=%d npayload=%d\n",
+                       __func__, nb, npayload);
                return -1;
        }
  
@@@ -705,19 -703,19 +701,19 @@@ static int mwifiex_prog_fw_w_helper(str
        u32 i = 0;
  
        if (!firmware_len) {
-               dev_err(adapter->dev, "firmware image not found!"
-                               " Terminating download\n");
+               dev_err(adapter->dev,
+                       "firmware image not found! Terminating download\n");
                return -1;
        }
  
        dev_dbg(adapter->dev, "info: downloading FW image (%d bytes)\n",
-                       firmware_len);
+               firmware_len);
  
        /* Assume that the allocated buffer is 8-byte aligned */
        fwbuf = kzalloc(MWIFIEX_UPLD_SIZE, GFP_KERNEL);
        if (!fwbuf) {
-               dev_err(adapter->dev, "unable to alloc buffer for firmware."
-                               " Terminating download\n");
+               dev_err(adapter->dev,
+                       "unable to alloc buffer for FW. Terminating dnld\n");
                return -ENOMEM;
        }
  
                                                    DN_LD_CARD_RDY);
                if (ret) {
                        dev_err(adapter->dev, "FW download with helper:"
-                                       " poll status timeout @ %d\n", offset);
+                               " poll status timeout @ %d\n", offset);
                        goto done;
                }
  
                        ret = mwifiex_read_reg(adapter, HOST_F1_RD_BASE_0,
                                               &base0);
                        if (ret) {
-                               dev_err(adapter->dev, "dev BASE0 register read"
-                                       " failed: base0=0x%04X(%d). Terminating "
-                                      "download\n", base0, base0);
+                               dev_err(adapter->dev,
+                                       "dev BASE0 register read failed: "
+                                       "base0=%#04X(%d). Terminating dnld\n",
+                                       base0, base0);
                                goto done;
                        }
                        ret = mwifiex_read_reg(adapter, HOST_F1_RD_BASE_1,
                                               &base1);
                        if (ret) {
-                               dev_err(adapter->dev, "dev BASE1 register read"
-                                       " failed: base1=0x%04X(%d). Terminating "
-                                      "download\n", base1, base1);
+                               dev_err(adapter->dev,
+                                       "dev BASE1 register read failed: "
+                                       "base1=%#04X(%d). Terminating dnld\n",
+                                       base1, base1);
                                goto done;
                        }
                        len = (u16) (((base1 & 0xff) << 8) | (base0 & 0xff));
                        if (len)
                                break;
  
-                       udelay(10);
+                       usleep_range(10, 20);
                }
  
                if (!len) {
                        break;
                } else if (len > MWIFIEX_UPLD_SIZE) {
-                       dev_err(adapter->dev, "FW download failed @ %d,"
-                               " invalid length %d\n", offset, len);
+                       dev_err(adapter->dev,
+                               "FW dnld failed @ %d, invalid length %d\n",
+                               offset, len);
                        ret = -1;
                        goto done;
                }
                if (len & BIT(0)) {
                        i++;
                        if (i > MAX_WRITE_IOMEM_RETRY) {
-                               dev_err(adapter->dev, "FW download failed @"
-                                       " %d, over max retry count\n", offset);
+                               dev_err(adapter->dev,
+                                       "FW dnld failed @ %d, over max retry\n",
+                                       offset);
                                ret = -1;
                                goto done;
                        }
                        dev_err(adapter->dev, "CRC indicated by the helper:"
-                              " len = 0x%04X, txlen = %d\n", len, txlen);
+                               " len = 0x%04X, txlen = %d\n", len, txlen);
                        len &= ~BIT(0);
                        /* Setting this to 0 to resend from same offset */
                        txlen = 0;
                        if (firmware_len - offset < txlen)
                                txlen = firmware_len - offset;
  
-                       tx_blocks = (txlen + MWIFIEX_SDIO_BLOCK_SIZE -
-                                       1) / MWIFIEX_SDIO_BLOCK_SIZE;
+                       tx_blocks = (txlen + MWIFIEX_SDIO_BLOCK_SIZE - 1)
+                                   / MWIFIEX_SDIO_BLOCK_SIZE;
  
                        /* Copy payload to buffer */
                        memmove(fwbuf, &firmware[offset], txlen);
                                              MWIFIEX_SDIO_BLOCK_SIZE,
                                              adapter->ioport);
                if (ret) {
-                       dev_err(adapter->dev, "FW download, write iomem (%d)"
-                                       " failed @ %d\n", i, offset);
+                       dev_err(adapter->dev,
+                               "FW download, write iomem (%d) failed @ %d\n",
+                               i, offset);
                        if (mwifiex_write_reg(adapter, CONFIGURATION_REG, 0x04))
                                dev_err(adapter->dev, "write CFG reg failed\n");
  
        } while (true);
  
        dev_dbg(adapter->dev, "info: FW download over, size %d bytes\n",
-                                               offset);
+               offset);
  
        ret = 0;
  done:
@@@ -910,7 -913,7 +911,7 @@@ mwifiex_sdio_interrupt(struct sdio_fun
        card = sdio_get_drvdata(func);
        if (!card || !card->adapter) {
                pr_debug("int: func=%p card=%p adapter=%p\n",
-                      func, card, card ? card->adapter : NULL);
+                        func, card, card ? card->adapter : NULL);
                return;
        }
        adapter = card->adapter;
@@@ -953,10 -956,12 +954,12 @@@ static int mwifiex_decode_rx_packet(str
  
                        if (adapter->ps_state == PS_STATE_SLEEP_CFM)
                                mwifiex_process_sleep_confirm_resp(adapter,
-                                                       skb->data, skb->len);
+                                                                  skb->data,
+                                                                  skb->len);
  
-                       memcpy(cmd_buf, skb->data, min_t(u32,
-                                      MWIFIEX_SIZE_OF_CMD_BUFFER, skb->len));
+                       memcpy(cmd_buf, skb->data,
+                              min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER,
+                                    skb->len));
  
                        dev_kfree_skb_any(skb);
                } else {
@@@ -1014,7 -1019,7 +1017,7 @@@ static int mwifiex_sdio_card_to_host_mp
        if (port == CTRL_PORT) {
                /* Read the command Resp without aggr */
                dev_dbg(adapter->dev, "info: %s: no aggregation for cmd "
-                               "response\n", __func__);
+                       "response\n", __func__);
  
                f_do_rx_cur = 1;
                goto rx_curr_single;
  
        if (!card->mpa_rx.enabled) {
                dev_dbg(adapter->dev, "info: %s: rx aggregation disabled\n",
-                                               __func__);
+                       __func__);
  
                f_do_rx_cur = 1;
                goto rx_curr_single;
                if (MP_RX_AGGR_PKT_LIMIT_REACHED(card) ||
                    MP_RX_AGGR_PORT_LIMIT_REACHED(card)) {
                        dev_dbg(adapter->dev, "info: %s: aggregated packet "
-                                       "limit reached\n", __func__);
+                               "limit reached\n", __func__);
                        /* No more pkts allowed in Aggr buf, rx it */
                        f_do_rx_aggr = 1;
                }
        if (f_do_rx_aggr) {
                /* do aggr RX now */
                dev_dbg(adapter->dev, "info: do_rx_aggr: num of packets: %d\n",
-                      card->mpa_rx.pkt_cnt);
+                       card->mpa_rx.pkt_cnt);
  
                if (mwifiex_read_data_sync(adapter, card->mpa_rx.buf,
                                           card->mpa_rx.buf_len,
@@@ -1192,7 -1197,7 +1195,7 @@@ static int mwifiex_process_int_status(s
                card->mp_wr_bitmap = ((u16) card->mp_regs[WR_BITMAP_U]) << 8;
                card->mp_wr_bitmap |= (u16) card->mp_regs[WR_BITMAP_L];
                dev_dbg(adapter->dev, "int: DNLD: wr_bitmap=0x%04x\n",
-                               card->mp_wr_bitmap);
+                       card->mp_wr_bitmap);
                if (adapter->data_sent &&
                    (card->mp_wr_bitmap & card->mp_data_port_mask)) {
                        dev_dbg(adapter->dev,
        }
  
        dev_dbg(adapter->dev, "info: cmd_sent=%d data_sent=%d\n",
-              adapter->cmd_sent, adapter->data_sent);
+               adapter->cmd_sent, adapter->data_sent);
        if (sdio_ireg & UP_LD_HOST_INT_STATUS) {
                card->mp_rd_bitmap = ((u16) card->mp_regs[RD_BITMAP_U]) << 8;
                card->mp_rd_bitmap |= (u16) card->mp_regs[RD_BITMAP_L];
                dev_dbg(adapter->dev, "int: UPLD: rd_bitmap=0x%04x\n",
-                               card->mp_rd_bitmap);
+                       card->mp_rd_bitmap);
  
                while (true) {
                        ret = mwifiex_get_rd_port(adapter, &port);
                        rx_len = ((u16) card->mp_regs[len_reg_u]) << 8;
                        rx_len |= (u16) card->mp_regs[len_reg_l];
                        dev_dbg(adapter->dev, "info: RX: port=%d rx_len=%u\n",
-                                       port, rx_len);
+                               port, rx_len);
                        rx_blocks =
                                (rx_len + MWIFIEX_SDIO_BLOCK_SIZE -
                                 1) / MWIFIEX_SDIO_BLOCK_SIZE;
-                       if (rx_len <= INTF_HEADER_LEN
-                           || (rx_blocks * MWIFIEX_SDIO_BLOCK_SIZE) >
-                           MWIFIEX_RX_DATA_BUF_SIZE) {
+                       if (rx_len <= INTF_HEADER_LEN ||
+                           (rx_blocks * MWIFIEX_SDIO_BLOCK_SIZE) >
+                            MWIFIEX_RX_DATA_BUF_SIZE) {
                                dev_err(adapter->dev, "invalid rx_len=%d\n",
-                                               rx_len);
+                                       rx_len);
                                return -1;
                        }
                        rx_len = (u16) (rx_blocks * MWIFIEX_SDIO_BLOCK_SIZE);
  
                        if (!skb) {
                                dev_err(adapter->dev, "%s: failed to alloc skb",
-                                                               __func__);
+                                       __func__);
                                return -1;
                        }
  
                        skb_put(skb, rx_len);
  
                        dev_dbg(adapter->dev, "info: rx_len = %d skb->len = %d\n",
-                                       rx_len, skb->len);
+                               rx_len, skb->len);
  
                        if (mwifiex_sdio_card_to_host_mp_aggr(adapter, skb,
                                                              port)) {
                                u32 cr = 0;
  
                                dev_err(adapter->dev, "card_to_host_mpa failed:"
-                                               " int status=%#x\n", sdio_ireg);
+                                       " int status=%#x\n", sdio_ireg);
                                if (mwifiex_read_reg(adapter,
                                                     CONFIGURATION_REG, &cr))
                                        dev_err(adapter->dev,
-                                                       "read CFG reg failed\n");
+                                               "read CFG reg failed\n");
  
                                dev_dbg(adapter->dev,
-                                               "info: CFG reg val = %d\n", cr);
+                                       "info: CFG reg val = %d\n", cr);
                                if (mwifiex_write_reg(adapter,
                                                      CONFIGURATION_REG,
                                                      (cr | 0x04)))
                                        dev_err(adapter->dev,
-                                                       "write CFG reg failed\n");
+                                               "write CFG reg failed\n");
  
                                dev_dbg(adapter->dev, "info: write success\n");
                                if (mwifiex_read_reg(adapter,
                                                     CONFIGURATION_REG, &cr))
                                        dev_err(adapter->dev,
-                                                       "read CFG reg failed\n");
+                                               "read CFG reg failed\n");
  
                                dev_dbg(adapter->dev,
-                                               "info: CFG reg val =%x\n", cr);
+                                       "info: CFG reg val =%x\n", cr);
                                return -1;
                        }
                }
@@@ -1321,7 -1326,7 +1324,7 @@@ static int mwifiex_host_to_card_mp_aggr
  
        if ((!card->mpa_tx.enabled) || (port == CTRL_PORT)) {
                dev_dbg(adapter->dev, "info: %s: tx aggregation disabled\n",
-                                               __func__);
+                       __func__);
  
                f_send_cur_buf = 1;
                goto tx_curr_single;
        if (next_pkt_len) {
                /* More pkt in TX queue */
                dev_dbg(adapter->dev, "info: %s: more packets in queue.\n",
-                                               __func__);
+                       __func__);
  
                if (MP_TX_AGGR_IN_PROGRESS(card)) {
                        if (!MP_TX_AGGR_PORT_LIMIT_REACHED(card) &&
                                f_precopy_cur_buf = 1;
  
                                if (!(card->mp_wr_bitmap &
-                                               (1 << card->curr_wr_port))
-                                               || !MP_TX_AGGR_BUF_HAS_ROOM(
-                                               card, pkt_len + next_pkt_len))
+                                     (1 << card->curr_wr_port)) ||
+                                   !MP_TX_AGGR_BUF_HAS_ROOM(
+                                           card, pkt_len + next_pkt_len))
                                        f_send_aggr_buf = 1;
                        } else {
                                /* No room in Aggr buf, send it */
                                        f_postcopy_cur_buf = 1;
                        }
                } else {
-                       if (MP_TX_AGGR_BUF_HAS_ROOM(card, pkt_len)
-                           && (card->mp_wr_bitmap & (1 << card->curr_wr_port)))
+                       if (MP_TX_AGGR_BUF_HAS_ROOM(card, pkt_len) &&
+                           (card->mp_wr_bitmap & (1 << card->curr_wr_port)))
                                f_precopy_cur_buf = 1;
                        else
                                f_send_cur_buf = 1;
        } else {
                /* Last pkt in TX queue */
                dev_dbg(adapter->dev, "info: %s: Last packet in Tx Queue.\n",
-                                               __func__);
+                       __func__);
  
                if (MP_TX_AGGR_IN_PROGRESS(card)) {
                        /* some packs in Aggr buf already */
  
        if (f_precopy_cur_buf) {
                dev_dbg(adapter->dev, "data: %s: precopy current buffer\n",
-                                               __func__);
+                       __func__);
                MP_TX_AGGR_BUF_PUT(card, payload, pkt_len, port);
  
                if (MP_TX_AGGR_PKT_LIMIT_REACHED(card) ||
  
        if (f_send_aggr_buf) {
                dev_dbg(adapter->dev, "data: %s: send aggr buffer: %d %d\n",
-                               __func__,
+                       __func__,
                                card->mpa_tx.start_port, card->mpa_tx.ports);
                ret = mwifiex_write_data_to_card(adapter, card->mpa_tx.buf,
                                                 card->mpa_tx.buf_len,
  tx_curr_single:
        if (f_send_cur_buf) {
                dev_dbg(adapter->dev, "data: %s: send current buffer %d\n",
-                                               __func__, port);
+                       __func__, port);
                ret = mwifiex_write_data_to_card(adapter, payload, pkt_len,
                                                 adapter->ioport + port);
        }
  
        if (f_postcopy_cur_buf) {
                dev_dbg(adapter->dev, "data: %s: postcopy current buffer\n",
-                                               __func__);
+                       __func__);
                MP_TX_AGGR_BUF_PUT(card, payload, pkt_len, port);
        }
  
@@@ -1458,7 -1463,7 +1461,7 @@@ static int mwifiex_sdio_host_to_card(st
                ret = mwifiex_get_wr_port_data(adapter, &port);
                if (ret) {
                        dev_err(adapter->dev, "%s: no wr_port available\n",
-                                               __func__);
+                               __func__);
                        return ret;
                }
        } else {
                if (pkt_len <= INTF_HEADER_LEN ||
                    pkt_len > MWIFIEX_UPLD_SIZE)
                        dev_err(adapter->dev, "%s: payload=%p, nb=%d\n",
-                                       __func__, payload, pkt_len);
+                               __func__, payload, pkt_len);
        }
  
        /* Transfer data to card */
  
        if (tx_param)
                ret = mwifiex_host_to_card_mp_aggr(adapter, payload, pkt_len,
-                               port, tx_param->next_pkt_len);
+                                                  port, tx_param->next_pkt_len
+                                                  );
        else
                ret = mwifiex_host_to_card_mp_aggr(adapter, payload, pkt_len,
-                               port, 0);
+                                                  port, 0);
  
        if (ret) {
                if (type == MWIFIEX_TYPE_CMD)
@@@ -1732,7 -1738,7 +1736,7 @@@ mwifiex_update_mp_end_port(struct mwifi
        card->curr_wr_port = 1;
  
        dev_dbg(adapter->dev, "cmd: mp_end_port %d, data port mask 0x%x\n",
-              port, card->mp_data_port_mask);
+               port, card->mp_data_port_mask);
  }
  
  static struct mwifiex_if_ops sdio_ops = {
This page took 0.205563 seconds and 4 git commands to generate.