ds                    /* first descriptor */
                );
 
-       memzero(series, sizeof(struct ath9k_11n_rate_series) * 4);
+       memset(series, 0, sizeof(struct ath9k_11n_rate_series) * 4);
        series[0].Tries = 1;
        series[0].Rate = rate;
        series[0].ChSel = sc->sc_tx_chainmask;
 {
        struct ath9k_tx_queue_info qi;
 
-       memzero(&qi, sizeof(qi));
+       memset(&qi, 0, sizeof(qi));
        qi.tqi_aifs = 1;
        qi.tqi_cwmin = 0;
        qi.tqi_cwmax = 0;
        else
                av_opmode = sc->sc_ah->ah_opmode;
 
-       memzero(&conf, sizeof(struct ath_beacon_config));
+       memset(&conf, 0, sizeof(struct ath_beacon_config));
 
        conf.beacon_interval = sc->hw->conf.beacon_int ?
                sc->hw->conf.beacon_int : ATH_DEFAULT_BINTVAL;
                        }
                } while (nexttbtt < tsftu);
 #undef FUDGE
-               memzero(&bs, sizeof(bs));
+               memset(&bs, 0, sizeof(bs));
                bs.bs_intval = intval;
                bs.bs_nexttbtt = nexttbtt;
                bs.bs_dtimperiod = dtimperiod*intval;
 
        for (i = 0; i < rt->rateCount; i++)
                sc->sc_rixmap[rt->info[i].rateCode] = (u8) i;
 
-       memzero(sc->sc_hwmap, sizeof(sc->sc_hwmap));
+       memset(sc->sc_hwmap, 0, sizeof(sc->sc_hwmap));
        for (i = 0; i < 256; i++) {
                u8 ix = rt->rateCodeToIndex[i];
 
 {
        struct ath_chainmask_sel *cm = &an->an_chainmask_sel;
 
-       memzero(cm, sizeof(struct ath_chainmask_sel));
+       memset(cm, 0, sizeof(struct ath_chainmask_sel));
 
        cm->cur_tx_mask = sc->sc_tx_chainmask;
        cm->cur_rx_mask = sc->sc_rx_chainmask;
        if (avp == NULL)
                return -ENOMEM;
 
-       memzero(avp, sizeof(struct ath_vap));
+       memset(avp, 0, sizeof(struct ath_vap));
        avp->av_if_data = if_data;
        /* Set the VAP opmode */
        avp->av_opmode = opmode;
        an = kmalloc(sizeof(struct ath_node), GFP_ATOMIC);
        if (an == NULL)
                return NULL;
-       memzero(an, sizeof(*an));
+       memset(an, 0, sizeof(*an));
 
        an->an_sc = sc;
        memcpy(an->an_addr, addr, ETH_ALEN);
                error = -ENOMEM;
                goto fail2;
        }
-       memzero(bf, bsize);
+       memset(bf, 0, bsize);
        dd->dd_bufptr = bf;
 
        INIT_LIST_HEAD(head);
        pci_free_consistent(sc->pdev,
                dd->dd_desc_len, dd->dd_desc, dd->dd_desc_paddr);
 fail:
-       memzero(dd, sizeof(*dd));
+       memset(dd, 0, sizeof(*dd));
        return error;
 #undef ATH_DESC_4KB_BOUND_CHECK
 #undef ATH_DESC_4KB_BOUND_NUM_SKIPPED
 
        INIT_LIST_HEAD(head);
        kfree(dd->dd_bufptr);
-       memzero(dd, sizeof(*dd));
+       memset(dd, 0, sizeof(*dd));
 }
 
 /*************/
 
 #define TSF_TO_TU(_h,_l) \
        ((((u32)(_h)) << 22) | (((u32)(_l)) >> 10))
 
-/* XXX: remove */
-#define memzero(_buf, _len) memset(_buf, 0, _len)
-
 #define ATH9K_BH_STATUS_INTACT         0
 #define ATH9K_BH_STATUS_CHANGE         1
 
                (_bf)->bf_lastbf = NULL;                        \
                (_bf)->bf_lastfrm = NULL;                       \
                (_bf)->bf_next = NULL;                          \
-               memzero(&((_bf)->bf_state),                     \
+               memset(&((_bf)->bf_state), 0,                   \
                            sizeof(struct ath_buf_state));      \
        } while (0)
 
 
 
                hdr = (struct ieee80211_hdr *)skb->data;
                fc = hdr->frame_control;
-               memzero(&rx_status, sizeof(struct ath_recv_status));
+               memset(&rx_status, 0, sizeof(struct ath_recv_status));
 
                if (ds->ds_rxstat.rs_more) {
                        /*
                } else {
                        /* Ensure the memory is zeroed out (all internal
                         * pointers are null) */
-                       memzero(rxtid->rxbuf, ATH_TID_MAX_BUFS *
+                       memset(rxtid->rxbuf, 0, ATH_TID_MAX_BUFS *
                                sizeof(struct ath_rxbuf));
                        DPRINTF(sc, ATH_DBG_AGGR,
                                "%s: Allocated @%p\n", __func__, rxtid->rxbuf);
 
        /*
         * Setup HAL rate series
         */
-       memzero(series, sizeof(struct ath9k_11n_rate_series) * 4);
+       memset(series, 0, sizeof(struct ath9k_11n_rate_series) * 4);
 
        for (i = 0; i < 4; i++) {
                if (!bf->bf_rcs[i].tries)
                 * Disable multi-rate retry when using RTS/CTS by clearing
                 * series 1, 2 and 3.
                 */
-               memzero(&series[1], sizeof(struct ath9k_11n_rate_series) * 3);
+               memset(&series[1], 0, sizeof(struct ath9k_11n_rate_series) * 3);
        }
 
        /*
                                        ATH_DS_BA_BITMAP(ds),
                                        WME_BA_BMP_SIZE >> 3);
                        } else {
-                               memzero(ba, WME_BA_BMP_SIZE >> 3);
+                               memset(ba, 0, WME_BA_BMP_SIZE >> 3);
 
                                /*
                                 * AR5416 can become deaf/mute when BA
                                        needreset = 1;
                        }
                } else {
-                       memzero(ba, WME_BA_BMP_SIZE >> 3);
+                       memset(ba, 0, WME_BA_BMP_SIZE >> 3);
                }
        }
 
        struct ath9k_tx_queue_info qi;
        int qnum;
 
-       memzero(&qi, sizeof(qi));
+       memset(&qi, 0, sizeof(qi));
        qi.tqi_subtype = subtype;
        qi.tqi_aifs = ATH9K_TXQ_USEDEFAULT;
        qi.tqi_cwmin = ATH9K_TXQ_USEDEFAULT;