From e7392364fcd1004a5e495f15cf21b1e0ef874215 Mon Sep 17 00:00:00 2001
From: Stanislaw Gruszka <sgruszka@redhat.com>
Date: Tue, 15 Nov 2011 14:45:59 +0100
Subject: iwlegacy: indentions and whitespaces

Process iwlegacy source files using:

indent -npro -l500 -nhnl
indent -npro -kr -i8 -ts8 -sob -l80 -nbbo -ss -ncs -cp1 -il0 -psl

Plus manual compilation fixes.

Signed-off-by: Stanislaw Gruszka <sgruszka@redhat.com>
---
 drivers/net/wireless/iwlegacy/4965-mac.c | 2173 +++++++++++++++---------------
 1 file changed, 1069 insertions(+), 1104 deletions(-)

(limited to 'drivers/net/wireless/iwlegacy/4965-mac.c')

diff --git a/drivers/net/wireless/iwlegacy/4965-mac.c b/drivers/net/wireless/iwlegacy/4965-mac.c
index 9e3f74c8e9a..ca819d87209 100644
--- a/drivers/net/wireless/iwlegacy/4965-mac.c
+++ b/drivers/net/wireless/iwlegacy/4965-mac.c
@@ -53,7 +53,6 @@
 #include "common.h"
 #include "4965.h"
 
-
 /******************************************************************************
  *
  * module boiler plate
@@ -73,15 +72,14 @@
 
 #define DRV_VERSION     IWLWIFI_VERSION VD
 
-
 MODULE_DESCRIPTION(DRV_DESCRIPTION);
 MODULE_VERSION(DRV_VERSION);
 MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("iwl4965");
 
-void il4965_check_abort_status(struct il_priv *il,
-			    u8 frame_count, u32 status)
+void
+il4965_check_abort_status(struct il_priv *il, u8 frame_count, u32 status)
 {
 	if (frame_count == 1 && status == TX_STATUS_FAIL_RFKILL_FLUSH) {
 		IL_ERR("Tx flush command to flush out all frames\n");
@@ -99,7 +97,8 @@ struct il_mod_params il4965_mod_params = {
 	/* the rest are 0 by default */
 };
 
-void il4965_rx_queue_reset(struct il_priv *il, struct il_rx_queue *rxq)
+void
+il4965_rx_queue_reset(struct il_priv *il, struct il_rx_queue *rxq)
 {
 	unsigned long flags;
 	int i;
@@ -112,8 +111,8 @@ void il4965_rx_queue_reset(struct il_priv *il, struct il_rx_queue *rxq)
 		 * to an SKB, so we need to unmap and free potential storage */
 		if (rxq->pool[i].page != NULL) {
 			pci_unmap_page(il->pci_dev, rxq->pool[i].page_dma,
-				PAGE_SIZE << il->hw_params.rx_page_order,
-				PCI_DMA_FROMDEVICE);
+				       PAGE_SIZE << il->hw_params.rx_page_order,
+				       PCI_DMA_FROMDEVICE);
 			__il_free_pages(il, rxq->pool[i].page);
 			rxq->pool[i].page = NULL;
 		}
@@ -131,10 +130,11 @@ void il4965_rx_queue_reset(struct il_priv *il, struct il_rx_queue *rxq)
 	spin_unlock_irqrestore(&rxq->lock, flags);
 }
 
-int il4965_rx_init(struct il_priv *il, struct il_rx_queue *rxq)
+int
+il4965_rx_init(struct il_priv *il, struct il_rx_queue *rxq)
 {
 	u32 rb_size;
-	const u32 rfdnlog = RX_QUEUE_SIZE_LOG; /* 256 RBDs */
+	const u32 rfdnlog = RX_QUEUE_SIZE_LOG;	/* 256 RBDs */
 	u32 rb_timeout = 0;
 
 	if (il->cfg->mod_params->amsdu_size_8K)
@@ -149,12 +149,10 @@ int il4965_rx_init(struct il_priv *il, struct il_rx_queue *rxq)
 	il_wr(il, FH49_RSCSR_CHNL0_RBDCB_WPTR_REG, 0);
 
 	/* Tell device where to find RBD circular buffer in DRAM */
-	il_wr(il, FH49_RSCSR_CHNL0_RBDCB_BASE_REG,
-			   (u32)(rxq->bd_dma >> 8));
+	il_wr(il, FH49_RSCSR_CHNL0_RBDCB_BASE_REG, (u32) (rxq->bd_dma >> 8));
 
 	/* Tell device where in DRAM to update its Rx status */
-	il_wr(il, FH49_RSCSR_CHNL0_STTS_WPTR_REG,
-			   rxq->rb_stts_dma >> 4);
+	il_wr(il, FH49_RSCSR_CHNL0_STTS_WPTR_REG, rxq->rb_stts_dma >> 4);
 
 	/* Enable Rx DMA
 	 * Direct rx interrupts to hosts
@@ -163,12 +161,12 @@ int il4965_rx_init(struct il_priv *il, struct il_rx_queue *rxq)
 	 * 256 RBDs
 	 */
 	il_wr(il, FH49_MEM_RCSR_CHNL0_CONFIG_REG,
-			   FH49_RCSR_RX_CONFIG_CHNL_EN_ENABLE_VAL |
-			   FH49_RCSR_CHNL0_RX_CONFIG_IRQ_DEST_INT_HOST_VAL |
-			   FH49_RCSR_CHNL0_RX_CONFIG_SINGLE_FRAME_MSK |
-			   rb_size|
-			   (rb_timeout << FH49_RCSR_RX_CONFIG_REG_IRQ_RBTH_POS)|
-			   (rfdnlog << FH49_RCSR_RX_CONFIG_RBDCB_SIZE_POS));
+	      FH49_RCSR_RX_CONFIG_CHNL_EN_ENABLE_VAL |
+	      FH49_RCSR_CHNL0_RX_CONFIG_IRQ_DEST_INT_HOST_VAL |
+	      FH49_RCSR_CHNL0_RX_CONFIG_SINGLE_FRAME_MSK | rb_size | (rb_timeout
+								      <<
+								      FH49_RCSR_RX_CONFIG_REG_IRQ_RBTH_POS)
+	      | (rfdnlog << FH49_RCSR_RX_CONFIG_RBDCB_SIZE_POS));
 
 	/* Set interrupt coalescing timer to default (2048 usecs) */
 	il_write8(il, CSR_INT_COALESCING, IL_HOST_INT_TIMEOUT_DEF);
@@ -176,7 +174,8 @@ int il4965_rx_init(struct il_priv *il, struct il_rx_queue *rxq)
 	return 0;
 }
 
-static void il4965_set_pwr_vmain(struct il_priv *il)
+static void
+il4965_set_pwr_vmain(struct il_priv *il)
 {
 /*
  * (for documentation purposes)
@@ -189,11 +188,12 @@ static void il4965_set_pwr_vmain(struct il_priv *il)
  */
 
 	il_set_bits_mask_prph(il, APMG_PS_CTRL_REG,
-			       APMG_PS_CTRL_VAL_PWR_SRC_VMAIN,
-			       ~APMG_PS_CTRL_MSK_PWR_SRC);
+			      APMG_PS_CTRL_VAL_PWR_SRC_VMAIN,
+			      ~APMG_PS_CTRL_MSK_PWR_SRC);
 }
 
-int il4965_hw_nic_init(struct il_priv *il)
+int
+il4965_hw_nic_init(struct il_priv *il)
 {
 	unsigned long flags;
 	struct il_rx_queue *rxq = &il->rxq;
@@ -249,10 +249,10 @@ int il4965_hw_nic_init(struct il_priv *il)
 /**
  * il4965_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
  */
-static inline __le32 il4965_dma_addr2rbd_ptr(struct il_priv *il,
-					  dma_addr_t dma_addr)
+static inline __le32
+il4965_dma_addr2rbd_ptr(struct il_priv *il, dma_addr_t dma_addr)
 {
-	return cpu_to_le32((u32)(dma_addr >> 8));
+	return cpu_to_le32((u32) (dma_addr >> 8));
 }
 
 /**
@@ -266,7 +266,8 @@ static inline __le32 il4965_dma_addr2rbd_ptr(struct il_priv *il,
  * also updates the memory address in the firmware to reference the new
  * target buffer.
  */
-void il4965_rx_queue_restock(struct il_priv *il)
+void
+il4965_rx_queue_restock(struct il_priv *il)
 {
 	struct il_rx_queue *rxq = &il->rxq;
 	struct list_head *element;
@@ -285,8 +286,8 @@ void il4965_rx_queue_restock(struct il_priv *il)
 		list_del(element);
 
 		/* Point to Rx buffer via next RBD in circular buffer */
-		rxq->bd[rxq->write] = il4965_dma_addr2rbd_ptr(il,
-							      rxb->page_dma);
+		rxq->bd[rxq->write] =
+		    il4965_dma_addr2rbd_ptr(il, rxb->page_dma);
 		rxq->queue[rxq->write] = rxb;
 		rxq->write = (rxq->write + 1) & RX_QUEUE_MASK;
 		rxq->free_count--;
@@ -297,7 +298,6 @@ void il4965_rx_queue_restock(struct il_priv *il)
 	if (rxq->free_count <= RX_LOW_WATERMARK)
 		queue_work(il->workqueue, &il->rx_replenish);
 
-
 	/* If we've added more space for the firmware to place data, tell it.
 	 * Increment device's write pointer in multiples of 8. */
 	if (rxq->write_actual != (rxq->write & ~0x7)) {
@@ -316,7 +316,8 @@ void il4965_rx_queue_restock(struct il_priv *il)
  * Also restock the Rx queue via il_rx_queue_restock.
  * This is called as a scheduled work item (except for during initialization)
  */
-static void il4965_rx_allocate(struct il_priv *il, gfp_t priority)
+static void
+il4965_rx_allocate(struct il_priv *il, gfp_t priority)
 {
 	struct il_rx_queue *rxq = &il->rxq;
 	struct list_head *element;
@@ -343,18 +344,16 @@ static void il4965_rx_allocate(struct il_priv *il, gfp_t priority)
 		page = alloc_pages(gfp_mask, il->hw_params.rx_page_order);
 		if (!page) {
 			if (net_ratelimit())
-				D_INFO("alloc_pages failed, "
-					       "order: %d\n",
-					       il->hw_params.rx_page_order);
+				D_INFO("alloc_pages failed, " "order: %d\n",
+				       il->hw_params.rx_page_order);
 
 			if (rxq->free_count <= RX_LOW_WATERMARK &&
 			    net_ratelimit())
-				IL_ERR(
-					"Failed to alloc_pages with %s. "
-					"Only %u free buffers remaining.\n",
-					 priority == GFP_ATOMIC ?
-						 "GFP_ATOMIC" : "GFP_KERNEL",
-					 rxq->free_count);
+				IL_ERR("Failed to alloc_pages with %s. "
+				       "Only %u free buffers remaining.\n",
+				       priority ==
+				       GFP_ATOMIC ? "GFP_ATOMIC" : "GFP_KERNEL",
+				       rxq->free_count);
 			/* We don't reschedule replenish work here -- we will
 			 * call the restock method and if it still needs
 			 * more buffers it will schedule replenish */
@@ -377,9 +376,10 @@ static void il4965_rx_allocate(struct il_priv *il, gfp_t priority)
 		BUG_ON(rxb->page);
 		rxb->page = page;
 		/* Get physical address of the RB */
-		rxb->page_dma = pci_map_page(il->pci_dev, page, 0,
-				PAGE_SIZE << il->hw_params.rx_page_order,
-				PCI_DMA_FROMDEVICE);
+		rxb->page_dma =
+		    pci_map_page(il->pci_dev, page, 0,
+				 PAGE_SIZE << il->hw_params.rx_page_order,
+				 PCI_DMA_FROMDEVICE);
 		/* dma address must be no more than 36 bits */
 		BUG_ON(rxb->page_dma & ~DMA_BIT_MASK(36));
 		/* and also 256 byte aligned! */
@@ -395,7 +395,8 @@ static void il4965_rx_allocate(struct il_priv *il, gfp_t priority)
 	}
 }
 
-void il4965_rx_replenish(struct il_priv *il)
+void
+il4965_rx_replenish(struct il_priv *il)
 {
 	unsigned long flags;
 
@@ -406,7 +407,8 @@ void il4965_rx_replenish(struct il_priv *il)
 	spin_unlock_irqrestore(&il->lock, flags);
 }
 
-void il4965_rx_replenish_now(struct il_priv *il)
+void
+il4965_rx_replenish_now(struct il_priv *il)
 {
 	il4965_rx_allocate(il, GFP_ATOMIC);
 
@@ -418,14 +420,15 @@ void il4965_rx_replenish_now(struct il_priv *il)
  * This free routine walks the list of POOL entries and if SKB is set to
  * non NULL it is unmapped and freed
  */
-void il4965_rx_queue_free(struct il_priv *il, struct il_rx_queue *rxq)
+void
+il4965_rx_queue_free(struct il_priv *il, struct il_rx_queue *rxq)
 {
 	int i;
 	for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
 		if (rxq->pool[i].page != NULL) {
 			pci_unmap_page(il->pci_dev, rxq->pool[i].page_dma,
-				PAGE_SIZE << il->hw_params.rx_page_order,
-				PCI_DMA_FROMDEVICE);
+				       PAGE_SIZE << il->hw_params.rx_page_order,
+				       PCI_DMA_FROMDEVICE);
 			__il_free_pages(il, rxq->pool[i].page);
 			rxq->pool[i].page = NULL;
 		}
@@ -436,21 +439,23 @@ void il4965_rx_queue_free(struct il_priv *il, struct il_rx_queue *rxq)
 	dma_free_coherent(&il->pci_dev->dev, sizeof(struct il_rb_status),
 			  rxq->rb_stts, rxq->rb_stts_dma);
 	rxq->bd = NULL;
-	rxq->rb_stts  = NULL;
+	rxq->rb_stts = NULL;
 }
 
-int il4965_rxq_stop(struct il_priv *il)
+int
+il4965_rxq_stop(struct il_priv *il)
 {
 
 	/* stop Rx DMA */
 	il_wr(il, FH49_MEM_RCSR_CHNL0_CONFIG_REG, 0);
 	il_poll_bit(il, FH49_MEM_RSSR_RX_STATUS_REG,
-			    FH49_RSSR_CHNL0_RX_STATUS_CHNL_IDLE, 1000);
+		    FH49_RSSR_CHNL0_RX_STATUS_CHNL_IDLE, 1000);
 
 	return 0;
 }
 
-int il4965_hwrate_to_mac80211_idx(u32 rate_n_flags, enum ieee80211_band band)
+int
+il4965_hwrate_to_mac80211_idx(u32 rate_n_flags, enum ieee80211_band band)
 {
 	int idx = 0;
 	int band_offset = 0;
@@ -459,7 +464,7 @@ int il4965_hwrate_to_mac80211_idx(u32 rate_n_flags, enum ieee80211_band band)
 	if (rate_n_flags & RATE_MCS_HT_MSK) {
 		idx = (rate_n_flags & 0xff);
 		return idx;
-	/* Legacy rate format, search for match in table */
+		/* Legacy rate format, search for match in table */
 	} else {
 		if (band == IEEE80211_BAND_5GHZ)
 			band_offset = IL_FIRST_OFDM_RATE;
@@ -471,19 +476,20 @@ int il4965_hwrate_to_mac80211_idx(u32 rate_n_flags, enum ieee80211_band band)
 	return -1;
 }
 
-static int il4965_calc_rssi(struct il_priv *il,
-			     struct il_rx_phy_res *rx_resp)
+static int
+il4965_calc_rssi(struct il_priv *il, struct il_rx_phy_res *rx_resp)
 {
 	/* data from PHY/DSP regarding signal strength, etc.,
 	 *   contents are always there, not configurable by host.  */
 	struct il4965_rx_non_cfg_phy *ncphy =
 	    (struct il4965_rx_non_cfg_phy *)rx_resp->non_cfg_phy_buf;
-	u32 agc = (le16_to_cpu(ncphy->agc_info) & IL49_AGC_DB_MASK)
-			>> IL49_AGC_DB_POS;
+	u32 agc =
+	    (le16_to_cpu(ncphy->agc_info) & IL49_AGC_DB_MASK) >>
+	    IL49_AGC_DB_POS;
 
 	u32 valid_antennae =
 	    (le16_to_cpu(rx_resp->phy_flags) & IL49_RX_PHY_FLAGS_ANTENNAE_MASK)
-			>> IL49_RX_PHY_FLAGS_ANTENNAE_OFFSET;
+	    >> IL49_RX_PHY_FLAGS_ANTENNAE_OFFSET;
 	u8 max_rssi = 0;
 	u32 i;
 
@@ -505,31 +511,32 @@ static int il4965_calc_rssi(struct il_priv *il,
 	return max_rssi - agc - IL4965_RSSI_OFFSET;
 }
 
-
-static u32 il4965_translate_rx_status(struct il_priv *il, u32 decrypt_in)
+static u32
+il4965_translate_rx_status(struct il_priv *il, u32 decrypt_in)
 {
 	u32 decrypt_out = 0;
 
 	if ((decrypt_in & RX_RES_STATUS_STATION_FOUND) ==
-					RX_RES_STATUS_STATION_FOUND)
-		decrypt_out |= (RX_RES_STATUS_STATION_FOUND |
-				RX_RES_STATUS_NO_STATION_INFO_MISMATCH);
+	    RX_RES_STATUS_STATION_FOUND)
+		decrypt_out |=
+		    (RX_RES_STATUS_STATION_FOUND |
+		     RX_RES_STATUS_NO_STATION_INFO_MISMATCH);
 
 	decrypt_out |= (decrypt_in & RX_RES_STATUS_SEC_TYPE_MSK);
 
 	/* packet was not encrypted */
 	if ((decrypt_in & RX_RES_STATUS_SEC_TYPE_MSK) ==
-					RX_RES_STATUS_SEC_TYPE_NONE)
+	    RX_RES_STATUS_SEC_TYPE_NONE)
 		return decrypt_out;
 
 	/* packet was encrypted with unknown alg */
 	if ((decrypt_in & RX_RES_STATUS_SEC_TYPE_MSK) ==
-					RX_RES_STATUS_SEC_TYPE_ERR)
+	    RX_RES_STATUS_SEC_TYPE_ERR)
 		return decrypt_out;
 
 	/* decryption was not done in HW */
 	if ((decrypt_in & RX_MPDU_RES_STATUS_DEC_DONE_MSK) !=
-					RX_MPDU_RES_STATUS_DEC_DONE_MSK)
+	    RX_MPDU_RES_STATUS_DEC_DONE_MSK)
 		return decrypt_out;
 
 	switch (decrypt_in & RX_RES_STATUS_SEC_TYPE_MSK) {
@@ -559,26 +566,22 @@ static u32 il4965_translate_rx_status(struct il_priv *il, u32 decrypt_in)
 		break;
 	}
 
-	D_RX("decrypt_in:0x%x  decrypt_out = 0x%x\n",
-					decrypt_in, decrypt_out);
+	D_RX("decrypt_in:0x%x  decrypt_out = 0x%x\n", decrypt_in, decrypt_out);
 
 	return decrypt_out;
 }
 
