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