X-Git-Url: https://jxself.org/git/?a=blobdiff_plain;ds=sidebyside;f=carlfw%2Fsrc%2Fwlan.c;h=c4cf0b3dfb0062b9957e706ab1ea76f1ea32a3f3;hb=19e4d682fca010ef72e0a304335910f670c2268a;hp=8c8c7a84c05a1d60cb510f29290be070cbed4c8b;hpb=9b5dbf90780e07b9372192ea20d8e86005670d83;p=carl9170fw.git diff --git a/carlfw/src/wlan.c b/carlfw/src/wlan.c index 8c8c7a8..c4cf0b3 100644 --- a/carlfw/src/wlan.c +++ b/carlfw/src/wlan.c @@ -31,18 +31,17 @@ #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) @@ -212,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; @@ -237,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); @@ -254,16 +292,28 @@ 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 */ } +static void wlan_assign_seq(struct ieee80211_hdr *hdr, unsigned int vif) +{ + hdr->seq_ctrl &= cpu_to_le16(~IEEE80211_SCTL_SEQ); + hdr->seq_ctrl |= cpu_to_le16(fw.wlan.sequence[vif]); + + if (!(hdr->seq_ctrl & cpu_to_le16(IEEE80211_SCTL_FRAG))) + fw.wlan.sequence[vif] += 0x10; +} + /* prepares frame for the first transmission */ static void _wlan_tx(struct dma_desc *desc) { struct carl9170_tx_superframe *super = get_super(desc); + if (unlikely(super->s.assign_seq)) { + wlan_assign_seq(&super->f.data.i3e, super->s.vif_id); + } + if (unlikely(super->s.ampdu_commit_density)) { set(AR9170_MAC_REG_AMPDU_DENSITY, MOD_VAL(AR9170_MAC_AMPDU_DENSITY, @@ -414,6 +464,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)); } } @@ -426,13 +477,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]++; @@ -441,7 +485,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 @@ -591,6 +643,83 @@ static void wlan_check_rx_overrun(void) } } +#ifdef CONFIG_CARL9170FW_WOL +static void wlan_rx_wol(struct ieee80211_hdr *hdr, unsigned int len) +{ + const unsigned char *data, *end, *mac; + unsigned int found = 0; + + /* + * 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; @@ -645,6 +774,14 @@ static unsigned int wlan_rx_filter(struct dma_desc *desc) 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; @@ -693,6 +830,7 @@ void wlan_cab_flush_queue(const unsigned int vif) /* ready to roll! */ _wlan_tx(desc); + wlan_trigger(BIT(super->s.queue)); } } @@ -717,7 +855,7 @@ static uint8_t *beacon_find_ie(uint8_t ie, void *addr, return NULL; } -void wlan_cab_modify_dtim_beacon(const unsigned int vif, +void wlan_modify_beacon(const unsigned int vif, const unsigned int addr, const unsigned int len) { uint8_t *_ie; @@ -742,6 +880,15 @@ void wlan_cab_modify_dtim_beacon(const unsigned int vif, ie->bitmap_ctrl |= 0x1; } } + + /* + * Ideally, the sequence number should be assigned by the TX arbiter + * hardware. But AFAIK that's not possible, so we have to go for the + * next best thing and write it into the beacon fifo during the open + * beacon update window. + */ + + wlan_assign_seq((struct ieee80211_hdr *)addr, vif); } #endif /* CONFIG_CARL9170FW_CAB_QUEUE */ @@ -752,8 +899,6 @@ static void handle_beacon_config(void) bcn_count = get(AR9170_MAC_REG_BCN_COUNT); send_cmd_to_host(4, CARL9170_RSP_BEACON_CONFIG, 0x00, (uint8_t *) &bcn_count); - - set(AR9170_MAC_REG_BCN_CTRL, AR9170_BCN_CTRL_READY); } static void handle_pretbtt(void) @@ -934,6 +1079,7 @@ static void wlan_check_hang(void) */ wlan_dma_bump(i); + wlan_trigger(BIT(i)); } #endif /* CONFIG_CARL9170FW_DMA_QUEUE_BUMP */ } else {