-static void il4965_pass_packet_to_mac80211(struct il_priv *il,
-					struct ieee80211_hdr *hdr,
-					u16 len,
-					u32 ampdu_status,
-					struct il_rx_buf *rxb,
-					struct ieee80211_rx_status *stats)
+static void
+il4965_pass_packet_to_mac80211(struct il_priv *il, struct ieee80211_hdr *hdr,
+			       u16 len, u32 ampdu_status, struct il_rx_buf *rxb,
+			       struct ieee80211_rx_status *stats)
 {
 	struct sk_buff *skb;
 	__le16 fc = hdr->frame_control;
 
 	/* We only process data packets if the interface is open */
 	if (unlikely(!il->is_open)) {
-		D_DROP(
-		    "Dropping packet while interface is not open.\n");
+		D_DROP("Dropping packet while interface is not open.\n");
 		return;
 	}
 
@@ -605,8 +608,8 @@ static void il4965_pass_packet_to_mac80211(struct il_priv *il,
 
 /* Called for N_RX (legacy ABG frames), or
  * N_RX_MPDU (HT high-throughput N frames). */
-void il4965_hdl_rx(struct il_priv *il,
-				struct il_rx_buf *rxb)
+void
+il4965_hdl_rx(struct il_priv *il, struct il_rx_buf *rxb)
 {
 	struct ieee80211_hdr *header;
 	struct ieee80211_rx_status rx_status;
@@ -629,12 +632,14 @@ void il4965_hdl_rx(struct il_priv *il,
 	 */
 	if (pkt->hdr.cmd == N_RX) {
 		phy_res = (struct il_rx_phy_res *)pkt->u.raw;
-		header = (struct ieee80211_hdr *)(pkt->u.raw + sizeof(*phy_res)
-				+ phy_res->cfg_phy_cnt);
+		header =
+		    (struct ieee80211_hdr *)(pkt->u.raw + sizeof(*phy_res) +
+					     phy_res->cfg_phy_cnt);
 
 		len = le16_to_cpu(phy_res->byte_count);
-		rx_pkt_status = *(__le32 *)(pkt->u.raw + sizeof(*phy_res) +
-				phy_res->cfg_phy_cnt + len);
+		rx_pkt_status =
+		    *(__le32 *) (pkt->u.raw + sizeof(*phy_res) +
+				 phy_res->cfg_phy_cnt + len);
 		ampdu_status = le32_to_cpu(rx_pkt_status);
 	} else {
 		if (!il->_4965.last_phy_res_valid) {
@@ -645,21 +650,20 @@ void il4965_hdl_rx(struct il_priv *il,
 		amsdu = (struct il_rx_mpdu_res_start *)pkt->u.raw;
 		header = (struct ieee80211_hdr *)(pkt->u.raw + sizeof(*amsdu));
 		len = le16_to_cpu(amsdu->byte_count);
-		rx_pkt_status = *(__le32 *)(pkt->u.raw + sizeof(*amsdu) + len);
-		ampdu_status = il4965_translate_rx_status(il,
-				le32_to_cpu(rx_pkt_status));
+		rx_pkt_status = *(__le32 *) (pkt->u.raw + sizeof(*amsdu) + len);
+		ampdu_status =
+		    il4965_translate_rx_status(il, le32_to_cpu(rx_pkt_status));
 	}
 
 	if ((unlikely(phy_res->cfg_phy_cnt > 20))) {
 		D_DROP("dsp size out of range [0,20]: %d/n",
-				phy_res->cfg_phy_cnt);
+		       phy_res->cfg_phy_cnt);
 		return;
 	}
 
 	if (!(rx_pkt_status & RX_RES_STATUS_NO_CRC32_ERROR) ||
 	    !(rx_pkt_status & RX_RES_STATUS_NO_RXE_OVERFLOW)) {
-		D_RX("Bad CRC or FIFO: 0x%08X.\n",
-				le32_to_cpu(rx_pkt_status));
+		D_RX("Bad CRC or FIFO: 0x%08X.\n", le32_to_cpu(rx_pkt_status));
 		return;
 	}
 
@@ -668,18 +672,20 @@ void il4965_hdl_rx(struct il_priv *il,
 
 	/* rx_status carries information about the packet to mac80211 */
 	rx_status.mactime = le64_to_cpu(phy_res->timestamp);
-	rx_status.band = (phy_res->phy_flags & RX_RES_PHY_FLAGS_BAND_24_MSK) ?
-				IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
+	rx_status.band =
+	    (phy_res->
+	     phy_flags & RX_RES_PHY_FLAGS_BAND_24_MSK) ? IEEE80211_BAND_2GHZ :
+	    IEEE80211_BAND_5GHZ;
 	rx_status.freq =
-		ieee80211_channel_to_frequency(le16_to_cpu(phy_res->channel),
-							rx_status.band);
+	    ieee80211_channel_to_frequency(le16_to_cpu(phy_res->channel),
+					   rx_status.band);
 	rx_status.rate_idx =
-		il4965_hwrate_to_mac80211_idx(rate_n_flags, rx_status.band);
+	    il4965_hwrate_to_mac80211_idx(rate_n_flags, rx_status.band);
 	rx_status.flag = 0;
 
 	/* TSF isn't reliable. In order to allow smooth user experience,
 	 * this W/A doesn't propagate it to the mac80211 */
-	/*rx_status.flag |= RX_FLAG_MACTIME_MPDU;*/
+	/*rx_status.flag |= RX_FLAG_MACTIME_MPDU; */
 
 	il->ucode_beacon_time = le32_to_cpu(phy_res->beacon_time_stamp);
 
@@ -687,8 +693,8 @@ void il4965_hdl_rx(struct il_priv *il,
 	rx_status.signal = il4965_calc_rssi(il, phy_res);
 
 	il_dbg_log_rx_data_frame(il, len, header);
-	D_STATS("Rssi %d, TSF %llu\n",
-		rx_status.signal, (unsigned long long)rx_status.mactime);
+	D_STATS("Rssi %d, TSF %llu\n", rx_status.signal,
+		(unsigned long long)rx_status.mactime);
 
 	/*
 	 * "antenna number"
@@ -704,8 +710,8 @@ void il4965_hdl_rx(struct il_priv *il,
 	 * as a bitmask.
 	 */
 	rx_status.antenna =
-		(le16_to_cpu(phy_res->phy_flags) & RX_RES_PHY_FLAGS_ANTENNA_MSK)
-		>> RX_RES_PHY_FLAGS_ANTENNA_POS;
+	    (le16_to_cpu(phy_res->phy_flags) & RX_RES_PHY_FLAGS_ANTENNA_MSK) >>
+	    RX_RES_PHY_FLAGS_ANTENNA_POS;
 
 	/* set the preamble flag if appropriate */
 	if (phy_res->phy_flags & RX_RES_PHY_FLAGS_SHORT_PREAMBLE_MSK)
@@ -719,14 +725,14 @@ void il4965_hdl_rx(struct il_priv *il,
 	if (rate_n_flags & RATE_MCS_SGI_MSK)
 		rx_status.flag |= RX_FLAG_SHORT_GI;
 
-	il4965_pass_packet_to_mac80211(il, header, len, ampdu_status,
-				    rxb, &rx_status);
+	il4965_pass_packet_to_mac80211(il, header, len, ampdu_status, rxb,
+				       &rx_status);
 }
 
 /* Cache phy data (Rx signal strength, etc) for HT frame (N_RX_PHY).
  * This will be used later in il_hdl_rx() for N_RX_MPDU. */
-void il4965_hdl_rx_phy(struct il_priv *il,
-			    struct il_rx_buf *rxb)
+void
+il4965_hdl_rx_phy(struct il_priv *il, struct il_rx_buf *rxb)
 {
 	struct il_rx_pkt *pkt = rxb_addr(rxb);
 	il->_4965.last_phy_res_valid = true;
@@ -734,11 +740,10 @@ void il4965_hdl_rx_phy(struct il_priv *il,
 	       sizeof(struct il_rx_phy_res));
 }
 
-static int il4965_get_channels_for_scan(struct il_priv *il,
-				     struct ieee80211_vif *vif,
-				     enum ieee80211_band band,
-				     u8 is_active, u8 n_probes,
-				     struct il_scan_channel *scan_ch)
+static int
+il4965_get_channels_for_scan(struct il_priv *il, struct ieee80211_vif *vif,
+			     enum ieee80211_band band, u8 is_active,
+			     u8 n_probes, struct il_scan_channel *scan_ch)
 {
 	struct ieee80211_channel *chan;
 	const struct ieee80211_supported_band *sband;
@@ -769,9 +774,8 @@ static int il4965_get_channels_for_scan(struct il_priv *il,
 
 		ch_info = il_get_channel_info(il, band, channel);
 		if (!il_is_channel_valid(ch_info)) {
-			D_SCAN(
-				 "Channel %d is INVALID for this band.\n",
-					channel);
+			D_SCAN("Channel %d is INVALID for this band.\n",
+			       channel);
 			continue;
 		}
 
@@ -799,12 +803,13 @@ static int il4965_get_channels_for_scan(struct il_priv *il,
 		else
 			scan_ch->tx_gain = ((1 << 5) | (5 << 3));
 
-		D_SCAN("Scanning ch=%d prob=0x%X [%s %d]\n",
-			       channel, le32_to_cpu(scan_ch->type),
-			       (scan_ch->type & SCAN_CHANNEL_TYPE_ACTIVE) ?
-				"ACTIVE" : "PASSIVE",
-			       (scan_ch->type & SCAN_CHANNEL_TYPE_ACTIVE) ?
-			       active_dwell : passive_dwell);
+		D_SCAN("Scanning ch=%d prob=0x%X [%s %d]\n", channel,
+		       le32_to_cpu(scan_ch->type),
+		       (scan_ch->
+			type & SCAN_CHANNEL_TYPE_ACTIVE) ? "ACTIVE" : "PASSIVE",
+		       (scan_ch->
+			type & SCAN_CHANNEL_TYPE_ACTIVE) ? active_dwell :
+		       passive_dwell);
 
 		scan_ch++;
 		added++;
@@ -814,12 +819,14 @@ static int il4965_get_channels_for_scan(struct il_priv *il,
 	return added;
 }
 
-static inline u32 il4965_ant_idx_to_flags(u8 ant_idx)
+static inline u32
+il4965_ant_idx_to_flags(u8 ant_idx)
 {
 	return BIT(ant_idx) << RATE_MCS_ANT_POS;
 }
 
-int il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
+int
+il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
 {
 	struct il_host_cmd cmd = {
 		.id = C_SCAN,
@@ -836,7 +843,7 @@ int il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
 	u8 rx_ant = il->hw_params.valid_rx_ant;
 	u8 rate;
 	bool is_active = false;
-	int  chan_mod;
+	int chan_mod;
 	u8 active_chains;
 	u8 scan_tx_antennas = il->hw_params.valid_tx_ant;
 	int ret;
@@ -847,11 +854,11 @@ int il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
 		ctx = il_rxon_ctx_from_vif(vif);
 
 	if (!il->scan_cmd) {
-		il->scan_cmd = kmalloc(sizeof(struct il_scan_cmd) +
-					 IL_MAX_SCAN_SIZE, GFP_KERNEL);
+		il->scan_cmd =
+		    kmalloc(sizeof(struct il_scan_cmd) + IL_MAX_SCAN_SIZE,
+			    GFP_KERNEL);
 		if (!il->scan_cmd) {
-			D_SCAN(
-				       "fail to allocate memory for scan\n");
+			D_SCAN("fail to allocate memory for scan\n");
 			return -ENOMEM;
 		}
 	}
@@ -876,11 +883,11 @@ int il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
 			interval = suspend_time;
 
 		extra = (suspend_time / interval) << 22;
-		scan_suspend_time = (extra |
-		    ((suspend_time % interval) * 1024));
+		scan_suspend_time =
+		    (extra | ((suspend_time % interval) * 1024));
 		scan->suspend_time = cpu_to_le32(scan_suspend_time);
 		D_SCAN("suspend_time 0x%X beacon interval %d\n",
-			       scan_suspend_time, interval);
+		       scan_suspend_time, interval);
 	}
 
 	if (il->scan_request->n_ssids) {
@@ -892,7 +899,7 @@ int il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
 				continue;
 			scan->direct_scan[p].id = WLAN_EID_SSID;
 			scan->direct_scan[p].len =
-				il->scan_request->ssids[i].ssid_len;
+			    il->scan_request->ssids[i].ssid_len;
 			memcpy(scan->direct_scan[p].ssid,
 			       il->scan_request->ssids[i].ssid,
 			       il->scan_request->ssids[i].ssid_len);
@@ -910,10 +917,10 @@ int il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
 	switch (il->scan_band) {
 	case IEEE80211_BAND_2GHZ:
 		scan->flags = RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK;
-		chan_mod = le32_to_cpu(
-			il->ctx.active.flags &
-						RXON_FLG_CHANNEL_MODE_MSK)
-				       >> RXON_FLG_CHANNEL_MODE_POS;
+		chan_mod =
+		    le32_to_cpu(il->ctx.active.
+				flags & RXON_FLG_CHANNEL_MODE_MSK) >>
+		    RXON_FLG_CHANNEL_MODE_POS;
 		if (chan_mod == CHANNEL_MODE_PURE_40) {
 			rate = RATE_6M_PLCP;
 		} else {
@@ -946,30 +953,30 @@ int il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
 	 * the aforementioned issue. Thus use IL_GOOD_CRC_TH_NEVER
 	 * here instead of IL_GOOD_CRC_TH_DISABLED.
 	 */
-	scan->good_CRC_th = is_active ? IL_GOOD_CRC_TH_DEFAULT :
-					IL_GOOD_CRC_TH_NEVER;
+	scan->good_CRC_th =
+	    is_active ? IL_GOOD_CRC_TH_DEFAULT : IL_GOOD_CRC_TH_NEVER;
 
 	band = il->scan_band;
 
 	if (il->cfg->scan_rx_antennas[band])
 		rx_ant = il->cfg->scan_rx_antennas[band];
 
-	il->scan_tx_ant[band] = il4965_toggle_tx_ant(il,
-						il->scan_tx_ant[band],
-						    scan_tx_antennas);
+	il->scan_tx_ant[band] =
+	    il4965_toggle_tx_ant(il, il->scan_tx_ant[band], scan_tx_antennas);
 	rate_flags |= il4965_ant_idx_to_flags(il->scan_tx_ant[band]);
-	scan->tx_cmd.rate_n_flags = il4965_hw_set_rate_n_flags(rate, rate_flags);
+	scan->tx_cmd.rate_n_flags =
+	    il4965_hw_set_rate_n_flags(rate, rate_flags);
 
 	/* In power save mode use one chain, otherwise use all chains */
 	if (test_bit(S_POWER_PMI, &il->status)) {
 		/* rx_ant has been set to all valid chains previously */
-		active_chains = rx_ant &
-				((u8)(il->chain_noise_data.active_chains));
+		active_chains =
+		    rx_ant & ((u8) (il->chain_noise_data.active_chains));
 		if (!active_chains)
 			active_chains = rx_ant;
 
 		D_SCAN("chain_noise_data.active_chains: %u\n",
-				il->chain_noise_data.active_chains);
+		       il->chain_noise_data.active_chains);
 
 		rx_ant = il4965_first_antenna(active_chains);
 	}
@@ -981,26 +988,26 @@ int il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
 	rx_chain |= 0x1 << RXON_RX_CHAIN_DRIVER_FORCE_POS;
 	scan->rx_chain = cpu_to_le16(rx_chain);
 
-	cmd_len = il_fill_probe_req(il,
-					(struct ieee80211_mgmt *)scan->data,
-					vif->addr,
-					il->scan_request->ie,
-					il->scan_request->ie_len,
-					IL_MAX_SCAN_SIZE - sizeof(*scan));
+	cmd_len =
+	    il_fill_probe_req(il, (struct ieee80211_mgmt *)scan->data,
+			      vif->addr, il->scan_request->ie,
+			      il->scan_request->ie_len,
+			      IL_MAX_SCAN_SIZE - sizeof(*scan));
 	scan->tx_cmd.len = cpu_to_le16(cmd_len);
 
-	scan->filter_flags |= (RXON_FILTER_ACCEPT_GRP_MSK |
-			       RXON_FILTER_BCON_AWARE_MSK);
+	scan->filter_flags |=
+	    (RXON_FILTER_ACCEPT_GRP_MSK | RXON_FILTER_BCON_AWARE_MSK);
 
-	scan->channel_count = il4965_get_channels_for_scan(il, vif, band,
-						is_active, n_probes,
-						(void *)&scan->data[cmd_len]);
+	scan->channel_count =
+	    il4965_get_channels_for_scan(il, vif, band, is_active, n_probes,
+					 (void *)&scan->data[cmd_len]);
 	if (scan->channel_count == 0) {
 		D_SCAN("channel count %d\n", scan->channel_count);
 		return -EIO;
 	}
 
-	cmd.len += le16_to_cpu(scan->tx_cmd.len) +
+	cmd.len +=
+	    le16_to_cpu(scan->tx_cmd.len) +
 	    scan->channel_count * sizeof(struct il_scan_channel);
 	cmd.data = scan;
 	scan->len = cpu_to_le16(cmd.len);
@@ -1014,8 +1021,9 @@ int il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
 	return ret;
 }
 
-int il4965_manage_ibss_station(struct il_priv *il,
-			       struct ieee80211_vif *vif, bool add)
+int
+il4965_manage_ibss_station(struct il_priv *il, struct ieee80211_vif *vif,
+			   bool add)
 {
 	struct il_vif_priv *vif_priv = (void *)vif->drv_priv;
 
@@ -1024,11 +1032,11 @@ int il4965_manage_ibss_station(struct il_priv *il,
 						vif->bss_conf.bssid,
 						&vif_priv->ibss_bssid_sta_id);
 	return il_remove_station(il, vif_priv->ibss_bssid_sta_id,
-				  vif->bss_conf.bssid);
+				 vif->bss_conf.bssid);
 }
 
-void il4965_free_tfds_in_queue(struct il_priv *il,
-			    int sta_id, int tid, int freed)
+void
+il4965_free_tfds_in_queue(struct il_priv *il, int sta_id, int tid, int freed)
 {
 	lockdep_assert_held(&il->sta_lock);
 
@@ -1036,18 +1044,18 @@ void il4965_free_tfds_in_queue(struct il_priv *il,
 		il->stations[sta_id].tid[tid].tfds_in_queue -= freed;
 	else {
 		D_TX("free more than tfds_in_queue (%u:%d)\n",
-			il->stations[sta_id].tid[tid].tfds_in_queue,
-			freed);
+		     il->stations[sta_id].tid[tid].tfds_in_queue, freed);
 		il->stations[sta_id].tid[tid].tfds_in_queue = 0;
 	}
 }
 
 #define IL_TX_QUEUE_MSK	0xfffff
 
-static bool il4965_is_single_rx_stream(struct il_priv *il)
+static bool
+il4965_is_single_rx_stream(struct il_priv *il)
 {
 	return il->current_ht_config.smps == IEEE80211_SMPS_STATIC ||
-	       il->current_ht_config.single_chain_sufficient;
+	    il->current_ht_config.single_chain_sufficient;
 }
 
 #define IL_NUM_RX_CHAINS_MULTIPLE	3
@@ -1065,7 +1073,8 @@ static bool il4965_is_single_rx_stream(struct il_priv *il)
  * MIMO (dual stream) requires at least 2, but works better with 3.
  * This does not determine *which* chains to use, just how many.
  */
-static int il4965_get_active_rx_chain_count(struct il_priv *il)
+static int
+il4965_get_active_rx_chain_count(struct il_priv *il)
 {
 	/* # of Rx chains to use when expecting MIMO. */
 	if (il4965_is_single_rx_stream(il))
@@ -1089,14 +1098,14 @@ il4965_get_idle_rx_chain_count(struct il_priv *il, int active_cnt)
 	case IEEE80211_SMPS_OFF:
 		return active_cnt;
 	default:
-		WARN(1, "invalid SMPS mode %d",
-		     il->current_ht_config.smps);
+		WARN(1, "invalid SMPS mode %d", il->current_ht_config.smps);
 		return active_cnt;
 	}
 }
 
 /* up to 4 chains */
-static u8 il4965_count_chain_bitmap(u32 chain_bitmap)
+static u8
+il4965_count_chain_bitmap(u32 chain_bitmap)
 {
 	u8 res;
 	res = (chain_bitmap & BIT(0)) >> 0;
@@ -1112,7 +1121,8 @@ static u8 il4965_count_chain_bitmap(u32 chain_bitmap)
  * Selects how many and which Rx receivers/antennas/chains to use.
  * This should not be used for scan command ... it puts data in wrong place.
  */
-void il4965_set_rxon_chain(struct il_priv *il, struct il_rxon_context *ctx)
+void
+il4965_set_rxon_chain(struct il_priv *il, struct il_rxon_context *ctx)
 {
 	bool is_single = il4965_is_single_rx_stream(il);
 	bool is_cam = !test_bit(S_POWER_PMI, &il->status);
@@ -1135,7 +1145,6 @@ void il4965_set_rxon_chain(struct il_priv *il, struct il_rxon_context *ctx)
 	active_rx_cnt = il4965_get_active_rx_chain_count(il);
 	idle_rx_cnt = il4965_get_idle_rx_chain_count(il, active_rx_cnt);
 
-
 	/* correct rx chain count according hw settings
 	 * and chain noise calibration
 	 */
@@ -1147,7 +1156,7 @@ void il4965_set_rxon_chain(struct il_priv *il, struct il_rxon_context *ctx)
 		idle_rx_cnt = valid_rx_cnt;
 
 	rx_chain |= active_rx_cnt << RXON_RX_CHAIN_MIMO_CNT_POS;
-	rx_chain |= idle_rx_cnt  << RXON_RX_CHAIN_CNT_POS;
+	rx_chain |= idle_rx_cnt << RXON_RX_CHAIN_CNT_POS;
 
 	ctx->staging.rx_chain = cpu_to_le16(rx_chain);
 
@@ -1156,45 +1165,47 @@ void il4965_set_rxon_chain(struct il_priv *il, struct il_rxon_context *ctx)
 	else
 		ctx->staging.rx_chain &= ~RXON_RX_CHAIN_MIMO_FORCE_MSK;
 
-	D_ASSOC("rx_chain=0x%X active=%d idle=%d\n",
-			ctx->staging.rx_chain,
-			active_rx_cnt, idle_rx_cnt);
+	D_ASSOC("rx_chain=0x%X active=%d idle=%d\n", ctx->staging.rx_chain,
+		active_rx_cnt, idle_rx_cnt);
 
 	WARN_ON(active_rx_cnt == 0 || idle_rx_cnt == 0 ||
 		active_rx_cnt < idle_rx_cnt);
 }
 
-u8 il4965_toggle_tx_ant(struct il_priv *il, u8 ant, u8 valid)
+u8
+il4965_toggle_tx_ant(struct il_priv *il, u8 ant, u8 valid)
 {
 	int i;
 	u8 ind = ant;
 
 	for (i = 0; i < RATE_ANT_NUM - 1; i++) {
-		ind = (ind + 1) < RATE_ANT_NUM ?  ind + 1 : 0;
+		ind = (ind + 1) < RATE_ANT_NUM ? ind + 1 : 0;
 		if (valid & BIT(ind))
 			return ind;
 	}
 	return ant;
 }
 
-static const char *il4965_get_fh_string(int cmd)
+static const char *
+il4965_get_fh_string(int cmd)
 {
 	switch (cmd) {
-	IL_CMD(FH49_RSCSR_CHNL0_STTS_WPTR_REG);
-	IL_CMD(FH49_RSCSR_CHNL0_RBDCB_BASE_REG);
-	IL_CMD(FH49_RSCSR_CHNL0_WPTR);
-	IL_CMD(FH49_MEM_RCSR_CHNL0_CONFIG_REG);
-	IL_CMD(FH49_MEM_RSSR_SHARED_CTRL_REG);
-	IL_CMD(FH49_MEM_RSSR_RX_STATUS_REG);
-	IL_CMD(FH49_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV);
-	IL_CMD(FH49_TSSR_TX_STATUS_REG);
-	IL_CMD(FH49_TSSR_TX_ERROR_REG);
+		IL_CMD(FH49_RSCSR_CHNL0_STTS_WPTR_REG);
+		IL_CMD(FH49_RSCSR_CHNL0_RBDCB_BASE_REG);
+		IL_CMD(FH49_RSCSR_CHNL0_WPTR);
+		IL_CMD(FH49_MEM_RCSR_CHNL0_CONFIG_REG);
+		IL_CMD(FH49_MEM_RSSR_SHARED_CTRL_REG);
+		IL_CMD(FH49_MEM_RSSR_RX_STATUS_REG);
+		IL_CMD(FH49_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV);
+		IL_CMD(FH49_TSSR_TX_STATUS_REG);
+		IL_CMD(FH49_TSSR_TX_ERROR_REG);
 	default:
 		return "UNKNOWN";
 	}
 }
 
-int il4965_dump_fh(struct il_priv *il, char **buf, bool display)
+int
+il4965_dump_fh(struct il_priv *il, char **buf, bool display)
 {
 	int i;
 #ifdef CONFIG_IWLEGACY_DEBUG
@@ -1218,28 +1229,29 @@ int il4965_dump_fh(struct il_priv *il, char **buf, bool display)
 		*buf = kmalloc(bufsz, GFP_KERNEL);
 		if (!*buf)
 			return -ENOMEM;
-		pos += scnprintf(*buf + pos, bufsz - pos,
-				"FH register values:\n");
+		pos +=
+		    scnprintf(*buf + pos, bufsz - pos, "FH register values:\n");
 		for (i = 0; i < ARRAY_SIZE(fh_tbl); i++) {
-			pos += scnprintf(*buf + pos, bufsz - pos,
-				"  %34s: 0X%08x\n",
-				il4965_get_fh_string(fh_tbl[i]),
-				il_rd(il, fh_tbl[i]));
+			pos +=
+			    scnprintf(*buf + pos, bufsz - pos,
+				      "  %34s: 0X%08x\n",
+				      il4965_get_fh_string(fh_tbl[i]), il_rd(il,
+									     fh_tbl
+									     [i]));
 		}
 		return pos;
 	}
 #endif
 	IL_ERR("FH register values:\n");
-	for (i = 0; i <  ARRAY_SIZE(fh_tbl); i++) {
-		IL_ERR("  %34s: 0X%08x\n",
-			il4965_get_fh_string(fh_tbl[i]),
-			il_rd(il, fh_tbl[i]));
+	for (i = 0; i < ARRAY_SIZE(fh_tbl); i++) {
+		IL_ERR("  %34s: 0X%08x\n", il4965_get_fh_string(fh_tbl[i]),
+		       il_rd(il, fh_tbl[i]));
 	}
 	return 0;
 }
-void il4965_hdl_missed_beacon(struct il_priv *il,
-				struct il_rx_buf *rxb)
 
+void
+il4965_hdl_missed_beacon(struct il_priv *il, struct il_rx_buf *rxb)
 {
 	struct il_rx_pkt *pkt = rxb_addr(rxb);
 	struct il_missed_beacon_notif *missed_beacon;
@@ -1247,12 +1259,11 @@ void il4965_hdl_missed_beacon(struct il_priv *il,
 	missed_beacon = &pkt->u.missed_beacon;
 	if (le32_to_cpu(missed_beacon->consecutive_missed_beacons) >
 	    il->missed_beacon_threshold) {
-		D_CALIB(
-		    "missed bcn cnsq %d totl %d rcd %d expctd %d\n",
-		    le32_to_cpu(missed_beacon->consecutive_missed_beacons),
-		    le32_to_cpu(missed_beacon->total_missed_becons),
-		    le32_to_cpu(missed_beacon->num_recvd_beacons),
-		    le32_to_cpu(missed_beacon->num_expected_beacons));
+		D_CALIB("missed bcn cnsq %d totl %d rcd %d expctd %d\n",
+			le32_to_cpu(missed_beacon->consecutive_missed_beacons),
+			le32_to_cpu(missed_beacon->total_missed_becons),
+			le32_to_cpu(missed_beacon->num_recvd_beacons),
+			le32_to_cpu(missed_beacon->num_expected_beacons));
 		if (!test_bit(S_SCANNING, &il->status))
 			il4965_init_sensitivity(il);
 	}
@@ -1261,7 +1272,8 @@ void il4965_hdl_missed_beacon(struct il_priv *il,
 /* Calculate noise level, based on measurements during network silence just
  *   before arriving beacon.  This measurement can be done only if we know
  *   exactly when to expect beacons, therefore only when we're associated. */
-static void il4965_rx_calc_noise(struct il_priv *il)
+static void
+il4965_rx_calc_noise(struct il_priv *il)
 {
 	struct stats_rx_non_phy *rx_info;
 	int num_active_rx = 0;
@@ -1271,11 +1283,11 @@ static void il4965_rx_calc_noise(struct il_priv *il)
 
 	rx_info = &(il->_4965.stats.rx.general);
 	bcn_silence_a =
-		le32_to_cpu(rx_info->beacon_silence_rssi_a) & IN_BAND_FILTER;
+	    le32_to_cpu(rx_info->beacon_silence_rssi_a) & IN_BAND_FILTER;
 	bcn_silence_b =
-		le32_to_cpu(rx_info->beacon_silence_rssi_b) & IN_BAND_FILTER;
+	    le32_to_cpu(rx_info->beacon_silence_rssi_b) & IN_BAND_FILTER;
 	bcn_silence_c =
-		le32_to_cpu(rx_info->beacon_silence_rssi_c) & IN_BAND_FILTER;
+	    le32_to_cpu(rx_info->beacon_silence_rssi_c) & IN_BAND_FILTER;
 
 	if (bcn_silence_a) {
 		total_silence += bcn_silence_a;
@@ -1296,9 +1308,8 @@ static void il4965_rx_calc_noise(struct il_priv *il)
 	else
 		last_rx_noise = IL_NOISE_MEAS_NOT_AVAILABLE;
 
-	D_CALIB("inband silence a %u, b %u, c %u, dBm %d\n",
-			bcn_silence_a, bcn_silence_b, bcn_silence_c,
-			last_rx_noise);
+	D_CALIB("inband silence a %u, b %u, c %u, dBm %d\n", bcn_silence_a,
+		bcn_silence_b, bcn_silence_c, last_rx_noise);
 }
 
 #ifdef CONFIG_IWLEGACY_DEBUGFS
@@ -1307,8 +1318,8 @@ static void il4965_rx_calc_noise(struct il_priv *il)
  *  FIXME: This function is for debugging, do not deal with
  *  the case of counters roll-over.
  */
-static void il4965_accumulative_stats(struct il_priv *il,
-					__le32 *stats)
+static void
+il4965_accumulative_stats(struct il_priv *il, __le32 * stats)
 {
 	int i, size;
 	__le32 *prev_stats;
@@ -1317,22 +1328,23 @@ static void il4965_accumulative_stats(struct il_priv *il,
 	struct stats_general_common *general, *accum_general;
 	struct stats_tx *tx, *accum_tx;
 
-	prev_stats = (__le32 *)&il->_4965.stats;
-	accum_stats = (u32 *)&il->_4965.accum_stats;
+	prev_stats = (__le32 *) & il->_4965.stats;
+	accum_stats = (u32 *) & il->_4965.accum_stats;
 	size = sizeof(struct il_notif_stats);
 	general = &il->_4965.stats.general.common;
 	accum_general = &il->_4965.accum_stats.general.common;
 	tx = &il->_4965.stats.tx;
 	accum_tx = &il->_4965.accum_stats.tx;
-	delta = (u32 *)&il->_4965.delta_stats;
-	max_delta = (u32 *)&il->_4965.max_delta;
+	delta = (u32 *) & il->_4965.delta_stats;
+	max_delta = (u32 *) & il->_4965.max_delta;
 
 	for (i = sizeof(__le32); i < size;
-	     i += sizeof(__le32), stats++, prev_stats++, delta++,
-	     max_delta++, accum_stats++) {
+	     i +=
+	     sizeof(__le32), stats++, prev_stats++, delta++, max_delta++,
+	     accum_stats++) {
 		if (le32_to_cpu(*stats) > le32_to_cpu(*prev_stats)) {
-			*delta = (le32_to_cpu(*stats) -
-				le32_to_cpu(*prev_stats));
+			*delta =
+			    (le32_to_cpu(*stats) - le32_to_cpu(*prev_stats));
 			*accum_stats += *delta;
 			if (*delta > *max_delta)
 				*max_delta = *delta;
@@ -1347,31 +1359,27 @@ static void il4965_accumulative_stats(struct il_priv *il,
 
 #define REG_RECALIB_PERIOD (60)
 
-void il4965_hdl_stats(struct il_priv *il,
-			      struct il_rx_buf *rxb)
+void
+il4965_hdl_stats(struct il_priv *il, struct il_rx_buf *rxb)
 {
 	int change;
 	struct il_rx_pkt *pkt = rxb_addr(rxb);
 
-	D_RX(
-		     "Statistics notification received (%d vs %d).\n",
-		     (int)sizeof(struct il_notif_stats),
-		     le32_to_cpu(pkt->len_n_flags) &
-		     IL_RX_FRAME_SIZE_MSK);
-
-	change = ((il->_4965.stats.general.common.temperature !=
-		   pkt->u.stats.general.common.temperature) ||
-		   ((il->_4965.stats.flag &
-		   STATS_REPLY_FLG_HT40_MODE_MSK) !=
-		   (pkt->u.stats.flag &
-		   STATS_REPLY_FLG_HT40_MODE_MSK)));
+	D_RX("Statistics notification received (%d vs %d).\n",
+	     (int)sizeof(struct il_notif_stats),
+	     le32_to_cpu(pkt->len_n_flags) & IL_RX_FRAME_SIZE_MSK);
+
+	change =
+	    ((il->_4965.stats.general.common.temperature !=
+	      pkt->u.stats.general.common.temperature) ||
+	     ((il->_4965.stats.flag & STATS_REPLY_FLG_HT40_MODE_MSK) !=
+	      (pkt->u.stats.flag & STATS_REPLY_FLG_HT40_MODE_MSK)));
 #ifdef CONFIG_IWLEGACY_DEBUGFS
-	il4965_accumulative_stats(il, (__le32 *)&pkt->u.stats);
+	il4965_accumulative_stats(il, (__le32 *) & pkt->u.stats);
 #endif
 
 	/* TODO: reading some of stats is unneeded */
-	memcpy(&il->_4965.stats, &pkt->u.stats,
-		sizeof(il->_4965.stats));
+	memcpy(&il->_4965.stats, &pkt->u.stats, sizeof(il->_4965.stats));
 
 	set_bit(S_STATS, &il->status);
 
@@ -1379,8 +1387,8 @@ void il4965_hdl_stats(struct il_priv *il,
 	 * REG_RECALIB_PERIOD seconds to ensure we get a
 	 * thermal update even if the uCode doesn't give
 	 * us one */
-	mod_timer(&il->stats_periodic, jiffies +
-		  msecs_to_jiffies(REG_RECALIB_PERIOD * 1000));
+	mod_timer(&il->stats_periodic,
+		  jiffies + msecs_to_jiffies(REG_RECALIB_PERIOD * 1000));
 
 	if (unlikely(!test_bit(S_SCANNING, &il->status)) &&
 	    (pkt->hdr.cmd == N_STATS)) {
@@ -1391,19 +1399,18 @@ void il4965_hdl_stats(struct il_priv *il,
 		il->cfg->ops->lib->temp_ops.temperature(il);
 }
 
-void il4965_hdl_c_stats(struct il_priv *il,
-			      struct il_rx_buf *rxb)
+void
+il4965_hdl_c_stats(struct il_priv *il, struct il_rx_buf *rxb)
 {
 	struct il_rx_pkt *pkt = rxb_addr(rxb);
 
 	if (le32_to_cpu(pkt->u.stats.flag) & UCODE_STATS_CLEAR_MSK) {
 #ifdef CONFIG_IWLEGACY_DEBUGFS
 		memset(&il->_4965.accum_stats, 0,
-			sizeof(struct il_notif_stats));
+		       sizeof(struct il_notif_stats));
 		memset(&il->_4965.delta_stats, 0,
-			sizeof(struct il_notif_stats));
-		memset(&il->_4965.max_delta, 0,
-			sizeof(struct il_notif_stats));
+		       sizeof(struct il_notif_stats));
+		memset(&il->_4965.max_delta, 0, sizeof(struct il_notif_stats));
 #endif
 		D_RX("Statistics have been cleared\n");
 	}
@@ -1448,7 +1455,8 @@ static const u8 tid_to_ac[] = {
 	IEEE80211_AC_VO
 };
 
-static inline int il4965_get_ac_from_tid(u16 tid)
+static inline int
+il4965_get_ac_from_tid(u16 tid)
 {
 	if (likely(tid < ARRAY_SIZE(tid_to_ac)))
 		return tid_to_ac[tid];
@@ -1470,12 +1478,11 @@ il4965_get_fifo_from_tid(struct il_rxon_context *ctx, u16 tid)
 /*
  * handle build C_TX command notification.
  */
-static void il4965_tx_cmd_build_basic(struct il_priv *il,
-					struct sk_buff *skb,
-					struct il_tx_cmd *tx_cmd,
-					struct ieee80211_tx_info *info,
-					struct ieee80211_hdr *hdr,
-					u8 std_id)
+static void
+il4965_tx_cmd_build_basic(struct il_priv *il, struct sk_buff *skb,
+			  struct il_tx_cmd *tx_cmd,
+			  struct ieee80211_tx_info *info,
+			  struct ieee80211_hdr *hdr, u8 std_id)
 {
 	__le16 fc = hdr->frame_control;
 	__le32 tx_flags = tx_cmd->tx_flags;
@@ -1527,10 +1534,9 @@ static void il4965_tx_cmd_build_basic(struct il_priv *il,
 
 #define RTS_DFAULT_RETRY_LIMIT		60
 
-static void il4965_tx_cmd_build_rate(struct il_priv *il,
-			      struct il_tx_cmd *tx_cmd,
-			      struct ieee80211_tx_info *info,
-			      __le16 fc)
+static void
+il4965_tx_cmd_build_rate(struct il_priv *il, struct il_tx_cmd *tx_cmd,
+			 struct ieee80211_tx_info *info, __le16 fc)
 {
 	u32 rate_flags;
 	int rate_idx;
@@ -1538,7 +1544,7 @@ static void il4965_tx_cmd_build_rate(struct il_priv *il,
 	u8 data_retry_limit;
 	u8 rate_plcp;
 
-	/* Set retry limit on DATA packets and Probe Responses*/
+	/* Set retry limit on DATA packets and Probe Responses */
 	if (ieee80211_is_probe_resp(fc))
 		data_retry_limit = 3;
 	else
@@ -1566,10 +1572,11 @@ static void il4965_tx_cmd_build_rate(struct il_priv *il,
 	 * idx is invalid.
 	 */
 	rate_idx = info->control.rates[0].idx;
-	if ((info->control.rates[0].flags & IEEE80211_TX_RC_MCS) ||
-	    rate_idx < 0 || rate_idx > RATE_COUNT_LEGACY)
-		rate_idx = rate_lowest_index(&il->bands[info->band],
-				info->control.sta);
+	if ((info->control.rates[0].flags & IEEE80211_TX_RC_MCS) || rate_idx < 0
+	    || rate_idx > RATE_COUNT_LEGACY)
+		rate_idx =
+		    rate_lowest_index(&il->bands[info->band],
+				      info->control.sta);
 	/* For 5 GHZ band, remap mac80211 rate indices into driver indices */
 	if (info->band == IEEE80211_BAND_5GHZ)
 		rate_idx += IL_FIRST_OFDM_RATE;
@@ -1583,20 +1590,21 @@ static void il4965_tx_cmd_build_rate(struct il_priv *il,
 		rate_flags |= RATE_MCS_CCK_MSK;
 
 	/* Set up antennas */
-	il->mgmt_tx_ant = il4965_toggle_tx_ant(il, il->mgmt_tx_ant,
-				      il->hw_params.valid_tx_ant);
+	il->mgmt_tx_ant =
+	    il4965_toggle_tx_ant(il, il->mgmt_tx_ant,
+				 il->hw_params.valid_tx_ant);
 
 	rate_flags |= il4965_ant_idx_to_flags(il->mgmt_tx_ant);
 
 	/* Set the rate in the TX cmd */
-	tx_cmd->rate_n_flags = il4965_hw_set_rate_n_flags(rate_plcp, rate_flags);
+	tx_cmd->rate_n_flags =
+	    il4965_hw_set_rate_n_flags(rate_plcp, rate_flags);
 }
 
-static void il4965_tx_cmd_build_hwcrypto(struct il_priv *il,
-				      struct ieee80211_tx_info *info,
-				      struct il_tx_cmd *tx_cmd,
-				      struct sk_buff *skb_frag,
-				      int sta_id)
+static void
+il4965_tx_cmd_build_hwcrypto(struct il_priv *il, struct ieee80211_tx_info *info,
+			     struct il_tx_cmd *tx_cmd, struct sk_buff *skb_frag,
+			     int sta_id)
 {
 	struct ieee80211_key_conf *keyconf = info->control.hw_key;
 
@@ -1619,13 +1627,14 @@ static void il4965_tx_cmd_build_hwcrypto(struct il_priv *il,
 		tx_cmd->sec_ctl |= TX_CMD_SEC_KEY128;
 		/* fall through */
 	case WLAN_CIPHER_SUITE_WEP40:
-		tx_cmd->sec_ctl |= (TX_CMD_SEC_WEP |
-			(keyconf->keyidx & TX_CMD_SEC_MSK) << TX_CMD_SEC_SHIFT);
+		tx_cmd->sec_ctl |=
+		    (TX_CMD_SEC_WEP | (keyconf->keyidx & TX_CMD_SEC_MSK) <<
+		     TX_CMD_SEC_SHIFT);
 
 		memcpy(&tx_cmd->key[3], keyconf->key, keyconf->keylen);
 
-		D_TX("Configuring packet for WEP encryption "
-			     "with key %d\n", keyconf->keyidx);
+		D_TX("Configuring packet for WEP encryption " "with key %d\n",
+		     keyconf->keyidx);
 		break;
 
 	default:
@@ -1637,7 +1646,8 @@ static void il4965_tx_cmd_build_hwcrypto(struct il_priv *il,
 /*
  * start C_TX command process
  */
-int il4965_tx_skb(struct il_priv *il, struct sk_buff *skb)
+int
+il4965_tx_skb(struct il_priv *il, struct sk_buff *skb)
 {
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
@@ -1694,8 +1704,7 @@ int il4965_tx_skb(struct il_priv *il, struct sk_buff *skb)
 		sta_id = il_sta_id_or_broadcast(il, ctx, info->control.sta);
 
 		if (sta_id == IL_INVALID_STATION) {
-			D_DROP("Dropping - INVALID STATION: %pM\n",
-				       hdr->addr1);
+			D_DROP("Dropping - INVALID STATION: %pM\n", hdr->addr1);
 			goto drop_unlock;
 		}
 	}
@@ -1729,8 +1738,7 @@ int il4965_tx_skb(struct il_priv *il, struct sk_buff *skb)
 		 * The microcode will clear the more data
 		 * bit in the last frame it transmits.
 		 */
-		hdr->frame_control |=
-			cpu_to_le16(IEEE80211_FCTL_MOREDATA);
+		hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_MOREDATA);
 	} else
 		txq_id = ctx->ac_to_queue[skb_get_queue_mapping(skb)];
 
@@ -1746,8 +1754,8 @@ int il4965_tx_skb(struct il_priv *il, struct sk_buff *skb)
 		}
 		seq_number = il->stations[sta_id].tid[tid].seq_number;
 		seq_number &= IEEE80211_SCTL_SEQ;
-		hdr->seq_ctrl = hdr->seq_ctrl &
-				cpu_to_le16(IEEE80211_SCTL_FRAG);
+		hdr->seq_ctrl =
+		    hdr->seq_ctrl & cpu_to_le16(IEEE80211_SCTL_FRAG);
 		hdr->seq_ctrl |= cpu_to_le16(seq_number);
 		seq_number += 0x10;
 		/* aggregation is on for this <sta,tid> */
@@ -1793,15 +1801,15 @@ int il4965_tx_skb(struct il_priv *il, struct sk_buff *skb)
 	 * locate the frame within the tx queue and do post-tx processing.
 	 */
 	out_cmd->hdr.cmd = C_TX;
-	out_cmd->hdr.sequence = cpu_to_le16((u16)(QUEUE_TO_SEQ(txq_id) |
-				IDX_TO_SEQ(q->write_ptr)));
+	out_cmd->hdr.sequence =
+	    cpu_to_le16((u16)
+			(QUEUE_TO_SEQ(txq_id) | IDX_TO_SEQ(q->write_ptr)));
 
 	/* Copy MAC header from skb into command buffer */
 	memcpy(tx_cmd->hdr, hdr, hdr_len);
 
-
 	/* Total # bytes to be transmitted */
-	len = (u16)skb->len;
+	len = (u16) skb->len;
 	tx_cmd->len = cpu_to_le16(len);
 
 	if (info->control.hw_key)
@@ -1823,8 +1831,7 @@ int il4965_tx_skb(struct il_priv *il, struct sk_buff *skb)
 	 * of the MAC header (device reads on dword boundaries).
 	 * We'll tell device about this padding later.
 	 */
-	len = sizeof(struct il_tx_cmd) +
-		sizeof(struct il_cmd_header) + hdr_len;
+	len = sizeof(struct il_tx_cmd) + sizeof(struct il_cmd_header) + hdr_len;
 	firstlen = (len + 3) & ~3;
 
 	/* Tell NIC about any 2-byte padding after MAC header */
@@ -1833,15 +1840,15 @@ int il4965_tx_skb(struct il_priv *il, struct sk_buff *skb)
 
 	/* Physical address of this Tx command's header (not MAC header!),
 	 * within command buffer array. */
-	txcmd_phys = pci_map_single(il->pci_dev,
-				    &out_cmd->hdr, firstlen,
-				    PCI_DMA_BIDIRECTIONAL);
+	txcmd_phys =
+	    pci_map_single(il->pci_dev, &out_cmd->hdr, firstlen,
+			   PCI_DMA_BIDIRECTIONAL);
 	dma_unmap_addr_set(out_meta, mapping, txcmd_phys);
 	dma_unmap_len_set(out_meta, len, firstlen);
 	/* Add buffer containing Tx command and MAC(!) header to TFD's
 	 * first entry */
-	il->cfg->ops->lib->txq_attach_buf_to_tfd(il, txq,
-						   txcmd_phys, firstlen, 1, 0);
+	il->cfg->ops->lib->txq_attach_buf_to_tfd(il, txq, txcmd_phys, firstlen,
+						 1, 0);
 
 	if (!ieee80211_has_morefrags(hdr->frame_control)) {
 		txq->need_update = 1;
@@ -1854,35 +1861,36 @@ int il4965_tx_skb(struct il_priv *il, struct sk_buff *skb)
 	 * if any (802.11 null frames have no payload). */
 	secondlen = skb->len - hdr_len;
 	if (secondlen > 0) {
-		phys_addr = pci_map_single(il->pci_dev, skb->data + hdr_len,
-					   secondlen, PCI_DMA_TODEVICE);
-		il->cfg->ops->lib->txq_attach_buf_to_tfd(il, txq,
-							   phys_addr, secondlen,
-							   0, 0);
+		phys_addr =
+		    pci_map_single(il->pci_dev, skb->data + hdr_len, secondlen,
+				   PCI_DMA_TODEVICE);
+		il->cfg->ops->lib->txq_attach_buf_to_tfd(il, txq, phys_addr,
+							 secondlen, 0, 0);
 	}
 
-	scratch_phys = txcmd_phys + sizeof(struct il_cmd_header) +
-				offsetof(struct il_tx_cmd, scratch);
+	scratch_phys =
+	    txcmd_phys + sizeof(struct il_cmd_header) +
+	    offsetof(struct il_tx_cmd, scratch);
 
 	/* take back ownership of DMA buffer to enable update */
-	pci_dma_sync_single_for_cpu(il->pci_dev, txcmd_phys,
-				    firstlen, PCI_DMA_BIDIRECTIONAL);
+	pci_dma_sync_single_for_cpu(il->pci_dev, txcmd_phys, firstlen,
+				    PCI_DMA_BIDIRECTIONAL);
 	tx_cmd->dram_lsb_ptr = cpu_to_le32(scratch_phys);
 	tx_cmd->dram_msb_ptr = il_get_dma_hi_addr(scratch_phys);
 
-	D_TX("sequence nr = 0X%x\n",
-		     le16_to_cpu(out_cmd->hdr.sequence));
+	D_TX("sequence nr = 0X%x\n", le16_to_cpu(out_cmd->hdr.sequence));
 	D_TX("tx_flags = 0X%x\n", le32_to_cpu(tx_cmd->tx_flags));
-	il_print_hex_dump(il, IL_DL_TX, (u8 *)tx_cmd, sizeof(*tx_cmd));
-	il_print_hex_dump(il, IL_DL_TX, (u8 *)tx_cmd->hdr, hdr_len);
+	il_print_hex_dump(il, IL_DL_TX, (u8 *) tx_cmd, sizeof(*tx_cmd));
+	il_print_hex_dump(il, IL_DL_TX, (u8 *) tx_cmd->hdr, hdr_len);
 
 	/* Set up entry for this TFD in Tx byte-count array */
 	if (info->flags & IEEE80211_TX_CTL_AMPDU)
 		il->cfg->ops->lib->txq_update_byte_cnt_tbl(il, txq,
-						     le16_to_cpu(tx_cmd->len));
+							   le16_to_cpu(tx_cmd->
+								       len));
 
-	pci_dma_sync_single_for_device(il->pci_dev, txcmd_phys,
-				       firstlen, PCI_DMA_BIDIRECTIONAL);
+	pci_dma_sync_single_for_device(il->pci_dev, txcmd_phys, firstlen,
+				       PCI_DMA_BIDIRECTIONAL);
 
 	/* Tell device the write idx *just past* this latest filled TFD */
 	q->write_ptr = il_queue_inc_wrap(q->write_ptr, q->n_bd);
@@ -1924,19 +1932,19 @@ drop_unlock:
 	return -1;
 }
 
-static inline int il4965_alloc_dma_ptr(struct il_priv *il,
-				    struct il_dma_ptr *ptr, size_t size)
+static inline int
+il4965_alloc_dma_ptr(struct il_priv *il, struct il_dma_ptr *ptr, size_t size)
 {
-	ptr->addr = dma_alloc_coherent(&il->pci_dev->dev, size, &ptr->dma,
-				       GFP_KERNEL);
+	ptr->addr =
+	    dma_alloc_coherent(&il->pci_dev->dev, size, &ptr->dma, GFP_KERNEL);
 	if (!ptr->addr)
 		return -ENOMEM;
 	ptr->size = size;
 	return 0;
 }
 
-static inline void il4965_free_dma_ptr(struct il_priv *il,
-				    struct il_dma_ptr *ptr)
+static inline void
+il4965_free_dma_ptr(struct il_priv *il, struct il_dma_ptr *ptr)
 {
 	if (unlikely(!ptr->addr))
 		return;
@@ -1950,7 +1958,8 @@ static inline void il4965_free_dma_ptr(struct il_priv *il,
  *
  * Destroy all TX DMA queues and structures
  */
-void il4965_hw_txq_ctx_free(struct il_priv *il)
+void
+il4965_hw_txq_ctx_free(struct il_priv *il)
 {
 	int txq_id;
 
@@ -1977,7 +1986,8 @@ void il4965_hw_txq_ctx_free(struct il_priv *il)
  * @param il
  * @return error code
  */
-int il4965_txq_ctx_alloc(struct il_priv *il)
+int
+il4965_txq_ctx_alloc(struct il_priv *il)
 {
 	int ret;
 	int txq_id, slots_num;
@@ -1986,8 +1996,9 @@ int il4965_txq_ctx_alloc(struct il_priv *il)
 	/* Free all tx/cmd queues and keep-warm buffer */
 	il4965_hw_txq_ctx_free(il);
 
-	ret = il4965_alloc_dma_ptr(il, &il->scd_bc_tbls,
-				il->hw_params.scd_bc_tbls_size);
+	ret =
+	    il4965_alloc_dma_ptr(il, &il->scd_bc_tbls,
+				 il->hw_params.scd_bc_tbls_size);
 	if (ret) {
 		IL_ERR("Scheduler BC Table allocation failed\n");
 		goto error_bc_tbls;
@@ -2016,11 +2027,10 @@ int il4965_txq_ctx_alloc(struct il_priv *il)
 
 	/* Alloc and init all Tx queues, including the command queue (#4/#9) */
 	for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++) {
-		slots_num = (txq_id == il->cmd_queue) ?
-					TFD_CMD_SLOTS : TFD_TX_CMD_SLOTS;
-		ret = il_tx_queue_init(il,
-					&il->txq[txq_id], slots_num,
-				       txq_id);
+		slots_num =
+		    (txq_id ==
+		     il->cmd_queue) ? TFD_CMD_SLOTS : TFD_TX_CMD_SLOTS;
+		ret = il_tx_queue_init(il, &il->txq[txq_id], slots_num, txq_id);
 		if (ret) {
 			IL_ERR("Tx %d queue init failed\n", txq_id);
 			goto error;
@@ -2029,16 +2039,17 @@ int il4965_txq_ctx_alloc(struct il_priv *il)
 
 	return ret;
 
- error:
+error:
 	il4965_hw_txq_ctx_free(il);
 	il4965_free_dma_ptr(il, &il->kw);
- error_kw:
+error_kw:
 	il4965_free_dma_ptr(il, &il->scd_bc_tbls);
- error_bc_tbls:
+error_bc_tbls:
 	return ret;
 }
 
-void il4965_txq_ctx_reset(struct il_priv *il)
+void
+il4965_txq_ctx_reset(struct il_priv *il)
 {
 	int txq_id, slots_num;
 	unsigned long flags;
@@ -2055,17 +2066,17 @@ void il4965_txq_ctx_reset(struct il_priv *il)
 
 	/* Alloc and init all Tx queues, including the command queue (#4) */
 	for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++) {
-		slots_num = txq_id == il->cmd_queue ?
-			    TFD_CMD_SLOTS : TFD_TX_CMD_SLOTS;
-		il_tx_queue_reset(il, &il->txq[txq_id],
-						slots_num, txq_id);
+		slots_num =
+		    txq_id == il->cmd_queue ? TFD_CMD_SLOTS : TFD_TX_CMD_SLOTS;
+		il_tx_queue_reset(il, &il->txq[txq_id], slots_num, txq_id);
 	}
 }
 
 /**
  * il4965_txq_ctx_stop - Stop all Tx DMA channels
  */
-void il4965_txq_ctx_stop(struct il_priv *il)
+void
+il4965_txq_ctx_stop(struct il_priv *il)
 {
 	int ch, txq_id;
 	unsigned long flags;
@@ -2077,15 +2088,13 @@ void il4965_txq_ctx_stop(struct il_priv *il)
 
 	/* Stop each Tx DMA channel, and wait for it to be idle */
 	for (ch = 0; ch < il->hw_params.dma_chnl_num; ch++) {
-		il_wr(il,
-				FH49_TCSR_CHNL_TX_CONFIG_REG(ch), 0x0);
-		if (il_poll_bit(il, FH49_TSSR_TX_STATUS_REG,
-				    FH49_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(ch),
-				    1000))
+		il_wr(il, FH49_TCSR_CHNL_TX_CONFIG_REG(ch), 0x0);
+		if (il_poll_bit
+		    (il, FH49_TSSR_TX_STATUS_REG,
+		     FH49_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(ch), 1000))
 			IL_ERR("Failing on timeout while stopping"
-			    " DMA channel %d [0x%08x]", ch,
-			    il_rd(il,
-					FH49_TSSR_TX_STATUS_REG));
+			       " DMA channel %d [0x%08x]", ch, il_rd(il,
+								     FH49_TSSR_TX_STATUS_REG));
 	}
 	spin_unlock_irqrestore(&il->lock, flags);
 
@@ -2106,7 +2115,8 @@ void il4965_txq_ctx_stop(struct il_priv *il)
  * Should never return anything < 7, because they should already
  * be in use as EDCA AC (0-3), Command (4), reserved (5, 6)
  */
-static int il4965_txq_ctx_activate_free(struct il_priv *il)
+static int
+il4965_txq_ctx_activate_free(struct il_priv *il)
 {
 	int txq_id;
 
@@ -2119,22 +2129,21 @@ static int il4965_txq_ctx_activate_free(struct il_priv *il)
 /**
  * il4965_tx_queue_stop_scheduler - Stop queue, but keep configuration
  */
-static void il4965_tx_queue_stop_scheduler(struct il_priv *il,
-					    u16 txq_id)
+static void
+il4965_tx_queue_stop_scheduler(struct il_priv *il, u16 txq_id)
 {
 	/* Simply stop the queue, but don't change any configuration;
 	 * the SCD_ACT_EN bit is the write-enable mask for the ACTIVE bit. */
-	il_wr_prph(il,
-		IL49_SCD_QUEUE_STATUS_BITS(txq_id),
-		(0 << IL49_SCD_QUEUE_STTS_REG_POS_ACTIVE)|
-		(1 << IL49_SCD_QUEUE_STTS_REG_POS_SCD_ACT_EN));
+	il_wr_prph(il, IL49_SCD_QUEUE_STATUS_BITS(txq_id),
+		   (0 << IL49_SCD_QUEUE_STTS_REG_POS_ACTIVE) | (1 <<
+								IL49_SCD_QUEUE_STTS_REG_POS_SCD_ACT_EN));
 }
 
 /**
  * il4965_tx_queue_set_q2ratid - Map unique receiver/tid combination to a queue
  */
-static int il4965_tx_queue_set_q2ratid(struct il_priv *il, u16 ra_tid,
-					u16 txq_id)
+static int
+il4965_tx_queue_set_q2ratid(struct il_priv *il, u16 ra_tid, u16 txq_id)
 {
 	u32 tbl_dw_addr;
 	u32 tbl_dw;
@@ -2142,8 +2151,8 @@ static int il4965_tx_queue_set_q2ratid(struct il_priv *il, u16 ra_tid,
 
 	scd_q2ratid = ra_tid & IL_SCD_QUEUE_RA_TID_MAP_RATID_MSK;
 
-	tbl_dw_addr = il->scd_base_addr +
-			IL49_SCD_TRANSLATE_TBL_OFFSET_QUEUE(txq_id);
+	tbl_dw_addr =
+	    il->scd_base_addr + IL49_SCD_TRANSLATE_TBL_OFFSET_QUEUE(txq_id);
 
 	tbl_dw = il_read_targ_mem(il, tbl_dw_addr);
 
@@ -2163,8 +2172,9 @@ static int il4965_tx_queue_set_q2ratid(struct il_priv *il, u16 ra_tid,
  * NOTE:  txq_id must be greater than IL49_FIRST_AMPDU_QUEUE,
  *        i.e. it must be one of the higher queues used for aggregation
  */
-static int il4965_txq_agg_enable(struct il_priv *il, int txq_id,
-				  int tx_fifo, int sta_id, int tid, u16 ssn_idx)
+static int
+il4965_txq_agg_enable(struct il_priv *il, int txq_id, int tx_fifo, int sta_id,
+		      int tid, u16 ssn_idx)
 {
 	unsigned long flags;
 	u16 ra_tid;
@@ -2172,9 +2182,8 @@ static int il4965_txq_agg_enable(struct il_priv *il, int txq_id,
 
 	if ((IL49_FIRST_AMPDU_QUEUE > txq_id) ||
 	    (IL49_FIRST_AMPDU_QUEUE +
-		il->cfg->base_params->num_of_ampdu_queues <= txq_id)) {
-		IL_WARN(
-			"queue number out of range: %d, must be %d to %d\n",
+	     il->cfg->base_params->num_of_ampdu_queues <= txq_id)) {
+		IL_WARN("queue number out of range: %d, must be %d to %d\n",
 			txq_id, IL49_FIRST_AMPDU_QUEUE,
 			IL49_FIRST_AMPDU_QUEUE +
 			il->cfg->base_params->num_of_ampdu_queues - 1);
@@ -2207,14 +2216,17 @@ static int il4965_txq_agg_enable(struct il_priv *il, int txq_id,
 
 	/* Set up Tx win size and frame limit for this queue */
 	il_write_targ_mem(il,
-		il->scd_base_addr + IL49_SCD_CONTEXT_QUEUE_OFFSET(txq_id),
-		(SCD_WIN_SIZE << IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_POS) &
-		IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK);
+			  il->scd_base_addr +
+			  IL49_SCD_CONTEXT_QUEUE_OFFSET(txq_id),
+			  (SCD_WIN_SIZE << IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_POS)
+			  & IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK);
 
-	il_write_targ_mem(il, il->scd_base_addr +
-		IL49_SCD_CONTEXT_QUEUE_OFFSET(txq_id) + sizeof(u32),
-		(SCD_FRAME_LIMIT << IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS)
-		& IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK);
+	il_write_targ_mem(il,
+			  il->scd_base_addr +
+			  IL49_SCD_CONTEXT_QUEUE_OFFSET(txq_id) + sizeof(u32),
+			  (SCD_FRAME_LIMIT <<
+			   IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS) &
+			  IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK);
 
 	il_set_bits_prph(il, IL49_SCD_INTERRUPT_MASK, (1 << txq_id));
 
@@ -2226,9 +2238,9 @@ static int il4965_txq_agg_enable(struct il_priv *il, int txq_id,
 	return 0;
 }
 
-
-int il4965_tx_agg_start(struct il_priv *il, struct ieee80211_vif *vif,
-			struct ieee80211_sta *sta, u16 tid, u16 *ssn)
+int
+il4965_tx_agg_start(struct il_priv *il, struct ieee80211_vif *vif,
+		    struct ieee80211_sta *sta, u16 tid, u16 * ssn)
 {
 	int sta_id;
 	int tx_fifo;
@@ -2241,8 +2253,7 @@ int il4965_tx_agg_start(struct il_priv *il, struct ieee80211_vif *vif,
 	if (unlikely(tx_fifo < 0))
 		return tx_fifo;
 
-	IL_WARN("%s on ra = %pM tid = %d\n",
-			__func__, sta->addr, tid);
+	IL_WARN("%s on ra = %pM tid = %d\n", __func__, sta->addr, tid);
 
 	sta_id = il_sta_id(sta);
 	if (sta_id == IL_INVALID_STATION) {
@@ -2267,12 +2278,10 @@ int il4965_tx_agg_start(struct il_priv *il, struct ieee80211_vif *vif,
 	tid_data = &il->stations[sta_id].tid[tid];
 	*ssn = SEQ_TO_SN(tid_data->seq_number);
 	tid_data->agg.txq_id = txq_id;
-	il_set_swq_id(&il->txq[txq_id],
-				il4965_get_ac_from_tid(tid), txq_id);
+	il_set_swq_id(&il->txq[txq_id], il4965_get_ac_from_tid(tid), txq_id);
 	spin_unlock_irqrestore(&il->sta_lock, flags);
 
-	ret = il4965_txq_agg_enable(il, txq_id, tx_fifo,
-						  sta_id, tid, *ssn);
+	ret = il4965_txq_agg_enable(il, txq_id, tx_fifo, sta_id, tid, *ssn);
 	if (ret)
 		return ret;
 
@@ -2283,9 +2292,8 @@ int il4965_tx_agg_start(struct il_priv *il, struct ieee80211_vif *vif,
 		tid_data->agg.state = IL_AGG_ON;
 		ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
 	} else {
-		D_HT(
-			"HW queue is NOT empty: %d packets in HW queue\n",
-			     tid_data->tfds_in_queue);
+		D_HT("HW queue is NOT empty: %d packets in HW queue\n",
+		     tid_data->tfds_in_queue);
 		tid_data->agg.state = IL_EMPTYING_HW_QUEUE_ADDBA;
 	}
 	spin_unlock_irqrestore(&il->sta_lock, flags);
@@ -2296,14 +2304,13 @@ int il4965_tx_agg_start(struct il_priv *il, struct ieee80211_vif *vif,
  * txq_id must be greater than IL49_FIRST_AMPDU_QUEUE
  * il->lock must be held by the caller
  */
-static int il4965_txq_agg_disable(struct il_priv *il, u16 txq_id,
-				   u16 ssn_idx, u8 tx_fifo)
+static int
+il4965_txq_agg_disable(struct il_priv *il, u16 txq_id, u16 ssn_idx, u8 tx_fifo)
 {
 	if ((IL49_FIRST_AMPDU_QUEUE > txq_id) ||
 	    (IL49_FIRST_AMPDU_QUEUE +
-		il->cfg->base_params->num_of_ampdu_queues <= txq_id)) {
-		IL_WARN(
-			"queue number out of range: %d, must be %d to %d\n",
+	     il->cfg->base_params->num_of_ampdu_queues <= txq_id)) {
+		IL_WARN("queue number out of range: %d, must be %d to %d\n",
 			txq_id, IL49_FIRST_AMPDU_QUEUE,
 			IL49_FIRST_AMPDU_QUEUE +
 			il->cfg->base_params->num_of_ampdu_queues - 1);
@@ -2312,24 +2319,23 @@ static int il4965_txq_agg_disable(struct il_priv *il, u16 txq_id,
 
 	il4965_tx_queue_stop_scheduler(il, txq_id);
 
-	il_clear_bits_prph(il,
-			IL49_SCD_QUEUECHAIN_SEL, (1 << txq_id));
+	il_clear_bits_prph(il, IL49_SCD_QUEUECHAIN_SEL, (1 << txq_id));
 
 	il->txq[txq_id].q.read_ptr = (ssn_idx & 0xff);
 	il->txq[txq_id].q.write_ptr = (ssn_idx & 0xff);
 	/* supposes that ssn_idx is valid (!= 0xFFF) */
 	il4965_set_wr_ptrs(il, txq_id, ssn_idx);
 
-	il_clear_bits_prph(il,
-			 IL49_SCD_INTERRUPT_MASK, (1 << txq_id));
+	il_clear_bits_prph(il, IL49_SCD_INTERRUPT_MASK, (1 << txq_id));
 	il_txq_ctx_deactivate(il, txq_id);
 	il4965_tx_queue_set_status(il, &il->txq[txq_id], tx_fifo, 0);
 
 	return 0;
 }
 
-int il4965_tx_agg_stop(struct il_priv *il, struct ieee80211_vif *vif,
-		       struct ieee80211_sta *sta, u16 tid)
+int
+il4965_tx_agg_stop(struct il_priv *il, struct ieee80211_vif *vif,
+		   struct ieee80211_sta *sta, u16 tid)
 {
 	int tx_fifo_id, txq_id, sta_id, ssn;
 	struct il_tid_data *tid_data;
@@ -2376,13 +2382,13 @@ int il4965_tx_agg_stop(struct il_priv *il, struct ieee80211_vif *vif,
 	if (write_ptr != read_ptr) {
 		D_HT("Stopping a non empty AGG HW QUEUE\n");
 		il->stations[sta_id].tid[tid].agg.state =
-				IL_EMPTYING_HW_QUEUE_DELBA;
+		    IL_EMPTYING_HW_QUEUE_DELBA;
 		spin_unlock_irqrestore(&il->sta_lock, flags);
 		return 0;
 	}
 
 	D_HT("HW queue is empty\n");
- turn_off:
+turn_off:
 	il->stations[sta_id].tid[tid].agg.state = IL_AGG_OFF;
 
 	/* do not restore/save irqs */
@@ -2404,8 +2410,8 @@ int il4965_tx_agg_stop(struct il_priv *il, struct ieee80211_vif *vif,
 	return 0;
 }
 
-int il4965_txq_check_empty(struct il_priv *il,
-			   int sta_id, u8 tid, int txq_id)
+int
+il4965_txq_check_empty(struct il_priv *il, int sta_id, u8 tid, int txq_id)
 {
 	struct il_queue *q = &il->txq[txq_id].q;
 	u8 *addr = il->stations[sta_id].sta.sta.addr;
@@ -2420,12 +2426,11 @@ int il4965_txq_check_empty(struct il_priv *il,
 	case IL_EMPTYING_HW_QUEUE_DELBA:
 		/* We are reclaiming the last packet of the */
 		/* aggregated HW queue */
-		if (txq_id  == tid_data->agg.txq_id &&
+		if (txq_id == tid_data->agg.txq_id &&
 		    q->read_ptr == q->write_ptr) {
 			u16 ssn = SEQ_TO_SN(tid_data->seq_number);
 			int tx_fifo = il4965_get_fifo_from_tid(ctx, tid);
-			D_HT(
-				"HW queue empty: continue DELBA flow\n");
+			D_HT("HW queue empty: continue DELBA flow\n");
 			il4965_txq_agg_disable(il, txq_id, ssn, tx_fifo);
 			tid_data->agg.state = IL_AGG_OFF;
 			ieee80211_stop_tx_ba_cb_irqsafe(ctx->vif, addr, tid);
@@ -2434,8 +2439,7 @@ int il4965_txq_check_empty(struct il_priv *il,
 	case IL_EMPTYING_HW_QUEUE_ADDBA:
 		/* We are reclaiming the last packet of the queue */
 		if (tid_data->tfds_in_queue == 0) {
-			D_HT(
-				"HW queue empty: continue ADDBA flow\n");
+			D_HT("HW queue empty: continue ADDBA flow\n");
 			tid_data->agg.state = IL_AGG_ON;
 			ieee80211_start_tx_ba_cb_irqsafe(ctx->vif, addr, tid);
 		}
@@ -2445,9 +2449,9 @@ int il4965_txq_check_empty(struct il_priv *il,
 	return 0;
 }
 
-static void il4965_non_agg_tx_status(struct il_priv *il,
-				     struct il_rxon_context *ctx,
-				     const u8 *addr1)
+static void
+il4965_non_agg_tx_status(struct il_priv *il, struct il_rxon_context *ctx,
+			 const u8 * addr1)
 {
 	struct ieee80211_sta *sta;
 	struct il_station_priv *sta_priv;
@@ -2465,10 +2469,9 @@ static void il4965_non_agg_tx_status(struct il_priv *il,
 }
 
 static void
-il4965_tx_status(struct il_priv *il, struct il_tx_info *tx_info,
-			     bool is_agg)
+il4965_tx_status(struct il_priv *il, struct il_tx_info *tx_info, bool is_agg)
 {
-	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) tx_info->skb->data;
+	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx_info->skb->data;
 
 	if (!is_agg)
 		il4965_non_agg_tx_status(il, tx_info->ctx, hdr->addr1);
@@ -2476,7 +2479,8 @@ il4965_tx_status(struct il_priv *il, struct il_tx_info *tx_info,
 	ieee80211_tx_status_irqsafe(il->hw, tx_info->skb);
 }
 
-int il4965_tx_queue_reclaim(struct il_priv *il, int txq_id, int idx)
+int
+il4965_tx_queue_reclaim(struct il_priv *il, int txq_id, int idx)
 {
 	struct il_tx_queue *txq = &il->txq[txq_id];
 	struct il_queue *q = &txq->q;
@@ -2486,13 +2490,12 @@ int il4965_tx_queue_reclaim(struct il_priv *il, int txq_id, int idx)
 
 	if (idx >= q->n_bd || il_queue_used(q, idx) == 0) {
 		IL_ERR("Read idx for DMA queue txq id (%d), idx %d, "
-			  "is out of range [0-%d] %d %d.\n", txq_id,
-			  idx, q->n_bd, q->write_ptr, q->read_ptr);
+		       "is out of range [0-%d] %d %d.\n", txq_id, idx, q->n_bd,
+		       q->write_ptr, q->read_ptr);
 		return 0;
 	}
 
-	for (idx = il_queue_inc_wrap(idx, q->n_bd);
-	     q->read_ptr != idx;
+	for (idx = il_queue_inc_wrap(idx, q->n_bd); q->read_ptr != idx;
 	     q->read_ptr = il_queue_inc_wrap(q->read_ptr, q->n_bd)) {
 
 		tx_info = &txq->txb[txq->q.read_ptr];
@@ -2519,10 +2522,9 @@ int il4965_tx_queue_reclaim(struct il_priv *il, int txq_id, int idx)
  * Go through block-ack's bitmap of ACK'd frames, update driver's record of
  * ACK vs. not.  This gets sent to mac80211, then to rate scaling algo.
  */
-static int il4965_tx_status_reply_compressed_ba(struct il_priv *il,
-				 struct il_ht_agg *agg,
-				 struct il_compressed_ba_resp *ba_resp)
-
+static int
+il4965_tx_status_reply_compressed_ba(struct il_priv *il, struct il_ht_agg *agg,
+				     struct il_compressed_ba_resp *ba_resp)
 {
 	int i, sh, ack;
 	u16 seq_ctl = le16_to_cpu(ba_resp->seq_ctl);
@@ -2531,7 +2533,7 @@ static int il4965_tx_status_reply_compressed_ba(struct il_priv *il,
 	struct ieee80211_tx_info *info;
 	u64 bitmap, sent_bitmap;
 
-	if (unlikely(!agg->wait_for_ba))  {
+	if (unlikely(!agg->wait_for_ba)) {
 		if (unlikely(ba_resp->bitmap))
 			IL_ERR("Received BA when not expected\n");
 		return -EINVAL;
@@ -2539,12 +2541,11 @@ static int il4965_tx_status_reply_compressed_ba(struct il_priv *il,
 
 	/* Mark that the expected block-ack response arrived */
 	agg->wait_for_ba = 0;
-	D_TX_REPLY("BA %d %d\n", agg->start_idx,
-							ba_resp->seq_ctl);
+	D_TX_REPLY("BA %d %d\n", agg->start_idx, ba_resp->seq_ctl);
 
 	/* Calculate shift to align block-ack bits with our Tx win bits */
 	sh = agg->start_idx - SEQ_TO_IDX(seq_ctl >> 4);
-	if (sh < 0) /* tbw something is wrong with indices */
+	if (sh < 0)		/* tbw something is wrong with indices */
 		sh += 0x100;
 
 	if (agg->frame_count > (64 - sh)) {
@@ -2565,16 +2566,13 @@ static int il4965_tx_status_reply_compressed_ba(struct il_priv *il,
 	while (sent_bitmap) {
 		ack = sent_bitmap & 1ULL;
 		successes += ack;
-		D_TX_REPLY("%s ON i=%d idx=%d raw=%d\n",
-			ack ? "ACK" : "NACK", i,
-			(agg->start_idx + i) & 0xff,
-			agg->start_idx + i);
+		D_TX_REPLY("%s ON i=%d idx=%d raw=%d\n", ack ? "ACK" : "NACK",
+			   i, (agg->start_idx + i) & 0xff, agg->start_idx + i);
 		sent_bitmap >>= 1;
 		++i;
 	}
 
-	D_TX_REPLY("Bitmap %llx\n",
-				   (unsigned long long)bitmap);
+	D_TX_REPLY("Bitmap %llx\n", (unsigned long long)bitmap);
 
 	info = IEEE80211_SKB_CB(il->txq[scd_flow].txb[agg->start_idx].skb);
 	memset(&info->status, 0, sizeof(info->status));
@@ -2590,13 +2588,14 @@ static int il4965_tx_status_reply_compressed_ba(struct il_priv *il,
 /**
  * translate ucode response to mac80211 tx status control values
  */
-void il4965_hwrate_to_tx_control(struct il_priv *il, u32 rate_n_flags,
-				  struct ieee80211_tx_info *info)
+void
+il4965_hwrate_to_tx_control(struct il_priv *il, u32 rate_n_flags,
+			    struct ieee80211_tx_info *info)
 {
 	struct ieee80211_tx_rate *r = &info->control.rates[0];
 
 	info->antenna_sel_tx =
-		((rate_n_flags & RATE_MCS_ANT_ABC_MSK) >> RATE_MCS_ANT_POS);
+	    ((rate_n_flags & RATE_MCS_ANT_ABC_MSK) >> RATE_MCS_ANT_POS);
 	if (rate_n_flags & RATE_MCS_HT_MSK)
 		r->flags |= IEEE80211_TX_RC_MCS;
 	if (rate_n_flags & RATE_MCS_GF_MSK)
@@ -2616,8 +2615,8 @@ void il4965_hwrate_to_tx_control(struct il_priv *il, u32 rate_n_flags,
  * Handles block-acknowledge notification from device, which reports success
  * of frames sent via aggregation.
  */
-void il4965_hdl_compressed_ba(struct il_priv *il,
-					   struct il_rx_buf *rxb)
+void
+il4965_hdl_compressed_ba(struct il_priv *il, struct il_rx_buf *rxb)
 {
 	struct il_rx_pkt *pkt = rxb_addr(rxb);
 	struct il_compressed_ba_resp *ba_resp = &pkt->u.compressed_ba;
@@ -2636,8 +2635,7 @@ void il4965_hdl_compressed_ba(struct il_priv *il,
 	u16 ba_resp_scd_ssn = le16_to_cpu(ba_resp->scd_ssn);
 
 	if (scd_flow >= il->hw_params.max_txq_num) {
-		IL_ERR(
-			"BUG_ON scd_flow is bigger than number of queues\n");
+		IL_ERR("BUG_ON scd_flow is bigger than number of queues\n");
 		return;
 	}
 
@@ -2652,9 +2650,8 @@ void il4965_hdl_compressed_ba(struct il_priv *il,
 		 * since it is possible happen very often and in order
 		 * not to fill the syslog, don't enable the logging by default
 		 */
-		D_TX_REPLY(
-			"BA scd_flow %d does not match txq_id %d\n",
-			scd_flow, agg->txq_id);
+		D_TX_REPLY("BA scd_flow %d does not match txq_id %d\n",
+			   scd_flow, agg->txq_id);
 		return;
 	}
 
@@ -2663,22 +2660,15 @@ void il4965_hdl_compressed_ba(struct il_priv *il,
 
 	spin_lock_irqsave(&il->sta_lock, flags);
 
-	D_TX_REPLY("N_COMPRESSED_BA [%d] Received from %pM, "
-			   "sta_id = %d\n",
-			   agg->wait_for_ba,
-			   (u8 *) &ba_resp->sta_addr_lo32,
-			   ba_resp->sta_id);
-	D_TX_REPLY("TID = %d, SeqCtl = %d, bitmap = 0x%llx,"
-			"scd_flow = "
-			   "%d, scd_ssn = %d\n",
-			   ba_resp->tid,
-			   ba_resp->seq_ctl,
-			   (unsigned long long)le64_to_cpu(ba_resp->bitmap),
-			   ba_resp->scd_flow,
-			   ba_resp->scd_ssn);
-	D_TX_REPLY("DAT start_idx = %d, bitmap = 0x%llx\n",
-			   agg->start_idx,
-			   (unsigned long long)agg->bitmap);
+	D_TX_REPLY("N_COMPRESSED_BA [%d] Received from %pM, " "sta_id = %d\n",
+		   agg->wait_for_ba, (u8 *) & ba_resp->sta_addr_lo32,
+		   ba_resp->sta_id);
+	D_TX_REPLY("TID = %d, SeqCtl = %d, bitmap = 0x%llx," "scd_flow = "
+		   "%d, scd_ssn = %d\n", ba_resp->tid, ba_resp->seq_ctl,
+		   (unsigned long long)le64_to_cpu(ba_resp->bitmap),
+		   ba_resp->scd_flow, ba_resp->scd_ssn);
+	D_TX_REPLY("DAT start_idx = %d, bitmap = 0x%llx\n", agg->start_idx,
+		   (unsigned long long)agg->bitmap);
 
 	/* Update driver's record of ACK vs. not for each frame in win */
 	il4965_tx_status_reply_compressed_ba(il, agg, ba_resp);
@@ -2703,7 +2693,8 @@ void il4965_hdl_compressed_ba(struct il_priv *il,
 }
 
 #ifdef CONFIG_IWLEGACY_DEBUG
-const char *il4965_get_tx_fail_reason(u32 status)
+const char *
+il4965_get_tx_fail_reason(u32 status)
 {
 #define TX_STATUS_FAIL(x) case TX_STATUS_FAIL_ ## x: return #x
 #define TX_STATUS_POSTPONE(x) case TX_STATUS_POSTPONE_ ## x: return #x
@@ -2711,27 +2702,27 @@ const char *il4965_get_tx_fail_reason(u32 status)
 	switch (status & TX_STATUS_MSK) {
 	case TX_STATUS_SUCCESS:
 		return "SUCCESS";
-	TX_STATUS_POSTPONE(DELAY);
-	TX_STATUS_POSTPONE(FEW_BYTES);
-	TX_STATUS_POSTPONE(QUIET_PERIOD);
-	TX_STATUS_POSTPONE(CALC_TTAK);
-	TX_STATUS_FAIL(INTERNAL_CROSSED_RETRY);
-	TX_STATUS_FAIL(SHORT_LIMIT);
-	TX_STATUS_FAIL(LONG_LIMIT);
-	TX_STATUS_FAIL(FIFO_UNDERRUN);
-	TX_STATUS_FAIL(DRAIN_FLOW);
-	TX_STATUS_FAIL(RFKILL_FLUSH);
-	TX_STATUS_FAIL(LIFE_EXPIRE);
-	TX_STATUS_FAIL(DEST_PS);
-	TX_STATUS_FAIL(HOST_ABORTED);
-	TX_STATUS_FAIL(BT_RETRY);
-	TX_STATUS_FAIL(STA_INVALID);
-	TX_STATUS_FAIL(FRAG_DROPPED);
-	TX_STATUS_FAIL(TID_DISABLE);
-	TX_STATUS_FAIL(FIFO_FLUSHED);
-	TX_STATUS_FAIL(INSUFFICIENT_CF_POLL);
-	TX_STATUS_FAIL(PASSIVE_NO_RX);
-	TX_STATUS_FAIL(NO_BEACON_ON_RADAR);
+		TX_STATUS_POSTPONE(DELAY);
+		TX_STATUS_POSTPONE(FEW_BYTES);
+		TX_STATUS_POSTPONE(QUIET_PERIOD);
+		TX_STATUS_POSTPONE(CALC_TTAK);
+		TX_STATUS_FAIL(INTERNAL_CROSSED_RETRY);
+		TX_STATUS_FAIL(SHORT_LIMIT);
+		TX_STATUS_FAIL(LONG_LIMIT);
+		TX_STATUS_FAIL(FIFO_UNDERRUN);
+		TX_STATUS_FAIL(DRAIN_FLOW);
+		TX_STATUS_FAIL(RFKILL_FLUSH);
+		TX_STATUS_FAIL(LIFE_EXPIRE);
+		TX_STATUS_FAIL(DEST_PS);
+		TX_STATUS_FAIL(HOST_ABORTED);
+		TX_STATUS_FAIL(BT_RETRY);
+		TX_STATUS_FAIL(STA_INVALID);
+		TX_STATUS_FAIL(FRAG_DROPPED);
+		TX_STATUS_FAIL(TID_DISABLE);
+		TX_STATUS_FAIL(FIFO_FLUSHED);
+		TX_STATUS_FAIL(INSUFFICIENT_CF_POLL);
+		TX_STATUS_FAIL(PASSIVE_NO_RX);
+		TX_STATUS_FAIL(NO_BEACON_ON_RADAR);
 	}
 
 	return "UNKNOWN";
@@ -2764,29 +2755,29 @@ il4965_sta_alloc_lq(struct il_priv *il, u8 sta_id)
 	if (r >= IL_FIRST_CCK_RATE && r <= IL_LAST_CCK_RATE)
 		rate_flags |= RATE_MCS_CCK_MSK;
 
-	rate_flags |= il4965_first_antenna(il->hw_params.valid_tx_ant) <<
-				RATE_MCS_ANT_POS;
-	rate_n_flags = il4965_hw_set_rate_n_flags(il_rates[r].plcp,
-						   rate_flags);
+	rate_flags |=
+	    il4965_first_antenna(il->hw_params.
+				 valid_tx_ant) << RATE_MCS_ANT_POS;
+	rate_n_flags = il4965_hw_set_rate_n_flags(il_rates[r].plcp, rate_flags);
 	for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
 		link_cmd->rs_table[i].rate_n_flags = rate_n_flags;
 
 	link_cmd->general_params.single_stream_ant_msk =
-				il4965_first_antenna(il->hw_params.valid_tx_ant);
+	    il4965_first_antenna(il->hw_params.valid_tx_ant);
 
 	link_cmd->general_params.dual_stream_ant_msk =
-		il->hw_params.valid_tx_ant &
-		~il4965_first_antenna(il->hw_params.valid_tx_ant);
+	    il->hw_params.valid_tx_ant & ~il4965_first_antenna(il->hw_params.
+							       valid_tx_ant);
 	if (!link_cmd->general_params.dual_stream_ant_msk) {
 		link_cmd->general_params.dual_stream_ant_msk = ANT_AB;
 	} else if (il4965_num_of_ant(il->hw_params.valid_tx_ant) == 2) {
 		link_cmd->general_params.dual_stream_ant_msk =
-			il->hw_params.valid_tx_ant;
+		    il->hw_params.valid_tx_ant;
 	}
 
 	link_cmd->agg_params.agg_dis_start_th = LINK_QUAL_AGG_DISABLE_START_DEF;
 	link_cmd->agg_params.agg_time_limit =
-		cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF);
+	    cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF);
 
 	link_cmd->sta_id = sta_id;
 
@@ -2800,7 +2791,7 @@ il4965_sta_alloc_lq(struct il_priv *il, u8 sta_id)
  */
 int
 il4965_add_bssid_station(struct il_priv *il, struct il_rxon_context *ctx,
-			     const u8 *addr, u8 *sta_id_r)
+			 const u8 * addr, u8 * sta_id_r)
 {
 	int ret;
 	u8 sta_id;
@@ -2826,9 +2817,8 @@ il4965_add_bssid_station(struct il_priv *il, struct il_rxon_context *ctx,
 	/* Set up default rate scaling table in device's station table */
 	link_cmd = il4965_sta_alloc_lq(il, sta_id);
 	if (!link_cmd) {
-		IL_ERR(
-			"Unable to initialize rate scaling for station %pM.\n",
-			addr);
+		IL_ERR("Unable to initialize rate scaling for station %pM.\n",
+		       addr);
 		return -ENOMEM;
 	}
 
@@ -2843,15 +2833,15 @@ il4965_add_bssid_station(struct il_priv *il, struct il_rxon_context *ctx,
 	return 0;
 }
 
-static int il4965_static_wepkey_cmd(struct il_priv *il,
-				      struct il_rxon_context *ctx,
-				      bool send_if_empty)
+static int
+il4965_static_wepkey_cmd(struct il_priv *il, struct il_rxon_context *ctx,
+			 bool send_if_empty)
 {
 	int i, not_empty = 0;
 	u8 buff[sizeof(struct il_wep_cmd) +
 		sizeof(struct il_wep_key) * WEP_KEYS_MAX];
 	struct il_wep_cmd *wep_cmd = (struct il_wep_cmd *)buff;
-	size_t cmd_size  = sizeof(struct il_wep_cmd);
+	size_t cmd_size = sizeof(struct il_wep_cmd);
 	struct il_host_cmd cmd = {
 		.id = ctx->wep_key_cmd,
 		.data = wep_cmd,
@@ -2860,10 +2850,10 @@ static int il4965_static_wepkey_cmd(struct il_priv *il,
 
 	might_sleep();
 
-	memset(wep_cmd, 0, cmd_size +
-			(sizeof(struct il_wep_key) * WEP_KEYS_MAX));
+	memset(wep_cmd, 0,
+	       cmd_size + (sizeof(struct il_wep_key) * WEP_KEYS_MAX));
 
-	for (i = 0; i < WEP_KEYS_MAX ; i++) {
+	for (i = 0; i < WEP_KEYS_MAX; i++) {
 		wep_cmd->key[i].key_idx = i;
 		if (ctx->wep_keys[i].key_size) {
 			wep_cmd->key[i].key_offset = i;
@@ -2874,7 +2864,7 @@ static int il4965_static_wepkey_cmd(struct il_priv *il,
 
 		wep_cmd->key[i].key_size = ctx->wep_keys[i].key_size;
 		memcpy(&wep_cmd->key[i].key[3], ctx->wep_keys[i].key,
-				ctx->wep_keys[i].key_size);
+		       ctx->wep_keys[i].key_size);
 	}
 
 	wep_cmd->global_key_type = WEP_KEY_WEP_TYPE;
@@ -2890,42 +2880,39 @@ static int il4965_static_wepkey_cmd(struct il_priv *il,
 		return 0;
 }
 
-int il4965_restore_default_wep_keys(struct il_priv *il,
-				 struct il_rxon_context *ctx)
+int
+il4965_restore_default_wep_keys(struct il_priv *il, struct il_rxon_context *ctx)
 {
 	lockdep_assert_held(&il->mutex);
 
 	return il4965_static_wepkey_cmd(il, ctx, false);
 }
 
-int il4965_remove_default_wep_key(struct il_priv *il,
-			       struct il_rxon_context *ctx,
-			       struct ieee80211_key_conf *keyconf)
+int
+il4965_remove_default_wep_key(struct il_priv *il, struct il_rxon_context *ctx,
+			      struct ieee80211_key_conf *keyconf)
 {
 	int ret;
 
 	lockdep_assert_held(&il->mutex);
 
-	D_WEP("Removing default WEP key: idx=%d\n",
-		      keyconf->keyidx);
+	D_WEP("Removing default WEP key: idx=%d\n", keyconf->keyidx);
 
 	memset(&ctx->wep_keys[keyconf->keyidx], 0, sizeof(ctx->wep_keys[0]));
 	if (il_is_rfkill(il)) {
-		D_WEP(
-		"Not sending C_WEPKEY command due to RFKILL.\n");
+		D_WEP("Not sending C_WEPKEY command due to RFKILL.\n");
 		/* but keys in device are clear anyway so return success */
 		return 0;
 	}
 	ret = il4965_static_wepkey_cmd(il, ctx, 1);
-	D_WEP("Remove default WEP key: idx=%d ret=%d\n",
-		      keyconf->keyidx, ret);
+	D_WEP("Remove default WEP key: idx=%d ret=%d\n", keyconf->keyidx, ret);
 
 	return ret;
 }
 
-int il4965_set_default_wep_key(struct il_priv *il,
-			    struct il_rxon_context *ctx,
-			    struct ieee80211_key_conf *keyconf)
+int
+il4965_set_default_wep_key(struct il_priv *il, struct il_rxon_context *ctx,
+			   struct ieee80211_key_conf *keyconf)
 {
 	int ret;
 
@@ -2943,19 +2930,18 @@ int il4965_set_default_wep_key(struct il_priv *il,
 
 	ctx->wep_keys[keyconf->keyidx].key_size = keyconf->keylen;
 	memcpy(&ctx->wep_keys[keyconf->keyidx].key, &keyconf->key,
-							keyconf->keylen);
+	       keyconf->keylen);
 
 	ret = il4965_static_wepkey_cmd(il, ctx, false);
-	D_WEP("Set default WEP key: len=%d idx=%d ret=%d\n",
-		keyconf->keylen, keyconf->keyidx, ret);
+	D_WEP("Set default WEP key: len=%d idx=%d ret=%d\n", keyconf->keylen,
+	      keyconf->keyidx, ret);
 
 	return ret;
 }
 
-static int il4965_set_wep_dynamic_key_info(struct il_priv *il,
-					struct il_rxon_context *ctx,
-					struct ieee80211_key_conf *keyconf,
-					u8 sta_id)
+static int
+il4965_set_wep_dynamic_key_info(struct il_priv *il, struct il_rxon_context *ctx,
+				struct ieee80211_key_conf *keyconf, u8 sta_id)
 {
 	unsigned long flags;
 	__le16 key_flags = 0;
@@ -2981,37 +2967,36 @@ static int il4965_set_wep_dynamic_key_info(struct il_priv *il,
 	il->stations[sta_id].keyinfo.keylen = keyconf->keylen;
 	il->stations[sta_id].keyinfo.keyidx = keyconf->keyidx;
 
-	memcpy(il->stations[sta_id].keyinfo.key,
-				keyconf->key, keyconf->keylen);
+	memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, keyconf->keylen);
 
-	memcpy(&il->stations[sta_id].sta.key.key[3],
-				keyconf->key, keyconf->keylen);
+	memcpy(&il->stations[sta_id].sta.key.key[3], keyconf->key,
+	       keyconf->keylen);
 
-	if ((il->stations[sta_id].sta.key.key_flags & STA_KEY_FLG_ENCRYPT_MSK)
-			== STA_KEY_FLG_NO_ENC)
+	if ((il->stations[sta_id].sta.key.
+	     key_flags & STA_KEY_FLG_ENCRYPT_MSK) == STA_KEY_FLG_NO_ENC)
 		il->stations[sta_id].sta.key.key_offset =
-				 il_get_free_ucode_key_idx(il);
+		    il_get_free_ucode_key_idx(il);
 	/* else, we are overriding an existing key => no need to allocated room
 	 * in uCode. */
 
 	WARN(il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
-		"no space for a new key");
+	     "no space for a new key");
 
 	il->stations[sta_id].sta.key.key_flags = key_flags;
 	il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
 	il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
 
 	memcpy(&sta_cmd, &il->stations[sta_id].sta,
-			sizeof(struct il_addsta_cmd));
+	       sizeof(struct il_addsta_cmd));
 	spin_unlock_irqrestore(&il->sta_lock, flags);
 
 	return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
 }
 
-static int il4965_set_ccmp_dynamic_key_info(struct il_priv *il,
-					 struct il_rxon_context *ctx,
-					 struct ieee80211_key_conf *keyconf,
-					 u8 sta_id)
+static int
+il4965_set_ccmp_dynamic_key_info(struct il_priv *il,
+				 struct il_rxon_context *ctx,
+				 struct ieee80211_key_conf *keyconf, u8 sta_id)
 {
 	unsigned long flags;
 	__le16 key_flags = 0;
@@ -3032,37 +3017,35 @@ static int il4965_set_ccmp_dynamic_key_info(struct il_priv *il,
 	il->stations[sta_id].keyinfo.cipher = keyconf->cipher;
 	il->stations[sta_id].keyinfo.keylen = keyconf->keylen;
 
-	memcpy(il->stations[sta_id].keyinfo.key, keyconf->key,
-	       keyconf->keylen);
+	memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, keyconf->keylen);
 
-	memcpy(il->stations[sta_id].sta.key.key, keyconf->key,
-	       keyconf->keylen);
+	memcpy(il->stations[sta_id].sta.key.key, keyconf->key, keyconf->keylen);
 
-	if ((il->stations[sta_id].sta.key.key_flags & STA_KEY_FLG_ENCRYPT_MSK)
-			== STA_KEY_FLG_NO_ENC)
+	if ((il->stations[sta_id].sta.key.
+	     key_flags & STA_KEY_FLG_ENCRYPT_MSK) == STA_KEY_FLG_NO_ENC)
 		il->stations[sta_id].sta.key.key_offset =
-				 il_get_free_ucode_key_idx(il);
+		    il_get_free_ucode_key_idx(il);
 	/* else, we are overriding an existing key => no need to allocated room
 	 * in uCode. */
 
 	WARN(il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
-		"no space for a new key");
+	     "no space for a new key");
 
 	il->stations[sta_id].sta.key.key_flags = key_flags;
 	il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
 	il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
 
 	memcpy(&sta_cmd, &il->stations[sta_id].sta,
-			 sizeof(struct il_addsta_cmd));
+	       sizeof(struct il_addsta_cmd));
 	spin_unlock_irqrestore(&il->sta_lock, flags);
 
 	return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
 }
 
-static int il4965_set_tkip_dynamic_key_info(struct il_priv *il,
-					 struct il_rxon_context *ctx,
-					 struct ieee80211_key_conf *keyconf,
-					 u8 sta_id)
+static int
+il4965_set_tkip_dynamic_key_info(struct il_priv *il,
+				 struct il_rxon_context *ctx,
+				 struct ieee80211_key_conf *keyconf, u8 sta_id)
 {
 	unsigned long flags;
 	int ret = 0;
@@ -3083,19 +3066,18 @@ static int il4965_set_tkip_dynamic_key_info(struct il_priv *il,
 	il->stations[sta_id].keyinfo.cipher = keyconf->cipher;
 	il->stations[sta_id].keyinfo.keylen = 16;
 
-	if ((il->stations[sta_id].sta.key.key_flags & STA_KEY_FLG_ENCRYPT_MSK)
-			== STA_KEY_FLG_NO_ENC)
+	if ((il->stations[sta_id].sta.key.
+	     key_flags & STA_KEY_FLG_ENCRYPT_MSK) == STA_KEY_FLG_NO_ENC)
 		il->stations[sta_id].sta.key.key_offset =
-				 il_get_free_ucode_key_idx(il);
+		    il_get_free_ucode_key_idx(il);
 	/* else, we are overriding an existing key => no need to allocated room
 	 * in uCode. */
 
 	WARN(il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
-		"no space for a new key");
+	     "no space for a new key");
 
 	il->stations[sta_id].sta.key.key_flags = key_flags;
 
-
 	/* This copy is acutally not needed: we get the key with each TX */
 	memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, 16);
 
@@ -3106,10 +3088,10 @@ static int il4965_set_tkip_dynamic_key_info(struct il_priv *il,
 	return ret;
 }
 
-void il4965_update_tkip_key(struct il_priv *il,
-			 struct il_rxon_context *ctx,
-			 struct ieee80211_key_conf *keyconf,
-			 struct ieee80211_sta *sta, u32 iv32, u16 *phase1key)
+void
+il4965_update_tkip_key(struct il_priv *il, struct il_rxon_context *ctx,
+		       struct ieee80211_key_conf *keyconf,
+		       struct ieee80211_sta *sta, u32 iv32, u16 * phase1key)
 {
 	u8 sta_id;
 	unsigned long flags;
@@ -3131,7 +3113,7 @@ void il4965_update_tkip_key(struct il_priv *il,
 
 	for (i = 0; i < 5; i++)
 		il->stations[sta_id].sta.key.tkip_rx_ttak[i] =
-			cpu_to_le16(phase1key[i]);
+		    cpu_to_le16(phase1key[i]);
 
 	il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
 	il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
@@ -3142,10 +3124,9 @@ void il4965_update_tkip_key(struct il_priv *il,
 
 }
 
-int il4965_remove_dynamic_key(struct il_priv *il,
-			   struct il_rxon_context *ctx,
-			   struct ieee80211_key_conf *keyconf,
-			   u8 sta_id)
+int
+il4965_remove_dynamic_key(struct il_priv *il, struct il_rxon_context *ctx,
+			  struct ieee80211_key_conf *keyconf, u8 sta_id)
 {
 	unsigned long flags;
 	u16 key_flags;
@@ -3160,8 +3141,7 @@ int il4965_remove_dynamic_key(struct il_priv *il,
 	key_flags = le16_to_cpu(il->stations[sta_id].sta.key.key_flags);
 	keyidx = (key_flags >> STA_KEY_FLG_KEYID_POS) & 0x3;
 
-	D_WEP("Remove dynamic key: idx=%d sta=%d\n",
-		      keyconf->keyidx, sta_id);
+	D_WEP("Remove dynamic key: idx=%d sta=%d\n", keyconf->keyidx, sta_id);
 
 	if (keyconf->keyidx != keyidx) {
 		/* We need to remove a key with idx different that the one
@@ -3174,41 +3154,40 @@ int il4965_remove_dynamic_key(struct il_priv *il,
 	}
 
 	if (il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET) {
-		IL_WARN("Removing wrong key %d 0x%x\n",
-			    keyconf->keyidx, key_flags);
+		IL_WARN("Removing wrong key %d 0x%x\n", keyconf->keyidx,
+			key_flags);
 		spin_unlock_irqrestore(&il->sta_lock, flags);
 		return 0;
 	}
 
-	if (!test_and_clear_bit(il->stations[sta_id].sta.key.key_offset,
-		&il->ucode_key_table))
+	if (!test_and_clear_bit
+	    (il->stations[sta_id].sta.key.key_offset, &il->ucode_key_table))
 		IL_ERR("idx %d not used in uCode key table.\n",
-			il->stations[sta_id].sta.key.key_offset);
-	memset(&il->stations[sta_id].keyinfo, 0,
-					sizeof(struct il_hw_key));
-	memset(&il->stations[sta_id].sta.key, 0,
-					sizeof(struct il4965_keyinfo));
+		       il->stations[sta_id].sta.key.key_offset);
+	memset(&il->stations[sta_id].keyinfo, 0, sizeof(struct il_hw_key));
+	memset(&il->stations[sta_id].sta.key, 0, sizeof(struct il4965_keyinfo));
 	il->stations[sta_id].sta.key.key_flags =
-			STA_KEY_FLG_NO_ENC | STA_KEY_FLG_INVALID;
+	    STA_KEY_FLG_NO_ENC | STA_KEY_FLG_INVALID;
 	il->stations[sta_id].sta.key.key_offset = WEP_INVALID_OFFSET;
 	il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
 	il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
 
 	if (il_is_rfkill(il)) {
-		D_WEP(
-		 "Not sending C_ADD_STA command because RFKILL enabled.\n");
+		D_WEP
+		    ("Not sending C_ADD_STA command because RFKILL enabled.\n");
 		spin_unlock_irqrestore(&il->sta_lock, flags);
 		return 0;
 	}
 	memcpy(&sta_cmd, &il->stations[sta_id].sta,
-			sizeof(struct il_addsta_cmd));
+	       sizeof(struct il_addsta_cmd));
 	spin_unlock_irqrestore(&il->sta_lock, flags);
 
 	return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
 }
 
-int il4965_set_dynamic_key(struct il_priv *il, struct il_rxon_context *ctx,
-			struct ieee80211_key_conf *keyconf, u8 sta_id)
+int
+il4965_set_dynamic_key(struct il_priv *il, struct il_rxon_context *ctx,
+		       struct ieee80211_key_conf *keyconf, u8 sta_id)
 {
 	int ret;
 
@@ -3219,29 +3198,25 @@ int il4965_set_dynamic_key(struct il_priv *il, struct il_rxon_context *ctx,
 
 	switch (keyconf->cipher) {
 	case WLAN_CIPHER_SUITE_CCMP:
-		ret = il4965_set_ccmp_dynamic_key_info(il, ctx,
-							keyconf, sta_id);
+		ret =
+		    il4965_set_ccmp_dynamic_key_info(il, ctx, keyconf, sta_id);
 		break;
 	case WLAN_CIPHER_SUITE_TKIP:
-		ret = il4965_set_tkip_dynamic_key_info(il, ctx,
-							keyconf, sta_id);
+		ret =
+		    il4965_set_tkip_dynamic_key_info(il, ctx, keyconf, sta_id);
 		break;
 	case WLAN_CIPHER_SUITE_WEP40:
 	case WLAN_CIPHER_SUITE_WEP104:
-		ret = il4965_set_wep_dynamic_key_info(il, ctx,
-							keyconf, sta_id);
+		ret = il4965_set_wep_dynamic_key_info(il, ctx, keyconf, sta_id);
 		break;
 	default:
-		IL_ERR(
-			"Unknown alg: %s cipher = %x\n", __func__,
-			keyconf->cipher);
+		IL_ERR("Unknown alg: %s cipher = %x\n", __func__,
+		       keyconf->cipher);
 		ret = -EINVAL;
 	}
 
-	D_WEP(
-		"Set dynamic key: cipher=%x len=%d idx=%d sta=%d ret=%d\n",
-		      keyconf->cipher, keyconf->keylen, keyconf->keyidx,
-		      sta_id, ret);
+	D_WEP("Set dynamic key: cipher=%x len=%d idx=%d sta=%d ret=%d\n",
+	      keyconf->cipher, keyconf->keylen, keyconf->keyidx, sta_id, ret);
 
 	return ret;
 }
@@ -3253,16 +3228,15 @@ int il4965_set_dynamic_key(struct il_priv *il, struct il_rxon_context *ctx,
  * and marks it driver active, so that it will be restored to the
  * device at the next best time.
  */
-int il4965_alloc_bcast_station(struct il_priv *il,
-			       struct il_rxon_context *ctx)
+int
+il4965_alloc_bcast_station(struct il_priv *il, struct il_rxon_context *ctx)
 {
 	struct il_link_quality_cmd *link_cmd;
 	unsigned long flags;
 	u8 sta_id;
 
 	spin_lock_irqsave(&il->sta_lock, flags);
-	sta_id = il_prep_station(il, ctx, il_bcast_addr,
-								false, NULL);
+	sta_id = il_prep_station(il, ctx, il_bcast_addr, false, NULL);
 	if (sta_id == IL_INVALID_STATION) {
 		IL_ERR("Unable to prepare broadcast station\n");
 		spin_unlock_irqrestore(&il->sta_lock, flags);
@@ -3276,8 +3250,8 @@ int il4965_alloc_bcast_station(struct il_priv *il,
 
 	link_cmd = il4965_sta_alloc_lq(il, sta_id);
 	if (!link_cmd) {
-		IL_ERR(
-			"Unable to initialize rate scaling for bcast station.\n");
+		IL_ERR
+		    ("Unable to initialize rate scaling for bcast station.\n");
 		return -ENOMEM;
 	}
 
@@ -3294,8 +3268,8 @@ int il4965_alloc_bcast_station(struct il_priv *il,
  * Only used by iwl4965. Placed here to have all bcast station management
  * code together.
  */
-static int il4965_update_bcast_station(struct il_priv *il,
-				    struct il_rxon_context *ctx)
+static int
+il4965_update_bcast_station(struct il_priv *il, struct il_rxon_context *ctx)
 {
 	unsigned long flags;
 	struct il_link_quality_cmd *link_cmd;
@@ -3303,8 +3277,8 @@ static int il4965_update_bcast_station(struct il_priv *il,
 
 	link_cmd = il4965_sta_alloc_lq(il, sta_id);
 	if (!link_cmd) {
-		IL_ERR(
-		"Unable to initialize rate scaling for bcast station.\n");
+		IL_ERR
+		    ("Unable to initialize rate scaling for bcast station.\n");
 		return -ENOMEM;
 	}
 
@@ -3312,15 +3286,16 @@ static int il4965_update_bcast_station(struct il_priv *il,
 	if (il->stations[sta_id].lq)
 		kfree(il->stations[sta_id].lq);
 	else
-		D_INFO(
-		"Bcast station rate scaling has not been initialized yet.\n");
+		D_INFO
+		    ("Bcast station rate scaling has not been initialized yet.\n");
 	il->stations[sta_id].lq = link_cmd;
 	spin_unlock_irqrestore(&il->sta_lock, flags);
 
 	return 0;
 }
 
-int il4965_update_bcast_stations(struct il_priv *il)
+int
+il4965_update_bcast_stations(struct il_priv *il)
 {
 	return il4965_update_bcast_station(il, &il->ctx);
 }
@@ -3328,7 +3303,8 @@ int il4965_update_bcast_stations(struct il_priv *il)
 /**
  * il4965_sta_tx_modify_enable_tid - Enable Tx for this TID in station table
  */
-int il4965_sta_tx_modify_enable_tid(struct il_priv *il, int sta_id, int tid)
+int
+il4965_sta_tx_modify_enable_tid(struct il_priv *il, int sta_id, int tid)
 {
 	unsigned long flags;
 	struct il_addsta_cmd sta_cmd;
@@ -3341,14 +3317,15 @@ int il4965_sta_tx_modify_enable_tid(struct il_priv *il, int sta_id, int tid)
 	il->stations[sta_id].sta.tid_disable_tx &= cpu_to_le16(~(1 << tid));
 	il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
 	memcpy(&sta_cmd, &il->stations[sta_id].sta,
-					sizeof(struct il_addsta_cmd));
+	       sizeof(struct il_addsta_cmd));
 	spin_unlock_irqrestore(&il->sta_lock, flags);
 
 	return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
 }
 
-int il4965_sta_rx_agg_start(struct il_priv *il, struct ieee80211_sta *sta,
-			 int tid, u16 ssn)
+int
+il4965_sta_rx_agg_start(struct il_priv *il, struct ieee80211_sta *sta, int tid,
+			u16 ssn)
 {
 	unsigned long flags;
 	int sta_id;
@@ -3363,18 +3340,18 @@ int il4965_sta_rx_agg_start(struct il_priv *il, struct ieee80211_sta *sta,
 	spin_lock_irqsave(&il->sta_lock, flags);
 	il->stations[sta_id].sta.station_flags_msk = 0;
 	il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_ADDBA_TID_MSK;
-	il->stations[sta_id].sta.add_immediate_ba_tid = (u8)tid;
+	il->stations[sta_id].sta.add_immediate_ba_tid = (u8) tid;
 	il->stations[sta_id].sta.add_immediate_ba_ssn = cpu_to_le16(ssn);
 	il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
 	memcpy(&sta_cmd, &il->stations[sta_id].sta,
-					sizeof(struct il_addsta_cmd));
+	       sizeof(struct il_addsta_cmd));
 	spin_unlock_irqrestore(&il->sta_lock, flags);
 
 	return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
 }
 
-int il4965_sta_rx_agg_stop(struct il_priv *il, struct ieee80211_sta *sta,
-			int tid)
+int
+il4965_sta_rx_agg_stop(struct il_priv *il, struct ieee80211_sta *sta, int tid)
 {
 	unsigned long flags;
 	int sta_id;
@@ -3391,10 +3368,10 @@ int il4965_sta_rx_agg_stop(struct il_priv *il, struct ieee80211_sta *sta,
 	spin_lock_irqsave(&il->sta_lock, flags);
 	il->stations[sta_id].sta.station_flags_msk = 0;
 	il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_DELBA_TID_MSK;
-	il->stations[sta_id].sta.remove_immediate_ba_tid = (u8)tid;
+	il->stations[sta_id].sta.remove_immediate_ba_tid = (u8) tid;
 	il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
 	memcpy(&sta_cmd, &il->stations[sta_id].sta,
-				sizeof(struct il_addsta_cmd));
+	       sizeof(struct il_addsta_cmd));
 	spin_unlock_irqrestore(&il->sta_lock, flags);
 
 	return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
@@ -3409,16 +3386,16 @@ il4965_sta_modify_sleep_tx_count(struct il_priv *il, int sta_id, int cnt)
 	il->stations[sta_id].sta.station_flags |= STA_FLG_PWR_SAVE_MSK;
 	il->stations[sta_id].sta.station_flags_msk = STA_FLG_PWR_SAVE_MSK;
 	il->stations[sta_id].sta.sta.modify_mask =
-					STA_MODIFY_SLEEP_TX_COUNT_MSK;
+	    STA_MODIFY_SLEEP_TX_COUNT_MSK;
 	il->stations[sta_id].sta.sleep_tx_count = cpu_to_le16(cnt);
 	il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
-	il_send_add_sta(il,
-				&il->stations[sta_id].sta, CMD_ASYNC);
+	il_send_add_sta(il, &il->stations[sta_id].sta, CMD_ASYNC);
 	spin_unlock_irqrestore(&il->sta_lock, flags);
 
 }
 
-void il4965_update_chain_flags(struct il_priv *il)
+void
+il4965_update_chain_flags(struct il_priv *il)
 {
 	if (il->cfg->ops->hcmd->set_rxon_chain) {
 		il->cfg->ops->hcmd->set_rxon_chain(il, &il->ctx);
@@ -3427,12 +3404,12 @@ void il4965_update_chain_flags(struct il_priv *il)
 	}
 }
 
-static void il4965_clear_free_frames(struct il_priv *il)
+static void
+il4965_clear_free_frames(struct il_priv *il)
 {
 	struct list_head *element;
 
-	D_INFO("%d frames on pre-allocated heap on clear.\n",
-		       il->frames_count);
+	D_INFO("%d frames on pre-allocated heap on clear.\n", il->frames_count);
 
 	while (!list_empty(&il->free_frames)) {
 		element = il->free_frames.next;
@@ -3443,12 +3420,13 @@ static void il4965_clear_free_frames(struct il_priv *il)
 
 	if (il->frames_count) {
 		IL_WARN("%d frames still in use.  Did we lose one?\n",
-			    il->frames_count);
+			il->frames_count);
 		il->frames_count = 0;
 	}
 }
 
-static struct il_frame *il4965_get_free_frame(struct il_priv *il)
+static struct il_frame *
+il4965_get_free_frame(struct il_priv *il)
 {
 	struct il_frame *frame;
 	struct list_head *element;
@@ -3468,15 +3446,16 @@ static struct il_frame *il4965_get_free_frame(struct il_priv *il)
 	return list_entry(element, struct il_frame, list);
 }
 
-static void il4965_free_frame(struct il_priv *il, struct il_frame *frame)
+static void
+il4965_free_frame(struct il_priv *il, struct il_frame *frame)
 {
 	memset(frame, 0, sizeof(*frame));
 	list_add(&frame->list, &il->free_frames);
 }
 
-static u32 il4965_fill_beacon_frame(struct il_priv *il,
-				 struct ieee80211_hdr *hdr,
-				 int left)
+static u32
+il4965_fill_beacon_frame(struct il_priv *il, struct ieee80211_hdr *hdr,
+			 int left)
 {
 	lockdep_assert_held(&il->mutex);
 
@@ -3492,9 +3471,10 @@ static u32 il4965_fill_beacon_frame(struct il_priv *il,
 }
 
 /* Parse the beacon frame to find the TIM element and set tim_idx & tim_size */
-static void il4965_set_beacon_tim(struct il_priv *il,
-			       struct il_tx_beacon_cmd *tx_beacon_cmd,
-			       u8 *beacon, u32 frame_size)
+static void
+il4965_set_beacon_tim(struct il_priv *il,
+		      struct il_tx_beacon_cmd *tx_beacon_cmd, u8 * beacon,
+		      u32 frame_size)
 {
 	u16 tim_idx;
 	struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)beacon;
@@ -3507,19 +3487,19 @@ static void il4965_set_beacon_tim(struct il_priv *il,
 
 	/* Parse variable-length elements of beacon to find WLAN_EID_TIM */
 	while ((tim_idx < (frame_size - 2)) &&
-			(beacon[tim_idx] != WLAN_EID_TIM))
-		tim_idx += beacon[tim_idx+1] + 2;
+	       (beacon[tim_idx] != WLAN_EID_TIM))
+		tim_idx += beacon[tim_idx + 1] + 2;
 
 	/* If TIM field was found, set variables */
 	if ((tim_idx < (frame_size - 1)) && (beacon[tim_idx] == WLAN_EID_TIM)) {
 		tx_beacon_cmd->tim_idx = cpu_to_le16(tim_idx);
-		tx_beacon_cmd->tim_size = beacon[tim_idx+1];
+		tx_beacon_cmd->tim_size = beacon[tim_idx + 1];
 	} else
 		IL_WARN("Unable to find TIM Element in beacon\n");
 }
 
-static unsigned int il4965_hw_get_beacon_cmd(struct il_priv *il,
-				       struct il_frame *frame)
+static unsigned int
+il4965_hw_get_beacon_cmd(struct il_priv *il, struct il_frame *frame)
 {
 	struct il_tx_beacon_cmd *tx_beacon_cmd;
 	u32 frame_size;
@@ -3542,38 +3522,42 @@ static unsigned int il4965_hw_get_beacon_cmd(struct il_priv *il,
 	memset(tx_beacon_cmd, 0, sizeof(*tx_beacon_cmd));
 
 	/* Set up TX beacon contents */
-	frame_size = il4965_fill_beacon_frame(il, tx_beacon_cmd->frame,
-				sizeof(frame->u) - sizeof(*tx_beacon_cmd));
+	frame_size =
+	    il4965_fill_beacon_frame(il, tx_beacon_cmd->frame,
+				     sizeof(frame->u) - sizeof(*tx_beacon_cmd));
 	if (WARN_ON_ONCE(frame_size > MAX_MPDU_SIZE))
 		return 0;
 	if (!frame_size)
 		return 0;
 
 	/* Set up TX command fields */
-	tx_beacon_cmd->tx.len = cpu_to_le16((u16)frame_size);
+	tx_beacon_cmd->tx.len = cpu_to_le16((u16) frame_size);
 	tx_beacon_cmd->tx.sta_id = il->beacon_ctx->bcast_sta_id;
 	tx_beacon_cmd->tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
-	tx_beacon_cmd->tx.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK |
-		TX_CMD_FLG_TSF_MSK | TX_CMD_FLG_STA_RATE_MSK;
+	tx_beacon_cmd->tx.tx_flags =
+	    TX_CMD_FLG_SEQ_CTL_MSK | TX_CMD_FLG_TSF_MSK |
+	    TX_CMD_FLG_STA_RATE_MSK;
 
 	/* Set up TX beacon command fields */
-	il4965_set_beacon_tim(il, tx_beacon_cmd, (u8 *)tx_beacon_cmd->frame,
-			   frame_size);
+	il4965_set_beacon_tim(il, tx_beacon_cmd, (u8 *) tx_beacon_cmd->frame,
+			      frame_size);
 
 	/* Set up packet rate and flags */
 	rate = il_get_lowest_plcp(il, il->beacon_ctx);
-	il->mgmt_tx_ant = il4965_toggle_tx_ant(il, il->mgmt_tx_ant,
-					      il->hw_params.valid_tx_ant);
+	il->mgmt_tx_ant =
+	    il4965_toggle_tx_ant(il, il->mgmt_tx_ant,
+				 il->hw_params.valid_tx_ant);
 	rate_flags = il4965_ant_idx_to_flags(il->mgmt_tx_ant);
 	if ((rate >= IL_FIRST_CCK_RATE) && (rate <= IL_LAST_CCK_RATE))
 		rate_flags |= RATE_MCS_CCK_MSK;
-	tx_beacon_cmd->tx.rate_n_flags = il4965_hw_set_rate_n_flags(rate,
-			rate_flags);
+	tx_beacon_cmd->tx.rate_n_flags =
+	    il4965_hw_set_rate_n_flags(rate, rate_flags);
 
 	return sizeof(*tx_beacon_cmd) + frame_size;
 }
 
-int il4965_send_beacon_cmd(struct il_priv *il)
+int
+il4965_send_beacon_cmd(struct il_priv *il)
 {
 	struct il_frame *frame;
 	unsigned int frame_size;
@@ -3582,7 +3566,7 @@ int il4965_send_beacon_cmd(struct il_priv *il)
 	frame = il4965_get_free_frame(il);
 	if (!frame) {
 		IL_ERR("Could not obtain free frame buffer for beacon "
-			  "command.\n");
+		       "command.\n");
 		return -ENOMEM;
 	}
 
@@ -3593,35 +3577,37 @@ int il4965_send_beacon_cmd(struct il_priv *il)
 		return -EINVAL;
 	}
 
-	rc = il_send_cmd_pdu(il, C_TX_BEACON, frame_size,
-			      &frame->u.cmd[0]);
+	rc = il_send_cmd_pdu(il, C_TX_BEACON, frame_size, &frame->u.cmd[0]);
 
 	il4965_free_frame(il, frame);
 
 	return rc;
 }
 
-static inline dma_addr_t il4965_tfd_tb_get_addr(struct il_tfd *tfd, u8 idx)
+static inline dma_addr_t
+il4965_tfd_tb_get_addr(struct il_tfd *tfd, u8 idx)
 {
 	struct il_tfd_tb *tb = &tfd->tbs[idx];
 
 	dma_addr_t addr = get_unaligned_le32(&tb->lo);
 	if (sizeof(dma_addr_t) > sizeof(u32))
 		addr |=
-		((dma_addr_t)(le16_to_cpu(tb->hi_n_len) & 0xF) << 16) << 16;
+		    ((dma_addr_t) (le16_to_cpu(tb->hi_n_len) & 0xF) << 16) <<
+		    16;
 
 	return addr;
 }
 
-static inline u16 il4965_tfd_tb_get_len(struct il_tfd *tfd, u8 idx)
+static inline u16
+il4965_tfd_tb_get_len(struct il_tfd *tfd, u8 idx)
 {
 	struct il_tfd_tb *tb = &tfd->tbs[idx];
 
 	return le16_to_cpu(tb->hi_n_len) >> 4;
 }
 
-static inline void il4965_tfd_set_tb(struct il_tfd *tfd, u8 idx,
-				  dma_addr_t addr, u16 len)
+static inline void
+il4965_tfd_set_tb(struct il_tfd *tfd, u8 idx, dma_addr_t addr, u16 len)
 {
 	struct il_tfd_tb *tb = &tfd->tbs[idx];
 	u16 hi_n_len = len << 4;
@@ -3635,7 +3621,8 @@ static inline void il4965_tfd_set_tb(struct il_tfd *tfd, u8 idx,
 	tfd->num_tbs = idx + 1;
 }
 
-static inline u8 il4965_tfd_get_num_tbs(struct il_tfd *tfd)
+static inline u8
+il4965_tfd_get_num_tbs(struct il_tfd *tfd)
 {
 	return tfd->num_tbs & 0x1f;
 }
@@ -3648,7 +3635,8 @@ static inline u8 il4965_tfd_get_num_tbs(struct il_tfd *tfd)
  * Does NOT advance any TFD circular buffer read/write idxes
  * Does NOT free the TFD itself (which is within circular buffer)
  */
-void il4965_hw_txq_free_tfd(struct il_priv *il, struct il_tx_queue *txq)
+void
+il4965_hw_txq_free_tfd(struct il_priv *il, struct il_tx_queue *txq)
 {
 	struct il_tfd *tfd_tmp = (struct il_tfd *)txq->tfds;
 	struct il_tfd *tfd;
@@ -3670,16 +3658,15 @@ void il4965_hw_txq_free_tfd(struct il_priv *il, struct il_tx_queue *txq)
 
 	/* Unmap tx_cmd */
 	if (num_tbs)
-		pci_unmap_single(dev,
-				dma_unmap_addr(&txq->meta[idx], mapping),
-				dma_unmap_len(&txq->meta[idx], len),
-				PCI_DMA_BIDIRECTIONAL);
+		pci_unmap_single(dev, dma_unmap_addr(&txq->meta[idx], mapping),
+				 dma_unmap_len(&txq->meta[idx], len),
+				 PCI_DMA_BIDIRECTIONAL);
 
 	/* Unmap chunks, if any. */
 	for (i = 1; i < num_tbs; i++)
 		pci_unmap_single(dev, il4965_tfd_tb_get_addr(tfd, i),
-				il4965_tfd_tb_get_len(tfd, i),
-				PCI_DMA_TODEVICE);
+				 il4965_tfd_tb_get_len(tfd, i),
+				 PCI_DMA_TODEVICE);
 
 	/* free SKB */
 	if (txq->txb) {
@@ -3695,10 +3682,9 @@ void il4965_hw_txq_free_tfd(struct il_priv *il, struct il_tx_queue *txq)
 	}
 }
 
-int il4965_hw_txq_attach_buf_to_tfd(struct il_priv *il,
-				 struct il_tx_queue *txq,
-				 dma_addr_t addr, u16 len,
-				 u8 reset, u8 pad)
+int
+il4965_hw_txq_attach_buf_to_tfd(struct il_priv *il, struct il_tx_queue *txq,
+				dma_addr_t addr, u16 len, u8 reset, u8 pad)
 {
 	struct il_queue *q;
 	struct il_tfd *tfd, *tfd_tmp;
@@ -3716,14 +3702,13 @@ int il4965_hw_txq_attach_buf_to_tfd(struct il_priv *il,
 	/* Each TFD can point to a maximum 20 Tx buffers */
 	if (num_tbs >= IL_NUM_OF_TBS) {
 		IL_ERR("Error can not send more than %d chunks\n",
-			  IL_NUM_OF_TBS);
+		       IL_NUM_OF_TBS);
 		return -EINVAL;
 	}
 
 	BUG_ON(addr & ~DMA_BIT_MASK(36));
 	if (unlikely(addr & ~IL_TX_DMA_MASK))
-		IL_ERR("Unaligned address = %llx\n",
-			  (unsigned long long)addr);
+		IL_ERR("Unaligned address = %llx\n", (unsigned long long)addr);
 
 	il4965_tfd_set_tb(tfd, num_tbs, addr, len);
 
@@ -3737,14 +3722,13 @@ int il4965_hw_txq_attach_buf_to_tfd(struct il_priv *il,
  * 4965 supports up to 16 Tx queues in DRAM, mapped to up to 8 Tx DMA
  * channels supported in hardware.
  */
-int il4965_hw_tx_queue_init(struct il_priv *il,
-			 struct il_tx_queue *txq)
+int
+il4965_hw_tx_queue_init(struct il_priv *il, struct il_tx_queue *txq)
 {
 	int txq_id = txq->q.id;
 
 	/* Circular buffer (TFD queue in DRAM) physical base address */
-	il_wr(il, FH49_MEM_CBBC_QUEUE(txq_id),
-			     txq->q.dma_addr >> 8);
+	il_wr(il, FH49_MEM_CBBC_QUEUE(txq_id), txq->q.dma_addr >> 8);
 
 	return 0;
 }
@@ -3754,8 +3738,8 @@ int il4965_hw_tx_queue_init(struct il_priv *il,
  * Generic RX handler implementations
  *
  ******************************************************************************/
-static void il4965_hdl_alive(struct il_priv *il,
-				struct il_rx_buf *rxb)
+static void
+il4965_hdl_alive(struct il_priv *il, struct il_rx_buf *rxb)
 {
 	struct il_rx_pkt *pkt = rxb_addr(rxb);
 	struct il_alive_resp *palive;
@@ -3763,15 +3747,12 @@ static void il4965_hdl_alive(struct il_priv *il,
 
 	palive = &pkt->u.alive_frame;
 
-	D_INFO("Alive ucode status 0x%08X revision "
-		       "0x%01X 0x%01X\n",
-		       palive->is_valid, palive->ver_type,
-		       palive->ver_subtype);
+	D_INFO("Alive ucode status 0x%08X revision " "0x%01X 0x%01X\n",
+	       palive->is_valid, palive->ver_type, palive->ver_subtype);
 
 	if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
 		D_INFO("Initialization Alive received.\n");
-		memcpy(&il->card_alive_init,
-		       &pkt->u.alive_frame,
+		memcpy(&il->card_alive_init, &pkt->u.alive_frame,
 		       sizeof(struct il_init_alive_resp));
 		pwork = &il->init_alive_start;
 	} else {
@@ -3784,8 +3765,7 @@ static void il4965_hdl_alive(struct il_priv *il,
 	/* We delay the ALIVE response by 5ms to
 	 * give the HW RF Kill time to activate... */
 	if (palive->is_valid == UCODE_VALID_OK)
-		queue_delayed_work(il->workqueue, pwork,
-				   msecs_to_jiffies(5));
+		queue_delayed_work(il->workqueue, pwork, msecs_to_jiffies(5));
 	else
 		IL_WARN("uCode did not respond OK.\n");
 }
@@ -3800,7 +3780,8 @@ static void il4965_hdl_alive(struct il_priv *il,
  * was received.  We need to ensure we receive the stats in order
  * to update the temperature used for calibrating the TXPOWER.
  */
-static void il4965_bg_stats_periodic(unsigned long data)
+static void
+il4965_bg_stats_periodic(unsigned long data)
 {
 	struct il_priv *il = (struct il_priv *)data;
 
@@ -3814,28 +3795,27 @@ static void il4965_bg_stats_periodic(unsigned long data)
 	il_send_stats_request(il, CMD_ASYNC, false);
 }
 
-static void il4965_hdl_beacon(struct il_priv *il,
-				struct il_rx_buf *rxb)
+static void
+il4965_hdl_beacon(struct il_priv *il, struct il_rx_buf *rxb)
 {
 	struct il_rx_pkt *pkt = rxb_addr(rxb);
 	struct il4965_beacon_notif *beacon =
-		(struct il4965_beacon_notif *)pkt->u.raw;
+	    (struct il4965_beacon_notif *)pkt->u.raw;
 #ifdef CONFIG_IWLEGACY_DEBUG
 	u8 rate = il4965_hw_get_rate(beacon->beacon_notify_hdr.rate_n_flags);
 
-	D_RX("beacon status %x retries %d iss %d "
-		"tsf %d %d rate %d\n",
-		le32_to_cpu(beacon->beacon_notify_hdr.u.status) & TX_STATUS_MSK,
-		beacon->beacon_notify_hdr.failure_frame,
-		le32_to_cpu(beacon->ibss_mgr_status),
-		le32_to_cpu(beacon->high_tsf),
-		le32_to_cpu(beacon->low_tsf), rate);
+	D_RX("beacon status %x retries %d iss %d " "tsf %d %d rate %d\n",
+	     le32_to_cpu(beacon->beacon_notify_hdr.u.status) & TX_STATUS_MSK,
+	     beacon->beacon_notify_hdr.failure_frame,
+	     le32_to_cpu(beacon->ibss_mgr_status),
+	     le32_to_cpu(beacon->high_tsf), le32_to_cpu(beacon->low_tsf), rate);
 #endif
 
 	il->ibss_manager = le32_to_cpu(beacon->ibss_mgr_status);
 }
 
-static void il4965_perform_ct_kill_task(struct il_priv *il)
+static void
+il4965_perform_ct_kill_task(struct il_priv *il)
 {
 	unsigned long flags;
 
@@ -3845,7 +3825,7 @@ static void il4965_perform_ct_kill_task(struct il_priv *il)
 		ieee80211_stop_queues(il->hw);
 
 	_il_wr(il, CSR_UCODE_DRV_GP1_SET,
-			CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
+	       CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
 	_il_rd(il, CSR_UCODE_DRV_GP1);
 
 	spin_lock_irqsave(&il->reg_lock, flags);
@@ -3856,33 +3836,30 @@ static void il4965_perform_ct_kill_task(struct il_priv *il)
 
 /* Handle notification from uCode that card's power state is changing
  * due to software, hardware, or critical temperature RFKILL */
-static void il4965_hdl_card_state(struct il_priv *il,
-				    struct il_rx_buf *rxb)
+static void
+il4965_hdl_card_state(struct il_priv *il, struct il_rx_buf *rxb)
 {
 	struct il_rx_pkt *pkt = rxb_addr(rxb);
 	u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
 	unsigned long status = il->status;
 
 	D_RF_KILL("Card state received: HW:%s SW:%s CT:%s\n",
-			  (flags & HW_CARD_DISABLED) ? "Kill" : "On",
-			  (flags & SW_CARD_DISABLED) ? "Kill" : "On",
-			  (flags & CT_CARD_DISABLED) ?
-			  "Reached" : "Not reached");
+		  (flags & HW_CARD_DISABLED) ? "Kill" : "On",
+		  (flags & SW_CARD_DISABLED) ? "Kill" : "On",
+		  (flags & CT_CARD_DISABLED) ? "Reached" : "Not reached");
 
-	if (flags & (SW_CARD_DISABLED | HW_CARD_DISABLED |
-		     CT_CARD_DISABLED)) {
+	if (flags & (SW_CARD_DISABLED | HW_CARD_DISABLED | CT_CARD_DISABLED)) {
 
 		_il_wr(il, CSR_UCODE_DRV_GP1_SET,
-			    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
+		       CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
 
-		il_wr(il, HBUS_TARG_MBX_C,
-					HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
+		il_wr(il, HBUS_TARG_MBX_C, HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
 
 		if (!(flags & RXON_CARD_DISABLED)) {
 			_il_wr(il, CSR_UCODE_DRV_GP1_CLR,
-				    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
+			       CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
 			il_wr(il, HBUS_TARG_MBX_C,
-					HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
+			      HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
 		}
 	}
 
@@ -3900,7 +3877,7 @@ static void il4965_hdl_card_state(struct il_priv *il,
 	if ((test_bit(S_RF_KILL_HW, &status) !=
 	     test_bit(S_RF_KILL_HW, &il->status)))
 		wiphy_rfkill_set_hw_state(il->hw->wiphy,
-			test_bit(S_RF_KILL_HW, &il->status));
+					  test_bit(S_RF_KILL_HW, &il->status));
 	else
 		wake_up(&il->wait_command_queue);
 }
@@ -3914,16 +3891,15 @@ static void il4965_hdl_card_state(struct il_priv *il,
  * This function chains into the hardware specific files for them to setup
  * any hardware specific handlers as well.
  */
-static void il4965_setup_handlers(struct il_priv *il)
+static void
+il4965_setup_handlers(struct il_priv *il)
 {
 	il->handlers[N_ALIVE] = il4965_hdl_alive;
 	il->handlers[N_ERROR] = il_hdl_error;
 	il->handlers[N_CHANNEL_SWITCH] = il_hdl_csa;
-	il->handlers[N_SPECTRUM_MEASUREMENT] =
-			il_hdl_spectrum_measurement;
+	il->handlers[N_SPECTRUM_MEASUREMENT] = il_hdl_spectrum_measurement;
 	il->handlers[N_PM_SLEEP] = il_hdl_pm_sleep;
-	il->handlers[N_PM_DEBUG_STATS] =
-	    il_hdl_pm_debug_stats;
+	il->handlers[N_PM_DEBUG_STATS] = il_hdl_pm_debug_stats;
 	il->handlers[N_BEACON] = il4965_hdl_beacon;
 
 	/*
@@ -3937,11 +3913,9 @@ static void il4965_setup_handlers(struct il_priv *il)
 	il_setup_rx_scan_handlers(il);
 
 	/* status change handler */
-	il->handlers[N_CARD_STATE] =
-					il4965_hdl_card_state;
+	il->handlers[N_CARD_STATE] = il4965_hdl_card_state;
 
-	il->handlers[N_MISSED_BEACONS] =
-	    il4965_hdl_missed_beacon;
+	il->handlers[N_MISSED_BEACONS] = il4965_hdl_missed_beacon;
 	/* Rx handlers */
 	il->handlers[N_RX_PHY] = il4965_hdl_rx_phy;
 	il->handlers[N_RX_MPDU] = il4965_hdl_rx;
@@ -3958,7 +3932,8 @@ static void il4965_setup_handlers(struct il_priv *il)
  * the appropriate handlers, including command responses,
  * frame-received notifications, and other notifications.
  */
-void il4965_rx_handle(struct il_priv *il)
+void
+il4965_rx_handle(struct il_priv *il)
 {
 	struct il_rx_buf *rxb;
 	struct il_rx_pkt *pkt;
@@ -3972,7 +3947,7 @@ void il4965_rx_handle(struct il_priv *il)
 
 	/* uCode's read idx (stored in shared DRAM) indicates the last Rx
 	 * buffer that the driver may process (last buffer filled by ucode). */
-	r = le16_to_cpu(rxq->rb_stts->closed_rb_num) &  0x0FFF;
+	r = le16_to_cpu(rxq->rb_stts->closed_rb_num) & 0x0FFF;
 	i = rxq->read;
 
 	/* Rx interrupt, but nothing sent from uCode */
@@ -4005,7 +3980,7 @@ void il4965_rx_handle(struct il_priv *il)
 		pkt = rxb_addr(rxb);
 
 		len = le32_to_cpu(pkt->len_n_flags) & IL_RX_FRAME_SIZE_MSK;
-		len += sizeof(u32); /* account for status word */
+		len += sizeof(u32);	/* account for status word */
 
 		/* Reclaim a command buffer only if this packet is a response
 		 *   to a (driver-originated) command.
@@ -4014,28 +3989,23 @@ void il4965_rx_handle(struct il_priv *il)
 		 * Ucode should set SEQ_RX_FRAME bit if ucode-originated,
 		 *   but apparently a few don't get set; catch them here. */
 		reclaim = !(pkt->hdr.sequence & SEQ_RX_FRAME) &&
-			(pkt->hdr.cmd != N_RX_PHY) &&
-			(pkt->hdr.cmd != N_RX) &&
-			(pkt->hdr.cmd != N_RX_MPDU) &&
-			(pkt->hdr.cmd != N_COMPRESSED_BA) &&
-			(pkt->hdr.cmd != N_STATS) &&
-			(pkt->hdr.cmd != C_TX);
+		    (pkt->hdr.cmd != N_RX_PHY) && (pkt->hdr.cmd != N_RX) &&
+		    (pkt->hdr.cmd != N_RX_MPDU) &&
+		    (pkt->hdr.cmd != N_COMPRESSED_BA) &&
+		    (pkt->hdr.cmd != N_STATS) && (pkt->hdr.cmd != C_TX);
 
 		/* Based on type of command response or notification,
 		 *   handle those that need handling via function in
 		 *   handlers table.  See il4965_setup_handlers() */
 		if (il->handlers[pkt->hdr.cmd]) {
-			D_RX("r = %d, i = %d, %s, 0x%02x\n", r,
-				i, il_get_cmd_string(pkt->hdr.cmd),
-				pkt->hdr.cmd);
+			D_RX("r = %d, i = %d, %s, 0x%02x\n", r, i,
+			     il_get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
 			il->isr_stats.handlers[pkt->hdr.cmd]++;
 			il->handlers[pkt->hdr.cmd] (il, rxb);
 		} else {
 			/* No handling needed */
-			D_RX(
-				"r %d i %d No handler needed for %s, 0x%02x\n",
-				r, i, il_get_cmd_string(pkt->hdr.cmd),
-				pkt->hdr.cmd);
+			D_RX("r %d i %d No handler needed for %s, 0x%02x\n", r,
+			     i, il_get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
 		}
 
 		/*
@@ -4060,9 +4030,10 @@ void il4965_rx_handle(struct il_priv *il)
 		 * rx_free list for reuse later. */
 		spin_lock_irqsave(&rxq->lock, flags);
 		if (rxb->page != NULL) {
-			rxb->page_dma = pci_map_page(il->pci_dev, rxb->page,
-				0, PAGE_SIZE << il->hw_params.rx_page_order,
-				PCI_DMA_FROMDEVICE);
+			rxb->page_dma =
+			    pci_map_page(il->pci_dev, rxb->page, 0,
+					 PAGE_SIZE << il->hw_params.
+					 rx_page_order, PCI_DMA_FROMDEVICE);
 			list_add_tail(&rxb->list, &rxq->rx_free);
 			rxq->free_count++;
 		} else
@@ -4092,14 +4063,16 @@ void il4965_rx_handle(struct il_priv *il)
 }
 
 /* call this function to flush any scheduled tasklet */
-static inline void il4965_synchronize_irq(struct il_priv *il)
+static inline void
+il4965_synchronize_irq(struct il_priv *il)
 {
-	/* wait to make sure we flush pending tasklet*/
+	/* wait to make sure we flush pending tasklet */
 	synchronize_irq(il->pci_dev->irq);
 	tasklet_kill(&il->irq_tasklet);
 }
 
-static void il4965_irq_tasklet(struct il_priv *il)
+static void
+il4965_irq_tasklet(struct il_priv *il)
 {
 	u32 inta, handled = 0;
 	u32 inta_fh;
@@ -4127,8 +4100,8 @@ static void il4965_irq_tasklet(struct il_priv *il)
 	if (il_get_debug_level(il) & IL_DL_ISR) {
 		/* just for debug */
 		inta_mask = _il_rd(il, CSR_INT_MASK);
-		D_ISR("inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
-			      inta, inta_mask, inta_fh);
+		D_ISR("inta 0x%08x, enabled 0x%08x, fh 0x%08x\n", inta,
+		      inta_mask, inta_fh);
 	}
 #endif
 
@@ -4157,13 +4130,12 @@ static void il4965_irq_tasklet(struct il_priv *il)
 
 		return;
 	}
-
 #ifdef CONFIG_IWLEGACY_DEBUG
 	if (il_get_debug_level(il) & (IL_DL_ISR)) {
 		/* NIC fires this, but we don't use it, redundant with WAKEUP */
 		if (inta & CSR_INT_BIT_SCD) {
 			D_ISR("Scheduler finished to transmit "
-				      "the frame/frames.\n");
+			      "the frame/frames.\n");
 			il->isr_stats.sch++;
 		}
 
@@ -4180,12 +4152,13 @@ static void il4965_irq_tasklet(struct il_priv *il)
 	/* HW RF KILL switch toggled */
 	if (inta & CSR_INT_BIT_RF_KILL) {
 		int hw_rf_kill = 0;
-		if (!(_il_rd(il, CSR_GP_CNTRL) &
-				CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW))
+		if (!
+		    (_il_rd(il, CSR_GP_CNTRL) &
+		     CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW))
 			hw_rf_kill = 1;
 
 		IL_WARN("RF_KILL bit toggled to %s.\n",
-				hw_rf_kill ? "disable radio" : "enable radio");
+			hw_rf_kill ? "disable radio" : "enable radio");
 
 		il->isr_stats.rfkill++;
 
@@ -4214,8 +4187,8 @@ static void il4965_irq_tasklet(struct il_priv *il)
 
 	/* Error detected by uCode */
 	if (inta & CSR_INT_BIT_SW_ERR) {
-		IL_ERR("Microcode SW error detected. "
-			" Restarting 0x%X.\n", inta);
+		IL_ERR("Microcode SW error detected. " " Restarting 0x%X.\n",
+		       inta);
 		il->isr_stats.sw++;
 		il_irq_handle_error(il);
 		handled |= CSR_INT_BIT_SW_ERR;
@@ -4261,7 +4234,7 @@ static void il4965_irq_tasklet(struct il_priv *il)
 
 	if (inta & ~(il->inta_mask)) {
 		IL_WARN("Disabled INTA bits 0x%08x were pending\n",
-			 inta & ~il->inta_mask);
+			inta & ~il->inta_mask);
 		IL_WARN("   with FH49_INT = 0x%08x\n", inta_fh);
 	}
 
@@ -4278,9 +4251,8 @@ static void il4965_irq_tasklet(struct il_priv *il)
 		inta = _il_rd(il, CSR_INT);
 		inta_mask = _il_rd(il, CSR_INT_MASK);
 		inta_fh = _il_rd(il, CSR_FH_INT_STATUS);
-		D_ISR(
-			"End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
-			"flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
+		D_ISR("End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
+		      "flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
 	}
 #endif
 }
@@ -4304,15 +4276,17 @@ static void il4965_irq_tasklet(struct il_priv *il)
  * level that is used instead of the global debug level if it (the per
  * device debug level) is set.
  */
-static ssize_t il4965_show_debug_level(struct device *d,
-				struct device_attribute *attr, char *buf)
+static ssize_t
+il4965_show_debug_level(struct device *d, struct device_attribute *attr,
+			char *buf)
 {
 	struct il_priv *il = dev_get_drvdata(d);
 	return sprintf(buf, "0x%08X\n", il_get_debug_level(il));
 }
-static ssize_t il4965_store_debug_level(struct device *d,
-				struct device_attribute *attr,
-				 const char *buf, size_t count)
+
+static ssize_t
+il4965_store_debug_level(struct device *d, struct device_attribute *attr,
+			 const char *buf, size_t count)
 {
 	struct il_priv *il = dev_get_drvdata(d);
 	unsigned long val;
@@ -4324,21 +4298,19 @@ static ssize_t il4965_store_debug_level(struct device *d,
 	else {
 		il->debug_level = val;
 		if (il_alloc_traffic_mem(il))
-			IL_ERR(
-				"Not enough memory to generate traffic log\n");
+			IL_ERR("Not enough memory to generate traffic log\n");
 	}
 	return strnlen(buf, count);
 }
 
-static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
-			il4965_show_debug_level, il4965_store_debug_level);
-
+static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO, il4965_show_debug_level,
+		   il4965_store_debug_level);
 
 #endif /* CONFIG_IWLEGACY_DEBUG */
 
-
-static ssize_t il4965_show_temperature(struct device *d,
-				struct device_attribute *attr, char *buf)
+static ssize_t
+il4965_show_temperature(struct device *d, struct device_attribute *attr,
+			char *buf)
 {
 	struct il_priv *il = dev_get_drvdata(d);
 
@@ -4350,8 +4322,8 @@ static ssize_t il4965_show_temperature(struct device *d,
 
 static DEVICE_ATTR(temperature, S_IRUGO, il4965_show_temperature, NULL);
 
-static ssize_t il4965_show_tx_power(struct device *d,
-			     struct device_attribute *attr, char *buf)
+static ssize_t
+il4965_show_tx_power(struct device *d, struct device_attribute *attr, char *buf)
 {
 	struct il_priv *il = dev_get_drvdata(d);
 
@@ -4361,9 +4333,9 @@ static ssize_t il4965_show_tx_power(struct device *d,
 		return sprintf(buf, "%d\n", il->tx_power_user_lmt);
 }
 
-static ssize_t il4965_store_tx_power(struct device *d,
-			      struct device_attribute *attr,
-			      const char *buf, size_t count)
+static ssize_t
+il4965_store_tx_power(struct device *d, struct device_attribute *attr,
+		      const char *buf, size_t count)
 {
 	struct il_priv *il = dev_get_drvdata(d);
 	unsigned long val;
@@ -4375,16 +4347,15 @@ static ssize_t il4965_store_tx_power(struct device *d,
 	else {
 		ret = il_set_tx_power(il, val, false);
 		if (ret)
-			IL_ERR("failed setting tx power (0x%d).\n",
-				ret);
+			IL_ERR("failed setting tx power (0x%d).\n", ret);
 		else
 			ret = count;
 	}
 	return ret;
 }
 
-static DEVICE_ATTR(tx_power, S_IWUSR | S_IRUGO,
-			il4965_show_tx_power, il4965_store_tx_power);
+static DEVICE_ATTR(tx_power, S_IWUSR | S_IRUGO, il4965_show_tx_power,
+		   il4965_store_tx_power);
 
 static struct attribute *il_sysfs_entries[] = {
 	&dev_attr_temperature.attr,
@@ -4406,7 +4377,8 @@ static struct attribute_group il_attribute_group = {
  *
  ******************************************************************************/
 
-static void il4965_dealloc_ucode_pci(struct il_priv *il)
+static void
+il4965_dealloc_ucode_pci(struct il_priv *il)
 {
 	il_free_fw_desc(il->pci_dev, &il->ucode_code);
 	il_free_fw_desc(il->pci_dev, &il->ucode_data);
@@ -4416,18 +4388,19 @@ static void il4965_dealloc_ucode_pci(struct il_priv *il)
 	il_free_fw_desc(il->pci_dev, &il->ucode_boot);
 }
 
-static void il4965_nic_start(struct il_priv *il)
+static void
+il4965_nic_start(struct il_priv *il)
 {
 	/* Remove all resets to allow NIC to operate */
 	_il_wr(il, CSR_RESET, 0);
 }
 
 static void il4965_ucode_callback(const struct firmware *ucode_raw,
-					void *context);
-static int il4965_mac_setup_register(struct il_priv *il,
-						u32 max_probe_length);
+				  void *context);
+static int il4965_mac_setup_register(struct il_priv *il, u32 max_probe_length);
 
-static int __must_check il4965_request_firmware(struct il_priv *il, bool first)
+static int __must_check
+il4965_request_firmware(struct il_priv *il, bool first)
 {
 	const char *name_pre = il->cfg->fw_name_pre;
 	char tag[8];
@@ -4447,8 +4420,7 @@ static int __must_check il4965_request_firmware(struct il_priv *il, bool first)
 
 	sprintf(il->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
 
-	D_INFO("attempting to load firmware '%s'\n",
-		       il->firmware_name);
+	D_INFO("attempting to load firmware '%s'\n", il->firmware_name);
 
 	return request_firmware_nowait(THIS_MODULE, 1, il->firmware_name,
 				       &il->pci_dev->dev, GFP_KERNEL, il,
@@ -4460,9 +4432,9 @@ struct il4965_firmware_pieces {
 	size_t inst_size, data_size, init_size, init_data_size, boot_size;
 };
 
-static int il4965_load_firmware(struct il_priv *il,
-				       const struct firmware *ucode_raw,
-				       struct il4965_firmware_pieces *pieces)
+static int
+il4965_load_firmware(struct il_priv *il, const struct firmware *ucode_raw,
+		     struct il4965_firmware_pieces *pieces)
 {
 	struct il_ucode_header *ucode = (void *)ucode_raw->data;
 	u32 api_ver, hdr_size;
@@ -4484,21 +4456,19 @@ static int il4965_load_firmware(struct il_priv *il,
 		pieces->inst_size = le32_to_cpu(ucode->v1.inst_size);
 		pieces->data_size = le32_to_cpu(ucode->v1.data_size);
 		pieces->init_size = le32_to_cpu(ucode->v1.init_size);
-		pieces->init_data_size =
-				le32_to_cpu(ucode->v1.init_data_size);
+		pieces->init_data_size = le32_to_cpu(ucode->v1.init_data_size);
 		pieces->boot_size = le32_to_cpu(ucode->v1.boot_size);
 		src = ucode->v1.data;
 		break;
 	}
 
 	/* Verify size of file vs. image size info in file's header */
-	if (ucode_raw->size != hdr_size + pieces->inst_size +
-				pieces->data_size + pieces->init_size +
-				pieces->init_data_size + pieces->boot_size) {
+	if (ucode_raw->size !=
+	    hdr_size + pieces->inst_size + pieces->data_size +
+	    pieces->init_size + pieces->init_data_size + pieces->boot_size) {
 
-		IL_ERR(
-			"uCode file size %d does not match expected size\n",
-			(int)ucode_raw->size);
+		IL_ERR("uCode file size %d does not match expected size\n",
+		       (int)ucode_raw->size);
 		return -EINVAL;
 	}
 
@@ -4535,20 +4505,19 @@ il4965_ucode_callback(const struct firmware *ucode_raw, void *context)
 
 	u32 max_probe_length = 200;
 	u32 standard_phy_calibration_size =
-			IL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE;
+	    IL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE;
 
 	memset(&pieces, 0, sizeof(pieces));
 
 	if (!ucode_raw) {
 		if (il->fw_idx <= il->cfg->ucode_api_max)
-			IL_ERR(
-				"request for firmware file '%s' failed.\n",
-				il->firmware_name);
+			IL_ERR("request for firmware file '%s' failed.\n",
+			       il->firmware_name);
 		goto try_again;
 	}
 
-	D_INFO("Loaded firmware file '%s' (%zd bytes).\n",
-		       il->firmware_name, ucode_raw->size);
+	D_INFO("Loaded firmware file '%s' (%zd bytes).\n", il->firmware_name,
+	       ucode_raw->size);
 
 	/* Make sure that we got at least the API version number */
 	if (ucode_raw->size < 4) {
@@ -4572,32 +4541,25 @@ il4965_ucode_callback(const struct firmware *ucode_raw, void *context)
 	 * on the API version read from firmware header from here on forward
 	 */
 	if (api_ver < api_min || api_ver > api_max) {
-		IL_ERR(
-			"Driver unable to support your firmware API. "
-			"Driver supports v%u, firmware is v%u.\n",
-			api_max, api_ver);
+		IL_ERR("Driver unable to support your firmware API. "
+		       "Driver supports v%u, firmware is v%u.\n", api_max,
+		       api_ver);
 		goto try_again;
 	}
 
 	if (api_ver != api_max)
-		IL_ERR(
-			"Firmware has old API version. Expected v%u, "
-			"got v%u. New firmware can be obtained "
-			"from http://www.intellinuxwireless.org.\n",
-			api_max, api_ver);
+		IL_ERR("Firmware has old API version. Expected v%u, "
+		       "got v%u. New firmware can be obtained "
+		       "from http://www.intellinuxwireless.org.\n", api_max,
+		       api_ver);
 
 	IL_INFO("loaded firmware version %u.%u.%u.%u\n",
-		 IL_UCODE_MAJOR(il->ucode_ver),
-		 IL_UCODE_MINOR(il->ucode_ver),
-		 IL_UCODE_API(il->ucode_ver),
-		 IL_UCODE_SERIAL(il->ucode_ver));
+		IL_UCODE_MAJOR(il->ucode_ver), IL_UCODE_MINOR(il->ucode_ver),
+		IL_UCODE_API(il->ucode_ver), IL_UCODE_SERIAL(il->ucode_ver));
 
-	snprintf(il->hw->wiphy->fw_version,
-		 sizeof(il->hw->wiphy->fw_version),
-		 "%u.%u.%u.%u",
-		 IL_UCODE_MAJOR(il->ucode_ver),
-		 IL_UCODE_MINOR(il->ucode_ver),
-		 IL_UCODE_API(il->ucode_ver),
+	snprintf(il->hw->wiphy->fw_version, sizeof(il->hw->wiphy->fw_version),
+		 "%u.%u.%u.%u", IL_UCODE_MAJOR(il->ucode_ver),
+		 IL_UCODE_MINOR(il->ucode_ver), IL_UCODE_API(il->ucode_ver),
 		 IL_UCODE_SERIAL(il->ucode_ver));
 
 	/*
@@ -4606,47 +4568,41 @@ il4965_ucode_callback(const struct firmware *ucode_raw, void *context)
 	 * user just got a corrupted version of the latest API.
 	 */
 
-	D_INFO("f/w package hdr ucode version raw = 0x%x\n",
-		       il->ucode_ver);
-	D_INFO("f/w package hdr runtime inst size = %Zd\n",
-		       pieces.inst_size);
-	D_INFO("f/w package hdr runtime data size = %Zd\n",
-		       pieces.data_size);
-	D_INFO("f/w package hdr init inst size = %Zd\n",
-		       pieces.init_size);
-	D_INFO("f/w package hdr init data size = %Zd\n",
-		       pieces.init_data_size);
-	D_INFO("f/w package hdr boot inst size = %Zd\n",
-		       pieces.boot_size);
+	D_INFO("f/w package hdr ucode version raw = 0x%x\n", il->ucode_ver);
+	D_INFO("f/w package hdr runtime inst size = %Zd\n", pieces.inst_size);
+	D_INFO("f/w package hdr runtime data size = %Zd\n", pieces.data_size);
+	D_INFO("f/w package hdr init inst size = %Zd\n", pieces.init_size);
+	D_INFO("f/w package hdr init data size = %Zd\n", pieces.init_data_size);
+	D_INFO("f/w package hdr boot inst size = %Zd\n", pieces.boot_size);
 
 	/* Verify that uCode images will fit in card's SRAM */
 	if (pieces.inst_size > il->hw_params.max_inst_size) {
 		IL_ERR("uCode instr len %Zd too large to fit in\n",
-			pieces.inst_size);
+		       pieces.inst_size);
 		goto try_again;
 	}
 
 	if (pieces.data_size > il->hw_params.max_data_size) {
 		IL_ERR("uCode data len %Zd too large to fit in\n",
-			pieces.data_size);
+		       pieces.data_size);
 		goto try_again;
 	}
 
 	if (pieces.init_size > il->hw_params.max_inst_size) {
 		IL_ERR("uCode init instr len %Zd too large to fit in\n",
-			pieces.init_size);
+		       pieces.init_size);
 		goto try_again;
 	}
 
 	if (pieces.init_data_size > il->hw_params.max_data_size) {
 		IL_ERR("uCode init data len %Zd too large to fit in\n",
-			pieces.init_data_size);
+		       pieces.init_data_size);
 		goto try_again;
 	}
 
 	if (pieces.boot_size > il->hw_params.max_bsm_size) {
 		IL_ERR("uCode boot instr len %Zd too large to fit in\n",
-			pieces.boot_size);
+		       pieces.boot_size);
 		goto try_again;
 	}
 
@@ -4697,41 +4653,39 @@ il4965_ucode_callback(const struct firmware *ucode_raw, void *context)
 
 	/* Runtime instructions (first block of data in file) */
 	D_INFO("Copying (but not loading) uCode instr len %Zd\n",
-			pieces.inst_size);
+	       pieces.inst_size);
 	memcpy(il->ucode_code.v_addr, pieces.inst, pieces.inst_size);
 
 	D_INFO("uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
-		il->ucode_code.v_addr, (u32)il->ucode_code.p_addr);
+	       il->ucode_code.v_addr, (u32) il->ucode_code.p_addr);
 
 	/*
 	 * Runtime data
 	 * NOTE:  Copy into backup buffer will be done in il_up()
 	 */
 	D_INFO("Copying (but not loading) uCode data len %Zd\n",
-			pieces.data_size);
+	       pieces.data_size);
 	memcpy(il->ucode_data.v_addr, pieces.data, pieces.data_size);
 	memcpy(il->ucode_data_backup.v_addr, pieces.data, pieces.data_size);
 
 	/* Initialization instructions */
 	if (pieces.init_size) {
-		D_INFO(
-				"Copying (but not loading) init instr len %Zd\n",
-				pieces.init_size);
+		D_INFO("Copying (but not loading) init instr len %Zd\n",
+		       pieces.init_size);
 		memcpy(il->ucode_init.v_addr, pieces.init, pieces.init_size);
 	}
 
 	/* Initialization data */
 	if (pieces.init_data_size) {
-		D_INFO(
-				"Copying (but not loading) init data len %Zd\n",
-			       pieces.init_data_size);
+		D_INFO("Copying (but not loading) init data len %Zd\n",
+		       pieces.init_data_size);
 		memcpy(il->ucode_init_data.v_addr, pieces.init_data,
 		       pieces.init_data_size);
 	}
 
 	/* Bootstrap instructions */
 	D_INFO("Copying (but not loading) boot instr len %Zd\n",
-			pieces.boot_size);
+	       pieces.boot_size);
 	memcpy(il->ucode_boot.v_addr, pieces.boot, pieces.boot_size);
 
 	/*
@@ -4739,9 +4693,9 @@ il4965_ucode_callback(const struct firmware *ucode_raw, void *context)
 	 * base on the size of standard phy calibration commands table size
 	 */
 	il->_4965.phy_calib_chain_noise_reset_cmd =
-		standard_phy_calibration_size;
+	    standard_phy_calibration_size;
 	il->_4965.phy_calib_chain_noise_gain_cmd =
-		standard_phy_calibration_size + 1;
+	    standard_phy_calibration_size + 1;
 
 	/**************************************************
 	 * This is still part of probe() in a sense...
@@ -4754,11 +4708,10 @@ il4965_ucode_callback(const struct firmware *ucode_raw, void *context)
 
 	err = il_dbgfs_register(il, DRV_NAME);
 	if (err)
-		IL_ERR(
-		"failed to create debugfs files. Ignoring error: %d\n", err);
+		IL_ERR("failed to create debugfs files. Ignoring error: %d\n",
+		       err);
 
-	err = sysfs_create_group(&il->pci_dev->dev.kobj,
-					&il_attribute_group);
+	err = sysfs_create_group(&il->pci_dev->dev.kobj, &il_attribute_group);
 	if (err) {
 		IL_ERR("failed to create sysfs device attributes\n");
 		goto out_unbind;
@@ -4769,23 +4722,23 @@ il4965_ucode_callback(const struct firmware *ucode_raw, void *context)
 	complete(&il->_4965.firmware_loading_complete);
 	return;
 
- try_again:
+try_again:
 	/* try next, if any */
 	if (il4965_request_firmware(il, false))
 		goto out_unbind;
 	release_firmware(ucode_raw);
 	return;
 
- err_pci_alloc:
+err_pci_alloc:
 	IL_ERR("failed to allocate pci memory\n");
 	il4965_dealloc_ucode_pci(il);
- out_unbind:
+out_unbind:
 	complete(&il->_4965.firmware_loading_complete);
 	device_release_driver(&il->pci_dev->dev);
 	release_firmware(ucode_raw);
 }
 
-static const char * const desc_lookup_text[] = {
+static const char *const desc_lookup_text[] = {
 	"OK",
 	"FAIL",
 	"BAD_PARAM",
@@ -4816,26 +4769,30 @@ static const char * const desc_lookup_text[] = {
 	"DEBUG_3",
 };
 
-static struct { char *name; u8 num; } advanced_lookup[] = {
-	{ "NMI_INTERRUPT_WDG", 0x34 },
-	{ "SYSASSERT", 0x35 },
-	{ "UCODE_VERSION_MISMATCH", 0x37 },
-	{ "BAD_COMMAND", 0x38 },
-	{ "NMI_INTERRUPT_DATA_ACTION_PT", 0x3C },
-	{ "FATAL_ERROR", 0x3D },
-	{ "NMI_TRM_HW_ERR", 0x46 },
-	{ "NMI_INTERRUPT_TRM", 0x4C },
-	{ "NMI_INTERRUPT_BREAK_POINT", 0x54 },
-	{ "NMI_INTERRUPT_WDG_RXF_FULL", 0x5C },
-	{ "NMI_INTERRUPT_WDG_NO_RBD_RXF_FULL", 0x64 },
-	{ "NMI_INTERRUPT_HOST", 0x66 },
-	{ "NMI_INTERRUPT_ACTION_PT", 0x7C },
-	{ "NMI_INTERRUPT_UNKNOWN", 0x84 },
-	{ "NMI_INTERRUPT_INST_ACTION_PT", 0x86 },
-	{ "ADVANCED_SYSASSERT", 0 },
-};
-
-static const char *il4965_desc_lookup(u32 num)
+static struct {
+	char *name;
+	u8 num;
+} advanced_lookup[] = {
+	{
+	"NMI_INTERRUPT_WDG", 0x34}, {
+	"SYSASSERT", 0x35}, {
+	"UCODE_VERSION_MISMATCH", 0x37}, {
+	"BAD_COMMAND", 0x38}, {
+	"NMI_INTERRUPT_DATA_ACTION_PT", 0x3C}, {
+	"FATAL_ERROR", 0x3D}, {
+	"NMI_TRM_HW_ERR", 0x46}, {
+	"NMI_INTERRUPT_TRM", 0x4C}, {
+	"NMI_INTERRUPT_BREAK_POINT", 0x54}, {
+	"NMI_INTERRUPT_WDG_RXF_FULL", 0x5C}, {
+	"NMI_INTERRUPT_WDG_NO_RBD_RXF_FULL", 0x64}, {
+	"NMI_INTERRUPT_HOST", 0x66}, {
+	"NMI_INTERRUPT_ACTION_PT", 0x7C}, {
+	"NMI_INTERRUPT_UNKNOWN", 0x84}, {
+	"NMI_INTERRUPT_INST_ACTION_PT", 0x86}, {
+"ADVANCED_SYSASSERT", 0},};
+
+static const char *
+il4965_desc_lookup(u32 num)
 {
 	int i;
 	int max = ARRAY_SIZE(desc_lookup_text);
@@ -4854,7 +4811,8 @@ static const char *il4965_desc_lookup(u32 num)
 #define ERROR_START_OFFSET  (1 * sizeof(u32))
 #define ERROR_ELEM_SIZE     (7 * sizeof(u32))
 
-void il4965_dump_nic_error_log(struct il_priv *il)
+void
+il4965_dump_nic_error_log(struct il_priv *il)
 {
 	u32 data2, line;
 	u32 desc, time, count, base, data1;
@@ -4868,9 +4826,8 @@ void il4965_dump_nic_error_log(struct il_priv *il)
 	}
 
 	if (!il->cfg->ops->lib->is_valid_rtc_data_addr(base)) {
-		IL_ERR(
-			"Not valid error log pointer 0x%08X for %s uCode\n",
-			base, (il->ucode_type == UCODE_INIT) ? "Init" : "RT");
+		IL_ERR("Not valid error log pointer 0x%08X for %s uCode\n",
+		       base, (il->ucode_type == UCODE_INIT) ? "Init" : "RT");
 		return;
 	}
 
@@ -4878,8 +4835,7 @@ void il4965_dump_nic_error_log(struct il_priv *il)
 
 	if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) {
 		IL_ERR("Start IWL Error Log Dump:\n");
-		IL_ERR("Status: 0x%08lX, count: %d\n",
-			il->status, count);
+		IL_ERR("Status: 0x%08lX, count: %d\n", il->status, count);
 	}
 
 	desc = il_read_targ_mem(il, base + 1 * sizeof(u32));
@@ -4896,15 +4852,16 @@ void il4965_dump_nic_error_log(struct il_priv *il)
 	hcmd = il_read_targ_mem(il, base + 22 * sizeof(u32));
 
 	IL_ERR("Desc                                  Time       "
-		"data1      data2      line\n");
+	       "data1      data2      line\n");
 	IL_ERR("%-28s (0x%04X) %010u 0x%08X 0x%08X %u\n",
-		il4965_desc_lookup(desc), desc, time, data1, data2, line);
+	       il4965_desc_lookup(desc), desc, time, data1, data2, line);
 	IL_ERR("pc      blink1  blink2  ilink1  ilink2  hcmd\n");
-	IL_ERR("0x%05X 0x%05X 0x%05X 0x%05X 0x%05X 0x%05X\n",
-		pc, blink1, blink2, ilink1, ilink2, hcmd);
+	IL_ERR("0x%05X 0x%05X 0x%05X 0x%05X 0x%05X 0x%05X\n", pc, blink1,
+	       blink2, ilink1, ilink2, hcmd);
 }
 
-static void il4965_rf_kill_ct_config(struct il_priv *il)
+static void
+il4965_rf_kill_ct_config(struct il_priv *il)
 {
 	struct il_ct_kill_config cmd;
 	unsigned long flags;
@@ -4912,21 +4869,19 @@ static void il4965_rf_kill_ct_config(struct il_priv *il)
 
 	spin_lock_irqsave(&il->lock, flags);
 	_il_wr(il, CSR_UCODE_DRV_GP1_CLR,
-		    CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
+	       CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
 	spin_unlock_irqrestore(&il->lock, flags);
 
 	cmd.critical_temperature_R =
-		cpu_to_le32(il->hw_params.ct_kill_threshold);
+	    cpu_to_le32(il->hw_params.ct_kill_threshold);
 
-	ret = il_send_cmd_pdu(il, C_CT_KILL_CONFIG,
-			       sizeof(cmd), &cmd);
+	ret = il_send_cmd_pdu(il, C_CT_KILL_CONFIG, sizeof(cmd), &cmd);
 	if (ret)
 		IL_ERR("C_CT_KILL_CONFIG failed\n");
 	else
-		D_INFO("C_CT_KILL_CONFIG "
-				"succeeded, "
-				"critical temperature is %d\n",
-				il->hw_params.ct_kill_threshold);
+		D_INFO("C_CT_KILL_CONFIG " "succeeded, "
+		       "critical temperature is %d\n",
+		       il->hw_params.ct_kill_threshold);
 }
 
 static const s8 default_queue_to_tx_fifo[] = {
@@ -4941,7 +4896,8 @@ static const s8 default_queue_to_tx_fifo[] = {
 
 #define IL_MASK(lo, hi) ((1 << (hi)) | ((1 << (hi)) - (1 << (lo))))
 
-static int il4965_alive_notify(struct il_priv *il)
+static int
+il4965_alive_notify(struct il_priv *il)
 {
 	u32 a;
 	unsigned long flags;
@@ -4951,32 +4907,32 @@ static int il4965_alive_notify(struct il_priv *il)
 	spin_lock_irqsave(&il->lock, flags);
 
 	/* Clear 4965's internal Tx Scheduler data base */
-	il->scd_base_addr = il_rd_prph(il,
-					IL49_SCD_SRAM_BASE_ADDR);
+	il->scd_base_addr = il_rd_prph(il, IL49_SCD_SRAM_BASE_ADDR);
 	a = il->scd_base_addr + IL49_SCD_CONTEXT_DATA_OFFSET;
 	for (; a < il->scd_base_addr + IL49_SCD_TX_STTS_BITMAP_OFFSET; a += 4)
 		il_write_targ_mem(il, a, 0);
 	for (; a < il->scd_base_addr + IL49_SCD_TRANSLATE_TBL_OFFSET; a += 4)
 		il_write_targ_mem(il, a, 0);
-	for (; a < il->scd_base_addr +
-	       IL49_SCD_TRANSLATE_TBL_OFFSET_QUEUE(il->hw_params.max_txq_num); a += 4)
+	for (;
+	     a <
+	     il->scd_base_addr +
+	     IL49_SCD_TRANSLATE_TBL_OFFSET_QUEUE(il->hw_params.max_txq_num);
+	     a += 4)
 		il_write_targ_mem(il, a, 0);
 
 	/* Tel 4965 where to find Tx byte count tables */
-	il_wr_prph(il, IL49_SCD_DRAM_BASE_ADDR,
-			il->scd_bc_tbls.dma >> 10);
+	il_wr_prph(il, IL49_SCD_DRAM_BASE_ADDR, il->scd_bc_tbls.dma >> 10);
 
 	/* Enable DMA channel */
-	for (chan = 0; chan < FH49_TCSR_CHNL_NUM ; chan++)
-		il_wr(il,
-				FH49_TCSR_CHNL_TX_CONFIG_REG(chan),
-				FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_ENABLE |
-				FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_ENABLE);
+	for (chan = 0; chan < FH49_TCSR_CHNL_NUM; chan++)
+		il_wr(il, FH49_TCSR_CHNL_TX_CONFIG_REG(chan),
+		      FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_ENABLE |
+		      FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_ENABLE);
 
 	/* Update FH chicken bits */
 	reg_val = il_rd(il, FH49_TX_CHICKEN_BITS_REG);
 	il_wr(il, FH49_TX_CHICKEN_BITS_REG,
-			   reg_val | FH49_TX_CHICKEN_BITS_SCD_AUTO_RETRY_EN);
+	      reg_val | FH49_TX_CHICKEN_BITS_SCD_AUTO_RETRY_EN);
 
 	/* Disable chain mode for all queues */
 	il_wr_prph(il, IL49_SCD_QUEUECHAIN_SEL, 0);
@@ -4989,23 +4945,25 @@ static int il4965_alive_notify(struct il_priv *il)
 		il_wr(il, HBUS_TARG_WRPTR, 0 | (i << 8));
 
 		/* Max Tx Window size for Scheduler-ACK mode */
-		il_write_targ_mem(il, il->scd_base_addr +
-				IL49_SCD_CONTEXT_QUEUE_OFFSET(i),
-				(SCD_WIN_SIZE <<
-				IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_POS) &
-				IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK);
+		il_write_targ_mem(il,
+				  il->scd_base_addr +
+				  IL49_SCD_CONTEXT_QUEUE_OFFSET(i),
+				  (SCD_WIN_SIZE <<
+				   IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_POS) &
+				  IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK);
 
 		/* Frame limit */
-		il_write_targ_mem(il, il->scd_base_addr +
-				IL49_SCD_CONTEXT_QUEUE_OFFSET(i) +
-				sizeof(u32),
-				(SCD_FRAME_LIMIT <<
-				IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS) &
-				IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK);
+		il_write_targ_mem(il,
+				  il->scd_base_addr +
+				  IL49_SCD_CONTEXT_QUEUE_OFFSET(i) +
+				  sizeof(u32),
+				  (SCD_FRAME_LIMIT <<
+				   IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS) &
+				  IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK);
 
 	}
 	il_wr_prph(il, IL49_SCD_INTERRUPT_MASK,
-				 (1 << il->hw_params.max_txq_num) - 1);
+		   (1 << il->hw_params.max_txq_num) - 1);
 
 	/* Activate all Tx DMA/FIFO channels */
 	il4965_txq_set_sched(il, IL_MASK(0, 6));
@@ -5043,7 +5001,8 @@ static int il4965_alive_notify(struct il_priv *il)
  *                   from protocol/runtime uCode (initialization uCode's
  *                   Alive gets handled by il_init_alive_start()).
  */
-static void il4965_alive_start(struct il_priv *il)
+static void
+il4965_alive_start(struct il_priv *il)
 {
 	int ret = 0;
 	struct il_rxon_context *ctx = &il->ctx;
@@ -5069,12 +5028,10 @@ static void il4965_alive_start(struct il_priv *il)
 
 	ret = il4965_alive_notify(il);
 	if (ret) {
-		IL_WARN(
-			"Could not complete ALIVE transition [ntf]: %d\n", ret);
+		IL_WARN("Could not complete ALIVE transition [ntf]: %d\n", ret);
 		goto restart;
 	}
 
-
 	/* After the ALIVE response, we can send host commands to the uCode */
 	set_bit(S_ALIVE, &il->status);
 
@@ -5090,7 +5047,7 @@ static void il4965_alive_start(struct il_priv *il)
 
 	if (il_is_associated_ctx(ctx)) {
 		struct il_rxon_cmd *active_rxon =
-				(struct il_rxon_cmd *)&ctx->active;
+		    (struct il_rxon_cmd *)&ctx->active;
 		/* apply any changes in staging */
 		ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
 		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
@@ -5123,13 +5080,14 @@ static void il4965_alive_start(struct il_priv *il)
 
 	return;
 
- restart:
+restart:
 	queue_work(il->workqueue, &il->restart);
 }
 
 static void il4965_cancel_deferred_work(struct il_priv *il);
 
-static void __il4965_down(struct il_priv *il)
+static void
+__il4965_down(struct il_priv *il)
 {
 	unsigned long flags;
 	int exit_pending;
@@ -5171,25 +5129,28 @@ static void __il4965_down(struct il_priv *il)
 	/* If we have not previously called il_init() then
 	 * clear all bits but the RF Kill bit and return */
 	if (!il_is_init(il)) {
-		il->status = test_bit(S_RF_KILL_HW, &il->status) <<
-					S_RF_KILL_HW |
-			       test_bit(S_GEO_CONFIGURED, &il->status) <<
-					S_GEO_CONFIGURED |
-			       test_bit(S_EXIT_PENDING, &il->status) <<
-					S_EXIT_PENDING;
+		il->status =
+		    test_bit(S_RF_KILL_HW,
+			     &il->
+			     status) << S_RF_KILL_HW |
+		    test_bit(S_GEO_CONFIGURED,
+			     &il->
+			     status) << S_GEO_CONFIGURED |
+		    test_bit(S_EXIT_PENDING, &il->status) << S_EXIT_PENDING;
 		goto exit;
 	}
 
 	/* ...otherwise clear out all the status bits but the RF Kill
 	 * bit and continue taking the NIC down. */
-	il->status &= test_bit(S_RF_KILL_HW, &il->status) <<
-				S_RF_KILL_HW |
-			test_bit(S_GEO_CONFIGURED, &il->status) <<
-				S_GEO_CONFIGURED |
-			test_bit(S_FW_ERROR, &il->status) <<
-				S_FW_ERROR |
-		       test_bit(S_EXIT_PENDING, &il->status) <<
-				S_EXIT_PENDING;
+	il->status &=
+	    test_bit(S_RF_KILL_HW,
+		     &il->status) << S_RF_KILL_HW | test_bit(S_GEO_CONFIGURED,
+							     &il->
+							     status) <<
+	    S_GEO_CONFIGURED | test_bit(S_FW_ERROR,
+					&il->
+					status) << S_FW_ERROR |
+	    test_bit(S_EXIT_PENDING, &il->status) << S_EXIT_PENDING;
 
 	il4965_txq_ctx_stop(il);
 	il4965_rxq_stop(il);
@@ -5199,13 +5160,12 @@ static void __il4965_down(struct il_priv *il)
 	udelay(5);
 
 	/* Make sure (redundant) we've released our request to stay awake */
-	il_clear_bit(il, CSR_GP_CNTRL,
-				CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
+	il_clear_bit(il, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
 
 	/* Stop the device, and put it in low power state */
 	il_apm_stop(il);
 
- exit:
+exit:
 	memset(&il->card_alive, 0, sizeof(struct il_alive_resp));
 
 	dev_kfree_skb(il->beacon_skb);
@@ -5215,7 +5175,8 @@ static void __il4965_down(struct il_priv *il)
 	il4965_clear_free_frames(il);
 }
 
-static void il4965_down(struct il_priv *il)
+static void
+il4965_down(struct il_priv *il)
 {
 	mutex_lock(&il->mutex);
 	__il4965_down(il);
@@ -5226,29 +5187,30 @@ static void il4965_down(struct il_priv *il)
 
 #define HW_READY_TIMEOUT (50)
 
-static int il4965_set_hw_ready(struct il_priv *il)
+static int
+il4965_set_hw_ready(struct il_priv *il)
 {
 	int ret = 0;
 
 	il_set_bit(il, CSR_HW_IF_CONFIG_REG,
-		CSR_HW_IF_CONFIG_REG_BIT_NIC_READY);
+		   CSR_HW_IF_CONFIG_REG_BIT_NIC_READY);
 
 	/* See if we got it */
-	ret = _il_poll_bit(il, CSR_HW_IF_CONFIG_REG,
-				CSR_HW_IF_CONFIG_REG_BIT_NIC_READY,
-				CSR_HW_IF_CONFIG_REG_BIT_NIC_READY,
-				HW_READY_TIMEOUT);
+	ret =
+	    _il_poll_bit(il, CSR_HW_IF_CONFIG_REG,
+			 CSR_HW_IF_CONFIG_REG_BIT_NIC_READY,
+			 CSR_HW_IF_CONFIG_REG_BIT_NIC_READY, HW_READY_TIMEOUT);
 	if (ret != -ETIMEDOUT)
 		il->hw_ready = true;
 	else
 		il->hw_ready = false;
 
-	D_INFO("hardware %s\n",
-		      (il->hw_ready == 1) ? "ready" : "not ready");
+	D_INFO("hardware %s\n", (il->hw_ready == 1) ? "ready" : "not ready");
 	return ret;
 }
 
-static int il4965_prepare_card_hw(struct il_priv *il)
+static int
+il4965_prepare_card_hw(struct il_priv *il)
 {
 	int ret = 0;
 
@@ -5259,12 +5221,12 @@ static int il4965_prepare_card_hw(struct il_priv *il)
 		return ret;
 
 	/* If HW is not ready, prepare the conditions to check again */
-	il_set_bit(il, CSR_HW_IF_CONFIG_REG,
-			CSR_HW_IF_CONFIG_REG_PREPARE);
+	il_set_bit(il, CSR_HW_IF_CONFIG_REG, CSR_HW_IF_CONFIG_REG_PREPARE);
 
-	ret = _il_poll_bit(il, CSR_HW_IF_CONFIG_REG,
-			~CSR_HW_IF_CONFIG_REG_BIT_NIC_PREPARE_DONE,
-			CSR_HW_IF_CONFIG_REG_BIT_NIC_PREPARE_DONE, 150000);
+	ret =
+	    _il_poll_bit(il, CSR_HW_IF_CONFIG_REG,
+			 ~CSR_HW_IF_CONFIG_REG_BIT_NIC_PREPARE_DONE,
+			 CSR_HW_IF_CONFIG_REG_BIT_NIC_PREPARE_DONE, 150000);
 
 	/* HW should be ready by now, check again. */
 	if (ret != -ETIMEDOUT)
@@ -5275,7 +5237,8 @@ static int il4965_prepare_card_hw(struct il_priv *il)
 
 #define MAX_HW_RESTARTS 5
 
-static int __il4965_up(struct il_priv *il)
+static int
+__il4965_up(struct il_priv *il)
 {
 	int i;
 	int ret;
@@ -5304,8 +5267,7 @@ static int __il4965_up(struct il_priv *il)
 	}
 
 	/* If platform's RF_KILL switch is NOT set to KILL */
-	if (_il_rd(il,
-		CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
+	if (_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
 		clear_bit(S_RF_KILL_HW, &il->status);
 	else
 		set_bit(S_RF_KILL_HW, &il->status);
@@ -5331,8 +5293,7 @@ static int __il4965_up(struct il_priv *il)
 
 	/* make sure rfkill handshake bits are cleared */
 	_il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
-	_il_wr(il, CSR_UCODE_DRV_GP1_CLR,
-		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
+	_il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
 
 	/* clear (again), then enable host interrupts */
 	_il_wr(il, CSR_INT, 0xFFFFFFFF);
@@ -5356,8 +5317,7 @@ static int __il4965_up(struct il_priv *il)
 		ret = il->cfg->ops->lib->load_ucode(il);
 
 		if (ret) {
-			IL_ERR("Unable to set up bootstrap uCode: %d\n",
-				ret);
+			IL_ERR("Unable to set up bootstrap uCode: %d\n", ret);
 			continue;
 		}
 
@@ -5379,14 +5339,14 @@ static int __il4965_up(struct il_priv *il)
 	return -EIO;
 }
 
-
 /*****************************************************************************
  *
  * Workqueue callbacks
  *
  *****************************************************************************/
 
-static void il4965_bg_init_alive_start(struct work_struct *data)
+static void
+il4965_bg_init_alive_start(struct work_struct *data)
 {
 	struct il_priv *il =
 	    container_of(data, struct il_priv, init_alive_start.work);
@@ -5400,7 +5360,8 @@ out:
 	mutex_unlock(&il->mutex);
 }
 
-static void il4965_bg_alive_start(struct work_struct *data)
+static void
+il4965_bg_alive_start(struct work_struct *data)
 {
 	struct il_priv *il =
 	    container_of(data, struct il_priv, alive_start.work);
@@ -5414,10 +5375,11 @@ out:
 	mutex_unlock(&il->mutex);
 }
 
-static void il4965_bg_run_time_calib_work(struct work_struct *work)
+static void
+il4965_bg_run_time_calib_work(struct work_struct *work)
 {
 	struct il_priv *il = container_of(work, struct il_priv,
-			run_time_calib_work);
+					  run_time_calib_work);
 
 	mutex_lock(&il->mutex);
 
@@ -5428,16 +5390,15 @@ static void il4965_bg_run_time_calib_work(struct work_struct *work)
 	}
 
 	if (il->start_calib) {
-		il4965_chain_noise_calibration(il,
-				(void *)&il->_4965.stats);
-		il4965_sensitivity_calibration(il,
-				(void *)&il->_4965.stats);
+		il4965_chain_noise_calibration(il, (void *)&il->_4965.stats);
+		il4965_sensitivity_calibration(il, (void *)&il->_4965.stats);
 	}
 
 	mutex_unlock(&il->mutex);
 }
 
-static void il4965_bg_restart(struct work_struct *data)
+static void
+il4965_bg_restart(struct work_struct *data)
 {
 	struct il_priv *il = container_of(data, struct il_priv, restart);
 
@@ -5468,10 +5429,10 @@ static void il4965_bg_restart(struct work_struct *data)
 	}
 }
 
-static void il4965_bg_rx_replenish(struct work_struct *data)
+static void
+il4965_bg_rx_replenish(struct work_struct *data)
 {
-	struct il_priv *il =
-	    container_of(data, struct il_priv, rx_replenish);
+	struct il_priv *il = container_of(data, struct il_priv, rx_replenish);
 
 	if (test_bit(S_EXIT_PENDING, &il->status))
 		return;
@@ -5493,8 +5454,8 @@ static void il4965_bg_rx_replenish(struct work_struct *data)
  * Not a mac80211 entry point function, but it fits in with all the
  * other mac80211 functions grouped here.
  */
-static int il4965_mac_setup_register(struct il_priv *il,
-				  u32 max_probe_length)
+static int
+il4965_mac_setup_register(struct il_priv *il, u32 max_probe_length)
 {
 	int ret;
 	struct ieee80211_hw *hw = il->hw;
@@ -5502,15 +5463,15 @@ static int il4965_mac_setup_register(struct il_priv *il,
 	hw->rate_control_algorithm = "iwl-4965-rs";
 
 	/* Tell mac80211 our characteristics */
-	hw->flags = IEEE80211_HW_SIGNAL_DBM |
-		    IEEE80211_HW_AMPDU_AGGREGATION |
-		    IEEE80211_HW_NEED_DTIM_PERIOD |
-		    IEEE80211_HW_SPECTRUM_MGMT |
-		    IEEE80211_HW_REPORTS_TX_ACK_STATUS;
+	hw->flags =
+	    IEEE80211_HW_SIGNAL_DBM | IEEE80211_HW_AMPDU_AGGREGATION |
+	    IEEE80211_HW_NEED_DTIM_PERIOD | IEEE80211_HW_SPECTRUM_MGMT |
+	    IEEE80211_HW_REPORTS_TX_ACK_STATUS;
 
 	if (il->cfg->sku & IL_SKU_N)
-		hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS |
-			     IEEE80211_HW_SUPPORTS_STATIC_SMPS;
+		hw->flags |=
+		    IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS |
+		    IEEE80211_HW_SUPPORTS_STATIC_SMPS;
 
 	hw->sta_data_size = sizeof(struct il_station_priv);
 	hw->vif_data_size = sizeof(struct il_vif_priv);
@@ -5518,8 +5479,8 @@ static int il4965_mac_setup_register(struct il_priv *il,
 	hw->wiphy->interface_modes |= il->ctx.interface_modes;
 	hw->wiphy->interface_modes |= il->ctx.exclusive_interface_modes;
 
-	hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY |
-			    WIPHY_FLAG_DISABLE_BEACON_HINTS;
+	hw->wiphy->flags |=
+	    WIPHY_FLAG_CUSTOM_REGULATORY | WIPHY_FLAG_DISABLE_BEACON_HINTS;
 
 	/*
 	 * For now, disable PS by default because it affects
@@ -5538,10 +5499,10 @@ static int il4965_mac_setup_register(struct il_priv *il,
 
 	if (il->bands[IEEE80211_BAND_2GHZ].n_channels)
 		il->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
-			&il->bands[IEEE80211_BAND_2GHZ];
+		    &il->bands[IEEE80211_BAND_2GHZ];
 	if (il->bands[IEEE80211_BAND_5GHZ].n_channels)
 		il->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
-			&il->bands[IEEE80211_BAND_5GHZ];
+		    &il->bands[IEEE80211_BAND_5GHZ];
 
 	il_leds_init(il);
 
@@ -5555,8 +5516,8 @@ static int il4965_mac_setup_register(struct il_priv *il,
 	return 0;
 }
 
-
-int il4965_mac_start(struct ieee80211_hw *hw)
+int
+il4965_mac_start(struct ieee80211_hw *hw)
 {
 	struct il_priv *il = hw->priv;
 	int ret;
@@ -5579,8 +5540,8 @@ int il4965_mac_start(struct ieee80211_hw *hw)
 	/* Wait for START_ALIVE from Run Time ucode. Otherwise callbacks from
 	 * mac80211 will not be run successfully. */
 	ret = wait_event_timeout(il->wait_command_queue,
-			test_bit(S_READY, &il->status),
-			UCODE_READY_TIMEOUT);
+				 test_bit(S_READY, &il->status),
+				 UCODE_READY_TIMEOUT);
 	if (!ret) {
 		if (!test_bit(S_READY, &il->status)) {
 			IL_ERR("START_ALIVE timeout after %dms.\n",
@@ -5597,7 +5558,8 @@ out:
 	return 0;
 }
 
-void il4965_mac_stop(struct ieee80211_hw *hw)
+void
+il4965_mac_stop(struct ieee80211_hw *hw)
 {
 	struct il_priv *il = hw->priv;
 
@@ -5620,14 +5582,15 @@ void il4965_mac_stop(struct ieee80211_hw *hw)
 	D_MAC80211("leave\n");
 }
 
-void il4965_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
+void
+il4965_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
 {
 	struct il_priv *il = hw->priv;
 
 	D_MACDUMP("enter\n");
 
 	D_TX("dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
-		     ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
+	     ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
 
 	if (il4965_tx_skb(il, skb))
 		dev_kfree_skb_any(skb);
@@ -5635,26 +5598,26 @@ void il4965_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
 	D_MACDUMP("leave\n");
 }
 
-void il4965_mac_update_tkip_key(struct ieee80211_hw *hw,
-				struct ieee80211_vif *vif,
-				struct ieee80211_key_conf *keyconf,
-				struct ieee80211_sta *sta,
-				u32 iv32, u16 *phase1key)
+void
+il4965_mac_update_tkip_key(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+			   struct ieee80211_key_conf *keyconf,
+			   struct ieee80211_sta *sta, u32 iv32, u16 * phase1key)
 {
 	struct il_priv *il = hw->priv;
 	struct il_vif_priv *vif_priv = (void *)vif->drv_priv;
 
 	D_MAC80211("enter\n");
 
-	il4965_update_tkip_key(il, vif_priv->ctx, keyconf, sta,
-			    iv32, phase1key);
+	il4965_update_tkip_key(il, vif_priv->ctx, keyconf, sta, iv32,
+			       phase1key);
 
 	D_MAC80211("leave\n");
 }
 
-int il4965_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
-		       struct ieee80211_vif *vif, struct ieee80211_sta *sta,
-		       struct ieee80211_key_conf *key)
+int
+il4965_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
+		   struct ieee80211_vif *vif, struct ieee80211_sta *sta,
+		   struct ieee80211_key_conf *key)
 {
 	struct il_priv *il = hw->priv;
 	struct il_vif_priv *vif_priv = (void *)vif->drv_priv;
@@ -5684,23 +5647,23 @@ int il4965_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
 	 * In legacy wep mode, we use another host command to the uCode.
 	 */
 	if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
-	     key->cipher == WLAN_CIPHER_SUITE_WEP104) &&
-	    !sta) {
+	     key->cipher == WLAN_CIPHER_SUITE_WEP104) && !sta) {
 		if (cmd == SET_KEY)
 			is_default_wep_key = !ctx->key_mapping_keys;
 		else
 			is_default_wep_key =
-					(key->hw_key_idx == HW_KEY_DEFAULT);
+			    (key->hw_key_idx == HW_KEY_DEFAULT);
 	}
 
 	switch (cmd) {
 	case SET_KEY:
 		if (is_default_wep_key)
-			ret = il4965_set_default_wep_key(il,
-							vif_priv->ctx, key);
+			ret =
+			    il4965_set_default_wep_key(il, vif_priv->ctx, key);
 		else
-			ret = il4965_set_dynamic_key(il, vif_priv->ctx,
-						  key, sta_id);
+			ret =
+			    il4965_set_dynamic_key(il, vif_priv->ctx, key,
+						   sta_id);
 
 		D_MAC80211("enable hwcrypto key\n");
 		break;
@@ -5708,8 +5671,7 @@ int il4965_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
 		if (is_default_wep_key)
 			ret = il4965_remove_default_wep_key(il, ctx, key);
 		else
-			ret = il4965_remove_dynamic_key(il, ctx,
-							key, sta_id);
+			ret = il4965_remove_dynamic_key(il, ctx, key, sta_id);
 
 		D_MAC80211("disable hwcrypto key\n");
 		break;
@@ -5723,17 +5685,16 @@ int il4965_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
 	return ret;
 }
 
-int il4965_mac_ampdu_action(struct ieee80211_hw *hw,
-			    struct ieee80211_vif *vif,
-			    enum ieee80211_ampdu_mlme_action action,
-			    struct ieee80211_sta *sta, u16 tid, u16 *ssn,
-			    u8 buf_size)
+int
+il4965_mac_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+			enum ieee80211_ampdu_mlme_action action,
+			struct ieee80211_sta *sta, u16 tid, u16 * ssn,
+			u8 buf_size)
 {
 	struct il_priv *il = hw->priv;
 	int ret = -EINVAL;
 
-	D_HT("A-MPDU action on addr %pM tid %d\n",
-		     sta->addr, tid);
+	D_HT("A-MPDU action on addr %pM tid %d\n", sta->addr, tid);
 
 	if (!(il->cfg->sku & IL_SKU_N))
 		return -EACCES;
@@ -5770,9 +5731,9 @@ int il4965_mac_ampdu_action(struct ieee80211_hw *hw,
 	return ret;
 }
 
-int il4965_mac_sta_add(struct ieee80211_hw *hw,
-		       struct ieee80211_vif *vif,
-		       struct ieee80211_sta *sta)
+int
+il4965_mac_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+		   struct ieee80211_sta *sta)
 {
 	struct il_priv *il = hw->priv;
 	struct il_station_priv *sta_priv = (void *)sta->drv_priv;
@@ -5781,20 +5742,18 @@ int il4965_mac_sta_add(struct ieee80211_hw *hw,
 	int ret;
 	u8 sta_id;
 
-	D_INFO("received request to add station %pM\n",
-			sta->addr);
+	D_INFO("received request to add station %pM\n", sta->addr);
 	mutex_lock(&il->mutex);
-	D_INFO("proceeding to add station %pM\n",
-			sta->addr);
+	D_INFO("proceeding to add station %pM\n", sta->addr);
 	sta_priv->common.sta_id = IL_INVALID_STATION;
 
 	atomic_set(&sta_priv->pending_frames, 0);
 
-	ret = il_add_station_common(il, vif_priv->ctx, sta->addr,
-				     is_ap, sta, &sta_id);
+	ret =
+	    il_add_station_common(il, vif_priv->ctx, sta->addr, is_ap, sta,
+				  &sta_id);
 	if (ret) {
-		IL_ERR("Unable to add station %pM (%d)\n",
-			sta->addr, ret);
+		IL_ERR("Unable to add station %pM (%d)\n", sta->addr, ret);
 		/* Should we return success if return code is EEXIST ? */
 		mutex_unlock(&il->mutex);
 		return ret;
@@ -5803,16 +5762,16 @@ int il4965_mac_sta_add(struct ieee80211_hw *hw,
 	sta_priv->common.sta_id = sta_id;
 
 	/* Initialize rate scaling */
-	D_INFO("Initializing rate scaling for station %pM\n",
-		       sta->addr);
+	D_INFO("Initializing rate scaling for station %pM\n", sta->addr);
 	il4965_rs_rate_init(il, sta, sta_id);
 	mutex_unlock(&il->mutex);
 
 	return 0;
 }
 
-void il4965_mac_channel_switch(struct ieee80211_hw *hw,
-			       struct ieee80211_channel_switch *ch_switch)
+void
+il4965_mac_channel_switch(struct ieee80211_hw *hw,
+			  struct ieee80211_channel_switch *ch_switch)
 {
 	struct il_priv *il = hw->priv;
 	const struct il_channel_info *ch_info;
@@ -5860,15 +5819,15 @@ void il4965_mac_channel_switch(struct ieee80211_hw *hw,
 	if (ctx->ht.enabled) {
 		if (conf_is_ht40_minus(conf)) {
 			ctx->ht.extension_chan_offset =
-				IEEE80211_HT_PARAM_CHA_SEC_BELOW;
+			    IEEE80211_HT_PARAM_CHA_SEC_BELOW;
 			ctx->ht.is_40mhz = true;
 		} else if (conf_is_ht40_plus(conf)) {
 			ctx->ht.extension_chan_offset =
-				IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
+			    IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
 			ctx->ht.is_40mhz = true;
 		} else {
 			ctx->ht.extension_chan_offset =
-				IEEE80211_HT_PARAM_CHA_SEC_NONE;
+			    IEEE80211_HT_PARAM_CHA_SEC_NONE;
 			ctx->ht.is_40mhz = false;
 		}
 	} else
@@ -5901,10 +5860,9 @@ out:
 	D_MAC80211("leave\n");
 }
 
-void il4965_configure_filter(struct ieee80211_hw *hw,
-			     unsigned int changed_flags,
-			     unsigned int *total_flags,
-			     u64 multicast)
+void
+il4965_configure_filter(struct ieee80211_hw *hw, unsigned int changed_flags,
+			unsigned int *total_flags, u64 multicast)
 {
 	struct il_priv *il = hw->priv;
 	__le32 filter_or = 0, filter_nand = 0;
@@ -5916,8 +5874,8 @@ void il4965_configure_filter(struct ieee80211_hw *hw,
 		filter_nand |= (flag);		\
 	} while (0)
 
-	D_MAC80211("Enter: changed: 0x%x, total: 0x%x\n",
-			changed_flags, *total_flags);
+	D_MAC80211("Enter: changed: 0x%x, total: 0x%x\n", changed_flags,
+		   *total_flags);
 
 	CHK(FIF_OTHER_BSS | FIF_PROMISC_IN_BSS, RXON_FILTER_PROMISC_MSK);
 	/* Setting _just_ RXON_FILTER_CTL2HOST_MSK causes FH errors */
@@ -5944,8 +5902,9 @@ void il4965_configure_filter(struct ieee80211_hw *hw,
 	 * since we currently do not support programming multicast
 	 * filters into the device.
 	 */
-	*total_flags &= FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS |
-			FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
+	*total_flags &=
+	    FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS |
+	    FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
 }
 
 /*****************************************************************************
@@ -5954,10 +5913,11 @@ void il4965_configure_filter(struct ieee80211_hw *hw,
  *
  *****************************************************************************/
 
-static void il4965_bg_txpower_work(struct work_struct *work)
+static void
+il4965_bg_txpower_work(struct work_struct *work)
 {
 	struct il_priv *il = container_of(work, struct il_priv,
-			txpower_work);
+					  txpower_work);
 
 	mutex_lock(&il->mutex);
 
@@ -5981,7 +5941,8 @@ out:
 	mutex_unlock(&il->mutex);
 }
 
-static void il4965_setup_deferred_work(struct il_priv *il)
+static void
+il4965_setup_deferred_work(struct il_priv *il)
 {
 	il->workqueue = create_singlethread_workqueue(DRV_NAME);
 
@@ -6005,11 +5966,13 @@ static void il4965_setup_deferred_work(struct il_priv *il)
 	il->watchdog.data = (unsigned long)il;
 	il->watchdog.function = il_bg_watchdog;
 
-	tasklet_init(&il->irq_tasklet, (void (*)(unsigned long))
-		il4965_irq_tasklet, (unsigned long)il);
+	tasklet_init(&il->irq_tasklet,
+		     (void (*)(unsigned long))il4965_irq_tasklet,
+		     (unsigned long)il);
 }
 
-static void il4965_cancel_deferred_work(struct il_priv *il)
+static void
+il4965_cancel_deferred_work(struct il_priv *il)
 {
 	cancel_work_sync(&il->txpower_work);
 	cancel_delayed_work_sync(&il->init_alive_start);
@@ -6021,14 +5984,14 @@ static void il4965_cancel_deferred_work(struct il_priv *il)
 	del_timer_sync(&il->stats_periodic);
 }
 
-static void il4965_init_hw_rates(struct il_priv *il,
-			      struct ieee80211_rate *rates)
+static void
+il4965_init_hw_rates(struct il_priv *il, struct ieee80211_rate *rates)
 {
 	int i;
 
 	for (i = 0; i < RATE_COUNT_LEGACY; i++) {
 		rates[i].bitrate = il_rates[i].ieee * 5;
-		rates[i].hw_value = i; /* Rate scaling will work on idxes */
+		rates[i].hw_value = i;	/* Rate scaling will work on idxes */
 		rates[i].hw_value_short = i;
 		rates[i].flags = 0;
 		if ((i >= IL_FIRST_CCK_RATE) && (i <= IL_LAST_CCK_RATE)) {
@@ -6036,24 +5999,25 @@ static void il4965_init_hw_rates(struct il_priv *il,
 			 * If CCK != 1M then set short preamble rate flag.
 			 */
 			rates[i].flags |=
-				(il_rates[i].plcp == RATE_1M_PLCP) ?
-					0 : IEEE80211_RATE_SHORT_PREAMBLE;
+			    (il_rates[i].plcp ==
+			     RATE_1M_PLCP) ? 0 : IEEE80211_RATE_SHORT_PREAMBLE;
 		}
 	}
 }
+
 /*
  * Acquire il->lock before calling this function !
  */
-void il4965_set_wr_ptrs(struct il_priv *il, int txq_id, u32 idx)
+void
+il4965_set_wr_ptrs(struct il_priv *il, int txq_id, u32 idx)
 {
-	il_wr(il, HBUS_TARG_WRPTR,
-			     (idx & 0xff) | (txq_id << 8));
+	il_wr(il, HBUS_TARG_WRPTR, (idx & 0xff) | (txq_id << 8));
 	il_wr_prph(il, IL49_SCD_QUEUE_RDPTR(txq_id), idx);
 }
 
-void il4965_tx_queue_set_status(struct il_priv *il,
-					struct il_tx_queue *txq,
-					int tx_fifo_id, int scd_retry)
+void
+il4965_tx_queue_set_status(struct il_priv *il, struct il_tx_queue *txq,
+			   int tx_fifo_id, int scd_retry)
 {
 	int txq_id = txq->q.id;
 
@@ -6062,21 +6026,22 @@ void il4965_tx_queue_set_status(struct il_priv *il,
 
 	/* Set up and activate */
 	il_wr_prph(il, IL49_SCD_QUEUE_STATUS_BITS(txq_id),
-			 (active << IL49_SCD_QUEUE_STTS_REG_POS_ACTIVE) |
-			 (tx_fifo_id << IL49_SCD_QUEUE_STTS_REG_POS_TXF) |
-			 (scd_retry << IL49_SCD_QUEUE_STTS_REG_POS_WSL) |
-			 (scd_retry << IL49_SCD_QUEUE_STTS_REG_POS_SCD_ACK) |
-			 IL49_SCD_QUEUE_STTS_REG_MSK);
+		   (active << IL49_SCD_QUEUE_STTS_REG_POS_ACTIVE) | (tx_fifo_id
+								     <<
+								     IL49_SCD_QUEUE_STTS_REG_POS_TXF)
+		   | (scd_retry << IL49_SCD_QUEUE_STTS_REG_POS_WSL) | (scd_retry
+								       <<
+								       IL49_SCD_QUEUE_STTS_REG_POS_SCD_ACK)
+		   | IL49_SCD_QUEUE_STTS_REG_MSK);
 
 	txq->sched_retry = scd_retry;
 
-	D_INFO("%s %s Queue %d on AC %d\n",
-		       active ? "Activate" : "Deactivate",
-		       scd_retry ? "BA" : "AC", txq_id, tx_fifo_id);
+	D_INFO("%s %s Queue %d on AC %d\n", active ? "Activate" : "Deactivate",
+	       scd_retry ? "BA" : "AC", txq_id, tx_fifo_id);
 }
 
-
-static int il4965_init_drv(struct il_priv *il)
+static int
+il4965_init_drv(struct il_priv *il)
 {
 	int ret;
 
@@ -6100,8 +6065,7 @@ static int il4965_init_drv(struct il_priv *il)
 
 	/* Choose which receivers/antennas to use */
 	if (il->cfg->ops->hcmd->set_rxon_chain)
-		il->cfg->ops->hcmd->set_rxon_chain(il,
-					&il->ctx);
+		il->cfg->ops->hcmd->set_rxon_chain(il, &il->ctx);
 
 	il_init_scan_params(il);
 
@@ -6126,7 +6090,8 @@ err:
 	return ret;
 }
 
-static void il4965_uninit_drv(struct il_priv *il)
+static void
+il4965_uninit_drv(struct il_priv *il)
 {
 	il4965_calib_free_results(il);
 	il_free_geos(il);
@@ -6134,7 +6099,8 @@ static void il4965_uninit_drv(struct il_priv *il)
 	kfree(il->scan_cmd);
 }
 
-static void il4965_hw_detect(struct il_priv *il)
+static void
+il4965_hw_detect(struct il_priv *il)
 {
 	il->hw_rev = _il_rd(il, CSR_HW_REV);
 	il->hw_wa_rev = _il_rd(il, CSR_HW_REV_WA_REG);
@@ -6142,7 +6108,8 @@ static void il4965_hw_detect(struct il_priv *il)
 	D_INFO("HW Revision ID = 0x%X\n", il->rev_id);
 }
 
-static int il4965_set_hw_params(struct il_priv *il)
+static int
+il4965_set_hw_params(struct il_priv *il)
 {
 	il->hw_params.max_rxq_size = RX_QUEUE_SIZE;
 	il->hw_params.max_rxq_log = RX_QUEUE_SIZE_LOG;
@@ -6205,10 +6172,8 @@ il4965_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 	il->ctx.wep_key_cmd = C_WEPKEY;
 	il->ctx.ac_to_fifo = il4965_bss_ac_to_fifo;
 	il->ctx.ac_to_queue = il4965_bss_ac_to_queue;
-	il->ctx.exclusive_interface_modes =
-		BIT(NL80211_IFTYPE_ADHOC);
-	il->ctx.interface_modes =
-		BIT(NL80211_IFTYPE_STATION);
+	il->ctx.exclusive_interface_modes = BIT(NL80211_IFTYPE_ADHOC);
+	il->ctx.interface_modes = BIT(NL80211_IFTYPE_STATION);
 	il->ctx.ap_devtype = RXON_DEV_TYPE_AP;
 	il->ctx.ibss_devtype = RXON_DEV_TYPE_IBSS;
 	il->ctx.station_devtype = RXON_DEV_TYPE_ESS;
@@ -6227,8 +6192,9 @@ il4965_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 	/**************************
 	 * 2. Initializing PCI bus
 	 **************************/
-	pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1 |
-				PCIE_LINK_STATE_CLKPM);
+	pci_disable_link_state(pdev,
+			       PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1 |
+			       PCIE_LINK_STATE_CLKPM);
 
 	if (pci_enable_device(pdev)) {
 		err = -ENODEV;
@@ -6243,8 +6209,8 @@ il4965_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 	if (err) {
 		err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
 		if (!err)
-			err = pci_set_consistent_dma_mask(pdev,
-							DMA_BIT_MASK(32));
+			err =
+			    pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
 		/* both attempts failed: */
 		if (err) {
 			IL_WARN("No suitable DMA available.\n");
@@ -6258,7 +6224,6 @@ il4965_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
 	pci_set_drvdata(pdev, il);
 
-
 	/***********************
 	 * 3. Read REV register
 	 ***********************/
@@ -6269,7 +6234,7 @@ il4965_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 	}
 
 	D_INFO("pci_resource_len = 0x%08llx\n",
-		(unsigned long long) pci_resource_len(pdev, 0));
+	       (unsigned long long)pci_resource_len(pdev, 0));
 	D_INFO("pci_resource_base = %p\n", il->hw_base);
 
 	/* these spin locks will be used in apm_ops.init and EEPROM access
@@ -6286,8 +6251,7 @@ il4965_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 	_il_wr(il, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
 
 	il4965_hw_detect(il);
-	IL_INFO("Detected %s, REV=0x%X\n",
-		il->cfg->name, il->hw_rev);
+	IL_INFO("Detected %s, REV=0x%X\n", il->cfg->name, il->hw_rev);
 
 	/* We disable the RETRY_TIMEOUT register (0x41) to keep
 	 * PCI Tx retries from interfering with C3 CPU state */
@@ -6347,8 +6311,7 @@ il4965_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
 	pci_enable_msi(il->pci_dev);
 
-	err = request_irq(il->pci_dev->irq, il_isr,
-			  IRQF_SHARED, DRV_NAME, il);
+	err = request_irq(il->pci_dev->irq, il_isr, IRQF_SHARED, DRV_NAME, il);
 	if (err) {
 		IL_ERR("Error allocating IRQ %d\n", il->pci_dev->irq);
 		goto out_disable_msi;
@@ -6371,14 +6334,13 @@ il4965_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 	il_enable_rfkill_int(il);
 
 	/* If platform's RF_KILL switch is NOT set to KILL */
-	if (_il_rd(il, CSR_GP_CNTRL) &
-		CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
+	if (_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
 		clear_bit(S_RF_KILL_HW, &il->status);
 	else
 		set_bit(S_RF_KILL_HW, &il->status);
 
 	wiphy_rfkill_set_hw_state(il->hw->wiphy,
-		test_bit(S_RF_KILL_HW, &il->status));
+				  test_bit(S_RF_KILL_HW, &il->status));
 
 	il_power_initialize(il);
 
@@ -6390,30 +6352,31 @@ il4965_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
 	return 0;
 
- out_destroy_workqueue:
+out_destroy_workqueue:
 	destroy_workqueue(il->workqueue);
 	il->workqueue = NULL;
 	free_irq(il->pci_dev->irq, il);
- out_disable_msi:
+out_disable_msi:
 	pci_disable_msi(il->pci_dev);
 	il4965_uninit_drv(il);
- out_free_eeprom:
+out_free_eeprom:
 	il_eeprom_free(il);
- out_iounmap:
+out_iounmap:
 	pci_iounmap(pdev, il->hw_base);
- out_pci_release_regions:
+out_pci_release_regions:
 	pci_set_drvdata(pdev, NULL);
 	pci_release_regions(pdev);
- out_pci_disable_device:
+out_pci_disable_device:
 	pci_disable_device(pdev);
- out_ieee80211_free_hw:
+out_ieee80211_free_hw:
 	il_free_traffic_mem(il);
 	ieee80211_free_hw(il->hw);
- out:
+out:
 	return err;
 }
 
-static void __devexit il4965_pci_remove(struct pci_dev *pdev)
+static void __devexit
+il4965_pci_remove(struct pci_dev *pdev)
 {
 	struct il_priv *il = pci_get_drvdata(pdev);
 	unsigned long flags;
@@ -6469,7 +6432,6 @@ static void __devexit il4965_pci_remove(struct pci_dev *pdev)
 
 	il_eeprom_free(il);
 
-
 	/*netif_stop_queue(dev); */
 	flush_workqueue(il->workqueue);
 
@@ -6498,7 +6460,8 @@ static void __devexit il4965_pci_remove(struct pci_dev *pdev)
  * Activate/Deactivate Tx DMA/FIFO channels according tx fifos mask
  * must be called under il->lock and mac access
  */
-void il4965_txq_set_sched(struct il_priv *il, u32 mask)
+void
+il4965_txq_set_sched(struct il_priv *il, u32 mask)
 {
 	il_wr_prph(il, IL49_SCD_TXFACT, mask);
 }
@@ -6525,7 +6488,8 @@ static struct pci_driver il4965_driver = {
 	.driver.pm = IL_LEGACY_PM_OPS,
 };
 
-static int __init il4965_init(void)
+static int __init
+il4965_init(void)
 {
 
 	int ret;
@@ -6551,7 +6515,8 @@ error_register:
 	return ret;
 }
 
-static void __exit il4965_exit(void)
+static void __exit
+il4965_exit(void)
 {
 	pci_unregister_driver(&il4965_driver);
 	il4965_rate_control_unregister();
@@ -6571,8 +6536,8 @@ module_param_named(queues_num, il4965_mod_params.num_of_queues, int, S_IRUGO);
 MODULE_PARM_DESC(queues_num, "number of hw queues.");
 module_param_named(11n_disable, il4965_mod_params.disable_11n, int, S_IRUGO);
 MODULE_PARM_DESC(11n_disable, "disable 11n functionality");
-module_param_named(amsdu_size_8K, il4965_mod_params.amsdu_size_8K,
-		   int, S_IRUGO);
+module_param_named(amsdu_size_8K, il4965_mod_params.amsdu_size_8K, int,
+		   S_IRUGO);
 MODULE_PARM_DESC(amsdu_size_8K, "enable 8K amsdu size");
 module_param_named(fw_restart, il4965_mod_params.restart_fw, int, S_IRUGO);
 MODULE_PARM_DESC(fw_restart, "restart firmware in case of error");
-- 
cgit v1.2.3-70-g09d2