Merge branch 'for-john' of git://git.kernel.org/pub/scm/linux/kernel/git/iwlwifi/iwlwifi-next

9 files changed, 121 insertions, 30 deletions

diff --git a/drivers/net/wireless/iwlwifi/dvm/main.c b/drivers/net/wireless/iwlwifi/dvm/main.c
index 7ff3f143067..475df45c832 100644
--- a/drivers/net/wireless/iwlwifi/dvm/main.c
+++ b/drivers/net/wireless/iwlwifi/dvm/main.c
@@ -1191,8 +1191,6 @@ static void iwl_option_config(struct iwl_priv *priv)
 
 static int iwl_eeprom_init_hw_params(struct iwl_priv *priv)
 {
-        u16 radio_cfg;
-
         priv->eeprom_data->sku = priv->eeprom_data->sku;
 
         if (priv->eeprom_data->sku & EEPROM_SKU_CAP_11N_ENABLE &&
@@ -1208,8 +1206,6 @@ static int iwl_eeprom_init_hw_params(struct iwl_priv *priv)
 
         IWL_INFO(priv, "Device SKU: 0x%X\n", priv->eeprom_data->sku);
 
-        radio_cfg = priv->eeprom_data->radio_cfg;
-
         priv->hw_params.tx_chains_num =
                 num_of_ant(priv->eeprom_data->valid_tx_ant);
         if (priv->cfg->rx_with_siso_diversity)
@@ -1334,6 +1330,9 @@ static struct iwl_op_mode *iwl_op_mode_dvm_start(struct iwl_trans *trans,
         /* Configure transport layer */
         iwl_trans_configure(priv->trans, &trans_cfg);
 
+        trans->rx_mpdu_cmd = REPLY_RX_MPDU_CMD;
+        trans->rx_mpdu_cmd_hdr_size = sizeof(struct iwl_rx_mpdu_res_start);
+
         /* At this point both hw and priv are allocated. */
 
         SET_IEEE80211_DEV(priv->hw, priv->trans->dev);
@@ -2152,8 +2151,6 @@ static int __init iwl_init(void)
 {
 
         int ret;
-        pr_info(DRV_DESCRIPTION ", " DRV_VERSION "\n");
-        pr_info(DRV_COPYRIGHT "\n");
 
         ret = iwlagn_rate_control_register();
         if (ret) {
diff --git a/drivers/net/wireless/iwlwifi/iwl-devtrace.h b/drivers/net/wireless/iwlwifi/iwl-devtrace.h
index 59a5f78402f..678717bf62e 100644
--- a/drivers/net/wireless/iwlwifi/iwl-devtrace.h
+++ b/drivers/net/wireless/iwlwifi/iwl-devtrace.h
@@ -25,6 +25,39 @@
  *****************************************************************************/
 
 #if !defined(__IWLWIFI_DEVICE_TRACE) || defined(TRACE_HEADER_MULTI_READ)
+#include <linux/skbuff.h>
+#include <linux/ieee80211.h>
+#include <net/cfg80211.h>
+#include "iwl-trans.h"
+#if !defined(__IWLWIFI_DEVICE_TRACE)
+static inline bool iwl_trace_data(struct sk_buff *skb)
+{
+        struct ieee80211_hdr *hdr = (void *)skb->data;
+
+        if (ieee80211_is_data(hdr->frame_control))
+                return skb->protocol != cpu_to_be16(ETH_P_PAE);
+        return false;
+}
+
+static inline size_t iwl_rx_trace_len(const struct iwl_trans *trans,
+                                      void *rxbuf, size_t len)
+{
+        struct iwl_cmd_header *cmd = (void *)((u8 *)rxbuf + sizeof(__le32));
+        struct ieee80211_hdr *hdr;
+
+        if (cmd->cmd != trans->rx_mpdu_cmd)
+                return len;
+
+        hdr = (void *)((u8 *)cmd + sizeof(struct iwl_cmd_header) +
+                        trans->rx_mpdu_cmd_hdr_size);
+        if (!ieee80211_is_data(hdr->frame_control))
+                return len;
+        /* maybe try to identify EAPOL frames? */
+        return sizeof(__le32) + sizeof(*cmd) + trans->rx_mpdu_cmd_hdr_size +
+                ieee80211_hdrlen(hdr->frame_control);
+}
+#endif
+
 #define __IWLWIFI_DEVICE_TRACE
 
 #include <linux/tracepoint.h>
@@ -235,6 +268,48 @@ TRACE_EVENT(iwlwifi_dbg,
 );
 
 #undef TRACE_SYSTEM
+#define TRACE_SYSTEM iwlwifi_data
+
+TRACE_EVENT(iwlwifi_dev_tx_data,
+        TP_PROTO(const struct device *dev,
+                 struct sk_buff *skb,
+                 void *data, size_t data_len),
+        TP_ARGS(dev, skb, data, data_len),
+        TP_STRUCT__entry(
+                DEV_ENTRY
+
+                __dynamic_array(u8, data, iwl_trace_data(skb) ? data_len : 0)
+        ),
+        TP_fast_assign(
+                DEV_ASSIGN;
+                if (iwl_trace_data(skb))
+                        memcpy(__get_dynamic_array(data), data, data_len);
+        ),
+        TP_printk("[%s] TX frame data", __get_str(dev))
+);
+
+TRACE_EVENT(iwlwifi_dev_rx_data,
+        TP_PROTO(const struct device *dev,
+                 const struct iwl_trans *trans,
+                 void *rxbuf, size_t len),
+        TP_ARGS(dev, trans, rxbuf, len),
+        TP_STRUCT__entry(
+                DEV_ENTRY
+
+                __dynamic_array(u8, data,
+                                len - iwl_rx_trace_len(trans, rxbuf, len))
+        ),
+        TP_fast_assign(
+                size_t offs = iwl_rx_trace_len(trans, rxbuf, len);
+                DEV_ASSIGN;
+                if (offs < len)
+                        memcpy(__get_dynamic_array(data),
+                               ((u8 *)rxbuf) + offs, len - offs);
+        ),
+        TP_printk("[%s] TX frame data", __get_str(dev))
+);
+
+#undef TRACE_SYSTEM
 #define TRACE_SYSTEM iwlwifi
 
 TRACE_EVENT(iwlwifi_dev_hcmd,
@@ -270,25 +345,28 @@ TRACE_EVENT(iwlwifi_dev_hcmd,
 );
 
 TRACE_EVENT(iwlwifi_dev_rx,
-        TP_PROTO(const struct device *dev, void *rxbuf, size_t len),
-        TP_ARGS(dev, rxbuf, len),
+        TP_PROTO(const struct device *dev, const struct iwl_trans *trans,
+                 void *rxbuf, size_t len),
+        TP_ARGS(dev, trans, rxbuf, len),
         TP_STRUCT__entry(
                 DEV_ENTRY
-                __dynamic_array(u8, rxbuf, len)
+                __dynamic_array(u8, rxbuf, iwl_rx_trace_len(trans, rxbuf, len))
         ),
         TP_fast_assign(
                 DEV_ASSIGN;
-                memcpy(__get_dynamic_array(rxbuf), rxbuf, len);
+                memcpy(__get_dynamic_array(rxbuf), rxbuf,
+                       iwl_rx_trace_len(trans, rxbuf, len));
         ),
         TP_printk("[%s] RX cmd %#.2x",
                   __get_str(dev), ((u8 *)__get_dynamic_array(rxbuf))[4])
 );
 
 TRACE_EVENT(iwlwifi_dev_tx,
-        TP_PROTO(const struct device *dev, void *tfd, size_t tfdlen,
+        TP_PROTO(const struct device *dev, struct sk_buff *skb,
+                 void *tfd, size_t tfdlen,
                  void *buf0, size_t buf0_len,
                  void *buf1, size_t buf1_len),
-        TP_ARGS(dev, tfd, tfdlen, buf0, buf0_len, buf1, buf1_len),
+        TP_ARGS(dev, skb, tfd, tfdlen, buf0, buf0_len, buf1, buf1_len),
         TP_STRUCT__entry(
                 DEV_ENTRY
 
@@ -301,14 +379,15 @@ TRACE_EVENT(iwlwifi_dev_tx,
                  * for the possible padding).
                  */
                 __dynamic_array(u8, buf0, buf0_len)
-                __dynamic_array(u8, buf1, buf1_len)
+                __dynamic_array(u8, buf1, iwl_trace_data(skb) ? 0 : buf1_len)
         ),
         TP_fast_assign(
                 DEV_ASSIGN;
                 __entry->framelen = buf0_len + buf1_len;
                 memcpy(__get_dynamic_array(tfd), tfd, tfdlen);
                 memcpy(__get_dynamic_array(buf0), buf0, buf0_len);
-                memcpy(__get_dynamic_array(buf1), buf1, buf1_len);
+                if (!iwl_trace_data(skb))
+                        memcpy(__get_dynamic_array(buf1), buf1, buf1_len);
         ),
         TP_printk("[%s] TX %.2x (%zu bytes)",
                   __get_str(dev), ((u8 *)__get_dynamic_array(buf0))[0],
diff --git a/drivers/net/wireless/iwlwifi/iwl-io.c b/drivers/net/wireless/iwlwifi/iwl-io.c
index 3dfebfb8434..54c41b44bff 100644
--- a/drivers/net/wireless/iwlwifi/iwl-io.c
+++ b/drivers/net/wireless/iwlwifi/iwl-io.c
@@ -327,11 +327,11 @@ u32 iwl_read_targ_mem(struct iwl_trans *trans, u32 addr)
 EXPORT_SYMBOL_GPL(iwl_read_targ_mem);
 
 int _iwl_write_targ_mem_dwords(struct iwl_trans *trans, u32 addr,
-                               void *buf, int dwords)
+                               const void *buf, int dwords)
 {
         unsigned long flags;
         int offs, result = 0;
-        u32 *vals = buf;
+        const u32 *vals = buf;
 
         spin_lock_irqsave(&trans->reg_lock, flags);
         if (likely(iwl_grab_nic_access(trans))) {
diff --git a/drivers/net/wireless/iwlwifi/iwl-io.h b/drivers/net/wireless/iwlwifi/iwl-io.h
index 50d3819739d..e1aa69f66de 100644
--- a/drivers/net/wireless/iwlwifi/iwl-io.h
+++ b/drivers/net/wireless/iwlwifi/iwl-io.h
@@ -87,7 +87,7 @@ void _iwl_read_targ_mem_dwords(struct iwl_trans *trans, u32 addr,
         } while (0)
 
 int _iwl_write_targ_mem_dwords(struct iwl_trans *trans, u32 addr,
-                               void *buf, int dwords);
+                               const void *buf, int dwords);
 
 u32 iwl_read_targ_mem(struct iwl_trans *trans, u32 addr);
 int iwl_write_targ_mem(struct iwl_trans *trans, u32 addr, u32 val);
diff --git a/drivers/net/wireless/iwlwifi/iwl-prph.h b/drivers/net/wireless/iwlwifi/iwl-prph.h
index 9253ef1dba7..c3a4bb41e53 100644
--- a/drivers/net/wireless/iwlwifi/iwl-prph.h
+++ b/drivers/net/wireless/iwlwifi/iwl-prph.h
@@ -213,6 +213,9 @@
 #define SCD_CONTEXT_QUEUE_OFFSET(x)\
         (SCD_CONTEXT_MEM_LOWER_BOUND + ((x) * 8))
 
+#define SCD_TX_STTS_QUEUE_OFFSET(x)\
+        (SCD_TX_STTS_MEM_LOWER_BOUND + ((x) * 16))
+
 #define SCD_TRANS_TBL_OFFSET_QUEUE(x) \
         ((SCD_TRANS_TBL_MEM_LOWER_BOUND + ((x) * 2)) & 0xfffc)
 
diff --git a/drivers/net/wireless/iwlwifi/iwl-trans.h b/drivers/net/wireless/iwlwifi/iwl-trans.h
index ff115423288..f75ea6d73ff 100644
--- a/drivers/net/wireless/iwlwifi/iwl-trans.h
+++ b/drivers/net/wireless/iwlwifi/iwl-trans.h
@@ -444,6 +444,10 @@ enum iwl_trans_state {
  * @dev_cmd_headroom: room needed for the transport's private use before the
  *      device_cmd for Tx - for internal use only
  *      The user should use iwl_trans_{alloc,free}_tx_cmd.
+ * @rx_mpdu_cmd: MPDU RX command ID, must be assigned by opmode before
+ *      starting the firmware, used for tracing
+ * @rx_mpdu_cmd_hdr_size: used for tracing, amount of data before the
+ *      start of the 802.11 header in the @rx_mpdu_cmd
  */
 struct iwl_trans {
         const struct iwl_trans_ops *ops;
@@ -457,6 +461,8 @@ struct iwl_trans {
         u32 hw_id;
         char hw_id_str[52];
 
+        u8 rx_mpdu_cmd, rx_mpdu_cmd_hdr_size;
+
         bool pm_support;
 
         wait_queue_head_t wait_command_queue;
@@ -516,6 +522,8 @@ static inline int iwl_trans_start_fw(struct iwl_trans *trans,
 {
         might_sleep();
 
+        WARN_ON_ONCE(!trans->rx_mpdu_cmd);
+
         return trans->ops->start_fw(trans, fw);
 }
 
diff --git a/drivers/net/wireless/iwlwifi/pcie/rx.c b/drivers/net/wireless/iwlwifi/pcie/rx.c
index 17c8e5d8268..137af4c46a6 100644
--- a/drivers/net/wireless/iwlwifi/pcie/rx.c
+++ b/drivers/net/wireless/iwlwifi/pcie/rx.c
@@ -411,7 +411,8 @@ static void iwl_rx_handle_rxbuf(struct iwl_trans *trans,
 
                 len = le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK;
                 len += sizeof(u32); /* account for status word */
-                trace_iwlwifi_dev_rx(trans->dev, pkt, len);
+                trace_iwlwifi_dev_rx(trans->dev, trans, pkt, len);
+                trace_iwlwifi_dev_rx_data(trans->dev, trans, pkt, len);
 
                 /* Reclaim a command buffer only if this packet is a response
                  *   to a (driver-originated) command.
diff --git a/drivers/net/wireless/iwlwifi/pcie/trans.c b/drivers/net/wireless/iwlwifi/pcie/trans.c
index fe0fffd0430..f95d88df777 100644
--- a/drivers/net/wireless/iwlwifi/pcie/trans.c
+++ b/drivers/net/wireless/iwlwifi/pcie/trans.c
@@ -300,7 +300,7 @@ static void iwl_trans_pcie_queue_stuck_timer(unsigned long data)
         struct iwl_trans_pcie *trans_pcie = txq->trans_pcie;
         struct iwl_trans *trans = iwl_trans_pcie_get_trans(trans_pcie);
         u32 scd_sram_addr = trans_pcie->scd_base_addr +
-                SCD_TX_STTS_MEM_LOWER_BOUND + (16 * txq->q.id);
+                                SCD_TX_STTS_QUEUE_OFFSET(txq->q.id);
         u8 buf[16];
         int i;
 
@@ -1385,11 +1385,13 @@ static int iwl_trans_pcie_tx(struct iwl_trans *trans, struct sk_buff *skb,
         dma_sync_single_for_device(trans->dev, txcmd_phys, firstlen,
                                    DMA_BIDIRECTIONAL);
 
-        trace_iwlwifi_dev_tx(trans->dev,
+        trace_iwlwifi_dev_tx(trans->dev, skb,
                              &txq->tfds[txq->q.write_ptr],
                              sizeof(struct iwl_tfd),
                              &dev_cmd->hdr, firstlen,
                              skb->data + hdr_len, secondlen);
+        trace_iwlwifi_dev_tx_data(trans->dev, skb,
+                                  skb->data + hdr_len, secondlen);
 
         /* start timer if queue currently empty */
         if (txq->need_update && q->read_ptr == q->write_ptr &&
@@ -1514,14 +1516,13 @@ static void iwl_trans_pcie_reclaim(struct iwl_trans *trans, int txq_id, int ssn,
         struct iwl_tx_queue *txq = &trans_pcie->txq[txq_id];
         /* n_bd is usually 256 => n_bd - 1 = 0xff */
         int tfd_num = ssn & (txq->q.n_bd - 1);
-        int freed = 0;
 
         spin_lock(&txq->lock);
 
         if (txq->q.read_ptr != tfd_num) {
                 IWL_DEBUG_TX_REPLY(trans, "[Q %d] %d -> %d (%d)\n",
                                    txq_id, txq->q.read_ptr, tfd_num, ssn);
-                freed = iwl_tx_queue_reclaim(trans, txq_id, tfd_num, skbs);
+                iwl_tx_queue_reclaim(trans, txq_id, tfd_num, skbs);
                 if (iwl_queue_space(&txq->q) > txq->q.low_mark)
                         iwl_wake_queue(trans, txq);
         }
diff --git a/drivers/net/wireless/iwlwifi/pcie/tx.c b/drivers/net/wireless/iwlwifi/pcie/tx.c
index 105e3af3c62..db3efbb84d9 100644
--- a/drivers/net/wireless/iwlwifi/pcie/tx.c
+++ b/drivers/net/wireless/iwlwifi/pcie/tx.c
@@ -480,21 +480,20 @@ void iwl_trans_pcie_txq_enable(struct iwl_trans *trans, int txq_id, int fifo,
 void iwl_trans_pcie_txq_disable(struct iwl_trans *trans, int txq_id)
 {
         struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
-        u16 rd_ptr, wr_ptr;
-        int n_bd = trans_pcie->txq[txq_id].q.n_bd;
+        u32 stts_addr = trans_pcie->scd_base_addr +
+                        SCD_TX_STTS_QUEUE_OFFSET(txq_id);
+        static const u32 zero_val[4] = {};
 
         if (!test_and_clear_bit(txq_id, trans_pcie->queue_used)) {
                 WARN_ONCE(1, "queue %d not used", txq_id);
                 return;
         }
 
-        rd_ptr = iwl_read_prph(trans, SCD_QUEUE_RDPTR(txq_id)) & (n_bd - 1);
-        wr_ptr = iwl_read_prph(trans, SCD_QUEUE_WRPTR(txq_id));
+        iwl_txq_set_inactive(trans, txq_id);
 
-        WARN_ONCE(rd_ptr != wr_ptr, "queue %d isn't empty: [%d,%d]",
-                  txq_id, rd_ptr, wr_ptr);
+        _iwl_write_targ_mem_dwords(trans, stts_addr,
+                                   zero_val, ARRAY_SIZE(zero_val));
 
-        iwl_txq_set_inactive(trans, txq_id);
         IWL_DEBUG_TX_QUEUES(trans, "Deactivate queue %d\n", txq_id);
 }
 
@@ -549,7 +548,10 @@ static int iwl_enqueue_hcmd(struct iwl_trans *trans, struct iwl_host_cmd *cmd)
          * allocated into separate TFDs, then we will need to
          * increase the size of the buffers.
          */
-        if (WARN_ON(copy_size > TFD_MAX_PAYLOAD_SIZE))
+        if (WARN(copy_size > TFD_MAX_PAYLOAD_SIZE,
+                 "Command %s (%#x) is too large (%d bytes)\n",
+                 trans_pcie_get_cmd_string(trans_pcie, cmd->id),
+                 cmd->id, copy_size))
                 return -EINVAL;
 
         spin_lock_bh(&txq->lock);