drivers/net/wireless/ath/ath5k/qcu.c

   1 /*
   2  * Copyright (c) 2004-2008 Reyk Floeter <reyk@openbsd.org>
   3  * Copyright (c) 2006-2008 Nick Kossifidis <mickflemm@gmail.com>
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  *
  17  */
  18
  19 /********************************************\
  20 Queue Control Unit, DCF Control Unit Functions
  21 \********************************************/
  22
  23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  24
  25 #include "ath5k.h"
  26 #include "reg.h"
  27 #include "debug.h"
  28 #include <linux/log2.h>
  29
  30 /**
  31  * DOC: Queue Control Unit (QCU)/DCF Control Unit (DCU) functions
  32  *
  33  * Here we setup parameters for the 12 available TX queues. Note that
  34  * on the various registers we can usually only map the first 10 of them so
  35  * basically we have 10 queues to play with. Each queue has a matching
  36  * QCU that controls when the queue will get triggered and multiple QCUs
  37  * can be mapped to a single DCU that controls the various DFS parameters
  38  * for the various queues. In our setup we have a 1:1 mapping between QCUs
  39  * and DCUs allowing us to have different DFS settings for each queue.
  40  *
  41  * When a frame goes into a TX queue, QCU decides when it'll trigger a
  42  * transmission based on various criteria (such as how many data we have inside
  43  * it's buffer or -if it's a beacon queue- if it's time to fire up the queue
  44  * based on TSF etc), DCU adds backoff, IFSes etc and then a scheduler
  45  * (arbitrator) decides the priority of each QCU based on it's configuration
  46  * (e.g. beacons are always transmitted when they leave DCU bypassing all other
  47  * frames from other queues waiting to be transmitted). After a frame leaves
  48  * the DCU it goes to PCU for further processing and then to PHY for
  49  * the actual transmission.
  50  */
  51
  52
  53 /******************\
  54 * Helper functions *
  55 \******************/
  56
  57 /**
  58  * ath5k_hw_num_tx_pending() - Get number of pending frames for a  given queue
  59  * @ah: The &struct ath5k_hw
  60  * @queue: One of enum ath5k_tx_queue_id
  61  */
  62 u32
  63 ath5k_hw_num_tx_pending(struct ath5k_hw *ah, unsigned int queue)
  64 {
  65         u32 pending;
  66         AR5K_ASSERT_ENTRY(queue, ah->ah_capabilities.cap_queues.q_tx_num);
  67
  68         /* Return if queue is declared inactive */
  69         if (ah->ah_txq[queue].tqi_type == AR5K_TX_QUEUE_INACTIVE)
  70                 return false;
  71
  72         /* XXX: How about AR5K_CFG_TXCNT ? */
  73         if (ah->ah_version == AR5K_AR5210)
  74                 return false;
  75
  76         pending = ath5k_hw_reg_read(ah, AR5K_QUEUE_STATUS(queue));
  77         pending &= AR5K_QCU_STS_FRMPENDCNT;
  78
  79         /* It's possible to have no frames pending even if TXE
  80          * is set. To indicate that q has not stopped return
  81          * true */
  82         if (!pending && AR5K_REG_READ_Q(ah, AR5K_QCU_TXE, queue))
  83                 return true;
  84
  85         return pending;
  86 }
  87
  88 /**
  89  * ath5k_hw_release_tx_queue() - Set a transmit queue inactive
  90  * @ah: The &struct ath5k_hw
  91  * @queue: One of enum ath5k_tx_queue_id
  92  */
  93 void
  94 ath5k_hw_release_tx_queue(struct ath5k_hw *ah, unsigned int queue)
  95 {
  96         if (WARN_ON(queue >= ah->ah_capabilities.cap_queues.q_tx_num))
  97                 return;
  98
  99         /* This queue will be skipped in further operations */
 100         ah->ah_txq[queue].tqi_type = AR5K_TX_QUEUE_INACTIVE;
 101         /*For SIMR setup*/
 102         AR5K_Q_DISABLE_BITS(ah->ah_txq_status, queue);
 103 }
 104
 105 /**
 106  * ath5k_cw_validate() - Make sure the given cw is valid
 107  * @cw_req: The contention window value to check
 108  *
 109  * Make sure cw is a power of 2 minus 1 and smaller than 1024
 110  */
 111 static u16
 112 ath5k_cw_validate(u16 cw_req)
 113 {
 114         cw_req = min(cw_req, (u16)1023);
 115
 116         /* Check if cw_req + 1 a power of 2 */
 117         if (is_power_of_2(cw_req + 1))
 118                 return cw_req;
 119
 120         /* Check if cw_req is a power of 2 */
 121         if (is_power_of_2(cw_req))
 122                 return cw_req - 1;
 123
 124         /* If none of the above is correct
 125          * find the closest power of 2 */
 126         cw_req = (u16) roundup_pow_of_two(cw_req) - 1;
 127
 128         return cw_req;
 129 }
 130
 131 /**
 132  * ath5k_hw_get_tx_queueprops() - Get properties for a transmit queue
 133  * @ah: The &struct ath5k_hw
 134  * @queue: One of enum ath5k_tx_queue_id
 135  * @queue_info: The &struct ath5k_txq_info to fill
 136  */
 137 int
 138 ath5k_hw_get_tx_queueprops(struct ath5k_hw *ah, int queue,
 139                 struct ath5k_txq_info *queue_info)
 140 {
 141         memcpy(queue_info, &ah->ah_txq[queue], sizeof(struct ath5k_txq_info));
 142         return 0;
 143 }
 144
 145 /**
 146  * ath5k_hw_set_tx_queueprops() - Set properties for a transmit queue
 147  * @ah: The &struct ath5k_hw
 148  * @queue: One of enum ath5k_tx_queue_id
 149  * @qinfo: The &struct ath5k_txq_info to use
 150  *
 151  * Returns 0 on success or -EIO if queue is inactive
 152  */
 153 int
 154 ath5k_hw_set_tx_queueprops(struct ath5k_hw *ah, int queue,
 155                                 const struct ath5k_txq_info *qinfo)
 156 {
 157         struct ath5k_txq_info *qi;
 158
 159         AR5K_ASSERT_ENTRY(queue, ah->ah_capabilities.cap_queues.q_tx_num);
 160
 161         qi = &ah->ah_txq[queue];
 162
 163         if (qi->tqi_type == AR5K_TX_QUEUE_INACTIVE)
 164                 return -EIO;
 165
 166         /* copy and validate values */
 167         qi->tqi_type = qinfo->tqi_type;
 168         qi->tqi_subtype = qinfo->tqi_subtype;
 169         qi->tqi_flags = qinfo->tqi_flags;
 170         /*
 171          * According to the docs: Although the AIFS field is 8 bit wide,
 172          * the maximum supported value is 0xFC. Setting it higher than that
 173          * will cause the DCU to hang.
 174          */
 175         qi->tqi_aifs = min(qinfo->tqi_aifs, (u8)0xFC);
 176         qi->tqi_cw_min = ath5k_cw_validate(qinfo->tqi_cw_min);
 177         qi->tqi_cw_max = ath5k_cw_validate(qinfo->tqi_cw_max);
 178         qi->tqi_cbr_period = qinfo->tqi_cbr_period;
 179         qi->tqi_cbr_overflow_limit = qinfo->tqi_cbr_overflow_limit;
 180         qi->tqi_burst_time = qinfo->tqi_burst_time;
 181         qi->tqi_ready_time = qinfo->tqi_ready_time;
 182
 183         /*XXX: Is this supported on 5210 ?*/
 184         /*XXX: Is this correct for AR5K_WME_AC_VI,VO ???*/
 185         if ((qinfo->tqi_type == AR5K_TX_QUEUE_DATA &&
 186                 ((qinfo->tqi_subtype == AR5K_WME_AC_VI) ||
 187                  (qinfo->tqi_subtype == AR5K_WME_AC_VO))) ||
 188              qinfo->tqi_type == AR5K_TX_QUEUE_UAPSD)
 189                 qi->tqi_flags |= AR5K_TXQ_FLAG_POST_FR_BKOFF_DIS;
 190
 191         return 0;
 192 }
 193
 194 /**
 195  * ath5k_hw_setup_tx_queue() - Initialize a transmit queue
 196  * @ah: The &struct ath5k_hw
 197  * @queue_type: One of enum ath5k_tx_queue
 198  * @queue_info: The &struct ath5k_txq_info to use
 199  *
 200  * Returns 0 on success, -EINVAL on invalid arguments
 201  */
 202 int
 203 ath5k_hw_setup_tx_queue(struct ath5k_hw *ah, enum ath5k_tx_queue queue_type,
 204                 struct ath5k_txq_info *queue_info)
 205 {
 206         unsigned int queue;
 207         int ret;
 208
 209         /*
 210          * Get queue by type
 211          */
 212         /* 5210 only has 2 queues */
 213         if (ah->ah_capabilities.cap_queues.q_tx_num == 2) {
 214                 switch (queue_type) {
 215                 case AR5K_TX_QUEUE_DATA:
 216                         queue = AR5K_TX_QUEUE_ID_NOQCU_DATA;
 217                         break;
 218                 case AR5K_TX_QUEUE_BEACON:
 219                 case AR5K_TX_QUEUE_CAB:
 220                         queue = AR5K_TX_QUEUE_ID_NOQCU_BEACON;
 221                         break;
 222                 default:
 223                         return -EINVAL;
 224                 }
 225         } else {
 226                 switch (queue_type) {
 227                 case AR5K_TX_QUEUE_DATA:
 228                         queue = queue_info->tqi_subtype;
 229                         break;
 230                 case AR5K_TX_QUEUE_UAPSD:
 231                         queue = AR5K_TX_QUEUE_ID_UAPSD;
 232                         break;
 233                 case AR5K_TX_QUEUE_BEACON:
 234                         queue = AR5K_TX_QUEUE_ID_BEACON;
 235                         break;
 236                 case AR5K_TX_QUEUE_CAB:
 237                         queue = AR5K_TX_QUEUE_ID_CAB;
 238                         break;
 239                 default:
 240                         return -EINVAL;
 241                 }
 242         }
 243
 244         /*
 245          * Setup internal queue structure
 246          */
 247         memset(&ah->ah_txq[queue], 0, sizeof(struct ath5k_txq_info));
 248         ah->ah_txq[queue].tqi_type = queue_type;
 249
 250         if (queue_info != NULL) {
 251                 queue_info->tqi_type = queue_type;
 252                 ret = ath5k_hw_set_tx_queueprops(ah, queue, queue_info);
 253                 if (ret)
 254                         return ret;
 255         }
 256
 257         /*
 258          * We use ah_txq_status to hold a temp value for
 259          * the Secondary interrupt mask registers on 5211+
 260          * check out ath5k_hw_reset_tx_queue
 261          */
 262         AR5K_Q_ENABLE_BITS(ah->ah_txq_status, queue);
 263
 264         return queue;
 265 }
 266
 267
 268 /*******************************\
 269 * Single QCU/DCU initialization *
 270 \*******************************/
 271
 272 /**
 273  * ath5k_hw_set_tx_retry_limits() - Set tx retry limits on DCU
 274  * @ah: The &struct ath5k_hw
 275  * @queue: One of enum ath5k_tx_queue_id
 276  *
 277  * This function is used when initializing a queue, to set
 278  * retry limits based on ah->ah_retry_* and the chipset used.
 279  */
 280 void
 281 ath5k_hw_set_tx_retry_limits(struct ath5k_hw *ah,
 282                                   unsigned int queue)
 283 {
 284         /* Single data queue on AR5210 */
 285         if (ah->ah_version == AR5K_AR5210) {
 286                 struct ath5k_txq_info *tq = &ah->ah_txq[queue];
 287
 288                 if (queue > 0)
 289                         return;
 290
 291                 ath5k_hw_reg_write(ah,
 292                         (tq->tqi_cw_min << AR5K_NODCU_RETRY_LMT_CW_MIN_S)
 293                         | AR5K_REG_SM(ah->ah_retry_long,
 294                                       AR5K_NODCU_RETRY_LMT_SLG_RETRY)
 295                         | AR5K_REG_SM(ah->ah_retry_short,
 296                                       AR5K_NODCU_RETRY_LMT_SSH_RETRY)
 297                         | AR5K_REG_SM(ah->ah_retry_long,
 298                                       AR5K_NODCU_RETRY_LMT_LG_RETRY)
 299                         | AR5K_REG_SM(ah->ah_retry_short,
 300                                       AR5K_NODCU_RETRY_LMT_SH_RETRY),
 301                         AR5K_NODCU_RETRY_LMT);
 302         /* DCU on AR5211+ */
 303         } else {
 304                 ath5k_hw_reg_write(ah,
 305                         AR5K_REG_SM(ah->ah_retry_long,
 306                                     AR5K_DCU_RETRY_LMT_RTS)
 307                         | AR5K_REG_SM(ah->ah_retry_long,
 308                                       AR5K_DCU_RETRY_LMT_STA_RTS)
 309                         | AR5K_REG_SM(max(ah->ah_retry_long, ah->ah_retry_short),
 310                                       AR5K_DCU_RETRY_LMT_STA_DATA),
 311                         AR5K_QUEUE_DFS_RETRY_LIMIT(queue));
 312         }
 313 }
 314
 315 /**
 316  * ath5k_hw_reset_tx_queue() - Initialize a single hw queue
 317  * @ah: The &struct ath5k_hw
 318  * @queue: One of enum ath5k_tx_queue_id
 319  *
 320  * Set DCF properties for the given transmit queue on DCU
 321  * and configures all queue-specific parameters.
 322  */
 323 int
 324 ath5k_hw_reset_tx_queue(struct ath5k_hw *ah, unsigned int queue)
 325 {
 326         struct ath5k_txq_info *tq = &ah->ah_txq[queue];
 327
 328         AR5K_ASSERT_ENTRY(queue, ah->ah_capabilities.cap_queues.q_tx_num);
 329
 330         tq = &ah->ah_txq[queue];
 331
 332         /* Skip if queue inactive or if we are on AR5210
 333          * that doesn't have QCU/DCU */
 334         if ((ah->ah_version == AR5K_AR5210) ||
 335         (tq->tqi_type == AR5K_TX_QUEUE_INACTIVE))
 336                 return 0;
 337
 338         /*
 339          * Set contention window (cw_min/cw_max)
 340          * and arbitrated interframe space (aifs)...
 341          */
 342         ath5k_hw_reg_write(ah,
 343                 AR5K_REG_SM(tq->tqi_cw_min, AR5K_DCU_LCL_IFS_CW_MIN) |
 344                 AR5K_REG_SM(tq->tqi_cw_max, AR5K_DCU_LCL_IFS_CW_MAX) |
 345                 AR5K_REG_SM(tq->tqi_aifs, AR5K_DCU_LCL_IFS_AIFS),
 346                 AR5K_QUEUE_DFS_LOCAL_IFS(queue));
 347
 348         /*
 349          * Set tx retry limits for this queue
 350          */
 351         ath5k_hw_set_tx_retry_limits(ah, queue);
 352
 353
 354         /*
 355          * Set misc registers
 356          */
 357
 358         /* Enable DCU to wait for next fragment from QCU */
 359         AR5K_REG_ENABLE_BITS(ah, AR5K_QUEUE_DFS_MISC(queue),
 360                                 AR5K_DCU_MISC_FRAG_WAIT);
 361
 362         /* On Maui and Spirit use the global seqnum on DCU */
 363         if (ah->ah_mac_version < AR5K_SREV_AR5211)
 364                 AR5K_REG_ENABLE_BITS(ah, AR5K_QUEUE_DFS_MISC(queue),
 365                                         AR5K_DCU_MISC_SEQNUM_CTL);
 366
 367         /* Constant bit rate period */
 368         if (tq->tqi_cbr_period) {
 369                 ath5k_hw_reg_write(ah, AR5K_REG_SM(tq->tqi_cbr_period,
 370                                         AR5K_QCU_CBRCFG_INTVAL) |
 371                                         AR5K_REG_SM(tq->tqi_cbr_overflow_limit,
 372                                         AR5K_QCU_CBRCFG_ORN_THRES),
 373                                         AR5K_QUEUE_CBRCFG(queue));
 374
 375                 AR5K_REG_ENABLE_BITS(ah, AR5K_QUEUE_MISC(queue),
 376                                         AR5K_QCU_MISC_FRSHED_CBR);
 377
 378                 if (tq->tqi_cbr_overflow_limit)
 379                         AR5K_REG_ENABLE_BITS(ah, AR5K_QUEUE_MISC(queue),
 380                                         AR5K_QCU_MISC_CBR_THRES_ENABLE);
 381         }
 382
 383         /* Ready time interval */
 384         if (tq->tqi_ready_time && (tq->tqi_type != AR5K_TX_QUEUE_CAB))
 385                 ath5k_hw_reg_write(ah, AR5K_REG_SM(tq->tqi_ready_time,
 386                                         AR5K_QCU_RDYTIMECFG_INTVAL) |
 387                                         AR5K_QCU_RDYTIMECFG_ENABLE,
 388                                         AR5K_QUEUE_RDYTIMECFG(queue));
 389
 390         if (tq->tqi_burst_time) {
 391                 ath5k_hw_reg_write(ah, AR5K_REG_SM(tq->tqi_burst_time,
 392                                         AR5K_DCU_CHAN_TIME_DUR) |
 393                                         AR5K_DCU_CHAN_TIME_ENABLE,
 394                                         AR5K_QUEUE_DFS_CHANNEL_TIME(queue));
 395
 396                 if (tq->tqi_flags & AR5K_TXQ_FLAG_RDYTIME_EXP_POLICY_ENABLE)
 397                         AR5K_REG_ENABLE_BITS(ah, AR5K_QUEUE_MISC(queue),
 398                                         AR5K_QCU_MISC_RDY_VEOL_POLICY);
 399         }
 400
 401         /* Enable/disable Post frame backoff */
 402         if (tq->tqi_flags & AR5K_TXQ_FLAG_BACKOFF_DISABLE)
 403                 ath5k_hw_reg_write(ah, AR5K_DCU_MISC_POST_FR_BKOFF_DIS,
 404                                         AR5K_QUEUE_DFS_MISC(queue));
 405
 406         /* Enable/disable fragmentation burst backoff */
 407         if (tq->tqi_flags & AR5K_TXQ_FLAG_FRAG_BURST_BACKOFF_ENABLE)
 408                 ath5k_hw_reg_write(ah, AR5K_DCU_MISC_BACKOFF_FRAG,
 409                                         AR5K_QUEUE_DFS_MISC(queue));
 410
 411         /*
 412          * Set registers by queue type
 413          */
 414         switch (tq->tqi_type) {
 415         case AR5K_TX_QUEUE_BEACON:
 416                 AR5K_REG_ENABLE_BITS(ah, AR5K_QUEUE_MISC(queue),
 417                                 AR5K_QCU_MISC_FRSHED_DBA_GT |
 418                                 AR5K_QCU_MISC_CBREXP_BCN_DIS |
 419                                 AR5K_QCU_MISC_BCN_ENABLE);
 420
 421                 AR5K_REG_ENABLE_BITS(ah, AR5K_QUEUE_DFS_MISC(queue),
 422                                 (AR5K_DCU_MISC_ARBLOCK_CTL_GLOBAL <<
 423                                 AR5K_DCU_MISC_ARBLOCK_CTL_S) |
 424                                 AR5K_DCU_MISC_ARBLOCK_IGNORE |
 425                                 AR5K_DCU_MISC_POST_FR_BKOFF_DIS |
 426                                 AR5K_DCU_MISC_BCN_ENABLE);
 427                 break;
 428
 429         case AR5K_TX_QUEUE_CAB:
 430                 /* XXX: use BCN_SENT_GT, if we can figure out how */
 431                 AR5K_REG_ENABLE_BITS(ah, AR5K_QUEUE_MISC(queue),
 432                                         AR5K_QCU_MISC_FRSHED_DBA_GT |
 433                                         AR5K_QCU_MISC_CBREXP_DIS |
 434                                         AR5K_QCU_MISC_CBREXP_BCN_DIS);
 435
 436                 ath5k_hw_reg_write(ah, ((tq->tqi_ready_time -
 437                                         (AR5K_TUNE_SW_BEACON_RESP -
 438                                         AR5K_TUNE_DMA_BEACON_RESP) -
 439                                 AR5K_TUNE_ADDITIONAL_SWBA_BACKOFF) * 1024) |
 440                                         AR5K_QCU_RDYTIMECFG_ENABLE,
 441                                         AR5K_QUEUE_RDYTIMECFG(queue));
 442
 443                 AR5K_REG_ENABLE_BITS(ah, AR5K_QUEUE_DFS_MISC(queue),
 444                                         (AR5K_DCU_MISC_ARBLOCK_CTL_GLOBAL <<
 445                                         AR5K_DCU_MISC_ARBLOCK_CTL_S));
 446                 break;
 447
 448         case AR5K_TX_QUEUE_UAPSD:
 449                 AR5K_REG_ENABLE_BITS(ah, AR5K_QUEUE_MISC(queue),
 450                                         AR5K_QCU_MISC_CBREXP_DIS);
 451                 break;
 452
 453         case AR5K_TX_QUEUE_DATA:
 454         default:
 455                         break;
 456         }
 457
 458         /* TODO: Handle frame compression */
 459
 460         /*
 461          * Enable interrupts for this tx queue
 462          * in the secondary interrupt mask registers
 463          */
 464         if (tq->tqi_flags & AR5K_TXQ_FLAG_TXOKINT_ENABLE)
 465                 AR5K_Q_ENABLE_BITS(ah->ah_txq_imr_txok, queue);
 466
 467         if (tq->tqi_flags & AR5K_TXQ_FLAG_TXERRINT_ENABLE)
 468                 AR5K_Q_ENABLE_BITS(ah->ah_txq_imr_txerr, queue);
 469
 470         if (tq->tqi_flags & AR5K_TXQ_FLAG_TXURNINT_ENABLE)
 471                 AR5K_Q_ENABLE_BITS(ah->ah_txq_imr_txurn, queue);
 472
 473         if (tq->tqi_flags & AR5K_TXQ_FLAG_TXDESCINT_ENABLE)
 474                 AR5K_Q_ENABLE_BITS(ah->ah_txq_imr_txdesc, queue);
 475
 476         if (tq->tqi_flags & AR5K_TXQ_FLAG_TXEOLINT_ENABLE)
 477                 AR5K_Q_ENABLE_BITS(ah->ah_txq_imr_txeol, queue);
 478
 479         if (tq->tqi_flags & AR5K_TXQ_FLAG_CBRORNINT_ENABLE)
 480                 AR5K_Q_ENABLE_BITS(ah->ah_txq_imr_cbrorn, queue);
 481
 482         if (tq->tqi_flags & AR5K_TXQ_FLAG_CBRURNINT_ENABLE)
 483                 AR5K_Q_ENABLE_BITS(ah->ah_txq_imr_cbrurn, queue);
 484
 485         if (tq->tqi_flags & AR5K_TXQ_FLAG_QTRIGINT_ENABLE)
 486                 AR5K_Q_ENABLE_BITS(ah->ah_txq_imr_qtrig, queue);
 487
 488         if (tq->tqi_flags & AR5K_TXQ_FLAG_TXNOFRMINT_ENABLE)
 489                 AR5K_Q_ENABLE_BITS(ah->ah_txq_imr_nofrm, queue);
 490
 491         /* Update secondary interrupt mask registers */
 492
 493         /* Filter out inactive queues */
 494         ah->ah_txq_imr_txok &= ah->ah_txq_status;
 495         ah->ah_txq_imr_txerr &= ah->ah_txq_status;
 496         ah->ah_txq_imr_txurn &= ah->ah_txq_status;
 497         ah->ah_txq_imr_txdesc &= ah->ah_txq_status;
 498         ah->ah_txq_imr_txeol &= ah->ah_txq_status;
 499         ah->ah_txq_imr_cbrorn &= ah->ah_txq_status;
 500         ah->ah_txq_imr_cbrurn &= ah->ah_txq_status;
 501         ah->ah_txq_imr_qtrig &= ah->ah_txq_status;
 502         ah->ah_txq_imr_nofrm &= ah->ah_txq_status;
 503
 504         ath5k_hw_reg_write(ah, AR5K_REG_SM(ah->ah_txq_imr_txok,
 505                                         AR5K_SIMR0_QCU_TXOK) |
 506                                         AR5K_REG_SM(ah->ah_txq_imr_txdesc,
 507                                         AR5K_SIMR0_QCU_TXDESC),
 508                                         AR5K_SIMR0);
 509
 510         ath5k_hw_reg_write(ah, AR5K_REG_SM(ah->ah_txq_imr_txerr,
 511                                         AR5K_SIMR1_QCU_TXERR) |
 512                                         AR5K_REG_SM(ah->ah_txq_imr_txeol,
 513                                         AR5K_SIMR1_QCU_TXEOL),
 514                                         AR5K_SIMR1);
 515
 516         /* Update SIMR2 but don't overwrite rest simr2 settings */
 517         AR5K_REG_DISABLE_BITS(ah, AR5K_SIMR2, AR5K_SIMR2_QCU_TXURN);
 518         AR5K_REG_ENABLE_BITS(ah, AR5K_SIMR2,
 519                                 AR5K_REG_SM(ah->ah_txq_imr_txurn,
 520                                 AR5K_SIMR2_QCU_TXURN));
 521
 522         ath5k_hw_reg_write(ah, AR5K_REG_SM(ah->ah_txq_imr_cbrorn,
 523                                 AR5K_SIMR3_QCBRORN) |
 524                                 AR5K_REG_SM(ah->ah_txq_imr_cbrurn,
 525                                 AR5K_SIMR3_QCBRURN),
 526                                 AR5K_SIMR3);
 527
 528         ath5k_hw_reg_write(ah, AR5K_REG_SM(ah->ah_txq_imr_qtrig,
 529                                 AR5K_SIMR4_QTRIG), AR5K_SIMR4);
 530
 531         /* Set TXNOFRM_QCU for the queues with TXNOFRM enabled */
 532         ath5k_hw_reg_write(ah, AR5K_REG_SM(ah->ah_txq_imr_nofrm,
 533                                 AR5K_TXNOFRM_QCU), AR5K_TXNOFRM);
 534
 535         /* No queue has TXNOFRM enabled, disable the interrupt
 536          * by setting AR5K_TXNOFRM to zero */
 537         if (ah->ah_txq_imr_nofrm == 0)
 538                 ath5k_hw_reg_write(ah, 0, AR5K_TXNOFRM);
 539
 540         /* Set QCU mask for this DCU to save power */
 541         AR5K_REG_WRITE_Q(ah, AR5K_QUEUE_QCUMASK(queue), queue);
 542
 543         return 0;
 544 }
 545
 546
 547 /**************************\
 548 * Global QCU/DCU functions *
 549 \**************************/
 550
 551 /**
 552  * ath5k_hw_set_ifs_intervals()  - Set global inter-frame spaces on DCU
 553  * @ah: The &struct ath5k_hw
 554  * @slot_time: Slot time in us
 555  *
 556  * Sets the global IFS intervals on DCU (also works on AR5210) for
 557  * the given slot time and the current bwmode.
 558  */
 559 int ath5k_hw_set_ifs_intervals(struct ath5k_hw *ah, unsigned int slot_time)
 560 {
 561         struct ieee80211_channel *channel = ah->ah_current_channel;
 562         enum nl80211_band band;
 563         struct ieee80211_supported_band *sband;
 564         struct ieee80211_rate *rate;
 565         u32 ack_tx_time, eifs, eifs_clock, sifs, sifs_clock;
 566         u32 slot_time_clock = ath5k_hw_htoclock(ah, slot_time);
 567         u32 rate_flags, i;
 568
 569         if (slot_time < 6 || slot_time_clock > AR5K_SLOT_TIME_MAX)
 570                 return -EINVAL;
 571
 572         sifs = ath5k_hw_get_default_sifs(ah);
 573         sifs_clock = ath5k_hw_htoclock(ah, sifs - 2);
 574
 575         /* EIFS
 576          * Txtime of ack at lowest rate + SIFS + DIFS
 577          * (DIFS = SIFS + 2 * Slot time)
 578          *
 579          * Note: HAL has some predefined values for EIFS
 580          * Turbo:   (37 + 2 * 6)
 581          * Default: (74 + 2 * 9)
 582          * Half:    (149 + 2 * 13)
 583          * Quarter: (298 + 2 * 21)
 584          *
 585          * (74 + 2 * 6) for AR5210 default and turbo !
 586          *
 587          * According to the formula we have
 588          * ack_tx_time = 25 for turbo and
 589          * ack_tx_time = 42.5 * clock multiplier
 590          * for default/half/quarter.
 591          *
 592          * This can't be right, 42 is what we would get
 593          * from ath5k_hw_get_frame_dur_for_bwmode or
 594          * ieee80211_generic_frame_duration for zero frame
 595          * length and without SIFS !
 596          *
 597          * Also we have different lowest rate for 802.11a
 598          */
 599         if (channel->band == NL80211_BAND_5GHZ)
 600                 band = NL80211_BAND_5GHZ;
 601         else
 602                 band = NL80211_BAND_2GHZ;
 603
 604         switch (ah->ah_bwmode) {
 605         case AR5K_BWMODE_5MHZ:
 606                 rate_flags = IEEE80211_RATE_SUPPORTS_5MHZ;
 607                 break;
 608         case AR5K_BWMODE_10MHZ:
 609                 rate_flags = IEEE80211_RATE_SUPPORTS_10MHZ;
 610                 break;
 611         default:
 612                 rate_flags = 0;
 613                 break;
 614         }
 615         sband = &ah->sbands[band];
 616         rate = NULL;
 617         for (i = 0; i < sband->n_bitrates; i++) {
 618                 if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
 619                         continue;
 620                 rate = &sband->bitrates[i];
 621                 break;
 622         }
 623         if (WARN_ON(!rate))
 624                 return -EINVAL;
 625
 626         ack_tx_time = ath5k_hw_get_frame_duration(ah, band, 10, rate, false);
 627
 628         /* ack_tx_time includes an SIFS already */
 629         eifs = ack_tx_time + sifs + 2 * slot_time;
 630         eifs_clock = ath5k_hw_htoclock(ah, eifs);
 631
 632         /* Set IFS settings on AR5210 */
 633         if (ah->ah_version == AR5K_AR5210) {
 634                 u32 pifs, pifs_clock, difs, difs_clock;
 635
 636                 /* Set slot time */
 637                 ath5k_hw_reg_write(ah, slot_time_clock, AR5K_SLOT_TIME);
 638
 639                 /* Set EIFS */
 640                 eifs_clock = AR5K_REG_SM(eifs_clock, AR5K_IFS1_EIFS);
 641
 642                 /* PIFS = Slot time + SIFS */
 643                 pifs = slot_time + sifs;
 644                 pifs_clock = ath5k_hw_htoclock(ah, pifs);
 645                 pifs_clock = AR5K_REG_SM(pifs_clock, AR5K_IFS1_PIFS);
 646
 647                 /* DIFS = SIFS + 2 * Slot time */
 648                 difs = sifs + 2 * slot_time;
 649                 difs_clock = ath5k_hw_htoclock(ah, difs);
 650
 651                 /* Set SIFS/DIFS */
 652                 ath5k_hw_reg_write(ah, (difs_clock <<
 653                                 AR5K_IFS0_DIFS_S) | sifs_clock,
 654                                 AR5K_IFS0);
 655
 656                 /* Set PIFS/EIFS and preserve AR5K_INIT_CARR_SENSE_EN */
 657                 ath5k_hw_reg_write(ah, pifs_clock | eifs_clock |
 658                                 (AR5K_INIT_CARR_SENSE_EN << AR5K_IFS1_CS_EN_S),
 659                                 AR5K_IFS1);
 660
 661                 return 0;
 662         }
 663
 664         /* Set IFS slot time */
 665         ath5k_hw_reg_write(ah, slot_time_clock, AR5K_DCU_GBL_IFS_SLOT);
 666
 667         /* Set EIFS interval */
 668         ath5k_hw_reg_write(ah, eifs_clock, AR5K_DCU_GBL_IFS_EIFS);
 669
 670         /* Set SIFS interval in usecs */
 671         AR5K_REG_WRITE_BITS(ah, AR5K_DCU_GBL_IFS_MISC,
 672                                 AR5K_DCU_GBL_IFS_MISC_SIFS_DUR_USEC,
 673                                 sifs);
 674
 675         /* Set SIFS interval in clock cycles */
 676         ath5k_hw_reg_write(ah, sifs_clock, AR5K_DCU_GBL_IFS_SIFS);
 677
 678         return 0;
 679 }
 680
 681
 682 /**
 683  * ath5k_hw_init_queues() - Initialize tx queues
 684  * @ah: The &struct ath5k_hw
 685  *
 686  * Initializes all tx queues based on information on
 687  * ah->ah_txq* set by the driver
 688  */
 689 int
 690 ath5k_hw_init_queues(struct ath5k_hw *ah)
 691 {
 692         int i, ret;
 693
 694         /* TODO: HW Compression support for data queues */
 695         /* TODO: Burst prefetch for data queues */
 696
 697         /*
 698          * Reset queues and start beacon timers at the end of the reset routine
 699          * This also sets QCU mask on each DCU for 1:1 qcu to dcu mapping
 700          * Note: If we want we can assign multiple qcus on one dcu.
 701          */
 702         if (ah->ah_version != AR5K_AR5210)
 703                 for (i = 0; i < ah->ah_capabilities.cap_queues.q_tx_num; i++) {
 704                         ret = ath5k_hw_reset_tx_queue(ah, i);
 705                         if (ret) {
 706                                 ATH5K_ERR(ah,
 707                                         "failed to reset TX queue #%d\n", i);
 708                                 return ret;
 709                         }
 710                 }
 711         else
 712                 /* No QCU/DCU on AR5210, just set tx
 713                  * retry limits. We set IFS parameters
 714                  * on ath5k_hw_set_ifs_intervals */
 715                 ath5k_hw_set_tx_retry_limits(ah, 0);
 716
 717         /* Set the turbo flag when operating on 40MHz */
 718         if (ah->ah_bwmode == AR5K_BWMODE_40MHZ)
 719                 AR5K_REG_ENABLE_BITS(ah, AR5K_DCU_GBL_IFS_MISC,
 720                                 AR5K_DCU_GBL_IFS_MISC_TURBO_MODE);
 721
 722         /* If we didn't set IFS timings through
 723          * ath5k_hw_set_coverage_class make sure
 724          * we set them here */
 725         if (!ah->ah_coverage_class) {
 726                 unsigned int slot_time = ath5k_hw_get_default_slottime(ah);
 727                 ath5k_hw_set_ifs_intervals(ah, slot_time);
 728         }
 729
 730         return 0;
 731 }