drivers/net/wireless/ath/ath9k/ar9003_mci.c

   1 /*
   2  * Copyright (c) 2008-2011 Atheros Communications Inc.
   3  *
   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.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include <linux/export.h>
  18 #include "hw.h"
  19 #include "hw-ops.h"
  20 #include "ar9003_phy.h"
  21 #include "ar9003_mci.h"
  22 #include "ar9003_aic.h"
  23
  24 static void ar9003_mci_reset_req_wakeup(struct ath_hw *ah)
  25 {
  26         REG_RMW_FIELD(ah, AR_MCI_COMMAND2,
  27                       AR_MCI_COMMAND2_RESET_REQ_WAKEUP, 1);
  28         udelay(1);
  29         REG_RMW_FIELD(ah, AR_MCI_COMMAND2,
  30                       AR_MCI_COMMAND2_RESET_REQ_WAKEUP, 0);
  31 }
  32
  33 static int ar9003_mci_wait_for_interrupt(struct ath_hw *ah, u32 address,
  34                                         u32 bit_position, int time_out)
  35 {
  36         struct ath_common *common = ath9k_hw_common(ah);
  37
  38         while (time_out) {
  39                 if (!(REG_READ(ah, address) & bit_position)) {
  40                         udelay(10);
  41                         time_out -= 10;
  42
  43                         if (time_out < 0)
  44                                 break;
  45                         else
  46                                 continue;
  47                 }
  48                 REG_WRITE(ah, address, bit_position);
  49
  50                 if (address != AR_MCI_INTERRUPT_RX_MSG_RAW)
  51                         break;
  52
  53                 if (bit_position & AR_MCI_INTERRUPT_RX_MSG_REQ_WAKE)
  54                         ar9003_mci_reset_req_wakeup(ah);
  55
  56                 if (bit_position & (AR_MCI_INTERRUPT_RX_MSG_SYS_SLEEPING |
  57                                     AR_MCI_INTERRUPT_RX_MSG_SYS_WAKING))
  58                         REG_WRITE(ah, AR_MCI_INTERRUPT_RAW,
  59                                   AR_MCI_INTERRUPT_REMOTE_SLEEP_UPDATE);
  60
  61                 REG_WRITE(ah, AR_MCI_INTERRUPT_RAW, AR_MCI_INTERRUPT_RX_MSG);
  62                 break;
  63         }
  64
  65         if (time_out <= 0) {
  66                 ath_dbg(common, MCI,
  67                         "MCI Wait for Reg 0x%08x = 0x%08x timeout\n",
  68                         address, bit_position);
  69                 ath_dbg(common, MCI,
  70                         "MCI INT_RAW = 0x%08x, RX_MSG_RAW = 0x%08x\n",
  71                         REG_READ(ah, AR_MCI_INTERRUPT_RAW),
  72                         REG_READ(ah, AR_MCI_INTERRUPT_RX_MSG_RAW));
  73                 time_out = 0;
  74         }
  75
  76         return time_out;
  77 }
  78
  79 static void ar9003_mci_remote_reset(struct ath_hw *ah, bool wait_done)
  80 {
  81         u32 payload[4] = { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffff00};
  82
  83         ar9003_mci_send_message(ah, MCI_REMOTE_RESET, 0, payload, 16,
  84                                 wait_done, false);
  85         udelay(5);
  86 }
  87
  88 static void ar9003_mci_send_lna_transfer(struct ath_hw *ah, bool wait_done)
  89 {
  90         u32 payload = 0x00000000;
  91
  92         ar9003_mci_send_message(ah, MCI_LNA_TRANS, 0, &payload, 1,
  93                                 wait_done, false);
  94 }
  95
  96 static void ar9003_mci_send_req_wake(struct ath_hw *ah, bool wait_done)
  97 {
  98         ar9003_mci_send_message(ah, MCI_REQ_WAKE, MCI_FLAG_DISABLE_TIMESTAMP,
  99                                 NULL, 0, wait_done, false);
 100         udelay(5);
 101 }
 102
 103 static void ar9003_mci_send_sys_waking(struct ath_hw *ah, bool wait_done)
 104 {
 105         ar9003_mci_send_message(ah, MCI_SYS_WAKING, MCI_FLAG_DISABLE_TIMESTAMP,
 106                                 NULL, 0, wait_done, false);
 107 }
 108
 109 static void ar9003_mci_send_lna_take(struct ath_hw *ah, bool wait_done)
 110 {
 111         u32 payload = 0x70000000;
 112
 113         ar9003_mci_send_message(ah, MCI_LNA_TAKE, 0, &payload, 1,
 114                                 wait_done, false);
 115 }
 116
 117 static void ar9003_mci_send_sys_sleeping(struct ath_hw *ah, bool wait_done)
 118 {
 119         ar9003_mci_send_message(ah, MCI_SYS_SLEEPING,
 120                                 MCI_FLAG_DISABLE_TIMESTAMP,
 121                                 NULL, 0, wait_done, false);
 122 }
 123
 124 static void ar9003_mci_send_coex_version_query(struct ath_hw *ah,
 125                                                bool wait_done)
 126 {
 127         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 128         u32 payload[4] = {0, 0, 0, 0};
 129
 130         if (mci->bt_version_known ||
 131             (mci->bt_state == MCI_BT_SLEEP))
 132                 return;
 133
 134         MCI_GPM_SET_TYPE_OPCODE(payload, MCI_GPM_COEX_AGENT,
 135                                 MCI_GPM_COEX_VERSION_QUERY);
 136         ar9003_mci_send_message(ah, MCI_GPM, 0, payload, 16, wait_done, true);
 137 }
 138
 139 static void ar9003_mci_send_coex_version_response(struct ath_hw *ah,
 140                                                   bool wait_done)
 141 {
 142         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 143         u32 payload[4] = {0, 0, 0, 0};
 144
 145         MCI_GPM_SET_TYPE_OPCODE(payload, MCI_GPM_COEX_AGENT,
 146                                 MCI_GPM_COEX_VERSION_RESPONSE);
 147         *(((u8 *)payload) + MCI_GPM_COEX_B_MAJOR_VERSION) =
 148                 mci->wlan_ver_major;
 149         *(((u8 *)payload) + MCI_GPM_COEX_B_MINOR_VERSION) =
 150                 mci->wlan_ver_minor;
 151         ar9003_mci_send_message(ah, MCI_GPM, 0, payload, 16, wait_done, true);
 152 }
 153
 154 static void ar9003_mci_send_coex_wlan_channels(struct ath_hw *ah,
 155                                                bool wait_done)
 156 {
 157         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 158         u32 *payload = &mci->wlan_channels[0];
 159
 160         if (!mci->wlan_channels_update ||
 161             (mci->bt_state == MCI_BT_SLEEP))
 162                 return;
 163
 164         MCI_GPM_SET_TYPE_OPCODE(payload, MCI_GPM_COEX_AGENT,
 165                                 MCI_GPM_COEX_WLAN_CHANNELS);
 166         ar9003_mci_send_message(ah, MCI_GPM, 0, payload, 16, wait_done, true);
 167         MCI_GPM_SET_TYPE_OPCODE(payload, 0xff, 0xff);
 168 }
 169
 170 static void ar9003_mci_send_coex_bt_status_query(struct ath_hw *ah,
 171                                                 bool wait_done, u8 query_type)
 172 {
 173         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 174         u32 payload[4] = {0, 0, 0, 0};
 175         bool query_btinfo;
 176
 177         if (mci->bt_state == MCI_BT_SLEEP)
 178                 return;
 179
 180         query_btinfo = !!(query_type & (MCI_GPM_COEX_QUERY_BT_ALL_INFO |
 181                                         MCI_GPM_COEX_QUERY_BT_TOPOLOGY));
 182         MCI_GPM_SET_TYPE_OPCODE(payload, MCI_GPM_COEX_AGENT,
 183                                 MCI_GPM_COEX_STATUS_QUERY);
 184
 185         *(((u8 *)payload) + MCI_GPM_COEX_B_BT_BITMAP) = query_type;
 186
 187         /*
 188          * If bt_status_query message is  not sent successfully,
 189          * then need_flush_btinfo should be set again.
 190          */
 191         if (!ar9003_mci_send_message(ah, MCI_GPM, 0, payload, 16,
 192                                 wait_done, true)) {
 193                 if (query_btinfo)
 194                         mci->need_flush_btinfo = true;
 195         }
 196
 197         if (query_btinfo)
 198                 mci->query_bt = false;
 199 }
 200
 201 static void ar9003_mci_send_coex_halt_bt_gpm(struct ath_hw *ah, bool halt,
 202                                              bool wait_done)
 203 {
 204         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 205         u32 payload[4] = {0, 0, 0, 0};
 206
 207         MCI_GPM_SET_TYPE_OPCODE(payload, MCI_GPM_COEX_AGENT,
 208                                 MCI_GPM_COEX_HALT_BT_GPM);
 209
 210         if (halt) {
 211                 mci->query_bt = true;
 212                 /* Send next unhalt no matter halt sent or not */
 213                 mci->unhalt_bt_gpm = true;
 214                 mci->need_flush_btinfo = true;
 215                 *(((u8 *)payload) + MCI_GPM_COEX_B_HALT_STATE) =
 216                         MCI_GPM_COEX_BT_GPM_HALT;
 217         } else
 218                 *(((u8 *)payload) + MCI_GPM_COEX_B_HALT_STATE) =
 219                         MCI_GPM_COEX_BT_GPM_UNHALT;
 220
 221         ar9003_mci_send_message(ah, MCI_GPM, 0, payload, 16, wait_done, true);
 222 }
 223
 224 static void ar9003_mci_prep_interface(struct ath_hw *ah)
 225 {
 226         struct ath_common *common = ath9k_hw_common(ah);
 227         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 228         u32 saved_mci_int_en;
 229         u32 mci_timeout = 150;
 230
 231         mci->bt_state = MCI_BT_SLEEP;
 232         saved_mci_int_en = REG_READ(ah, AR_MCI_INTERRUPT_EN);
 233
 234         REG_WRITE(ah, AR_MCI_INTERRUPT_EN, 0);
 235         REG_WRITE(ah, AR_MCI_INTERRUPT_RX_MSG_RAW,
 236                   REG_READ(ah, AR_MCI_INTERRUPT_RX_MSG_RAW));
 237         REG_WRITE(ah, AR_MCI_INTERRUPT_RAW,
 238                   REG_READ(ah, AR_MCI_INTERRUPT_RAW));
 239
 240         ar9003_mci_remote_reset(ah, true);
 241         ar9003_mci_send_req_wake(ah, true);
 242
 243         if (!ar9003_mci_wait_for_interrupt(ah, AR_MCI_INTERRUPT_RX_MSG_RAW,
 244                                   AR_MCI_INTERRUPT_RX_MSG_SYS_WAKING, 500))
 245                 goto clear_redunt;
 246
 247         mci->bt_state = MCI_BT_AWAKE;
 248
 249         /*
 250          * we don't need to send more remote_reset at this moment.
 251          * If BT receive first remote_reset, then BT HW will
 252          * be cleaned up and will be able to receive req_wake
 253          * and BT HW will respond sys_waking.
 254          * In this case, WLAN will receive BT's HW sys_waking.
 255          * Otherwise, if BT SW missed initial remote_reset,
 256          * that remote_reset will still clean up BT MCI RX,
 257          * and the req_wake will wake BT up,
 258          * and BT SW will respond this req_wake with a remote_reset and
 259          * sys_waking. In this case, WLAN will receive BT's SW
 260          * sys_waking. In either case, BT's RX is cleaned up. So we
 261          * don't need to reply BT's remote_reset now, if any.
 262          * Similarly, if in any case, WLAN can receive BT's sys_waking,
 263          * that means WLAN's RX is also fine.
 264          */
 265         ar9003_mci_send_sys_waking(ah, true);
 266         udelay(10);
 267
 268         /*
 269          * Set BT priority interrupt value to be 0xff to
 270          * avoid having too many BT PRIORITY interrupts.
 271          */
 272         REG_WRITE(ah, AR_MCI_BT_PRI0, 0xFFFFFFFF);
 273         REG_WRITE(ah, AR_MCI_BT_PRI1, 0xFFFFFFFF);
 274         REG_WRITE(ah, AR_MCI_BT_PRI2, 0xFFFFFFFF);
 275         REG_WRITE(ah, AR_MCI_BT_PRI3, 0xFFFFFFFF);
 276         REG_WRITE(ah, AR_MCI_BT_PRI, 0X000000FF);
 277
 278         /*
 279          * A contention reset will be received after send out
 280          * sys_waking. Also BT priority interrupt bits will be set.
 281          * Clear those bits before the next step.
 282          */
 283
 284         REG_WRITE(ah, AR_MCI_INTERRUPT_RX_MSG_RAW,
 285                   AR_MCI_INTERRUPT_RX_MSG_CONT_RST);
 286         REG_WRITE(ah, AR_MCI_INTERRUPT_RAW, AR_MCI_INTERRUPT_BT_PRI);
 287
 288         if (mci->is_2g && MCI_ANT_ARCH_PA_LNA_SHARED(mci)) {
 289                 ar9003_mci_send_lna_transfer(ah, true);
 290                 udelay(5);
 291         }
 292
 293         if (mci->is_2g && !mci->update_2g5g && MCI_ANT_ARCH_PA_LNA_SHARED(mci)) {
 294                 if (ar9003_mci_wait_for_interrupt(ah,
 295                                         AR_MCI_INTERRUPT_RX_MSG_RAW,
 296                                         AR_MCI_INTERRUPT_RX_MSG_LNA_INFO,
 297                                         mci_timeout))
 298                         ath_dbg(common, MCI,
 299                                 "MCI WLAN has control over the LNA & BT obeys it\n");
 300                 else
 301                         ath_dbg(common, MCI,
 302                                 "MCI BT didn't respond to LNA_TRANS\n");
 303         }
 304
 305 clear_redunt:
 306         /* Clear the extra redundant SYS_WAKING from BT */
 307         if ((mci->bt_state == MCI_BT_AWAKE) &&
 308             (REG_READ_FIELD(ah, AR_MCI_INTERRUPT_RX_MSG_RAW,
 309                             AR_MCI_INTERRUPT_RX_MSG_SYS_WAKING)) &&
 310             (REG_READ_FIELD(ah, AR_MCI_INTERRUPT_RX_MSG_RAW,
 311                             AR_MCI_INTERRUPT_RX_MSG_SYS_SLEEPING) == 0)) {
 312                 REG_WRITE(ah, AR_MCI_INTERRUPT_RX_MSG_RAW,
 313                           AR_MCI_INTERRUPT_RX_MSG_SYS_WAKING);
 314                 REG_WRITE(ah, AR_MCI_INTERRUPT_RAW,
 315                           AR_MCI_INTERRUPT_REMOTE_SLEEP_UPDATE);
 316         }
 317
 318         REG_WRITE(ah, AR_MCI_INTERRUPT_EN, saved_mci_int_en);
 319 }
 320
 321 void ar9003_mci_set_full_sleep(struct ath_hw *ah)
 322 {
 323         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 324
 325         if (ar9003_mci_state(ah, MCI_STATE_ENABLE) &&
 326             (mci->bt_state != MCI_BT_SLEEP) &&
 327             !mci->halted_bt_gpm) {
 328                 ar9003_mci_send_coex_halt_bt_gpm(ah, true, true);
 329         }
 330
 331         mci->ready = false;
 332 }
 333
 334 static void ar9003_mci_disable_interrupt(struct ath_hw *ah)
 335 {
 336         REG_WRITE(ah, AR_MCI_INTERRUPT_EN, 0);
 337         REG_WRITE(ah, AR_MCI_INTERRUPT_RX_MSG_EN, 0);
 338 }
 339
 340 static void ar9003_mci_enable_interrupt(struct ath_hw *ah)
 341 {
 342         REG_WRITE(ah, AR_MCI_INTERRUPT_EN, AR_MCI_INTERRUPT_DEFAULT);
 343         REG_WRITE(ah, AR_MCI_INTERRUPT_RX_MSG_EN,
 344                   AR_MCI_INTERRUPT_RX_MSG_DEFAULT);
 345 }
 346
 347 static bool ar9003_mci_check_int(struct ath_hw *ah, u32 ints)
 348 {
 349         u32 intr;
 350
 351         intr = REG_READ(ah, AR_MCI_INTERRUPT_RX_MSG_RAW);
 352         return ((intr & ints) == ints);
 353 }
 354
 355 void ar9003_mci_get_interrupt(struct ath_hw *ah, u32 *raw_intr,
 356                               u32 *rx_msg_intr)
 357 {
 358         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 359
 360         *raw_intr = mci->raw_intr;
 361         *rx_msg_intr = mci->rx_msg_intr;
 362
 363         /* Clean int bits after the values are read. */
 364         mci->raw_intr = 0;
 365         mci->rx_msg_intr = 0;
 366 }
 367 EXPORT_SYMBOL(ar9003_mci_get_interrupt);
 368
 369 void ar9003_mci_get_isr(struct ath_hw *ah, enum ath9k_int *masked)
 370 {
 371         struct ath_common *common = ath9k_hw_common(ah);
 372         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 373         u32 raw_intr, rx_msg_intr;
 374
 375         rx_msg_intr = REG_READ(ah, AR_MCI_INTERRUPT_RX_MSG_RAW);
 376         raw_intr = REG_READ(ah, AR_MCI_INTERRUPT_RAW);
 377
 378         if ((raw_intr == 0xdeadbeef) || (rx_msg_intr == 0xdeadbeef)) {
 379                 ath_dbg(common, MCI,
 380                         "MCI gets 0xdeadbeef during int processing\n");
 381         } else {
 382                 mci->rx_msg_intr |= rx_msg_intr;
 383                 mci->raw_intr |= raw_intr;
 384                 *masked |= ATH9K_INT_MCI;
 385
 386                 if (rx_msg_intr & AR_MCI_INTERRUPT_RX_MSG_CONT_INFO)
 387                         mci->cont_status = REG_READ(ah, AR_MCI_CONT_STATUS);
 388
 389                 REG_WRITE(ah, AR_MCI_INTERRUPT_RX_MSG_RAW, rx_msg_intr);
 390                 REG_WRITE(ah, AR_MCI_INTERRUPT_RAW, raw_intr);
 391         }
 392 }
 393
 394 static void ar9003_mci_2g5g_changed(struct ath_hw *ah, bool is_2g)
 395 {
 396         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 397
 398         if (!mci->update_2g5g &&
 399             (mci->is_2g != is_2g))
 400                 mci->update_2g5g = true;
 401
 402         mci->is_2g = is_2g;
 403 }
 404
 405 static bool ar9003_mci_is_gpm_valid(struct ath_hw *ah, u32 msg_index)
 406 {
 407         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 408         u32 *payload;
 409         u32 recv_type, offset;
 410
 411         if (msg_index == MCI_GPM_INVALID)
 412                 return false;
 413
 414         offset = msg_index << 4;
 415
 416         payload = (u32 *)(mci->gpm_buf + offset);
 417         recv_type = MCI_GPM_TYPE(payload);
 418
 419         if (recv_type == MCI_GPM_RSVD_PATTERN)
 420                 return false;
 421
 422         return true;
 423 }
 424
 425 static void ar9003_mci_observation_set_up(struct ath_hw *ah)
 426 {
 427         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 428
 429         if (mci->config & ATH_MCI_CONFIG_MCI_OBS_MCI) {
 430                 ath9k_hw_gpio_request_out(ah, 3, NULL,
 431                                           AR_GPIO_OUTPUT_MUX_AS_MCI_WLAN_DATA);
 432                 ath9k_hw_gpio_request_out(ah, 2, NULL,
 433                                           AR_GPIO_OUTPUT_MUX_AS_MCI_WLAN_CLK);
 434                 ath9k_hw_gpio_request_out(ah, 1, NULL,
 435                                           AR_GPIO_OUTPUT_MUX_AS_MCI_BT_DATA);
 436                 ath9k_hw_gpio_request_out(ah, 0, NULL,
 437                                           AR_GPIO_OUTPUT_MUX_AS_MCI_BT_CLK);
 438         } else if (mci->config & ATH_MCI_CONFIG_MCI_OBS_TXRX) {
 439                 ath9k_hw_gpio_request_out(ah, 3, NULL,
 440                                           AR_GPIO_OUTPUT_MUX_AS_WL_IN_TX);
 441                 ath9k_hw_gpio_request_out(ah, 2, NULL,
 442                                           AR_GPIO_OUTPUT_MUX_AS_WL_IN_RX);
 443                 ath9k_hw_gpio_request_out(ah, 1, NULL,
 444                                           AR_GPIO_OUTPUT_MUX_AS_BT_IN_TX);
 445                 ath9k_hw_gpio_request_out(ah, 0, NULL,
 446                                           AR_GPIO_OUTPUT_MUX_AS_BT_IN_RX);
 447                 ath9k_hw_gpio_request_out(ah, 5, NULL,
 448                                           AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
 449         } else if (mci->config & ATH_MCI_CONFIG_MCI_OBS_BT) {
 450                 ath9k_hw_gpio_request_out(ah, 3, NULL,
 451                                           AR_GPIO_OUTPUT_MUX_AS_BT_IN_TX);
 452                 ath9k_hw_gpio_request_out(ah, 2, NULL,
 453                                           AR_GPIO_OUTPUT_MUX_AS_BT_IN_RX);
 454                 ath9k_hw_gpio_request_out(ah, 1, NULL,
 455                                           AR_GPIO_OUTPUT_MUX_AS_MCI_BT_DATA);
 456                 ath9k_hw_gpio_request_out(ah, 0, NULL,
 457                                           AR_GPIO_OUTPUT_MUX_AS_MCI_BT_CLK);
 458         } else
 459                 return;
 460
 461         REG_SET_BIT(ah, AR_GPIO_INPUT_EN_VAL, AR_GPIO_JTAG_DISABLE);
 462
 463         REG_RMW_FIELD(ah, AR_PHY_GLB_CONTROL, AR_GLB_DS_JTAG_DISABLE, 1);
 464         REG_RMW_FIELD(ah, AR_PHY_GLB_CONTROL, AR_GLB_WLAN_UART_INTF_EN, 0);
 465         REG_SET_BIT(ah, AR_GLB_GPIO_CONTROL, ATH_MCI_CONFIG_MCI_OBS_GPIO);
 466
 467         REG_RMW_FIELD(ah, AR_BTCOEX_CTRL2, AR_BTCOEX_CTRL2_GPIO_OBS_SEL, 0);
 468         REG_RMW_FIELD(ah, AR_BTCOEX_CTRL2, AR_BTCOEX_CTRL2_MAC_BB_OBS_SEL, 1);
 469         REG_WRITE(ah, AR_OBS, 0x4b);
 470         REG_RMW_FIELD(ah, AR_DIAG_SW, AR_DIAG_OBS_PT_SEL1, 0x03);
 471         REG_RMW_FIELD(ah, AR_DIAG_SW, AR_DIAG_OBS_PT_SEL2, 0x01);
 472         REG_RMW_FIELD(ah, AR_MACMISC, AR_MACMISC_MISC_OBS_BUS_LSB, 0x02);
 473         REG_RMW_FIELD(ah, AR_MACMISC, AR_MACMISC_MISC_OBS_BUS_MSB, 0x03);
 474         REG_RMW_FIELD(ah, AR_PHY_TEST_CTL_STATUS,
 475                       AR_PHY_TEST_CTL_DEBUGPORT_SEL, 0x07);
 476 }
 477
 478 static bool ar9003_mci_send_coex_bt_flags(struct ath_hw *ah, bool wait_done,
 479                                           u8 opcode, u32 bt_flags)
 480 {
 481         u32 pld[4] = {0, 0, 0, 0};
 482
 483         MCI_GPM_SET_TYPE_OPCODE(pld, MCI_GPM_COEX_AGENT,
 484                                 MCI_GPM_COEX_BT_UPDATE_FLAGS);
 485
 486         *(((u8 *)pld) + MCI_GPM_COEX_B_BT_FLAGS_OP)  = opcode;
 487         *(((u8 *)pld) + MCI_GPM_COEX_W_BT_FLAGS + 0) = bt_flags & 0xFF;
 488         *(((u8 *)pld) + MCI_GPM_COEX_W_BT_FLAGS + 1) = (bt_flags >> 8) & 0xFF;
 489         *(((u8 *)pld) + MCI_GPM_COEX_W_BT_FLAGS + 2) = (bt_flags >> 16) & 0xFF;
 490         *(((u8 *)pld) + MCI_GPM_COEX_W_BT_FLAGS + 3) = (bt_flags >> 24) & 0xFF;
 491
 492         return ar9003_mci_send_message(ah, MCI_GPM, 0, pld, 16,
 493                                        wait_done, true);
 494 }
 495
 496 static void ar9003_mci_sync_bt_state(struct ath_hw *ah)
 497 {
 498         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 499         u32 cur_bt_state;
 500
 501         cur_bt_state = ar9003_mci_state(ah, MCI_STATE_REMOTE_SLEEP);
 502
 503         if (mci->bt_state != cur_bt_state)
 504                 mci->bt_state = cur_bt_state;
 505
 506         if (mci->bt_state != MCI_BT_SLEEP) {
 507
 508                 ar9003_mci_send_coex_version_query(ah, true);
 509                 ar9003_mci_send_coex_wlan_channels(ah, true);
 510
 511                 if (mci->unhalt_bt_gpm == true)
 512                         ar9003_mci_send_coex_halt_bt_gpm(ah, false, true);
 513         }
 514 }
 515
 516 void ar9003_mci_check_bt(struct ath_hw *ah)
 517 {
 518         struct ath9k_hw_mci *mci_hw = &ah->btcoex_hw.mci;
 519
 520         if (!mci_hw->ready)
 521                 return;
 522
 523         /*
 524          * check BT state again to make
 525          * sure it's not changed.
 526          */
 527         ar9003_mci_sync_bt_state(ah);
 528         ar9003_mci_2g5g_switch(ah, true);
 529
 530         if ((mci_hw->bt_state == MCI_BT_AWAKE) &&
 531             (mci_hw->query_bt == true)) {
 532                 mci_hw->need_flush_btinfo = true;
 533         }
 534 }
 535
 536 static void ar9003_mci_process_gpm_extra(struct ath_hw *ah, u8 gpm_type,
 537                                          u8 gpm_opcode, u32 *p_gpm)
 538 {
 539         struct ath_common *common = ath9k_hw_common(ah);
 540         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 541         u8 *p_data = (u8 *) p_gpm;
 542
 543         if (gpm_type != MCI_GPM_COEX_AGENT)
 544                 return;
 545
 546         switch (gpm_opcode) {
 547         case MCI_GPM_COEX_VERSION_QUERY:
 548                 ath_dbg(common, MCI, "MCI Recv GPM COEX Version Query\n");
 549                 ar9003_mci_send_coex_version_response(ah, true);
 550                 break;
 551         case MCI_GPM_COEX_VERSION_RESPONSE:
 552                 ath_dbg(common, MCI, "MCI Recv GPM COEX Version Response\n");
 553                 mci->bt_ver_major =
 554                         *(p_data + MCI_GPM_COEX_B_MAJOR_VERSION);
 555                 mci->bt_ver_minor =
 556                         *(p_data + MCI_GPM_COEX_B_MINOR_VERSION);
 557                 mci->bt_version_known = true;
 558                 ath_dbg(common, MCI, "MCI BT Coex version: %d.%d\n",
 559                         mci->bt_ver_major, mci->bt_ver_minor);
 560                 break;
 561         case MCI_GPM_COEX_STATUS_QUERY:
 562                 ath_dbg(common, MCI,
 563                         "MCI Recv GPM COEX Status Query = 0x%02X\n",
 564                         *(p_data + MCI_GPM_COEX_B_WLAN_BITMAP));
 565                 mci->wlan_channels_update = true;
 566                 ar9003_mci_send_coex_wlan_channels(ah, true);
 567                 break;
 568         case MCI_GPM_COEX_BT_PROFILE_INFO:
 569                 mci->query_bt = true;
 570                 ath_dbg(common, MCI, "MCI Recv GPM COEX BT_Profile_Info\n");
 571                 break;
 572         case MCI_GPM_COEX_BT_STATUS_UPDATE:
 573                 mci->query_bt = true;
 574                 ath_dbg(common, MCI,
 575                         "MCI Recv GPM COEX BT_Status_Update SEQ=%d (drop&query)\n",
 576                         *(p_gpm + 3));
 577                 break;
 578         default:
 579                 break;
 580         }
 581 }
 582
 583 static u32 ar9003_mci_wait_for_gpm(struct ath_hw *ah, u8 gpm_type,
 584                                    u8 gpm_opcode, int time_out)
 585 {
 586         struct ath_common *common = ath9k_hw_common(ah);
 587         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 588         u32 *p_gpm = NULL, mismatch = 0, more_data;
 589         u32 offset;
 590         u8 recv_type = 0, recv_opcode = 0;
 591         bool b_is_bt_cal_done = (gpm_type == MCI_GPM_BT_CAL_DONE);
 592
 593         more_data = time_out ? MCI_GPM_NOMORE : MCI_GPM_MORE;
 594
 595         while (time_out > 0) {
 596                 if (p_gpm) {
 597                         MCI_GPM_RECYCLE(p_gpm);
 598                         p_gpm = NULL;
 599                 }
 600
 601                 if (more_data != MCI_GPM_MORE)
 602                         time_out = ar9003_mci_wait_for_interrupt(ah,
 603                                         AR_MCI_INTERRUPT_RX_MSG_RAW,
 604                                         AR_MCI_INTERRUPT_RX_MSG_GPM,
 605                                         time_out);
 606
 607                 if (!time_out)
 608                         break;
 609
 610                 offset = ar9003_mci_get_next_gpm_offset(ah, &more_data);
 611
 612                 if (offset == MCI_GPM_INVALID)
 613                         continue;
 614
 615                 p_gpm = (u32 *) (mci->gpm_buf + offset);
 616                 recv_type = MCI_GPM_TYPE(p_gpm);
 617                 recv_opcode = MCI_GPM_OPCODE(p_gpm);
 618
 619                 if (MCI_GPM_IS_CAL_TYPE(recv_type)) {
 620                         if (recv_type == gpm_type) {
 621                                 if ((gpm_type == MCI_GPM_BT_CAL_DONE) &&
 622                                     !b_is_bt_cal_done) {
 623                                         gpm_type = MCI_GPM_BT_CAL_GRANT;
 624                                         continue;
 625                                 }
 626                                 break;
 627                         }
 628                 } else if ((recv_type == gpm_type) &&
 629                            (recv_opcode == gpm_opcode))
 630                         break;
 631
 632                 /*
 633                  * check if it's cal_grant
 634                  *
 635                  * When we're waiting for cal_grant in reset routine,
 636                  * it's possible that BT sends out cal_request at the
 637                  * same time. Since BT's calibration doesn't happen
 638                  * that often, we'll let BT completes calibration then
 639                  * we continue to wait for cal_grant from BT.
 640                  * Orginal: Wait BT_CAL_GRANT.
 641                  * New: Receive BT_CAL_REQ -> send WLAN_CAL_GRANT->wait
 642                  * BT_CAL_DONE -> Wait BT_CAL_GRANT.
 643                  */
 644
 645                 if ((gpm_type == MCI_GPM_BT_CAL_GRANT) &&
 646                     (recv_type == MCI_GPM_BT_CAL_REQ)) {
 647
 648                         u32 payload[4] = {0, 0, 0, 0};
 649
 650                         gpm_type = MCI_GPM_BT_CAL_DONE;
 651                         MCI_GPM_SET_CAL_TYPE(payload,
 652                                              MCI_GPM_WLAN_CAL_GRANT);
 653                         ar9003_mci_send_message(ah, MCI_GPM, 0, payload, 16,
 654                                                 false, false);
 655                         continue;
 656                 } else {
 657                         ath_dbg(common, MCI, "MCI GPM subtype not match 0x%x\n",
 658                                 *(p_gpm + 1));
 659                         mismatch++;
 660                         ar9003_mci_process_gpm_extra(ah, recv_type,
 661                                                      recv_opcode, p_gpm);
 662                 }
 663         }
 664
 665         if (p_gpm) {
 666                 MCI_GPM_RECYCLE(p_gpm);
 667                 p_gpm = NULL;
 668         }
 669
 670         if (time_out <= 0)
 671                 time_out = 0;
 672
 673         while (more_data == MCI_GPM_MORE) {
 674                 offset = ar9003_mci_get_next_gpm_offset(ah, &more_data);
 675                 if (offset == MCI_GPM_INVALID)
 676                         break;
 677
 678                 p_gpm = (u32 *) (mci->gpm_buf + offset);
 679                 recv_type = MCI_GPM_TYPE(p_gpm);
 680                 recv_opcode = MCI_GPM_OPCODE(p_gpm);
 681
 682                 if (!MCI_GPM_IS_CAL_TYPE(recv_type))
 683                         ar9003_mci_process_gpm_extra(ah, recv_type,
 684                                                      recv_opcode, p_gpm);
 685
 686                 MCI_GPM_RECYCLE(p_gpm);
 687         }
 688
 689         return time_out;
 690 }
 691
 692 bool ar9003_mci_start_reset(struct ath_hw *ah, struct ath9k_channel *chan)
 693 {
 694         struct ath_common *common = ath9k_hw_common(ah);
 695         struct ath9k_hw_mci *mci_hw = &ah->btcoex_hw.mci;
 696         u32 payload[4] = {0, 0, 0, 0};
 697
 698         ar9003_mci_2g5g_changed(ah, IS_CHAN_2GHZ(chan));
 699
 700         if (mci_hw->bt_state != MCI_BT_CAL_START)
 701                 return false;
 702
 703         mci_hw->bt_state = MCI_BT_CAL;
 704
 705         /*
 706          * MCI FIX: disable mci interrupt here. This is to avoid
 707          * SW_MSG_DONE or RX_MSG bits to trigger MCI_INT and
 708          * lead to mci_intr reentry.
 709          */
 710         ar9003_mci_disable_interrupt(ah);
 711
 712         MCI_GPM_SET_CAL_TYPE(payload, MCI_GPM_WLAN_CAL_GRANT);
 713         ar9003_mci_send_message(ah, MCI_GPM, 0, payload,
 714                                 16, true, false);
 715
 716         /* Wait BT calibration to be completed for 25ms */
 717
 718         if (ar9003_mci_wait_for_gpm(ah, MCI_GPM_BT_CAL_DONE,
 719                                     0, 25000))
 720                 ath_dbg(common, MCI, "MCI BT_CAL_DONE received\n");
 721         else
 722                 ath_dbg(common, MCI,
 723                         "MCI BT_CAL_DONE not received\n");
 724
 725         mci_hw->bt_state = MCI_BT_AWAKE;
 726         /* MCI FIX: enable mci interrupt here */
 727         ar9003_mci_enable_interrupt(ah);
 728
 729         return true;
 730 }
 731
 732 int ar9003_mci_end_reset(struct ath_hw *ah, struct ath9k_channel *chan,
 733                          struct ath9k_hw_cal_data *caldata)
 734 {
 735         struct ath9k_hw_mci *mci_hw = &ah->btcoex_hw.mci;
 736
 737         if (!mci_hw->ready)
 738                 return 0;
 739
 740         if (!IS_CHAN_2GHZ(chan) || (mci_hw->bt_state != MCI_BT_SLEEP))
 741                 goto exit;
 742
 743         if (!ar9003_mci_check_int(ah, AR_MCI_INTERRUPT_RX_MSG_REMOTE_RESET) &&
 744             !ar9003_mci_check_int(ah, AR_MCI_INTERRUPT_RX_MSG_REQ_WAKE))
 745                 goto exit;
 746
 747         /*
 748          * BT is sleeping. Check if BT wakes up during
 749          * WLAN calibration. If BT wakes up during
 750          * WLAN calibration, need to go through all
 751          * message exchanges again and recal.
 752          */
 753         REG_WRITE(ah, AR_MCI_INTERRUPT_RX_MSG_RAW,
 754                   (AR_MCI_INTERRUPT_RX_MSG_REMOTE_RESET |
 755                    AR_MCI_INTERRUPT_RX_MSG_REQ_WAKE));
 756
 757         ar9003_mci_remote_reset(ah, true);
 758         ar9003_mci_send_sys_waking(ah, true);
 759         udelay(1);
 760
 761         if (IS_CHAN_2GHZ(chan))
 762                 ar9003_mci_send_lna_transfer(ah, true);
 763
 764         mci_hw->bt_state = MCI_BT_AWAKE;
 765
 766         REG_CLR_BIT(ah, AR_PHY_TIMING4,
 767                     1 << AR_PHY_TIMING_CONTROL4_DO_GAIN_DC_IQ_CAL_SHIFT);
 768
 769         if (caldata) {
 770                 clear_bit(TXIQCAL_DONE, &caldata->cal_flags);
 771                 clear_bit(TXCLCAL_DONE, &caldata->cal_flags);
 772                 clear_bit(RTT_DONE, &caldata->cal_flags);
 773         }
 774
 775         if (!ath9k_hw_init_cal(ah, chan))
 776                 return -EIO;
 777
 778         REG_SET_BIT(ah, AR_PHY_TIMING4,
 779                     1 << AR_PHY_TIMING_CONTROL4_DO_GAIN_DC_IQ_CAL_SHIFT);
 780
 781 exit:
 782         ar9003_mci_enable_interrupt(ah);
 783         return 0;
 784 }
 785
 786 static void ar9003_mci_mute_bt(struct ath_hw *ah)
 787 {
 788         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 789
 790         /* disable all MCI messages */
 791         REG_WRITE(ah, AR_MCI_MSG_ATTRIBUTES_TABLE, 0xffff0000);
 792         REG_WRITE(ah, AR_BTCOEX_WL_WEIGHTS0, 0xffffffff);
 793         REG_WRITE(ah, AR_BTCOEX_WL_WEIGHTS1, 0xffffffff);
 794         REG_WRITE(ah, AR_BTCOEX_WL_WEIGHTS2, 0xffffffff);
 795         REG_WRITE(ah, AR_BTCOEX_WL_WEIGHTS3, 0xffffffff);
 796         REG_SET_BIT(ah, AR_MCI_TX_CTRL, AR_MCI_TX_CTRL_DISABLE_LNA_UPDATE);
 797
 798         /* wait pending HW messages to flush out */
 799         udelay(10);
 800
 801         /*
 802          * Send LNA_TAKE and SYS_SLEEPING when
 803          * 1. reset not after resuming from full sleep
 804          * 2. before reset MCI RX, to quiet BT and avoid MCI RX misalignment
 805          */
 806         if (MCI_ANT_ARCH_PA_LNA_SHARED(mci)) {
 807                 ar9003_mci_send_lna_take(ah, true);
 808                 udelay(5);
 809         }
 810
 811         ar9003_mci_send_sys_sleeping(ah, true);
 812 }
 813
 814 static void ar9003_mci_osla_setup(struct ath_hw *ah, bool enable)
 815 {
 816         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 817         u32 thresh;
 818
 819         if (!enable) {
 820                 REG_CLR_BIT(ah, AR_BTCOEX_CTRL,
 821                             AR_BTCOEX_CTRL_ONE_STEP_LOOK_AHEAD_EN);
 822                 return;
 823         }
 824         REG_RMW_FIELD(ah, AR_MCI_SCHD_TABLE_2, AR_MCI_SCHD_TABLE_2_HW_BASED, 1);
 825         REG_RMW_FIELD(ah, AR_MCI_SCHD_TABLE_2,
 826                       AR_MCI_SCHD_TABLE_2_MEM_BASED, 1);
 827
 828         if (AR_SREV_9565(ah))
 829                 REG_RMW_FIELD(ah, AR_MCI_MISC, AR_MCI_MISC_HW_FIX_EN, 1);
 830
 831         if (!(mci->config & ATH_MCI_CONFIG_DISABLE_AGGR_THRESH)) {
 832                 thresh = MS(mci->config, ATH_MCI_CONFIG_AGGR_THRESH);
 833                 REG_RMW_FIELD(ah, AR_BTCOEX_CTRL,
 834                               AR_BTCOEX_CTRL_AGGR_THRESH, thresh);
 835                 REG_RMW_FIELD(ah, AR_BTCOEX_CTRL,
 836                               AR_BTCOEX_CTRL_TIME_TO_NEXT_BT_THRESH_EN, 1);
 837         } else
 838                 REG_RMW_FIELD(ah, AR_BTCOEX_CTRL,
 839                               AR_BTCOEX_CTRL_TIME_TO_NEXT_BT_THRESH_EN, 0);
 840
 841         REG_RMW_FIELD(ah, AR_BTCOEX_CTRL,
 842                       AR_BTCOEX_CTRL_ONE_STEP_LOOK_AHEAD_EN, 1);
 843 }
 844
 845 static void ar9003_mci_stat_setup(struct ath_hw *ah)
 846 {
 847         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 848
 849         if (!AR_SREV_9565(ah))
 850                 return;
 851
 852         if (mci->config & ATH_MCI_CONFIG_MCI_STAT_DBG) {
 853                 REG_RMW_FIELD(ah, AR_MCI_DBG_CNT_CTRL,
 854                               AR_MCI_DBG_CNT_CTRL_ENABLE, 1);
 855                 REG_RMW_FIELD(ah, AR_MCI_DBG_CNT_CTRL,
 856                               AR_MCI_DBG_CNT_CTRL_BT_LINKID,
 857                               MCI_STAT_ALL_BT_LINKID);
 858         } else {
 859                 REG_RMW_FIELD(ah, AR_MCI_DBG_CNT_CTRL,
 860                               AR_MCI_DBG_CNT_CTRL_ENABLE, 0);
 861         }
 862 }
 863
 864 static void ar9003_mci_set_btcoex_ctrl_9565_1ANT(struct ath_hw *ah)
 865 {
 866         u32 regval;
 867
 868         regval = SM(1, AR_BTCOEX_CTRL_AR9462_MODE) |
 869                  SM(1, AR_BTCOEX_CTRL_WBTIMER_EN) |
 870                  SM(1, AR_BTCOEX_CTRL_PA_SHARED) |
 871                  SM(1, AR_BTCOEX_CTRL_LNA_SHARED) |
 872                  SM(1, AR_BTCOEX_CTRL_NUM_ANTENNAS) |
 873                  SM(1, AR_BTCOEX_CTRL_RX_CHAIN_MASK) |
 874                  SM(0, AR_BTCOEX_CTRL_1_CHAIN_ACK) |
 875                  SM(0, AR_BTCOEX_CTRL_1_CHAIN_BCN) |
 876                  SM(0, AR_BTCOEX_CTRL_ONE_STEP_LOOK_AHEAD_EN);
 877
 878         REG_RMW_FIELD(ah, AR_BTCOEX_CTRL2,
 879                       AR_BTCOEX_CTRL2_TX_CHAIN_MASK, 0x1);
 880         REG_WRITE(ah, AR_BTCOEX_CTRL, regval);
 881 }
 882
 883 static void ar9003_mci_set_btcoex_ctrl_9565_2ANT(struct ath_hw *ah)
 884 {
 885         u32 regval;
 886
 887         regval = SM(1, AR_BTCOEX_CTRL_AR9462_MODE) |
 888                  SM(1, AR_BTCOEX_CTRL_WBTIMER_EN) |
 889                  SM(0, AR_BTCOEX_CTRL_PA_SHARED) |
 890                  SM(0, AR_BTCOEX_CTRL_LNA_SHARED) |
 891                  SM(2, AR_BTCOEX_CTRL_NUM_ANTENNAS) |
 892                  SM(1, AR_BTCOEX_CTRL_RX_CHAIN_MASK) |
 893                  SM(0, AR_BTCOEX_CTRL_1_CHAIN_ACK) |
 894                  SM(0, AR_BTCOEX_CTRL_1_CHAIN_BCN) |
 895                  SM(0, AR_BTCOEX_CTRL_ONE_STEP_LOOK_AHEAD_EN);
 896
 897         REG_RMW_FIELD(ah, AR_BTCOEX_CTRL2,
 898                       AR_BTCOEX_CTRL2_TX_CHAIN_MASK, 0x0);
 899         REG_WRITE(ah, AR_BTCOEX_CTRL, regval);
 900 }
 901
 902 static void ar9003_mci_set_btcoex_ctrl_9462(struct ath_hw *ah)
 903 {
 904         u32 regval;
 905
 906         regval = SM(1, AR_BTCOEX_CTRL_AR9462_MODE) |
 907                  SM(1, AR_BTCOEX_CTRL_WBTIMER_EN) |
 908                  SM(1, AR_BTCOEX_CTRL_PA_SHARED) |
 909                  SM(1, AR_BTCOEX_CTRL_LNA_SHARED) |
 910                  SM(2, AR_BTCOEX_CTRL_NUM_ANTENNAS) |
 911                  SM(3, AR_BTCOEX_CTRL_RX_CHAIN_MASK) |
 912                  SM(0, AR_BTCOEX_CTRL_1_CHAIN_ACK) |
 913                  SM(0, AR_BTCOEX_CTRL_1_CHAIN_BCN) |
 914                  SM(0, AR_BTCOEX_CTRL_ONE_STEP_LOOK_AHEAD_EN);
 915
 916         REG_WRITE(ah, AR_BTCOEX_CTRL, regval);
 917 }
 918
 919 int ar9003_mci_reset(struct ath_hw *ah, bool en_int, bool is_2g,
 920                      bool is_full_sleep)
 921 {
 922         struct ath_common *common = ath9k_hw_common(ah);
 923         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 924         u32 regval, i;
 925
 926         ath_dbg(common, MCI, "MCI Reset (full_sleep = %d, is_2g = %d)\n",
 927                 is_full_sleep, is_2g);
 928
 929         if (REG_READ(ah, AR_BTCOEX_CTRL) == 0xdeadbeef) {
 930                 ath_err(common, "BTCOEX control register is dead\n");
 931                 return -EINVAL;
 932         }
 933
 934         /* Program MCI DMA related registers */
 935         REG_WRITE(ah, AR_MCI_GPM_0, mci->gpm_addr);
 936         REG_WRITE(ah, AR_MCI_GPM_1, mci->gpm_len);
 937         REG_WRITE(ah, AR_MCI_SCHD_TABLE_0, mci->sched_addr);
 938
 939         /*
 940         * To avoid MCI state machine be affected by incoming remote MCI msgs,
 941         * MCI mode will be enabled later, right before reset the MCI TX and RX.
 942         */
 943         if (AR_SREV_9565(ah)) {
 944                 u8 ant = MS(mci->config, ATH_MCI_CONFIG_ANT_ARCH);
 945
 946                 if (ant == ATH_MCI_ANT_ARCH_1_ANT_PA_LNA_SHARED)
 947                         ar9003_mci_set_btcoex_ctrl_9565_1ANT(ah);
 948                 else
 949                         ar9003_mci_set_btcoex_ctrl_9565_2ANT(ah);
 950         } else {
 951                 ar9003_mci_set_btcoex_ctrl_9462(ah);
 952         }
 953
 954         if (is_2g && !(mci->config & ATH_MCI_CONFIG_DISABLE_OSLA))
 955                 ar9003_mci_osla_setup(ah, true);
 956         else
 957                 ar9003_mci_osla_setup(ah, false);
 958
 959         REG_SET_BIT(ah, AR_PHY_GLB_CONTROL,
 960                     AR_BTCOEX_CTRL_SPDT_ENABLE);
 961         REG_RMW_FIELD(ah, AR_BTCOEX_CTRL3,
 962                       AR_BTCOEX_CTRL3_CONT_INFO_TIMEOUT, 20);
 963
 964         REG_RMW_FIELD(ah, AR_BTCOEX_CTRL2, AR_BTCOEX_CTRL2_RX_DEWEIGHT, 0);
 965         REG_RMW_FIELD(ah, AR_PCU_MISC, AR_PCU_BT_ANT_PREVENT_RX, 0);
 966
 967         /* Set the time out to 3.125ms (5 BT slots) */
 968         REG_RMW_FIELD(ah, AR_BTCOEX_WL_LNA, AR_BTCOEX_WL_LNA_TIMEOUT, 0x3D090);
 969
 970         /* concurrent tx priority */
 971         if (mci->config & ATH_MCI_CONFIG_CONCUR_TX) {
 972                 REG_RMW_FIELD(ah, AR_BTCOEX_CTRL2,
 973                               AR_BTCOEX_CTRL2_DESC_BASED_TXPWR_ENABLE, 0);
 974                 REG_RMW_FIELD(ah, AR_BTCOEX_CTRL2,
 975                               AR_BTCOEX_CTRL2_TXPWR_THRESH, 0x7f);
 976                 REG_RMW_FIELD(ah, AR_BTCOEX_CTRL,
 977                               AR_BTCOEX_CTRL_REDUCE_TXPWR, 0);
 978                 for (i = 0; i < 8; i++)
 979                         REG_WRITE(ah, AR_BTCOEX_MAX_TXPWR(i), 0x7f7f7f7f);
 980         }
 981
 982         regval = MS(mci->config, ATH_MCI_CONFIG_CLK_DIV);
 983         REG_RMW_FIELD(ah, AR_MCI_TX_CTRL, AR_MCI_TX_CTRL_CLK_DIV, regval);
 984         REG_SET_BIT(ah, AR_BTCOEX_CTRL, AR_BTCOEX_CTRL_MCI_MODE_EN);
 985
 986         /* Resetting the Rx and Tx paths of MCI */
 987         regval = REG_READ(ah, AR_MCI_COMMAND2);
 988         regval |= SM(1, AR_MCI_COMMAND2_RESET_TX);
 989         REG_WRITE(ah, AR_MCI_COMMAND2, regval);
 990
 991         udelay(1);
 992
 993         regval &= ~SM(1, AR_MCI_COMMAND2_RESET_TX);
 994         REG_WRITE(ah, AR_MCI_COMMAND2, regval);
 995
 996         if (is_full_sleep) {
 997                 ar9003_mci_mute_bt(ah);
 998                 udelay(100);
 999         }
1000
1001         /* Check pending GPM msg before MCI Reset Rx */
1002         ar9003_mci_check_gpm_offset(ah);
1003
1004         regval |= SM(1, AR_MCI_COMMAND2_RESET_RX);
1005         REG_WRITE(ah, AR_MCI_COMMAND2, regval);
1006         udelay(1);
1007         regval &= ~SM(1, AR_MCI_COMMAND2_RESET_RX);
1008         REG_WRITE(ah, AR_MCI_COMMAND2, regval);
1009
1010         /* Init GPM offset after MCI Reset Rx */
1011         ar9003_mci_state(ah, MCI_STATE_INIT_GPM_OFFSET);
1012
1013         REG_WRITE(ah, AR_MCI_MSG_ATTRIBUTES_TABLE,
1014                   (SM(0xe801, AR_MCI_MSG_ATTRIBUTES_TABLE_INVALID_HDR) |
1015                    SM(0x0000, AR_MCI_MSG_ATTRIBUTES_TABLE_CHECKSUM)));
1016
1017         if (MCI_ANT_ARCH_PA_LNA_SHARED(mci))
1018                 REG_CLR_BIT(ah, AR_MCI_TX_CTRL,
1019                             AR_MCI_TX_CTRL_DISABLE_LNA_UPDATE);
1020         else
1021                 REG_SET_BIT(ah, AR_MCI_TX_CTRL,
1022                             AR_MCI_TX_CTRL_DISABLE_LNA_UPDATE);
1023
1024         ar9003_mci_observation_set_up(ah);
1025
1026         mci->ready = true;
1027         ar9003_mci_prep_interface(ah);
1028         ar9003_mci_stat_setup(ah);
1029
1030         if (en_int)
1031                 ar9003_mci_enable_interrupt(ah);
1032
1033         if (ath9k_hw_is_aic_enabled(ah))
1034                 ar9003_aic_start_normal(ah);
1035
1036         return 0;
1037 }
1038
1039 void ar9003_mci_stop_bt(struct ath_hw *ah, bool save_fullsleep)
1040 {
1041         struct ath9k_hw_mci *mci_hw = &ah->btcoex_hw.mci;
1042
1043         ar9003_mci_disable_interrupt(ah);
1044
1045         if (mci_hw->ready && !save_fullsleep) {
1046                 ar9003_mci_mute_bt(ah);
1047                 udelay(20);
1048                 REG_WRITE(ah, AR_BTCOEX_CTRL, 0);
1049         }
1050
1051         mci_hw->bt_state = MCI_BT_SLEEP;
1052         mci_hw->ready = false;
1053 }
1054
1055 static void ar9003_mci_send_2g5g_status(struct ath_hw *ah, bool wait_done)
1056 {
1057         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
1058         u32 new_flags, to_set, to_clear;
1059
1060         if (!mci->update_2g5g || (mci->bt_state == MCI_BT_SLEEP))
1061                 return;
1062
1063         if (mci->is_2g) {
1064                 new_flags = MCI_2G_FLAGS;
1065                 to_clear = MCI_2G_FLAGS_CLEAR_MASK;
1066                 to_set = MCI_2G_FLAGS_SET_MASK;
1067         } else {
1068                 new_flags = MCI_5G_FLAGS;
1069                 to_clear = MCI_5G_FLAGS_CLEAR_MASK;
1070                 to_set = MCI_5G_FLAGS_SET_MASK;
1071         }
1072
1073         if (to_clear)
1074                 ar9003_mci_send_coex_bt_flags(ah, wait_done,
1075                                               MCI_GPM_COEX_BT_FLAGS_CLEAR,
1076                                               to_clear);
1077         if (to_set)
1078                 ar9003_mci_send_coex_bt_flags(ah, wait_done,
1079                                               MCI_GPM_COEX_BT_FLAGS_SET,
1080                                               to_set);
1081 }
1082
1083 static void ar9003_mci_queue_unsent_gpm(struct ath_hw *ah, u8 header,
1084                                         u32 *payload, bool queue)
1085 {
1086         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
1087         u8 type, opcode;
1088
1089         /* check if the message is to be queued */
1090         if (header != MCI_GPM)
1091                 return;
1092
1093         type = MCI_GPM_TYPE(payload);
1094         opcode = MCI_GPM_OPCODE(payload);
1095
1096         if (type != MCI_GPM_COEX_AGENT)
1097                 return;
1098
1099         switch (opcode) {
1100         case MCI_GPM_COEX_BT_UPDATE_FLAGS:
1101                 if (*(((u8 *)payload) + MCI_GPM_COEX_B_BT_FLAGS_OP) ==
1102                     MCI_GPM_COEX_BT_FLAGS_READ)
1103                         break;
1104
1105                 mci->update_2g5g = queue;
1106
1107                 break;
1108         case MCI_GPM_COEX_WLAN_CHANNELS:
1109                 mci->wlan_channels_update = queue;
1110                 break;
1111         case MCI_GPM_COEX_HALT_BT_GPM:
1112                 if (*(((u8 *)payload) + MCI_GPM_COEX_B_HALT_STATE) ==
1113                     MCI_GPM_COEX_BT_GPM_UNHALT) {
1114                         mci->unhalt_bt_gpm = queue;
1115
1116                         if (!queue)
1117                                 mci->halted_bt_gpm = false;
1118                 }
1119
1120                 if (*(((u8 *)payload) + MCI_GPM_COEX_B_HALT_STATE) ==
1121                                 MCI_GPM_COEX_BT_GPM_HALT) {
1122
1123                         mci->halted_bt_gpm = !queue;
1124                 }
1125
1126                 break;
1127         default:
1128                 break;
1129         }
1130 }
1131
1132 void ar9003_mci_2g5g_switch(struct ath_hw *ah, bool force)
1133 {
1134         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
1135
1136         if (!mci->update_2g5g && !force)
1137                 return;
1138
1139         if (mci->is_2g) {
1140                 ar9003_mci_send_2g5g_status(ah, true);
1141                 ar9003_mci_send_lna_transfer(ah, true);
1142                 udelay(5);
1143
1144                 REG_CLR_BIT(ah, AR_MCI_TX_CTRL,
1145                             AR_MCI_TX_CTRL_DISABLE_LNA_UPDATE);
1146                 REG_CLR_BIT(ah, AR_PHY_GLB_CONTROL,
1147                             AR_BTCOEX_CTRL_BT_OWN_SPDT_CTRL);
1148
1149                 if (!(mci->config & ATH_MCI_CONFIG_DISABLE_OSLA))
1150                         ar9003_mci_osla_setup(ah, true);
1151
1152                 if (AR_SREV_9462(ah))
1153                         REG_WRITE(ah, AR_SELFGEN_MASK, 0x02);
1154         } else {
1155                 ar9003_mci_send_lna_take(ah, true);
1156                 udelay(5);
1157
1158                 REG_SET_BIT(ah, AR_MCI_TX_CTRL,
1159                             AR_MCI_TX_CTRL_DISABLE_LNA_UPDATE);
1160                 REG_SET_BIT(ah, AR_PHY_GLB_CONTROL,
1161                             AR_BTCOEX_CTRL_BT_OWN_SPDT_CTRL);
1162
1163                 ar9003_mci_osla_setup(ah, false);
1164                 ar9003_mci_send_2g5g_status(ah, true);
1165         }
1166 }
1167
1168 bool ar9003_mci_send_message(struct ath_hw *ah, u8 header, u32 flag,
1169                              u32 *payload, u8 len, bool wait_done,
1170                              bool check_bt)
1171 {
1172         struct ath_common *common = ath9k_hw_common(ah);
1173         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
1174         bool msg_sent = false;
1175         u32 regval;
1176         u32 saved_mci_int_en;
1177         int i;
1178
1179         saved_mci_int_en = REG_READ(ah, AR_MCI_INTERRUPT_EN);
1180         regval = REG_READ(ah, AR_BTCOEX_CTRL);
1181
1182         if ((regval == 0xdeadbeef) || !(regval & AR_BTCOEX_CTRL_MCI_MODE_EN)) {
1183                 ath_dbg(common, MCI,
1184                         "MCI Not sending 0x%x. MCI is not enabled. full_sleep = %d\n",
1185                         header, (ah->power_mode == ATH9K_PM_FULL_SLEEP) ? 1 : 0);
1186                 ar9003_mci_queue_unsent_gpm(ah, header, payload, true);
1187                 return false;
1188         } else if (check_bt && (mci->bt_state == MCI_BT_SLEEP)) {
1189                 ath_dbg(common, MCI,
1190                         "MCI Don't send message 0x%x. BT is in sleep state\n",
1191                         header);
1192                 ar9003_mci_queue_unsent_gpm(ah, header, payload, true);
1193                 return false;
1194         }
1195
1196         if (wait_done)
1197                 REG_WRITE(ah, AR_MCI_INTERRUPT_EN, 0);
1198
1199         /* Need to clear SW_MSG_DONE raw bit before wait */
1200
1201         REG_WRITE(ah, AR_MCI_INTERRUPT_RAW,
1202                   (AR_MCI_INTERRUPT_SW_MSG_DONE |
1203                    AR_MCI_INTERRUPT_MSG_FAIL_MASK));
1204
1205         if (payload) {
1206                 for (i = 0; (i * 4) < len; i++)
1207                         REG_WRITE(ah, (AR_MCI_TX_PAYLOAD0 + i * 4),
1208                                   *(payload + i));
1209         }
1210
1211         REG_WRITE(ah, AR_MCI_COMMAND0,
1212                   (SM((flag & MCI_FLAG_DISABLE_TIMESTAMP),
1213                       AR_MCI_COMMAND0_DISABLE_TIMESTAMP) |
1214                    SM(len, AR_MCI_COMMAND0_LEN) |
1215                    SM(header, AR_MCI_COMMAND0_HEADER)));
1216
1217         if (wait_done &&
1218             !(ar9003_mci_wait_for_interrupt(ah, AR_MCI_INTERRUPT_RAW,
1219                                             AR_MCI_INTERRUPT_SW_MSG_DONE, 500)))
1220                 ar9003_mci_queue_unsent_gpm(ah, header, payload, true);
1221         else {
1222                 ar9003_mci_queue_unsent_gpm(ah, header, payload, false);
1223                 msg_sent = true;
1224         }
1225
1226         if (wait_done)
1227                 REG_WRITE(ah, AR_MCI_INTERRUPT_EN, saved_mci_int_en);
1228
1229         return msg_sent;
1230 }
1231 EXPORT_SYMBOL(ar9003_mci_send_message);
1232
1233 void ar9003_mci_init_cal_req(struct ath_hw *ah, bool *is_reusable)
1234 {
1235         struct ath_common *common = ath9k_hw_common(ah);
1236         struct ath9k_hw_mci *mci_hw = &ah->btcoex_hw.mci;
1237         u32 pld[4] = {0, 0, 0, 0};
1238
1239         if ((mci_hw->bt_state != MCI_BT_AWAKE) ||
1240             (mci_hw->config & ATH_MCI_CONFIG_DISABLE_MCI_CAL))
1241                 return;
1242
1243         MCI_GPM_SET_CAL_TYPE(pld, MCI_GPM_WLAN_CAL_REQ);
1244         pld[MCI_GPM_WLAN_CAL_W_SEQUENCE] = mci_hw->wlan_cal_seq++;
1245
1246         ar9003_mci_send_message(ah, MCI_GPM, 0, pld, 16, true, false);
1247
1248         if (ar9003_mci_wait_for_gpm(ah, MCI_GPM_BT_CAL_GRANT, 0, 50000)) {
1249                 ath_dbg(common, MCI, "MCI BT_CAL_GRANT received\n");
1250         } else {
1251                 *is_reusable = false;
1252                 ath_dbg(common, MCI, "MCI BT_CAL_GRANT not received\n");
1253         }
1254 }
1255
1256 void ar9003_mci_init_cal_done(struct ath_hw *ah)
1257 {
1258         struct ath9k_hw_mci *mci_hw = &ah->btcoex_hw.mci;
1259         u32 pld[4] = {0, 0, 0, 0};
1260
1261         if ((mci_hw->bt_state != MCI_BT_AWAKE) ||
1262             (mci_hw->config & ATH_MCI_CONFIG_DISABLE_MCI_CAL))
1263                 return;
1264
1265         MCI_GPM_SET_CAL_TYPE(pld, MCI_GPM_WLAN_CAL_DONE);
1266         pld[MCI_GPM_WLAN_CAL_W_SEQUENCE] = mci_hw->wlan_cal_done++;
1267         ar9003_mci_send_message(ah, MCI_GPM, 0, pld, 16, true, false);
1268 }
1269
1270 int ar9003_mci_setup(struct ath_hw *ah, u32 gpm_addr, void *gpm_buf,
1271                      u16 len, u32 sched_addr)
1272 {
1273         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
1274
1275         mci->gpm_addr = gpm_addr;
1276         mci->gpm_buf = gpm_buf;
1277         mci->gpm_len = len;
1278         mci->sched_addr = sched_addr;
1279
1280         return ar9003_mci_reset(ah, true, true, true);
1281 }
1282 EXPORT_SYMBOL(ar9003_mci_setup);
1283
1284 void ar9003_mci_cleanup(struct ath_hw *ah)
1285 {
1286         /* Turn off MCI and Jupiter mode. */
1287         REG_WRITE(ah, AR_BTCOEX_CTRL, 0x00);
1288         ar9003_mci_disable_interrupt(ah);
1289 }
1290 EXPORT_SYMBOL(ar9003_mci_cleanup);
1291
1292 u32 ar9003_mci_state(struct ath_hw *ah, u32 state_type)
1293 {
1294         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
1295         u32 value = 0, tsf;
1296         u8 query_type;
1297
1298         switch (state_type) {
1299         case MCI_STATE_ENABLE:
1300                 if (mci->ready) {
1301                         value = REG_READ(ah, AR_BTCOEX_CTRL);
1302
1303                         if ((value == 0xdeadbeef) || (value == 0xffffffff))
1304                                 value = 0;
1305                 }
1306                 value &= AR_BTCOEX_CTRL_MCI_MODE_EN;
1307                 break;
1308         case MCI_STATE_INIT_GPM_OFFSET:
1309                 value = MS(REG_READ(ah, AR_MCI_GPM_1), AR_MCI_GPM_WRITE_PTR);
1310
1311                 if (value < mci->gpm_len)
1312                         mci->gpm_idx = value;
1313                 else
1314                         mci->gpm_idx = 0;
1315                 break;
1316         case MCI_STATE_LAST_SCHD_MSG_OFFSET:
1317                 value = MS(REG_READ(ah, AR_MCI_RX_STATUS),
1318                                     AR_MCI_RX_LAST_SCHD_MSG_INDEX);
1319                 /* Make it in bytes */
1320                 value <<= 4;
1321                 break;
1322         case MCI_STATE_REMOTE_SLEEP:
1323                 value = MS(REG_READ(ah, AR_MCI_RX_STATUS),
1324                            AR_MCI_RX_REMOTE_SLEEP) ?
1325                         MCI_BT_SLEEP : MCI_BT_AWAKE;
1326                 break;
1327         case MCI_STATE_SET_BT_AWAKE:
1328                 mci->bt_state = MCI_BT_AWAKE;
1329                 ar9003_mci_send_coex_version_query(ah, true);
1330                 ar9003_mci_send_coex_wlan_channels(ah, true);
1331
1332                 if (mci->unhalt_bt_gpm)
1333                         ar9003_mci_send_coex_halt_bt_gpm(ah, false, true);
1334
1335                 ar9003_mci_2g5g_switch(ah, false);
1336                 break;
1337         case MCI_STATE_RESET_REQ_WAKE:
1338                 ar9003_mci_reset_req_wakeup(ah);
1339                 mci->update_2g5g = true;
1340
1341                 if (mci->config & ATH_MCI_CONFIG_MCI_OBS_MASK) {
1342                         /* Check if we still have control of the GPIOs */
1343                         if ((REG_READ(ah, AR_GLB_GPIO_CONTROL) &
1344                              ATH_MCI_CONFIG_MCI_OBS_GPIO) !=
1345                             ATH_MCI_CONFIG_MCI_OBS_GPIO) {
1346                                 ar9003_mci_observation_set_up(ah);
1347                         }
1348                 }
1349                 break;
1350         case MCI_STATE_SEND_WLAN_COEX_VERSION:
1351                 ar9003_mci_send_coex_version_response(ah, true);
1352                 break;
1353         case MCI_STATE_SEND_VERSION_QUERY:
1354                 ar9003_mci_send_coex_version_query(ah, true);
1355                 break;
1356         case MCI_STATE_SEND_STATUS_QUERY:
1357                 query_type = MCI_GPM_COEX_QUERY_BT_TOPOLOGY;
1358                 ar9003_mci_send_coex_bt_status_query(ah, true, query_type);
1359                 break;
1360         case MCI_STATE_RECOVER_RX:
1361                 tsf = ath9k_hw_gettsf32(ah);
1362                 if ((tsf - mci->last_recovery) <= MCI_RECOVERY_DUR_TSF) {
1363                         ath_dbg(ath9k_hw_common(ah), MCI,
1364                                 "(MCI) ignore Rx recovery\n");
1365                         break;
1366                 }
1367                 ath_dbg(ath9k_hw_common(ah), MCI, "(MCI) RECOVER RX\n");
1368                 mci->last_recovery = tsf;
1369                 ar9003_mci_prep_interface(ah);
1370                 mci->query_bt = true;
1371                 mci->need_flush_btinfo = true;
1372                 ar9003_mci_send_coex_wlan_channels(ah, true);
1373                 ar9003_mci_2g5g_switch(ah, false);
1374                 break;
1375         case MCI_STATE_NEED_FTP_STOMP:
1376                 value = !(mci->config & ATH_MCI_CONFIG_DISABLE_FTP_STOMP);
1377                 break;
1378         case MCI_STATE_NEED_FLUSH_BT_INFO:
1379                 value = (!mci->unhalt_bt_gpm && mci->need_flush_btinfo) ? 1 : 0;
1380                 mci->need_flush_btinfo = false;
1381                 break;
1382         case MCI_STATE_AIC_CAL:
1383                 if (ath9k_hw_is_aic_enabled(ah))
1384                         value = ar9003_aic_calibration(ah);
1385                 break;
1386         case MCI_STATE_AIC_START:
1387                 if (ath9k_hw_is_aic_enabled(ah))
1388                         ar9003_aic_start_normal(ah);
1389                 break;
1390         case MCI_STATE_AIC_CAL_RESET:
1391                 if (ath9k_hw_is_aic_enabled(ah))
1392                         value = ar9003_aic_cal_reset(ah);
1393                 break;
1394         case MCI_STATE_AIC_CAL_SINGLE:
1395                 if (ath9k_hw_is_aic_enabled(ah))
1396                         value = ar9003_aic_calibration_single(ah);
1397                 break;
1398         default:
1399                 break;
1400         }
1401
1402         return value;
1403 }
1404 EXPORT_SYMBOL(ar9003_mci_state);
1405
1406 void ar9003_mci_bt_gain_ctrl(struct ath_hw *ah)
1407 {
1408         struct ath_common *common = ath9k_hw_common(ah);
1409         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
1410
1411         ath_dbg(common, MCI, "Give LNA and SPDT control to BT\n");
1412
1413         ar9003_mci_send_lna_take(ah, true);
1414         udelay(50);
1415
1416         REG_SET_BIT(ah, AR_PHY_GLB_CONTROL, AR_BTCOEX_CTRL_BT_OWN_SPDT_CTRL);
1417         mci->is_2g = false;
1418         mci->update_2g5g = true;
1419         ar9003_mci_send_2g5g_status(ah, true);
1420
1421         /* Force another 2g5g update at next scanning */
1422         mci->update_2g5g = true;
1423 }
1424
1425 void ar9003_mci_set_power_awake(struct ath_hw *ah)
1426 {
1427         u32 btcoex_ctrl2, diag_sw;
1428         int i;
1429         u8 lna_ctrl, bt_sleep;
1430
1431         for (i = 0; i < AH_WAIT_TIMEOUT; i++) {
1432                 btcoex_ctrl2 = REG_READ(ah, AR_BTCOEX_CTRL2);
1433                 if (btcoex_ctrl2 != 0xdeadbeef)
1434                         break;
1435                 udelay(AH_TIME_QUANTUM);
1436         }
1437         REG_WRITE(ah, AR_BTCOEX_CTRL2, (btcoex_ctrl2 | BIT(23)));
1438
1439         for (i = 0; i < AH_WAIT_TIMEOUT; i++) {
1440                 diag_sw = REG_READ(ah, AR_DIAG_SW);
1441                 if (diag_sw != 0xdeadbeef)
1442                         break;
1443                 udelay(AH_TIME_QUANTUM);
1444         }
1445         REG_WRITE(ah, AR_DIAG_SW, (diag_sw | BIT(27) | BIT(19) | BIT(18)));
1446         lna_ctrl = REG_READ(ah, AR_OBS_BUS_CTRL) & 0x3;
1447         bt_sleep = MS(REG_READ(ah, AR_MCI_RX_STATUS), AR_MCI_RX_REMOTE_SLEEP);
1448
1449         REG_WRITE(ah, AR_BTCOEX_CTRL2, btcoex_ctrl2);
1450         REG_WRITE(ah, AR_DIAG_SW, diag_sw);
1451
1452         if (bt_sleep && (lna_ctrl == 2)) {
1453                 REG_SET_BIT(ah, AR_BTCOEX_RC, 0x1);
1454                 REG_CLR_BIT(ah, AR_BTCOEX_RC, 0x1);
1455                 udelay(50);
1456         }
1457 }
1458
1459 void ar9003_mci_check_gpm_offset(struct ath_hw *ah)
1460 {
1461         struct ath_common *common = ath9k_hw_common(ah);
1462         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
1463         u32 offset;
1464
1465         /*
1466          * This should only be called before "MAC Warm Reset" or "MCI Reset Rx".
1467          */
1468         offset = MS(REG_READ(ah, AR_MCI_GPM_1), AR_MCI_GPM_WRITE_PTR);
1469         if (mci->gpm_idx == offset)
1470                 return;
1471         ath_dbg(common, MCI, "GPM cached write pointer mismatch %d %d\n",
1472                 mci->gpm_idx, offset);
1473         mci->query_bt = true;
1474         mci->need_flush_btinfo = true;
1475         mci->gpm_idx = 0;
1476 }
1477
1478 u32 ar9003_mci_get_next_gpm_offset(struct ath_hw *ah, u32 *more)
1479 {
1480         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
1481         u32 offset, more_gpm = 0, gpm_ptr;
1482
1483         /*
1484          * This could be useful to avoid new GPM message interrupt which
1485          * may lead to spurious interrupt after power sleep, or multiple
1486          * entry of ath_mci_intr().
1487          * Adding empty GPM check by returning HAL_MCI_GPM_INVALID can
1488          * alleviate this effect, but clearing GPM RX interrupt bit is
1489          * safe, because whether this is called from hw or driver code
1490          * there must be an interrupt bit set/triggered initially
1491          */
1492         REG_WRITE(ah, AR_MCI_INTERRUPT_RX_MSG_RAW,
1493                         AR_MCI_INTERRUPT_RX_MSG_GPM);
1494
1495         gpm_ptr = MS(REG_READ(ah, AR_MCI_GPM_1), AR_MCI_GPM_WRITE_PTR);
1496         offset = gpm_ptr;
1497
1498         if (!offset)
1499                 offset = mci->gpm_len - 1;
1500         else if (offset >= mci->gpm_len) {
1501                 if (offset != 0xFFFF)
1502                         offset = 0;
1503         } else {
1504                 offset--;
1505         }
1506
1507         if ((offset == 0xFFFF) || (gpm_ptr == mci->gpm_idx)) {
1508                 offset = MCI_GPM_INVALID;
1509                 more_gpm = MCI_GPM_NOMORE;
1510                 goto out;
1511         }
1512         for (;;) {
1513                 u32 temp_index;
1514
1515                 /* skip reserved GPM if any */
1516
1517                 if (offset != mci->gpm_idx)
1518                         more_gpm = MCI_GPM_MORE;
1519                 else
1520                         more_gpm = MCI_GPM_NOMORE;
1521
1522                 temp_index = mci->gpm_idx;
1523
1524                 if (temp_index >= mci->gpm_len)
1525                         temp_index = 0;
1526
1527                 mci->gpm_idx++;
1528
1529                 if (mci->gpm_idx >= mci->gpm_len)
1530                         mci->gpm_idx = 0;
1531
1532                 if (ar9003_mci_is_gpm_valid(ah, temp_index)) {
1533                         offset = temp_index;
1534                         break;
1535                 }
1536
1537                 if (more_gpm == MCI_GPM_NOMORE) {
1538                         offset = MCI_GPM_INVALID;
1539                         break;
1540                 }
1541         }
1542
1543         if (offset != MCI_GPM_INVALID)
1544                 offset <<= 4;
1545 out:
1546         if (more)
1547                 *more = more_gpm;
1548
1549         return offset;
1550 }
1551 EXPORT_SYMBOL(ar9003_mci_get_next_gpm_offset);
1552
1553 void ar9003_mci_set_bt_version(struct ath_hw *ah, u8 major, u8 minor)
1554 {
1555         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
1556
1557         mci->bt_ver_major = major;
1558         mci->bt_ver_minor = minor;
1559         mci->bt_version_known = true;
1560         ath_dbg(ath9k_hw_common(ah), MCI, "MCI BT version set: %d.%d\n",
1561                 mci->bt_ver_major, mci->bt_ver_minor);
1562 }
1563 EXPORT_SYMBOL(ar9003_mci_set_bt_version);
1564
1565 void ar9003_mci_send_wlan_channels(struct ath_hw *ah)
1566 {
1567         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
1568
1569         mci->wlan_channels_update = true;
1570         ar9003_mci_send_coex_wlan_channels(ah, true);
1571 }
1572 EXPORT_SYMBOL(ar9003_mci_send_wlan_channels);
1573
1574 u16 ar9003_mci_get_max_txpower(struct ath_hw *ah, u8 ctlmode)
1575 {
1576         if (!ah->btcoex_hw.mci.concur_tx)
1577                 goto out;
1578
1579         if (ctlmode == CTL_2GHT20)
1580                 return ATH_BTCOEX_HT20_MAX_TXPOWER;
1581         else if (ctlmode == CTL_2GHT40)
1582                 return ATH_BTCOEX_HT40_MAX_TXPOWER;
1583
1584 out:
1585         return -1;
1586 }