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         u32 granularity;
 314         u32 val;
 315
 316         /* Fill in backward-compatibility register, based on version */
 317         val = ipa_reg_bcr_val(ipa->version);
 318         iowrite32(val, ipa->reg_virt + IPA_REG_BCR_OFFSET);
 319
 320         if (ipa->version != IPA_VERSION_3_5_1) {
 321                 /* Enable open global clocks (hardware workaround) */
 322                 val = GLOBAL_FMASK;
 323                 val |= GLOBAL_2X_CLK_FMASK;
 324                 iowrite32(val, ipa->reg_virt + IPA_REG_CLKON_CFG_OFFSET);
 325
 326                 /* Disable PA mask to allow HOLB drop (hardware workaround) */
 327                 val = ioread32(ipa->reg_virt + IPA_REG_TX_CFG_OFFSET);
 328                 val &= ~PA_MASK_EN;
 329                 iowrite32(val, ipa->reg_virt + IPA_REG_TX_CFG_OFFSET);
 330         }
 331
 332         ipa_hardware_config_comp(ipa);
 333
 334         /* Configure system bus limits */
 335         ipa_hardware_config_qsb(ipa);
 336
 337         /* Configure aggregation granularity */
 338         val = ioread32(ipa->reg_virt + IPA_REG_COUNTER_CFG_OFFSET);
 339         granularity = ipa_aggr_granularity_val(IPA_AGGR_GRANULARITY);
 340         val = u32_encode_bits(granularity, AGGR_GRANULARITY);
 341         iowrite32(val, ipa->reg_virt + IPA_REG_COUNTER_CFG_OFFSET);
 342
 343         /* Disable hashed IPv4 and IPv6 routing and filtering for IPA v4.2 */
 344         if (ipa->version == IPA_VERSION_4_2)
 345                 iowrite32(0, ipa->reg_virt + IPA_REG_FILT_ROUT_HASH_EN_OFFSET);
 346
 347         /* Enable dynamic clock division */
 348         ipa_hardware_dcd_config(ipa);
 349 }
 350
 351 /**
 352  * ipa_hardware_deconfig() - Inverse of ipa_hardware_config()
 353  * @ipa:        IPA pointer
 354  *
 355  * This restores the power-on reset values (even if they aren't different)
 356  */
 357 static void ipa_hardware_deconfig(struct ipa *ipa)
 358 {
 359         /* Mostly we just leave things as we set them. */
 360         ipa_hardware_dcd_deconfig(ipa);
 361 }
 362
 363 #ifdef IPA_VALIDATION
 364
 365 static bool ipa_resource_limits_valid(struct ipa *ipa,
 366                                       const struct ipa_resource_data *data)
 367 {
 368         u32 group_count;
 369         u32 i;
 370         u32 j;
 371
 372         /* We program at most 6 source or destination resource group limits */
 373         BUILD_BUG_ON(IPA_RESOURCE_GROUP_SRC_MAX > 6);
 374
 375         group_count = ipa_resource_group_src_count(ipa->version);
 376         if (!group_count || group_count > IPA_RESOURCE_GROUP_SRC_MAX)
 377                 return false;
 378
 379         /* Return an error if a non-zero resource limit is specified
 380          * for a resource group not supported by hardware.
 381          */
 382         for (i = 0; i < data->resource_src_count; i++) {
 383                 const struct ipa_resource_src *resource;
 384
 385                 resource = &data->resource_src[i];
 386                 for (j = group_count; j < IPA_RESOURCE_GROUP_SRC_MAX; j++)
 387                         if (resource->limits[j].min || resource->limits[j].max)
 388                                 return false;
 389         }
 390
 391         group_count = ipa_resource_group_dst_count(ipa->version);
 392         if (!group_count || group_count > IPA_RESOURCE_GROUP_DST_MAX)
 393                 return false;
 394
 395         for (i = 0; i < data->resource_dst_count; i++) {
 396                 const struct ipa_resource_dst *resource;
 397
 398                 resource = &data->resource_dst[i];
 399                 for (j = group_count; j < IPA_RESOURCE_GROUP_DST_MAX; j++)
 400                         if (resource->limits[j].min || resource->limits[j].max)
 401                                 return false;
 402         }
 403
 404         return true;
 405 }
 406
 407 #else /* !IPA_VALIDATION */
 408
 409 static bool ipa_resource_limits_valid(struct ipa *ipa,
 410                                       const struct ipa_resource_data *data)
 411 {
 412         return true;
 413 }
 414
 415 #endif /* !IPA_VALIDATION */
 416
 417 static void
 418 ipa_resource_config_common(struct ipa *ipa, u32 offset,
 419                            const struct ipa_resource_limits *xlimits,
 420                            const struct ipa_resource_limits *ylimits)
 421 {
 422         u32 val;
 423
 424         val = u32_encode_bits(xlimits->min, X_MIN_LIM_FMASK);
 425         val |= u32_encode_bits(xlimits->max, X_MAX_LIM_FMASK);
 426         if (ylimits) {
 427                 val |= u32_encode_bits(ylimits->min, Y_MIN_LIM_FMASK);
 428                 val |= u32_encode_bits(ylimits->max, Y_MAX_LIM_FMASK);
 429         }
 430
 431         iowrite32(val, ipa->reg_virt + offset);
 432 }
 433
 434 static void ipa_resource_config_src(struct ipa *ipa,
 435                                     const struct ipa_resource_src *resource)
 436 {
 437         u32 group_count = ipa_resource_group_src_count(ipa->version);
 438         const struct ipa_resource_limits *ylimits;
 439         u32 offset;
 440
 441         offset = IPA_REG_SRC_RSRC_GRP_01_RSRC_TYPE_N_OFFSET(resource->type);
 442         ylimits = group_count == 1 ? NULL : &resource->limits[1];
 443         ipa_resource_config_common(ipa, offset, &resource->limits[0], ylimits);
 444
 445         if (group_count < 2)
 446                 return;
 447
 448         offset = IPA_REG_SRC_RSRC_GRP_23_RSRC_TYPE_N_OFFSET(resource->type);
 449         ylimits = group_count == 3 ? NULL : &resource->limits[3];
 450         ipa_resource_config_common(ipa, offset, &resource->limits[2], ylimits);
 451
 452         if (group_count < 4)
 453                 return;
 454
 455         offset = IPA_REG_SRC_RSRC_GRP_45_RSRC_TYPE_N_OFFSET(resource->type);
 456         ylimits = group_count == 5 ? NULL : &resource->limits[5];
 457         ipa_resource_config_common(ipa, offset, &resource->limits[4], ylimits);
 458 }
 459
 460 static void ipa_resource_config_dst(struct ipa *ipa,
 461                                     const struct ipa_resource_dst *resource)
 462 {
 463         u32 group_count = ipa_resource_group_dst_count(ipa->version);
 464         const struct ipa_resource_limits *ylimits;
 465         u32 offset;
 466
 467         offset = IPA_REG_DST_RSRC_GRP_01_RSRC_TYPE_N_OFFSET(resource->type);
 468         ylimits = group_count == 1 ? NULL : &resource->limits[1];
 469         ipa_resource_config_common(ipa, offset, &resource->limits[0], ylimits);
 470
 471         if (group_count < 2)
 472                 return;
 473
 474         offset = IPA_REG_DST_RSRC_GRP_23_RSRC_TYPE_N_OFFSET(resource->type);
 475         ylimits = group_count == 3 ? NULL : &resource->limits[3];
 476         ipa_resource_config_common(ipa, offset, &resource->limits[2], ylimits);
 477
 478         if (group_count < 4)
 479                 return;
 480
 481         offset = IPA_REG_DST_RSRC_GRP_45_RSRC_TYPE_N_OFFSET(resource->type);
 482         ylimits = group_count == 5 ? NULL : &resource->limits[5];
 483         ipa_resource_config_common(ipa, offset, &resource->limits[4], ylimits);
 484 }
 485
 486 static int
 487 ipa_resource_config(struct ipa *ipa, const struct ipa_resource_data *data)
 488 {
 489         u32 i;
 490
 491         if (!ipa_resource_limits_valid(ipa, data))
 492                 return -EINVAL;
 493
 494         for (i = 0; i < data->resource_src_count; i++)
 495                 ipa_resource_config_src(ipa, data->resource_src);
 496
 497         for (i = 0; i < data->resource_dst_count; i++)
 498                 ipa_resource_config_dst(ipa, data->resource_dst);
 499
 500         return 0;
 501 }
 502
 503 static void ipa_resource_deconfig(struct ipa *ipa)
 504 {
 505         /* Nothing to do */
 506 }
 507
 508 /**
 509  * ipa_config() - Configure IPA hardware
 510  * @ipa:        IPA pointer
 511  * @data:       IPA configuration data
 512  *
 513  * Perform initialization requiring IPA clock to be enabled.
 514  */
 515 static int ipa_config(struct ipa *ipa, const struct ipa_data *data)
 516 {
 517         int ret;
 518
 519         /* Get a clock reference to allow initialization.  This reference
 520          * is held after initialization completes, and won't get dropped
 521          * unless/until a system suspend request arrives.
 522          */
 523         ipa_clock_get(ipa);
 524
 525         ipa_hardware_config(ipa);
 526
 527         ret = ipa_endpoint_config(ipa);
 528         if (ret)
 529                 goto err_hardware_deconfig;
 530
 531         ret = ipa_mem_config(ipa);
 532         if (ret)
 533                 goto err_endpoint_deconfig;
 534
 535         ipa_table_config(ipa);
 536
 537         /* Assign resource limitation to each group */
 538         ret = ipa_resource_config(ipa, data->resource_data);
 539         if (ret)
 540                 goto err_table_deconfig;
 541
 542         ret = ipa_modem_config(ipa);
 543         if (ret)
 544                 goto err_resource_deconfig;
 545
 546         return 0;
 547
 548 err_resource_deconfig:
 549         ipa_resource_deconfig(ipa);
 550 err_table_deconfig:
 551         ipa_table_deconfig(ipa);
 552         ipa_mem_deconfig(ipa);
 553 err_endpoint_deconfig:
 554         ipa_endpoint_deconfig(ipa);
 555 err_hardware_deconfig:
 556         ipa_hardware_deconfig(ipa);
 557         ipa_clock_put(ipa);
 558
 559         return ret;
 560 }
 561
 562 /**
 563  * ipa_deconfig() - Inverse of ipa_config()
 564  * @ipa:        IPA pointer
 565  */
 566 static void ipa_deconfig(struct ipa *ipa)
 567 {
 568         ipa_modem_deconfig(ipa);
 569         ipa_resource_deconfig(ipa);
 570         ipa_table_deconfig(ipa);
 571         ipa_mem_deconfig(ipa);
 572         ipa_endpoint_deconfig(ipa);
 573         ipa_hardware_deconfig(ipa);
 574         ipa_clock_put(ipa);
 575 }
 576
 577 static int ipa_firmware_load(struct device *dev)
 578 {
 579         const struct firmware *fw;
 580         struct device_node *node;
 581         struct resource res;
 582         phys_addr_t phys;
 583         ssize_t size;
 584         void *virt;
 585         int ret;
 586
 587         node = of_parse_phandle(dev->of_node, "memory-region", 0);
 588         if (!node) {
 589                 dev_err(dev, "DT error getting \"memory-region\" property\n");
 590                 return -EINVAL;
 591         }
 592
 593         ret = of_address_to_resource(node, 0, &res);
 594         if (ret) {
 595                 dev_err(dev, "error %d getting \"memory-region\" resource\n",
 596                         ret);
 597                 return ret;
 598         }
 599
 600         ret = request_firmware(&fw, IPA_FWS_PATH, dev);
 601         if (ret) {
 602                 dev_err(dev, "error %d requesting \"%s\"\n", ret, IPA_FWS_PATH);
 603                 return ret;
 604         }
 605
 606         phys = res.start;
 607         size = (size_t)resource_size(&res);
 608         virt = memremap(phys, size, MEMREMAP_WC);
 609         if (!virt) {
 610                 dev_err(dev, "unable to remap firmware memory\n");
 611                 ret = -ENOMEM;
 612                 goto out_release_firmware;
 613         }
 614
 615         ret = qcom_mdt_load(dev, fw, IPA_FWS_PATH, IPA_PAS_ID,
 616                             virt, phys, size, NULL);
 617         if (ret)
 618                 dev_err(dev, "error %d loading \"%s\"\n", ret, IPA_FWS_PATH);
 619         else if ((ret = qcom_scm_pas_auth_and_reset(IPA_PAS_ID)))
 620                 dev_err(dev, "error %d authenticating \"%s\"\n", ret,
 621                         IPA_FWS_PATH);
 622
 623         memunmap(virt);
 624 out_release_firmware:
 625         release_firmware(fw);
 626
 627         return ret;
 628 }
 629
 630 static const struct of_device_id ipa_match[] = {
 631         {
 632                 .compatible     = "qcom,sdm845-ipa",
 633                 .data           = &ipa_data_sdm845,
 634         },
 635         {
 636                 .compatible     = "qcom,sc7180-ipa",
 637                 .data           = &ipa_data_sc7180,
 638         },
 639         { },
 640 };
 641 MODULE_DEVICE_TABLE(of, ipa_match);
 642
 643 static phandle of_property_read_phandle(const struct device_node *np,
 644                                         const char *name)
 645 {
 646         struct property *prop;
 647         int len = 0;
 648
 649         prop = of_find_property(np, name, &len);
 650         if (!prop || len != sizeof(__be32))
 651                 return 0;
 652
 653         return be32_to_cpup(prop->value);
 654 }
 655
 656 /* Check things that can be validated at build time.  This just
 657  * groups these things BUILD_BUG_ON() calls don't clutter the rest
 658  * of the code.
 659  * */
 660 static void ipa_validate_build(void)
 661 {
 662 #ifdef IPA_VALIDATE
 663         /* We assume we're working on 64-bit hardware */
 664         BUILD_BUG_ON(!IS_ENABLED(CONFIG_64BIT));
 665
 666         /* Code assumes the EE ID for the AP is 0 (zeroed structure field) */
 667         BUILD_BUG_ON(GSI_EE_AP != 0);
 668
 669         /* There's no point if we have no channels or event rings */
 670         BUILD_BUG_ON(!GSI_CHANNEL_COUNT_MAX);
 671         BUILD_BUG_ON(!GSI_EVT_RING_COUNT_MAX);
 672
 673         /* GSI hardware design limits */
 674         BUILD_BUG_ON(GSI_CHANNEL_COUNT_MAX > 32);
 675         BUILD_BUG_ON(GSI_EVT_RING_COUNT_MAX > 31);
 676
 677         /* The number of TREs in a transaction is limited by the channel's
 678          * TLV FIFO size.  A transaction structure uses 8-bit fields
 679          * to represents the number of TREs it has allocated and used.
 680          */
 681         BUILD_BUG_ON(GSI_TLV_MAX > U8_MAX);
 682
 683         /* This is used as a divisor */
 684         BUILD_BUG_ON(!IPA_AGGR_GRANULARITY);
 685
 686         /* Aggregation granularity value can't be 0, and must fit */
 687         BUILD_BUG_ON(!ipa_aggr_granularity_val(IPA_AGGR_GRANULARITY));
 688         BUILD_BUG_ON(ipa_aggr_granularity_val(IPA_AGGR_GRANULARITY) >
 689                         field_max(AGGR_GRANULARITY));
 690 #endif /* IPA_VALIDATE */
 691 }
 692
 693 /**
 694  * ipa_probe() - IPA platform driver probe function
 695  * @pdev:       Platform device pointer
 696  *
 697  * Return:      0 if successful, or a negative error code (possibly
 698  *              EPROBE_DEFER)
 699  *
 700  * This is the main entry point for the IPA driver.  Initialization proceeds
 701  * in several stages:
 702  *   - The "init" stage involves activities that can be initialized without
 703  *     access to the IPA hardware.
 704  *   - The "config" stage requires the IPA clock to be active so IPA registers
 705  *     can be accessed, but does not require the use of IPA immediate commands.
 706  *   - The "setup" stage uses IPA immediate commands, and so requires the GSI
 707  *     layer to be initialized.
 708  *
 709  * A Boolean Device Tree "modem-init" property determines whether GSI
 710  * initialization will be performed by the AP (Trust Zone) or the modem.
 711  * If the AP does GSI initialization, the setup phase is entered after
 712  * this has completed successfully.  Otherwise the modem initializes
 713  * the GSI layer and signals it has finished by sending an SMP2P interrupt
 714  * to the AP; this triggers the start if IPA setup.
 715  */
 716 static int ipa_probe(struct platform_device *pdev)
 717 {
 718         struct device *dev = &pdev->dev;
 719         const struct ipa_data *data;
 720         struct ipa_clock *clock;
 721         struct rproc *rproc;
 722         bool modem_init;
 723         struct ipa *ipa;
 724         phandle ph;
 725         int ret;
 726
 727         ipa_validate_build();
 728
 729         /* If we need Trust Zone, make sure it's available */
 730         modem_init = of_property_read_bool(dev->of_node, "modem-init");
 731         if (!modem_init)
 732                 if (!qcom_scm_is_available())
 733                         return -EPROBE_DEFER;
 734
 735         /* We rely on remoteproc to tell us about modem state changes */
 736         ph = of_property_read_phandle(dev->of_node, "modem-remoteproc");
 737         if (!ph) {
 738                 dev_err(dev, "DT missing \"modem-remoteproc\" property\n");
 739                 return -EINVAL;
 740         }
 741
 742         rproc = rproc_get_by_phandle(ph);
 743         if (!rproc)
 744                 return -EPROBE_DEFER;
 745
 746         /* The clock and interconnects might not be ready when we're
 747          * probed, so might return -EPROBE_DEFER.
 748          */
 749         clock = ipa_clock_init(dev);
 750         if (IS_ERR(clock)) {
 751                 ret = PTR_ERR(clock);
 752                 goto err_rproc_put;
 753         }
 754
 755         /* No more EPROBE_DEFER.  Get our configuration data */
 756         data = of_device_get_match_data(dev);
 757         if (!data) {
 758                 /* This is really IPA_VALIDATE (should never happen) */
 759                 dev_err(dev, "matched hardware not supported\n");
 760                 ret = -ENOTSUPP;
 761                 goto err_clock_exit;
 762         }
 763
 764         /* Allocate and initialize the IPA structure */
 765         ipa = kzalloc(sizeof(*ipa), GFP_KERNEL);
 766         if (!ipa) {
 767                 ret = -ENOMEM;
 768                 goto err_clock_exit;
 769         }
 770
 771         ipa->pdev = pdev;
 772         dev_set_drvdata(dev, ipa);
 773         ipa->modem_rproc = rproc;
 774         ipa->clock = clock;
 775         ipa->version = data->version;
 776
 777         ret = ipa_reg_init(ipa);
 778         if (ret)
 779                 goto err_kfree_ipa;
 780
 781         ret = ipa_mem_init(ipa, data->mem_data);
 782         if (ret)
 783                 goto err_reg_exit;
 784
 785         ret = gsi_init(&ipa->gsi, pdev, ipa->version, data->endpoint_count,
 786                        data->endpoint_data);
 787         if (ret)
 788                 goto err_mem_exit;
 789
 790         /* Result is a non-zero mask endpoints that support filtering */
 791         ipa->filter_map = ipa_endpoint_init(ipa, data->endpoint_count,
 792                                             data->endpoint_data);
 793         if (!ipa->filter_map) {
 794                 ret = -EINVAL;
 795                 goto err_gsi_exit;
 796         }
 797
 798         ret = ipa_table_init(ipa);
 799         if (ret)
 800                 goto err_endpoint_exit;
 801
 802         ret = ipa_modem_init(ipa, modem_init);
 803         if (ret)
 804                 goto err_table_exit;
 805
 806         ret = ipa_config(ipa, data);
 807         if (ret)
 808                 goto err_modem_exit;
 809
 810         dev_info(dev, "IPA driver initialized");
 811
 812         /* If the modem is doing early initialization, it will trigger a
 813          * call to ipa_setup() call when it has finished.  In that case
 814          * we're done here.
 815          */
 816         if (modem_init)
 817                 return 0;
 818
 819         /* Otherwise we need to load the firmware and have Trust Zone validate
 820          * and install it.  If that succeeds we can proceed with setup.
 821          */
 822         ret = ipa_firmware_load(dev);
 823         if (ret)
 824                 goto err_deconfig;
 825
 826         ret = ipa_setup(ipa);
 827         if (ret)
 828                 goto err_deconfig;
 829
 830         return 0;
 831
 832 err_deconfig:
 833         ipa_deconfig(ipa);
 834 err_modem_exit:
 835         ipa_modem_exit(ipa);
 836 err_table_exit:
 837         ipa_table_exit(ipa);
 838 err_endpoint_exit:
 839         ipa_endpoint_exit(ipa);
 840 err_gsi_exit:
 841         gsi_exit(&ipa->gsi);
 842 err_mem_exit:
 843         ipa_mem_exit(ipa);
 844 err_reg_exit:
 845         ipa_reg_exit(ipa);
 846 err_kfree_ipa:
 847         kfree(ipa);
 848 err_clock_exit:
 849         ipa_clock_exit(clock);
 850 err_rproc_put:
 851         rproc_put(rproc);
 852
 853         return ret;
 854 }
 855
 856 static int ipa_remove(struct platform_device *pdev)
 857 {
 858         struct ipa *ipa = dev_get_drvdata(&pdev->dev);
 859         struct rproc *rproc = ipa->modem_rproc;
 860         struct ipa_clock *clock = ipa->clock;
 861         int ret;
 862
 863         if (ipa->setup_complete) {
 864                 ret = ipa_modem_stop(ipa);
 865                 if (ret)
 866                         return ret;
 867
 868                 ipa_teardown(ipa);
 869         }
 870
 871         ipa_deconfig(ipa);
 872         ipa_modem_exit(ipa);
 873         ipa_table_exit(ipa);
 874         ipa_endpoint_exit(ipa);
 875         gsi_exit(&ipa->gsi);
 876         ipa_mem_exit(ipa);
 877         ipa_reg_exit(ipa);
 878         kfree(ipa);
 879         ipa_clock_exit(clock);
 880         rproc_put(rproc);
 881
 882         return 0;
 883 }
 884
 885 /**
 886  * ipa_suspend() - Power management system suspend callback
 887  * @dev:        IPA device structure
 888  *
 889  * Return:      Always returns zero
 890  *
 891  * Called by the PM framework when a system suspend operation is invoked.
 892  * Suspends endpoints and releases the clock reference held to keep
 893  * the IPA clock running until this point.
 894  */
 895 static int ipa_suspend(struct device *dev)
 896 {
 897         struct ipa *ipa = dev_get_drvdata(dev);
 898
 899         /* When a suspended RX endpoint has a packet ready to receive, we
 900          * get an IPA SUSPEND interrupt.  We trigger a system resume in
 901          * that case, but only on the first such interrupt since suspend.
 902          */
 903         __clear_bit(IPA_FLAG_RESUMED, ipa->flags);
 904
 905         ipa_endpoint_suspend(ipa);
 906
 907         ipa_clock_put(ipa);
 908
 909         return 0;
 910 }
 911
 912 /**
 913  * ipa_resume() - Power management system resume callback
 914  * @dev:        IPA device structure
 915  *
 916  * Return:      Always returns 0
 917  *
 918  * Called by the PM framework when a system resume operation is invoked.
 919  * Takes an IPA clock reference to keep the clock running until suspend,
 920  * and resumes endpoints.
 921  */
 922 static int ipa_resume(struct device *dev)
 923 {
 924         struct ipa *ipa = dev_get_drvdata(dev);
 925
 926         /* This clock reference will keep the IPA out of suspend
 927          * until we get a power management suspend request.
 928          */
 929         ipa_clock_get(ipa);
 930
 931         ipa_endpoint_resume(ipa);
 932
 933         return 0;
 934 }
 935
 936 static const struct dev_pm_ops ipa_pm_ops = {
 937         .suspend        = ipa_suspend,
 938         .resume         = ipa_resume,
 939 };
 940
 941 static struct platform_driver ipa_driver = {
 942         .probe  = ipa_probe,
 943         .remove = ipa_remove,
 944         .driver = {
 945                 .name           = "ipa",
 946                 .pm             = &ipa_pm_ops,
 947                 .of_match_table = ipa_match,
 948         },
 949 };
 950
 951 module_platform_driver(ipa_driver);
 952
 953 MODULE_LICENSE("GPL v2");
 954 MODULE_DESCRIPTION("Qualcomm IP Accelerator device driver");