Update compat-wireless to 2.6.36-5-spn

chromeos/compat-wireless/drivers/net/wireless/ath/ath9k/main.c

 /*
  * Copyright (c) 2008-2009 Atheros Communications Inc.
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
@@ skipping 252 matching lines @@
         spin_unlock_bh(&sc->sc_pcu_lock);
 
         ath9k_ps_restore(sc);
         return r;
 }
 
 static void ath_paprd_activate(struct ath_softc *sc)
 {
         struct ath_hw *ah = sc->sc_ah;
         struct ath9k_hw_cal_data *caldata = ah->caldata;
+        struct ath_common *common = ath9k_hw_common(ah);
         int chain;
 
         if (!caldata || !caldata->paprd_done)
                 return;
 
         ath9k_ps_wakeup(sc);
         ar9003_paprd_enable(ah, false);
         for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {
-                if (!(ah->caps.tx_chainmask & BIT(chain)))
+                if (!(common->tx_chainmask & BIT(chain)))
                         continue;
 
                 ar9003_paprd_populate_single_table(ah, caldata, chain);
         }
 
         ar9003_paprd_enable(ah, true);
         ath9k_ps_restore(sc);
 }
 
 void ath_paprd_calibrate(struct work_struct *work)
 {
         struct ath_softc *sc = container_of(work, struct ath_softc, paprd_work);
         struct ieee80211_hw *hw = sc->hw;
         struct ath_hw *ah = sc->sc_ah;
         struct ieee80211_hdr *hdr;
         struct sk_buff *skb = NULL;
         struct ieee80211_tx_info *tx_info;
         int band = hw->conf.channel->band;
         struct ieee80211_supported_band *sband = &sc->sbands[band];
         struct ath_tx_control txctl;
         struct ath9k_hw_cal_data *caldata = ah->caldata;
-        int qnum, ftype;
+        struct ath_common *common = ath9k_hw_common(ah);
+        int ftype;
         int chain_ok = 0;
         int chain;
         int len = 1800;
         int time_left;
         int i;
 
         if (!caldata)
                 return;
 
         skb = alloc_skb(len, GFP_KERNEL);
         if (!skb)
                 return;
 
         tx_info = IEEE80211_SKB_CB(skb);
 
         skb_put(skb, len);
         memset(skb->data, 0, len);
         hdr = (struct ieee80211_hdr *)skb->data;
         ftype = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC;
         hdr->frame_control = cpu_to_le16(ftype);
         hdr->duration_id = cpu_to_le16(10);
         memcpy(hdr->addr1, hw->wiphy->perm_addr, ETH_ALEN);
         memcpy(hdr->addr2, hw->wiphy->perm_addr, ETH_ALEN);
         memcpy(hdr->addr3, hw->wiphy->perm_addr, ETH_ALEN);
 
         memset(&txctl, 0, sizeof(txctl));
-        qnum = sc->tx.hwq_map[WME_AC_BE];
-        txctl.txq = &sc->tx.txq[qnum];
+        txctl.txq = sc->tx.txq_map[WME_AC_BE];
 
         ath9k_ps_wakeup(sc);
         ar9003_paprd_init_table(ah);
         for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {
-                if (!(ah->caps.tx_chainmask & BIT(chain)))
+                if (!(common->tx_chainmask & BIT(chain)))
                         continue;
 
                 chain_ok = 0;
                 memset(tx_info, 0, sizeof(*tx_info));
                 tx_info->band = band;
 
                 for (i = 0; i < 4; i++) {
                         tx_info->control.rates[i].idx = sband->n_bitrates - 1;
                         tx_info->control.rates[i].count = 6;
                 }
@@ skipping 197 matching lines @@
         int i;
 
         ath9k_ps_wakeup(sc);
 
         for (i = 0; i < 3; i++) {
                 if (ath9k_hw_check_alive(sc->sc_ah))
                         goto out;
 
                 msleep(1);
         }
-        ath_reset(sc, false);
+        ath_reset(sc, true);
 
 out:
         ath9k_ps_restore(sc);
 }
 
 void ath9k_tasklet(unsigned long data)
 {
         struct ath_softc *sc = (struct ath_softc *)data;
         struct ath_hw *ah = sc->sc_ah;
         struct ath_common *common = ath9k_hw_common(ah);
 
         u32 status = sc->intrstatus;
         u32 rxmask;
 
         ath9k_ps_wakeup(sc);
 
         if (status & ATH9K_INT_FATAL) {
-                ath_reset(sc, false);
+                ath_reset(sc, true);
                 ath9k_ps_restore(sc);
                 return;
         }
 
         spin_lock_bh(&sc->sc_pcu_lock);
 
         if (!ath9k_hw_check_alive(ah))
                 ieee80211_queue_work(sc->hw, &sc->hw_check_work);
 
         if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
@@ skipping 396 matching lines @@
 
         ieee80211_wake_queues(hw);
         spin_unlock_bh(&sc->sc_pcu_lock);
 
         /* Start ANI */
         ath_start_ani(common);
 
         return r;
 }
 
