iwlwifi: Fix 52 rate report in rx status

This patch fixes reporting rate in RX packets in 52 band.
The rate was updated from CCK rate index instead of OFDM rate 6M
Most of the patch is collateral clean up

Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

1 files changed, 217 insertions, 33 deletions

diff --git a/drivers/net/wireless/iwlwifi/iwl-4965.c b/drivers/net/wireless/iwlwifi/iwl-4965.c
index a9c30bcb65b8..8b9c419e094e 100644
--- a/drivers/net/wireless/iwlwifi/iwl-4965.c
+++ b/drivers/net/wireless/iwlwifi/iwl-4965.c
@@ -122,6 +122,35 @@ static u8 is_single_stream(struct iwl4965_priv *priv)
         return 0;
 }
 
+int iwl4965_hwrate_to_plcp_idx(u32 rate_n_flags)
+{
+        int idx = 0;
+
+        /* 4965 HT rate format */
+        if (rate_n_flags & RATE_MCS_HT_MSK) {
+                idx = (rate_n_flags & 0xff);
+
+                if (idx >= IWL_RATE_MIMO_6M_PLCP)
+                        idx = idx - IWL_RATE_MIMO_6M_PLCP;
+
+                idx += IWL_FIRST_OFDM_RATE;
+                /* skip 9M not supported in ht*/
+                if (idx >= IWL_RATE_9M_INDEX)
+                        idx += 1;
+                if ((idx >= IWL_FIRST_OFDM_RATE) && (idx <= IWL_LAST_OFDM_RATE))
+                        return idx;
+
+        /* 4965 legacy rate format, search for match in table */
+        } else {
+                for (idx = 0; idx < ARRAY_SIZE(iwl4965_rates); idx++)
+                        if (iwl4965_rates[idx].plcp == (rate_n_flags & 0xFF))
+                                return idx;
+        }
+
+        return -1;
+}
+
+
 /*
  * Determine how many receiver/antenna chains to use.
  * More provides better reception via diversity.  Fewer saves power.
@@ -3523,6 +3552,160 @@ static void iwl4965_update_ps_mode(struct iwl4965_priv *priv, u16 ps_bit, u8 *ad
                 }
         }
 }
+#ifdef CONFIG_IWL4965_DEBUG
+
+/**
+ * iwl4965_dbg_report_frame - dump frame to syslog during debug sessions
+ *
+ * You may hack this function to show different aspects of received frames,
+ * including selective frame dumps.
+ * group100 parameter selects whether to show 1 out of 100 good frames.
+ *
+ * TODO:  This was originally written for 3945, need to audit for
+ *        proper operation with 4965.
+ */
+static void iwl4965_dbg_report_frame(struct iwl4965_priv *priv,
+                      struct iwl4965_rx_packet *pkt,
+                      struct ieee80211_hdr *header, int group100)
+{
+        u32 to_us;
+        u32 print_summary = 0;
+        u32 print_dump = 0;     /* set to 1 to dump all frames' contents */
+        u32 hundred = 0;
+        u32 dataframe = 0;
+        u16 fc;
+        u16 seq_ctl;
+        u16 channel;
+        u16 phy_flags;
+        int rate_sym;
+        u16 length;
+        u16 status;
+        u16 bcn_tmr;
+        u32 tsf_low;
+        u64 tsf;
+        u8 rssi;
+        u8 agc;
+        u16 sig_avg;
+        u16 noise_diff;
+        struct iwl4965_rx_frame_stats *rx_stats = IWL_RX_STATS(pkt);
+        struct iwl4965_rx_frame_hdr *rx_hdr = IWL_RX_HDR(pkt);
+        struct iwl4965_rx_frame_end *rx_end = IWL_RX_END(pkt);
+        u8 *data = IWL_RX_DATA(pkt);
+
+        if (likely(!(iwl4965_debug_level & IWL_DL_RX)))
+                return;
+
+        /* MAC header */
+        fc = le16_to_cpu(header->frame_control);
+        seq_ctl = le16_to_cpu(header->seq_ctrl);
+
+        /* metadata */
+        channel = le16_to_cpu(rx_hdr->channel);
+        phy_flags = le16_to_cpu(rx_hdr->phy_flags);
+        rate_sym = rx_hdr->rate;
+        length = le16_to_cpu(rx_hdr->len);
+
+        /* end-of-frame status and timestamp */
+        status = le32_to_cpu(rx_end->status);
+        bcn_tmr = le32_to_cpu(rx_end->beacon_timestamp);
+        tsf_low = le64_to_cpu(rx_end->timestamp) & 0x0ffffffff;
+        tsf = le64_to_cpu(rx_end->timestamp);
+
+        /* signal statistics */
+        rssi = rx_stats->rssi;
+        agc = rx_stats->agc;
+        sig_avg = le16_to_cpu(rx_stats->sig_avg);
+        noise_diff = le16_to_cpu(rx_stats->noise_diff);
+
+        to_us = !compare_ether_addr(header->addr1, priv->mac_addr);
+
+        /* if data frame is to us and all is good,
+         *   (optionally) print summary for only 1 out of every 100 */
+        if (to_us && (fc & ~IEEE80211_FCTL_PROTECTED) ==
+            (IEEE80211_FCTL_FROMDS | IEEE80211_FTYPE_DATA)) {
+                dataframe = 1;
+                if (!group100)
+                        print_summary = 1;      /* print each frame */
+                else if (priv->framecnt_to_us < 100) {
+                        priv->framecnt_to_us++;
+                        print_summary = 0;
+                } else {
+                        priv->framecnt_to_us = 0;
+                        print_summary = 1;
+                        hundred = 1;
+                }
+        } else {
+                /* print summary for all other frames */
+                print_summary = 1;
+        }
+
+        if (print_summary) {
+                char *title;
+                int rate_idx;
+                u32 bitrate;
+
+                if (hundred)
+                        title = "100Frames";
+                else if (fc & IEEE80211_FCTL_RETRY)
+                        title = "Retry";
+                else if (ieee80211_is_assoc_response(fc))
+                        title = "AscRsp";
+                else if (ieee80211_is_reassoc_response(fc))
+                        title = "RasRsp";
+                else if (ieee80211_is_probe_response(fc)) {
+                        title = "PrbRsp";
+                        print_dump = 1; /* dump frame contents */
+                } else if (ieee80211_is_beacon(fc)) {
+                        title = "Beacon";
+                        print_dump = 1; /* dump frame contents */
+                } else if (ieee80211_is_atim(fc))
+                        title = "ATIM";
+                else if (ieee80211_is_auth(fc))
+                        title = "Auth";
+                else if (ieee80211_is_deauth(fc))
+                        title = "DeAuth";
+                else if (ieee80211_is_disassoc(fc))
+                        title = "DisAssoc";
+                else
+                        title = "Frame";
+
+                rate_idx = iwl4965_hwrate_to_plcp_idx(rate_sym);
+                if (unlikely(rate_idx == -1))
+                        bitrate = 0;
+                else
+                        bitrate = iwl4965_rates[rate_idx].ieee / 2;
+
+                /* print frame summary.
+                 * MAC addresses show just the last byte (for brevity),
+                 *    but you can hack it to show more, if you'd like to. */
+                if (dataframe)
+                        IWL_DEBUG_RX("%s: mhd=0x%04x, dst=0x%02x, "
+                                     "len=%u, rssi=%d, chnl=%d, rate=%u, \n",
+                                     title, fc, header->addr1[5],
+                                     length, rssi, channel, bitrate);
+                else {
+                        /* src/dst addresses assume managed mode */
+                        IWL_DEBUG_RX("%s: 0x%04x, dst=0x%02x, "
+                                     "src=0x%02x, rssi=%u, tim=%lu usec, "
+                                     "phy=0x%02x, chnl=%d\n",
+                                     title, fc, header->addr1[5],
+                                     header->addr3[5], rssi,
+                                     tsf_low - priv->scan_start_tsf,
+                                     phy_flags, channel);
+                }
+        }
+        if (print_dump)
+                iwl4965_print_hex_dump(IWL_DL_RX, data, length);
+}
+#else
+static inline void iwl4965_dbg_report_frame(struct iwl4965_priv *priv,
+                                            struct iwl4965_rx_packet *pkt,
+                                            struct ieee80211_hdr *header,
+                                            int group100)
+{
+}
+#endif
+
 
 #define IWL_DELAY_NEXT_SCAN_AFTER_ASSOC (HZ*6)
 
