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