-static int ath_get_hal_qnum(u16 queue, struct ath_softc *sc)
-{
-        int qnum;
-
-        switch (queue) {
-        case 0:
-                qnum = sc->tx.hwq_map[WME_AC_VO];
-                break;
-        case 1:
-                qnum = sc->tx.hwq_map[WME_AC_VI];
-                break;
-        case 2:
-                qnum = sc->tx.hwq_map[WME_AC_BE];
-                break;
-        case 3:
-                qnum = sc->tx.hwq_map[WME_AC_BK];
-                break;
-        default:
-                qnum = sc->tx.hwq_map[WME_AC_BE];
-                break;
-        }
-
-        return qnum;
-}
-
-int ath_get_mac80211_qnum(u32 queue, struct ath_softc *sc)
-{
-        int qnum;
-
-        switch (queue) {
-        case WME_AC_VO:
-                qnum = 0;
-                break;
-        case WME_AC_VI:
-                qnum = 1;
-                break;
-        case WME_AC_BE:
-                qnum = 2;
-                break;
-        case WME_AC_BK:
-                qnum = 3;
-                break;
-        default:
-                qnum = -1;
-                break;
-        }
-
-        return qnum;
-}
-
 /* XXX: Remove me once we don't depend on ath9k_channel for all
  * this redundant data */
 void ath9k_update_ichannel(struct ath_softc *sc, struct ieee80211_hw *hw,
                            struct ath9k_channel *ichan)
 {
         struct ieee80211_channel *chan = hw->conf.channel;
         struct ieee80211_conf *conf = &hw->conf;
 
         ichan->channel = chan->center_freq;
         ichan->chan = chan;
@@ skipping 152 matching lines @@
 static int ath9k_tx(struct ieee80211_hw *hw,
                     struct sk_buff *skb)
 {
         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
         struct ath_wiphy *aphy = hw->priv;
         struct ath_softc *sc = aphy->sc;
         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
         struct ath_tx_control txctl;
         int padpos, padsize;
         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
-        int qnum;
 
         if (aphy->state != ATH_WIPHY_ACTIVE && aphy->state != ATH_WIPHY_SCAN) {
                 ath_print(common, ATH_DBG_XMIT,
                           "ath9k: %s: TX in unexpected wiphy state "
                           "%d\n", wiphy_name(hw->wiphy), aphy->state);
                 goto exit;
         }
 
         if (sc->ps_enabled) {
                 /*
@@ skipping 52 matching lines @@
         /* Add the padding after the header if this is not already done */
         padpos = ath9k_cmn_padpos(hdr->frame_control);
         padsize = padpos & 3;
         if (padsize && skb->len>padpos) {
                 if (skb_headroom(skb) < padsize)
                         return -1;
                 skb_push(skb, padsize);
                 memmove(skb->data, skb->data + padsize, padpos);
         }
 
-        qnum = ath_get_hal_qnum(skb_get_queue_mapping(skb), sc);
-        txctl.txq = &sc->tx.txq[qnum];
+        txctl.txq = sc->tx.txq_map[skb_get_queue_mapping(skb)];
 
         ath_print(common, ATH_DBG_XMIT, "transmitting packet, skb: %p\n", skb);
 
         if (ath_tx_start(hw, skb, &txctl) != 0) {
                 ath_print(common, ATH_DBG_XMIT, "TX failed\n");
                 goto exit;
         }
 
         return 0;
 exit:
@@ skipping 433 matching lines @@
 
         return 0;
 }
 
 static int ath9k_conf_tx(struct ieee80211_hw *hw, u16 queue,
                          const struct ieee80211_tx_queue_params *params)
 {
         struct ath_wiphy *aphy = hw->priv;
         struct ath_softc *sc = aphy->sc;
         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
+        struct ath_txq *txq;
         struct ath9k_tx_queue_info qi;
-        int ret = 0, qnum;
+        int ret = 0;
 
         if (queue >= WME_NUM_AC)
                 return 0;
 
+        txq = sc->tx.txq_map[queue];
+
         mutex_lock(&sc->mutex);
 
         memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));
 
         qi.tqi_aifs = params->aifs;
         qi.tqi_cwmin = params->cw_min;
         qi.tqi_cwmax = params->cw_max;
         qi.tqi_burstTime = params->txop;
-        qnum = ath_get_hal_qnum(queue, sc);
 
         ath_print(common, ATH_DBG_CONFIG,
                   "Configure tx [queue/halq] [%d/%d],  "
                   "aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
-                  queue, qnum, params->aifs, params->cw_min,
+                  queue, txq->axq_qnum, params->aifs, params->cw_min,
                   params->cw_max, params->txop);
 
-        ret = ath_txq_update(sc, qnum, &qi);
+        ret = ath_txq_update(sc, txq->axq_qnum, &qi);
         if (ret)
                 ath_print(common, ATH_DBG_FATAL, "TXQ Update failed\n");
 
         if (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC)
-                if ((qnum == sc->tx.hwq_map[WME_AC_BE]) && !ret)
+                if (queue == WME_AC_BE && !ret)
                         ath_beaconq_config(sc);
 
         mutex_unlock(&sc->mutex);
 
         return ret;
 }
 
 static int ath9k_set_key(struct ieee80211_hw *hw,
                          enum set_key_cmd cmd,
                          struct ieee80211_vif *vif,
@@ skipping 321 matching lines @@
         .get_tsf            = ath9k_get_tsf,
         .set_tsf            = ath9k_set_tsf,
         .reset_tsf          = ath9k_reset_tsf,
         .ampdu_action       = ath9k_ampdu_action,
         .get_survey         = ath9k_get_survey,
         .sw_scan_start      = ath9k_sw_scan_start,
         .sw_scan_complete   = ath9k_sw_scan_complete,
         .rfkill_poll        = ath9k_rfkill_poll_state,
         .set_coverage_class = ath9k_set_coverage_class,
 };