drivers/net/ipa/ipa_main.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 /* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
   4  * Copyright (C) 2018-2020 Linaro Ltd.
   5  */
   6
   7 #include <linux/types.h>
   8 #include <linux/atomic.h>
   9 #include <linux/bitfield.h>
  10 #include <linux/device.h>
  11 #include <linux/bug.h>
  12 #include <linux/io.h>
  13 #include <linux/firmware.h>
  14 #include <linux/module.h>
  15 #include <linux/of.h>
  16 #include <linux/of_device.h>
  17 #include <linux/of_address.h>
  18 #include <linux/remoteproc.h>
  19 #include <linux/qcom_scm.h>
  20 #include <linux/soc/qcom/mdt_loader.h>
  21
  22 #include "ipa.h"
  23 #include "ipa_clock.h"
  24 #include "ipa_data.h"
  25 #include "ipa_endpoint.h"
  26 #include "ipa_cmd.h"
  27 #include "ipa_reg.h"
  28 #include "ipa_mem.h"
  29 #include "ipa_table.h"
  30 #include "ipa_modem.h"
  31 #include "ipa_uc.h"
  32 #include "ipa_interrupt.h"
  33 #include "gsi_trans.h"
  34
  35 /**
  36  * DOC: The IP Accelerator
  37  *
  38  * This driver supports the Qualcomm IP Accelerator (IPA), which is a
  39  * networking component found in many Qualcomm SoCs.  The IPA is connected
  40  * to the application processor (AP), but is also connected (and partially
  41  * controlled by) other "execution environments" (EEs), such as a modem.
  42  *
  43  * The IPA is the conduit between the AP and the modem that carries network
  44  * traffic.  This driver presents a network interface representing the
  45  * connection of the modem to external (e.g. LTE) networks.
  46  *
  47  * The IPA provides protocol checksum calculation, offloading this work
  48  * from the AP.  The IPA offers additional functionality, including routing,
  49  * filtering, and NAT support, but that more advanced functionality is not
  50  * currently supported.  Despite that, some resources--including routing
  51  * tables and filter tables--are defined in this driver because they must
  52  * be initialized even when the advanced hardware features are not used.
  53  *
  54  * There are two distinct layers that implement the IPA hardware, and this
  55  * is reflected in the organization of the driver.  The generic software
  56  * interface (GSI) is an integral component of the IPA, providing a
  57  * well-defined communication layer between the AP subsystem and the IPA
  58  * core.  The GSI implements a set of "channels" used for communication
  59  * between the AP and the IPA.
  60  *
  61  * The IPA layer uses GSI channels to implement its "endpoints".  And while
  62  * a GSI channel carries data between the AP and the IPA, a pair of IPA
  63  * endpoints is used to carry traffic between two EEs.  Specifically, the main
  64  * modem network interface is implemented by two pairs of endpoints:  a TX
  65  * endpoint on the AP coupled with an RX endpoint on the modem; and another
  66  * RX endpoint on the AP receiving data from a TX endpoint on the modem.
  67  */
  68
  69 /* The name of the GSI firmware file relative to /lib/firmware */
  70 #define IPA_FWS_PATH            "ipa_fws.mdt"
  71 #define IPA_PAS_ID              15
  72
  73 /**
  74  * ipa_suspend_handler() - Handle the suspend IPA interrupt
  75  * @ipa:        IPA pointer
  76  * @irq_id:     IPA interrupt type (unused)
  77  *
  78  * If an RX endpoint is in suspend state, and the IPA has a packet
  79  * destined for that endpoint, the IPA generates a SUSPEND interrupt
  80  * to inform the AP that it should resume the endpoint.  If we get
  81  * one of these interrupts we just resume everything.
  82  */
  83 static void ipa_suspend_handler(struct ipa *ipa, enum ipa_irq_id irq_id)
  84 {
  85         /* Just report the event, and let system resume handle the rest.
  86          * More than one endpoint could signal this; if so, ignore
  87          * all but the first.
  88          */
  89         if (!test_and_set_bit(IPA_FLAG_RESUMED, ipa->flags))
  90                 pm_wakeup_dev_event(&ipa->pdev->dev, 0, true);
  91
  92         /* Acknowledge/clear the suspend interrupt on all endpoints */
  93         ipa_interrupt_suspend_clear_all(ipa->interrupt);
  94 }
  95
  96 /**
  97  * ipa_setup() - Set up IPA hardware
  98  * @ipa:        IPA pointer
  99  *
 100  * Perform initialization that requires issuing immediate commands on
 101  * the command TX endpoint.  If the modem is doing GSI firmware load
 102  * and initialization, this function will be called when an SMP2P
 103  * interrupt has been signaled by the modem.  Otherwise it will be
 104  * called from ipa_probe() after GSI firmware has been successfully
 105  * loaded, authenticated, and started by Trust Zone.
 106  */
 107 int ipa_setup(struct ipa *ipa)
 108 {
 109         struct ipa_endpoint *exception_endpoint;
 110         struct ipa_endpoint *command_endpoint;
 111         struct device *dev = &ipa->pdev->dev;
 112         int ret;
 113
 114         ret = gsi_setup(&ipa->gsi);
 115         if (ret)
 116                 return ret;
 117
 118         ipa->interrupt = ipa_interrupt_setup(ipa);
 119         if (IS_ERR(ipa->interrupt)) {
 120                 ret = PTR_ERR(ipa->interrupt);
 121                 goto err_gsi_teardown;
 122         }
 123         ipa_interrupt_add(ipa->interrupt, IPA_IRQ_TX_SUSPEND,
 124                           ipa_suspend_handler);
 125
 126         ipa_uc_setup(ipa);
 127
 128         ret = device_init_wakeup(dev, true);
 129         if (ret)
 130                 goto err_uc_teardown;
 131
 132         ipa_endpoint_setup(ipa);
 133
 134         /* We need to use the AP command TX endpoint to perform other
 135          * initialization, so we enable first.
 136          */
 137         command_endpoint = ipa->name_map[IPA_ENDPOINT_AP_COMMAND_TX];
 138         ret = ipa_endpoint_enable_one(command_endpoint);
 139         if (ret)
 140                 goto err_endpoint_teardown;
 141
 142         ret = ipa_mem_setup(ipa);
 143         if (ret)
 144                 goto err_command_disable;
 145
 146         ret = ipa_table_setup(ipa);
 147         if (ret)
 148                 goto err_mem_teardown;
 149
 150         /* Enable the exception handling endpoint, and tell the hardware
 151          * to use it by default.
 152          */
 153         exception_endpoint = ipa->name_map[IPA_ENDPOINT_AP_LAN_RX];
 154         ret = ipa_endpoint_enable_one(exception_endpoint);
 155         if (ret)
 156                 goto err_table_teardown;
 157
 158         ipa_endpoint_default_route_set(ipa, exception_endpoint->endpoint_id);
 159
 160         /* We're all set.  Now prepare for communication with the modem */
 161         ret = ipa_modem_setup(ipa);
 162         if (ret)
 163                 goto err_default_route_clear;
 164
 165         ipa->setup_complete = true;
 166
 167         dev_info(dev, "IPA driver setup completed successfully\n");
 168
 169         return 0;
 170
 171 err_default_route_clear:
 172         ipa_endpoint_default_route_clear(ipa);
 173         ipa_endpoint_disable_one(exception_endpoint);
 174 err_table_teardown:
 175         ipa_table_teardown(ipa);
 176 err_mem_teardown:
 177         ipa_mem_teardown(ipa);
 178 err_command_disable:
 179         ipa_endpoint_disable_one(command_endpoint);
 180 err_endpoint_teardown:
 181         ipa_endpoint_teardown(ipa);
 182         (void)device_init_wakeup(dev, false);
 183 err_uc_teardown:
 184         ipa_uc_teardown(ipa);
 185         ipa_interrupt_remove(ipa->interrupt, IPA_IRQ_TX_SUSPEND);
 186         ipa_interrupt_teardown(ipa->interrupt);
 187 err_gsi_teardown:
 188         gsi_teardown(&ipa->gsi);
 189
 190         return ret;
 191 }
 192
 193 /**
 194  * ipa_teardown() - Inverse of ipa_setup()
 195  * @ipa:        IPA pointer
 196  */
 197 static void ipa_teardown(struct ipa *ipa)
 198 {
 199         struct ipa_endpoint *exception_endpoint;
 200         struct ipa_endpoint *command_endpoint;
 201
 202         ipa_modem_teardown(ipa);
 203         ipa_endpoint_default_route_clear(ipa);
 204         exception_endpoint = ipa->name_map[IPA_ENDPOINT_AP_LAN_RX];
 205         ipa_endpoint_disable_one(exception_endpoint);
 206         ipa_table_teardown(ipa);
 207         ipa_mem_teardown(ipa);
 208         command_endpoint = ipa->name_map[IPA_ENDPOINT_AP_COMMAND_TX];
 209         ipa_endpoint_disable_one(command_endpoint);
 210         ipa_endpoint_teardown(ipa);
 211         (void)device_init_wakeup(&ipa->pdev->dev, false);
 212         ipa_uc_teardown(ipa);
 213         ipa_interrupt_remove(ipa->interrupt, IPA_IRQ_TX_SUSPEND);
 214         ipa_interrupt_teardown(ipa->interrupt);
 215         gsi_teardown(&ipa->gsi);
 216 }
 217
 218 /* Configure QMB Core Master Port selection */
 219 static void ipa_hardware_config_comp(struct ipa *ipa)
 220 {
 221         u32 val;
 222
 223         /* Nothing to configure for IPA v3.5.1 */
 224         if (ipa->version == IPA_VERSION_3_5_1)
 225                 return;
 226
 227         val = ioread32(ipa->reg_virt + IPA_REG_COMP_CFG_OFFSET);
 228
 229         if (ipa->version == IPA_VERSION_4_0) {
 230                 val &= ~IPA_QMB_SELECT_CONS_EN_FMASK;
 231                 val &= ~IPA_QMB_SELECT_PROD_EN_FMASK;
 232                 val &= ~IPA_QMB_SELECT_GLOBAL_EN_FMASK;
 233         } else  {
 234                 val |= GSI_MULTI_AXI_MASTERS_DIS_FMASK;
 235         }
 236
 237         val |= GSI_MULTI_INORDER_RD_DIS_FMASK;
 238         val |= GSI_MULTI_INORDER_WR_DIS_FMASK;
 239
 240         iowrite32(val, ipa->reg_virt + IPA_REG_COMP_CFG_OFFSET);
 241 }
 242
 243 /* Configure DDR and PCIe max read/write QSB values */
 244 static void ipa_hardware_config_qsb(struct ipa *ipa)
 245 {
 246         u32 val;
 247
 248         /* QMB_0 represents DDR; QMB_1 represents PCIe (not present in 4.2) */
 249         val = u32_encode_bits(8, GEN_QMB_0_MAX_WRITES_FMASK);
 250         if (ipa->version == IPA_VERSION_4_2)
 251                 val |= u32_encode_bits(0, GEN_QMB_1_MAX_WRITES_FMASK);
 252         else
 253                 val |= u32_encode_bits(4, GEN_QMB_1_MAX_WRITES_FMASK);
 254         iowrite32(val, ipa->reg_virt + IPA_REG_QSB_MAX_WRITES_OFFSET);
 255
 256         if (ipa->version == IPA_VERSION_3_5_1) {
 257                 val = u32_encode_bits(8, GEN_QMB_0_MAX_READS_FMASK);
 258                 val |= u32_encode_bits(12, GEN_QMB_1_MAX_READS_FMASK);
 259         } else {
 260                 val = u32_encode_bits(12, GEN_QMB_0_MAX_READS_FMASK);
 261                 if (ipa->version == IPA_VERSION_4_2)
 262                         val |= u32_encode_bits(0, GEN_QMB_1_MAX_READS_FMASK);
 263                 else
 264                         val |= u32_encode_bits(12, GEN_QMB_1_MAX_READS_FMASK);
 265                 /* GEN_QMB_0_MAX_READS_BEATS is 0 */
 266                 /* GEN_QMB_1_MAX_READS_BEATS is 0 */
 267         }
 268         iowrite32(val, ipa->reg_virt + IPA_REG_QSB_MAX_READS_OFFSET);
 269 }
 270
 271 static void ipa_idle_indication_cfg(struct ipa *ipa,
 272                                     u32 enter_idle_debounce_thresh,
 273                                     bool const_non_idle_enable)
 274 {
 275         u32 offset;
 276         u32 val;
 277
 278         val = u32_encode_bits(enter_idle_debounce_thresh,
 279                               ENTER_IDLE_DEBOUNCE_THRESH_FMASK);
 280         if (const_non_idle_enable)
 281                 val |= CONST_NON_IDLE_ENABLE_FMASK;
 282
 283         offset = ipa_reg_idle_indication_cfg_offset(ipa->version);
 284         iowrite32(val, ipa->reg_virt + offset);
 285 }
 286
 287 /**
 288  * ipa_hardware_dcd_config() - Enable dynamic clock division on IPA
 289  * @ipa:        IPA pointer
 290  *
 291  * Configures when the IPA signals it is idle to the global clock
 292  * controller, which can respond by scalling down the clock to
 293  * save power.
 294  */
 295 static void ipa_hardware_dcd_config(struct ipa *ipa)
 296 {
 297         /* Recommended values for IPA 3.5 according to IPA HPG */
 298         ipa_idle_indication_cfg(ipa, 256, false);
 299 }
 300
 301 static void ipa_hardware_dcd_deconfig(struct ipa *ipa)
 302 {
 303         /* Power-on reset values */
 304         ipa_idle_indication_cfg(ipa, 0, true);
 305 }
 306
 307 /**
 308  * ipa_hardware_config() - Primitive hardware initialization
 309  * @ipa:        IPA pointer
 310  */
 311 static void ipa_hardware_config(struct ipa *ipa)
 312 {
 313         enum ipa_version version = ipa->version;
 314         u32 granularity;
 315         u32 val;
 316
 317         /* IPA v4.5 has no backward compatibility register */
 318         if (version < IPA_VERSION_4_5) {
 319                 val = ipa_reg_bcr_val(version);
 320                 iowrite32(val, ipa->reg_virt + IPA_REG_BCR_OFFSET);
 321         }
 322
 323         if (version != IPA_VERSION_3_5_1) {
 324                 /* Enable open global clocks (hardware workaround) */
 325                 val = GLOBAL_FMASK;
 326                 val |= GLOBAL_2X_CLK_FMASK;
 327                 iowrite32(val, ipa->reg_virt + IPA_REG_CLKON_CFG_OFFSET);
 328
 329                 /* Disable PA mask to allow HOLB drop (hardware workaround) */
 330                 val = ioread32(ipa->reg_virt + IPA_REG_TX_CFG_OFFSET);
 331                 val &= ~PA_MASK_EN_FMASK;
 332                 iowrite32(val, ipa->reg_virt + IPA_REG_TX_CFG_OFFSET);
 333         }
 334
 335         ipa_hardware_config_comp(ipa);
 336
 337         /* Configure system bus limits */
 338         ipa_hardware_config_qsb(ipa);
 339
 340         /* Configure aggregation granularity */
 341         granularity = ipa_aggr_granularity_val(IPA_AGGR_GRANULARITY);
 342         val = u32_encode_bits(granularity, AGGR_GRANULARITY_FMASK);
 343         iowrite32(val, ipa->reg_virt + IPA_REG_COUNTER_CFG_OFFSET);
 344
 345         /* IPA v4.2 does not support hashed tables, so disable them */
 346         if (version == IPA_VERSION_4_2) {
 347                 u32 offset = ipa_reg_filt_rout_hash_en_offset(version);
 348
 349                 iowrite32(0, ipa->reg_virt + offset);
 350         }
 351
 352         /* Enable dynamic clock division */
 353         ipa_hardware_dcd_config(ipa);
 354 }
 355
 356 /**
 357  * ipa_hardware_deconfig() - Inverse of ipa_hardware_config()
 358  * @ipa:        IPA pointer
 359  *
 360  * This restores the power-on reset values (even if they aren't different)
 361  */
 362 static void ipa_hardware_deconfig(struct ipa *ipa)
 363 {
 364         /* Mostly we just leave things as we set them. */
 365         ipa_hardware_dcd_deconfig(ipa);
 366 }
 367
 368 #ifdef IPA_VALIDATION
 369
 370 static bool ipa_resource_limits_valid(struct ipa *ipa,
 371                                       const struct ipa_resource_data *data)
 372 {
 373         u32 group_count;
 374         u32 i;
 375         u32 j;
 376
 377         /* We program at most 6 source or destination resource group limits */
 378         BUILD_BUG_ON(IPA_RESOURCE_GROUP_SRC_MAX > 6);
 379
 380         group_count = ipa_resource_group_src_count(ipa->version);
 381         if (!group_count || group_count > IPA_RESOURCE_GROUP_SRC_MAX)
 382                 return false;
 383
 384         /* Return an error if a non-zero resource limit is specified
 385          * for a resource group not supported by hardware.
 386          */
 387         for (i = 0; i < data->resource_src_count; i++) {
 388                 const struct ipa_resource_src *resource;
 389
 390                 resource = &data->resource_src[i];
 391                 for (j = group_count; j < IPA_RESOURCE_GROUP_SRC_MAX; j++)
 392                         if (resource->limits[j].min || resource->limits[j].max)
 393                                 return false;
 394         }
 395
 396         group_count = ipa_resource_group_dst_count(ipa->version);
 397         if (!group_count || group_count > IPA_RESOURCE_GROUP_DST_MAX)
 398                 return false;
 399
 400         for (i = 0; i < data->resource_dst_count; i++) {
 401                 const struct ipa_resource_dst *resource;
 402
 403                 resource = &data->resource_dst[i];
 404                 for (j = group_count; j < IPA_RESOURCE_GROUP_DST_MAX; j++)
 405                         if (resource->limits[j].min || resource->limits[j].max)
 406                                 return false;
 407         }
 408
 409         return true;
 410 }
 411
 412 #else /* !IPA_VALIDATION */
 413
 414 static bool ipa_resource_limits_valid(struct ipa *ipa,
 415                                       const struct ipa_resource_data *data)
 416 {
 417         return true;
 418 }
 419
 420 #endif /* !IPA_VALIDATION */
 421
 422 static void
 423 ipa_resource_config_common(struct ipa *ipa, u32 offset,
 424                            const struct ipa_resource_limits *xlimits,
 425                            const struct ipa_resource_limits *ylimits)
 426 {
 427         u32 val;
 428
 429         val = u32_encode_bits(xlimits->min, X_MIN_LIM_FMASK);
 430         val |= u32_encode_bits(xlimits->max, X_MAX_LIM_FMASK);
 431         if (ylimits) {
 432                 val |= u32_encode_bits(ylimits->min, Y_MIN_LIM_FMASK);
 433                 val |= u32_encode_bits(ylimits->max, Y_MAX_LIM_FMASK);
 434         }
 435
 436         iowrite32(val, ipa->reg_virt + offset);
 437 }
 438
 439 static void ipa_resource_config_src(struct ipa *ipa,
 440                                     const struct ipa_resource_src *resource)
 441 {
 442         u32 group_count = ipa_resource_group_src_count(ipa->version);
 443         const struct ipa_resource_limits *ylimits;
 444         u32 offset;
 445
 446         offset = IPA_REG_SRC_RSRC_GRP_01_RSRC_TYPE_N_OFFSET(resource->type);
 447         ylimits = group_count == 1 ? NULL : &resource->limits[1];
 448         ipa_resource_config_common(ipa, offset, &resource->limits[0], ylimits);
 449
 450         if (group_count < 2)
 451                 return;
 452
 453         offset = IPA_REG_SRC_RSRC_GRP_23_RSRC_TYPE_N_OFFSET(resource->type);
 454         ylimits = group_count == 3 ? NULL : &resource->limits[3];
 455         ipa_resource_config_common(ipa, offset, &resource->limits[2], ylimits);
 456
 457         if (group_count < 4)
 458                 return;
 459
 460         offset = IPA_REG_SRC_RSRC_GRP_45_RSRC_TYPE_N_OFFSET(resource->type);
 461         ylimits = group_count == 5 ? NULL : &resource->limits[5];
 462         ipa_resource_config_common(ipa, offset, &resource->limits[4], ylimits);
 463 }
 464
 465 static void ipa_resource_config_dst(struct ipa *ipa,
 466                                     const struct ipa_resource_dst *resource)
 467 {
 468         u32 group_count = ipa_resource_group_dst_count(ipa->version);
 469         const struct ipa_resource_limits *ylimits;
 470         u32 offset;
 471
 472         offset = IPA_REG_DST_RSRC_GRP_01_RSRC_TYPE_N_OFFSET(resource->type);
 473         ylimits = group_count == 1 ? NULL : &resource->limits[1];
 474         ipa_resource_config_common(ipa, offset, &resource->limits[0], ylimits);
 475
 476         if (group_count < 2)
 477                 return;
 478
 479         offset = IPA_REG_DST_RSRC_GRP_23_RSRC_TYPE_N_OFFSET(resource->type);
 480         ylimits = group_count == 3 ? NULL : &resource->limits[3];
 481         ipa_resource_config_common(ipa, offset, &resource->limits[2], ylimits);
 482
 483         if (group_count < 4)
 484                 return;
 485
 486         offset = IPA_REG_DST_RSRC_GRP_45_RSRC_TYPE_N_OFFSET(resource->type);
 487         ylimits = group_count == 5 ? NULL : &resource->limits[5];
 488         ipa_resource_config_common(ipa, offset, &resource->limits[4], ylimits);
 489 }
 490
 491 static int
 492 ipa_resource_config(struct ipa *ipa, const struct ipa_resource_data *data)
 493 {
 494         u32 i;
 495
 496         if (!ipa_resource_limits_valid(ipa, data))
 497                 return -EINVAL;
 498
 499         for (i = 0; i < data->resource_src_count; i++)
 500                 ipa_resource_config_src(ipa, data->resource_src);
 501
 502         for (i = 0; i < data->resource_dst_count; i++)
 503                 ipa_resource_config_dst(ipa, data->resource_dst);
 504
 505         return 0;
 506 }
 507
 508 static void ipa_resource_deconfig(struct ipa *ipa)
 509 {
 510         /* Nothing to do */
 511 }
 512
 513 /**
 514  * ipa_config() - Configure IPA hardware
 515  * @ipa:        IPA pointer
 516  * @data:       IPA configuration data
 517  *
 518  * Perform initialization requiring IPA clock to be enabled.
 519  */
 520 static int ipa_config(struct ipa *ipa, const struct ipa_data *data)
 521 {
 522         int ret;
 523
 524         /* Get a clock reference to allow initialization.  This reference
 525          * is held after initialization completes, and won't get dropped
 526          * unless/until a system suspend request arrives.
 527          */
 528         ipa_clock_get(ipa);
 529
 530         ipa_hardware_config(ipa);
 531
 532         ret = ipa_endpoint_config(ipa);
 533         if (ret)
 534                 goto err_hardware_deconfig;
 535
 536         ret = ipa_mem_config(ipa);
 537         if (ret)
 538                 goto err_endpoint_deconfig;
 539
 540         ipa_table_config(ipa);
 541
 542         /* Assign resource limitation to each group */
 543         ret = ipa_resource_config(ipa, data->resource_data);
 544         if (ret)
 545                 goto err_table_deconfig;
 546
 547         ret = ipa_modem_config(ipa);
 548         if (ret)
 549                 goto err_resource_deconfig;
 550
 551         return 0;
 552
 553 err_resource_deconfig:
 554         ipa_resource_deconfig(ipa);
 555 err_table_deconfig:
 556         ipa_table_deconfig(ipa);
 557         ipa_mem_deconfig(ipa);
 558 err_endpoint_deconfig:
 559         ipa_endpoint_deconfig(ipa);
 560 err_hardware_deconfig:
 561         ipa_hardware_deconfig(ipa);
 562         ipa_clock_put(ipa);
 563
 564         return ret;
 565 }
 566
 567 /**
 568  * ipa_deconfig() - Inverse of ipa_config()
 569  * @ipa:        IPA pointer
 570  */
 571 static void ipa_deconfig(struct ipa *ipa)
 572 {
 573         ipa_modem_deconfig(ipa);
 574         ipa_resource_deconfig(ipa);
 575         ipa_table_deconfig(ipa);
 576         ipa_mem_deconfig(ipa);
 577         ipa_endpoint_deconfig(ipa);
 578         ipa_hardware_deconfig(ipa);
 579         ipa_clock_put(ipa);
 580 }
 581
 582 static int ipa_firmware_load(struct device *dev)
 583 {
 584         const struct firmware *fw;
 585         struct device_node *node;
 586         struct resource res;
 587         phys_addr_t phys;
 588         ssize_t size;
 589         void *virt;
 590         int ret;
 591
 592         node = of_parse_phandle(dev->of_node, "memory-region", 0);
 593         if (!node) {
 594                 dev_err(dev, "DT error getting \"memory-region\" property\n");
 595                 return -EINVAL;
 596         }
 597
 598         ret = of_address_to_resource(node, 0, &res);
 599         if (ret) {
 600                 dev_err(dev, "error %d getting \"memory-region\" resource\n",
 601                         ret);
 602                 return ret;
 603         }
 604
 605         ret = request_firmware(&fw, IPA_FWS_PATH, dev);
 606         if (ret) {
 607                 dev_err(dev, "error %d requesting \"%s\"\n", ret, IPA_FWS_PATH);
 608                 return ret;
 609         }
 610
 611         phys = res.start;
 612         size = (size_t)resource_size(&res);
 613         virt = memremap(phys, size, MEMREMAP_WC);
 614         if (!virt) {
 615                 dev_err(dev, "unable to remap firmware memory\n");
 616                 ret = -ENOMEM;
 617                 goto out_release_firmware;
 618         }
 619
 620         ret = qcom_mdt_load(dev, fw, IPA_FWS_PATH, IPA_PAS_ID,
 621                             virt, phys, size, NULL);
 622         if (ret)
 623                 dev_err(dev, "error %d loading \"%s\"\n", ret, IPA_FWS_PATH);
 624         else if ((ret = qcom_scm_pas_auth_and_reset(IPA_PAS_ID)))
 625                 dev_err(dev, "error %d authenticating \"%s\"\n", ret,
 626                         IPA_FWS_PATH);
 627
 628         memunmap(virt);
 629 out_release_firmware:
 630         release_firmware(fw);
 631
 632         return ret;
 633 }
 634
 635 static const struct of_device_id ipa_match[] = {
 636         {
 637                 .compatible     = "qcom,sdm845-ipa",
 638                 .data           = &ipa_data_sdm845,
 639         },
 640         {
 641                 .compatible     = "qcom,sc7180-ipa",
 642                 .data           = &ipa_data_sc7180,
 643         },
 644         { },
 645 };
 646 MODULE_DEVICE_TABLE(of, ipa_match);
 647
 648 static phandle of_property_read_phandle(const struct device_node *np,
 649                                         const char *name)
 650 {
 651         struct property *prop;
 652         int len = 0;
 653
 654         prop = of_find_property(np, name, &len);
 655         if (!prop || len != sizeof(__be32))
 656                 return 0;
 657
 658         return be32_to_cpup(prop->value);
 659 }
 660
 661 /* Check things that can be validated at build time.  This just
 662  * groups these things BUILD_BUG_ON() calls don't clutter the rest
 663  * of the code.
 664  * */
 665 static void ipa_validate_build(void)
 666 {
 667 #ifdef IPA_VALIDATE
 668         /* We assume we're working on 64-bit hardware */
 669         BUILD_BUG_ON(!IS_ENABLED(CONFIG_64BIT));
 670
 671         /* Code assumes the EE ID for the AP is 0 (zeroed structure field) */
 672         BUILD_BUG_ON(GSI_EE_AP != 0);
 673
 674         /* There's no point if we have no channels or event rings */
 675         BUILD_BUG_ON(!GSI_CHANNEL_COUNT_MAX);
 676         BUILD_BUG_ON(!GSI_EVT_RING_COUNT_MAX);
 677
 678         /* GSI hardware design limits */
 679         BUILD_BUG_ON(GSI_CHANNEL_COUNT_MAX > 32);
 680         BUILD_BUG_ON(GSI_EVT_RING_COUNT_MAX > 31);
 681
 682         /* The number of TREs in a transaction is limited by the channel's
 683          * TLV FIFO size.  A transaction structure uses 8-bit fields
 684          * to represents the number of TREs it has allocated and used.
 685          */
 686         BUILD_BUG_ON(GSI_TLV_MAX > U8_MAX);
 687
 688         /* This is used as a divisor */
 689         BUILD_BUG_ON(!IPA_AGGR_GRANULARITY);
 690
 691         /* Aggregation granularity value can't be 0, and must fit */
 692         BUILD_BUG_ON(!ipa_aggr_granularity_val(IPA_AGGR_GRANULARITY));
 693         BUILD_BUG_ON(ipa_aggr_granularity_val(IPA_AGGR_GRANULARITY) >
 694                         field_max(AGGR_GRANULARITY_FMASK));
 695 #endif /* IPA_VALIDATE */
 696 }
 697
 698 /**
 699  * ipa_probe() - IPA platform driver probe function
 700  * @pdev:       Platform device pointer
 701  *
 702  * Return:      0 if successful, or a negative error code (possibly
 703  *              EPROBE_DEFER)
 704  *
 705  * This is the main entry point for the IPA driver.  Initialization proceeds
 706  * in several stages:
 707  *   - The "init" stage involves activities that can be initialized without
 708  *     access to the IPA hardware.
 709  *   - The "config" stage requires the IPA clock to be active so IPA registers
 710  *     can be accessed, but does not require the use of IPA immediate commands.
 711  *   - The "setup" stage uses IPA immediate commands, and so requires the GSI
 712  *     layer to be initialized.
 713  *
 714  * A Boolean Device Tree "modem-init" property determines whether GSI
 715  * initialization will be performed by the AP (Trust Zone) or the modem.
 716  * If the AP does GSI initialization, the setup phase is entered after
 717  * this has completed successfully.  Otherwise the modem initializes
 718  * the GSI layer and signals it has finished by sending an SMP2P interrupt
 719  * to the AP; this triggers the start if IPA setup.
 720  */
 721 static int ipa_probe(struct platform_device *pdev)
 722 {
 723         struct device *dev = &pdev->dev;
 724         const struct ipa_data *data;
 725         struct ipa_clock *clock;
 726         struct rproc *rproc;
 727         bool modem_init;
 728         struct ipa *ipa;
 729         phandle ph;
 730         int ret;
 731
 732         ipa_validate_build();
 733
 734         /* Get configuration data early; needed for clock initialization */
 735         data = of_device_get_match_data(dev);
 736         if (!data) {
 737                 /* This is really IPA_VALIDATE (should never happen) */
 738                 dev_err(dev, "matched hardware not supported\n");
 739                 return -ENODEV;
 740         }
 741
 742         /* If we need Trust Zone, make sure it's available */
 743         modem_init = of_property_read_bool(dev->of_node, "modem-init");
 744         if (!modem_init)
 745                 if (!qcom_scm_is_available())
 746                         return -EPROBE_DEFER;
 747
 748         /* We rely on remoteproc to tell us about modem state changes */
 749         ph = of_property_read_phandle(dev->of_node, "modem-remoteproc");
 750         if (!ph) {
 751                 dev_err(dev, "DT missing \"modem-remoteproc\" property\n");
 752                 return -EINVAL;
 753         }
 754
 755         rproc = rproc_get_by_phandle(ph);
 756         if (!rproc)
 757                 return -EPROBE_DEFER;
 758
 759         /* The clock and interconnects might not be ready when we're
 760          * probed, so might return -EPROBE_DEFER.
 761          */
 762         clock = ipa_clock_init(dev, data->clock_data);
 763         if (IS_ERR(clock)) {
 764                 ret = PTR_ERR(clock);
 765                 goto err_rproc_put;
 766         }
 767
 768         /* No more EPROBE_DEFER.  Allocate and initialize the IPA structure */
 769         ipa = kzalloc(sizeof(*ipa), GFP_KERNEL);
 770         if (!ipa) {
 771                 ret = -ENOMEM;
 772                 goto err_clock_exit;
 773         }
 774
 775         ipa->pdev = pdev;
 776         dev_set_drvdata(dev, ipa);
 777         ipa->modem_rproc = rproc;
 778         ipa->clock = clock;
 779         ipa->version = data->version;
 780
 781         ret = ipa_reg_init(ipa);
 782         if (ret)
 783                 goto err_kfree_ipa;
 784
 785         ret = ipa_mem_init(ipa, data->mem_data);
 786         if (ret)
 787                 goto err_reg_exit;
 788
 789         ret = gsi_init(&ipa->gsi, pdev, ipa->version, data->endpoint_count,
 790                        data->endpoint_data);
 791         if (ret)
 792                 goto err_mem_exit;
 793
 794         /* Result is a non-zero mask of endpoints that support filtering */
 795         ipa->filter_map = ipa_endpoint_init(ipa, data->endpoint_count,
 796                                             data->endpoint_data);
 797         if (!ipa->filter_map) {
 798                 ret = -EINVAL;
 799                 goto err_gsi_exit;
 800         }
 801
 802         ret = ipa_table_init(ipa);
 803         if (ret)
 804                 goto err_endpoint_exit;
 805
 806         ret = ipa_modem_init(ipa, modem_init);
 807         if (ret)
 808                 goto err_table_exit;
 809
 810         ret = ipa_config(ipa, data);
 811         if (ret)
 812                 goto err_modem_exit;
 813
 814         dev_info(dev, "IPA driver initialized");
 815
 816         /* If the modem is doing early initialization, it will trigger a
 817          * call to ipa_setup() call when it has finished.  In that case
 818          * we're done here.
 819          */
 820         if (modem_init)
 821                 return 0;
 822
 823         /* Otherwise we need to load the firmware and have Trust Zone validate
 824          * and install it.  If that succeeds we can proceed with setup.
 825          */
 826         ret = ipa_firmware_load(dev);
 827         if (ret)
 828                 goto err_deconfig;
 829
 830         ret = ipa_setup(ipa);
 831         if (ret)
 832                 goto err_deconfig;
 833
 834         return 0;
 835
 836 err_deconfig:
 837         ipa_deconfig(ipa);
 838 err_modem_exit:
 839         ipa_modem_exit(ipa);
 840 err_table_exit:
 841         ipa_table_exit(ipa);
 842 err_endpoint_exit:
 843         ipa_endpoint_exit(ipa);
 844 err_gsi_exit:
 845         gsi_exit(&ipa->gsi);
 846 err_mem_exit:
 847         ipa_mem_exit(ipa);
 848 err_reg_exit:
 849         ipa_reg_exit(ipa);
 850 err_kfree_ipa:
 851         kfree(ipa);
 852 err_clock_exit:
 853         ipa_clock_exit(clock);
 854 err_rproc_put:
 855         rproc_put(rproc);
 856
 857         return ret;
 858 }
 859
 860 static int ipa_remove(struct platform_device *pdev)
 861 {
 862         struct ipa *ipa = dev_get_drvdata(&pdev->dev);
 863         struct rproc *rproc = ipa->modem_rproc;
 864         struct ipa_clock *clock = ipa->clock;
 865         int ret;
 866
 867         if (ipa->setup_complete) {
 868                 ret = ipa_modem_stop(ipa);
 869                 /* If starting or stopping is in progress, try once more */
 870                 if (ret == -EBUSY) {
 871                         usleep_range(USEC_PER_MSEC, 2 * USEC_PER_MSEC);
 872                         ret = ipa_modem_stop(ipa);
 873                 }
 874                 if (ret)
 875                         return ret;
 876
 877                 ipa_teardown(ipa);
 878         }
 879
 880         ipa_deconfig(ipa);
 881         ipa_modem_exit(ipa);
 882         ipa_table_exit(ipa);
 883         ipa_endpoint_exit(ipa);
 884         gsi_exit(&ipa->gsi);
 885         ipa_mem_exit(ipa);
 886         ipa_reg_exit(ipa);
 887         kfree(ipa);
 888         ipa_clock_exit(clock);
 889         rproc_put(rproc);
 890
 891         return 0;
 892 }
 893
 894 static void ipa_shutdown(struct platform_device *pdev)
 895 {
 896         int ret;
 897
 898         ret = ipa_remove(pdev);
 899         if (ret)
 900                 dev_err(&pdev->dev, "shutdown: remove returned %d\n", ret);
 901 }
 902
 903 /**
 904  * ipa_suspend() - Power management system suspend callback
 905  * @dev:        IPA device structure
 906  *
 907  * Return:      Always returns zero
 908  *
 909  * Called by the PM framework when a system suspend operation is invoked.
 910  * Suspends endpoints and releases the clock reference held to keep
 911  * the IPA clock running until this point.
 912  */
 913 static int ipa_suspend(struct device *dev)
 914 {
 915         struct ipa *ipa = dev_get_drvdata(dev);
 916
 917         /* When a suspended RX endpoint has a packet ready to receive, we
 918          * get an IPA SUSPEND interrupt.  We trigger a system resume in
 919          * that case, but only on the first such interrupt since suspend.
 920          */
 921         __clear_bit(IPA_FLAG_RESUMED, ipa->flags);
 922
 923         ipa_endpoint_suspend(ipa);
 924
 925         ipa_clock_put(ipa);
 926
 927         return 0;
 928 }
 929
 930 /**
 931  * ipa_resume() - Power management system resume callback
 932  * @dev:        IPA device structure
 933  *
 934  * Return:      Always returns 0
 935  *
 936  * Called by the PM framework when a system resume operation is invoked.
 937  * Takes an IPA clock reference to keep the clock running until suspend,
 938  * and resumes endpoints.
 939  */
 940 static int ipa_resume(struct device *dev)
 941 {
 942         struct ipa *ipa = dev_get_drvdata(dev);
 943
 944         /* This clock reference will keep the IPA out of suspend
 945          * until we get a power management suspend request.
 946          */
 947         ipa_clock_get(ipa);
 948
 949         ipa_endpoint_resume(ipa);
 950
 951         return 0;
 952 }
 953
 954 static const struct dev_pm_ops ipa_pm_ops = {
 955         .suspend        = ipa_suspend,
 956         .resume         = ipa_resume,
 957 };
 958
 959 static struct platform_driver ipa_driver = {
 960         .probe          = ipa_probe,
 961         .remove         = ipa_remove,
 962         .shutdown       = ipa_shutdown,
 963         .driver = {
 964                 .name           = "ipa",
 965                 .pm             = &ipa_pm_ops,
 966                 .of_match_table = ipa_match,
 967         },
 968 };
 969
 970 module_platform_driver(ipa_driver);
 971
 972 MODULE_LICENSE("GPL v2");
 973 MODULE_DESCRIPTION("Qualcomm IP Accelerator device driver");