2 * Copyright (c) 2013 Qualcomm Atheros, Inc.
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
9 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
10 * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
11 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
12 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
13 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
14 * PERFORMANCE OF THIS SOFTWARE.
21 #include "ah_internal.h"
23 #include "ar9300/ar9300.h"
24 #include "ar9300/ar9300reg.h"
25 #include "ar9300/ar9300phy.h"
26 #include "ar9300/ar9300desc.h"
28 #define TU_TO_USEC(_tu) ((_tu) << 10)
29 #define ONE_EIGHTH_TU_TO_USEC(_tu8) ((_tu8) << 7)
32 * Update Tx FIFO trigger level.
34 * Set b_inc_trig_level to TRUE to increase the trigger level.
35 * Set b_inc_trig_level to FALSE to decrease the trigger level.
37 * Returns TRUE if the trigger level was updated
40 ar9300_update_tx_trig_level(struct ath_hal *ah, HAL_BOOL b_inc_trig_level)
42 struct ath_hal_9300 *ahp = AH9300(ah);
43 u_int32_t txcfg, cur_level, new_level;
46 if (AH9300(ah)->ah_tx_trig_level >= MAX_TX_FIFO_THRESHOLD &&
53 * Disable interrupts while futzing with the fifo level.
55 omask = ar9300_set_interrupts(ah, ahp->ah_mask_reg &~ HAL_INT_GLOBAL, 0);
57 txcfg = OS_REG_READ(ah, AR_TXCFG);
58 cur_level = MS(txcfg, AR_FTRIG);
59 new_level = cur_level;
61 if (b_inc_trig_level) { /* increase the trigger level */
62 if (cur_level < MAX_TX_FIFO_THRESHOLD) {
65 } else if (cur_level > MIN_TX_FIFO_THRESHOLD) {
69 if (new_level != cur_level) {
70 /* Update the trigger level */
72 AR_TXCFG, (txcfg &~ AR_FTRIG) | SM(new_level, AR_FTRIG));
75 /* re-enable chip interrupts */
76 ar9300_set_interrupts(ah, omask, 0);
78 AH9300(ah)->ah_tx_trig_level = new_level;
80 return (new_level != cur_level);
84 * Returns the value of Tx Trigger Level
87 ar9300_get_tx_trig_level(struct ath_hal *ah)
89 return (AH9300(ah)->ah_tx_trig_level);
93 * Set the properties of the tx queue with the parameters
97 ar9300_set_tx_queue_props(struct ath_hal *ah, int q, const HAL_TXQ_INFO *q_info)
99 struct ath_hal_9300 *ahp = AH9300(ah);
100 HAL_CAPABILITIES *p_cap = &AH_PRIVATE(ah)->ah_caps;
102 if (q >= p_cap->halTotalQueues) {
103 HALDEBUG(ah, HAL_DEBUG_QUEUE, "%s: invalid queue num %u\n", __func__, q);
106 return ath_hal_setTxQProps(ah, &ahp->ah_txq[q], q_info);
110 * Return the properties for the specified tx queue.
113 ar9300_get_tx_queue_props(struct ath_hal *ah, int q, HAL_TXQ_INFO *q_info)
115 struct ath_hal_9300 *ahp = AH9300(ah);
116 HAL_CAPABILITIES *p_cap = &AH_PRIVATE(ah)->ah_caps;
119 if (q >= p_cap->halTotalQueues) {
120 HALDEBUG(ah, HAL_DEBUG_QUEUE, "%s: invalid queue num %u\n", __func__, q);
123 return ath_hal_getTxQProps(ah, q_info, &ahp->ah_txq[q]);
127 AH_TX_QUEUE_MINUS_OFFSET_BEACON = 1,
128 AH_TX_QUEUE_MINUS_OFFSET_CAB = 2,
129 AH_TX_QUEUE_MINUS_OFFSET_UAPSD = 3,
130 AH_TX_QUEUE_MINUS_OFFSET_PAPRD = 4,
134 * Allocate and initialize a tx DCU/QCU combination.
137 ar9300_setup_tx_queue(struct ath_hal *ah, HAL_TX_QUEUE type,
138 const HAL_TXQ_INFO *q_info)
140 struct ath_hal_9300 *ahp = AH9300(ah);
141 HAL_TX_QUEUE_INFO *qi;
142 HAL_CAPABILITIES *p_cap = &AH_PRIVATE(ah)->ah_caps;
145 /* XXX move queue assignment to driver */
147 case HAL_TX_QUEUE_BEACON:
148 /* highest priority */
149 q = p_cap->halTotalQueues - AH_TX_QUEUE_MINUS_OFFSET_BEACON;
151 case HAL_TX_QUEUE_CAB:
152 /* next highest priority */
153 q = p_cap->halTotalQueues - AH_TX_QUEUE_MINUS_OFFSET_CAB;
155 case HAL_TX_QUEUE_UAPSD:
156 q = p_cap->halTotalQueues - AH_TX_QUEUE_MINUS_OFFSET_UAPSD;
158 case HAL_TX_QUEUE_PAPRD:
159 q = p_cap->halTotalQueues - AH_TX_QUEUE_MINUS_OFFSET_PAPRD;
161 case HAL_TX_QUEUE_DATA:
163 * don't infringe on top 4 queues, reserved for:
164 * beacon, CAB, UAPSD, PAPRD
167 q < p_cap->halTotalQueues - AH_TX_QUEUE_MINUS_OFFSET_PAPRD;
170 if (ahp->ah_txq[q].tqi_type == HAL_TX_QUEUE_INACTIVE) {
174 if (q == p_cap->halTotalQueues - 3) {
175 HALDEBUG(ah, HAL_DEBUG_QUEUE,
176 "%s: no available tx queue\n", __func__);
181 HALDEBUG(ah, HAL_DEBUG_QUEUE,
182 "%s: bad tx queue type %u\n", __func__, type);
186 HALDEBUG(ah, HAL_DEBUG_QUEUE, "%s: queue %u\n", __func__, q);
188 qi = &ahp->ah_txq[q];
189 if (qi->tqi_type != HAL_TX_QUEUE_INACTIVE) {
190 HALDEBUG(ah, HAL_DEBUG_QUEUE,
191 "%s: tx queue %u already active\n", __func__, q);
195 OS_MEMZERO(qi, sizeof(HAL_TX_QUEUE_INFO));
198 if (q_info == AH_NULL) {
199 /* by default enable OK+ERR+DESC+URN interrupts */
200 qi->tqi_qflags = HAL_TXQ_TXOKINT_ENABLE
201 | HAL_TXQ_TXERRINT_ENABLE
202 | HAL_TXQ_TXDESCINT_ENABLE
203 | HAL_TXQ_TXURNINT_ENABLE;
204 qi->tqi_aifs = INIT_AIFS;
205 qi->tqi_cwmin = HAL_TXQ_USEDEFAULT; /* NB: do at reset */
206 qi->tqi_cwmax = INIT_CWMAX;
207 qi->tqi_shretry = INIT_SH_RETRY;
208 qi->tqi_lgretry = INIT_LG_RETRY;
209 qi->tqi_physCompBuf = 0;
211 qi->tqi_physCompBuf = q_info->tqi_compBuf;
212 (void) ar9300_set_tx_queue_props(ah, q, q_info);
214 /* NB: must be followed by ar9300_reset_tx_queue */
219 * Update the h/w interrupt registers to reflect a tx q's configuration.
222 set_tx_q_interrupts(struct ath_hal *ah, HAL_TX_QUEUE_INFO *qi)
224 struct ath_hal_9300 *ahp = AH9300(ah);
226 HALDEBUG(ah, HAL_DEBUG_INTERRUPT,
227 "%s: tx ok 0x%x err 0x%x eol 0x%x urn 0x%x\n",
229 ahp->ah_tx_ok_interrupt_mask,
230 ahp->ah_tx_err_interrupt_mask,
231 ahp->ah_tx_eol_interrupt_mask,
232 ahp->ah_tx_urn_interrupt_mask);
234 OS_REG_WRITE(ah, AR_IMR_S0,
235 SM(ahp->ah_tx_ok_interrupt_mask, AR_IMR_S0_QCU_TXOK));
236 OS_REG_WRITE(ah, AR_IMR_S1,
237 SM(ahp->ah_tx_err_interrupt_mask, AR_IMR_S1_QCU_TXERR)
238 | SM(ahp->ah_tx_eol_interrupt_mask, AR_IMR_S1_QCU_TXEOL));
240 AR_IMR_S2, AR_IMR_S2_QCU_TXURN, ahp->ah_tx_urn_interrupt_mask);
241 ahp->ah_mask2Reg = OS_REG_READ(ah, AR_IMR_S2);
245 * Free a tx DCU/QCU combination.
248 ar9300_release_tx_queue(struct ath_hal *ah, u_int q)
250 struct ath_hal_9300 *ahp = AH9300(ah);
251 HAL_CAPABILITIES *p_cap = &AH_PRIVATE(ah)->ah_caps;
252 HAL_TX_QUEUE_INFO *qi;
254 if (q >= p_cap->halTotalQueues) {
255 HALDEBUG(ah, HAL_DEBUG_QUEUE, "%s: invalid queue num %u\n", __func__, q);
259 qi = &ahp->ah_txq[q];
260 if (qi->tqi_type == HAL_TX_QUEUE_INACTIVE) {
261 HALDEBUG(ah, HAL_DEBUG_QUEUE, "%s: inactive queue %u\n", __func__, q);
265 HALDEBUG(ah, HAL_DEBUG_QUEUE, "%s: release queue %u\n", __func__, q);
267 qi->tqi_type = HAL_TX_QUEUE_INACTIVE;
268 ahp->ah_tx_ok_interrupt_mask &= ~(1 << q);
269 ahp->ah_tx_err_interrupt_mask &= ~(1 << q);
270 ahp->ah_tx_eol_interrupt_mask &= ~(1 << q);
271 ahp->ah_tx_urn_interrupt_mask &= ~(1 << q);
272 set_tx_q_interrupts(ah, qi);
278 * Set the retry, aifs, cwmin/max, ready_time regs for specified queue
280 * phw_channel has been set to point to the current channel
283 ar9300_reset_tx_queue(struct ath_hal *ah, u_int q)
285 struct ath_hal_9300 *ahp = AH9300(ah);
286 // struct ath_hal_private *ap = AH_PRIVATE(ah);
287 HAL_CAPABILITIES *p_cap = &AH_PRIVATE(ah)->ah_caps;
288 const struct ieee80211_channel *chan = AH_PRIVATE(ah)->ah_curchan;
289 HAL_TX_QUEUE_INFO *qi;
290 u_int32_t cw_min, chan_cw_min, value;
291 uint32_t qmisc, dmisc;
293 if (q >= p_cap->halTotalQueues) {
294 HALDEBUG(ah, HAL_DEBUG_QUEUE, "%s: invalid queue num %u\n", __func__, q);
298 qi = &ahp->ah_txq[q];
299 if (qi->tqi_type == HAL_TX_QUEUE_INACTIVE) {
300 HALDEBUG(ah, HAL_DEBUG_QUEUE, "%s: inactive queue %u\n", __func__, q);
301 return AH_TRUE; /* XXX??? */
304 HALDEBUG(ah, HAL_DEBUG_QUEUE, "%s: reset queue %u\n", __func__, q);
306 if (qi->tqi_cwmin == HAL_TXQ_USEDEFAULT) {
308 * Select cwmin according to channel type.
309 * NB: chan can be NULL during attach
311 if (chan && IEEE80211_IS_CHAN_B(chan)) {
312 chan_cw_min = INIT_CWMIN_11B;
314 chan_cw_min = INIT_CWMIN;
316 /* make sure that the CWmin is of the form (2^n - 1) */
317 for (cw_min = 1; cw_min < chan_cw_min; cw_min = (cw_min << 1) | 1) {}
319 cw_min = qi->tqi_cwmin;
322 /* set cw_min/Max and AIFS values */
323 if (q > 3 || (!AH9300(ah)->ah_fccaifs))
324 /* values should not be overwritten if domain is FCC and manual rate
325 less than 24Mb is set, this check is making sure this */
327 OS_REG_WRITE(ah, AR_DLCL_IFS(q), SM(cw_min, AR_D_LCL_IFS_CWMIN)
328 | SM(qi->tqi_cwmax, AR_D_LCL_IFS_CWMAX)
329 | SM(qi->tqi_aifs, AR_D_LCL_IFS_AIFS));
332 /* Set retry limit values */
333 OS_REG_WRITE(ah, AR_DRETRY_LIMIT(q),
334 SM(INIT_SSH_RETRY, AR_D_RETRY_LIMIT_STA_SH) |
335 SM(INIT_SLG_RETRY, AR_D_RETRY_LIMIT_STA_LG) |
336 SM(qi->tqi_shretry, AR_D_RETRY_LIMIT_FR_SH));
338 /* enable early termination on the QCU */
339 qmisc = AR_Q_MISC_DCU_EARLY_TERM_REQ;
341 /* enable DCU to wait for next fragment from QCU */
342 if (AR_SREV_WASP(ah) && (AH_PRIVATE((ah))->ah_macRev <= AR_SREV_REVISION_WASP_12)) {
343 /* WAR for EV#85395: Wasp Rx overrun issue - reduces Tx queue backoff
344 * threshold to 1 to avoid Rx overruns - Fixed in Wasp 1.3 */
345 dmisc = AR_D_MISC_CW_BKOFF_EN | AR_D_MISC_FRAG_WAIT_EN | 0x1;
347 dmisc = AR_D_MISC_CW_BKOFF_EN | AR_D_MISC_FRAG_WAIT_EN | 0x2;
350 /* multiqueue support */
351 if (qi->tqi_cbrPeriod) {
354 SM(qi->tqi_cbrPeriod, AR_Q_CBRCFG_INTERVAL) |
355 SM(qi->tqi_cbrOverflowLimit,
356 AR_Q_CBRCFG_OVF_THRESH));
357 qmisc |= AR_Q_MISC_FSP_CBR |
358 (qi->tqi_cbrOverflowLimit ?
359 AR_Q_MISC_CBR_EXP_CNTR_LIMIT_EN : 0);
362 if (qi->tqi_readyTime && (qi->tqi_type != HAL_TX_QUEUE_CAB)) {
363 OS_REG_WRITE(ah, AR_QRDYTIMECFG(q),
364 SM(qi->tqi_readyTime, AR_Q_RDYTIMECFG_DURATION) |
368 OS_REG_WRITE(ah, AR_DCHNTIME(q), SM(qi->tqi_burstTime, AR_D_CHNTIME_DUR) |
369 (qi->tqi_burstTime ? AR_D_CHNTIME_EN : 0));
371 if (qi->tqi_readyTime &&
372 (qi->tqi_qflags & HAL_TXQ_RDYTIME_EXP_POLICY_ENABLE))
373 qmisc |= AR_Q_MISC_RDYTIME_EXP_POLICY;
374 if (qi->tqi_qflags & HAL_TXQ_DBA_GATED)
375 qmisc = (qmisc &~ AR_Q_MISC_FSP) | AR_Q_MISC_FSP_DBA_GATED;
376 if (MS(qmisc, AR_Q_MISC_FSP) != AR_Q_MISC_FSP_ASAP) {
378 * These are meangingful only when not scheduled asap.
380 if (qi->tqi_qflags & HAL_TXQ_CBR_DIS_BEMPTY)
381 qmisc |= AR_Q_MISC_CBR_INCR_DIS0;
383 qmisc &= ~AR_Q_MISC_CBR_INCR_DIS0;
384 if (qi->tqi_qflags & HAL_TXQ_CBR_DIS_QEMPTY)
385 qmisc |= AR_Q_MISC_CBR_INCR_DIS1;
387 qmisc &= ~AR_Q_MISC_CBR_INCR_DIS1;
390 if (qi->tqi_qflags & HAL_TXQ_BACKOFF_DISABLE)
391 dmisc |= AR_D_MISC_POST_FR_BKOFF_DIS;
392 if (qi->tqi_qflags & HAL_TXQ_FRAG_BURST_BACKOFF_ENABLE)
393 dmisc |= AR_D_MISC_FRAG_BKOFF_EN;
394 if (qi->tqi_qflags & HAL_TXQ_ARB_LOCKOUT_GLOBAL)
395 dmisc |= SM(AR_D_MISC_ARB_LOCKOUT_CNTRL_GLOBAL,
396 AR_D_MISC_ARB_LOCKOUT_CNTRL);
397 else if (qi->tqi_qflags & HAL_TXQ_ARB_LOCKOUT_INTRA)
398 dmisc |= SM(AR_D_MISC_ARB_LOCKOUT_CNTRL_INTRA_FR,
399 AR_D_MISC_ARB_LOCKOUT_CNTRL);
400 if (qi->tqi_qflags & HAL_TXQ_IGNORE_VIRTCOL)
401 dmisc |= SM(AR_D_MISC_VIR_COL_HANDLING_IGNORE,
402 AR_D_MISC_VIR_COL_HANDLING);
403 if (qi->tqi_qflags & HAL_TXQ_SEQNUM_INC_DIS)
404 dmisc |= AR_D_MISC_SEQ_NUM_INCR_DIS;
406 switch (qi->tqi_type) {
407 case HAL_TX_QUEUE_BEACON: /* beacon frames */
408 qmisc |= AR_Q_MISC_FSP_DBA_GATED
409 | AR_Q_MISC_BEACON_USE
410 | AR_Q_MISC_CBR_INCR_DIS1;
412 dmisc |= (AR_D_MISC_ARB_LOCKOUT_CNTRL_GLOBAL <<
413 AR_D_MISC_ARB_LOCKOUT_CNTRL_S)
414 | AR_D_MISC_BEACON_USE
415 | AR_D_MISC_POST_FR_BKOFF_DIS;
416 /* XXX cwmin and cwmax should be 0 for beacon queue */
417 if (AH_PRIVATE(ah)->ah_opmode != HAL_M_IBSS) {
418 OS_REG_WRITE(ah, AR_DLCL_IFS(q), SM(0, AR_D_LCL_IFS_CWMIN)
419 | SM(0, AR_D_LCL_IFS_CWMAX)
420 | SM(qi->tqi_aifs, AR_D_LCL_IFS_AIFS));
423 case HAL_TX_QUEUE_CAB: /* CAB frames */
425 * No longer Enable AR_Q_MISC_RDYTIME_EXP_POLICY,
426 * bug #6079. There is an issue with the CAB Queue
427 * not properly refreshing the Tx descriptor if
428 * the TXE clear setting is used.
430 qmisc |= AR_Q_MISC_FSP_DBA_GATED
431 | AR_Q_MISC_CBR_INCR_DIS1
432 | AR_Q_MISC_CBR_INCR_DIS0;
434 if (qi->tqi_readyTime) {
435 OS_REG_WRITE(ah, AR_QRDYTIMECFG(q),
436 SM(qi->tqi_readyTime, AR_Q_RDYTIMECFG_DURATION) |
440 value = (ahp->ah_beaconInterval * 50 / 100)
441 - ah->ah_config.ah_additional_swba_backoff
442 - ah->ah_config.ah_sw_beacon_response_time
443 + ah->ah_config.ah_dma_beacon_response_time;
445 * XXX Ensure it isn't too low - nothing lower
452 HALDEBUG(ah, HAL_DEBUG_TXQUEUE,
453 "%s: defaulting to rdytime = %d uS\n",
455 OS_REG_WRITE(ah, AR_QRDYTIMECFG(q),
456 SM(TU_TO_USEC(value), AR_Q_RDYTIMECFG_DURATION) |
459 dmisc |= SM(AR_D_MISC_ARB_LOCKOUT_CNTRL_GLOBAL,
460 AR_D_MISC_ARB_LOCKOUT_CNTRL);
462 case HAL_TX_QUEUE_PSPOLL:
464 * We may configure ps_poll QCU to be TIM-gated in the
465 * future; TIM_GATED bit is not enabled currently because
466 * of a hardware problem in Oahu that overshoots the TIM
467 * bitmap in beacon and may find matching associd bit in
468 * non-TIM elements and send PS-poll PS poll processing
469 * will be done in software
471 qmisc |= AR_Q_MISC_CBR_INCR_DIS1;
473 case HAL_TX_QUEUE_UAPSD:
474 dmisc |= AR_D_MISC_POST_FR_BKOFF_DIS;
476 default: /* NB: silence compiler */
480 #ifndef AH_DISABLE_WME
482 * Yes, this is a hack and not the right way to do it, but
483 * it does get the lockout bits and backoff set for the
484 * high-pri WME queues for testing. We need to either extend
485 * the meaning of queue_info->mode, or create something like
486 * queue_info->dcumode.
488 if (qi->tqi_intFlags & HAL_TXQ_USE_LOCKOUT_BKOFF_DIS) {
489 dmisc |= SM(AR_D_MISC_ARB_LOCKOUT_CNTRL_GLOBAL,
490 AR_D_MISC_ARB_LOCKOUT_CNTRL) |
491 AR_D_MISC_POST_FR_BKOFF_DIS;
495 OS_REG_WRITE(ah, AR_Q_DESC_CRCCHK, AR_Q_DESC_CRCCHK_EN);
496 OS_REG_WRITE(ah, AR_QMISC(q), qmisc);
497 OS_REG_WRITE(ah, AR_DMISC(q), dmisc);
500 * Always update the secondary interrupt mask registers - this
501 * could be a new queue getting enabled in a running system or
502 * hw getting re-initialized during a reset!
504 * Since we don't differentiate between tx interrupts corresponding
505 * to individual queues - secondary tx mask regs are always unmasked;
506 * tx interrupts are enabled/disabled for all queues collectively
507 * using the primary mask reg
509 if (qi->tqi_qflags & HAL_TXQ_TXOKINT_ENABLE) {
510 ahp->ah_tx_ok_interrupt_mask |= (1 << q);
512 ahp->ah_tx_ok_interrupt_mask &= ~(1 << q);
514 if (qi->tqi_qflags & HAL_TXQ_TXERRINT_ENABLE) {
515 ahp->ah_tx_err_interrupt_mask |= (1 << q);
517 ahp->ah_tx_err_interrupt_mask &= ~(1 << q);
519 if (qi->tqi_qflags & HAL_TXQ_TXEOLINT_ENABLE) {
520 ahp->ah_tx_eol_interrupt_mask |= (1 << q);
522 ahp->ah_tx_eol_interrupt_mask &= ~(1 << q);
524 if (qi->tqi_qflags & HAL_TXQ_TXURNINT_ENABLE) {
525 ahp->ah_tx_urn_interrupt_mask |= (1 << q);
527 ahp->ah_tx_urn_interrupt_mask &= ~(1 << q);
529 set_tx_q_interrupts(ah, qi);
535 * Get the TXDP for the specified queue
538 ar9300_get_tx_dp(struct ath_hal *ah, u_int q)
540 HALASSERT(q < AH_PRIVATE(ah)->ah_caps.halTotalQueues);
541 return OS_REG_READ(ah, AR_QTXDP(q));
545 * Set the tx_dp for the specified queue
548 ar9300_set_tx_dp(struct ath_hal *ah, u_int q, u_int32_t txdp)
550 HALASSERT(q < AH_PRIVATE(ah)->ah_caps.halTotalQueues);
551 HALASSERT(AH9300(ah)->ah_txq[q].tqi_type != HAL_TX_QUEUE_INACTIVE);
552 HALASSERT(txdp != 0);
554 OS_REG_WRITE(ah, AR_QTXDP(q), txdp);
560 * Transmit Enable is read-only now
563 ar9300_start_tx_dma(struct ath_hal *ah, u_int q)
569 * Return the number of pending frames or 0 if the specified
573 ar9300_num_tx_pending(struct ath_hal *ah, u_int q)
577 HALASSERT(q < AH_PRIVATE(ah)->ah_caps.halTotalQueues);
579 npend = OS_REG_READ(ah, AR_QSTS(q)) & AR_Q_STS_PEND_FR_CNT;
582 * Pending frame count (PFC) can momentarily go to zero
583 * while TXE remains asserted. In other words a PFC of
584 * zero is not sufficient to say that the queue has stopped.
586 if (OS_REG_READ(ah, AR_Q_TXE) & (1 << q)) {
587 npend = 1; /* arbitrarily return 1 */
591 if (npend && (AH9300(ah)->ah_txq[q].tqi_type == HAL_TX_QUEUE_CAB)) {
592 if (OS_REG_READ(ah, AR_Q_RDYTIMESHDN) & (1 << q)) {
593 HALDEBUG(ah, HAL_DEBUG_QUEUE, "RTSD on CAB queue\n");
594 /* Clear the ready_time shutdown status bits */
595 OS_REG_WRITE(ah, AR_Q_RDYTIMESHDN, 1 << q);
599 HALASSERT((npend == 0) ||
600 (AH9300(ah)->ah_txq[q].tqi_type != HAL_TX_QUEUE_INACTIVE));
606 * Stop transmit on the specified queue
609 ar9300_stop_tx_dma(struct ath_hal *ah, u_int q, u_int timeout)
611 struct ath_hal_9300 *ahp = AH9300(ah);
614 * If we call abort txdma instead, no need to stop RX.
615 * Otherwise, the RX logic might not be restarted properly.
617 ahp->ah_abort_txdma_norx = AH_FALSE;
620 * Directly call abort. It is better, hardware-wise, to stop all
621 * queues at once than individual ones.
623 return ar9300_abort_tx_dma(ah);
626 #define AH_TX_STOP_DMA_TIMEOUT 4000 /* usec */
627 #define AH_TIME_QUANTUM 100 /* usec */
630 HALASSERT(q < AH_PRIVATE(ah)->ah_caps.hal_total_queues);
632 HALASSERT(AH9300(ah)->ah_txq[q].tqi_type != HAL_TX_QUEUE_INACTIVE);
635 timeout = AH_TX_STOP_DMA_TIMEOUT;
638 OS_REG_WRITE(ah, AR_Q_TXD, 1 << q);
640 for (wait = timeout / AH_TIME_QUANTUM; wait != 0; wait--) {
641 if (ar9300_num_tx_pending(ah, q) == 0) {
644 OS_DELAY(AH_TIME_QUANTUM); /* XXX get actual value */
649 HALDEBUG(ah, HAL_DEBUG_QUEUE,
650 "%s: queue %u DMA did not stop in 100 msec\n", __func__, q);
651 HALDEBUG(ah, HAL_DEBUG_QUEUE,
652 "%s: QSTS 0x%x Q_TXE 0x%x Q_TXD 0x%x Q_CBR 0x%x\n",
654 OS_REG_READ(ah, AR_QSTS(q)),
655 OS_REG_READ(ah, AR_Q_TXE),
656 OS_REG_READ(ah, AR_Q_TXD),
657 OS_REG_READ(ah, AR_QCBRCFG(q)));
658 HALDEBUG(ah, HAL_DEBUG_QUEUE,
659 "%s: Q_MISC 0x%x Q_RDYTIMECFG 0x%x Q_RDYTIMESHDN 0x%x\n",
661 OS_REG_READ(ah, AR_QMISC(q)),
662 OS_REG_READ(ah, AR_QRDYTIMECFG(q)),
663 OS_REG_READ(ah, AR_Q_RDYTIMESHDN));
665 #endif /* AH_DEBUG */
667 /* 2413+ and up can kill packets at the PCU level */
668 if (ar9300_num_tx_pending(ah, q)) {
669 u_int32_t tsf_low, j;
671 HALDEBUG(ah, HAL_DEBUG_QUEUE, "%s: Num of pending TX Frames %d on Q %d\n",
672 __func__, ar9300_num_tx_pending(ah, q), q);
674 /* Kill last PCU Tx Frame */
675 /* TODO - save off and restore current values of Q1/Q2? */
676 for (j = 0; j < 2; j++) {
677 tsf_low = OS_REG_READ(ah, AR_TSF_L32);
678 OS_REG_WRITE(ah, AR_QUIET2, SM(10, AR_QUIET2_QUIET_DUR));
679 OS_REG_WRITE(ah, AR_QUIET_PERIOD, 100);
680 OS_REG_WRITE(ah, AR_NEXT_QUIET_TIMER, tsf_low >> 10);
681 OS_REG_SET_BIT(ah, AR_TIMER_MODE, AR_QUIET_TIMER_EN);
683 if ((OS_REG_READ(ah, AR_TSF_L32) >> 10) == (tsf_low >> 10)) {
687 HALDEBUG(ah, HAL_DEBUG_QUEUE,
688 "%s: TSF have moved while trying to set "
689 "quiet time TSF: 0x%08x\n",
691 /* TSF shouldn't count twice or reg access is taking forever */
695 OS_REG_SET_BIT(ah, AR_DIAG_SW, AR_DIAG_FORCE_CH_IDLE_HIGH);
697 /* Allow the quiet mechanism to do its work */
699 OS_REG_CLR_BIT(ah, AR_TIMER_MODE, AR_QUIET_TIMER_EN);
701 /* Verify all transmit is dead */
702 wait = timeout / AH_TIME_QUANTUM;
703 while (ar9300_num_tx_pending(ah, q)) {
705 HALDEBUG(ah, HAL_DEBUG_TX,
706 "%s: Failed to stop Tx DMA in %d msec "
707 "after killing last frame\n",
708 __func__, timeout / 1000);
711 OS_DELAY(AH_TIME_QUANTUM);
714 OS_REG_CLR_BIT(ah, AR_DIAG_SW, AR_DIAG_FORCE_CH_IDLE_HIGH);
717 OS_REG_WRITE(ah, AR_Q_TXD, 0);
720 #undef AH_TX_STOP_DMA_TIMEOUT
721 #undef AH_TIME_QUANTUM
726 * Really Stop transmit on the specified queue
729 ar9300_stop_tx_dma_indv_que(struct ath_hal *ah, u_int q, u_int timeout)
731 #define AH_TX_STOP_DMA_TIMEOUT 4000 /* usec */
732 #define AH_TIME_QUANTUM 100 /* usec */
735 HALASSERT(q < AH_PRIVATE(ah)->ah_caps.hal_total_queues);
737 HALASSERT(AH9300(ah)->ah_txq[q].tqi_type != HAL_TX_QUEUE_INACTIVE);
740 timeout = AH_TX_STOP_DMA_TIMEOUT;
743 OS_REG_WRITE(ah, AR_Q_TXD, 1 << q);
745 for (wait = timeout / AH_TIME_QUANTUM; wait != 0; wait--) {
746 if (ar9300_num_tx_pending(ah, q) == 0) {
749 OS_DELAY(AH_TIME_QUANTUM); /* XXX get actual value */
754 HALDEBUG(ah, HAL_DEBUG_QUEUE,
755 "%s: queue %u DMA did not stop in 100 msec\n", __func__, q);
756 HALDEBUG(ah, HAL_DEBUG_QUEUE,
757 "%s: QSTS 0x%x Q_TXE 0x%x Q_TXD 0x%x Q_CBR 0x%x\n",
759 OS_REG_READ(ah, AR_QSTS(q)),
760 OS_REG_READ(ah, AR_Q_TXE),
761 OS_REG_READ(ah, AR_Q_TXD),
762 OS_REG_READ(ah, AR_QCBRCFG(q)));
763 HALDEBUG(ah, HAL_DEBUG_QUEUE,
764 "%s: Q_MISC 0x%x Q_RDYTIMECFG 0x%x Q_RDYTIMESHDN 0x%x\n",
766 OS_REG_READ(ah, AR_QMISC(q)),
767 OS_REG_READ(ah, AR_QRDYTIMECFG(q)),
768 OS_REG_READ(ah, AR_Q_RDYTIMESHDN));
770 #endif /* AH_DEBUG */
772 /* 2413+ and up can kill packets at the PCU level */
773 if (ar9300_num_tx_pending(ah, q)) {
774 u_int32_t tsf_low, j;
776 HALDEBUG(ah, HAL_DEBUG_QUEUE, "%s: Num of pending TX Frames %d on Q %d\n",
777 __func__, ar9300_num_tx_pending(ah, q), q);
779 /* Kill last PCU Tx Frame */
780 /* TODO - save off and restore current values of Q1/Q2? */
781 for (j = 0; j < 2; j++) {
782 tsf_low = OS_REG_READ(ah, AR_TSF_L32);
783 OS_REG_WRITE(ah, AR_QUIET2, SM(10, AR_QUIET2_QUIET_DUR));
784 OS_REG_WRITE(ah, AR_QUIET_PERIOD, 100);
785 OS_REG_WRITE(ah, AR_NEXT_QUIET_TIMER, tsf_low >> 10);
786 OS_REG_SET_BIT(ah, AR_TIMER_MODE, AR_QUIET_TIMER_EN);
788 if ((OS_REG_READ(ah, AR_TSF_L32) >> 10) == (tsf_low >> 10)) {
792 HALDEBUG(ah, HAL_DEBUG_QUEUE,
793 "%s: TSF have moved while trying to set "
794 "quiet time TSF: 0x%08x\n",
796 /* TSF shouldn't count twice or reg access is taking forever */
800 OS_REG_SET_BIT(ah, AR_DIAG_SW, AR_DIAG_FORCE_CH_IDLE_HIGH);
802 /* Allow the quiet mechanism to do its work */
804 OS_REG_CLR_BIT(ah, AR_TIMER_MODE, AR_QUIET_TIMER_EN);
806 /* Verify all transmit is dead */
807 wait = timeout / AH_TIME_QUANTUM;
808 while (ar9300_num_tx_pending(ah, q)) {
810 HALDEBUG(ah, HAL_DEBUG_TX,
811 "%s: Failed to stop Tx DMA in %d msec "
812 "after killing last frame\n",
813 __func__, timeout / 1000);
816 OS_DELAY(AH_TIME_QUANTUM);
819 OS_REG_CLR_BIT(ah, AR_DIAG_SW, AR_DIAG_FORCE_CH_IDLE_HIGH);
822 OS_REG_WRITE(ah, AR_Q_TXD, 0);
825 #undef AH_TX_STOP_DMA_TIMEOUT
826 #undef AH_TIME_QUANTUM
830 * Abort transmit on all queues
832 #define AR9300_ABORT_LOOPS 1000
833 #define AR9300_ABORT_WAIT 5
834 #define NEXT_TBTT_NOW 10
836 ar9300_abort_tx_dma(struct ath_hal *ah)
838 struct ath_hal_9300 *ahp = AH9300(ah);
840 u_int32_t nexttbtt, nextdba, tsf_tbtt, tbtt, dba;
842 HAL_BOOL status = AH_TRUE;
844 if (ahp->ah_abort_txdma_norx) {
846 * First of all, make sure RX has been stopped
848 if (ar9300_get_power_mode(ah) != HAL_PM_FULL_SLEEP) {
849 /* Need to stop RX DMA before reset otherwise chip might hang */
850 stopped = ar9300_set_rx_abort(ah, AH_TRUE); /* abort and disable PCU */
851 ar9300_set_rx_filter(ah, 0);
852 stopped &= ar9300_stop_dma_receive(ah, 0); /* stop and disable RX DMA */
855 * During the transition from full sleep to reset,
856 * recv DMA regs are not available to be read
858 HALDEBUG(ah, HAL_DEBUG_UNMASKABLE,
859 "%s[%d]: ar9300_stop_dma_receive failed\n", __func__, __LINE__);
860 //We still continue to stop TX dma
864 HALDEBUG(ah, HAL_DEBUG_UNMASKABLE,
865 "%s[%d]: Chip is already in full sleep\n", __func__, __LINE__);
870 * set txd on all queues
872 OS_REG_WRITE(ah, AR_Q_TXD, AR_Q_TXD_M);
875 * set tx abort bits (also disable rx)
877 OS_REG_SET_BIT(ah, AR_PCU_MISC, AR_PCU_FORCE_QUIET_COLL | AR_PCU_CLEAR_VMF);
878 /* Add a new receipe from K31 code */
879 OS_REG_SET_BIT(ah, AR_DIAG_SW, AR_DIAG_FORCE_CH_IDLE_HIGH | AR_DIAG_RX_DIS |
880 AR_DIAG_RX_ABORT | AR_DIAG_FORCE_RX_CLEAR);
882 nexttbtt = OS_REG_READ(ah, AR_NEXT_TBTT_TIMER);
883 nextdba = OS_REG_READ(ah, AR_NEXT_DMA_BEACON_ALERT);
884 //printk("%s[%d]:dba: %d, nt: %d \n", __func__, __LINE__, nextdba, nexttbtt);
885 tsf_tbtt = OS_REG_READ(ah, AR_TSF_L32);
886 tbtt = tsf_tbtt + NEXT_TBTT_NOW;
888 OS_REG_WRITE(ah, AR_NEXT_DMA_BEACON_ALERT, dba);
889 OS_REG_WRITE(ah, AR_NEXT_TBTT_TIMER, tbtt);
890 OS_REG_SET_BIT(ah, AR_D_GBL_IFS_MISC, AR_D_GBL_IFS_MISC_IGNORE_BACKOFF);
893 * Let TXE (all queues) clear before waiting for any pending frames
894 * This is needed before starting the RF_BUS GRANT sequence other wise causes kernel
897 for(i = 0; i < AR9300_ABORT_LOOPS; i++) {
898 if(OS_REG_READ(ah, AR_Q_TXE) == 0) {
901 OS_DELAY(AR9300_ABORT_WAIT);
903 if (i == AR9300_ABORT_LOOPS) {
904 HALDEBUG(ah, HAL_DEBUG_TX, "%s[%d] reached max wait on TXE\n",
909 * wait on all tx queues
910 * This need to be checked in the last to gain extra 50 usec. on avg.
911 * Currently checked first since we dont have a previous channel information currently.
912 * Which is needed to revert the rf changes.
914 for (q = AR_NUM_QCU - 1; q >= 0; q--) {
915 for (i = 0; i < AR9300_ABORT_LOOPS; i++) {
916 if (!(ar9300_num_tx_pending(ah, q))) {
919 OS_DELAY(AR9300_ABORT_WAIT);
921 if (i == AR9300_ABORT_LOOPS) {
923 HALDEBUG(ah, HAL_DEBUG_UNMASKABLE,
924 "ABORT LOOP finsihsed for Q: %d, num_pending: %d \n",
925 q, ar9300_num_tx_pending(ah, q));
930 /* Updating the beacon alert register with correct value */
931 OS_REG_WRITE(ah, AR_NEXT_DMA_BEACON_ALERT, nextdba);
932 OS_REG_WRITE(ah, AR_NEXT_TBTT_TIMER, nexttbtt);
936 * clear tx abort bits
938 OS_REG_CLR_BIT(ah, AR_PCU_MISC, AR_PCU_FORCE_QUIET_COLL | AR_PCU_CLEAR_VMF);
939 /* Added a new receipe from K31 code */
940 OS_REG_CLR_BIT(ah, AR_DIAG_SW, AR_DIAG_FORCE_CH_IDLE_HIGH | AR_DIAG_RX_DIS |
941 AR_DIAG_RX_ABORT | AR_DIAG_FORCE_RX_CLEAR);
942 OS_REG_CLR_BIT(ah, AR_D_GBL_IFS_MISC, AR_D_GBL_IFS_MISC_IGNORE_BACKOFF);
947 OS_REG_WRITE(ah, AR_Q_TXD, 0);
949 ahp->ah_abort_txdma_norx = AH_TRUE;
955 * Determine which tx queues need interrupt servicing.
958 ar9300_get_tx_intr_queue(struct ath_hal *ah, u_int32_t *txqs)
960 HALDEBUG(AH_NULL, HAL_DEBUG_UNMASKABLE,
961 "ar9300_get_tx_intr_queue: Should not be called\n");
963 struct ath_hal_9300 *ahp = AH9300(ah);
964 *txqs &= ahp->ah_intr_txqs;
965 ahp->ah_intr_txqs &= ~(*txqs);
970 ar9300_reset_tx_status_ring(struct ath_hal *ah)
972 struct ath_hal_9300 *ahp = AH9300(ah);
976 /* Zero out the status descriptors */
977 OS_MEMZERO((void *)ahp->ts_ring, ahp->ts_size * sizeof(struct ar9300_txs));
978 HALDEBUG(ah, HAL_DEBUG_QUEUE,
979 "%s: TS Start 0x%x End 0x%x Virt %p, Size %d\n", __func__,
980 ahp->ts_paddr_start, ahp->ts_paddr_end, ahp->ts_ring, ahp->ts_size);
982 OS_REG_WRITE(ah, AR_Q_STATUS_RING_START, ahp->ts_paddr_start);
983 OS_REG_WRITE(ah, AR_Q_STATUS_RING_END, ahp->ts_paddr_end);
987 ar9300_setup_tx_status_ring(struct ath_hal *ah, void *ts_start,
988 u_int32_t ts_paddr_start, u_int16_t size)
990 struct ath_hal_9300 *ahp = AH9300(ah);
992 ahp->ts_paddr_start = ts_paddr_start;
993 ahp->ts_paddr_end = ts_paddr_start + (size * sizeof(struct ar9300_txs));
995 ahp->ts_ring = (struct ar9300_txs *)ts_start;
997 ar9300_reset_tx_status_ring(ah);