X-Git-Url: https://jxself.org/git/?a=blobdiff_plain;f=carlfw%2Fsrc%2Fwlan.c;h=9eb336a267eee7c4858d1e057e18358cede4b7c8;hb=6476369c2c6d4ba487408cb5daff8df0480d6b4a;hp=947652486205e9092689327a08b5000e3bc56c63;hpb=0c5091c6bc2a036c1eb3272db0768ecb84559671;p=carl9170fw.git diff --git a/carlfw/src/wlan.c b/carlfw/src/wlan.c index 9476524..9eb336a 100644 --- a/carlfw/src/wlan.c +++ b/carlfw/src/wlan.c @@ -31,19 +31,46 @@ #include "printf.h" #include "rf.h" #include "linux/ieee80211.h" +#include "rom.h" static void wlan_txunstuck(unsigned int queue) { set_wlan_txq_dma_addr(queue, ((uint32_t) fw.wlan.tx_queue[queue].head) | 1); - wlan_trigger(BIT(queue)); } +#ifdef CONFIG_CARL9170FW_DMA_QUEUE_BUMP static void wlan_txupdate(unsigned int queue) { set_wlan_txq_dma_addr(queue, ((uint32_t) fw.wlan.tx_queue[queue].head)); - wlan_trigger(BIT(queue)); } +static void wlan_dma_bump(unsigned int qidx) +{ + unsigned int offset = qidx; + uint32_t status, trigger; + + status = get(AR9170_MAC_REG_DMA_STATUS) >> 12; + trigger = get(AR9170_MAC_REG_DMA_TRIGGER) >> 12; + + while (offset != 0) { + status >>= 4; + trigger >>= 4; + offset--; + } + + status &= 0xf; + trigger &= 0xf; + + if ((trigger == 0xa) && (status == 0x8)) { + DBG("UNSTUCK"); + wlan_txunstuck(qidx); + } else { + DBG("UPDATE"); + wlan_txupdate(qidx); + } +} +#endif /* CONFIG_CARL9170FW_DMA_QUEUE_BUMP */ + #ifdef CONFIG_CARL9170FW_DEBUG static void wlan_dump_queue(unsigned int qidx) { @@ -184,13 +211,48 @@ static bool wlan_tx_consume_retry(struct carl9170_tx_superframe *super) return true; } +static inline u16 get_tid(struct ieee80211_hdr *hdr) +{ + return (ieee80211_get_qos_ctl(hdr))[0] & IEEE80211_QOS_CTL_TID_MASK; +} + +/* This function will only work on uint32_t-aligned pointers! */ +static inline bool compare_ether_address(const void *_d0, const void *_d1) +{ + const uint32_t *d0 = _d0; + const uint32_t *d1 = _d1; + + /* BUG_ON((unsigned long)d0 & 3 || (unsigned long)d1 & 3)) */ + return !((d0[0] ^ d1[0]) | (unsigned short)(d0[1] ^ d1[1])); +} + +#ifdef CONFIG_CARL9170FW_TX_AMPDU +static void wlan_tx_ampdu(struct carl9170_tx_superframe *super) +{ + unsigned int qidx = super->s.queue; + struct carl9170_tx_superframe *ht_prev = fw.wlan.ampdu_prev[qidx]; + + if (!super->f.hdr.mac.ampdu) { + fw.wlan.ampdu_prev[qidx] = NULL; + + if (ht_prev) + ht_prev->f.hdr.mac.ba_end = 1; + } else { + fw.wlan.ampdu_prev[qidx] = super; + + if (ht_prev && (get_tid(&super->f.data.i3e) != get_tid(&ht_prev->f.data.i3e) || + !compare_ether_address(super->f.data.i3e.addr1, ht_prev->f.data.i3e.addr1))) + ht_prev->f.hdr.mac.ba_end = 1; + else + super->f.hdr.mac.ba_end = 0; + } +} +#endif /* CONFIG_CARL9170FW_TX_AMPDU */ + /* for all tries */ static void __wlan_tx(struct dma_desc *desc) { struct carl9170_tx_superframe *super = get_super(desc); -#ifdef CONFIG_CARL9170FW_NORMAL_TX_RX - unsigned int queue = super->s.queue; -#endif /* CONFIG_CARL9170FW_LOOPBACK */ if (unlikely(super->s.fill_in_tsf)) { struct ieee80211_mgmt *mgmt = (void *) &super->f.data.i3e; @@ -209,6 +271,10 @@ static void __wlan_tx(struct dma_desc *desc) read_tsf(tsf); } +#ifdef CONFIG_CARL9170FW_TX_AMPDU + wlan_tx_ampdu(super); +#endif /* CONFIG_CARL9170FW_TX_AMPDU */ + #if (defined CONFIG_CARL9170FW_LOOPBACK) || (defined CONFIG_CARL9170FW_DISCARD) wlan_tx_complete(super, true); unhide_super(desc); @@ -226,8 +292,7 @@ static void __wlan_tx(struct dma_desc *desc) # endif /* CONFIG_CARL9170FW_DEBUG && CONFIG_CARL9170FW_PSM */ /* insert desc into the right queue */ - dma_put(&fw.wlan.tx_queue[queue], desc); - wlan_trigger(BIT(queue)); + dma_put(&fw.wlan.tx_queue[super->s.queue], desc); #endif /* CONFIG_CARL9170FW_LOOPBACK */ } @@ -386,6 +451,7 @@ static void handle_tx_completion(void) for_each_desc(desc, &fw.wlan.tx_delay[i]) _wlan_tx(desc); #endif /* CONFIG_CARL9170FW_DELAYED_TX */ + wlan_trigger(BIT(i)); } } @@ -398,13 +464,6 @@ void __hot wlan_tx(struct dma_desc *desc) super->s.cnt = 1; hide_super(desc); -#ifdef CONFIG_CARL9170FW_DELAYED_TX - if (!queue_empty(&fw.wlan.tx_queue[super->s.queue])) { - dma_put(&fw.wlan.tx_delay[super->s.queue], desc); - return; - } -#endif /* CONFIG_CARL9170FW_DELAYED_TX */ - #ifdef CONFIG_CARL9170FW_CAB_QUEUE if (unlikely(super->s.cab)) { fw.wlan.cab_queue_len[super->s.vif_id]++; @@ -413,7 +472,15 @@ void __hot wlan_tx(struct dma_desc *desc) } #endif /* CONFIG_CARL9170FW_CAB_QUEUE */ +#ifdef CONFIG_CARL9170FW_DELAYED_TX + if (!queue_empty(&fw.wlan.tx_queue[super->s.queue])) { + dma_put(&fw.wlan.tx_delay[super->s.queue], desc); + return; + } +#endif /* CONFIG_CARL9170FW_DELAYED_TX */ + _wlan_tx(desc); + wlan_trigger(BIT(super->s.queue)); } #ifdef CONFIG_CARL9170FW_HANDLE_BACK_REQ @@ -494,19 +561,13 @@ static struct carl9170_bar_ctx *wlan_get_bar_cache_buffer(void) return tmp; } -static void handle_bar(struct dma_desc *desc) +static void handle_bar(struct dma_desc *desc, struct ieee80211_hdr *hdr, + unsigned int len, unsigned int mac_err) { - struct ieee80211_hdr *hdr; struct ieee80211_bar *bar; struct carl9170_bar_ctx *ctx; - hdr = ar9170_get_rx_i3e(desc); - - /* check if this is a BAR for us */ - if (likely(!ieee80211_is_back_req(hdr->frame_control))) - return ; - - if (unlikely(ar9170_get_rx_macstatus_error(desc))) { + if (unlikely(mac_err)) { /* * This check does a number of things: * 1. checks if the frame is in good nick @@ -515,8 +576,7 @@ static void handle_bar(struct dma_desc *desc) return ; } - if (unlikely(ar9170_get_rx_mpdu_len(desc) < - sizeof(struct ieee80211_bar))) { + if (unlikely(len < (sizeof(struct ieee80211_bar) + FCS_LEN))) { /* * Sneaky, corrupted BARs... but not with us! */ @@ -570,26 +630,161 @@ static void wlan_check_rx_overrun(void) } } -static void handle_rx(void) +#ifdef CONFIG_CARL9170FW_WOL +static void wlan_rx_wol(struct ieee80211_hdr *hdr, unsigned int len) { - struct dma_desc *desc; + const unsigned char *data, *end, *mac; + unsigned int found = 0; - for_each_desc_not_bits(desc, &fw.wlan.rx_queue, AR9170_OWN_BITS_HW) { - if (unlikely(desc->totalLen < 26 || - desc->totalLen > CONFIG_CARL9170FW_RX_FRAME_LEN)) { - /* - * This frame is too damaged to do anything - * useful with it. - */ - dma_reclaim(&fw.wlan.rx_queue, desc); - _wlan_trigger(AR9170_DMA_TRIGGER_RXQ); - } else { + /* + * LIMITATION: + * We can only scan the first AR9170_BLOCK_SIZE [=~320] bytes + * for MAGIC patterns! + */ + + /* + * TODO: + * Currently, the MAGIC MAC Address is fixed to the EEPROM default. + * It's possible to make it fully configurable, e.g: + * + * mac = (const unsigned char *) AR9170_MAC_REG_MAC_ADDR_L; + * But this will clash with the driver's suspend path, because it + * needs to reset the registers. + */ + mac = rom.sys.mac_address; + + data = (u8 *)((unsigned long)hdr + ieee80211_hdrlen(hdr->frame_control)); + end = (u8 *)((unsigned long)hdr + len); + + /* + * scan for standard WOL Magic frame + * + * "A physical WakeOnLAN (Magic Packet) will look like this: + * --------------------------------------------------------------- + * | Synchronization Stream | Target MAC | Password (optional) | + * | 6 octets | 96 octets | 0, 4 or 6 | + * --------------------------------------------------------------- + * + * The Synchronization Stream is defined as 6 bytes of FFh. + * The Target MAC block contains 16 duplications of the IEEEaddress + * of the target, with no breaks or interruptions. + * + * The Password field is optional, but if present, contains either + * 4 bytes or 6 bytes. The WakeOnLAN dissector was implemented to + * dissect the password, if present, according to the command-line + * format that ether-wake uses, therefore, if a 4-byte password is + * present, it will be dissected as an IPv4 address and if a 6-byte + * password is present, it will be dissected as an Ethernet address. + * + * + */ + + while (data < end) { + if (found >= 6) { + if (*data == mac[found % 6]) + found++; + else + found = 0; + } + + /* previous check might reset found counter */ + if (found < 6) { + if (*data == 0xff) + found++; + else + found = 0; + } + + if (found == (6 + 16 * 6)) { + fw.suspend_mode = CARL9170_AWAKE_HOST; + return; + } + + data++; + } + + return; +} +#endif /* CONFIG_CARL9170FW_WOL */ + +static unsigned int wlan_rx_filter(struct dma_desc *desc) +{ + struct ieee80211_hdr *hdr; + unsigned int data_len; + unsigned int rx_filter; + unsigned int mac_err; + + data_len = ar9170_get_rx_mpdu_len(desc); + mac_err = ar9170_get_rx_macstatus_error(desc); + +#define AR9170_RX_ERROR_BAD (AR9170_RX_ERROR_FCS | AR9170_RX_ERROR_PLCP) + + if (unlikely(data_len < (4 + 6 + FCS_LEN) || + desc->totalLen > CONFIG_CARL9170FW_RX_FRAME_LEN) || + mac_err & AR9170_RX_ERROR_BAD) { + /* + * This frame is too damaged to do anything + * useful with it. + */ + + return CARL9170_RX_FILTER_BAD; + } + + rx_filter = 0; + if (mac_err & AR9170_RX_ERROR_WRONG_RA) + rx_filter |= CARL9170_RX_FILTER_OTHER_RA; + + if (mac_err & AR9170_RX_ERROR_DECRYPT) + rx_filter |= CARL9170_RX_FILTER_DECRY_FAIL; + + hdr = ar9170_get_rx_i3e(desc); + if (likely(ieee80211_is_data(hdr->frame_control))) { + rx_filter |= CARL9170_RX_FILTER_DATA; + } else if (ieee80211_is_ctl(hdr->frame_control)) { + switch (le16_to_cpu(hdr->frame_control) & IEEE80211_FCTL_STYPE) { + case IEEE80211_STYPE_BACK_REQ: #ifdef CONFIG_CARL9170FW_HANDLE_BACK_REQ - handle_bar(desc); + handle_bar(desc, hdr, data_len, mac_err); #endif /* CONFIG_CARL9170FW_HANDLE_BACK_REQ */ + /* fallthrough */ + rx_filter |= CARL9170_RX_FILTER_CTL_BACKR; + break; + case IEEE80211_STYPE_PSPOLL: + rx_filter |= CARL9170_RX_FILTER_CTL_PSPOLL; + break; + default: + rx_filter |= CARL9170_RX_FILTER_CTL_OTHER; + break; + } + } else { + /* ieee80211_is_mgmt */ + rx_filter |= CARL9170_RX_FILTER_MGMT; + } +#ifdef CONFIG_CARL9170FW_WOL + if (unlikely(fw.suspend_mode == CARL9170_HOST_SUSPENDED)) { + if (rx_filter & CARL9170_RX_FILTER_DATA) + wlan_rx_wol(hdr, min(data_len, + (unsigned int)AR9170_BLOCK_SIZE)); + } +#endif /* CONFIG_CARL9170FW_WOL */ + +#undef AR9170_RX_ERROR_BAD + + return rx_filter; +} + +static void handle_rx(void) +{ + struct dma_desc *desc; + + for_each_desc_not_bits(desc, &fw.wlan.rx_queue, AR9170_OWN_BITS_HW) { + if (!(wlan_rx_filter(desc) & fw.wlan.rx_filter)) { dma_put(&fw.pta.up_queue, desc); up_trigger(); + } else { + dma_reclaim(&fw.wlan.rx_queue, desc); + _wlan_trigger(AR9170_DMA_TRIGGER_RXQ); } } } @@ -622,6 +817,7 @@ void wlan_cab_flush_queue(const unsigned int vif) /* ready to roll! */ _wlan_tx(desc); + wlan_trigger(BIT(super->s.queue)); } } @@ -784,6 +980,9 @@ void handle_wlan(void) } \ } while (0) + intr |= fw.wlan.soft_int; + fw.wlan.soft_int = 0; + HANDLER(intr, AR9170_MAC_INT_PRETBTT, handle_pretbtt); HANDLER(intr, AR9170_MAC_INT_ATIM, handle_atim); @@ -809,32 +1008,6 @@ void handle_wlan(void) #undef HANDLER } -static void wlan_dma_bump(unsigned int qidx) -{ - unsigned int offset = qidx; - uint32_t status, trigger; - - status = get(AR9170_MAC_REG_DMA_STATUS) >> 12; - trigger = get(AR9170_MAC_REG_DMA_TRIGGER) >> 12; - - while (offset != 0) { - status >>= 4; - trigger >>= 4; - offset--; - } - - status &= 0xf; - trigger &= 0xf; - - if ((trigger == 0xa) && (status == 0x8)) { - DBG("UNSTUCK"); - wlan_txunstuck(qidx); - } else { - DBG("UPDATE"); - wlan_txupdate(qidx); - } -} - static void wlan_check_hang(void) { struct dma_desc *desc; @@ -878,6 +1051,7 @@ static void wlan_check_hang(void) } #endif /* CONFIG_CARL9170FW_DEBUG */ +#ifdef CONFIG_CARL9170FW_DMA_QUEUE_BUMP if (unlikely(fw.wlan.last_tx_desc_num[i] > 3)) { /* * Hrrm, bump the queue a bit. @@ -885,7 +1059,9 @@ static void wlan_check_hang(void) */ wlan_dma_bump(i); + wlan_trigger(BIT(i)); } +#endif /* CONFIG_CARL9170FW_DMA_QUEUE_BUMP */ } else { /* Nothing stuck */ fw.wlan.last_tx_desc[i] = desc; @@ -911,6 +1087,7 @@ static void wlan_mac_reset(void) uint32_t cam_mode; uint32_t ack_power; uint32_t rts_cts_tpc; + uint32_t rts_cts_rate; unsigned int i; #ifdef CONFIG_CARL9170FW_RADIO_FUNCTIONS @@ -931,6 +1108,7 @@ static void wlan_mac_reset(void) ack_power = get(AR9170_MAC_REG_ACK_TPC); rts_cts_tpc = get(AR9170_MAC_REG_RTS_CTS_TPC); + rts_cts_rate = get(AR9170_MAC_REG_RTS_CTS_RATE); #ifdef CONFIG_CARL9170FW_RADIO_FUNCTIONS /* 0x1c8960 write only */ @@ -972,6 +1150,7 @@ static void wlan_mac_reset(void) set(AR9170_MAC_REG_RTS_CTS_TPC, rts_cts_tpc); set(AR9170_MAC_REG_ACK_TPC, ack_power); + set(AR9170_MAC_REG_RTS_CTS_RATE, rts_cts_rate); #ifdef CONFIG_CARL9170FW_RADIO_FUNCTIONS set(AR9170_PHY_REG_SWITCH_CHAIN_2, rx_BB); @@ -983,17 +1162,24 @@ static void wlan_mac_reset(void) * set(AR9170_PHY_REG_CCA_THRESHOLD, 0x0); */ + /* Reinitialize all WLAN TX DMA queues. */ for (i = 0; i < __AR9170_NUM_TX_QUEUES; i++) { - DBG("Q:%d l:%d h:%p t:%p\n", i, queue_len(&fw.wlan.tx_queue[i]), - fw.wlan.tx_queue[i].head, fw.wlan.tx_queue[i].terminator); + struct dma_desc *iter; - set_wlan_txq_dma_addr(i, (uint32_t) fw.wlan.tx_queue[i].head); + __for_each_desc_bits(iter, &fw.wlan.tx_queue[i], AR9170_OWN_BITS_SW); - if (!queue_empty(&fw.wlan.tx_queue[i])) + set_wlan_txq_dma_addr(i, (uint32_t) iter); + if (!is_terminator(&fw.wlan.tx_queue[i], iter)) wlan_trigger(BIT(i)); + + DBG("Q:%d l:%d h:%p t:%p cu:%p it:%p ct:%x st:%x\n", i, queue_len(&fw.wlan.tx_queue[i]), + fw.wlan.tx_queue[i].head, fw.wlan.tx_queue[i].terminator, + get_wlan_txq_addr(i), iter, iter->ctrl, iter->status); } - handle_rx(); + fw.wlan.soft_int |= AR9170_MAC_INT_RXC | AR9170_MAC_INT_TXC | + AR9170_MAC_INT_RETRY_FAIL; + set(AR9170_MAC_REG_DMA_RXQ_ADDR, (uint32_t) fw.wlan.rx_queue.head); wlan_trigger(AR9170_DMA_TRIGGER_RXQ); }