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

   1 /*
   2  * Copyright (c) 2016 Qualcomm Atheros, Inc. All rights reserved.
   3  * Copyright (c) 2015 The Linux Foundation. All rights reserved.
   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 #include <linux/module.h>
  18 #include <linux/of.h>
  19 #include <linux/of_device.h>
  20 #include <linux/clk.h>
  21 #include <linux/reset.h>
  22 #include "core.h"
  23 #include "debug.h"
  24 #include "pci.h"
  25 #include "ahb.h"
  26
  27 static const struct of_device_id ath10k_ahb_of_match[] = {
  28         { .compatible = "qcom,ipq4019-wifi",
  29           .data = (void *)ATH10K_HW_QCA4019
  30         },
  31         { }
  32 };
  33
  34 MODULE_DEVICE_TABLE(of, ath10k_ahb_of_match);
  35
  36 #define QCA4019_SRAM_ADDR      0x000C0000
  37 #define QCA4019_SRAM_LEN       0x00040000 /* 256 kb */
  38
  39 static inline struct ath10k_ahb *ath10k_ahb_priv(struct ath10k *ar)
  40 {
  41         return &((struct ath10k_pci *)ar->drv_priv)->ahb[0];
  42 }
  43
  44 static void ath10k_ahb_write32(struct ath10k *ar, u32 offset, u32 value)
  45 {
  46         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
  47
  48         iowrite32(value, ar_ahb->mem + offset);
  49 }
  50
  51 static u32 ath10k_ahb_read32(struct ath10k *ar, u32 offset)
  52 {
  53         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
  54
  55         return ioread32(ar_ahb->mem + offset);
  56 }
  57
  58 static u32 ath10k_ahb_gcc_read32(struct ath10k *ar, u32 offset)
  59 {
  60         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
  61
  62         return ioread32(ar_ahb->gcc_mem + offset);
  63 }
  64
  65 static void ath10k_ahb_tcsr_write32(struct ath10k *ar, u32 offset, u32 value)
  66 {
  67         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
  68
  69         iowrite32(value, ar_ahb->tcsr_mem + offset);
  70 }
  71
  72 static u32 ath10k_ahb_tcsr_read32(struct ath10k *ar, u32 offset)
  73 {
  74         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
  75
  76         return ioread32(ar_ahb->tcsr_mem + offset);
  77 }
  78
  79 static u32 ath10k_ahb_soc_read32(struct ath10k *ar, u32 addr)
  80 {
  81         return ath10k_ahb_read32(ar, RTC_SOC_BASE_ADDRESS + addr);
  82 }
  83
  84 static int ath10k_ahb_get_num_banks(struct ath10k *ar)
  85 {
  86         if (ar->hw_rev == ATH10K_HW_QCA4019)
  87                 return 1;
  88
  89         ath10k_warn(ar, "unknown number of banks, assuming 1\n");
  90         return 1;
  91 }
  92
  93 static int ath10k_ahb_clock_init(struct ath10k *ar)
  94 {
  95         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
  96         struct device *dev;
  97
  98         dev = &ar_ahb->pdev->dev;
  99
 100         ar_ahb->cmd_clk = devm_clk_get(dev, "wifi_wcss_cmd");
 101         if (IS_ERR_OR_NULL(ar_ahb->cmd_clk)) {
 102                 ath10k_err(ar, "failed to get cmd clk: %ld\n",
 103                            PTR_ERR(ar_ahb->cmd_clk));
 104                 return ar_ahb->cmd_clk ? PTR_ERR(ar_ahb->cmd_clk) : -ENODEV;
 105         }
 106
 107         ar_ahb->ref_clk = devm_clk_get(dev, "wifi_wcss_ref");
 108         if (IS_ERR_OR_NULL(ar_ahb->ref_clk)) {
 109                 ath10k_err(ar, "failed to get ref clk: %ld\n",
 110                            PTR_ERR(ar_ahb->ref_clk));
 111                 return ar_ahb->ref_clk ? PTR_ERR(ar_ahb->ref_clk) : -ENODEV;
 112         }
 113
 114         ar_ahb->rtc_clk = devm_clk_get(dev, "wifi_wcss_rtc");
 115         if (IS_ERR_OR_NULL(ar_ahb->rtc_clk)) {
 116                 ath10k_err(ar, "failed to get rtc clk: %ld\n",
 117                            PTR_ERR(ar_ahb->rtc_clk));
 118                 return ar_ahb->rtc_clk ? PTR_ERR(ar_ahb->rtc_clk) : -ENODEV;
 119         }
 120
 121         return 0;
 122 }
 123
 124 static void ath10k_ahb_clock_deinit(struct ath10k *ar)
 125 {
 126         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
 127
 128         ar_ahb->cmd_clk = NULL;
 129         ar_ahb->ref_clk = NULL;
 130         ar_ahb->rtc_clk = NULL;
 131 }
 132
 133 static int ath10k_ahb_clock_enable(struct ath10k *ar)
 134 {
 135         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
 136         struct device *dev;
 137         int ret;
 138
 139         dev = &ar_ahb->pdev->dev;
 140
 141         if (IS_ERR_OR_NULL(ar_ahb->cmd_clk) ||
 142             IS_ERR_OR_NULL(ar_ahb->ref_clk) ||
 143             IS_ERR_OR_NULL(ar_ahb->rtc_clk)) {
 144                 ath10k_err(ar, "clock(s) is/are not initialized\n");
 145                 ret = -EIO;
 146                 goto out;
 147         }
 148
 149         ret = clk_prepare_enable(ar_ahb->cmd_clk);
 150         if (ret) {
 151                 ath10k_err(ar, "failed to enable cmd clk: %d\n", ret);
 152                 goto out;
 153         }
 154
 155         ret = clk_prepare_enable(ar_ahb->ref_clk);
 156         if (ret) {
 157                 ath10k_err(ar, "failed to enable ref clk: %d\n", ret);
 158                 goto err_cmd_clk_disable;
 159         }
 160
 161         ret = clk_prepare_enable(ar_ahb->rtc_clk);
 162         if (ret) {
 163                 ath10k_err(ar, "failed to enable rtc clk: %d\n", ret);
 164                 goto err_ref_clk_disable;
 165         }
 166
 167         return 0;
 168
 169 err_ref_clk_disable:
 170         clk_disable_unprepare(ar_ahb->ref_clk);
 171
 172 err_cmd_clk_disable:
 173         clk_disable_unprepare(ar_ahb->cmd_clk);
 174
 175 out:
 176         return ret;
 177 }
 178
 179 static void ath10k_ahb_clock_disable(struct ath10k *ar)
 180 {
 181         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
 182
 183         if (!IS_ERR_OR_NULL(ar_ahb->cmd_clk))
 184                 clk_disable_unprepare(ar_ahb->cmd_clk);
 185
 186         if (!IS_ERR_OR_NULL(ar_ahb->ref_clk))
 187                 clk_disable_unprepare(ar_ahb->ref_clk);
 188
 189         if (!IS_ERR_OR_NULL(ar_ahb->rtc_clk))
 190                 clk_disable_unprepare(ar_ahb->rtc_clk);
 191 }
 192
 193 static int ath10k_ahb_rst_ctrl_init(struct ath10k *ar)
 194 {
 195         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
 196         struct device *dev;
 197
 198         dev = &ar_ahb->pdev->dev;
 199
 200         ar_ahb->core_cold_rst = devm_reset_control_get_exclusive(dev,
 201                                                                  "wifi_core_cold");
 202         if (IS_ERR(ar_ahb->core_cold_rst)) {
 203                 ath10k_err(ar, "failed to get core cold rst ctrl: %ld\n",
 204                            PTR_ERR(ar_ahb->core_cold_rst));
 205                 return PTR_ERR(ar_ahb->core_cold_rst);
 206         }
 207
 208         ar_ahb->radio_cold_rst = devm_reset_control_get_exclusive(dev,
 209                                                                   "wifi_radio_cold");
 210         if (IS_ERR(ar_ahb->radio_cold_rst)) {
 211                 ath10k_err(ar, "failed to get radio cold rst ctrl: %ld\n",
 212                            PTR_ERR(ar_ahb->radio_cold_rst));
 213                 return PTR_ERR(ar_ahb->radio_cold_rst);
 214         }
 215
 216         ar_ahb->radio_warm_rst = devm_reset_control_get_exclusive(dev,
 217                                                                   "wifi_radio_warm");
 218         if (IS_ERR(ar_ahb->radio_warm_rst)) {
 219                 ath10k_err(ar, "failed to get radio warm rst ctrl: %ld\n",
 220                            PTR_ERR(ar_ahb->radio_warm_rst));
 221                 return PTR_ERR(ar_ahb->radio_warm_rst);
 222         }
 223
 224         ar_ahb->radio_srif_rst = devm_reset_control_get_exclusive(dev,
 225                                                                   "wifi_radio_srif");
 226         if (IS_ERR(ar_ahb->radio_srif_rst)) {
 227                 ath10k_err(ar, "failed to get radio srif rst ctrl: %ld\n",
 228                            PTR_ERR(ar_ahb->radio_srif_rst));
 229                 return PTR_ERR(ar_ahb->radio_srif_rst);
 230         }
 231
 232         ar_ahb->cpu_init_rst = devm_reset_control_get_exclusive(dev,
 233                                                                 "wifi_cpu_init");
 234         if (IS_ERR(ar_ahb->cpu_init_rst)) {
 235                 ath10k_err(ar, "failed to get cpu init rst ctrl: %ld\n",
 236                            PTR_ERR(ar_ahb->cpu_init_rst));
 237                 return PTR_ERR(ar_ahb->cpu_init_rst);
 238         }
 239
 240         return 0;
 241 }
 242
 243 static void ath10k_ahb_rst_ctrl_deinit(struct ath10k *ar)
 244 {
 245         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
 246
 247         ar_ahb->core_cold_rst = NULL;
 248         ar_ahb->radio_cold_rst = NULL;
 249         ar_ahb->radio_warm_rst = NULL;
 250         ar_ahb->radio_srif_rst = NULL;
 251         ar_ahb->cpu_init_rst = NULL;
 252 }
 253
 254 static int ath10k_ahb_release_reset(struct ath10k *ar)
 255 {
 256         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
 257         int ret;
 258
 259         if (IS_ERR_OR_NULL(ar_ahb->radio_cold_rst) ||
 260             IS_ERR_OR_NULL(ar_ahb->radio_warm_rst) ||
 261             IS_ERR_OR_NULL(ar_ahb->radio_srif_rst) ||
 262             IS_ERR_OR_NULL(ar_ahb->cpu_init_rst)) {
 263                 ath10k_err(ar, "rst ctrl(s) is/are not initialized\n");
 264                 return -EINVAL;
 265         }
 266
 267         ret = reset_control_deassert(ar_ahb->radio_cold_rst);
 268         if (ret) {
 269                 ath10k_err(ar, "failed to deassert radio cold rst: %d\n", ret);
 270                 return ret;
 271         }
 272
 273         ret = reset_control_deassert(ar_ahb->radio_warm_rst);
 274         if (ret) {
 275                 ath10k_err(ar, "failed to deassert radio warm rst: %d\n", ret);
 276                 return ret;
 277         }
 278
 279         ret = reset_control_deassert(ar_ahb->radio_srif_rst);
 280         if (ret) {
 281                 ath10k_err(ar, "failed to deassert radio srif rst: %d\n", ret);
 282                 return ret;
 283         }
 284
 285         ret = reset_control_deassert(ar_ahb->cpu_init_rst);
 286         if (ret) {
 287                 ath10k_err(ar, "failed to deassert cpu init rst: %d\n", ret);
 288                 return ret;
 289         }
 290
 291         return 0;
 292 }
 293
 294 static void ath10k_ahb_halt_axi_bus(struct ath10k *ar, u32 haltreq_reg,
 295                                     u32 haltack_reg)
 296 {
 297         unsigned long timeout;
 298         u32 val;
 299
 300         /* Issue halt axi bus request */
 301         val = ath10k_ahb_tcsr_read32(ar, haltreq_reg);
 302         val |= AHB_AXI_BUS_HALT_REQ;
 303         ath10k_ahb_tcsr_write32(ar, haltreq_reg, val);
 304
 305         /* Wait for axi bus halted ack */
 306         timeout = jiffies + msecs_to_jiffies(ATH10K_AHB_AXI_BUS_HALT_TIMEOUT);
 307         do {
 308                 val = ath10k_ahb_tcsr_read32(ar, haltack_reg);
 309                 if (val & AHB_AXI_BUS_HALT_ACK)
 310                         break;
 311
 312                 mdelay(1);
 313         } while (time_before(jiffies, timeout));
 314
 315         if (!(val & AHB_AXI_BUS_HALT_ACK)) {
 316                 ath10k_err(ar, "failed to halt axi bus: %d\n", val);
 317                 return;
 318         }
 319
 320         ath10k_dbg(ar, ATH10K_DBG_AHB, "axi bus halted\n");
 321 }
 322
 323 static void ath10k_ahb_halt_chip(struct ath10k *ar)
 324 {
 325         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
 326         u32 core_id, glb_cfg_reg, haltreq_reg, haltack_reg;
 327         u32 val;
 328         int ret;
 329
 330         if (IS_ERR_OR_NULL(ar_ahb->core_cold_rst) ||
 331             IS_ERR_OR_NULL(ar_ahb->radio_cold_rst) ||
 332             IS_ERR_OR_NULL(ar_ahb->radio_warm_rst) ||
 333             IS_ERR_OR_NULL(ar_ahb->radio_srif_rst) ||
 334             IS_ERR_OR_NULL(ar_ahb->cpu_init_rst)) {
 335                 ath10k_err(ar, "rst ctrl(s) is/are not initialized\n");
 336                 return;
 337         }
 338
 339         core_id = ath10k_ahb_read32(ar, ATH10K_AHB_WLAN_CORE_ID_REG);
 340
 341         switch (core_id) {
 342         case 0:
 343                 glb_cfg_reg = ATH10K_AHB_TCSR_WIFI0_GLB_CFG;
 344                 haltreq_reg = ATH10K_AHB_TCSR_WCSS0_HALTREQ;
 345                 haltack_reg = ATH10K_AHB_TCSR_WCSS0_HALTACK;
 346                 break;
 347         case 1:
 348                 glb_cfg_reg = ATH10K_AHB_TCSR_WIFI1_GLB_CFG;
 349                 haltreq_reg = ATH10K_AHB_TCSR_WCSS1_HALTREQ;
 350                 haltack_reg = ATH10K_AHB_TCSR_WCSS1_HALTACK;
 351                 break;
 352         default:
 353                 ath10k_err(ar, "invalid core id %d found, skipping reset sequence\n",
 354                            core_id);
 355                 return;
 356         }
 357
 358         ath10k_ahb_halt_axi_bus(ar, haltreq_reg, haltack_reg);
 359
 360         val = ath10k_ahb_tcsr_read32(ar, glb_cfg_reg);
 361         val |= TCSR_WIFIX_GLB_CFG_DISABLE_CORE_CLK;
 362         ath10k_ahb_tcsr_write32(ar, glb_cfg_reg, val);
 363
 364         ret = reset_control_assert(ar_ahb->core_cold_rst);
 365         if (ret)
 366                 ath10k_err(ar, "failed to assert core cold rst: %d\n", ret);
 367         msleep(1);
 368
 369         ret = reset_control_assert(ar_ahb->radio_cold_rst);
 370         if (ret)
 371                 ath10k_err(ar, "failed to assert radio cold rst: %d\n", ret);
 372         msleep(1);
 373
 374         ret = reset_control_assert(ar_ahb->radio_warm_rst);
 375         if (ret)
 376                 ath10k_err(ar, "failed to assert radio warm rst: %d\n", ret);
 377         msleep(1);
 378
 379         ret = reset_control_assert(ar_ahb->radio_srif_rst);
 380         if (ret)
 381                 ath10k_err(ar, "failed to assert radio srif rst: %d\n", ret);
 382         msleep(1);
 383
 384         ret = reset_control_assert(ar_ahb->cpu_init_rst);
 385         if (ret)
 386                 ath10k_err(ar, "failed to assert cpu init rst: %d\n", ret);
 387         msleep(10);
 388
 389         /* Clear halt req and core clock disable req before
 390          * deasserting wifi core reset.
 391          */
 392         val = ath10k_ahb_tcsr_read32(ar, haltreq_reg);
 393         val &= ~AHB_AXI_BUS_HALT_REQ;
 394         ath10k_ahb_tcsr_write32(ar, haltreq_reg, val);
 395
 396         val = ath10k_ahb_tcsr_read32(ar, glb_cfg_reg);
 397         val &= ~TCSR_WIFIX_GLB_CFG_DISABLE_CORE_CLK;
 398         ath10k_ahb_tcsr_write32(ar, glb_cfg_reg, val);
 399
 400         ret = reset_control_deassert(ar_ahb->core_cold_rst);
 401         if (ret)
 402                 ath10k_err(ar, "failed to deassert core cold rst: %d\n", ret);
 403
 404         ath10k_dbg(ar, ATH10K_DBG_AHB, "core %d reset done\n", core_id);
 405 }
 406
 407 static irqreturn_t ath10k_ahb_interrupt_handler(int irq, void *arg)
 408 {
 409         struct ath10k *ar = arg;
 410
 411         if (!ath10k_pci_irq_pending(ar))
 412                 return IRQ_NONE;
 413
 414         ath10k_pci_disable_and_clear_legacy_irq(ar);
 415         ath10k_pci_irq_msi_fw_mask(ar);
 416         napi_schedule(&ar->napi);
 417
 418         return IRQ_HANDLED;
 419 }
 420
 421 static int ath10k_ahb_request_irq_legacy(struct ath10k *ar)
 422 {
 423         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
 424         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
 425         int ret;
 426
 427         ret = request_irq(ar_ahb->irq,
 428                           ath10k_ahb_interrupt_handler,
 429                           IRQF_SHARED, "ath10k_ahb", ar);
 430         if (ret) {
 431                 ath10k_warn(ar, "failed to request legacy irq %d: %d\n",
 432                             ar_ahb->irq, ret);
 433                 return ret;
 434         }
 435         ar_pci->oper_irq_mode = ATH10K_PCI_IRQ_LEGACY;
 436
 437         return 0;
 438 }
 439
 440 static void ath10k_ahb_release_irq_legacy(struct ath10k *ar)
 441 {
 442         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
 443
 444         free_irq(ar_ahb->irq, ar);
 445 }
 446
 447 static void ath10k_ahb_irq_disable(struct ath10k *ar)
 448 {
 449         ath10k_ce_disable_interrupts(ar);
 450         ath10k_pci_disable_and_clear_legacy_irq(ar);
 451 }
 452
 453 static int ath10k_ahb_resource_init(struct ath10k *ar)
 454 {
 455         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
 456         struct platform_device *pdev;
 457         struct device *dev;
 458         struct resource *res;
 459         int ret;
 460
 461         pdev = ar_ahb->pdev;
 462         dev = &pdev->dev;
 463
 464         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 465         if (!res) {
 466                 ath10k_err(ar, "failed to get memory resource\n");
 467                 ret = -ENXIO;
 468                 goto out;
 469         }
 470
 471         ar_ahb->mem = devm_ioremap_resource(&pdev->dev, res);
 472         if (IS_ERR(ar_ahb->mem)) {
 473                 ath10k_err(ar, "mem ioremap error\n");
 474                 ret = PTR_ERR(ar_ahb->mem);
 475                 goto out;
 476         }
 477
 478         ar_ahb->mem_len = resource_size(res);
 479
 480         ar_ahb->gcc_mem = ioremap_nocache(ATH10K_GCC_REG_BASE,
 481                                           ATH10K_GCC_REG_SIZE);
 482         if (!ar_ahb->gcc_mem) {
 483                 ath10k_err(ar, "gcc mem ioremap error\n");
 484                 ret = -ENOMEM;
 485                 goto err_mem_unmap;
 486         }
 487
 488         ar_ahb->tcsr_mem = ioremap_nocache(ATH10K_TCSR_REG_BASE,
 489                                            ATH10K_TCSR_REG_SIZE);
 490         if (!ar_ahb->tcsr_mem) {
 491                 ath10k_err(ar, "tcsr mem ioremap error\n");
 492                 ret = -ENOMEM;
 493                 goto err_gcc_mem_unmap;
 494         }
 495
 496         ret = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
 497         if (ret) {
 498                 ath10k_err(ar, "failed to set 32-bit dma mask: %d\n", ret);
 499                 goto err_tcsr_mem_unmap;
 500         }
 501
 502         ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
 503         if (ret) {
 504                 ath10k_err(ar, "failed to set 32-bit consistent dma: %d\n",
 505                            ret);
 506                 goto err_tcsr_mem_unmap;
 507         }
 508
 509         ret = ath10k_ahb_clock_init(ar);
 510         if (ret)
 511                 goto err_tcsr_mem_unmap;
 512
 513         ret = ath10k_ahb_rst_ctrl_init(ar);
 514         if (ret)
 515                 goto err_clock_deinit;
 516
 517         ar_ahb->irq = platform_get_irq_byname(pdev, "legacy");
 518         if (ar_ahb->irq < 0) {
 519                 ath10k_err(ar, "failed to get irq number: %d\n", ar_ahb->irq);
 520                 ret = ar_ahb->irq;
 521                 goto err_clock_deinit;
 522         }
 523
 524         ath10k_dbg(ar, ATH10K_DBG_BOOT, "irq: %d\n", ar_ahb->irq);
 525
 526         ath10k_dbg(ar, ATH10K_DBG_BOOT, "mem: 0x%pK mem_len: %lu gcc mem: 0x%pK tcsr_mem: 0x%pK\n",
 527                    ar_ahb->mem, ar_ahb->mem_len,
 528                    ar_ahb->gcc_mem, ar_ahb->tcsr_mem);
 529         return 0;
 530
 531 err_clock_deinit:
 532         ath10k_ahb_clock_deinit(ar);
 533
 534 err_tcsr_mem_unmap:
 535         iounmap(ar_ahb->tcsr_mem);
 536
 537 err_gcc_mem_unmap:
 538         ar_ahb->tcsr_mem = NULL;
 539         iounmap(ar_ahb->gcc_mem);
 540
 541 err_mem_unmap:
 542         ar_ahb->gcc_mem = NULL;
 543         devm_iounmap(&pdev->dev, ar_ahb->mem);
 544
 545 out:
 546         ar_ahb->mem = NULL;
 547         return ret;
 548 }
 549
 550 static void ath10k_ahb_resource_deinit(struct ath10k *ar)
 551 {
 552         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
 553         struct device *dev;
 554
 555         dev = &ar_ahb->pdev->dev;
 556
 557         if (ar_ahb->mem)
 558                 devm_iounmap(dev, ar_ahb->mem);
 559
 560         if (ar_ahb->gcc_mem)
 561                 iounmap(ar_ahb->gcc_mem);
 562
 563         if (ar_ahb->tcsr_mem)
 564                 iounmap(ar_ahb->tcsr_mem);
 565
 566         ar_ahb->mem = NULL;
 567         ar_ahb->gcc_mem = NULL;
 568         ar_ahb->tcsr_mem = NULL;
 569
 570         ath10k_ahb_clock_deinit(ar);
 571         ath10k_ahb_rst_ctrl_deinit(ar);
 572 }
 573
 574 static int ath10k_ahb_prepare_device(struct ath10k *ar)
 575 {
 576         u32 val;
 577         int ret;
 578
 579         ret = ath10k_ahb_clock_enable(ar);
 580         if (ret) {
 581                 ath10k_err(ar, "failed to enable clocks\n");
 582                 return ret;
 583         }
 584
 585         /* Clock for the target is supplied from outside of target (ie,
 586          * external clock module controlled by the host). Target needs
 587          * to know what frequency target cpu is configured which is needed
 588          * for target internal use. Read target cpu frequency info from
 589          * gcc register and write into target's scratch register where
 590          * target expects this information.
 591          */
 592         val = ath10k_ahb_gcc_read32(ar, ATH10K_AHB_GCC_FEPLL_PLL_DIV);
 593         ath10k_ahb_write32(ar, ATH10K_AHB_WIFI_SCRATCH_5_REG, val);
 594
 595         ret = ath10k_ahb_release_reset(ar);
 596         if (ret)
 597                 goto err_clk_disable;
 598
 599         ath10k_ahb_irq_disable(ar);
 600
 601         ath10k_ahb_write32(ar, FW_INDICATOR_ADDRESS, FW_IND_HOST_READY);
 602
 603         ret = ath10k_pci_wait_for_target_init(ar);
 604         if (ret)
 605                 goto err_halt_chip;
 606
 607         return 0;
 608
 609 err_halt_chip:
 610         ath10k_ahb_halt_chip(ar);
 611
 612 err_clk_disable:
 613         ath10k_ahb_clock_disable(ar);
 614
 615         return ret;
 616 }
 617
 618 static int ath10k_ahb_chip_reset(struct ath10k *ar)
 619 {
 620         int ret;
 621
 622         ath10k_ahb_halt_chip(ar);
 623         ath10k_ahb_clock_disable(ar);
 624
 625         ret = ath10k_ahb_prepare_device(ar);
 626         if (ret)
 627                 return ret;
 628
 629         return 0;
 630 }
 631
 632 static int ath10k_ahb_wake_target_cpu(struct ath10k *ar)
 633 {
 634         u32 addr, val;
 635
 636         addr = SOC_CORE_BASE_ADDRESS | CORE_CTRL_ADDRESS;
 637         val = ath10k_ahb_read32(ar, addr);
 638         val |= ATH10K_AHB_CORE_CTRL_CPU_INTR_MASK;
 639         ath10k_ahb_write32(ar, addr, val);
 640
 641         return 0;
 642 }
 643
 644 static int ath10k_ahb_hif_start(struct ath10k *ar)
 645 {
 646         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot ahb hif start\n");
 647
 648         napi_enable(&ar->napi);
 649         ath10k_ce_enable_interrupts(ar);
 650         ath10k_pci_enable_legacy_irq(ar);
 651
 652         ath10k_pci_rx_post(ar);
 653
 654         return 0;
 655 }
 656
 657 static void ath10k_ahb_hif_stop(struct ath10k *ar)
 658 {
 659         struct ath10k_ahb *ar_ahb = ath10k_ahb_priv(ar);
 660
 661         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot ahb hif stop\n");
 662
 663         ath10k_ahb_irq_disable(ar);
 664         synchronize_irq(ar_ahb->irq);
 665
 666         napi_synchronize(&ar->napi);
 667         napi_disable(&ar->napi);
 668
 669         ath10k_pci_flush(ar);
 670 }
 671
 672 static int ath10k_ahb_hif_power_up(struct ath10k *ar)
 673 {
 674         int ret;
 675
 676         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot ahb hif power up\n");
 677
 678         ret = ath10k_ahb_chip_reset(ar);
 679         if (ret) {
 680                 ath10k_err(ar, "failed to reset chip: %d\n", ret);
 681                 goto out;
 682         }
 683
 684         ret = ath10k_pci_init_pipes(ar);
 685         if (ret) {
 686                 ath10k_err(ar, "failed to initialize CE: %d\n", ret);
 687                 goto out;
 688         }
 689
 690         ret = ath10k_pci_init_config(ar);
 691         if (ret) {
 692                 ath10k_err(ar, "failed to setup init config: %d\n", ret);
 693                 goto err_ce_deinit;
 694         }
 695
 696         ret = ath10k_ahb_wake_target_cpu(ar);
 697         if (ret) {
 698                 ath10k_err(ar, "could not wake up target CPU: %d\n", ret);
 699                 goto err_ce_deinit;
 700         }
 701
 702         return 0;
 703
 704 err_ce_deinit:
 705         ath10k_pci_ce_deinit(ar);
 706 out:
 707         return ret;
 708 }
 709
 710 static u32 ath10k_ahb_qca4019_targ_cpu_to_ce_addr(struct ath10k *ar, u32 addr)
 711 {
 712         u32 val = 0, region = addr & 0xfffff;
 713
 714         val = ath10k_pci_read32(ar, PCIE_BAR_REG_ADDRESS);
 715
 716         if (region >= QCA4019_SRAM_ADDR && region <=
 717             (QCA4019_SRAM_ADDR + QCA4019_SRAM_LEN)) {
 718                 /* SRAM contents for QCA4019 can be directly accessed and
 719                  * no conversions are required
 720                  */
 721                 val |= region;
 722         } else {
 723                 val |= 0x100000 | region;
 724         }
 725
 726         return val;
 727 }
 728
 729 static const struct ath10k_hif_ops ath10k_ahb_hif_ops = {
 730         .tx_sg                  = ath10k_pci_hif_tx_sg,
 731         .diag_read              = ath10k_pci_hif_diag_read,
 732         .diag_write             = ath10k_pci_diag_write_mem,
 733         .exchange_bmi_msg       = ath10k_pci_hif_exchange_bmi_msg,
 734         .start                  = ath10k_ahb_hif_start,
 735         .stop                   = ath10k_ahb_hif_stop,
 736         .map_service_to_pipe    = ath10k_pci_hif_map_service_to_pipe,
 737         .get_default_pipe       = ath10k_pci_hif_get_default_pipe,
 738         .send_complete_check    = ath10k_pci_hif_send_complete_check,
 739         .get_free_queue_number  = ath10k_pci_hif_get_free_queue_number,
 740         .power_up               = ath10k_ahb_hif_power_up,
 741         .power_down             = ath10k_pci_hif_power_down,
 742         .read32                 = ath10k_ahb_read32,
 743         .write32                = ath10k_ahb_write32,
 744 };
 745
 746 static const struct ath10k_bus_ops ath10k_ahb_bus_ops = {
 747         .read32         = ath10k_ahb_read32,
 748         .write32        = ath10k_ahb_write32,
 749         .get_num_banks  = ath10k_ahb_get_num_banks,
 750 };
 751
 752 static int ath10k_ahb_probe(struct platform_device *pdev)
 753 {
 754         struct ath10k *ar;
 755         struct ath10k_ahb *ar_ahb;
 756         struct ath10k_pci *ar_pci;
 757         const struct of_device_id *of_id;
 758         enum ath10k_hw_rev hw_rev;
 759         size_t size;
 760         int ret;
 761         u32 chip_id;
 762
 763         of_id = of_match_device(ath10k_ahb_of_match, &pdev->dev);
 764         if (!of_id) {
 765                 dev_err(&pdev->dev, "failed to find matching device tree id\n");
 766                 return -EINVAL;
 767         }
 768
 769         hw_rev = (enum ath10k_hw_rev)of_id->data;
 770
 771         size = sizeof(*ar_pci) + sizeof(*ar_ahb);
 772         ar = ath10k_core_create(size, &pdev->dev, ATH10K_BUS_AHB,
 773                                 hw_rev, &ath10k_ahb_hif_ops);
 774         if (!ar) {
 775                 dev_err(&pdev->dev, "failed to allocate core\n");
 776                 return -ENOMEM;
 777         }
 778
 779         ath10k_dbg(ar, ATH10K_DBG_BOOT, "ahb probe\n");
 780
 781         ar_pci = ath10k_pci_priv(ar);
 782         ar_ahb = ath10k_ahb_priv(ar);
 783
 784         ar_ahb->pdev = pdev;
 785         platform_set_drvdata(pdev, ar);
 786
 787         ret = ath10k_ahb_resource_init(ar);
 788         if (ret)
 789                 goto err_core_destroy;
 790
 791         ar->dev_id = 0;
 792         ar_pci->mem = ar_ahb->mem;
 793         ar_pci->mem_len = ar_ahb->mem_len;
 794         ar_pci->ar = ar;
 795         ar_pci->ce.bus_ops = &ath10k_ahb_bus_ops;
 796         ar_pci->targ_cpu_to_ce_addr = ath10k_ahb_qca4019_targ_cpu_to_ce_addr;
 797         ar->ce_priv = &ar_pci->ce;
 798
 799         ret = ath10k_pci_setup_resource(ar);
 800         if (ret) {
 801                 ath10k_err(ar, "failed to setup resource: %d\n", ret);
 802                 goto err_resource_deinit;
 803         }
 804
 805         ath10k_pci_init_napi(ar);
 806
 807         ret = ath10k_ahb_request_irq_legacy(ar);
 808         if (ret)
 809                 goto err_free_pipes;
 810
 811         ret = ath10k_ahb_prepare_device(ar);
 812         if (ret)
 813                 goto err_free_irq;
 814
 815         ath10k_pci_ce_deinit(ar);
 816
 817         chip_id = ath10k_ahb_soc_read32(ar, SOC_CHIP_ID_ADDRESS);
 818         if (chip_id == 0xffffffff) {
 819                 ath10k_err(ar, "failed to get chip id\n");
 820                 ret = -ENODEV;
 821                 goto err_halt_device;
 822         }
 823
 824         ret = ath10k_core_register(ar, chip_id);
 825         if (ret) {
 826                 ath10k_err(ar, "failed to register driver core: %d\n", ret);
 827                 goto err_halt_device;
 828         }
 829
 830         return 0;
 831
 832 err_halt_device:
 833         ath10k_ahb_halt_chip(ar);
 834         ath10k_ahb_clock_disable(ar);
 835
 836 err_free_irq:
 837         ath10k_ahb_release_irq_legacy(ar);
 838
 839 err_free_pipes:
 840         ath10k_pci_free_pipes(ar);
 841
 842 err_resource_deinit:
 843         ath10k_ahb_resource_deinit(ar);
 844
 845 err_core_destroy:
 846         ath10k_core_destroy(ar);
 847         platform_set_drvdata(pdev, NULL);
 848
 849         return ret;
 850 }
 851
 852 static int ath10k_ahb_remove(struct platform_device *pdev)
 853 {
 854         struct ath10k *ar = platform_get_drvdata(pdev);
 855         struct ath10k_ahb *ar_ahb;
 856
 857         if (!ar)
 858                 return -EINVAL;
 859
 860         ar_ahb = ath10k_ahb_priv(ar);
 861
 862         if (!ar_ahb)
 863                 return -EINVAL;
 864
 865         ath10k_dbg(ar, ATH10K_DBG_AHB, "ahb remove\n");
 866
 867         ath10k_core_unregister(ar);
 868         ath10k_ahb_irq_disable(ar);
 869         ath10k_ahb_release_irq_legacy(ar);
 870         ath10k_pci_release_resource(ar);
 871         ath10k_ahb_halt_chip(ar);
 872         ath10k_ahb_clock_disable(ar);
 873         ath10k_ahb_resource_deinit(ar);
 874         ath10k_core_destroy(ar);
 875
 876         platform_set_drvdata(pdev, NULL);
 877
 878         return 0;
 879 }
 880
 881 static struct platform_driver ath10k_ahb_driver = {
 882         .driver         = {
 883                 .name   = "ath10k_ahb",
 884                 .of_match_table = ath10k_ahb_of_match,
 885         },
 886         .probe  = ath10k_ahb_probe,
 887         .remove = ath10k_ahb_remove,
 888 };
 889
 890 int ath10k_ahb_init(void)
 891 {
 892         int ret;
 893
 894         ret = platform_driver_register(&ath10k_ahb_driver);
 895         if (ret)
 896                 printk(KERN_ERR "failed to register ath10k ahb driver: %d\n",
 897                        ret);
 898         return ret;
 899 }
 900
 901 void ath10k_ahb_exit(void)
 902 {
 903         platform_driver_unregister(&ath10k_ahb_driver);
 904 }