source: branches/backfire/package/mac80211/patches/550-ath9k_optimize_memory_allocation.patch @ 25206

Last change on this file since 25206 was 25206, checked in by nbd, 6 years ago

ath9k: merge fixes from r25204, r25205

File size: 5.6 KB
  • drivers/net/wireless/ath/ath9k/main.c

    a b static void ath9k_stop(struct ieee80211_ 
    12911291        } else 
    12921292                sc->rx.rxlink = NULL; 
    12931293 
     1294        if (sc->rx.frag) { 
     1295                dev_kfree_skb_any(sc->rx.frag); 
     1296                sc->rx.frag = NULL; 
     1297        } 
     1298 
    12941299        /* disable HAL and put h/w to sleep */ 
    12951300        ath9k_hw_disable(ah); 
    12961301        ath9k_hw_configpcipowersave(ah, 1, 1); 
  • drivers/net/wireless/ath/ath9k/recv.c

    a b static int ath_rx_edma_init(struct ath_s 
    209209        int error = 0, i; 
    210210        u32 size; 
    211211 
    212  
    213         common->rx_bufsize = roundup(IEEE80211_MAX_MPDU_LEN + 
    214                                      ah->caps.rx_status_len, 
    215                                      min(common->cachelsz, (u16)64)); 
    216  
    217212        ath9k_hw_set_rx_bufsize(ah, common->rx_bufsize - 
    218213                                    ah->caps.rx_status_len); 
    219214 
    int ath_rx_init(struct ath_softc *sc, in 
    300295        sc->sc_flags &= ~SC_OP_RXFLUSH; 
    301296        spin_lock_init(&sc->rx.rxbuflock); 
    302297 
     298        common->rx_bufsize = IEEE80211_MAX_MPDU_LEN / 2 + 
     299                             sc->sc_ah->caps.rx_status_len; 
     300 
    303301        if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) { 
    304302                return ath_rx_edma_init(sc, nbufs); 
    305303        } else { 
    306                 common->rx_bufsize = roundup(IEEE80211_MAX_MPDU_LEN, 
    307                                 min(common->cachelsz, (u16)64)); 
    308  
    309304                ath_dbg(common, ATH_DBG_CONFIG, "cachelsz %u rxbufsize %u\n", 
    310305                        common->cachelsz, common->rx_bufsize); 
    311306 
    static bool ath9k_rx_accept(struct ath_c 
    815810        if (rx_stats->rs_datalen > (common->rx_bufsize - rx_status_len)) 
    816811                return false; 
    817812 
    818         /* 
    819          * rs_more indicates chained descriptors which can be used 
    820          * to link buffers together for a sort of scatter-gather 
    821          * operation. 
    822          * reject the frame, we don't support scatter-gather yet and 
    823          * the frame is probably corrupt anyway 
    824          */ 
     813        /* Only use error bits from the last fragment */ 
    825814        if (rx_stats->rs_more) 
    826                 return false; 
     815                return true; 
    827816 
    828817        /* 
    829818         * The rx_stats->rs_status will not be set until the end of the 
    static int ath9k_rx_skb_preprocess(struc 
    981970        if (!ath9k_rx_accept(common, hdr, rx_status, rx_stats, decrypt_error)) 
    982971                return -EINVAL; 
    983972 
     973        /* Only use status info from the last fragment */ 
     974        if (rx_stats->rs_more) 
     975                return 0; 
     976 
    984977        ath9k_process_rssi(common, hw, hdr, rx_stats); 
    985978 
    986979        if (ath9k_process_rate(common, hw, rx_stats, rx_status)) 
    div_comb_done: 
    15821575int ath_rx_tasklet(struct ath_softc *sc, int flush, bool hp) 
    15831576{ 
    15841577        struct ath_buf *bf; 
    1585         struct sk_buff *skb = NULL, *requeue_skb; 
     1578        struct sk_buff *skb = NULL, *requeue_skb, *hdr_skb; 
    15861579        struct ieee80211_rx_status *rxs; 
    15871580        struct ath_hw *ah = sc->sc_ah; 
    15881581        struct ath_common *common = ath9k_hw_common(ah); 
    int ath_rx_tasklet(struct ath_softc *sc, 
    16331626                if (!skb) 
    16341627                        continue; 
    16351628 
    1636                 hdr = (struct ieee80211_hdr *) (skb->data + rx_status_len); 
    1637                 rxs =  IEEE80211_SKB_RXCB(skb); 
     1629                /* 
     1630                 * Take frame header from the first fragment and RX status from 
     1631                 * the last one. 
     1632                 */ 
     1633                if (sc->rx.frag) 
     1634                        hdr_skb = sc->rx.frag; 
     1635                else 
     1636                        hdr_skb = skb; 
     1637 
     1638                hdr = (struct ieee80211_hdr *) (hdr_skb->data + rx_status_len); 
     1639                rxs = IEEE80211_SKB_RXCB(hdr_skb); 
    16381640 
    16391641                ath_debug_stat_rx(sc, &rs); 
    16401642 
    int ath_rx_tasklet(struct ath_softc *sc, 
    16431645                 * chain it back at the queue without processing it. 
    16441646                 */ 
    16451647                if (flush) 
    1646                         goto requeue; 
     1648                        goto requeue_drop_frag; 
    16471649 
    16481650                retval = ath9k_rx_skb_preprocess(common, hw, hdr, &rs, 
    16491651                                                 rxs, &decrypt_error); 
    16501652                if (retval) 
    1651                         goto requeue; 
     1653                        goto requeue_drop_frag; 
    16521654 
    16531655                rxs->mactime = (tsf & ~0xffffffffULL) | rs.rs_tstamp; 
    16541656                if (rs.rs_tstamp > tsf_lower && 
    int ath_rx_tasklet(struct ath_softc *sc, 
    16681670                 * skb and put it at the tail of the sc->rx.rxbuf list for 
    16691671                 * processing. */ 
    16701672                if (!requeue_skb) 
    1671                         goto requeue; 
     1673                        goto requeue_drop_frag; 
    16721674 
    16731675                /* Unmap the frame */ 
    16741676                dma_unmap_single(sc->dev, bf->bf_buf_addr, 
    int ath_rx_tasklet(struct ath_softc *sc, 
    16791681                if (ah->caps.rx_status_len) 
    16801682                        skb_pull(skb, ah->caps.rx_status_len); 
    16811683 
    1682                 ath9k_rx_skb_postprocess(common, skb, &rs, 
    1683                                          rxs, decrypt_error); 
     1684                if (!rs.rs_more) 
     1685                        ath9k_rx_skb_postprocess(common, hdr_skb, &rs, 
     1686                                                 rxs, decrypt_error); 
    16841687 
    16851688                /* We will now give hardware our shiny new allocated skb */ 
    16861689                bf->bf_mpdu = requeue_skb; 
    int ath_rx_tasklet(struct ath_softc *sc, 
    16971700                        break; 
    16981701                } 
    16991702 
     1703                if (rs.rs_more) { 
     1704                        /* 
     1705                         * rs_more indicates chained descriptors which can be 
     1706                         * used to link buffers together for a sort of 
     1707                         * scatter-gather operation. 
     1708                         */ 
     1709                        if (sc->rx.frag) { 
     1710                                /* too many fragments - cannot handle frame */ 
     1711                                dev_kfree_skb_any(sc->rx.frag); 
     1712                                dev_kfree_skb_any(skb); 
     1713                                skb = NULL; 
     1714                        } 
     1715                        sc->rx.frag = skb; 
     1716                        goto requeue; 
     1717                } 
     1718 
     1719                if (sc->rx.frag) { 
     1720                        int space = skb->len - skb_tailroom(hdr_skb); 
     1721 
     1722                        sc->rx.frag = NULL; 
     1723 
     1724                        if (pskb_expand_head(hdr_skb, 0, space, GFP_ATOMIC) < 0) { 
     1725                                dev_kfree_skb(skb); 
     1726                                goto requeue_drop_frag; 
     1727                        } 
     1728 
     1729                        skb_copy_from_linear_data(skb, skb_put(hdr_skb, skb->len), 
     1730                                                  skb->len); 
     1731                        dev_kfree_skb_any(skb); 
     1732                        skb = hdr_skb; 
     1733                } 
     1734 
    17001735                /* 
    17011736                 * change the default rx antenna if rx diversity chooses the 
    17021737                 * other antenna 3 times in a row. 
    int ath_rx_tasklet(struct ath_softc *sc, 
    17221757 
    17231758                ieee80211_rx(hw, skb); 
    17241759 
     1760requeue_drop_frag: 
     1761                if (sc->rx.frag) { 
     1762                        dev_kfree_skb_any(sc->rx.frag); 
     1763                        sc->rx.frag = NULL; 
     1764                } 
    17251765requeue: 
    17261766                if (edma) { 
    17271767                        list_add_tail(&bf->list, &sc->rx.rxbuf); 
  • drivers/net/wireless/ath/ath9k/ath9k.h

    a b struct ath_rx { 
    311311        struct ath_descdma rxdma; 
    312312        struct ath_buf *rx_bufptr; 
    313313        struct ath_rx_edma rx_edma[ATH9K_RX_QUEUE_MAX]; 
     314 
     315        struct sk_buff *frag; 
    314316}; 
    315317 
    316318int ath_startrecv(struct ath_softc *sc); 
Note: See TracBrowser for help on using the repository browser.