#define A_MAX(a, b) ((a) > (b) ? (a) : (b))
 
-#define ASSERT(exp) BUG_ON(!(exp))
-
 #define TSF_TO_TU(_h,_l) \
        ((((u32)(_h)) << 22) | (((u32)(_l)) >> 10))
 
 
 {
        u32 gpio_shift;
 
-       ASSERT(gpio < ah->caps.num_gpio_pins);
+       BUG_ON(gpio >= ah->caps.num_gpio_pins);
 
        gpio_shift = gpio << 1;
 
 
        if ((sizeof(struct ath_desc) % 4) != 0) {
                ath_print(common, ATH_DBG_FATAL,
                          "ath_desc not DWORD aligned\n");
-               ASSERT((sizeof(struct ath_desc) % 4) == 0);
+               BUG_ON((sizeof(struct ath_desc) % 4) != 0);
                error = -ENOMEM;
                goto fail;
        }
                         * descriptor fetch.
                         */
                        while (ATH_DESC_4KB_BOUND_CHECK(bf->bf_daddr)) {
-                               ASSERT((caddr_t) bf->bf_desc <
+                               BUG_ON((caddr_t) bf->bf_desc >=
                                       ((caddr_t) dd->dd_desc +
                                        dd->dd_desc_len));
 
 
 static inline void ath_rc_set_valid_txmask(struct ath_rate_priv *ath_rc_priv,
                                           u8 index, int valid_tx_rate)
 {
-       ASSERT(index <= ath_rc_priv->rate_table_size);
+       BUG_ON(index > ath_rc_priv->rate_table_size);
        ath_rc_priv->valid_rate_index[index] = valid_tx_rate ? 1 : 0;
 }
 
 
        ath_rc_priv->rate_table_size = hi + 1;
        ath_rc_priv->rate_max_phy = 0;
-       ASSERT(ath_rc_priv->rate_table_size <= RATE_TABLE_SIZE);
+       BUG_ON(ath_rc_priv->rate_table_size > RATE_TABLE_SIZE);
 
        for (i = 0, k = 0; i < WLAN_RC_PHY_MAX; i++) {
                for (j = 0; j < ath_rc_priv->valid_phy_ratecnt[i]; j++) {
 
                ath_rc_priv->rate_max_phy = ath_rc_priv->valid_phy_rateidx[i][j-1];
        }
-       ASSERT(ath_rc_priv->rate_table_size <= RATE_TABLE_SIZE);
-       ASSERT(k <= RATE_TABLE_SIZE);
+       BUG_ON(ath_rc_priv->rate_table_size > RATE_TABLE_SIZE);
+       BUG_ON(k > RATE_TABLE_SIZE);
 
        ath_rc_priv->max_valid_rate = k;
        ath_rc_sort_validrates(rate_table, ath_rc_priv);
 
 
        /* virtual addr of the beginning of the buffer. */
        skb = bf->bf_mpdu;
-       ASSERT(skb != NULL);
+       BUG_ON(skb == NULL);
        ds->ds_vdata = skb->data;
 
        /* setup rx descriptors. The rx.bufsize here tells the harware
 
 {
        struct ath_txq *txq = &sc->tx.txq[tid->ac->qnum];
 
-       ASSERT(tid->paused > 0);
+       BUG_ON(tid->paused <= 0);
        spin_lock_bh(&txq->axq_lock);
 
        tid->paused--;
        struct list_head bf_head;
        INIT_LIST_HEAD(&bf_head);
 
-       ASSERT(tid->paused > 0);
+       BUG_ON(tid->paused <= 0);
        spin_lock_bh(&txq->axq_lock);
 
        tid->paused--;
 
        while (!list_empty(&tid->buf_q)) {
                bf = list_first_entry(&tid->buf_q, struct ath_buf, list);
-               ASSERT(!bf_isretried(bf));
+               BUG_ON(bf_isretried(bf));
                list_move_tail(&bf->list, &bf_head);
                ath_tx_send_ht_normal(sc, txq, tid, &bf_head);
        }
        index  = ATH_BA_INDEX(tid->seq_start, bf->bf_seqno);
        cindex = (tid->baw_head + index) & (ATH_TID_MAX_BUFS - 1);
 
-       ASSERT(tid->tx_buf[cindex] == NULL);
+       BUG_ON(tid->tx_buf[cindex] != NULL);
        tid->tx_buf[cindex] = bf;
 
        if (index >= ((tid->baw_tail - tid->baw_head) &
                        else
                                INIT_LIST_HEAD(&bf_head);
                } else {
-                       ASSERT(!list_empty(bf_q));
+                       BUG_ON(list_empty(bf_q));
                        list_move_tail(&bf->list, &bf_head);
                }
 
                return 0;
        }
 
-       ASSERT(sc->tx.txq[qnum].axq_qnum == qnum);
+       BUG_ON(sc->tx.txq[qnum].axq_qnum != qnum);
 
        ath9k_hw_get_txq_props(ah, qnum, &qi);
        qi.tqi_aifs = qinfo->tqi_aifs;