drivers/net/wireless/ath/ath10k/pci.c

   1 /*
   2  * Copyright (c) 2005-2011 Atheros Communications Inc.
   3  * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
   4  *
   5  * Permission to use, copy, modify, and/or 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 #include <linux/pci.h>
  19 #include <linux/module.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/spinlock.h>
  22 #include <linux/bitops.h>
  23
  24 #include "core.h"
  25 #include "debug.h"
  26
  27 #include "targaddrs.h"
  28 #include "bmi.h"
  29
  30 #include "hif.h"
  31 #include "htc.h"
  32
  33 #include "ce.h"
  34 #include "pci.h"
  35
  36 enum ath10k_pci_irq_mode {
  37         ATH10K_PCI_IRQ_AUTO = 0,
  38         ATH10K_PCI_IRQ_LEGACY = 1,
  39         ATH10K_PCI_IRQ_MSI = 2,
  40 };
  41
  42 enum ath10k_pci_reset_mode {
  43         ATH10K_PCI_RESET_AUTO = 0,
  44         ATH10K_PCI_RESET_WARM_ONLY = 1,
  45 };
  46
  47 static unsigned int ath10k_pci_irq_mode = ATH10K_PCI_IRQ_AUTO;
  48 static unsigned int ath10k_pci_reset_mode = ATH10K_PCI_RESET_AUTO;
  49
  50 module_param_named(irq_mode, ath10k_pci_irq_mode, uint, 0644);
  51 MODULE_PARM_DESC(irq_mode, "0: auto, 1: legacy, 2: msi (default: 0)");
  52
  53 module_param_named(reset_mode, ath10k_pci_reset_mode, uint, 0644);
  54 MODULE_PARM_DESC(reset_mode, "0: auto, 1: warm only (default: 0)");
  55
  56 /* how long wait to wait for target to initialise, in ms */
  57 #define ATH10K_PCI_TARGET_WAIT 3000
  58 #define ATH10K_PCI_NUM_WARM_RESET_ATTEMPTS 3
  59
  60 #define QCA988X_2_0_DEVICE_ID   (0x003c)
  61
  62 static const struct pci_device_id ath10k_pci_id_table[] = {
  63         { PCI_VDEVICE(ATHEROS, QCA988X_2_0_DEVICE_ID) }, /* PCI-E QCA988X V2 */
  64         {0}
  65 };
  66
  67 static void ath10k_pci_buffer_cleanup(struct ath10k *ar);
  68 static int ath10k_pci_cold_reset(struct ath10k *ar);
  69 static int ath10k_pci_warm_reset(struct ath10k *ar);
  70 static int ath10k_pci_wait_for_target_init(struct ath10k *ar);
  71 static int ath10k_pci_init_irq(struct ath10k *ar);
  72 static int ath10k_pci_deinit_irq(struct ath10k *ar);
  73 static int ath10k_pci_request_irq(struct ath10k *ar);
  74 static void ath10k_pci_free_irq(struct ath10k *ar);
  75 static int ath10k_pci_bmi_wait(struct ath10k_ce_pipe *tx_pipe,
  76                                struct ath10k_ce_pipe *rx_pipe,
  77                                struct bmi_xfer *xfer);
  78
  79 static const struct ce_attr host_ce_config_wlan[] = {
  80         /* CE0: host->target HTC control and raw streams */
  81         {
  82                 .flags = CE_ATTR_FLAGS,
  83                 .src_nentries = 16,
  84                 .src_sz_max = 256,
  85                 .dest_nentries = 0,
  86         },
  87
  88         /* CE1: target->host HTT + HTC control */
  89         {
  90                 .flags = CE_ATTR_FLAGS,
  91                 .src_nentries = 0,
  92                 .src_sz_max = 512,
  93                 .dest_nentries = 512,
  94         },
  95
  96         /* CE2: target->host WMI */
  97         {
  98                 .flags = CE_ATTR_FLAGS,
  99                 .src_nentries = 0,
 100                 .src_sz_max = 2048,
 101                 .dest_nentries = 32,
 102         },
 103
 104         /* CE3: host->target WMI */
 105         {
 106                 .flags = CE_ATTR_FLAGS,
 107                 .src_nentries = 32,
 108                 .src_sz_max = 2048,
 109                 .dest_nentries = 0,
 110         },
 111
 112         /* CE4: host->target HTT */
 113         {
 114                 .flags = CE_ATTR_FLAGS | CE_ATTR_DIS_INTR,
 115                 .src_nentries = CE_HTT_H2T_MSG_SRC_NENTRIES,
 116                 .src_sz_max = 256,
 117                 .dest_nentries = 0,
 118         },
 119
 120         /* CE5: unused */
 121         {
 122                 .flags = CE_ATTR_FLAGS,
 123                 .src_nentries = 0,
 124                 .src_sz_max = 0,
 125                 .dest_nentries = 0,
 126         },
 127
 128         /* CE6: target autonomous hif_memcpy */
 129         {
 130                 .flags = CE_ATTR_FLAGS,
 131                 .src_nentries = 0,
 132                 .src_sz_max = 0,
 133                 .dest_nentries = 0,
 134         },
 135
 136         /* CE7: ce_diag, the Diagnostic Window */
 137         {
 138                 .flags = CE_ATTR_FLAGS,
 139                 .src_nentries = 2,
 140                 .src_sz_max = DIAG_TRANSFER_LIMIT,
 141                 .dest_nentries = 2,
 142         },
 143 };
 144
 145 /* Target firmware's Copy Engine configuration. */
 146 static const struct ce_pipe_config target_ce_config_wlan[] = {
 147         /* CE0: host->target HTC control and raw streams */
 148         {
 149                 .pipenum = __cpu_to_le32(0),
 150                 .pipedir = __cpu_to_le32(PIPEDIR_OUT),
 151                 .nentries = __cpu_to_le32(32),
 152                 .nbytes_max = __cpu_to_le32(256),
 153                 .flags = __cpu_to_le32(CE_ATTR_FLAGS),
 154                 .reserved = __cpu_to_le32(0),
 155         },
 156
 157         /* CE1: target->host HTT + HTC control */
 158         {
 159                 .pipenum = __cpu_to_le32(1),
 160                 .pipedir = __cpu_to_le32(PIPEDIR_IN),
 161                 .nentries = __cpu_to_le32(32),
 162                 .nbytes_max = __cpu_to_le32(512),
 163                 .flags = __cpu_to_le32(CE_ATTR_FLAGS),
 164                 .reserved = __cpu_to_le32(0),
 165         },
 166
 167         /* CE2: target->host WMI */
 168         {
 169                 .pipenum = __cpu_to_le32(2),
 170                 .pipedir = __cpu_to_le32(PIPEDIR_IN),
 171                 .nentries = __cpu_to_le32(32),
 172                 .nbytes_max = __cpu_to_le32(2048),
 173                 .flags = __cpu_to_le32(CE_ATTR_FLAGS),
 174                 .reserved = __cpu_to_le32(0),
 175         },
 176
 177         /* CE3: host->target WMI */
 178         {
 179                 .pipenum = __cpu_to_le32(3),
 180                 .pipedir = __cpu_to_le32(PIPEDIR_OUT),
 181                 .nentries = __cpu_to_le32(32),
 182                 .nbytes_max = __cpu_to_le32(2048),
 183                 .flags = __cpu_to_le32(CE_ATTR_FLAGS),
 184                 .reserved = __cpu_to_le32(0),
 185         },
 186
 187         /* CE4: host->target HTT */
 188         {
 189                 .pipenum = __cpu_to_le32(4),
 190                 .pipedir = __cpu_to_le32(PIPEDIR_OUT),
 191                 .nentries = __cpu_to_le32(256),
 192                 .nbytes_max = __cpu_to_le32(256),
 193                 .flags = __cpu_to_le32(CE_ATTR_FLAGS),
 194                 .reserved = __cpu_to_le32(0),
 195         },
 196
 197         /* NB: 50% of src nentries, since tx has 2 frags */
 198
 199         /* CE5: unused */
 200         {
 201                 .pipenum = __cpu_to_le32(5),
 202                 .pipedir = __cpu_to_le32(PIPEDIR_OUT),
 203                 .nentries = __cpu_to_le32(32),
 204                 .nbytes_max = __cpu_to_le32(2048),
 205                 .flags = __cpu_to_le32(CE_ATTR_FLAGS),
 206                 .reserved = __cpu_to_le32(0),
 207         },
 208
 209         /* CE6: Reserved for target autonomous hif_memcpy */
 210         {
 211                 .pipenum = __cpu_to_le32(6),
 212                 .pipedir = __cpu_to_le32(PIPEDIR_INOUT),
 213                 .nentries = __cpu_to_le32(32),
 214                 .nbytes_max = __cpu_to_le32(4096),
 215                 .flags = __cpu_to_le32(CE_ATTR_FLAGS),
 216                 .reserved = __cpu_to_le32(0),
 217         },
 218
 219         /* CE7 used only by Host */
 220 };
 221
 222 /*
 223  * Map from service/endpoint to Copy Engine.
 224  * This table is derived from the CE_PCI TABLE, above.
 225  * It is passed to the Target at startup for use by firmware.
 226  */
 227 static const struct service_to_pipe target_service_to_ce_map_wlan[] = {
 228         {
 229                 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_VO),
 230                 __cpu_to_le32(PIPEDIR_OUT),     /* out = UL = host -> target */
 231                 __cpu_to_le32(3),
 232         },
 233         {
 234                 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_VO),
 235                 __cpu_to_le32(PIPEDIR_IN),      /* in = DL = target -> host */
 236                 __cpu_to_le32(2),
 237         },
 238         {
 239                 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_BK),
 240                 __cpu_to_le32(PIPEDIR_OUT),     /* out = UL = host -> target */
 241                 __cpu_to_le32(3),
 242         },
 243         {
 244                 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_BK),
 245                 __cpu_to_le32(PIPEDIR_IN),      /* in = DL = target -> host */
 246                 __cpu_to_le32(2),
 247         },
 248         {
 249                 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_BE),
 250                 __cpu_to_le32(PIPEDIR_OUT),     /* out = UL = host -> target */
 251                 __cpu_to_le32(3),
 252         },
 253         {
 254                 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_BE),
 255                 __cpu_to_le32(PIPEDIR_IN),      /* in = DL = target -> host */
 256                 __cpu_to_le32(2),
 257         },
 258         {
 259                 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_VI),
 260                 __cpu_to_le32(PIPEDIR_OUT),     /* out = UL = host -> target */
 261                 __cpu_to_le32(3),
 262         },
 263         {
 264                 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_VI),
 265                 __cpu_to_le32(PIPEDIR_IN),      /* in = DL = target -> host */
 266                 __cpu_to_le32(2),
 267         },
 268         {
 269                 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_CONTROL),
 270                 __cpu_to_le32(PIPEDIR_OUT),     /* out = UL = host -> target */
 271                 __cpu_to_le32(3),
 272         },
 273         {
 274                 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_CONTROL),
 275                 __cpu_to_le32(PIPEDIR_IN),      /* in = DL = target -> host */
 276                 __cpu_to_le32(2),
 277         },
 278         {
 279                 __cpu_to_le32(ATH10K_HTC_SVC_ID_RSVD_CTRL),
 280                 __cpu_to_le32(PIPEDIR_OUT),     /* out = UL = host -> target */
 281                 __cpu_to_le32(0),
 282         },
 283         {
 284                 __cpu_to_le32(ATH10K_HTC_SVC_ID_RSVD_CTRL),
 285                 __cpu_to_le32(PIPEDIR_IN),      /* in = DL = target -> host */
 286                 __cpu_to_le32(1),
 287         },
 288         { /* not used */
 289                 __cpu_to_le32(ATH10K_HTC_SVC_ID_TEST_RAW_STREAMS),
 290                 __cpu_to_le32(PIPEDIR_OUT),     /* out = UL = host -> target */
 291                 __cpu_to_le32(0),
 292         },
 293         { /* not used */
 294                 __cpu_to_le32(ATH10K_HTC_SVC_ID_TEST_RAW_STREAMS),
 295                 __cpu_to_le32(PIPEDIR_IN),      /* in = DL = target -> host */
 296                 __cpu_to_le32(1),
 297         },
 298         {
 299                 __cpu_to_le32(ATH10K_HTC_SVC_ID_HTT_DATA_MSG),
 300                 __cpu_to_le32(PIPEDIR_OUT),     /* out = UL = host -> target */
 301                 __cpu_to_le32(4),
 302         },
 303         {
 304                 __cpu_to_le32(ATH10K_HTC_SVC_ID_HTT_DATA_MSG),
 305                 __cpu_to_le32(PIPEDIR_IN),      /* in = DL = target -> host */
 306                 __cpu_to_le32(1),
 307         },
 308
 309         /* (Additions here) */
 310
 311         { /* must be last */
 312                 __cpu_to_le32(0),
 313                 __cpu_to_le32(0),
 314                 __cpu_to_le32(0),
 315         },
 316 };
 317
 318 static bool ath10k_pci_irq_pending(struct ath10k *ar)
 319 {
 320         u32 cause;
 321
 322         /* Check if the shared legacy irq is for us */
 323         cause = ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS +
 324                                   PCIE_INTR_CAUSE_ADDRESS);
 325         if (cause & (PCIE_INTR_FIRMWARE_MASK | PCIE_INTR_CE_MASK_ALL))
 326                 return true;
 327
 328         return false;
 329 }
 330
 331 static void ath10k_pci_disable_and_clear_legacy_irq(struct ath10k *ar)
 332 {
 333         /* IMPORTANT: INTR_CLR register has to be set after
 334          * INTR_ENABLE is set to 0, otherwise interrupt can not be
 335          * really cleared. */
 336         ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS + PCIE_INTR_ENABLE_ADDRESS,
 337                            0);
 338         ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS + PCIE_INTR_CLR_ADDRESS,
 339                            PCIE_INTR_FIRMWARE_MASK | PCIE_INTR_CE_MASK_ALL);
 340
 341         /* IMPORTANT: this extra read transaction is required to
 342          * flush the posted write buffer. */
 343         (void)ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS +
 344                                 PCIE_INTR_ENABLE_ADDRESS);
 345 }
 346
 347 static void ath10k_pci_enable_legacy_irq(struct ath10k *ar)
 348 {
 349         ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS +
 350                            PCIE_INTR_ENABLE_ADDRESS,
 351                            PCIE_INTR_FIRMWARE_MASK | PCIE_INTR_CE_MASK_ALL);
 352
 353         /* IMPORTANT: this extra read transaction is required to
 354          * flush the posted write buffer. */
 355         (void)ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS +
 356                                 PCIE_INTR_ENABLE_ADDRESS);
 357 }
 358
 359 static inline const char *ath10k_pci_get_irq_method(struct ath10k *ar)
 360 {
 361         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
 362
 363         if (ar_pci->num_msi_intrs > 1)
 364                 return "msi-x";
 365
 366         if (ar_pci->num_msi_intrs == 1)
 367                 return "msi";
 368
 369         return "legacy";
 370 }
 371
 372 static int __ath10k_pci_rx_post_buf(struct ath10k_pci_pipe *pipe)
 373 {
 374         struct ath10k *ar = pipe->hif_ce_state;
 375         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
 376         struct ath10k_ce_pipe *ce_pipe = pipe->ce_hdl;
 377         struct sk_buff *skb;
 378         dma_addr_t paddr;
 379         int ret;
 380
 381         lockdep_assert_held(&ar_pci->ce_lock);
 382
 383         skb = dev_alloc_skb(pipe->buf_sz);
 384         if (!skb)
 385                 return -ENOMEM;
 386
 387         WARN_ONCE((unsigned long)skb->data & 3, "unaligned skb");
 388
 389         paddr = dma_map_single(ar->dev, skb->data,
 390                                skb->len + skb_tailroom(skb),
 391                                DMA_FROM_DEVICE);
 392         if (unlikely(dma_mapping_error(ar->dev, paddr))) {
 393                 ath10k_warn(ar, "failed to dma map pci rx buf\n");
 394                 dev_kfree_skb_any(skb);
 395                 return -EIO;
 396         }
 397
 398         ATH10K_SKB_CB(skb)->paddr = paddr;
 399
 400         ret = __ath10k_ce_rx_post_buf(ce_pipe, skb, paddr);
 401         if (ret) {
 402                 ath10k_warn(ar, "failed to post pci rx buf: %d\n", ret);
 403                 dma_unmap_single(ar->dev, paddr, skb->len + skb_tailroom(skb),
 404                                  DMA_FROM_DEVICE);
 405                 dev_kfree_skb_any(skb);
 406                 return ret;
 407         }
 408
 409         return 0;
 410 }
 411
 412 static void __ath10k_pci_rx_post_pipe(struct ath10k_pci_pipe *pipe)
 413 {
 414         struct ath10k *ar = pipe->hif_ce_state;
 415         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
 416         struct ath10k_ce_pipe *ce_pipe = pipe->ce_hdl;
 417         int ret, num;
 418
 419         lockdep_assert_held(&ar_pci->ce_lock);
 420
 421         if (pipe->buf_sz == 0)
 422                 return;
 423
 424         if (!ce_pipe->dest_ring)
 425                 return;
 426
 427         num = __ath10k_ce_rx_num_free_bufs(ce_pipe);
 428         while (num--) {
 429                 ret = __ath10k_pci_rx_post_buf(pipe);
 430                 if (ret) {
 431                         ath10k_warn(ar, "failed to post pci rx buf: %d\n", ret);
 432                         mod_timer(&ar_pci->rx_post_retry, jiffies +
 433                                   ATH10K_PCI_RX_POST_RETRY_MS);
 434                         break;
 435                 }
 436         }
 437 }
 438
 439 static void ath10k_pci_rx_post_pipe(struct ath10k_pci_pipe *pipe)
 440 {
 441         struct ath10k *ar = pipe->hif_ce_state;
 442         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
 443
 444         spin_lock_bh(&ar_pci->ce_lock);
 445         __ath10k_pci_rx_post_pipe(pipe);
 446         spin_unlock_bh(&ar_pci->ce_lock);
 447 }
 448
 449 static void ath10k_pci_rx_post(struct ath10k *ar)
 450 {
 451         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
 452         int i;
 453
 454         spin_lock_bh(&ar_pci->ce_lock);
 455         for (i = 0; i < CE_COUNT; i++)
 456                 __ath10k_pci_rx_post_pipe(&ar_pci->pipe_info[i]);
 457         spin_unlock_bh(&ar_pci->ce_lock);
 458 }
 459
 460 static void ath10k_pci_rx_replenish_retry(unsigned long ptr)
 461 {
 462         struct ath10k *ar = (void *)ptr;
 463
 464         ath10k_pci_rx_post(ar);
 465 }
 466
 467 /*
 468  * Diagnostic read/write access is provided for startup/config/debug usage.
 469  * Caller must guarantee proper alignment, when applicable, and single user
 470  * at any moment.
 471  */
 472 static int ath10k_pci_diag_read_mem(struct ath10k *ar, u32 address, void *data,
 473                                     int nbytes)
 474 {
 475         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
 476         int ret = 0;
 477         u32 buf;
 478         unsigned int completed_nbytes, orig_nbytes, remaining_bytes;
 479         unsigned int id;
 480         unsigned int flags;
 481         struct ath10k_ce_pipe *ce_diag;
 482         /* Host buffer address in CE space */
 483         u32 ce_data;
 484         dma_addr_t ce_data_base = 0;
 485         void *data_buf = NULL;
 486         int i;
 487
 488         spin_lock_bh(&ar_pci->ce_lock);
 489
 490         ce_diag = ar_pci->ce_diag;
 491
 492         /*
 493          * Allocate a temporary bounce buffer to hold caller's data
 494          * to be DMA'ed from Target. This guarantees
 495          *   1) 4-byte alignment
 496          *   2) Buffer in DMA-able space
 497          */
 498         orig_nbytes = nbytes;
 499         data_buf = (unsigned char *)dma_alloc_coherent(ar->dev,
 500                                                        orig_nbytes,
 501                                                        &ce_data_base,
 502                                                        GFP_ATOMIC);
 503
 504         if (!data_buf) {
 505                 ret = -ENOMEM;
 506                 goto done;
 507         }
 508         memset(data_buf, 0, orig_nbytes);
 509
 510         remaining_bytes = orig_nbytes;
 511         ce_data = ce_data_base;
 512         while (remaining_bytes) {
 513                 nbytes = min_t(unsigned int, remaining_bytes,
 514                                DIAG_TRANSFER_LIMIT);
 515
 516                 ret = __ath10k_ce_rx_post_buf(ce_diag, NULL, ce_data);
 517                 if (ret != 0)
 518                         goto done;
 519
 520                 /* Request CE to send from Target(!) address to Host buffer */
 521                 /*
 522                  * The address supplied by the caller is in the
 523                  * Target CPU virtual address space.
 524                  *
 525                  * In order to use this address with the diagnostic CE,
 526                  * convert it from Target CPU virtual address space
 527                  * to CE address space
 528                  */
 529                 address = TARG_CPU_SPACE_TO_CE_SPACE(ar, ar_pci->mem,
 530                                                      address);
 531
 532                 ret = ath10k_ce_send_nolock(ce_diag, NULL, (u32)address, nbytes, 0,
 533                                             0);
 534                 if (ret)
 535                         goto done;
 536
 537                 i = 0;
 538                 while (ath10k_ce_completed_send_next_nolock(ce_diag, NULL, &buf,
 539                                                             &completed_nbytes,
 540                                                             &id) != 0) {
 541                         mdelay(1);
 542                         if (i++ > DIAG_ACCESS_CE_TIMEOUT_MS) {
 543                                 ret = -EBUSY;
 544                                 goto done;
 545                         }
 546                 }
 547
 548                 if (nbytes != completed_nbytes) {
 549                         ret = -EIO;
 550                         goto done;
 551                 }
 552
 553                 if (buf != (u32)address) {
 554                         ret = -EIO;
 555                         goto done;
 556                 }
 557
 558                 i = 0;
 559                 while (ath10k_ce_completed_recv_next_nolock(ce_diag, NULL, &buf,
 560                                                             &completed_nbytes,
 561                                                             &id, &flags) != 0) {
 562                         mdelay(1);
 563
 564                         if (i++ > DIAG_ACCESS_CE_TIMEOUT_MS) {
 565                                 ret = -EBUSY;
 566                                 goto done;
 567                         }
 568                 }
 569
 570                 if (nbytes != completed_nbytes) {
 571                         ret = -EIO;
 572                         goto done;
 573                 }
 574
 575                 if (buf != ce_data) {
 576                         ret = -EIO;
 577                         goto done;
 578                 }
 579
 580                 remaining_bytes -= nbytes;
 581                 address += nbytes;
 582                 ce_data += nbytes;
 583         }
 584
 585 done:
 586         if (ret == 0)
 587                 memcpy(data, data_buf, orig_nbytes);
 588         else
 589                 ath10k_warn(ar, "failed to read diag value at 0x%x: %d\n",
 590                             address, ret);
 591
 592         if (data_buf)
 593                 dma_free_coherent(ar->dev, orig_nbytes, data_buf,
 594                                   ce_data_base);
 595
 596         spin_unlock_bh(&ar_pci->ce_lock);
 597
 598         return ret;
 599 }
 600
 601 static int ath10k_pci_diag_read32(struct ath10k *ar, u32 address, u32 *value)
 602 {
 603         __le32 val = 0;
 604         int ret;
 605
 606         ret = ath10k_pci_diag_read_mem(ar, address, &val, sizeof(val));
 607         *value = __le32_to_cpu(val);
 608
 609         return ret;
 610 }
 611
 612 static int __ath10k_pci_diag_read_hi(struct ath10k *ar, void *dest,
 613                                      u32 src, u32 len)
 614 {
 615         u32 host_addr, addr;
 616         int ret;
 617
 618         host_addr = host_interest_item_address(src);
 619
 620         ret = ath10k_pci_diag_read32(ar, host_addr, &addr);
 621         if (ret != 0) {
 622                 ath10k_warn(ar, "failed to get memcpy hi address for firmware address %d: %d\n",
 623                             src, ret);
 624                 return ret;
 625         }
 626
 627         ret = ath10k_pci_diag_read_mem(ar, addr, dest, len);
 628         if (ret != 0) {
 629                 ath10k_warn(ar, "failed to memcpy firmware memory from %d (%d B): %d\n",
 630                             addr, len, ret);
 631                 return ret;
 632         }
 633
 634         return 0;
 635 }
 636
 637 #define ath10k_pci_diag_read_hi(ar, dest, src, len)             \
 638         __ath10k_pci_diag_read_hi(ar, dest, HI_ITEM(src), len)
 639
 640 static int ath10k_pci_diag_write_mem(struct ath10k *ar, u32 address,
 641                                      const void *data, int nbytes)
 642 {
 643         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
 644         int ret = 0;
 645         u32 buf;
 646         unsigned int completed_nbytes, orig_nbytes, remaining_bytes;
 647         unsigned int id;
 648         unsigned int flags;
 649         struct ath10k_ce_pipe *ce_diag;
 650         void *data_buf = NULL;
 651         u32 ce_data;    /* Host buffer address in CE space */
 652         dma_addr_t ce_data_base = 0;
 653         int i;
 654
 655         spin_lock_bh(&ar_pci->ce_lock);
 656
 657         ce_diag = ar_pci->ce_diag;
 658
 659         /*
 660          * Allocate a temporary bounce buffer to hold caller's data
 661          * to be DMA'ed to Target. This guarantees
 662          *   1) 4-byte alignment
 663          *   2) Buffer in DMA-able space
 664          */
 665         orig_nbytes = nbytes;
 666         data_buf = (unsigned char *)dma_alloc_coherent(ar->dev,
 667                                                        orig_nbytes,
 668                                                        &ce_data_base,
 669                                                        GFP_ATOMIC);
 670         if (!data_buf) {
 671                 ret = -ENOMEM;
 672                 goto done;
 673         }
 674
 675         /* Copy caller's data to allocated DMA buf */
 676         memcpy(data_buf, data, orig_nbytes);
 677
 678         /*
 679          * The address supplied by the caller is in the
 680          * Target CPU virtual address space.
 681          *
 682          * In order to use this address with the diagnostic CE,
 683          * convert it from
 684          *    Target CPU virtual address space
 685          * to
 686          *    CE address space
 687          */
 688         address = TARG_CPU_SPACE_TO_CE_SPACE(ar, ar_pci->mem, address);
 689
 690         remaining_bytes = orig_nbytes;
 691         ce_data = ce_data_base;
 692         while (remaining_bytes) {
 693                 /* FIXME: check cast */
 694                 nbytes = min_t(int, remaining_bytes, DIAG_TRANSFER_LIMIT);
 695
 696                 /* Set up to receive directly into Target(!) address */
 697                 ret = __ath10k_ce_rx_post_buf(ce_diag, NULL, address);
 698                 if (ret != 0)
 699                         goto done;
 700
 701                 /*
 702                  * Request CE to send caller-supplied data that
 703                  * was copied to bounce buffer to Target(!) address.
 704                  */
 705                 ret = ath10k_ce_send_nolock(ce_diag, NULL, (u32)ce_data,
 706                                             nbytes, 0, 0);
 707                 if (ret != 0)
 708                         goto done;
 709
 710                 i = 0;
 711                 while (ath10k_ce_completed_send_next_nolock(ce_diag, NULL, &buf,
 712                                                             &completed_nbytes,
 713                                                             &id) != 0) {
 714                         mdelay(1);
 715
 716                         if (i++ > DIAG_ACCESS_CE_TIMEOUT_MS) {
 717                                 ret = -EBUSY;
 718                                 goto done;
 719                         }
 720                 }
 721
 722                 if (nbytes != completed_nbytes) {
 723                         ret = -EIO;
 724                         goto done;
 725                 }
 726
 727                 if (buf != ce_data) {
 728                         ret = -EIO;
 729                         goto done;
 730                 }
 731
 732                 i = 0;
 733                 while (ath10k_ce_completed_recv_next_nolock(ce_diag, NULL, &buf,
 734                                                             &completed_nbytes,
 735                                                             &id, &flags) != 0) {
 736                         mdelay(1);
 737
 738                         if (i++ > DIAG_ACCESS_CE_TIMEOUT_MS) {
 739                                 ret = -EBUSY;
 740                                 goto done;
 741                         }
 742                 }
 743
 744                 if (nbytes != completed_nbytes) {
 745                         ret = -EIO;
 746                         goto done;
 747                 }
 748
 749                 if (buf != address) {
 750                         ret = -EIO;
 751                         goto done;
 752                 }
 753
 754                 remaining_bytes -= nbytes;
 755                 address += nbytes;
 756                 ce_data += nbytes;
 757         }
 758
 759 done:
 760         if (data_buf) {
 761                 dma_free_coherent(ar->dev, orig_nbytes, data_buf,
 762                                   ce_data_base);
 763         }
 764
 765         if (ret != 0)
 766                 ath10k_warn(ar, "failed to write diag value at 0x%x: %d\n",
 767                             address, ret);
 768
 769         spin_unlock_bh(&ar_pci->ce_lock);
 770
 771         return ret;
 772 }
 773
 774 static int ath10k_pci_diag_write32(struct ath10k *ar, u32 address, u32 value)
 775 {
 776         __le32 val = __cpu_to_le32(value);
 777
 778         return ath10k_pci_diag_write_mem(ar, address, &val, sizeof(val));
 779 }
 780
 781 static bool ath10k_pci_is_awake(struct ath10k *ar)
 782 {
 783         u32 val = ath10k_pci_reg_read32(ar, RTC_STATE_ADDRESS);
 784
 785         return RTC_STATE_V_GET(val) == RTC_STATE_V_ON;
 786 }
 787
 788 static int ath10k_pci_wake_wait(struct ath10k *ar)
 789 {
 790         int tot_delay = 0;
 791         int curr_delay = 5;
 792
 793         while (tot_delay < PCIE_WAKE_TIMEOUT) {
 794                 if (ath10k_pci_is_awake(ar))
 795                         return 0;
 796
 797                 udelay(curr_delay);
 798                 tot_delay += curr_delay;
 799
 800                 if (curr_delay < 50)
 801                         curr_delay += 5;
 802         }
 803
 804         return -ETIMEDOUT;
 805 }
 806
 807 static int ath10k_pci_wake(struct ath10k *ar)
 808 {
 809         ath10k_pci_reg_write32(ar, PCIE_SOC_WAKE_ADDRESS,
 810                                PCIE_SOC_WAKE_V_MASK);
 811         return ath10k_pci_wake_wait(ar);
 812 }
 813
 814 static void ath10k_pci_sleep(struct ath10k *ar)
 815 {
 816         ath10k_pci_reg_write32(ar, PCIE_SOC_WAKE_ADDRESS,
 817                                PCIE_SOC_WAKE_RESET);
 818 }
 819
 820 /* Called by lower (CE) layer when a send to Target completes. */
 821 static void ath10k_pci_ce_send_done(struct ath10k_ce_pipe *ce_state)
 822 {
 823         struct ath10k *ar = ce_state->ar;
 824         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
 825         struct ath10k_hif_cb *cb = &ar_pci->msg_callbacks_current;
 826         void *transfer_context;
 827         u32 ce_data;
 828         unsigned int nbytes;
 829         unsigned int transfer_id;
 830
 831         while (ath10k_ce_completed_send_next(ce_state, &transfer_context,
 832                                              &ce_data, &nbytes,
 833                                              &transfer_id) == 0) {
 834                 /* no need to call tx completion for NULL pointers */
 835                 if (transfer_context == NULL)
 836                         continue;
 837
 838                 cb->tx_completion(ar, transfer_context, transfer_id);
 839         }
 840 }
 841
 842 /* Called by lower (CE) layer when data is received from the Target. */
 843 static void ath10k_pci_ce_recv_data(struct ath10k_ce_pipe *ce_state)
 844 {
 845         struct ath10k *ar = ce_state->ar;
 846         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
 847         struct ath10k_pci_pipe *pipe_info =  &ar_pci->pipe_info[ce_state->id];
 848         struct ath10k_hif_cb *cb = &ar_pci->msg_callbacks_current;
 849         struct sk_buff *skb;
 850         void *transfer_context;
 851         u32 ce_data;
 852         unsigned int nbytes, max_nbytes;
 853         unsigned int transfer_id;
 854         unsigned int flags;
 855
 856         while (ath10k_ce_completed_recv_next(ce_state, &transfer_context,
 857                                              &ce_data, &nbytes, &transfer_id,
 858                                              &flags) == 0) {
 859                 skb = transfer_context;
 860                 max_nbytes = skb->len + skb_tailroom(skb);
 861                 dma_unmap_single(ar->dev, ATH10K_SKB_CB(skb)->paddr,
 862                                  max_nbytes, DMA_FROM_DEVICE);
 863
 864                 if (unlikely(max_nbytes < nbytes)) {
 865                         ath10k_warn(ar, "rxed more than expected (nbytes %d, max %d)",
 866                                     nbytes, max_nbytes);
 867                         dev_kfree_skb_any(skb);
 868                         continue;
 869                 }
 870
 871                 skb_put(skb, nbytes);
 872
 873                 ath10k_dbg(ar, ATH10K_DBG_PCI, "pci rx ce pipe %d len %d\n",
 874                            ce_state->id, skb->len);
 875                 ath10k_dbg_dump(ar, ATH10K_DBG_PCI_DUMP, NULL, "pci rx: ",
 876                                 skb->data, skb->len);
 877
 878                 cb->rx_completion(ar, skb, pipe_info->pipe_num);
 879         }
 880
 881         ath10k_pci_rx_post_pipe(pipe_info);
 882 }
 883
 884 static int ath10k_pci_hif_tx_sg(struct ath10k *ar, u8 pipe_id,
 885                                 struct ath10k_hif_sg_item *items, int n_items)
 886 {
 887         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
 888         struct ath10k_pci_pipe *pci_pipe = &ar_pci->pipe_info[pipe_id];
 889         struct ath10k_ce_pipe *ce_pipe = pci_pipe->ce_hdl;
 890         struct ath10k_ce_ring *src_ring = ce_pipe->src_ring;
 891         unsigned int nentries_mask;
 892         unsigned int sw_index;
 893         unsigned int write_index;
 894         int err, i = 0;
 895
 896         spin_lock_bh(&ar_pci->ce_lock);
 897
 898         nentries_mask = src_ring->nentries_mask;
 899         sw_index = src_ring->sw_index;
 900         write_index = src_ring->write_index;
 901
 902         if (unlikely(CE_RING_DELTA(nentries_mask,
 903                                    write_index, sw_index - 1) < n_items)) {
 904                 err = -ENOBUFS;
 905                 goto err;
 906         }
 907
 908         for (i = 0; i < n_items - 1; i++) {
 909                 ath10k_dbg(ar, ATH10K_DBG_PCI,
 910                            "pci tx item %d paddr 0x%08x len %d n_items %d\n",
 911                            i, items[i].paddr, items[i].len, n_items);
 912                 ath10k_dbg_dump(ar, ATH10K_DBG_PCI_DUMP, NULL, "pci tx data: ",
 913                                 items[i].vaddr, items[i].len);
 914
 915                 err = ath10k_ce_send_nolock(ce_pipe,
 916                                             items[i].transfer_context,
 917                                             items[i].paddr,
 918                                             items[i].len,
 919                                             items[i].transfer_id,
 920                                             CE_SEND_FLAG_GATHER);
 921                 if (err)
 922                         goto err;
 923         }
 924
 925         /* `i` is equal to `n_items -1` after for() */
 926
 927         ath10k_dbg(ar, ATH10K_DBG_PCI,
 928                    "pci tx item %d paddr 0x%08x len %d n_items %d\n",
 929                    i, items[i].paddr, items[i].len, n_items);
 930         ath10k_dbg_dump(ar, ATH10K_DBG_PCI_DUMP, NULL, "pci tx data: ",
 931                         items[i].vaddr, items[i].len);
 932
 933         err = ath10k_ce_send_nolock(ce_pipe,
 934                                     items[i].transfer_context,
 935                                     items[i].paddr,
 936                                     items[i].len,
 937                                     items[i].transfer_id,
 938                                     0);
 939         if (err)
 940                 goto err;
 941
 942         spin_unlock_bh(&ar_pci->ce_lock);
 943         return 0;
 944
 945 err:
 946         for (; i > 0; i--)
 947                 __ath10k_ce_send_revert(ce_pipe);
 948
 949         spin_unlock_bh(&ar_pci->ce_lock);
 950         return err;
 951 }
 952
 953 static int ath10k_pci_hif_diag_read(struct ath10k *ar, u32 address, void *buf,
 954                                     size_t buf_len)
 955 {
 956         return ath10k_pci_diag_read_mem(ar, address, buf, buf_len);
 957 }
 958
 959 static u16 ath10k_pci_hif_get_free_queue_number(struct ath10k *ar, u8 pipe)
 960 {
 961         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
 962
 963         ath10k_dbg(ar, ATH10K_DBG_PCI, "pci hif get free queue number\n");
 964
 965         return ath10k_ce_num_free_src_entries(ar_pci->pipe_info[pipe].ce_hdl);
 966 }
 967
 968 static void ath10k_pci_dump_registers(struct ath10k *ar,
 969                                       struct ath10k_fw_crash_data *crash_data)
 970 {
 971         __le32 reg_dump_values[REG_DUMP_COUNT_QCA988X] = {};
 972         int i, ret;
 973
 974         lockdep_assert_held(&ar->data_lock);
 975
 976         ret = ath10k_pci_diag_read_hi(ar, &reg_dump_values[0],
 977                                       hi_failure_state,
 978                                       REG_DUMP_COUNT_QCA988X * sizeof(__le32));
 979         if (ret) {
 980                 ath10k_err(ar, "failed to read firmware dump area: %d\n", ret);
 981                 return;
 982         }
 983
 984         BUILD_BUG_ON(REG_DUMP_COUNT_QCA988X % 4);
 985
 986         ath10k_err(ar, "firmware register dump:\n");
 987         for (i = 0; i < REG_DUMP_COUNT_QCA988X; i += 4)
 988                 ath10k_err(ar, "[%02d]: 0x%08X 0x%08X 0x%08X 0x%08X\n",
 989                            i,
 990                            __le32_to_cpu(reg_dump_values[i]),
 991                            __le32_to_cpu(reg_dump_values[i + 1]),
 992                            __le32_to_cpu(reg_dump_values[i + 2]),
 993                            __le32_to_cpu(reg_dump_values[i + 3]));
 994
 995         if (!crash_data)
 996                 return;
 997
 998         for (i = 0; i < REG_DUMP_COUNT_QCA988X; i++)
 999                 crash_data->registers[i] = reg_dump_values[i];
1000 }
1001
1002 static void ath10k_pci_fw_crashed_dump(struct ath10k *ar)
1003 {
1004         struct ath10k_fw_crash_data *crash_data;
1005         char uuid[50];
1006
1007         spin_lock_bh(&ar->data_lock);
1008
1009         ar->stats.fw_crash_counter++;
1010
1011         crash_data = ath10k_debug_get_new_fw_crash_data(ar);
1012
1013         if (crash_data)
1014                 scnprintf(uuid, sizeof(uuid), "%pUl", &crash_data->uuid);
1015         else
1016                 scnprintf(uuid, sizeof(uuid), "n/a");
1017
1018         ath10k_err(ar, "firmware crashed! (uuid %s)\n", uuid);
1019         ath10k_print_driver_info(ar);
1020         ath10k_pci_dump_registers(ar, crash_data);
1021
1022         spin_unlock_bh(&ar->data_lock);
1023
1024         queue_work(ar->workqueue, &ar->restart_work);
1025 }
1026
1027 static void ath10k_pci_hif_send_complete_check(struct ath10k *ar, u8 pipe,
1028                                                int force)
1029 {
1030         ath10k_dbg(ar, ATH10K_DBG_PCI, "pci hif send complete check\n");
1031
1032         if (!force) {
1033                 int resources;
1034                 /*
1035                  * Decide whether to actually poll for completions, or just
1036                  * wait for a later chance.
1037                  * If there seem to be plenty of resources left, then just wait
1038                  * since checking involves reading a CE register, which is a
1039                  * relatively expensive operation.
1040                  */
1041                 resources = ath10k_pci_hif_get_free_queue_number(ar, pipe);
1042
1043                 /*
1044                  * If at least 50% of the total resources are still available,
1045                  * don't bother checking again yet.
1046                  */
1047                 if (resources > (host_ce_config_wlan[pipe].src_nentries >> 1))
1048                         return;
1049         }
1050         ath10k_ce_per_engine_service(ar, pipe);
1051 }
1052
1053 static void ath10k_pci_hif_set_callbacks(struct ath10k *ar,
1054                                          struct ath10k_hif_cb *callbacks)
1055 {
1056         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1057
1058         ath10k_dbg(ar, ATH10K_DBG_PCI, "pci hif set callbacks\n");
1059
1060         memcpy(&ar_pci->msg_callbacks_current, callbacks,
1061                sizeof(ar_pci->msg_callbacks_current));
1062 }
1063
1064 static void ath10k_pci_kill_tasklet(struct ath10k *ar)
1065 {
1066         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1067         int i;
1068
1069         tasklet_kill(&ar_pci->intr_tq);
1070         tasklet_kill(&ar_pci->msi_fw_err);
1071
1072         for (i = 0; i < CE_COUNT; i++)
1073                 tasklet_kill(&ar_pci->pipe_info[i].intr);
1074
1075         del_timer_sync(&ar_pci->rx_post_retry);
1076 }
1077
1078 static int ath10k_pci_hif_map_service_to_pipe(struct ath10k *ar,
1079                                               u16 service_id, u8 *ul_pipe,
1080                                               u8 *dl_pipe, int *ul_is_polled,
1081                                               int *dl_is_polled)
1082 {
1083         const struct service_to_pipe *entry;
1084         bool ul_set = false, dl_set = false;
1085         int i;
1086
1087         ath10k_dbg(ar, ATH10K_DBG_PCI, "pci hif map service\n");
1088
1089         /* polling for received messages not supported */
1090         *dl_is_polled = 0;
1091
1092         for (i = 0; i < ARRAY_SIZE(target_service_to_ce_map_wlan); i++) {
1093                 entry = &target_service_to_ce_map_wlan[i];
1094
1095                 if (__le32_to_cpu(entry->service_id) != service_id)
1096                         continue;
1097
1098                 switch (__le32_to_cpu(entry->pipedir)) {
1099                 case PIPEDIR_NONE:
1100                         break;
1101                 case PIPEDIR_IN:
1102                         WARN_ON(dl_set);
1103                         *dl_pipe = __le32_to_cpu(entry->pipenum);
1104                         dl_set = true;
1105                         break;
1106                 case PIPEDIR_OUT:
1107                         WARN_ON(ul_set);
1108                         *ul_pipe = __le32_to_cpu(entry->pipenum);
1109                         ul_set = true;
1110                         break;
1111                 case PIPEDIR_INOUT:
1112                         WARN_ON(dl_set);
1113                         WARN_ON(ul_set);
1114                         *dl_pipe = __le32_to_cpu(entry->pipenum);
1115                         *ul_pipe = __le32_to_cpu(entry->pipenum);
1116                         dl_set = true;
1117                         ul_set = true;
1118                         break;
1119                 }
1120         }
1121
1122         if (WARN_ON(!ul_set || !dl_set))
1123                 return -ENOENT;
1124
1125         *ul_is_polled =
1126                 (host_ce_config_wlan[*ul_pipe].flags & CE_ATTR_DIS_INTR) != 0;
1127
1128         return 0;
1129 }
1130
1131 static void ath10k_pci_hif_get_default_pipe(struct ath10k *ar,
1132                                             u8 *ul_pipe, u8 *dl_pipe)
1133 {
1134         int ul_is_polled, dl_is_polled;
1135
1136         ath10k_dbg(ar, ATH10K_DBG_PCI, "pci hif get default pipe\n");
1137
1138         (void)ath10k_pci_hif_map_service_to_pipe(ar,
1139                                                  ATH10K_HTC_SVC_ID_RSVD_CTRL,
1140                                                  ul_pipe,
1141                                                  dl_pipe,
1142                                                  &ul_is_polled,
1143                                                  &dl_is_polled);
1144 }
1145
1146 static void ath10k_pci_irq_msi_fw_mask(struct ath10k *ar)
1147 {
1148         u32 val;
1149
1150         val = ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS + CORE_CTRL_ADDRESS);
1151         val &= ~CORE_CTRL_PCIE_REG_31_MASK;
1152
1153         ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS + CORE_CTRL_ADDRESS, val);
1154 }
1155
1156 static void ath10k_pci_irq_msi_fw_unmask(struct ath10k *ar)
1157 {
1158         u32 val;
1159
1160         val = ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS + CORE_CTRL_ADDRESS);
1161         val |= CORE_CTRL_PCIE_REG_31_MASK;
1162
1163         ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS + CORE_CTRL_ADDRESS, val);
1164 }
1165
1166 static void ath10k_pci_irq_disable(struct ath10k *ar)
1167 {
1168         ath10k_ce_disable_interrupts(ar);
1169         ath10k_pci_disable_and_clear_legacy_irq(ar);
1170         ath10k_pci_irq_msi_fw_mask(ar);
1171 }
1172
1173 static void ath10k_pci_irq_sync(struct ath10k *ar)
1174 {
1175         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1176         int i;
1177
1178         for (i = 0; i < max(1, ar_pci->num_msi_intrs); i++)
1179                 synchronize_irq(ar_pci->pdev->irq + i);
1180 }
1181
1182 static void ath10k_pci_irq_enable(struct ath10k *ar)
1183 {
1184         ath10k_ce_enable_interrupts(ar);
1185         ath10k_pci_enable_legacy_irq(ar);
1186         ath10k_pci_irq_msi_fw_unmask(ar);
1187 }
1188
1189 static int ath10k_pci_hif_start(struct ath10k *ar)
1190 {
1191         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot hif start\n");
1192
1193         ath10k_pci_irq_enable(ar);
1194         ath10k_pci_rx_post(ar);
1195
1196         return 0;
1197 }
1198
1199 static void ath10k_pci_rx_pipe_cleanup(struct ath10k_pci_pipe *pci_pipe)
1200 {
1201         struct ath10k *ar;
1202         struct ath10k_ce_pipe *ce_pipe;
1203         struct ath10k_ce_ring *ce_ring;
1204         struct sk_buff *skb;
1205         int i;
1206
1207         ar = pci_pipe->hif_ce_state;
1208         ce_pipe = pci_pipe->ce_hdl;
1209         ce_ring = ce_pipe->dest_ring;
1210
1211         if (!ce_ring)
1212                 return;
1213
1214         if (!pci_pipe->buf_sz)
1215                 return;
1216
1217         for (i = 0; i < ce_ring->nentries; i++) {
1218                 skb = ce_ring->per_transfer_context[i];
1219                 if (!skb)
1220                         continue;
1221
1222                 ce_ring->per_transfer_context[i] = NULL;
1223
1224                 dma_unmap_single(ar->dev, ATH10K_SKB_CB(skb)->paddr,
1225                                  skb->len + skb_tailroom(skb),
1226                                  DMA_FROM_DEVICE);
1227                 dev_kfree_skb_any(skb);
1228         }
1229 }
1230
1231 static void ath10k_pci_tx_pipe_cleanup(struct ath10k_pci_pipe *pci_pipe)
1232 {
1233         struct ath10k *ar;
1234         struct ath10k_pci *ar_pci;
1235         struct ath10k_ce_pipe *ce_pipe;
1236         struct ath10k_ce_ring *ce_ring;
1237         struct ce_desc *ce_desc;
1238         struct sk_buff *skb;
1239         unsigned int id;
1240         int i;
1241
1242         ar = pci_pipe->hif_ce_state;
1243         ar_pci = ath10k_pci_priv(ar);
1244         ce_pipe = pci_pipe->ce_hdl;
1245         ce_ring = ce_pipe->src_ring;
1246
1247         if (!ce_ring)
1248                 return;
1249
1250         if (!pci_pipe->buf_sz)
1251                 return;
1252
1253         ce_desc = ce_ring->shadow_base;
1254         if (WARN_ON(!ce_desc))
1255                 return;
1256
1257         for (i = 0; i < ce_ring->nentries; i++) {
1258                 skb = ce_ring->per_transfer_context[i];
1259                 if (!skb)
1260                         continue;
1261
1262                 ce_ring->per_transfer_context[i] = NULL;
1263                 id = MS(__le16_to_cpu(ce_desc[i].flags),
1264                         CE_DESC_FLAGS_META_DATA);
1265
1266                 ar_pci->msg_callbacks_current.tx_completion(ar, skb, id);
1267         }
1268 }
1269
1270 /*
1271  * Cleanup residual buffers for device shutdown:
1272  *    buffers that were enqueued for receive
1273  *    buffers that were to be sent
1274  * Note: Buffers that had completed but which were
1275  * not yet processed are on a completion queue. They
1276  * are handled when the completion thread shuts down.
1277  */
1278 static void ath10k_pci_buffer_cleanup(struct ath10k *ar)
1279 {
1280         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1281         int pipe_num;
1282
1283         for (pipe_num = 0; pipe_num < CE_COUNT; pipe_num++) {
1284                 struct ath10k_pci_pipe *pipe_info;
1285
1286                 pipe_info = &ar_pci->pipe_info[pipe_num];
1287                 ath10k_pci_rx_pipe_cleanup(pipe_info);
1288                 ath10k_pci_tx_pipe_cleanup(pipe_info);
1289         }
1290 }
1291
1292 static void ath10k_pci_ce_deinit(struct ath10k *ar)
1293 {
1294         int i;
1295
1296         for (i = 0; i < CE_COUNT; i++)
1297                 ath10k_ce_deinit_pipe(ar, i);
1298 }
1299
1300 static void ath10k_pci_flush(struct ath10k *ar)
1301 {
1302         ath10k_pci_kill_tasklet(ar);
1303         ath10k_pci_buffer_cleanup(ar);
1304 }
1305
1306 static void ath10k_pci_hif_stop(struct ath10k *ar)
1307 {
1308         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot hif stop\n");
1309
1310         /* Most likely the device has HTT Rx ring configured. The only way to
1311          * prevent the device from accessing (and possible corrupting) host
1312          * memory is to reset the chip now.
1313          *
1314          * There's also no known way of masking MSI interrupts on the device.
1315          * For ranged MSI the CE-related interrupts can be masked. However
1316          * regardless how many MSI interrupts are assigned the first one
1317          * is always used for firmware indications (crashes) and cannot be
1318          * masked. To prevent the device from asserting the interrupt reset it
1319          * before proceeding with cleanup.
1320          */
1321         ath10k_pci_warm_reset(ar);
1322
1323         ath10k_pci_irq_disable(ar);
1324         ath10k_pci_irq_sync(ar);
1325         ath10k_pci_flush(ar);
1326 }
1327
1328 static int ath10k_pci_hif_exchange_bmi_msg(struct ath10k *ar,
1329                                            void *req, u32 req_len,
1330                                            void *resp, u32 *resp_len)
1331 {
1332         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1333         struct ath10k_pci_pipe *pci_tx = &ar_pci->pipe_info[BMI_CE_NUM_TO_TARG];
1334         struct ath10k_pci_pipe *pci_rx = &ar_pci->pipe_info[BMI_CE_NUM_TO_HOST];
1335         struct ath10k_ce_pipe *ce_tx = pci_tx->ce_hdl;
1336         struct ath10k_ce_pipe *ce_rx = pci_rx->ce_hdl;
1337         dma_addr_t req_paddr = 0;
1338         dma_addr_t resp_paddr = 0;
1339         struct bmi_xfer xfer = {};
1340         void *treq, *tresp = NULL;
1341         int ret = 0;
1342
1343         might_sleep();
1344
1345         if (resp && !resp_len)
1346                 return -EINVAL;
1347
1348         if (resp && resp_len && *resp_len == 0)
1349                 return -EINVAL;
1350
1351         treq = kmemdup(req, req_len, GFP_KERNEL);
1352         if (!treq)
1353                 return -ENOMEM;
1354
1355         req_paddr = dma_map_single(ar->dev, treq, req_len, DMA_TO_DEVICE);
1356         ret = dma_mapping_error(ar->dev, req_paddr);
1357         if (ret)
1358                 goto err_dma;
1359
1360         if (resp && resp_len) {
1361                 tresp = kzalloc(*resp_len, GFP_KERNEL);
1362                 if (!tresp) {
1363                         ret = -ENOMEM;
1364                         goto err_req;
1365                 }
1366
1367                 resp_paddr = dma_map_single(ar->dev, tresp, *resp_len,
1368                                             DMA_FROM_DEVICE);
1369                 ret = dma_mapping_error(ar->dev, resp_paddr);
1370                 if (ret)
1371                         goto err_req;
1372
1373                 xfer.wait_for_resp = true;
1374                 xfer.resp_len = 0;
1375
1376                 ath10k_ce_rx_post_buf(ce_rx, &xfer, resp_paddr);
1377         }
1378
1379         ret = ath10k_ce_send(ce_tx, &xfer, req_paddr, req_len, -1, 0);
1380         if (ret)
1381                 goto err_resp;
1382
1383         ret = ath10k_pci_bmi_wait(ce_tx, ce_rx, &xfer);
1384         if (ret) {
1385                 u32 unused_buffer;
1386                 unsigned int unused_nbytes;
1387                 unsigned int unused_id;
1388
1389                 ath10k_ce_cancel_send_next(ce_tx, NULL, &unused_buffer,
1390                                            &unused_nbytes, &unused_id);
1391         } else {
1392                 /* non-zero means we did not time out */
1393                 ret = 0;
1394         }
1395
1396 err_resp:
1397         if (resp) {
1398                 u32 unused_buffer;
1399
1400                 ath10k_ce_revoke_recv_next(ce_rx, NULL, &unused_buffer);
1401                 dma_unmap_single(ar->dev, resp_paddr,
1402                                  *resp_len, DMA_FROM_DEVICE);
1403         }
1404 err_req:
1405         dma_unmap_single(ar->dev, req_paddr, req_len, DMA_TO_DEVICE);
1406
1407         if (ret == 0 && resp_len) {
1408                 *resp_len = min(*resp_len, xfer.resp_len);
1409                 memcpy(resp, tresp, xfer.resp_len);
1410         }
1411 err_dma:
1412         kfree(treq);
1413         kfree(tresp);
1414
1415         return ret;
1416 }
1417
1418 static void ath10k_pci_bmi_send_done(struct ath10k_ce_pipe *ce_state)
1419 {
1420         struct bmi_xfer *xfer;
1421         u32 ce_data;
1422         unsigned int nbytes;
1423         unsigned int transfer_id;
1424
1425         if (ath10k_ce_completed_send_next(ce_state, (void **)&xfer, &ce_data,
1426                                           &nbytes, &transfer_id))
1427                 return;
1428
1429         xfer->tx_done = true;
1430 }
1431
1432 static void ath10k_pci_bmi_recv_data(struct ath10k_ce_pipe *ce_state)
1433 {
1434         struct ath10k *ar = ce_state->ar;
1435         struct bmi_xfer *xfer;
1436         u32 ce_data;
1437         unsigned int nbytes;
1438         unsigned int transfer_id;
1439         unsigned int flags;
1440
1441         if (ath10k_ce_completed_recv_next(ce_state, (void **)&xfer, &ce_data,
1442                                           &nbytes, &transfer_id, &flags))
1443                 return;
1444
1445         if (!xfer->wait_for_resp) {
1446                 ath10k_warn(ar, "unexpected: BMI data received; ignoring\n");
1447                 return;
1448         }
1449
1450         xfer->resp_len = nbytes;
1451         xfer->rx_done = true;
1452 }
1453
1454 static int ath10k_pci_bmi_wait(struct ath10k_ce_pipe *tx_pipe,
1455                                struct ath10k_ce_pipe *rx_pipe,
1456                                struct bmi_xfer *xfer)
1457 {
1458         unsigned long timeout = jiffies + BMI_COMMUNICATION_TIMEOUT_HZ;
1459
1460         while (time_before_eq(jiffies, timeout)) {
1461                 ath10k_pci_bmi_send_done(tx_pipe);
1462                 ath10k_pci_bmi_recv_data(rx_pipe);
1463
1464                 if (xfer->tx_done && (xfer->rx_done == xfer->wait_for_resp))
1465                         return 0;
1466
1467                 schedule();
1468         }
1469
1470         return -ETIMEDOUT;
1471 }
1472
1473 /*
1474  * Send an interrupt to the device to wake up the Target CPU
1475  * so it has an opportunity to notice any changed state.
1476  */
1477 static int ath10k_pci_wake_target_cpu(struct ath10k *ar)
1478 {
1479         u32 addr, val;
1480
1481         addr = SOC_CORE_BASE_ADDRESS | CORE_CTRL_ADDRESS;
1482         val = ath10k_pci_read32(ar, addr);
1483         val |= CORE_CTRL_CPU_INTR_MASK;
1484         ath10k_pci_write32(ar, addr, val);
1485
1486         return 0;
1487 }
1488
1489 static int ath10k_pci_init_config(struct ath10k *ar)
1490 {
1491         u32 interconnect_targ_addr;
1492         u32 pcie_state_targ_addr = 0;
1493         u32 pipe_cfg_targ_addr = 0;
1494         u32 svc_to_pipe_map = 0;
1495         u32 pcie_config_flags = 0;
1496         u32 ealloc_value;
1497         u32 ealloc_targ_addr;
1498         u32 flag2_value;
1499         u32 flag2_targ_addr;
1500         int ret = 0;
1501
1502         /* Download to Target the CE Config and the service-to-CE map */
1503         interconnect_targ_addr =
1504                 host_interest_item_address(HI_ITEM(hi_interconnect_state));
1505
1506         /* Supply Target-side CE configuration */
1507         ret = ath10k_pci_diag_read32(ar, interconnect_targ_addr,
1508                                      &pcie_state_targ_addr);
1509         if (ret != 0) {
1510                 ath10k_err(ar, "Failed to get pcie state addr: %d\n", ret);
1511                 return ret;
1512         }
1513
1514         if (pcie_state_targ_addr == 0) {
1515                 ret = -EIO;
1516                 ath10k_err(ar, "Invalid pcie state addr\n");
1517                 return ret;
1518         }
1519
1520         ret = ath10k_pci_diag_read32(ar, (pcie_state_targ_addr +
1521                                           offsetof(struct pcie_state,
1522                                                    pipe_cfg_addr)),
1523                                      &pipe_cfg_targ_addr);
1524         if (ret != 0) {
1525                 ath10k_err(ar, "Failed to get pipe cfg addr: %d\n", ret);
1526                 return ret;
1527         }
1528
1529         if (pipe_cfg_targ_addr == 0) {
1530                 ret = -EIO;
1531                 ath10k_err(ar, "Invalid pipe cfg addr\n");
1532                 return ret;
1533         }
1534
1535         ret = ath10k_pci_diag_write_mem(ar, pipe_cfg_targ_addr,
1536                                         target_ce_config_wlan,
1537                                         sizeof(target_ce_config_wlan));
1538
1539         if (ret != 0) {
1540                 ath10k_err(ar, "Failed to write pipe cfg: %d\n", ret);
1541                 return ret;
1542         }
1543
1544         ret = ath10k_pci_diag_read32(ar, (pcie_state_targ_addr +
1545                                           offsetof(struct pcie_state,
1546                                                    svc_to_pipe_map)),
1547                                      &svc_to_pipe_map);
1548         if (ret != 0) {
1549                 ath10k_err(ar, "Failed to get svc/pipe map: %d\n", ret);
1550                 return ret;
1551         }
1552
1553         if (svc_to_pipe_map == 0) {
1554                 ret = -EIO;
1555                 ath10k_err(ar, "Invalid svc_to_pipe map\n");
1556                 return ret;
1557         }
1558
1559         ret = ath10k_pci_diag_write_mem(ar, svc_to_pipe_map,
1560                                         target_service_to_ce_map_wlan,
1561                                         sizeof(target_service_to_ce_map_wlan));
1562         if (ret != 0) {
1563                 ath10k_err(ar, "Failed to write svc/pipe map: %d\n", ret);
1564                 return ret;
1565         }
1566
1567         ret = ath10k_pci_diag_read32(ar, (pcie_state_targ_addr +
1568                                           offsetof(struct pcie_state,
1569                                                    config_flags)),
1570                                      &pcie_config_flags);
1571         if (ret != 0) {
1572                 ath10k_err(ar, "Failed to get pcie config_flags: %d\n", ret);
1573                 return ret;
1574         }
1575
1576         pcie_config_flags &= ~PCIE_CONFIG_FLAG_ENABLE_L1;
1577
1578         ret = ath10k_pci_diag_write32(ar, (pcie_state_targ_addr +
1579                                            offsetof(struct pcie_state,
1580                                                     config_flags)),
1581                                       pcie_config_flags);
1582         if (ret != 0) {
1583                 ath10k_err(ar, "Failed to write pcie config_flags: %d\n", ret);
1584                 return ret;
1585         }
1586
1587         /* configure early allocation */
1588         ealloc_targ_addr = host_interest_item_address(HI_ITEM(hi_early_alloc));
1589
1590         ret = ath10k_pci_diag_read32(ar, ealloc_targ_addr, &ealloc_value);
1591         if (ret != 0) {
1592                 ath10k_err(ar, "Faile to get early alloc val: %d\n", ret);
1593                 return ret;
1594         }
1595
1596         /* first bank is switched to IRAM */
1597         ealloc_value |= ((HI_EARLY_ALLOC_MAGIC << HI_EARLY_ALLOC_MAGIC_SHIFT) &
1598                          HI_EARLY_ALLOC_MAGIC_MASK);
1599         ealloc_value |= ((1 << HI_EARLY_ALLOC_IRAM_BANKS_SHIFT) &
1600                          HI_EARLY_ALLOC_IRAM_BANKS_MASK);
1601
1602         ret = ath10k_pci_diag_write32(ar, ealloc_targ_addr, ealloc_value);
1603         if (ret != 0) {
1604                 ath10k_err(ar, "Failed to set early alloc val: %d\n", ret);
1605                 return ret;
1606         }
1607
1608         /* Tell Target to proceed with initialization */
1609         flag2_targ_addr = host_interest_item_address(HI_ITEM(hi_option_flag2));
1610
1611         ret = ath10k_pci_diag_read32(ar, flag2_targ_addr, &flag2_value);
1612         if (ret != 0) {
1613                 ath10k_err(ar, "Failed to get option val: %d\n", ret);
1614                 return ret;
1615         }
1616
1617         flag2_value |= HI_OPTION_EARLY_CFG_DONE;
1618
1619         ret = ath10k_pci_diag_write32(ar, flag2_targ_addr, flag2_value);
1620         if (ret != 0) {
1621                 ath10k_err(ar, "Failed to set option val: %d\n", ret);
1622                 return ret;
1623         }
1624
1625         return 0;
1626 }
1627
1628 static int ath10k_pci_alloc_pipes(struct ath10k *ar)
1629 {
1630         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1631         struct ath10k_pci_pipe *pipe;
1632         int i, ret;
1633
1634         for (i = 0; i < CE_COUNT; i++) {
1635                 pipe = &ar_pci->pipe_info[i];
1636                 pipe->ce_hdl = &ar_pci->ce_states[i];
1637                 pipe->pipe_num = i;
1638                 pipe->hif_ce_state = ar;
1639
1640                 ret = ath10k_ce_alloc_pipe(ar, i, &host_ce_config_wlan[i],
1641                                            ath10k_pci_ce_send_done,
1642                                            ath10k_pci_ce_recv_data);
1643                 if (ret) {
1644                         ath10k_err(ar, "failed to allocate copy engine pipe %d: %d\n",
1645                                    i, ret);
1646                         return ret;
1647                 }
1648
1649                 /* Last CE is Diagnostic Window */
1650                 if (i == CE_COUNT - 1) {
1651                         ar_pci->ce_diag = pipe->ce_hdl;
1652                         continue;
1653                 }
1654
1655                 pipe->buf_sz = (size_t)(host_ce_config_wlan[i].src_sz_max);
1656         }
1657
1658         return 0;
1659 }
1660
1661 static void ath10k_pci_free_pipes(struct ath10k *ar)
1662 {
1663         int i;
1664
1665         for (i = 0; i < CE_COUNT; i++)
1666                 ath10k_ce_free_pipe(ar, i);
1667 }
1668
1669 static int ath10k_pci_init_pipes(struct ath10k *ar)
1670 {
1671         int i, ret;
1672
1673         for (i = 0; i < CE_COUNT; i++) {
1674                 ret = ath10k_ce_init_pipe(ar, i, &host_ce_config_wlan[i]);
1675                 if (ret) {
1676                         ath10k_err(ar, "failed to initialize copy engine pipe %d: %d\n",
1677                                    i, ret);
1678                         return ret;
1679                 }
1680         }
1681
1682         return 0;
1683 }
1684
1685 static bool ath10k_pci_has_fw_crashed(struct ath10k *ar)
1686 {
1687         return ath10k_pci_read32(ar, FW_INDICATOR_ADDRESS) &
1688                FW_IND_EVENT_PENDING;
1689 }
1690
1691 static void ath10k_pci_fw_crashed_clear(struct ath10k *ar)
1692 {
1693         u32 val;
1694
1695         val = ath10k_pci_read32(ar, FW_INDICATOR_ADDRESS);
1696         val &= ~FW_IND_EVENT_PENDING;
1697         ath10k_pci_write32(ar, FW_INDICATOR_ADDRESS, val);
1698 }
1699
1700 /* this function effectively clears target memory controller assert line */
1701 static void ath10k_pci_warm_reset_si0(struct ath10k *ar)
1702 {
1703         u32 val;
1704
1705         val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
1706         ath10k_pci_soc_write32(ar, SOC_RESET_CONTROL_ADDRESS,
1707                                val | SOC_RESET_CONTROL_SI0_RST_MASK);
1708         val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
1709
1710         msleep(10);
1711
1712         val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
1713         ath10k_pci_soc_write32(ar, SOC_RESET_CONTROL_ADDRESS,
1714                                val & ~SOC_RESET_CONTROL_SI0_RST_MASK);
1715         val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
1716
1717         msleep(10);
1718 }
1719
1720 static void ath10k_pci_warm_reset_cpu(struct ath10k *ar)
1721 {
1722         u32 val;
1723
1724         ath10k_pci_write32(ar, FW_INDICATOR_ADDRESS, 0);
1725
1726         val = ath10k_pci_read32(ar, RTC_SOC_BASE_ADDRESS +
1727                                 SOC_RESET_CONTROL_ADDRESS);
1728         ath10k_pci_write32(ar, RTC_SOC_BASE_ADDRESS + SOC_RESET_CONTROL_ADDRESS,
1729                            val | SOC_RESET_CONTROL_CPU_WARM_RST_MASK);
1730 }
1731
1732 static void ath10k_pci_warm_reset_ce(struct ath10k *ar)
1733 {
1734         u32 val;
1735
1736         val = ath10k_pci_read32(ar, RTC_SOC_BASE_ADDRESS +
1737                                 SOC_RESET_CONTROL_ADDRESS);
1738
1739         ath10k_pci_write32(ar, RTC_SOC_BASE_ADDRESS + SOC_RESET_CONTROL_ADDRESS,
1740                            val | SOC_RESET_CONTROL_CE_RST_MASK);
1741         msleep(10);
1742         ath10k_pci_write32(ar, RTC_SOC_BASE_ADDRESS + SOC_RESET_CONTROL_ADDRESS,
1743                            val & ~SOC_RESET_CONTROL_CE_RST_MASK);
1744 }
1745
1746 static void ath10k_pci_warm_reset_clear_lf(struct ath10k *ar)
1747 {
1748         u32 val;
1749
1750         val = ath10k_pci_read32(ar, RTC_SOC_BASE_ADDRESS +
1751                                 SOC_LF_TIMER_CONTROL0_ADDRESS);
1752         ath10k_pci_write32(ar, RTC_SOC_BASE_ADDRESS +
1753                            SOC_LF_TIMER_CONTROL0_ADDRESS,
1754                            val & ~SOC_LF_TIMER_CONTROL0_ENABLE_MASK);
1755 }
1756
1757 static int ath10k_pci_warm_reset(struct ath10k *ar)
1758 {
1759         int ret;
1760
1761         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot warm reset\n");
1762
1763         spin_lock_bh(&ar->data_lock);
1764         ar->stats.fw_warm_reset_counter++;
1765         spin_unlock_bh(&ar->data_lock);
1766
1767         ath10k_pci_irq_disable(ar);
1768
1769         /* Make sure the target CPU is not doing anything dangerous, e.g. if it
1770          * were to access copy engine while host performs copy engine reset
1771          * then it is possible for the device to confuse pci-e controller to
1772          * the point of bringing host system to a complete stop (i.e. hang).
1773          */
1774         ath10k_pci_warm_reset_si0(ar);
1775         ath10k_pci_warm_reset_cpu(ar);
1776         ath10k_pci_init_pipes(ar);
1777         ath10k_pci_wait_for_target_init(ar);
1778
1779         ath10k_pci_warm_reset_clear_lf(ar);
1780         ath10k_pci_warm_reset_ce(ar);
1781         ath10k_pci_warm_reset_cpu(ar);
1782         ath10k_pci_init_pipes(ar);
1783
1784         ret = ath10k_pci_wait_for_target_init(ar);
1785         if (ret) {
1786                 ath10k_warn(ar, "failed to wait for target init: %d\n", ret);
1787                 return ret;
1788         }
1789
1790         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot warm reset complete\n");
1791
1792         return 0;
1793 }
1794
1795 static int ath10k_pci_chip_reset(struct ath10k *ar)
1796 {
1797         int i, ret;
1798         u32 val;
1799
1800         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot chip reset\n");
1801
1802         /* Some hardware revisions (e.g. CUS223v2) has issues with cold reset.
1803          * It is thus preferred to use warm reset which is safer but may not be
1804          * able to recover the device from all possible fail scenarios.
1805          *
1806          * Warm reset doesn't always work on first try so attempt it a few
1807          * times before giving up.
1808          */
1809         for (i = 0; i < ATH10K_PCI_NUM_WARM_RESET_ATTEMPTS; i++) {
1810                 ret = ath10k_pci_warm_reset(ar);
1811                 if (ret) {
1812                         ath10k_warn(ar, "failed to warm reset attempt %d of %d: %d\n",
1813                                     i + 1, ATH10K_PCI_NUM_WARM_RESET_ATTEMPTS,
1814                                     ret);
1815                         continue;
1816                 }
1817
1818                 /* FIXME: Sometimes copy engine doesn't recover after warm
1819                  * reset. In most cases this needs cold reset. In some of these
1820                  * cases the device is in such a state that a cold reset may
1821                  * lock up the host.
1822                  *
1823                  * Reading any host interest register via copy engine is
1824                  * sufficient to verify if device is capable of booting
1825                  * firmware blob.
1826                  */
1827                 ret = ath10k_pci_init_pipes(ar);
1828                 if (ret) {
1829                         ath10k_warn(ar, "failed to init copy engine: %d\n",
1830                                     ret);
1831                         continue;
1832                 }
1833
1834                 ret = ath10k_pci_diag_read32(ar, QCA988X_HOST_INTEREST_ADDRESS,
1835                                              &val);
1836                 if (ret) {
1837                         ath10k_warn(ar, "failed to poke copy engine: %d\n",
1838                                     ret);
1839                         continue;
1840                 }
1841
1842                 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot chip reset complete (warm)\n");
1843                 return 0;
1844         }
1845
1846         if (ath10k_pci_reset_mode == ATH10K_PCI_RESET_WARM_ONLY) {
1847                 ath10k_warn(ar, "refusing cold reset as requested\n");
1848                 return -EPERM;
1849         }
1850
1851         ret = ath10k_pci_cold_reset(ar);
1852         if (ret) {
1853                 ath10k_warn(ar, "failed to cold reset: %d\n", ret);
1854                 return ret;
1855         }
1856
1857         ret = ath10k_pci_wait_for_target_init(ar);
1858         if (ret) {
1859                 ath10k_warn(ar, "failed to wait for target after cold reset: %d\n",
1860                             ret);
1861                 return ret;
1862         }
1863
1864         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot chip reset complete (cold)\n");
1865
1866         return 0;
1867 }
1868
1869 static int ath10k_pci_hif_power_up(struct ath10k *ar)
1870 {
1871         int ret;
1872
1873         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot hif power up\n");
1874
1875         /*
1876          * Bring the target up cleanly.
1877          *
1878          * The target may be in an undefined state with an AUX-powered Target
1879          * and a Host in WoW mode. If the Host crashes, loses power, or is
1880          * restarted (without unloading the driver) then the Target is left
1881          * (aux) powered and running. On a subsequent driver load, the Target
1882          * is in an unexpected state. We try to catch that here in order to
1883          * reset the Target and retry the probe.
1884          */
1885         ret = ath10k_pci_chip_reset(ar);
1886         if (ret) {
1887                 ath10k_err(ar, "failed to reset chip: %d\n", ret);
1888                 goto err;
1889         }
1890
1891         ret = ath10k_pci_init_pipes(ar);
1892         if (ret) {
1893                 ath10k_err(ar, "failed to initialize CE: %d\n", ret);
1894                 goto err;
1895         }
1896
1897         ret = ath10k_pci_init_config(ar);
1898         if (ret) {
1899                 ath10k_err(ar, "failed to setup init config: %d\n", ret);
1900                 goto err_ce;
1901         }
1902
1903         ret = ath10k_pci_wake_target_cpu(ar);
1904         if (ret) {
1905                 ath10k_err(ar, "could not wake up target CPU: %d\n", ret);
1906                 goto err_ce;
1907         }
1908
1909         return 0;
1910
1911 err_ce:
1912         ath10k_pci_ce_deinit(ar);
1913
1914 err:
1915         return ret;
1916 }
1917
1918 static void ath10k_pci_hif_power_down(struct ath10k *ar)
1919 {
1920         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot hif power down\n");
1921
1922         ath10k_pci_warm_reset(ar);
1923 }
1924
1925 #ifdef CONFIG_PM
1926
1927 #define ATH10K_PCI_PM_CONTROL 0x44
1928
1929 static int ath10k_pci_hif_suspend(struct ath10k *ar)
1930 {
1931         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1932         struct pci_dev *pdev = ar_pci->pdev;
1933         u32 val;
1934
1935         pci_read_config_dword(pdev, ATH10K_PCI_PM_CONTROL, &val);
1936
1937         if ((val & 0x000000ff) != 0x3) {
1938                 pci_save_state(pdev);
1939                 pci_disable_device(pdev);
1940                 pci_write_config_dword(pdev, ATH10K_PCI_PM_CONTROL,
1941                                        (val & 0xffffff00) | 0x03);
1942         }
1943
1944         return 0;
1945 }
1946
1947 static int ath10k_pci_hif_resume(struct ath10k *ar)
1948 {
1949         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1950         struct pci_dev *pdev = ar_pci->pdev;
1951         u32 val;
1952
1953         pci_read_config_dword(pdev, ATH10K_PCI_PM_CONTROL, &val);
1954
1955         if ((val & 0x000000ff) != 0) {
1956                 pci_restore_state(pdev);
1957                 pci_write_config_dword(pdev, ATH10K_PCI_PM_CONTROL,
1958                                        val & 0xffffff00);
1959                 /*
1960                  * Suspend/Resume resets the PCI configuration space,
1961                  * so we have to re-disable the RETRY_TIMEOUT register (0x41)
1962                  * to keep PCI Tx retries from interfering with C3 CPU state
1963                  */
1964                 pci_read_config_dword(pdev, 0x40, &val);
1965
1966                 if ((val & 0x0000ff00) != 0)
1967                         pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
1968         }
1969
1970         return 0;
1971 }
1972 #endif
1973
1974 static const struct ath10k_hif_ops ath10k_pci_hif_ops = {
1975         .tx_sg                  = ath10k_pci_hif_tx_sg,
1976         .diag_read              = ath10k_pci_hif_diag_read,
1977         .exchange_bmi_msg       = ath10k_pci_hif_exchange_bmi_msg,
1978         .start                  = ath10k_pci_hif_start,
1979         .stop                   = ath10k_pci_hif_stop,
1980         .map_service_to_pipe    = ath10k_pci_hif_map_service_to_pipe,
1981         .get_default_pipe       = ath10k_pci_hif_get_default_pipe,
1982         .send_complete_check    = ath10k_pci_hif_send_complete_check,
1983         .set_callbacks          = ath10k_pci_hif_set_callbacks,
1984         .get_free_queue_number  = ath10k_pci_hif_get_free_queue_number,
1985         .power_up               = ath10k_pci_hif_power_up,
1986         .power_down             = ath10k_pci_hif_power_down,
1987 #ifdef CONFIG_PM
1988         .suspend                = ath10k_pci_hif_suspend,
1989         .resume                 = ath10k_pci_hif_resume,
1990 #endif
1991 };
1992
1993 static void ath10k_pci_ce_tasklet(unsigned long ptr)
1994 {
1995         struct ath10k_pci_pipe *pipe = (struct ath10k_pci_pipe *)ptr;
1996         struct ath10k_pci *ar_pci = pipe->ar_pci;
1997
1998         ath10k_ce_per_engine_service(ar_pci->ar, pipe->pipe_num);
1999 }
2000
2001 static void ath10k_msi_err_tasklet(unsigned long data)
2002 {
2003         struct ath10k *ar = (struct ath10k *)data;
2004
2005         if (!ath10k_pci_has_fw_crashed(ar)) {
2006                 ath10k_warn(ar, "received unsolicited fw crash interrupt\n");
2007                 return;
2008         }
2009
2010         ath10k_pci_fw_crashed_clear(ar);
2011         ath10k_pci_fw_crashed_dump(ar);
2012 }
2013
2014 /*
2015  * Handler for a per-engine interrupt on a PARTICULAR CE.
2016  * This is used in cases where each CE has a private MSI interrupt.
2017  */
2018 static irqreturn_t ath10k_pci_per_engine_handler(int irq, void *arg)
2019 {
2020         struct ath10k *ar = arg;
2021         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2022         int ce_id = irq - ar_pci->pdev->irq - MSI_ASSIGN_CE_INITIAL;
2023
2024         if (ce_id < 0 || ce_id >= ARRAY_SIZE(ar_pci->pipe_info)) {
2025                 ath10k_warn(ar, "unexpected/invalid irq %d ce_id %d\n", irq,
2026                             ce_id);
2027                 return IRQ_HANDLED;
2028         }
2029
2030         /*
2031          * NOTE: We are able to derive ce_id from irq because we
2032          * use a one-to-one mapping for CE's 0..5.
2033          * CE's 6 & 7 do not use interrupts at all.
2034          *
2035          * This mapping must be kept in sync with the mapping
2036          * used by firmware.
2037          */
2038         tasklet_schedule(&ar_pci->pipe_info[ce_id].intr);
2039         return IRQ_HANDLED;
2040 }
2041
2042 static irqreturn_t ath10k_pci_msi_fw_handler(int irq, void *arg)
2043 {
2044         struct ath10k *ar = arg;
2045         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2046
2047         tasklet_schedule(&ar_pci->msi_fw_err);
2048         return IRQ_HANDLED;
2049 }
2050
2051 /*
2052  * Top-level interrupt handler for all PCI interrupts from a Target.
2053  * When a block of MSI interrupts is allocated, this top-level handler
2054  * is not used; instead, we directly call the correct sub-handler.
2055  */
2056 static irqreturn_t ath10k_pci_interrupt_handler(int irq, void *arg)
2057 {
2058         struct ath10k *ar = arg;
2059         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2060
2061         if (ar_pci->num_msi_intrs == 0) {
2062                 if (!ath10k_pci_irq_pending(ar))
2063                         return IRQ_NONE;
2064
2065                 ath10k_pci_disable_and_clear_legacy_irq(ar);
2066         }
2067
2068         tasklet_schedule(&ar_pci->intr_tq);
2069
2070         return IRQ_HANDLED;
2071 }
2072
2073 static void ath10k_pci_tasklet(unsigned long data)
2074 {
2075         struct ath10k *ar = (struct ath10k *)data;
2076         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2077
2078         if (ath10k_pci_has_fw_crashed(ar)) {
2079                 ath10k_pci_fw_crashed_clear(ar);
2080                 ath10k_pci_fw_crashed_dump(ar);
2081                 return;
2082         }
2083
2084         ath10k_ce_per_engine_service_any(ar);
2085
2086         /* Re-enable legacy irq that was disabled in the irq handler */
2087         if (ar_pci->num_msi_intrs == 0)
2088                 ath10k_pci_enable_legacy_irq(ar);
2089 }
2090
2091 static int ath10k_pci_request_irq_msix(struct ath10k *ar)
2092 {
2093         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2094         int ret, i;
2095
2096         ret = request_irq(ar_pci->pdev->irq + MSI_ASSIGN_FW,
2097                           ath10k_pci_msi_fw_handler,
2098                           IRQF_SHARED, "ath10k_pci", ar);
2099         if (ret) {
2100                 ath10k_warn(ar, "failed to request MSI-X fw irq %d: %d\n",
2101                             ar_pci->pdev->irq + MSI_ASSIGN_FW, ret);
2102                 return ret;
2103         }
2104
2105         for (i = MSI_ASSIGN_CE_INITIAL; i <= MSI_ASSIGN_CE_MAX; i++) {
2106                 ret = request_irq(ar_pci->pdev->irq + i,
2107                                   ath10k_pci_per_engine_handler,
2108                                   IRQF_SHARED, "ath10k_pci", ar);
2109                 if (ret) {
2110                         ath10k_warn(ar, "failed to request MSI-X ce irq %d: %d\n",
2111                                     ar_pci->pdev->irq + i, ret);
2112
2113                         for (i--; i >= MSI_ASSIGN_CE_INITIAL; i--)
2114                                 free_irq(ar_pci->pdev->irq + i, ar);
2115
2116                         free_irq(ar_pci->pdev->irq + MSI_ASSIGN_FW, ar);
2117                         return ret;
2118                 }
2119         }
2120
2121         return 0;
2122 }
2123
2124 static int ath10k_pci_request_irq_msi(struct ath10k *ar)
2125 {
2126         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2127         int ret;
2128
2129         ret = request_irq(ar_pci->pdev->irq,
2130                           ath10k_pci_interrupt_handler,
2131                           IRQF_SHARED, "ath10k_pci", ar);
2132         if (ret) {
2133                 ath10k_warn(ar, "failed to request MSI irq %d: %d\n",
2134                             ar_pci->pdev->irq, ret);
2135                 return ret;
2136         }
2137
2138         return 0;
2139 }
2140
2141 static int ath10k_pci_request_irq_legacy(struct ath10k *ar)
2142 {
2143         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2144         int ret;
2145
2146         ret = request_irq(ar_pci->pdev->irq,
2147                           ath10k_pci_interrupt_handler,
2148                           IRQF_SHARED, "ath10k_pci", ar);
2149         if (ret) {
2150                 ath10k_warn(ar, "failed to request legacy irq %d: %d\n",
2151                             ar_pci->pdev->irq, ret);
2152                 return ret;
2153         }
2154
2155         return 0;
2156 }
2157
2158 static int ath10k_pci_request_irq(struct ath10k *ar)
2159 {
2160         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2161
2162         switch (ar_pci->num_msi_intrs) {
2163         case 0:
2164                 return ath10k_pci_request_irq_legacy(ar);
2165         case 1:
2166                 return ath10k_pci_request_irq_msi(ar);
2167         case MSI_NUM_REQUEST:
2168                 return ath10k_pci_request_irq_msix(ar);
2169         }
2170
2171         ath10k_warn(ar, "unknown irq configuration upon request\n");
2172         return -EINVAL;
2173 }
2174
2175 static void ath10k_pci_free_irq(struct ath10k *ar)
2176 {
2177         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2178         int i;
2179
2180         /* There's at least one interrupt irregardless whether its legacy INTR
2181          * or MSI or MSI-X */
2182         for (i = 0; i < max(1, ar_pci->num_msi_intrs); i++)
2183                 free_irq(ar_pci->pdev->irq + i, ar);
2184 }
2185
2186 static void ath10k_pci_init_irq_tasklets(struct ath10k *ar)
2187 {
2188         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2189         int i;
2190
2191         tasklet_init(&ar_pci->intr_tq, ath10k_pci_tasklet, (unsigned long)ar);
2192         tasklet_init(&ar_pci->msi_fw_err, ath10k_msi_err_tasklet,
2193                      (unsigned long)ar);
2194
2195         for (i = 0; i < CE_COUNT; i++) {
2196                 ar_pci->pipe_info[i].ar_pci = ar_pci;
2197                 tasklet_init(&ar_pci->pipe_info[i].intr, ath10k_pci_ce_tasklet,
2198                              (unsigned long)&ar_pci->pipe_info[i]);
2199         }
2200 }
2201
2202 static int ath10k_pci_init_irq(struct ath10k *ar)
2203 {
2204         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2205         int ret;
2206
2207         ath10k_pci_init_irq_tasklets(ar);
2208
2209         if (ath10k_pci_irq_mode != ATH10K_PCI_IRQ_AUTO)
2210                 ath10k_info(ar, "limiting irq mode to: %d\n",
2211                             ath10k_pci_irq_mode);
2212
2213         /* Try MSI-X */
2214         if (ath10k_pci_irq_mode == ATH10K_PCI_IRQ_AUTO) {
2215                 ar_pci->num_msi_intrs = MSI_NUM_REQUEST;
2216                 ret = pci_enable_msi_range(ar_pci->pdev, ar_pci->num_msi_intrs,
2217                                            ar_pci->num_msi_intrs);
2218                 if (ret > 0)
2219                         return 0;
2220
2221                 /* fall-through */
2222         }
2223
2224         /* Try MSI */
2225         if (ath10k_pci_irq_mode != ATH10K_PCI_IRQ_LEGACY) {
2226                 ar_pci->num_msi_intrs = 1;
2227                 ret = pci_enable_msi(ar_pci->pdev);
2228                 if (ret == 0)
2229                         return 0;
2230
2231                 /* fall-through */
2232         }
2233
2234         /* Try legacy irq
2235          *
2236          * A potential race occurs here: The CORE_BASE write
2237          * depends on target correctly decoding AXI address but
2238          * host won't know when target writes BAR to CORE_CTRL.
2239          * This write might get lost if target has NOT written BAR.
2240          * For now, fix the race by repeating the write in below
2241          * synchronization checking. */
2242         ar_pci->num_msi_intrs = 0;
2243
2244         ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS + PCIE_INTR_ENABLE_ADDRESS,
2245                            PCIE_INTR_FIRMWARE_MASK | PCIE_INTR_CE_MASK_ALL);
2246
2247         return 0;
2248 }
2249
2250 static void ath10k_pci_deinit_irq_legacy(struct ath10k *ar)
2251 {
2252         ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS + PCIE_INTR_ENABLE_ADDRESS,
2253                            0);
2254 }
2255
2256 static int ath10k_pci_deinit_irq(struct ath10k *ar)
2257 {
2258         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2259
2260         switch (ar_pci->num_msi_intrs) {
2261         case 0:
2262                 ath10k_pci_deinit_irq_legacy(ar);
2263                 return 0;
2264         case 1:
2265                 /* fall-through */
2266         case MSI_NUM_REQUEST:
2267                 pci_disable_msi(ar_pci->pdev);
2268                 return 0;
2269         default:
2270                 pci_disable_msi(ar_pci->pdev);
2271         }
2272
2273         ath10k_warn(ar, "unknown irq configuration upon deinit\n");
2274         return -EINVAL;
2275 }
2276
2277 static int ath10k_pci_wait_for_target_init(struct ath10k *ar)
2278 {
2279         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2280         unsigned long timeout;
2281         u32 val;
2282
2283         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot waiting target to initialise\n");
2284
2285         timeout = jiffies + msecs_to_jiffies(ATH10K_PCI_TARGET_WAIT);
2286
2287         do {
2288                 val = ath10k_pci_read32(ar, FW_INDICATOR_ADDRESS);
2289
2290                 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot target indicator %x\n",
2291                            val);
2292
2293                 /* target should never return this */
2294                 if (val == 0xffffffff)
2295                         continue;
2296
2297                 /* the device has crashed so don't bother trying anymore */
2298                 if (val & FW_IND_EVENT_PENDING)
2299                         break;
2300
2301                 if (val & FW_IND_INITIALIZED)
2302                         break;
2303
2304                 if (ar_pci->num_msi_intrs == 0)
2305                         /* Fix potential race by repeating CORE_BASE writes */
2306                         ath10k_pci_enable_legacy_irq(ar);
2307
2308                 mdelay(10);
2309         } while (time_before(jiffies, timeout));
2310
2311         ath10k_pci_disable_and_clear_legacy_irq(ar);
2312         ath10k_pci_irq_msi_fw_mask(ar);
2313
2314         if (val == 0xffffffff) {
2315                 ath10k_err(ar, "failed to read device register, device is gone\n");
2316                 return -EIO;
2317         }
2318
2319         if (val & FW_IND_EVENT_PENDING) {
2320                 ath10k_warn(ar, "device has crashed during init\n");
2321                 ath10k_pci_fw_crashed_clear(ar);
2322                 ath10k_pci_fw_crashed_dump(ar);
2323                 return -ECOMM;
2324         }
2325
2326         if (!(val & FW_IND_INITIALIZED)) {
2327                 ath10k_err(ar, "failed to receive initialized event from target: %08x\n",
2328                            val);
2329                 return -ETIMEDOUT;
2330         }
2331
2332         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot target initialised\n");
2333         return 0;
2334 }
2335
2336 static int ath10k_pci_cold_reset(struct ath10k *ar)
2337 {
2338         int i;
2339         u32 val;
2340
2341         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot cold reset\n");
2342
2343         spin_lock_bh(&ar->data_lock);
2344
2345         ar->stats.fw_cold_reset_counter++;
2346
2347         spin_unlock_bh(&ar->data_lock);
2348
2349         /* Put Target, including PCIe, into RESET. */
2350         val = ath10k_pci_reg_read32(ar, SOC_GLOBAL_RESET_ADDRESS);
2351         val |= 1;
2352         ath10k_pci_reg_write32(ar, SOC_GLOBAL_RESET_ADDRESS, val);
2353
2354         for (i = 0; i < ATH_PCI_RESET_WAIT_MAX; i++) {
2355                 if (ath10k_pci_reg_read32(ar, RTC_STATE_ADDRESS) &
2356                                           RTC_STATE_COLD_RESET_MASK)
2357                         break;
2358                 msleep(1);
2359         }
2360
2361         /* Pull Target, including PCIe, out of RESET. */
2362         val &= ~1;
2363         ath10k_pci_reg_write32(ar, SOC_GLOBAL_RESET_ADDRESS, val);
2364
2365         for (i = 0; i < ATH_PCI_RESET_WAIT_MAX; i++) {
2366                 if (!(ath10k_pci_reg_read32(ar, RTC_STATE_ADDRESS) &
2367                                             RTC_STATE_COLD_RESET_MASK))
2368                         break;
2369                 msleep(1);
2370         }
2371
2372         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot cold reset complete\n");
2373
2374         return 0;
2375 }
2376
2377 static int ath10k_pci_claim(struct ath10k *ar)
2378 {
2379         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2380         struct pci_dev *pdev = ar_pci->pdev;
2381         u32 lcr_val;
2382         int ret;
2383
2384         pci_set_drvdata(pdev, ar);
2385
2386         ret = pci_enable_device(pdev);
2387         if (ret) {
2388                 ath10k_err(ar, "failed to enable pci device: %d\n", ret);
2389                 return ret;
2390         }
2391
2392         ret = pci_request_region(pdev, BAR_NUM, "ath");
2393         if (ret) {
2394                 ath10k_err(ar, "failed to request region BAR%d: %d\n", BAR_NUM,
2395                            ret);
2396                 goto err_device;
2397         }
2398
2399         /* Target expects 32 bit DMA. Enforce it. */
2400         ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2401         if (ret) {
2402                 ath10k_err(ar, "failed to set dma mask to 32-bit: %d\n", ret);
2403                 goto err_region;
2404         }
2405
2406         ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2407         if (ret) {
2408                 ath10k_err(ar, "failed to set consistent dma mask to 32-bit: %d\n",
2409                            ret);
2410                 goto err_region;
2411         }
2412
2413         pci_set_master(pdev);
2414
2415         /* Workaround: Disable ASPM */
2416         pci_read_config_dword(pdev, 0x80, &lcr_val);
2417         pci_write_config_dword(pdev, 0x80, (lcr_val & 0xffffff00));
2418
2419         /* Arrange for access to Target SoC registers. */
2420         ar_pci->mem = pci_iomap(pdev, BAR_NUM, 0);
2421         if (!ar_pci->mem) {
2422                 ath10k_err(ar, "failed to iomap BAR%d\n", BAR_NUM);
2423                 ret = -EIO;
2424                 goto err_master;
2425         }
2426
2427         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot pci_mem 0x%p\n", ar_pci->mem);
2428         return 0;
2429
2430 err_master:
2431         pci_clear_master(pdev);
2432
2433 err_region:
2434         pci_release_region(pdev, BAR_NUM);
2435
2436 err_device:
2437         pci_disable_device(pdev);
2438
2439         return ret;
2440 }
2441
2442 static void ath10k_pci_release(struct ath10k *ar)
2443 {
2444         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2445         struct pci_dev *pdev = ar_pci->pdev;
2446
2447         pci_iounmap(pdev, ar_pci->mem);
2448         pci_release_region(pdev, BAR_NUM);
2449         pci_clear_master(pdev);
2450         pci_disable_device(pdev);
2451 }
2452
2453 static int ath10k_pci_probe(struct pci_dev *pdev,
2454                             const struct pci_device_id *pci_dev)
2455 {
2456         int ret = 0;
2457         struct ath10k *ar;
2458         struct ath10k_pci *ar_pci;
2459         u32 chip_id;
2460
2461         ar = ath10k_core_create(sizeof(*ar_pci), &pdev->dev,
2462                                 ATH10K_BUS_PCI,
2463                                 &ath10k_pci_hif_ops);
2464         if (!ar) {
2465                 dev_err(&pdev->dev, "failed to allocate core\n");
2466                 return -ENOMEM;
2467         }
2468
2469         ath10k_dbg(ar, ATH10K_DBG_PCI, "pci probe\n");
2470
2471         ar_pci = ath10k_pci_priv(ar);
2472         ar_pci->pdev = pdev;
2473         ar_pci->dev = &pdev->dev;
2474         ar_pci->ar = ar;
2475
2476         spin_lock_init(&ar_pci->ce_lock);
2477         setup_timer(&ar_pci->rx_post_retry, ath10k_pci_rx_replenish_retry,
2478                     (unsigned long)ar);
2479
2480         ret = ath10k_pci_claim(ar);
2481         if (ret) {
2482                 ath10k_err(ar, "failed to claim device: %d\n", ret);
2483                 goto err_core_destroy;
2484         }
2485
2486         ret = ath10k_pci_wake(ar);
2487         if (ret) {
2488                 ath10k_err(ar, "failed to wake up: %d\n", ret);
2489                 goto err_release;
2490         }
2491
2492         chip_id = ath10k_pci_soc_read32(ar, SOC_CHIP_ID_ADDRESS);
2493         if (chip_id == 0xffffffff) {
2494                 ath10k_err(ar, "failed to get chip id\n");
2495                 goto err_sleep;
2496         }
2497
2498         ret = ath10k_pci_alloc_pipes(ar);
2499         if (ret) {
2500                 ath10k_err(ar, "failed to allocate copy engine pipes: %d\n",
2501                            ret);
2502                 goto err_sleep;
2503         }
2504
2505         ath10k_pci_ce_deinit(ar);
2506         ath10k_pci_irq_disable(ar);
2507
2508         ret = ath10k_pci_init_irq(ar);
2509         if (ret) {
2510                 ath10k_err(ar, "failed to init irqs: %d\n", ret);
2511                 goto err_free_pipes;
2512         }
2513
2514         ath10k_info(ar, "pci irq %s interrupts %d irq_mode %d reset_mode %d\n",
2515                     ath10k_pci_get_irq_method(ar), ar_pci->num_msi_intrs,
2516                     ath10k_pci_irq_mode, ath10k_pci_reset_mode);
2517
2518         ret = ath10k_pci_request_irq(ar);
2519         if (ret) {
2520                 ath10k_warn(ar, "failed to request irqs: %d\n", ret);
2521                 goto err_deinit_irq;
2522         }
2523
2524         ret = ath10k_core_register(ar, chip_id);
2525         if (ret) {
2526                 ath10k_err(ar, "failed to register driver core: %d\n", ret);
2527                 goto err_free_irq;
2528         }
2529
2530         return 0;
2531
2532 err_free_irq:
2533         ath10k_pci_free_irq(ar);
2534         ath10k_pci_kill_tasklet(ar);
2535
2536 err_deinit_irq:
2537         ath10k_pci_deinit_irq(ar);
2538
2539 err_free_pipes:
2540         ath10k_pci_free_pipes(ar);
2541
2542 err_sleep:
2543         ath10k_pci_sleep(ar);
2544
2545 err_release:
2546         ath10k_pci_release(ar);
2547
2548 err_core_destroy:
2549         ath10k_core_destroy(ar);
2550
2551         return ret;
2552 }
2553
2554 static void ath10k_pci_remove(struct pci_dev *pdev)
2555 {
2556         struct ath10k *ar = pci_get_drvdata(pdev);
2557         struct ath10k_pci *ar_pci;
2558
2559         ath10k_dbg(ar, ATH10K_DBG_PCI, "pci remove\n");
2560
2561         if (!ar)
2562                 return;
2563
2564         ar_pci = ath10k_pci_priv(ar);
2565
2566         if (!ar_pci)
2567                 return;
2568
2569         ath10k_core_unregister(ar);
2570         ath10k_pci_free_irq(ar);
2571         ath10k_pci_kill_tasklet(ar);
2572         ath10k_pci_deinit_irq(ar);
2573         ath10k_pci_ce_deinit(ar);
2574         ath10k_pci_free_pipes(ar);
2575         ath10k_pci_sleep(ar);
2576         ath10k_pci_release(ar);
2577         ath10k_core_destroy(ar);
2578 }
2579
2580 MODULE_DEVICE_TABLE(pci, ath10k_pci_id_table);
2581
2582 static struct pci_driver ath10k_pci_driver = {
2583         .name = "ath10k_pci",
2584         .id_table = ath10k_pci_id_table,
2585         .probe = ath10k_pci_probe,
2586         .remove = ath10k_pci_remove,
2587 };
2588
2589 static int __init ath10k_pci_init(void)
2590 {
2591         int ret;
2592
2593         ret = pci_register_driver(&ath10k_pci_driver);
2594         if (ret)
2595                 printk(KERN_ERR "failed to register ath10k pci driver: %d\n",
2596                        ret);
2597
2598         return ret;
2599 }
2600 module_init(ath10k_pci_init);
2601
2602 static void __exit ath10k_pci_exit(void)
2603 {
2604         pci_unregister_driver(&ath10k_pci_driver);
2605 }
2606
2607 module_exit(ath10k_pci_exit);
2608
2609 MODULE_AUTHOR("Qualcomm Atheros");
2610 MODULE_DESCRIPTION("Driver support for Atheros QCA988X PCIe devices");
2611 MODULE_LICENSE("Dual BSD/GPL");
2612 MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" QCA988X_HW_2_0_FW_FILE);
2613 MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" ATH10K_FW_API2_FILE);
2614 MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" ATH10K_FW_API3_FILE);
2615 MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" QCA988X_HW_2_0_BOARD_DATA_FILE);