@@ -3531,6 +3714,8 @@ static void iwl4965_update_ps_mode(struct iwl4965_priv *priv, u16 ps_bit, u8 *ad
 static void iwl4965_rx_reply_rx(struct iwl4965_priv *priv,
                                 struct iwl4965_rx_mem_buffer *rxb)
 {
+        struct ieee80211_hdr *header;
+        struct ieee80211_rx_status rx_status;
         struct iwl4965_rx_packet *pkt = (void *)rxb->skb->data;
         /* Use phy data (Rx signal strength, etc.) contained within
          *   this rx packet for legacy frames,
@@ -3541,27 +3726,29 @@ static void iwl4965_rx_reply_rx(struct iwl4965_priv *priv,
                 (struct iwl4965_rx_phy_res *)&priv->last_phy_res[1];
         __le32 *rx_end;
         unsigned int len = 0;
-        struct ieee80211_hdr *header;
         u16 fc;
-        struct ieee80211_rx_status stats = {
-                .mactime = le64_to_cpu(rx_start->timestamp),
-                .freq = ieee80211chan2mhz(le16_to_cpu(rx_start->channel)),
-                .band =
-                        (rx_start->phy_flags & RX_RES_PHY_FLAGS_BAND_24_MSK) ?
-                        IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ,
-                .antenna = 0,
-                .rate_idx = iwl4965_rate_index_from_plcp(
-                                le32_to_cpu(rx_start->rate_n_flags)),
-                .flag = 0,
-        };
         u8 network_packet;
 
+        rx_status.mactime = le64_to_cpu(rx_start->timestamp);
+        rx_status.freq = ieee80211chan2mhz(le16_to_cpu(rx_start->channel));
+        rx_status.band = (rx_start->phy_flags & RX_RES_PHY_FLAGS_BAND_24_MSK) ?
+                                IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
+        rx_status.rate_idx = iwl4965_hwrate_to_plcp_idx(
+                                        le32_to_cpu(rx_start->rate_n_flags));
+
+        if (rx_status.band == IEEE80211_BAND_5GHZ)
+                rx_status.rate_idx -= IWL_FIRST_OFDM_RATE;
+
+        rx_status.antenna = 0;
+        rx_status.flag = 0;
+
         if ((unlikely(rx_start->cfg_phy_cnt > 20))) {
                 IWL_DEBUG_DROP
                         ("dsp size out of range [0,20]: "
                          "%d/n", rx_start->cfg_phy_cnt);
                 return;
         }
+
         if (!include_phy) {
                 if (priv->last_phy_res[0])
                         rx_start = (struct iwl4965_rx_phy_res *)
@@ -3580,7 +3767,7 @@ static void iwl4965_rx_reply_rx(struct iwl4965_priv *priv,
                                                   + rx_start->cfg_phy_cnt);
 
                 len = le16_to_cpu(rx_start->byte_count);
-                rx_end = (__le32 *) (pkt->u.raw + rx_start->cfg_phy_cnt +
+                rx_end = (__le32 *)(pkt->u.raw + rx_start->cfg_phy_cnt +
                                   sizeof(struct iwl4965_rx_phy_res) + len);
         } else {
                 struct iwl4965_rx_mpdu_res_start *amsdu =
@@ -3603,7 +3790,7 @@ static void iwl4965_rx_reply_rx(struct iwl4965_priv *priv,
         priv->ucode_beacon_time = le32_to_cpu(rx_start->beacon_time_stamp);
 
         /* Find max signal strength (dBm) among 3 antenna/receiver chains */
-        stats.ssi = iwl4965_calc_rssi(rx_start);
+        rx_status.ssi = iwl4965_calc_rssi(rx_start);
 
         /* Meaningful noise values are available only from beacon statistics,
          *   which are gathered only when associated, and indicate noise
@@ -3611,32 +3798,29 @@ static void iwl4965_rx_reply_rx(struct iwl4965_priv *priv,
          * Ignore these noise values while scanning (other channels) */
         if (iwl4965_is_associated(priv) &&
             !test_bit(STATUS_SCANNING, &priv->status)) {
-                stats.noise = priv->last_rx_noise;
-                stats.signal = iwl4965_calc_sig_qual(stats.ssi, stats.noise);
+                rx_status.noise = priv->last_rx_noise;
+                rx_status.signal = iwl4965_calc_sig_qual(rx_status.ssi,
+                                                         rx_status.noise);
         } else {
-                stats.noise = IWL_NOISE_MEAS_NOT_AVAILABLE;
-                stats.signal = iwl4965_calc_sig_qual(stats.ssi, 0);
+                rx_status.noise = IWL_NOISE_MEAS_NOT_AVAILABLE;
+                rx_status.signal = iwl4965_calc_sig_qual(rx_status.ssi, 0);
         }
 
         /* Reset beacon noise level if not associated. */
         if (!iwl4965_is_associated(priv))
                 priv->last_rx_noise = IWL_NOISE_MEAS_NOT_AVAILABLE;
 
-#ifdef CONFIG_IWL4965_DEBUG
-        /* TODO:  Parts of iwl4965_report_frame are broken for 4965 */
-        if (iwl4965_debug_level & (IWL_DL_RX))
-                /* Set "1" to report good data frames in groups of 100 */
-                iwl4965_report_frame(priv, pkt, header, 1);
-
-        if (iwl4965_debug_level & (IWL_DL_RX | IWL_DL_STATS))
-        IWL_DEBUG_RX("Rssi %d, noise %d, qual %d, TSF %lu\n",
-                stats.ssi, stats.noise, stats.signal,
-                 (long unsigned int)le64_to_cpu(rx_start->timestamp));
-#endif
+        /* Set "1" to report good data frames in groups of 100 */
+        /* FIXME: need to optimze the call: */
+        iwl4965_dbg_report_frame(priv, pkt, header, 1);
+
+        IWL_DEBUG_STATS_LIMIT("Rssi %d, noise %d, qual %d, TSF %llu\n",
+                              rx_status.ssi, rx_status.noise, rx_status.signal,
+                              rx_status.mactime);
 
         network_packet = iwl4965_is_network_packet(priv, header);
         if (network_packet) {
-                priv->last_rx_rssi = stats.ssi;
+                priv->last_rx_rssi = rx_status.ssi;
                 priv->last_beacon_time =  priv->ucode_beacon_time;
                 priv->last_tsf = le64_to_cpu(rx_start->timestamp);
         }
@@ -3739,7 +3923,7 @@ static void iwl4965_rx_reply_rx(struct iwl4965_priv *priv,
                                 return;
                         }
                 }
-                iwl4965_handle_data_packet(priv, 0, include_phy, rxb, &stats);
+                iwl4965_handle_data_packet(priv, 0, include_phy, rxb, &rx_status);
                 break;
 
         case IEEE80211_FTYPE_CTL:
@@ -3748,7 +3932,7 @@ static void iwl4965_rx_reply_rx(struct iwl4965_priv *priv,
                 case IEEE80211_STYPE_BACK_REQ:
                         IWL_DEBUG_HT("IEEE80211_STYPE_BACK_REQ arrived\n");
                         iwl4965_handle_data_packet(priv, 0, include_phy,
-                                                rxb, &stats);
+                                                rxb, &rx_status);
                         break;
                 default:
                         break;
@@ -3778,7 +3962,7 @@ static void iwl4965_rx_reply_rx(struct iwl4965_priv *priv,
                                        print_mac(mac3, header->addr3));
                 else
                         iwl4965_handle_data_packet(priv, 1, include_phy, rxb,
-                                                   &stats);
+                                                   &rx_status);
                 break;
         }
         default: