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 (WARN_ON_ONCE(!xfer))
1446                 return;
1447
1448         if (!xfer->wait_for_resp) {
1449                 ath10k_warn(ar, "unexpected: BMI data received; ignoring\n");
1450                 return;
1451         }
1452
1453         xfer->resp_len = nbytes;
1454         xfer->rx_done = true;
1455 }
1456
1457 static int ath10k_pci_bmi_wait(struct ath10k_ce_pipe *tx_pipe,
1458                                struct ath10k_ce_pipe *rx_pipe,
1459                                struct bmi_xfer *xfer)
1460 {
1461         unsigned long timeout = jiffies + BMI_COMMUNICATION_TIMEOUT_HZ;
1462
1463         while (time_before_eq(jiffies, timeout)) {
1464                 ath10k_pci_bmi_send_done(tx_pipe);
1465                 ath10k_pci_bmi_recv_data(rx_pipe);
1466
1467                 if (xfer->tx_done && (xfer->rx_done == xfer->wait_for_resp))
1468                         return 0;
1469
1470                 schedule();
1471         }
1472
1473         return -ETIMEDOUT;
1474 }
1475
1476 /*
1477  * Send an interrupt to the device to wake up the Target CPU
1478  * so it has an opportunity to notice any changed state.
1479  */
1480 static int ath10k_pci_wake_target_cpu(struct ath10k *ar)
1481 {
1482         u32 addr, val;
1483
1484         addr = SOC_CORE_BASE_ADDRESS | CORE_CTRL_ADDRESS;
1485         val = ath10k_pci_read32(ar, addr);
1486         val |= CORE_CTRL_CPU_INTR_MASK;
1487         ath10k_pci_write32(ar, addr, val);
1488
1489         return 0;
1490 }
1491
1492 static int ath10k_pci_init_config(struct ath10k *ar)
1493 {
1494         u32 interconnect_targ_addr;
1495         u32 pcie_state_targ_addr = 0;
1496         u32 pipe_cfg_targ_addr = 0;
1497         u32 svc_to_pipe_map = 0;
1498         u32 pcie_config_flags = 0;
1499         u32 ealloc_value;
1500         u32 ealloc_targ_addr;
1501         u32 flag2_value;
1502         u32 flag2_targ_addr;
1503         int ret = 0;
1504
1505         /* Download to Target the CE Config and the service-to-CE map */
1506         interconnect_targ_addr =
1507                 host_interest_item_address(HI_ITEM(hi_interconnect_state));
1508
1509         /* Supply Target-side CE configuration */
1510         ret = ath10k_pci_diag_read32(ar, interconnect_targ_addr,
1511                                      &pcie_state_targ_addr);
1512         if (ret != 0) {
1513                 ath10k_err(ar, "Failed to get pcie state addr: %d\n", ret);
1514                 return ret;
1515         }
1516
1517         if (pcie_state_targ_addr == 0) {
1518                 ret = -EIO;
1519                 ath10k_err(ar, "Invalid pcie state addr\n");
1520                 return ret;
1521         }
1522
1523         ret = ath10k_pci_diag_read32(ar, (pcie_state_targ_addr +
1524                                           offsetof(struct pcie_state,
1525                                                    pipe_cfg_addr)),
1526                                      &pipe_cfg_targ_addr);
1527         if (ret != 0) {
1528                 ath10k_err(ar, "Failed to get pipe cfg addr: %d\n", ret);
1529                 return ret;
1530         }
1531
1532         if (pipe_cfg_targ_addr == 0) {
1533                 ret = -EIO;
1534                 ath10k_err(ar, "Invalid pipe cfg addr\n");
1535                 return ret;
1536         }
1537
1538         ret = ath10k_pci_diag_write_mem(ar, pipe_cfg_targ_addr,
1539                                         target_ce_config_wlan,
1540                                         sizeof(target_ce_config_wlan));
1541
1542         if (ret != 0) {
1543                 ath10k_err(ar, "Failed to write pipe cfg: %d\n", ret);
1544                 return ret;
1545         }
1546
1547         ret = ath10k_pci_diag_read32(ar, (pcie_state_targ_addr +
1548                                           offsetof(struct pcie_state,
1549                                                    svc_to_pipe_map)),
1550                                      &svc_to_pipe_map);
1551         if (ret != 0) {
1552                 ath10k_err(ar, "Failed to get svc/pipe map: %d\n", ret);
1553                 return ret;
1554         }
1555
1556         if (svc_to_pipe_map == 0) {
1557                 ret = -EIO;
1558                 ath10k_err(ar, "Invalid svc_to_pipe map\n");
1559                 return ret;
1560         }
1561
1562         ret = ath10k_pci_diag_write_mem(ar, svc_to_pipe_map,
1563                                         target_service_to_ce_map_wlan,
1564                                         sizeof(target_service_to_ce_map_wlan));
1565         if (ret != 0) {
1566                 ath10k_err(ar, "Failed to write svc/pipe map: %d\n", ret);
1567                 return ret;
1568         }
1569
1570         ret = ath10k_pci_diag_read32(ar, (pcie_state_targ_addr +
1571                                           offsetof(struct pcie_state,
1572                                                    config_flags)),
1573                                      &pcie_config_flags);
1574         if (ret != 0) {
1575                 ath10k_err(ar, "Failed to get pcie config_flags: %d\n", ret);
1576                 return ret;
1577         }
1578
1579         pcie_config_flags &= ~PCIE_CONFIG_FLAG_ENABLE_L1;
1580
1581         ret = ath10k_pci_diag_write32(ar, (pcie_state_targ_addr +
1582                                            offsetof(struct pcie_state,
1583                                                     config_flags)),
1584                                       pcie_config_flags);
1585         if (ret != 0) {
1586                 ath10k_err(ar, "Failed to write pcie config_flags: %d\n", ret);
1587                 return ret;
1588         }
1589
1590         /* configure early allocation */
1591         ealloc_targ_addr = host_interest_item_address(HI_ITEM(hi_early_alloc));
1592
1593         ret = ath10k_pci_diag_read32(ar, ealloc_targ_addr, &ealloc_value);
1594         if (ret != 0) {
1595                 ath10k_err(ar, "Faile to get early alloc val: %d\n", ret);
1596                 return ret;
1597         }
1598
1599         /* first bank is switched to IRAM */
1600         ealloc_value |= ((HI_EARLY_ALLOC_MAGIC << HI_EARLY_ALLOC_MAGIC_SHIFT) &
1601                          HI_EARLY_ALLOC_MAGIC_MASK);
1602         ealloc_value |= ((1 << HI_EARLY_ALLOC_IRAM_BANKS_SHIFT) &
1603                          HI_EARLY_ALLOC_IRAM_BANKS_MASK);
1604
1605         ret = ath10k_pci_diag_write32(ar, ealloc_targ_addr, ealloc_value);
1606         if (ret != 0) {
1607                 ath10k_err(ar, "Failed to set early alloc val: %d\n", ret);
1608                 return ret;
1609         }
1610
1611         /* Tell Target to proceed with initialization */
1612         flag2_targ_addr = host_interest_item_address(HI_ITEM(hi_option_flag2));
1613
1614         ret = ath10k_pci_diag_read32(ar, flag2_targ_addr, &flag2_value);
1615         if (ret != 0) {
1616                 ath10k_err(ar, "Failed to get option val: %d\n", ret);
1617                 return ret;
1618         }
1619
1620         flag2_value |= HI_OPTION_EARLY_CFG_DONE;
1621
1622         ret = ath10k_pci_diag_write32(ar, flag2_targ_addr, flag2_value);
1623         if (ret != 0) {
1624                 ath10k_err(ar, "Failed to set option val: %d\n", ret);
1625                 return ret;
1626         }
1627
1628         return 0;
1629 }
1630
1631 static int ath10k_pci_alloc_pipes(struct ath10k *ar)
1632 {
1633         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1634         struct ath10k_pci_pipe *pipe;
1635         int i, ret;
1636
1637         for (i = 0; i < CE_COUNT; i++) {
1638                 pipe = &ar_pci->pipe_info[i];
1639                 pipe->ce_hdl = &ar_pci->ce_states[i];
1640                 pipe->pipe_num = i;
1641                 pipe->hif_ce_state = ar;
1642
1643                 ret = ath10k_ce_alloc_pipe(ar, i, &host_ce_config_wlan[i],
1644                                            ath10k_pci_ce_send_done,
1645                                            ath10k_pci_ce_recv_data);
1646                 if (ret) {
1647                         ath10k_err(ar, "failed to allocate copy engine pipe %d: %d\n",
1648                                    i, ret);
1649                         return ret;
1650                 }
1651
1652                 /* Last CE is Diagnostic Window */
1653                 if (i == CE_COUNT - 1) {
1654                         ar_pci->ce_diag = pipe->ce_hdl;
1655                         continue;
1656                 }
1657
1658                 pipe->buf_sz = (size_t)(host_ce_config_wlan[i].src_sz_max);
1659         }
1660
1661         return 0;
1662 }
1663
1664 static void ath10k_pci_free_pipes(struct ath10k *ar)
1665 {
1666         int i;
1667
1668         for (i = 0; i < CE_COUNT; i++)
1669                 ath10k_ce_free_pipe(ar, i);
1670 }
1671
1672 static int ath10k_pci_init_pipes(struct ath10k *ar)
1673 {
1674         int i, ret;
1675
1676         for (i = 0; i < CE_COUNT; i++) {
1677                 ret = ath10k_ce_init_pipe(ar, i, &host_ce_config_wlan[i]);
1678                 if (ret) {
1679                         ath10k_err(ar, "failed to initialize copy engine pipe %d: %d\n",
1680                                    i, ret);
1681                         return ret;
1682                 }
1683         }
1684
1685         return 0;
1686 }
1687
1688 static bool ath10k_pci_has_fw_crashed(struct ath10k *ar)
1689 {
1690         return ath10k_pci_read32(ar, FW_INDICATOR_ADDRESS) &
1691                FW_IND_EVENT_PENDING;
1692 }
1693
1694 static void ath10k_pci_fw_crashed_clear(struct ath10k *ar)
1695 {
1696         u32 val;
1697
1698         val = ath10k_pci_read32(ar, FW_INDICATOR_ADDRESS);
1699         val &= ~FW_IND_EVENT_PENDING;
1700         ath10k_pci_write32(ar, FW_INDICATOR_ADDRESS, val);
1701 }
1702
1703 /* this function effectively clears target memory controller assert line */
1704 static void ath10k_pci_warm_reset_si0(struct ath10k *ar)
1705 {
1706         u32 val;
1707
1708         val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
1709         ath10k_pci_soc_write32(ar, SOC_RESET_CONTROL_ADDRESS,
1710                                val | SOC_RESET_CONTROL_SI0_RST_MASK);
1711         val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
1712
1713         msleep(10);
1714
1715         val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
1716         ath10k_pci_soc_write32(ar, SOC_RESET_CONTROL_ADDRESS,
1717                                val & ~SOC_RESET_CONTROL_SI0_RST_MASK);
1718         val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
1719
1720         msleep(10);
1721 }
1722
1723 static void ath10k_pci_warm_reset_cpu(struct ath10k *ar)
1724 {
1725         u32 val;
1726
1727         ath10k_pci_write32(ar, FW_INDICATOR_ADDRESS, 0);
1728
1729         val = ath10k_pci_read32(ar, RTC_SOC_BASE_ADDRESS +
1730                                 SOC_RESET_CONTROL_ADDRESS);
1731         ath10k_pci_write32(ar, RTC_SOC_BASE_ADDRESS + SOC_RESET_CONTROL_ADDRESS,
1732                            val | SOC_RESET_CONTROL_CPU_WARM_RST_MASK);
1733 }
1734
1735 static void ath10k_pci_warm_reset_ce(struct ath10k *ar)
1736 {
1737         u32 val;
1738
1739         val = ath10k_pci_read32(ar, RTC_SOC_BASE_ADDRESS +
1740                                 SOC_RESET_CONTROL_ADDRESS);
1741
1742         ath10k_pci_write32(ar, RTC_SOC_BASE_ADDRESS + SOC_RESET_CONTROL_ADDRESS,
1743                            val | SOC_RESET_CONTROL_CE_RST_MASK);
1744         msleep(10);
1745         ath10k_pci_write32(ar, RTC_SOC_BASE_ADDRESS + SOC_RESET_CONTROL_ADDRESS,
1746                            val & ~SOC_RESET_CONTROL_CE_RST_MASK);
1747 }
1748
1749 static void ath10k_pci_warm_reset_clear_lf(struct ath10k *ar)
1750 {
1751         u32 val;
1752
1753         val = ath10k_pci_read32(ar, RTC_SOC_BASE_ADDRESS +
1754                                 SOC_LF_TIMER_CONTROL0_ADDRESS);
1755         ath10k_pci_write32(ar, RTC_SOC_BASE_ADDRESS +
1756                            SOC_LF_TIMER_CONTROL0_ADDRESS,
1757                            val & ~SOC_LF_TIMER_CONTROL0_ENABLE_MASK);
1758 }
1759
1760 static int ath10k_pci_warm_reset(struct ath10k *ar)
1761 {
1762         int ret;
1763
1764         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot warm reset\n");
1765
1766         spin_lock_bh(&ar->data_lock);
1767         ar->stats.fw_warm_reset_counter++;
1768         spin_unlock_bh(&ar->data_lock);
1769
1770         ath10k_pci_irq_disable(ar);
1771
1772         /* Make sure the target CPU is not doing anything dangerous, e.g. if it
1773          * were to access copy engine while host performs copy engine reset
1774          * then it is possible for the device to confuse pci-e controller to
1775          * the point of bringing host system to a complete stop (i.e. hang).
1776          */
1777         ath10k_pci_warm_reset_si0(ar);
1778         ath10k_pci_warm_reset_cpu(ar);
1779         ath10k_pci_init_pipes(ar);
1780         ath10k_pci_wait_for_target_init(ar);
1781
1782         ath10k_pci_warm_reset_clear_lf(ar);
1783         ath10k_pci_warm_reset_ce(ar);
1784         ath10k_pci_warm_reset_cpu(ar);
1785         ath10k_pci_init_pipes(ar);
1786
1787         ret = ath10k_pci_wait_for_target_init(ar);
1788         if (ret) {
1789                 ath10k_warn(ar, "failed to wait for target init: %d\n", ret);
1790                 return ret;
1791         }
1792
1793         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot warm reset complete\n");
1794
1795         return 0;
1796 }
1797
1798 static int ath10k_pci_chip_reset(struct ath10k *ar)
1799 {
1800         int i, ret;
1801         u32 val;
1802
1803         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot chip reset\n");
1804
1805         /* Some hardware revisions (e.g. CUS223v2) has issues with cold reset.
1806          * It is thus preferred to use warm reset which is safer but may not be
1807          * able to recover the device from all possible fail scenarios.
1808          *
1809          * Warm reset doesn't always work on first try so attempt it a few
1810          * times before giving up.
1811          */
1812         for (i = 0; i < ATH10K_PCI_NUM_WARM_RESET_ATTEMPTS; i++) {
1813                 ret = ath10k_pci_warm_reset(ar);
1814                 if (ret) {
1815                         ath10k_warn(ar, "failed to warm reset attempt %d of %d: %d\n",
1816                                     i + 1, ATH10K_PCI_NUM_WARM_RESET_ATTEMPTS,
1817                                     ret);
1818                         continue;
1819                 }
1820
1821                 /* FIXME: Sometimes copy engine doesn't recover after warm
1822                  * reset. In most cases this needs cold reset. In some of these
1823                  * cases the device is in such a state that a cold reset may
1824                  * lock up the host.
1825                  *
1826                  * Reading any host interest register via copy engine is
1827                  * sufficient to verify if device is capable of booting
1828                  * firmware blob.
1829                  */
1830                 ret = ath10k_pci_init_pipes(ar);
1831                 if (ret) {
1832                         ath10k_warn(ar, "failed to init copy engine: %d\n",
1833                                     ret);
1834                         continue;
1835                 }
1836
1837                 ret = ath10k_pci_diag_read32(ar, QCA988X_HOST_INTEREST_ADDRESS,
1838                                              &val);
1839                 if (ret) {
1840                         ath10k_warn(ar, "failed to poke copy engine: %d\n",
1841                                     ret);
1842                         continue;
1843                 }
1844
1845                 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot chip reset complete (warm)\n");
1846                 return 0;
1847         }
1848
1849         if (ath10k_pci_reset_mode == ATH10K_PCI_RESET_WARM_ONLY) {
1850                 ath10k_warn(ar, "refusing cold reset as requested\n");
1851                 return -EPERM;
1852         }
1853
1854         ret = ath10k_pci_cold_reset(ar);
1855         if (ret) {
1856                 ath10k_warn(ar, "failed to cold reset: %d\n", ret);
1857                 return ret;
1858         }
1859
1860         ret = ath10k_pci_wait_for_target_init(ar);
1861         if (ret) {
1862                 ath10k_warn(ar, "failed to wait for target after cold reset: %d\n",
1863                             ret);
1864                 return ret;
1865         }
1866
1867         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot chip reset complete (cold)\n");
1868
1869         return 0;
1870 }
1871
1872 static int ath10k_pci_hif_power_up(struct ath10k *ar)
1873 {
1874         int ret;
1875
1876         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot hif power up\n");
1877
1878         ret = ath10k_pci_wake(ar);
1879         if (ret) {
1880                 ath10k_err(ar, "failed to wake up target: %d\n", ret);
1881                 return ret;
1882         }
1883
1884         /*
1885          * Bring the target up cleanly.
1886          *
1887          * The target may be in an undefined state with an AUX-powered Target
1888          * and a Host in WoW mode. If the Host crashes, loses power, or is
1889          * restarted (without unloading the driver) then the Target is left
1890          * (aux) powered and running. On a subsequent driver load, the Target
1891          * is in an unexpected state. We try to catch that here in order to
1892          * reset the Target and retry the probe.
1893          */
1894         ret = ath10k_pci_chip_reset(ar);
1895         if (ret) {
1896                 ath10k_err(ar, "failed to reset chip: %d\n", ret);
1897                 goto err_sleep;
1898         }
1899
1900         ret = ath10k_pci_init_pipes(ar);
1901         if (ret) {
1902                 ath10k_err(ar, "failed to initialize CE: %d\n", ret);
1903                 goto err_sleep;
1904         }
1905
1906         ret = ath10k_pci_init_config(ar);
1907         if (ret) {
1908                 ath10k_err(ar, "failed to setup init config: %d\n", ret);
1909                 goto err_ce;
1910         }
1911
1912         ret = ath10k_pci_wake_target_cpu(ar);
1913         if (ret) {
1914                 ath10k_err(ar, "could not wake up target CPU: %d\n", ret);
1915                 goto err_ce;
1916         }
1917
1918         return 0;
1919
1920 err_ce:
1921         ath10k_pci_ce_deinit(ar);
1922
1923 err_sleep:
1924         ath10k_pci_sleep(ar);
1925         return ret;
1926 }
1927
1928 static void ath10k_pci_hif_power_down(struct ath10k *ar)
1929 {
1930         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot hif power down\n");
1931
1932         /* Currently hif_power_up performs effectively a reset and hif_stop
1933          * resets the chip as well so there's no point in resetting here.
1934          */
1935
1936         ath10k_pci_sleep(ar);
1937 }
1938
1939 #ifdef CONFIG_PM
1940
1941 #define ATH10K_PCI_PM_CONTROL 0x44
1942
1943 static int ath10k_pci_hif_suspend(struct ath10k *ar)
1944 {
1945         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1946         struct pci_dev *pdev = ar_pci->pdev;
1947         u32 val;
1948
1949         pci_read_config_dword(pdev, ATH10K_PCI_PM_CONTROL, &val);
1950
1951         if ((val & 0x000000ff) != 0x3) {
1952                 pci_save_state(pdev);
1953                 pci_disable_device(pdev);
1954                 pci_write_config_dword(pdev, ATH10K_PCI_PM_CONTROL,
1955                                        (val & 0xffffff00) | 0x03);
1956         }
1957
1958         return 0;
1959 }
1960
1961 static int ath10k_pci_hif_resume(struct ath10k *ar)
1962 {
1963         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1964         struct pci_dev *pdev = ar_pci->pdev;
1965         u32 val;
1966
1967         pci_read_config_dword(pdev, ATH10K_PCI_PM_CONTROL, &val);
1968
1969         if ((val & 0x000000ff) != 0) {
1970                 pci_restore_state(pdev);
1971                 pci_write_config_dword(pdev, ATH10K_PCI_PM_CONTROL,
1972                                        val & 0xffffff00);
1973                 /*
1974                  * Suspend/Resume resets the PCI configuration space,
1975                  * so we have to re-disable the RETRY_TIMEOUT register (0x41)
1976                  * to keep PCI Tx retries from interfering with C3 CPU state
1977                  */
1978                 pci_read_config_dword(pdev, 0x40, &val);
1979
1980                 if ((val & 0x0000ff00) != 0)
1981                         pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
1982         }
1983
1984         return 0;
1985 }
1986 #endif
1987
1988 static const struct ath10k_hif_ops ath10k_pci_hif_ops = {
1989         .tx_sg                  = ath10k_pci_hif_tx_sg,
1990         .diag_read              = ath10k_pci_hif_diag_read,
1991         .exchange_bmi_msg       = ath10k_pci_hif_exchange_bmi_msg,
1992         .start                  = ath10k_pci_hif_start,
1993         .stop                   = ath10k_pci_hif_stop,
1994         .map_service_to_pipe    = ath10k_pci_hif_map_service_to_pipe,
1995         .get_default_pipe       = ath10k_pci_hif_get_default_pipe,
1996         .send_complete_check    = ath10k_pci_hif_send_complete_check,
1997         .set_callbacks          = ath10k_pci_hif_set_callbacks,
1998         .get_free_queue_number  = ath10k_pci_hif_get_free_queue_number,
1999         .power_up               = ath10k_pci_hif_power_up,
2000         .power_down             = ath10k_pci_hif_power_down,
2001         .read32                 = ath10k_pci_read32,
2002         .write32                = ath10k_pci_write32,
2003 #ifdef CONFIG_PM
2004         .suspend                = ath10k_pci_hif_suspend,
2005         .resume                 = ath10k_pci_hif_resume,
2006 #endif
2007 };
2008
2009 static void ath10k_pci_ce_tasklet(unsigned long ptr)
2010 {
2011         struct ath10k_pci_pipe *pipe = (struct ath10k_pci_pipe *)ptr;
2012         struct ath10k_pci *ar_pci = pipe->ar_pci;
2013
2014         ath10k_ce_per_engine_service(ar_pci->ar, pipe->pipe_num);
2015 }
2016
2017 static void ath10k_msi_err_tasklet(unsigned long data)
2018 {
2019         struct ath10k *ar = (struct ath10k *)data;
2020
2021         if (!ath10k_pci_has_fw_crashed(ar)) {
2022                 ath10k_warn(ar, "received unsolicited fw crash interrupt\n");
2023                 return;
2024         }
2025
2026         ath10k_pci_fw_crashed_clear(ar);
2027         ath10k_pci_fw_crashed_dump(ar);
2028 }
2029
2030 /*
2031  * Handler for a per-engine interrupt on a PARTICULAR CE.
2032  * This is used in cases where each CE has a private MSI interrupt.
2033  */
2034 static irqreturn_t ath10k_pci_per_engine_handler(int irq, void *arg)
2035 {
2036         struct ath10k *ar = arg;
2037         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2038         int ce_id = irq - ar_pci->pdev->irq - MSI_ASSIGN_CE_INITIAL;
2039
2040         if (ce_id < 0 || ce_id >= ARRAY_SIZE(ar_pci->pipe_info)) {
2041                 ath10k_warn(ar, "unexpected/invalid irq %d ce_id %d\n", irq,
2042                             ce_id);
2043                 return IRQ_HANDLED;
2044         }
2045
2046         /*
2047          * NOTE: We are able to derive ce_id from irq because we
2048          * use a one-to-one mapping for CE's 0..5.
2049          * CE's 6 & 7 do not use interrupts at all.
2050          *
2051          * This mapping must be kept in sync with the mapping
2052          * used by firmware.
2053          */
2054         tasklet_schedule(&ar_pci->pipe_info[ce_id].intr);
2055         return IRQ_HANDLED;
2056 }
2057
2058 static irqreturn_t ath10k_pci_msi_fw_handler(int irq, void *arg)
2059 {
2060         struct ath10k *ar = arg;
2061         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2062
2063         tasklet_schedule(&ar_pci->msi_fw_err);
2064         return IRQ_HANDLED;
2065 }
2066
2067 /*
2068  * Top-level interrupt handler for all PCI interrupts from a Target.
2069  * When a block of MSI interrupts is allocated, this top-level handler
2070  * is not used; instead, we directly call the correct sub-handler.
2071  */
2072 static irqreturn_t ath10k_pci_interrupt_handler(int irq, void *arg)
2073 {
2074         struct ath10k *ar = arg;
2075         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2076
2077         if (ar_pci->num_msi_intrs == 0) {
2078                 if (!ath10k_pci_irq_pending(ar))
2079                         return IRQ_NONE;
2080
2081                 ath10k_pci_disable_and_clear_legacy_irq(ar);
2082         }
2083
2084         tasklet_schedule(&ar_pci->intr_tq);
2085
2086         return IRQ_HANDLED;
2087 }
2088
2089 static void ath10k_pci_tasklet(unsigned long data)
2090 {
2091         struct ath10k *ar = (struct ath10k *)data;
2092         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2093
2094         if (ath10k_pci_has_fw_crashed(ar)) {
2095                 ath10k_pci_fw_crashed_clear(ar);
2096                 ath10k_pci_fw_crashed_dump(ar);
2097                 return;
2098         }
2099
2100         ath10k_ce_per_engine_service_any(ar);
2101
2102         /* Re-enable legacy irq that was disabled in the irq handler */
2103         if (ar_pci->num_msi_intrs == 0)
2104                 ath10k_pci_enable_legacy_irq(ar);
2105 }
2106
2107 static int ath10k_pci_request_irq_msix(struct ath10k *ar)
2108 {
2109         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2110         int ret, i;
2111
2112         ret = request_irq(ar_pci->pdev->irq + MSI_ASSIGN_FW,
2113                           ath10k_pci_msi_fw_handler,
2114                           IRQF_SHARED, "ath10k_pci", ar);
2115         if (ret) {
2116                 ath10k_warn(ar, "failed to request MSI-X fw irq %d: %d\n",
2117                             ar_pci->pdev->irq + MSI_ASSIGN_FW, ret);
2118                 return ret;
2119         }
2120
2121         for (i = MSI_ASSIGN_CE_INITIAL; i <= MSI_ASSIGN_CE_MAX; i++) {
2122                 ret = request_irq(ar_pci->pdev->irq + i,
2123                                   ath10k_pci_per_engine_handler,
2124                                   IRQF_SHARED, "ath10k_pci", ar);
2125                 if (ret) {
2126                         ath10k_warn(ar, "failed to request MSI-X ce irq %d: %d\n",
2127                                     ar_pci->pdev->irq + i, ret);
2128
2129                         for (i--; i >= MSI_ASSIGN_CE_INITIAL; i--)
2130                                 free_irq(ar_pci->pdev->irq + i, ar);
2131
2132                         free_irq(ar_pci->pdev->irq + MSI_ASSIGN_FW, ar);
2133                         return ret;
2134                 }
2135         }
2136
2137         return 0;
2138 }
2139
2140 static int ath10k_pci_request_irq_msi(struct ath10k *ar)
2141 {
2142         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2143         int ret;
2144
2145         ret = request_irq(ar_pci->pdev->irq,
2146                           ath10k_pci_interrupt_handler,
2147                           IRQF_SHARED, "ath10k_pci", ar);
2148         if (ret) {
2149                 ath10k_warn(ar, "failed to request MSI irq %d: %d\n",
2150                             ar_pci->pdev->irq, ret);
2151                 return ret;
2152         }
2153
2154         return 0;
2155 }
2156
2157 static int ath10k_pci_request_irq_legacy(struct ath10k *ar)
2158 {
2159         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2160         int ret;
2161
2162         ret = request_irq(ar_pci->pdev->irq,
2163                           ath10k_pci_interrupt_handler,
2164                           IRQF_SHARED, "ath10k_pci", ar);
2165         if (ret) {
2166                 ath10k_warn(ar, "failed to request legacy irq %d: %d\n",
2167                             ar_pci->pdev->irq, ret);
2168                 return ret;
2169         }
2170
2171         return 0;
2172 }
2173
2174 static int ath10k_pci_request_irq(struct ath10k *ar)
2175 {
2176         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2177
2178         switch (ar_pci->num_msi_intrs) {
2179         case 0:
2180                 return ath10k_pci_request_irq_legacy(ar);
2181         case 1:
2182                 return ath10k_pci_request_irq_msi(ar);
2183         case MSI_NUM_REQUEST:
2184                 return ath10k_pci_request_irq_msix(ar);
2185         }
2186
2187         ath10k_warn(ar, "unknown irq configuration upon request\n");
2188         return -EINVAL;
2189 }
2190
2191 static void ath10k_pci_free_irq(struct ath10k *ar)
2192 {
2193         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2194         int i;
2195
2196         /* There's at least one interrupt irregardless whether its legacy INTR
2197          * or MSI or MSI-X */
2198         for (i = 0; i < max(1, ar_pci->num_msi_intrs); i++)
2199                 free_irq(ar_pci->pdev->irq + i, ar);
2200 }
2201
2202 static void ath10k_pci_init_irq_tasklets(struct ath10k *ar)
2203 {
2204         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2205         int i;
2206
2207         tasklet_init(&ar_pci->intr_tq, ath10k_pci_tasklet, (unsigned long)ar);
2208         tasklet_init(&ar_pci->msi_fw_err, ath10k_msi_err_tasklet,
2209                      (unsigned long)ar);
2210
2211         for (i = 0; i < CE_COUNT; i++) {
2212                 ar_pci->pipe_info[i].ar_pci = ar_pci;
2213                 tasklet_init(&ar_pci->pipe_info[i].intr, ath10k_pci_ce_tasklet,
2214                              (unsigned long)&ar_pci->pipe_info[i]);
2215         }
2216 }
2217
2218 static int ath10k_pci_init_irq(struct ath10k *ar)
2219 {
2220         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2221         int ret;
2222
2223         ath10k_pci_init_irq_tasklets(ar);
2224
2225         if (ath10k_pci_irq_mode != ATH10K_PCI_IRQ_AUTO)
2226                 ath10k_info(ar, "limiting irq mode to: %d\n",
2227                             ath10k_pci_irq_mode);
2228
2229         /* Try MSI-X */
2230         if (ath10k_pci_irq_mode == ATH10K_PCI_IRQ_AUTO) {
2231                 ar_pci->num_msi_intrs = MSI_NUM_REQUEST;
2232                 ret = pci_enable_msi_range(ar_pci->pdev, ar_pci->num_msi_intrs,
2233                                            ar_pci->num_msi_intrs);
2234                 if (ret > 0)
2235                         return 0;
2236
2237                 /* fall-through */
2238         }
2239
2240         /* Try MSI */
2241         if (ath10k_pci_irq_mode != ATH10K_PCI_IRQ_LEGACY) {
2242                 ar_pci->num_msi_intrs = 1;
2243                 ret = pci_enable_msi(ar_pci->pdev);
2244                 if (ret == 0)
2245                         return 0;
2246
2247                 /* fall-through */
2248         }
2249
2250         /* Try legacy irq
2251          *
2252          * A potential race occurs here: The CORE_BASE write
2253          * depends on target correctly decoding AXI address but
2254          * host won't know when target writes BAR to CORE_CTRL.
2255          * This write might get lost if target has NOT written BAR.
2256          * For now, fix the race by repeating the write in below
2257          * synchronization checking. */
2258         ar_pci->num_msi_intrs = 0;
2259
2260         ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS + PCIE_INTR_ENABLE_ADDRESS,
2261                            PCIE_INTR_FIRMWARE_MASK | PCIE_INTR_CE_MASK_ALL);
2262
2263         return 0;
2264 }
2265
2266 static void ath10k_pci_deinit_irq_legacy(struct ath10k *ar)
2267 {
2268         ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS + PCIE_INTR_ENABLE_ADDRESS,
2269                            0);
2270 }
2271
2272 static int ath10k_pci_deinit_irq(struct ath10k *ar)
2273 {
2274         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2275
2276         switch (ar_pci->num_msi_intrs) {
2277         case 0:
2278                 ath10k_pci_deinit_irq_legacy(ar);
2279                 return 0;
2280         case 1:
2281                 /* fall-through */
2282         case MSI_NUM_REQUEST:
2283                 pci_disable_msi(ar_pci->pdev);
2284                 return 0;
2285         default:
2286                 pci_disable_msi(ar_pci->pdev);
2287         }
2288
2289         ath10k_warn(ar, "unknown irq configuration upon deinit\n");
2290         return -EINVAL;
2291 }
2292
2293 static int ath10k_pci_wait_for_target_init(struct ath10k *ar)
2294 {
2295         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2296         unsigned long timeout;
2297         u32 val;
2298
2299         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot waiting target to initialise\n");
2300
2301         timeout = jiffies + msecs_to_jiffies(ATH10K_PCI_TARGET_WAIT);
2302
2303         do {
2304                 val = ath10k_pci_read32(ar, FW_INDICATOR_ADDRESS);
2305
2306                 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot target indicator %x\n",
2307                            val);
2308
2309                 /* target should never return this */
2310                 if (val == 0xffffffff)
2311                         continue;
2312
2313                 /* the device has crashed so don't bother trying anymore */
2314                 if (val & FW_IND_EVENT_PENDING)
2315                         break;
2316
2317                 if (val & FW_IND_INITIALIZED)
2318                         break;
2319
2320                 if (ar_pci->num_msi_intrs == 0)
2321                         /* Fix potential race by repeating CORE_BASE writes */
2322                         ath10k_pci_enable_legacy_irq(ar);
2323
2324                 mdelay(10);
2325         } while (time_before(jiffies, timeout));
2326
2327         ath10k_pci_disable_and_clear_legacy_irq(ar);
2328         ath10k_pci_irq_msi_fw_mask(ar);
2329
2330         if (val == 0xffffffff) {
2331                 ath10k_err(ar, "failed to read device register, device is gone\n");
2332                 return -EIO;
2333         }
2334
2335         if (val & FW_IND_EVENT_PENDING) {
2336                 ath10k_warn(ar, "device has crashed during init\n");
2337                 ath10k_pci_fw_crashed_clear(ar);
2338                 ath10k_pci_fw_crashed_dump(ar);
2339                 return -ECOMM;
2340         }
2341
2342         if (!(val & FW_IND_INITIALIZED)) {
2343                 ath10k_err(ar, "failed to receive initialized event from target: %08x\n",
2344                            val);
2345                 return -ETIMEDOUT;
2346         }
2347
2348         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot target initialised\n");
2349         return 0;
2350 }
2351
2352 static int ath10k_pci_cold_reset(struct ath10k *ar)
2353 {
2354         int i;
2355         u32 val;
2356
2357         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot cold reset\n");
2358
2359         spin_lock_bh(&ar->data_lock);
2360
2361         ar->stats.fw_cold_reset_counter++;
2362
2363         spin_unlock_bh(&ar->data_lock);
2364
2365         /* Put Target, including PCIe, into RESET. */
2366         val = ath10k_pci_reg_read32(ar, SOC_GLOBAL_RESET_ADDRESS);
2367         val |= 1;
2368         ath10k_pci_reg_write32(ar, SOC_GLOBAL_RESET_ADDRESS, val);
2369
2370         for (i = 0; i < ATH_PCI_RESET_WAIT_MAX; i++) {
2371                 if (ath10k_pci_reg_read32(ar, RTC_STATE_ADDRESS) &
2372                                           RTC_STATE_COLD_RESET_MASK)
2373                         break;
2374                 msleep(1);
2375         }
2376
2377         /* Pull Target, including PCIe, out of RESET. */
2378         val &= ~1;
2379         ath10k_pci_reg_write32(ar, SOC_GLOBAL_RESET_ADDRESS, val);
2380
2381         for (i = 0; i < ATH_PCI_RESET_WAIT_MAX; i++) {
2382                 if (!(ath10k_pci_reg_read32(ar, RTC_STATE_ADDRESS) &
2383                                             RTC_STATE_COLD_RESET_MASK))
2384                         break;
2385                 msleep(1);
2386         }
2387
2388         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot cold reset complete\n");
2389
2390         return 0;
2391 }
2392
2393 static int ath10k_pci_claim(struct ath10k *ar)
2394 {
2395         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2396         struct pci_dev *pdev = ar_pci->pdev;
2397         u32 lcr_val;
2398         int ret;
2399
2400         pci_set_drvdata(pdev, ar);
2401
2402         ret = pci_enable_device(pdev);
2403         if (ret) {
2404                 ath10k_err(ar, "failed to enable pci device: %d\n", ret);
2405                 return ret;
2406         }
2407
2408         ret = pci_request_region(pdev, BAR_NUM, "ath");
2409         if (ret) {
2410                 ath10k_err(ar, "failed to request region BAR%d: %d\n", BAR_NUM,
2411                            ret);
2412                 goto err_device;
2413         }
2414
2415         /* Target expects 32 bit DMA. Enforce it. */
2416         ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2417         if (ret) {
2418                 ath10k_err(ar, "failed to set dma mask to 32-bit: %d\n", ret);
2419                 goto err_region;
2420         }
2421
2422         ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2423         if (ret) {
2424                 ath10k_err(ar, "failed to set consistent dma mask to 32-bit: %d\n",
2425                            ret);
2426                 goto err_region;
2427         }
2428
2429         pci_set_master(pdev);
2430
2431         /* Workaround: Disable ASPM */
2432         pci_read_config_dword(pdev, 0x80, &lcr_val);
2433         pci_write_config_dword(pdev, 0x80, (lcr_val & 0xffffff00));
2434
2435         /* Arrange for access to Target SoC registers. */
2436         ar_pci->mem = pci_iomap(pdev, BAR_NUM, 0);
2437         if (!ar_pci->mem) {
2438                 ath10k_err(ar, "failed to iomap BAR%d\n", BAR_NUM);
2439                 ret = -EIO;
2440                 goto err_master;
2441         }
2442
2443         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot pci_mem 0x%p\n", ar_pci->mem);
2444         return 0;
2445
2446 err_master:
2447         pci_clear_master(pdev);
2448
2449 err_region:
2450         pci_release_region(pdev, BAR_NUM);
2451
2452 err_device:
2453         pci_disable_device(pdev);
2454
2455         return ret;
2456 }
2457
2458 static void ath10k_pci_release(struct ath10k *ar)
2459 {
2460         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2461         struct pci_dev *pdev = ar_pci->pdev;
2462
2463         pci_iounmap(pdev, ar_pci->mem);
2464         pci_release_region(pdev, BAR_NUM);
2465         pci_clear_master(pdev);
2466         pci_disable_device(pdev);
2467 }
2468
2469 static int ath10k_pci_probe(struct pci_dev *pdev,
2470                             const struct pci_device_id *pci_dev)
2471 {
2472         int ret = 0;
2473         struct ath10k *ar;
2474         struct ath10k_pci *ar_pci;
2475         u32 chip_id;
2476
2477         ar = ath10k_core_create(sizeof(*ar_pci), &pdev->dev,
2478                                 ATH10K_BUS_PCI,
2479                                 &ath10k_pci_hif_ops);
2480         if (!ar) {
2481                 dev_err(&pdev->dev, "failed to allocate core\n");
2482                 return -ENOMEM;
2483         }
2484
2485         ath10k_dbg(ar, ATH10K_DBG_PCI, "pci probe\n");
2486
2487         ar_pci = ath10k_pci_priv(ar);
2488         ar_pci->pdev = pdev;
2489         ar_pci->dev = &pdev->dev;
2490         ar_pci->ar = ar;
2491
2492         spin_lock_init(&ar_pci->ce_lock);
2493         setup_timer(&ar_pci->rx_post_retry, ath10k_pci_rx_replenish_retry,
2494                     (unsigned long)ar);
2495
2496         ret = ath10k_pci_claim(ar);
2497         if (ret) {
2498                 ath10k_err(ar, "failed to claim device: %d\n", ret);
2499                 goto err_core_destroy;
2500         }
2501
2502         ret = ath10k_pci_wake(ar);
2503         if (ret) {
2504                 ath10k_err(ar, "failed to wake up: %d\n", ret);
2505                 goto err_release;
2506         }
2507
2508         chip_id = ath10k_pci_soc_read32(ar, SOC_CHIP_ID_ADDRESS);
2509         if (chip_id == 0xffffffff) {
2510                 ath10k_err(ar, "failed to get chip id\n");
2511                 goto err_sleep;
2512         }
2513
2514         ret = ath10k_pci_alloc_pipes(ar);
2515         if (ret) {
2516                 ath10k_err(ar, "failed to allocate copy engine pipes: %d\n",
2517                            ret);
2518                 goto err_sleep;
2519         }
2520
2521         ath10k_pci_ce_deinit(ar);
2522         ath10k_pci_irq_disable(ar);
2523
2524         ret = ath10k_pci_init_irq(ar);
2525         if (ret) {
2526                 ath10k_err(ar, "failed to init irqs: %d\n", ret);
2527                 goto err_free_pipes;
2528         }
2529
2530         ath10k_info(ar, "pci irq %s interrupts %d irq_mode %d reset_mode %d\n",
2531                     ath10k_pci_get_irq_method(ar), ar_pci->num_msi_intrs,
2532                     ath10k_pci_irq_mode, ath10k_pci_reset_mode);
2533
2534         ret = ath10k_pci_request_irq(ar);
2535         if (ret) {
2536                 ath10k_warn(ar, "failed to request irqs: %d\n", ret);
2537                 goto err_deinit_irq;
2538         }
2539
2540         ath10k_pci_sleep(ar);
2541
2542         ret = ath10k_core_register(ar, chip_id);
2543         if (ret) {
2544                 ath10k_err(ar, "failed to register driver core: %d\n", ret);
2545                 goto err_free_irq;
2546         }
2547
2548         return 0;
2549
2550 err_free_irq:
2551         ath10k_pci_free_irq(ar);
2552         ath10k_pci_kill_tasklet(ar);
2553
2554 err_deinit_irq:
2555         ath10k_pci_deinit_irq(ar);
2556
2557 err_free_pipes:
2558         ath10k_pci_free_pipes(ar);
2559
2560 err_sleep:
2561         ath10k_pci_sleep(ar);
2562
2563 err_release:
2564         ath10k_pci_release(ar);
2565
2566 err_core_destroy:
2567         ath10k_core_destroy(ar);
2568
2569         return ret;
2570 }
2571
2572 static void ath10k_pci_remove(struct pci_dev *pdev)
2573 {
2574         struct ath10k *ar = pci_get_drvdata(pdev);
2575         struct ath10k_pci *ar_pci;
2576
2577         ath10k_dbg(ar, ATH10K_DBG_PCI, "pci remove\n");
2578
2579         if (!ar)
2580                 return;
2581
2582         ar_pci = ath10k_pci_priv(ar);
2583
2584         if (!ar_pci)
2585                 return;
2586
2587         ath10k_core_unregister(ar);
2588         ath10k_pci_free_irq(ar);
2589         ath10k_pci_kill_tasklet(ar);
2590         ath10k_pci_deinit_irq(ar);
2591         ath10k_pci_ce_deinit(ar);
2592         ath10k_pci_free_pipes(ar);
2593         ath10k_pci_release(ar);
2594         ath10k_core_destroy(ar);
2595 }
2596
2597 MODULE_DEVICE_TABLE(pci, ath10k_pci_id_table);
2598
2599 static struct pci_driver ath10k_pci_driver = {
2600         .name = "ath10k_pci",
2601         .id_table = ath10k_pci_id_table,
2602         .probe = ath10k_pci_probe,
2603         .remove = ath10k_pci_remove,
2604 };
2605
2606 static int __init ath10k_pci_init(void)
2607 {
2608         int ret;
2609
2610         ret = pci_register_driver(&ath10k_pci_driver);
2611         if (ret)
2612                 printk(KERN_ERR "failed to register ath10k pci driver: %d\n",
2613                        ret);
2614
2615         return ret;
2616 }
2617 module_init(ath10k_pci_init);
2618
2619 static void __exit ath10k_pci_exit(void)
2620 {
2621         pci_unregister_driver(&ath10k_pci_driver);
2622 }
2623
2624 module_exit(ath10k_pci_exit);
2625
2626 MODULE_AUTHOR("Qualcomm Atheros");
2627 MODULE_DESCRIPTION("Driver support for Atheros QCA988X PCIe devices");
2628 MODULE_LICENSE("Dual BSD/GPL");
2629 MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" QCA988X_HW_2_0_FW_FILE);
2630 MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" ATH10K_FW_API2_FILE);
2631 MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" ATH10K_FW_API3_FILE);
2632 MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" QCA988X_HW_2_0_BOARD_DATA_FILE);