include/linux/ipa.h

   1 /* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
   2  *
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License version 2 and
   5  * only version 2 as published by the Free Software Foundation.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  */
  12
  13 #ifndef _IPA_H_
  14 #define _IPA_H_
  15
  16 #include <linux/msm_ipa.h>
  17 #include <linux/skbuff.h>
  18 #include <linux/types.h>
  19 #include <linux/msm-sps.h>
  20 #include <linux/if_ether.h>
  21 #include "linux/msm_gsi.h"
  22
  23 #define IPA_APPS_MAX_BW_IN_MBPS 700
  24 /**
  25  * enum ipa_transport_type
  26  * transport type: either GSI or SPS
  27  */
  28 enum ipa_transport_type {
  29         IPA_TRANSPORT_TYPE_SPS,
  30         IPA_TRANSPORT_TYPE_GSI
  31 };
  32
  33 /**
  34  * enum ipa_nat_en_type - NAT setting type in IPA end-point
  35  */
  36 enum ipa_nat_en_type {
  37         IPA_BYPASS_NAT,
  38         IPA_SRC_NAT,
  39         IPA_DST_NAT,
  40 };
  41
  42 /**
  43  * enum ipa_ipv6ct_en_type - IPv6CT setting type in IPA end-point
  44  */
  45 enum ipa_ipv6ct_en_type {
  46         IPA_BYPASS_IPV6CT,
  47         IPA_ENABLE_IPV6CT,
  48 };
  49
  50 /**
  51  * enum ipa_mode_type - mode setting type in IPA end-point
  52  * @BASIC: basic mode
  53  * @ENABLE_FRAMING_HDLC: not currently supported
  54  * @ENABLE_DEFRAMING_HDLC: not currently supported
  55  * @DMA: all data arriving IPA will not go through IPA logic blocks, this
  56  *  allows IPA to work as DMA for specific pipes.
  57  */
  58 enum ipa_mode_type {
  59         IPA_BASIC,
  60         IPA_ENABLE_FRAMING_HDLC,
  61         IPA_ENABLE_DEFRAMING_HDLC,
  62         IPA_DMA,
  63 };
  64
  65 /**
  66  *  enum ipa_aggr_en_type - aggregation setting type in IPA
  67  *  end-point
  68  */
  69 enum ipa_aggr_en_type {
  70         IPA_BYPASS_AGGR,
  71         IPA_ENABLE_AGGR,
  72         IPA_ENABLE_DEAGGR,
  73 };
  74
  75 /**
  76  *  enum ipa_aggr_type - type of aggregation in IPA end-point
  77  */
  78 enum ipa_aggr_type {
  79         IPA_MBIM_16 = 0,
  80         IPA_HDLC    = 1,
  81         IPA_TLP     = 2,
  82         IPA_RNDIS   = 3,
  83         IPA_GENERIC = 4,
  84         IPA_QCMAP   = 6,
  85 };
  86
  87 /**
  88  * enum ipa_aggr_mode - global aggregation mode
  89  */
  90 enum ipa_aggr_mode {
  91         IPA_MBIM_AGGR,
  92         IPA_QCNCM_AGGR,
  93 };
  94
  95 /**
  96  * enum ipa_dp_evt_type - type of event client callback is
  97  * invoked for on data path
  98  * @IPA_RECEIVE: data is struct sk_buff
  99  * @IPA_WRITE_DONE: data is struct sk_buff
 100  */
 101 enum ipa_dp_evt_type {
 102         IPA_RECEIVE,
 103         IPA_WRITE_DONE,
 104         IPA_CLIENT_START_POLL,
 105         IPA_CLIENT_COMP_NAPI,
 106 };
 107
 108 /**
 109  * enum hdr_total_len_or_pad_type - type of value held by TOTAL_LEN_OR_PAD
 110  * field in header configuration register.
 111  * @IPA_HDR_PAD: field is used as padding length
 112  * @IPA_HDR_TOTAL_LEN: field is used as total length
 113  */
 114 enum hdr_total_len_or_pad_type {
 115         IPA_HDR_PAD = 0,
 116         IPA_HDR_TOTAL_LEN = 1,
 117 };
 118
 119 /**
 120  * struct ipa_ep_cfg_nat - NAT configuration in IPA end-point
 121  * @nat_en:     This defines the default NAT mode for the pipe: in case of
 122  *              filter miss - the default NAT mode defines the NATing operation
 123  *              on the packet. Valid for Input Pipes only (IPA consumer)
 124  */
 125 struct ipa_ep_cfg_nat {
 126         enum ipa_nat_en_type nat_en;
 127 };
 128
 129 /**
 130  * struct ipa_ep_cfg_conn_track - IPv6 Connection tracking configuration in
 131  *      IPA end-point
 132  * @conn_track_en: Defines speculative conn_track action, means if specific
 133  *                 pipe needs to have UL/DL IPv6 Connection Tracking or Bypass
 134  *                 IPv6 Connection Tracking. 0: Bypass IPv6 Connection Tracking
 135  *                                           1: IPv6 UL/DL Connection Tracking.
 136  *                Valid for Input Pipes only (IPA consumer)
 137  */
 138 struct ipa_ep_cfg_conn_track {
 139         enum ipa_ipv6ct_en_type conn_track_en;
 140 };
 141
 142 /**
 143  * struct ipa_ep_cfg_hdr - header configuration in IPA end-point
 144  *
 145  * @hdr_len:Header length in bytes to be added/removed. Assuming
 146  *                      header len is constant per endpoint. Valid for
 147  *                      both Input and Output Pipes
 148  * @hdr_ofst_metadata_valid:    0: Metadata_Ofst  value is invalid, i.e., no
 149  *                      metadata within header.
 150  *                      1: Metadata_Ofst  value is valid, i.e., metadata
 151  *                      within header is in offset Metadata_Ofst Valid
 152  *                      for Input Pipes only (IPA Consumer) (for output
 153  *                      pipes, metadata already set within the header)
 154  * @hdr_ofst_metadata:  Offset within header in which metadata resides
 155  *                      Size of metadata - 4bytes
 156  *                      Example -  Stream ID/SSID/mux ID.
 157  *                      Valid for  Input Pipes only (IPA Consumer) (for output
 158  *                      pipes, metadata already set within the header)
 159  * @hdr_additional_const_len:   Defines the constant length that should be added
 160  *                      to the payload length in order for IPA to update
 161  *                      correctly the length field within the header
 162  *                      (valid only in case Hdr_Ofst_Pkt_Size_Valid=1)
 163  *                      Valid for Output Pipes (IPA Producer)
 164  * @hdr_ofst_pkt_size_valid:    0: Hdr_Ofst_Pkt_Size  value is invalid, i.e., no
 165  *                      length field within the inserted header
 166  *                      1: Hdr_Ofst_Pkt_Size  value is valid, i.e., a
 167  *                      packet length field resides within the header
 168  *                      Valid for Output Pipes (IPA Producer)
 169  * @hdr_ofst_pkt_size:  Offset within header in which packet size reside. Upon
 170  *                      Header Insertion, IPA will update this field within the
 171  *                      header with the packet length . Assumption is that
 172  *                      header length field size is constant and is 2Bytes
 173  *                      Valid for Output Pipes (IPA Producer)
 174  * @hdr_a5_mux: Determines whether A5 Mux header should be added to the packet.
 175  *                      This bit is valid only when Hdr_En=01(Header Insertion)
 176  *                      SW should set this bit for IPA-to-A5 pipes.
 177  *                      0: Do not insert A5 Mux Header
 178  *                      1: Insert A5 Mux Header
 179  *                      Valid for Output Pipes (IPA Producer)
 180  * @hdr_remove_additional:      bool switch, remove more of the header
 181  *                      based on the aggregation configuration (register
 182  *                      HDR_LEN_INC_DEAGG_HDR)
 183  * @hdr_metadata_reg_valid:     bool switch, metadata from
 184  *                      register INIT_HDR_METADATA_n is valid.
 185  *                      (relevant only for IPA Consumer pipes)
 186  */
 187 struct ipa_ep_cfg_hdr {
 188         u32  hdr_len;
 189         u32  hdr_ofst_metadata_valid;
 190         u32  hdr_ofst_metadata;
 191         u32  hdr_additional_const_len;
 192         u32  hdr_ofst_pkt_size_valid;
 193         u32  hdr_ofst_pkt_size;
 194         u32  hdr_a5_mux;
 195         u32  hdr_remove_additional;
 196         u32  hdr_metadata_reg_valid;
 197 };
 198
 199 /**
 200  * struct ipa_ep_cfg_hdr_ext - extended header configuration in IPA end-point
 201  * @hdr_pad_to_alignment: Pad packet to specified alignment
 202  *      (2^pad to alignment value), i.e. value of 3 means pad to 2^3 = 8 bytes
 203  *      alignment. Alignment is to 0,2 up to 32 bytes (IPAv2 does not support 64
 204  *      byte alignment). Valid for Output Pipes only (IPA Producer).
 205  * @hdr_total_len_or_pad_offset: Offset to length field containing either
 206  *      total length or pad length, per hdr_total_len_or_pad config
 207  * @hdr_payload_len_inc_padding: 0-IPA_ENDP_INIT_HDR_n's
 208  *      HDR_OFST_PKT_SIZE does
 209  *      not includes padding bytes size, payload_len = packet length,
 210  *      1-IPA_ENDP_INIT_HDR_n's HDR_OFST_PKT_SIZE includes
 211  *      padding bytes size, payload_len = packet length + padding
 212  * @hdr_total_len_or_pad: field is used as PAD length ot as Total length
 213  *      (header + packet + padding)
 214  * @hdr_total_len_or_pad_valid: 0-Ignore TOTAL_LEN_OR_PAD field, 1-Process
 215  *      TOTAL_LEN_OR_PAD field
 216  * @hdr_little_endian: 0-Big Endian, 1-Little Endian
 217  */
 218 struct ipa_ep_cfg_hdr_ext {
 219         u32 hdr_pad_to_alignment;
 220         u32 hdr_total_len_or_pad_offset;
 221         bool hdr_payload_len_inc_padding;
 222         enum hdr_total_len_or_pad_type hdr_total_len_or_pad;
 223         bool hdr_total_len_or_pad_valid;
 224         bool hdr_little_endian;
 225 };
 226
 227 /**
 228  * struct ipa_ep_cfg_mode - mode configuration in IPA end-point
 229  * @mode:       Valid for Input Pipes only (IPA Consumer)
 230  * @dst:        This parameter specifies the output pipe to which the packets
 231  *              will be routed to.
 232  *              This parameter is valid for Mode=DMA and not valid for
 233  *              Mode=Basic
 234  *              Valid for Input Pipes only (IPA Consumer)
 235  */
 236 struct ipa_ep_cfg_mode {
 237         enum ipa_mode_type mode;
 238         enum ipa_client_type dst;
 239 };
 240
 241 /**
 242  * struct ipa_ep_cfg_aggr - aggregation configuration in IPA end-point
 243  *
 244  * @aggr_en:    Valid for both Input and Output Pipes
 245  * @aggr:       aggregation type (Valid for both Input and Output Pipes)
 246  * @aggr_byte_limit:    Limit of aggregated packet size in KB (<=32KB) When set
 247  *                      to 0, there is no size limitation on the aggregation.
 248  *                      When both, Aggr_Byte_Limit and Aggr_Time_Limit are set
 249  *                      to 0, there is no aggregation, every packet is sent
 250  *                      independently according to the aggregation structure
 251  *                      Valid for Output Pipes only (IPA Producer )
 252  * @aggr_time_limit:    Timer to close aggregated packet (<=32ms) When set to 0,
 253  *                      there is no time limitation on the aggregation.  When
 254  *                      both, Aggr_Byte_Limit and Aggr_Time_Limit are set to 0,
 255  *                      there is no aggregation, every packet is sent
 256  *                      independently according to the aggregation structure
 257  *                      Valid for Output Pipes only (IPA Producer)
 258  * @aggr_pkt_limit: Defines if EOF close aggregation or not. if set to false
 259  *                      HW closes aggregation (sends EOT) only based on its
 260  *                      aggregation config (byte/time limit, etc). if set to
 261  *                      true EOF closes aggregation in addition to HW based
 262  *                      aggregation closure. Valid for Output Pipes only (IPA
 263  *                      Producer). EOF affects only Pipes configured for
 264  *                      generic aggregation.
 265  * @aggr_hard_byte_limit_en: If set to 1, byte-limit aggregation for this
 266  *                      pipe will apply a hard-limit behavior which will not
 267  *                      allow frames to be closed with more than byte-limit
 268  *                      bytes. If set to 0, previous byte-limit behavior
 269  *                      will apply - frames close once a packet causes the
 270  *                      accumulated byte-count to cross the byte-limit
 271  *                      threshold (closed frame will contain that packet).
 272  * @aggr_sw_eof_active: 0: EOF does not close aggregation. HW closes aggregation
 273  *                      (sends EOT) only based on its aggregation config
 274  *                      (byte/time limit, etc).
 275  *                      1: EOF closes aggregation in addition to HW based
 276  *                      aggregation closure. Valid for Output Pipes only (IPA
 277  *                      Producer). EOF affects only Pipes configured for generic
 278  *                      aggregation.
 279  */
 280 struct ipa_ep_cfg_aggr {
 281         enum ipa_aggr_en_type aggr_en;
 282         enum ipa_aggr_type aggr;
 283         u32 aggr_byte_limit;
 284         u32 aggr_time_limit;
 285         u32 aggr_pkt_limit;
 286         u32 aggr_hard_byte_limit_en;
 287         bool aggr_sw_eof_active;
 288 };
 289
 290 /**
 291  * struct ipa_ep_cfg_route - route configuration in IPA end-point
 292  * @rt_tbl_hdl: Defines the default routing table index to be used in case there
 293  *              is no filter rule matching, valid for Input Pipes only (IPA
 294  *              Consumer). Clients should set this to 0 which will cause default
 295  *              v4 and v6 routes setup internally by IPA driver to be used for
 296  *              this end-point
 297  */
 298 struct ipa_ep_cfg_route {
 299         u32 rt_tbl_hdl;
 300 };
 301
 302 /**
 303  * struct ipa_ep_cfg_holb - head of line blocking configuration in IPA end-point
 304  * @en: enable(1 => ok to drop pkt)/disable(0 => never drop pkt)
 305  * @tmr_val: duration in units of 128 IPA clk clock cyles [0,511], 1 clk=1.28us
 306  *           IPAv2.5 support 32 bit HOLB timeout value, previous versions
 307  *           supports 16 bit
 308  */
 309 struct ipa_ep_cfg_holb {
 310         u16 en;
 311         u32 tmr_val;
 312 };
 313
 314 /**
 315  * struct ipa_ep_cfg_deaggr - deaggregation configuration in IPA end-point
 316  * @deaggr_hdr_len: Deaggregation Header length in bytes. Valid only for Input
 317  *      Pipes, which are configured for 'Generic' deaggregation.
 318  * @packet_offset_valid: - 0: PACKET_OFFSET is not used, 1: PACKET_OFFSET is
 319  *      used.
 320  * @packet_offset_location: Location of packet offset field, which specifies
 321  *      the offset to the packet from the start of the packet offset field.
 322  * @max_packet_len: DEAGGR Max Packet Length in Bytes. A Packet with higher
 323  *      size wil be treated as an error. 0 - Packet Length is not Bound,
 324  *      IPA should not check for a Max Packet Length.
 325  */
 326 struct ipa_ep_cfg_deaggr {
 327         u32 deaggr_hdr_len;
 328         bool packet_offset_valid;
 329         u32 packet_offset_location;
 330         u32 max_packet_len;
 331 };
 332
 333 /**
 334  * enum ipa_cs_offload - checksum offload setting
 335  */
 336 enum ipa_cs_offload {
 337         IPA_DISABLE_CS_OFFLOAD,
 338         IPA_ENABLE_CS_OFFLOAD_UL,
 339         IPA_ENABLE_CS_OFFLOAD_DL,
 340         IPA_CS_RSVD
 341 };
 342
 343 /**
 344  * struct ipa_ep_cfg_cfg - IPA ENDP_INIT Configuration register
 345  * @frag_offload_en: - 0 - IP packet fragment handling is disabled. IP packet
 346  *      fragments should be sent to SW. SW is responsible for
 347  *      configuring filter rules, and IP packet filter exception should be
 348  *      used to send all fragments to SW. 1 - IP packet fragment
 349  *      handling is enabled. IPA checks for fragments and uses frag
 350  *      rules table for processing fragments. Valid only for Input Pipes
 351  *      (IPA Consumer)
 352  * @cs_offload_en: Checksum offload enable: 00: Disable checksum offload, 01:
 353  *      Enable checksum calculation offload (UL) - For output pipe
 354  *      (IPA producer) specifies that checksum trailer is to be added.
 355  *      For input pipe (IPA consumer) specifies presence of checksum
 356  *      header and IPA checksum calculation accordingly. 10: Enable
 357  *      checksum calculation offload (DL) - For output pipe (IPA
 358  *      producer) specifies that checksum trailer is to be added. For
 359  *      input pipe (IPA consumer) specifies IPA checksum calculation.
 360  *      11: Reserved
 361  * @cs_metadata_hdr_offset: Offset in Words (4 bytes) within header in which
 362  *      checksum meta info header (4 bytes) starts (UL). Values are 0-15, which
 363  *      mean 0 - 60 byte checksum header offset. Valid for input
 364  *      pipes only (IPA consumer)
 365  * @gen_qmb_master_sel: Select bit for ENDP GEN-QMB master. This is used to
 366  *      separate DDR & PCIe transactions in-order to limit them as
 367  *      a group (using MAX_WRITES/READS limiation). Valid for input and
 368  *      output pipes (IPA consumer+producer)
 369  */
 370 struct ipa_ep_cfg_cfg {
 371         bool frag_offload_en;
 372         enum ipa_cs_offload cs_offload_en;
 373         u8 cs_metadata_hdr_offset;
 374         u8 gen_qmb_master_sel;
 375 };
 376
 377 /**
 378  * struct ipa_ep_cfg_metadata_mask - Endpoint initialization hdr metadata mask
 379  * @metadata_mask: Mask specifying which metadata bits to write to
 380  *      IPA_ENDP_INIT_HDR_n.s HDR_OFST_METADATA. Only
 381  *      masked metadata bits (set to 1) will be written. Valid for Output
 382  *      Pipes only (IPA Producer)
 383  */
 384 struct ipa_ep_cfg_metadata_mask {
 385         u32 metadata_mask;
 386 };
 387
 388 /**
 389  * struct ipa_ep_cfg_metadata - Meta Data configuration in IPA end-point
 390  * @md: This defines the meta data from tx data descriptor
 391  * @qmap_id: qmap id
 392  */
 393 struct ipa_ep_cfg_metadata {
 394         u32 qmap_id;
 395 };
 396
 397 /**
 398  * struct ipa_ep_cfg_seq - HPS/DPS sequencer type configuration in IPA end-point
 399  * @set_dynamic:  0 - HPS/DPS seq type is configured statically,
 400  *                 1 - HPS/DPS seq type is set to seq_type
 401  * @seq_type: HPS/DPS sequencer type configuration
 402  */
 403 struct ipa_ep_cfg_seq {
 404         bool set_dynamic;
 405         int seq_type;
 406 };
 407
 408 /**
 409  * struct ipa_ep_cfg - configuration of IPA end-point
 410  * @nat:                NAT parameters
 411  * @conn_track:         IPv6CT parameters
 412  * @hdr:                Header parameters
 413  * @hdr_ext:            Extended header parameters
 414  * @mode:               Mode parameters
 415  * @aggr:               Aggregation parameters
 416  * @deaggr:             Deaggregation params
 417  * @route:              Routing parameters
 418  * @cfg:                Configuration register data
 419  * @metadata_mask:      Hdr metadata mask
 420  * @meta:               Meta Data
 421  * @seq:                HPS/DPS sequencers configuration
 422  */
 423 struct ipa_ep_cfg {
 424         struct ipa_ep_cfg_nat nat;
 425         struct ipa_ep_cfg_conn_track conn_track;
 426         struct ipa_ep_cfg_hdr hdr;
 427         struct ipa_ep_cfg_hdr_ext hdr_ext;
 428         struct ipa_ep_cfg_mode mode;
 429         struct ipa_ep_cfg_aggr aggr;
 430         struct ipa_ep_cfg_deaggr deaggr;
 431         struct ipa_ep_cfg_route route;
 432         struct ipa_ep_cfg_cfg cfg;
 433         struct ipa_ep_cfg_metadata_mask metadata_mask;
 434         struct ipa_ep_cfg_metadata meta;
 435         struct ipa_ep_cfg_seq seq;
 436 };
 437
 438 /**
 439  * struct ipa_ep_cfg_ctrl - Control configuration in IPA end-point
 440  * @ipa_ep_suspend: 0 - ENDP is enabled, 1 - ENDP is suspended (disabled).
 441  *                      Valid for PROD Endpoints
 442  * @ipa_ep_delay:   0 - ENDP is free-running, 1 - ENDP is delayed.
 443  *                      SW controls the data flow of an endpoint usind this bit.
 444  *                      Valid for CONS Endpoints
 445  */
 446 struct ipa_ep_cfg_ctrl {
 447         bool ipa_ep_suspend;
 448         bool ipa_ep_delay;
 449 };
 450
 451 /**
 452  * x should be in bytes
 453  */
 454 #define IPA_NUM_OF_FIFO_DESC(x) (x/sizeof(struct sps_iovec))
 455 typedef void (*ipa_notify_cb)(void *priv, enum ipa_dp_evt_type evt,
 456                        unsigned long data);
 457
 458 /**
 459  * enum ipa_wdi_meter_evt_type - type of event client callback is
 460  * for AP+STA mode metering
 461  * @IPA_GET_WDI_SAP_STATS: get IPA_stats betwen SAP and STA -
 462  *                      use ipa_get_wdi_sap_stats structure
 463  * @IPA_SET_WIFI_QUOTA: set quota limit on STA -
 464  *                      use ipa_set_wifi_quota structure
 465  */
 466 enum ipa_wdi_meter_evt_type {
 467         IPA_GET_WDI_SAP_STATS,
 468         IPA_SET_WIFI_QUOTA,
 469 };
 470
 471 struct ipa_get_wdi_sap_stats {
 472         /* indicate to reset stats after query */
 473         uint8_t reset_stats;
 474         /* indicate valid stats from wlan-fw */
 475         uint8_t stats_valid;
 476         /* Tx: SAP->STA */
 477         uint64_t ipv4_tx_packets;
 478         uint64_t ipv4_tx_bytes;
 479         /* Rx: STA->SAP */
 480         uint64_t ipv4_rx_packets;
 481         uint64_t ipv4_rx_bytes;
 482         uint64_t ipv6_tx_packets;
 483         uint64_t ipv6_tx_bytes;
 484         uint64_t ipv6_rx_packets;
 485         uint64_t ipv6_rx_bytes;
 486 };
 487
 488 /**
 489  * struct ipa_set_wifi_quota - structure used for
 490  *                                   IPA_SET_WIFI_QUOTA.
 491  *
 492  * @quota_bytes:    Quota (in bytes) for the STA interface.
 493  * @set_quota:       Indicate whether to set the quota (use 1) or
 494  *                   unset the quota.
 495  *
 496  */
 497 struct ipa_set_wifi_quota {
 498         uint64_t quota_bytes;
 499         uint8_t  set_quota;
 500         /* indicate valid quota set from wlan-fw */
 501         uint8_t set_valid;
 502 };
 503
 504 typedef void (*ipa_wdi_meter_notifier_cb)(enum ipa_wdi_meter_evt_type evt,
 505                        void *data);
 506
 507 /**
 508  * struct ipa_connect_params - low-level client connect input parameters. Either
 509  * client allocates the data and desc FIFO and specifies that in data+desc OR
 510  * specifies sizes and pipe_mem pref and IPA does the allocation.
 511  *
 512  * @ipa_ep_cfg: IPA EP configuration
 513  * @client:     type of "client"
 514  * @client_bam_hdl:      client SPS handle
 515  * @client_ep_idx:       client PER EP index
 516  * @priv:       callback cookie
 517  * @notify:     callback
 518  *              priv - callback cookie evt - type of event data - data relevant
 519  *              to event.  May not be valid. See event_type enum for valid
 520  *              cases.
 521  * @desc_fifo_sz:       size of desc FIFO
 522  * @data_fifo_sz:       size of data FIFO
 523  * @pipe_mem_preferred: if true, try to alloc the FIFOs in pipe mem, fallback
 524  *                      to sys mem if pipe mem alloc fails
 525  * @desc:       desc FIFO meta-data when client has allocated it
 526  * @data:       data FIFO meta-data when client has allocated it
 527  * @skip_ep_cfg: boolean field that determines if EP should be configured
 528  *  by IPA driver
 529  * @keep_ipa_awake: when true, IPA will not be clock gated
 530  */
 531 struct ipa_connect_params {
 532         struct ipa_ep_cfg ipa_ep_cfg;
 533         enum ipa_client_type client;
 534         unsigned long client_bam_hdl;
 535         u32 client_ep_idx;
 536         void *priv;
 537         ipa_notify_cb notify;
 538         u32 desc_fifo_sz;
 539         u32 data_fifo_sz;
 540         bool pipe_mem_preferred;
 541         struct sps_mem_buffer desc;
 542         struct sps_mem_buffer data;
 543         bool skip_ep_cfg;
 544         bool keep_ipa_awake;
 545 };
 546
 547 /**
 548  *  struct ipa_sps_params - SPS related output parameters resulting from
 549  *  low/high level client connect
 550  *  @ipa_bam_hdl:       IPA SPS handle
 551  *  @ipa_ep_idx:        IPA PER EP index
 552  *  @desc:      desc FIFO meta-data
 553  *  @data:      data FIFO meta-data
 554  */
 555 struct ipa_sps_params {
 556         unsigned long ipa_bam_hdl;
 557         u32 ipa_ep_idx;
 558         struct sps_mem_buffer desc;
 559         struct sps_mem_buffer data;
 560 };
 561
 562 /**
 563  * struct ipa_tx_intf - interface tx properties
 564  * @num_props:  number of tx properties
 565  * @prop:       the tx properties array
 566  */
 567 struct ipa_tx_intf {
 568         u32 num_props;
 569         struct ipa_ioc_tx_intf_prop *prop;
 570 };
 571
 572 /**
 573  * struct ipa_rx_intf - interface rx properties
 574  * @num_props:  number of rx properties
 575  * @prop:       the rx properties array
 576  */
 577 struct ipa_rx_intf {
 578         u32 num_props;
 579         struct ipa_ioc_rx_intf_prop *prop;
 580 };
 581
 582 /**
 583  * struct ipa_ext_intf - interface ext properties
 584  * @excp_pipe_valid:    is next field valid?
 585  * @excp_pipe:  exception packets should be routed to this pipe
 586  * @num_props:  number of ext properties
 587  * @prop:       the ext properties array
 588  */
 589 struct ipa_ext_intf {
 590         bool excp_pipe_valid;
 591         enum ipa_client_type excp_pipe;
 592         u32 num_props;
 593         struct ipa_ioc_ext_intf_prop *prop;
 594 };
 595
 596 /**
 597  * struct ipa_sys_connect_params - information needed to setup an IPA end-point
 598  * in system-BAM mode
 599  * @ipa_ep_cfg: IPA EP configuration
 600  * @client:     the type of client who "owns" the EP
 601  * @desc_fifo_sz: size of desc FIFO. This number is used to allocate the desc
 602  *              fifo for BAM. For GSI, this size is used by IPA driver as a
 603  *              baseline to calculate the GSI ring size in the following way:
 604  *              For PROD pipes, GSI ring is 4 * desc_fifo_sz.
 605                 For PROD pipes, GSI ring is 2 * desc_fifo_sz.
 606  * @priv:       callback cookie
 607  * @notify:     callback
 608  *              priv - callback cookie
 609  *              evt - type of event
 610  *              data - data relevant to event.  May not be valid. See event_type
 611  *              enum for valid cases.
 612  * @skip_ep_cfg: boolean field that determines if EP should be configured
 613  *  by IPA driver
 614  * @keep_ipa_awake: when true, IPA will not be clock gated
 615  * @napi_enabled: when true, IPA call client callback to start polling
 616  */
 617 struct ipa_sys_connect_params {
 618         struct ipa_ep_cfg ipa_ep_cfg;
 619         enum ipa_client_type client;
 620         u32 desc_fifo_sz;
 621         void *priv;
 622         ipa_notify_cb notify;
 623         bool skip_ep_cfg;
 624         bool keep_ipa_awake;
 625         bool napi_enabled;
 626         bool recycle_enabled;
 627 };
 628
 629 /**
 630  * struct ipa_tx_meta - meta-data for the TX packet
 631  * @dma_address: dma mapped address of TX packet
 632  * @dma_address_valid: is above field valid?
 633  */
 634 struct ipa_tx_meta {
 635         u8 pkt_init_dst_ep;
 636         bool pkt_init_dst_ep_valid;
 637         bool pkt_init_dst_ep_remote;
 638         dma_addr_t dma_address;
 639         bool dma_address_valid;
 640 };
 641
 642 /**
 643  * typedef ipa_msg_free_fn - callback function
 644  * @param buff - [in] the message payload to free
 645  * @param len - [in] size of message payload
 646  * @param type - [in] the message type
 647  *
 648  * Message callback registered by kernel client with IPA driver to
 649  * free message payload after IPA driver processing is complete
 650  *
 651  * No return value
 652  */
 653 typedef void (*ipa_msg_free_fn)(void *buff, u32 len, u32 type);
 654
 655 /**
 656  * typedef ipa_msg_pull_fn - callback function
 657  * @param buff - [in] where to copy message payload
 658  * @param len - [in] size of buffer to copy payload into
 659  * @param type - [in] the message type
 660  *
 661  * Message callback registered by kernel client with IPA driver for
 662  * IPA driver to pull messages from the kernel client upon demand from
 663  * user-space
 664  *
 665  * Returns how many bytes were copied into the buffer.
 666  */
 667 typedef int (*ipa_msg_pull_fn)(void *buff, u32 len, u32 type);
 668
 669 /**
 670  * enum ipa_voltage_level - IPA Voltage levels
 671  */
 672 enum ipa_voltage_level {
 673         IPA_VOLTAGE_UNSPECIFIED,
 674         IPA_VOLTAGE_SVS = IPA_VOLTAGE_UNSPECIFIED,
 675         IPA_VOLTAGE_NOMINAL,
 676         IPA_VOLTAGE_TURBO,
 677         IPA_VOLTAGE_MAX,
 678 };
 679
 680 /**
 681  * enum ipa_rm_event - IPA RM events
 682  *
 683  * Indicate the resource state change
 684  */
 685 enum ipa_rm_event {
 686         IPA_RM_RESOURCE_GRANTED,
 687         IPA_RM_RESOURCE_RELEASED
 688 };
 689
 690 typedef void (*ipa_rm_notify_cb)(void *user_data,
 691                 enum ipa_rm_event event,
 692                 unsigned long data);
 693 /**
 694  * struct ipa_rm_register_params - information needed to
 695  *      register IPA RM client with IPA RM
 696  *
 697  * @user_data: IPA RM client provided information
 698  *              to be passed to notify_cb callback below
 699  * @notify_cb: callback which is called by resource
 700  *              to notify the IPA RM client about its state
 701  *              change IPA RM client is expected to perform non
 702  *              blocking operations only in notify_cb and
 703  *              release notification context as soon as
 704  *              possible.
 705  */
 706 struct ipa_rm_register_params {
 707         void *user_data;
 708         ipa_rm_notify_cb notify_cb;
 709 };
 710
 711 /**
 712  * struct ipa_rm_create_params - information needed to initialize
 713  *                              the resource
 714  * @name: resource name
 715  * @floor_voltage: floor voltage needed for client to operate in maximum
 716  *              bandwidth.
 717  * @reg_params: register parameters, contains are ignored
 718  *              for consumer resource NULL should be provided
 719  *              for consumer resource
 720  * @request_resource: function which should be called to request resource,
 721  *                      NULL should be provided for producer resource
 722  * @release_resource: function which should be called to release resource,
 723  *                      NULL should be provided for producer resource
 724  *
 725  * IPA RM client is expected to perform non blocking operations only
 726  * in request_resource and release_resource functions and
 727  * release notification context as soon as possible.
 728  */
 729 struct ipa_rm_create_params {
 730         enum ipa_rm_resource_name name;
 731         enum ipa_voltage_level floor_voltage;
 732         struct ipa_rm_register_params reg_params;
 733         int (*request_resource)(void);
 734         int (*release_resource)(void);
 735 };
 736
 737 /**
 738  * struct ipa_rm_perf_profile - information regarding IPA RM client performance
 739  * profile
 740  *
 741  * @max_bandwidth_mbps: maximum bandwidth need of the client in Mbps
 742  */
 743 struct ipa_rm_perf_profile {
 744         u32 max_supported_bandwidth_mbps;
 745 };
 746
 747 #define A2_MUX_HDR_NAME_V4_PREF "dmux_hdr_v4_"
 748 #define A2_MUX_HDR_NAME_V6_PREF "dmux_hdr_v6_"
 749
 750 /**
 751  * enum teth_tethering_mode - Tethering mode (Rmnet / MBIM)
 752  */
 753 enum teth_tethering_mode {
 754         TETH_TETHERING_MODE_RMNET,
 755         TETH_TETHERING_MODE_MBIM,
 756         TETH_TETHERING_MODE_MAX,
 757 };
 758
 759 /**
 760  * teth_bridge_init_params - Parameters used for in/out USB API
 761  * @usb_notify_cb:      Callback function which should be used by the caller.
 762  * Output parameter.
 763  * @private_data:       Data for the callback function. Should be used by the
 764  * caller. Output parameter.
 765  * @skip_ep_cfg: boolean field that determines if Apps-processor
 766  *  should or should not confiugre this end-point.
 767  */
 768 struct teth_bridge_init_params {
 769         ipa_notify_cb usb_notify_cb;
 770         void *private_data;
 771         enum ipa_client_type client;
 772         bool skip_ep_cfg;
 773 };
 774
 775 /**
 776  * struct teth_bridge_connect_params - Parameters used in teth_bridge_connect()
 777  * @ipa_usb_pipe_hdl:   IPA to USB pipe handle, returned from ipa_connect()
 778  * @usb_ipa_pipe_hdl:   USB to IPA pipe handle, returned from ipa_connect()
 779  * @tethering_mode:     Rmnet or MBIM
 780  * @ipa_client_type:    IPA "client" name (IPA_CLIENT_USB#_PROD)
 781  */
 782 struct teth_bridge_connect_params {
 783         u32 ipa_usb_pipe_hdl;
 784         u32 usb_ipa_pipe_hdl;
 785         enum teth_tethering_mode tethering_mode;
 786         enum ipa_client_type client_type;
 787 };
 788
 789 /**
 790  * struct  ipa_tx_data_desc - information needed
 791  * to send data packet to HW link: link to data descriptors
 792  * priv: client specific private data
 793  * @pyld_buffer: pointer to the data buffer that holds frame
 794  * @pyld_len: length of the data packet
 795  */
 796 struct ipa_tx_data_desc {
 797         struct list_head link;
 798         void *priv;
 799         void *pyld_buffer;
 800         u16  pyld_len;
 801 };
 802
 803 /**
 804  * struct  ipa_rx_data - information needed
 805  * to send to wlan driver on receiving data from ipa hw
 806  * @skb: skb
 807  * @dma_addr: DMA address of this Rx packet
 808  */
 809 struct ipa_rx_data {
 810         struct sk_buff *skb;
 811         dma_addr_t dma_addr;
 812 };
 813
 814 /**
 815  * enum ipa_irq_type - IPA Interrupt Type
 816  * Used to register handlers for IPA interrupts
 817  *
 818  * Below enum is a logical mapping and not the actual interrupt bit in HW
 819  */
 820 enum ipa_irq_type {
 821         IPA_BAD_SNOC_ACCESS_IRQ,
 822         IPA_EOT_COAL_IRQ,
 823         IPA_UC_IRQ_0,
 824         IPA_UC_IRQ_1,
 825         IPA_UC_IRQ_2,
 826         IPA_UC_IRQ_3,
 827         IPA_UC_IN_Q_NOT_EMPTY_IRQ,
 828         IPA_UC_RX_CMD_Q_NOT_FULL_IRQ,
 829         IPA_UC_TX_CMD_Q_NOT_FULL_IRQ,
 830         IPA_UC_TO_PROC_ACK_Q_NOT_FULL_IRQ,
 831         IPA_PROC_TO_UC_ACK_Q_NOT_EMPTY_IRQ,
 832         IPA_RX_ERR_IRQ,
 833         IPA_DEAGGR_ERR_IRQ,
 834         IPA_TX_ERR_IRQ,
 835         IPA_STEP_MODE_IRQ,
 836         IPA_PROC_ERR_IRQ,
 837         IPA_TX_SUSPEND_IRQ,
 838         IPA_TX_HOLB_DROP_IRQ,
 839         IPA_BAM_IDLE_IRQ,
 840         IPA_BAM_GSI_IDLE_IRQ = IPA_BAM_IDLE_IRQ,
 841         IPA_IRQ_MAX
 842 };
 843
 844 /**
 845  * struct ipa_tx_suspend_irq_data - interrupt data for IPA_TX_SUSPEND_IRQ
 846  * @endpoints: bitmask of endpoints which case IPA_TX_SUSPEND_IRQ interrupt
 847  * @dma_addr: DMA address of this Rx packet
 848  */
 849 struct ipa_tx_suspend_irq_data {
 850         u32 endpoints;
 851 };
 852
 853
 854 /**
 855  * typedef ipa_irq_handler_t - irq handler/callback type
 856  * @param ipa_irq_type - [in] interrupt type
 857  * @param private_data - [in, out] the client private data
 858  * @param interrupt_data - [out] interrupt information data
 859  *
 860  * callback registered by ipa_add_interrupt_handler function to
 861  * handle a specific interrupt type
 862  *
 863  * No return value
 864  */
 865 typedef void (*ipa_irq_handler_t)(enum ipa_irq_type interrupt,
 866                                 void *private_data,
 867                                 void *interrupt_data);
 868
 869 /**
 870  * struct IpaHwBamStats_t - Strucuture holding the BAM statistics
 871  *
 872  * @bamFifoFull : Number of times Bam Fifo got full - For In Ch: Good,
 873  * For Out Ch: Bad
 874  * @bamFifoEmpty : Number of times Bam Fifo got empty - For In Ch: Bad,
 875  * For Out Ch: Good
 876  * @bamFifoUsageHigh : Number of times Bam fifo usage went above 75% -
 877  * For In Ch: Good, For Out Ch: Bad
 878  * @bamFifoUsageLow : Number of times Bam fifo usage went below 25% -
 879  * For In Ch: Bad, For Out Ch: Good
 880 */
 881 struct IpaHwBamStats_t {
 882         u32 bamFifoFull;
 883         u32 bamFifoEmpty;
 884         u32 bamFifoUsageHigh;
 885         u32 bamFifoUsageLow;
 886         u32 bamUtilCount;
 887 } __packed;
 888
 889 /**
 890  * struct IpaHwRingStats_t - Strucuture holding the Ring statistics
 891  *
 892  * @ringFull : Number of times Transfer Ring got full - For In Ch: Good,
 893  * For Out Ch: Bad
 894  * @ringEmpty : Number of times Transfer Ring got empty - For In Ch: Bad,
 895  * For Out Ch: Good
 896  * @ringUsageHigh : Number of times Transfer Ring usage went above 75% -
 897  * For In Ch: Good, For Out Ch: Bad
 898  * @ringUsageLow : Number of times Transfer Ring usage went below 25% -
 899  * For In Ch: Bad, For Out Ch: Good
 900 */
 901 struct IpaHwRingStats_t {
 902         u32 ringFull;
 903         u32 ringEmpty;
 904         u32 ringUsageHigh;
 905         u32 ringUsageLow;
 906         u32 RingUtilCount;
 907 } __packed;
 908
 909 /**
 910  * struct IpaHwStatsWDIRxInfoData_t - Structure holding the WDI Rx channel
 911  * structures
 912  *
 913  * @max_outstanding_pkts : Number of outstanding packets in Rx Ring
 914  * @num_pkts_processed : Number of packets processed - cumulative
 915  * @rx_ring_rp_value : Read pointer last advertized to the WLAN FW
 916  * @rx_ind_ring_stats : Ring info
 917  * @bam_stats : BAM info
 918  * @num_bam_int_handled : Number of Bam Interrupts handled by FW
 919  * @num_db : Number of times the doorbell was rung
 920  * @num_unexpected_db : Number of unexpected doorbells
 921  * @num_pkts_in_dis_uninit_state : number of completions we
 922  *              received in disabled or uninitialized state
 923  * @num_ic_inj_vdev_change : Number of times the Imm Cmd is
 924  *              injected due to vdev_id change
 925  * @num_ic_inj_fw_desc_change : Number of times the Imm Cmd is
 926  *              injected due to fw_desc change
 927  * @num_qmb_int_handled : Number of QMB interrupts handled
 928 */
 929 struct IpaHwStatsWDIRxInfoData_t {
 930         u32 max_outstanding_pkts;
 931         u32 num_pkts_processed;
 932         u32 rx_ring_rp_value;
 933         struct IpaHwRingStats_t rx_ind_ring_stats;
 934         struct IpaHwBamStats_t bam_stats;
 935         u32 num_bam_int_handled;
 936         u32 num_db;
 937         u32 num_unexpected_db;
 938         u32 num_pkts_in_dis_uninit_state;
 939         u32 num_ic_inj_vdev_change;
 940         u32 num_ic_inj_fw_desc_change;
 941         u32 num_qmb_int_handled;
 942         u32 reserved1;
 943         u32 reserved2;
 944 } __packed;
 945
 946 /**
 947  * struct IpaHwStatsWDITxInfoData_t  - Structure holding the WDI Tx channel
 948  * structures
 949  *
 950  * @num_pkts_processed : Number of packets processed - cumulative
 951  * @copy_engine_doorbell_value : latest value of doorbell written to copy engine
 952  * @num_db_fired : Number of DB from uC FW to Copy engine
 953  * @tx_comp_ring_stats : ring info
 954  * @bam_stats : BAM info
 955  * @num_db : Number of times the doorbell was rung
 956  * @num_unexpected_db : Number of unexpected doorbells
 957  * @num_bam_int_handled : Number of Bam Interrupts handled by FW
 958  * @num_bam_int_in_non_running_state : Number of Bam interrupts while not in
 959  * Running state
 960  * @num_qmb_int_handled : Number of QMB interrupts handled
 961 */
 962 struct IpaHwStatsWDITxInfoData_t {
 963         u32 num_pkts_processed;
 964         u32 copy_engine_doorbell_value;
 965         u32 num_db_fired;
 966         struct IpaHwRingStats_t tx_comp_ring_stats;
 967         struct IpaHwBamStats_t bam_stats;
 968         u32 num_db;
 969         u32 num_unexpected_db;
 970         u32 num_bam_int_handled;
 971         u32 num_bam_int_in_non_runnning_state;
 972         u32 num_qmb_int_handled;
 973         u32 num_bam_int_handled_while_wait_for_bam;
 974 } __packed;
 975
 976 /**
 977  * struct IpaHwStatsWDIInfoData_t - Structure holding the WDI channel structures
 978  *
 979  * @rx_ch_stats : RX stats
 980  * @tx_ch_stats : TX stats
 981 */
 982 struct IpaHwStatsWDIInfoData_t {
 983         struct IpaHwStatsWDIRxInfoData_t rx_ch_stats;
 984         struct IpaHwStatsWDITxInfoData_t tx_ch_stats;
 985 } __packed;
 986
 987
 988 /**
 989  * struct  ipa_wdi_ul_params - WDI_RX configuration
 990  * @rdy_ring_base_pa: physical address of the base of the Rx ring (containing
 991  * Rx buffers)
 992  * @rdy_ring_size: size of the Rx ring in bytes
 993  * @rdy_ring_rp_pa: physical address of the location through which IPA uc is
 994  * reading (WDI-1.0)
 995  * @rdy_comp_ring_base_pa: physical address of the base of the Rx completion
 996  * ring (WDI-2.0)
 997  * @rdy_comp_ring_wp_pa: physical address of the location through which IPA
 998  * uc is writing (WDI-2.0)
 999  * @rdy_comp_ring_size: size of the Rx_completion ring in bytes
1000  * expected to communicate about the Read pointer into the Rx Ring
1001  */
1002 struct ipa_wdi_ul_params {
1003         phys_addr_t rdy_ring_base_pa;
1004         u32 rdy_ring_size;
1005         phys_addr_t rdy_ring_rp_pa;
1006         phys_addr_t rdy_comp_ring_base_pa;
1007         phys_addr_t rdy_comp_ring_wp_pa;
1008         u32 rdy_comp_ring_size;
1009         u32 *rdy_ring_rp_va;
1010         u32 *rdy_comp_ring_wp_va;
1011 };
1012
1013 /**
1014  * struct  ipa_wdi_ul_params_smmu - WDI_RX configuration (with WLAN SMMU)
1015  * @rdy_ring: SG table describing the Rx ring (containing Rx buffers)
1016  * @rdy_ring_size: size of the Rx ring in bytes
1017  * @rdy_ring_rp_pa: physical address of the location through which IPA uc is
1018  * expected to communicate about the Read pointer into the Rx Ring
1019  */
1020 struct ipa_wdi_ul_params_smmu {
1021         struct sg_table rdy_ring;
1022         u32 rdy_ring_size;
1023         phys_addr_t rdy_ring_rp_pa;
1024         struct sg_table rdy_comp_ring;
1025         phys_addr_t rdy_comp_ring_wp_pa;
1026         u32 rdy_comp_ring_size;
1027         u32 *rdy_ring_rp_va;
1028         u32 *rdy_comp_ring_wp_va;
1029 };
1030
1031 /**
1032  * struct  ipa_wdi_dl_params - WDI_TX configuration
1033  * @comp_ring_base_pa: physical address of the base of the Tx completion ring
1034  * @comp_ring_size: size of the Tx completion ring in bytes
1035  * @ce_ring_base_pa: physical address of the base of the Copy Engine Source
1036  * Ring
1037  * @ce_door_bell_pa: physical address of the doorbell that the IPA uC has to
1038  * write into to trigger the copy engine
1039  * @ce_ring_size: Copy Engine Ring size in bytes
1040  * @num_tx_buffers: Number of pkt buffers allocated
1041  */
1042 struct ipa_wdi_dl_params {
1043         phys_addr_t comp_ring_base_pa;
1044         u32 comp_ring_size;
1045         phys_addr_t ce_ring_base_pa;
1046         phys_addr_t ce_door_bell_pa;
1047         u32 ce_ring_size;
1048         u32 num_tx_buffers;
1049 };
1050
1051 /**
1052  * struct  ipa_wdi_dl_params_smmu - WDI_TX configuration (with WLAN SMMU)
1053  * @comp_ring: SG table describing the Tx completion ring
1054  * @comp_ring_size: size of the Tx completion ring in bytes
1055  * @ce_ring: SG table describing the Copy Engine Source Ring
1056  * @ce_door_bell_pa: physical address of the doorbell that the IPA uC has to
1057  * write into to trigger the copy engine
1058  * @ce_ring_size: Copy Engine Ring size in bytes
1059  * @num_tx_buffers: Number of pkt buffers allocated
1060  */
1061 struct ipa_wdi_dl_params_smmu {
1062         struct sg_table comp_ring;
1063         u32 comp_ring_size;
1064         struct sg_table ce_ring;
1065         phys_addr_t ce_door_bell_pa;
1066         u32 ce_ring_size;
1067         u32 num_tx_buffers;
1068 };
1069
1070 /**
1071  * struct  ipa_wdi_in_params - information provided by WDI client
1072  * @sys: IPA EP configuration info
1073  * @ul: WDI_RX configuration info
1074  * @dl: WDI_TX configuration info
1075  * @ul_smmu: WDI_RX configuration info when WLAN uses SMMU
1076  * @dl_smmu: WDI_TX configuration info when WLAN uses SMMU
1077  * @smmu_enabled: true if WLAN uses SMMU
1078  * @ipa_wdi_meter_notifier_cb: Get WDI stats and quato info
1079  */
1080 struct ipa_wdi_in_params {
1081         struct ipa_sys_connect_params sys;
1082         union {
1083                 struct ipa_wdi_ul_params ul;
1084                 struct ipa_wdi_dl_params dl;
1085                 struct ipa_wdi_ul_params_smmu ul_smmu;
1086                 struct ipa_wdi_dl_params_smmu dl_smmu;
1087         } u;
1088         bool smmu_enabled;
1089 #ifdef IPA_WAN_MSG_IPv6_ADDR_GW_LEN
1090         ipa_wdi_meter_notifier_cb wdi_notify;
1091 #endif
1092 };
1093
1094 enum ipa_upstream_type {
1095         IPA_UPSTEAM_MODEM = 1,
1096         IPA_UPSTEAM_WLAN,
1097         IPA_UPSTEAM_MAX
1098 };
1099
1100 /**
1101  * struct  ipa_wdi_out_params - information provided to WDI client
1102  * @uc_door_bell_pa: physical address of IPA uc doorbell
1103  * @clnt_hdl: opaque handle assigned to client
1104  */
1105 struct ipa_wdi_out_params {
1106         phys_addr_t uc_door_bell_pa;
1107         u32 clnt_hdl;
1108 };
1109
1110 /**
1111  * struct ipa_wdi_db_params - information provided to retrieve
1112  *       physical address of uC doorbell
1113  * @client:     type of "client" (IPA_CLIENT_WLAN#_PROD/CONS)
1114  * @uc_door_bell_pa: physical address of IPA uc doorbell
1115  */
1116 struct ipa_wdi_db_params {
1117         enum ipa_client_type client;
1118         phys_addr_t uc_door_bell_pa;
1119 };
1120
1121 /**
1122  * struct  ipa_wdi_uc_ready_params - uC ready CB parameters
1123  * @is_uC_ready: uC loaded or not
1124  * @priv : callback cookie
1125  * @notify:     callback
1126  */
1127 typedef void (*ipa_uc_ready_cb)(void *priv);
1128 struct ipa_wdi_uc_ready_params {
1129         bool is_uC_ready;
1130         void *priv;
1131         ipa_uc_ready_cb notify;
1132 };
1133
1134 /**
1135  * struct  ipa_wdi_buffer_info - address info of a WLAN allocated buffer
1136  * @pa: physical address of the buffer
1137  * @iova: IOVA of the buffer as embedded inside the WDI descriptors
1138  * @size: size in bytes of the buffer
1139  * @result: result of map or unmap operations (out param)
1140  *
1141  * IPA driver will create/release IOMMU mapping in IPA SMMU from iova->pa
1142  */
1143 struct ipa_wdi_buffer_info {
1144         phys_addr_t pa;
1145         unsigned long iova;
1146         size_t size;
1147         int result;
1148 };
1149
1150 /**
1151  * struct ipa_gsi_ep_config - IPA GSI endpoint configurations
1152  *
1153  * @ipa_ep_num: IPA EP pipe number
1154  * @ipa_gsi_chan_num: GSI channel number
1155  * @ipa_if_tlv: number of IPA_IF TLV
1156  * @ipa_if_aos: number of IPA_IF AOS
1157  * @ee: Execution environment
1158  */
1159 struct ipa_gsi_ep_config {
1160         int ipa_ep_num;
1161         int ipa_gsi_chan_num;
1162         int ipa_if_tlv;
1163         int ipa_if_aos;
1164         int ee;
1165 };
1166
1167 /**
1168  * union ipa_bam_sw_peer_desc - IPA sps sw peer desc
1169  *
1170  * @sw_dsc_ofst: software desc offset
1171  * @sw_ofst_in_desc: offset in desc
1172  * @p_dsc_fifo_peer_ofst: peer desc offset
1173  * @p_bytes_consumed: bytes consumed
1174  */
1175 union ipa_bam_sw_peer_desc {
1176         struct sw_ofsts_reg {
1177                 u32 sw_dsc_ofst:16;
1178                 u32 sw_ofst_in_desc:15;
1179         } sw_desc;
1180
1181         struct evnt_reg {
1182                 u32 p_dsc_fifo_peer_ofst:16;
1183                 u32 p_bytes_consumed:15;
1184         } peer_desc;
1185
1186         u32 read_reg;
1187 };
1188
1189 #if defined CONFIG_IPA || defined CONFIG_IPA3
1190
1191 /*
1192  * Connect / Disconnect
1193  */
1194 int ipa_connect(const struct ipa_connect_params *in, struct ipa_sps_params *sps,
1195                 u32 *clnt_hdl);
1196 int ipa_disconnect(u32 clnt_hdl);
1197
1198 /*
1199  * Resume / Suspend
1200  */
1201 int ipa_reset_endpoint(u32 clnt_hdl);
1202
1203 /*
1204  * Remove ep delay
1205  */
1206 int ipa_clear_endpoint_delay(u32 clnt_hdl);
1207
1208 /*
1209  * Disable ep
1210  */
1211 int ipa_disable_endpoint(u32 clnt_hdl);
1212
1213 /*
1214  * Configuration
1215  */
1216 int ipa_cfg_ep(u32 clnt_hdl, const struct ipa_ep_cfg *ipa_ep_cfg);
1217
1218 int ipa_cfg_ep_nat(u32 clnt_hdl, const struct ipa_ep_cfg_nat *ipa_ep_cfg);
1219
1220 int ipa_cfg_ep_hdr(u32 clnt_hdl, const struct ipa_ep_cfg_hdr *ipa_ep_cfg);
1221
1222 int ipa_cfg_ep_hdr_ext(u32 clnt_hdl,
1223                         const struct ipa_ep_cfg_hdr_ext *ipa_ep_cfg);
1224
1225 int ipa_cfg_ep_mode(u32 clnt_hdl, const struct ipa_ep_cfg_mode *ipa_ep_cfg);
1226
1227 int ipa_cfg_ep_aggr(u32 clnt_hdl, const struct ipa_ep_cfg_aggr *ipa_ep_cfg);
1228
1229 int ipa_cfg_ep_deaggr(u32 clnt_hdl,
1230                       const struct ipa_ep_cfg_deaggr *ipa_ep_cfg);
1231
1232 int ipa_cfg_ep_route(u32 clnt_hdl, const struct ipa_ep_cfg_route *ipa_ep_cfg);
1233
1234 int ipa_cfg_ep_holb(u32 clnt_hdl, const struct ipa_ep_cfg_holb *ipa_ep_cfg);
1235
1236 int ipa_cfg_ep_cfg(u32 clnt_hdl, const struct ipa_ep_cfg_cfg *ipa_ep_cfg);
1237
1238 int ipa_cfg_ep_metadata_mask(u32 clnt_hdl, const struct ipa_ep_cfg_metadata_mask
1239                 *ipa_ep_cfg);
1240
1241 int ipa_cfg_ep_holb_by_client(enum ipa_client_type client,
1242                                 const struct ipa_ep_cfg_holb *ipa_ep_cfg);
1243
1244 int ipa_cfg_ep_ctrl(u32 clnt_hdl, const struct ipa_ep_cfg_ctrl *ep_ctrl);
1245
1246 /*
1247  * Header removal / addition
1248  */
1249 int ipa_add_hdr(struct ipa_ioc_add_hdr *hdrs);
1250
1251 int ipa_add_hdr_usr(struct ipa_ioc_add_hdr *hdrs, bool user_only);
1252
1253 int ipa_del_hdr(struct ipa_ioc_del_hdr *hdls);
1254
1255 int ipa_commit_hdr(void);
1256
1257 int ipa_reset_hdr(bool user_only);
1258
1259 int ipa_get_hdr(struct ipa_ioc_get_hdr *lookup);
1260
1261 int ipa_put_hdr(u32 hdr_hdl);
1262
1263 int ipa_copy_hdr(struct ipa_ioc_copy_hdr *copy);
1264
1265 /*
1266  * Header Processing Context
1267  */
1268 int ipa_add_hdr_proc_ctx(struct ipa_ioc_add_hdr_proc_ctx *proc_ctxs,
1269                                                         bool user_only);
1270
1271 int ipa_del_hdr_proc_ctx(struct ipa_ioc_del_hdr_proc_ctx *hdls);
1272
1273 /*
1274  * Routing
1275  */
1276 int ipa_add_rt_rule(struct ipa_ioc_add_rt_rule *rules);
1277
1278 int ipa_add_rt_rule_usr(struct ipa_ioc_add_rt_rule *rules, bool user_only);
1279
1280 int ipa_del_rt_rule(struct ipa_ioc_del_rt_rule *hdls);
1281
1282 int ipa_commit_rt(enum ipa_ip_type ip);
1283
1284 int ipa_reset_rt(enum ipa_ip_type ip, bool user_only);
1285
1286 int ipa_get_rt_tbl(struct ipa_ioc_get_rt_tbl *lookup);
1287
1288 int ipa_put_rt_tbl(u32 rt_tbl_hdl);
1289
1290 int ipa_query_rt_index(struct ipa_ioc_get_rt_tbl_indx *in);
1291
1292 int ipa_mdfy_rt_rule(struct ipa_ioc_mdfy_rt_rule *rules);
1293
1294 /*
1295  * Filtering
1296  */
1297 int ipa_add_flt_rule(struct ipa_ioc_add_flt_rule *rules);
1298
1299 int ipa_add_flt_rule_usr(struct ipa_ioc_add_flt_rule *rules, bool user_only);
1300
1301 int ipa_del_flt_rule(struct ipa_ioc_del_flt_rule *hdls);
1302
1303 int ipa_mdfy_flt_rule(struct ipa_ioc_mdfy_flt_rule *rules);
1304
1305 int ipa_commit_flt(enum ipa_ip_type ip);
1306
1307 int ipa_reset_flt(enum ipa_ip_type ip, bool user_only);
1308
1309 /*
1310  * NAT
1311  */
1312 int allocate_nat_device(struct ipa_ioc_nat_alloc_mem *mem);
1313
1314 int ipa_nat_init_cmd(struct ipa_ioc_v4_nat_init *init);
1315
1316 int ipa_nat_dma_cmd(struct ipa_ioc_nat_dma_cmd *dma);
1317
1318 int ipa_nat_del_cmd(struct ipa_ioc_v4_nat_del *del);
1319
1320 /*
1321  * Messaging
1322  */
1323 int ipa_send_msg(struct ipa_msg_meta *meta, void *buff,
1324                   ipa_msg_free_fn callback);
1325 int ipa_register_pull_msg(struct ipa_msg_meta *meta, ipa_msg_pull_fn callback);
1326 int ipa_deregister_pull_msg(struct ipa_msg_meta *meta);
1327
1328 /*
1329  * Interface
1330  */
1331 int ipa_register_intf(const char *name, const struct ipa_tx_intf *tx,
1332                        const struct ipa_rx_intf *rx);
1333 int ipa_register_intf_ext(const char *name, const struct ipa_tx_intf *tx,
1334                        const struct ipa_rx_intf *rx,
1335                        const struct ipa_ext_intf *ext);
1336 int ipa_deregister_intf(const char *name);
1337
1338 /*
1339  * Aggregation
1340  */
1341 int ipa_set_aggr_mode(enum ipa_aggr_mode mode);
1342
1343 int ipa_set_qcncm_ndp_sig(char sig[3]);
1344
1345 int ipa_set_single_ndp_per_mbim(bool enable);
1346
1347 /*
1348  * Data path
1349  */
1350 int ipa_tx_dp(enum ipa_client_type dst, struct sk_buff *skb,
1351                 struct ipa_tx_meta *metadata);
1352
1353 /*
1354  * To transfer multiple data packets
1355  * While passing the data descriptor list, the anchor node
1356  * should be of type struct ipa_tx_data_desc not list_head
1357 */
1358 int ipa_tx_dp_mul(enum ipa_client_type dst,
1359                         struct ipa_tx_data_desc *data_desc);
1360
1361 void ipa_free_skb(struct ipa_rx_data *);
1362 int ipa_rx_poll(u32 clnt_hdl, int budget);
1363 void ipa_recycle_wan_skb(struct sk_buff *skb);
1364
1365 /*
1366  * System pipes
1367  */
1368 int ipa_setup_sys_pipe(struct ipa_sys_connect_params *sys_in, u32 *clnt_hdl);
1369
1370 int ipa_teardown_sys_pipe(u32 clnt_hdl);
1371
1372 int ipa_connect_wdi_pipe(struct ipa_wdi_in_params *in,
1373                 struct ipa_wdi_out_params *out);
1374 int ipa_disconnect_wdi_pipe(u32 clnt_hdl);
1375 int ipa_enable_wdi_pipe(u32 clnt_hdl);
1376 int ipa_disable_wdi_pipe(u32 clnt_hdl);
1377 int ipa_resume_wdi_pipe(u32 clnt_hdl);
1378 int ipa_suspend_wdi_pipe(u32 clnt_hdl);
1379 int ipa_get_wdi_stats(struct IpaHwStatsWDIInfoData_t *stats);
1380 u16 ipa_get_smem_restr_bytes(void);
1381 int ipa_broadcast_wdi_quota_reach_ind(uint32_t fid,
1382                 uint64_t num_bytes);
1383
1384 /*
1385  * To retrieve doorbell physical address of
1386  * wlan pipes
1387  */
1388 int ipa_uc_wdi_get_dbpa(struct ipa_wdi_db_params *out);
1389
1390 /*
1391  * To register uC ready callback if uC not ready
1392  * and also check uC readiness
1393  * if uC not ready only, register callback
1394  */
1395 int ipa_uc_reg_rdyCB(struct ipa_wdi_uc_ready_params *param);
1396 /*
1397  * To de-register uC ready callback
1398  */
1399 int ipa_uc_dereg_rdyCB(void);
1400
1401 int ipa_create_wdi_mapping(u32 num_buffers, struct ipa_wdi_buffer_info *info);
1402 int ipa_release_wdi_mapping(u32 num_buffers, struct ipa_wdi_buffer_info *info);
1403
1404 /*
1405  * Resource manager
1406  */
1407 int ipa_rm_create_resource(struct ipa_rm_create_params *create_params);
1408
1409 int ipa_rm_delete_resource(enum ipa_rm_resource_name resource_name);
1410
1411 int ipa_rm_register(enum ipa_rm_resource_name resource_name,
1412                         struct ipa_rm_register_params *reg_params);
1413
1414 int ipa_rm_deregister(enum ipa_rm_resource_name resource_name,
1415                         struct ipa_rm_register_params *reg_params);
1416
1417 int ipa_rm_set_perf_profile(enum ipa_rm_resource_name resource_name,
1418                         struct ipa_rm_perf_profile *profile);
1419
1420 int ipa_rm_add_dependency(enum ipa_rm_resource_name resource_name,
1421                         enum ipa_rm_resource_name depends_on_name);
1422
1423 int ipa_rm_add_dependency_sync(enum ipa_rm_resource_name resource_name,
1424                 enum ipa_rm_resource_name depends_on_name);
1425
1426 int ipa_rm_delete_dependency(enum ipa_rm_resource_name resource_name,
1427                         enum ipa_rm_resource_name depends_on_name);
1428
1429 int ipa_rm_request_resource(enum ipa_rm_resource_name resource_name);
1430
1431 int ipa_rm_release_resource(enum ipa_rm_resource_name resource_name);
1432
1433 int ipa_rm_notify_completion(enum ipa_rm_event event,
1434                 enum ipa_rm_resource_name resource_name);
1435
1436 int ipa_rm_inactivity_timer_init(enum ipa_rm_resource_name resource_name,
1437                                  unsigned long msecs);
1438
1439 int ipa_rm_inactivity_timer_destroy(enum ipa_rm_resource_name resource_name);
1440
1441 int ipa_rm_inactivity_timer_request_resource(
1442                                 enum ipa_rm_resource_name resource_name);
1443
1444 int ipa_rm_inactivity_timer_release_resource(
1445                                 enum ipa_rm_resource_name resource_name);
1446
1447 /*
1448  * Tethering bridge (Rmnet / MBIM)
1449  */
1450 int teth_bridge_init(struct teth_bridge_init_params *params);
1451
1452 int teth_bridge_disconnect(enum ipa_client_type client);
1453
1454 int teth_bridge_connect(struct teth_bridge_connect_params *connect_params);
1455
1456 /*
1457  * Tethering client info
1458  */
1459 void ipa_set_client(int index, enum ipacm_client_enum client, bool uplink);
1460
1461 enum ipacm_client_enum ipa_get_client(int pipe_idx);
1462
1463 bool ipa_get_client_uplink(int pipe_idx);
1464
1465 /*
1466  * IPADMA
1467  */
1468 int ipa_dma_init(void);
1469
1470 int ipa_dma_enable(void);
1471
1472 int ipa_dma_disable(void);
1473
1474 int ipa_dma_sync_memcpy(u64 dest, u64 src, int len);
1475
1476 int ipa_dma_async_memcpy(u64 dest, u64 src, int len,
1477                         void (*user_cb)(void *user1), void *user_param);
1478
1479 int ipa_dma_uc_memcpy(phys_addr_t dest, phys_addr_t src, int len);
1480
1481 void ipa_dma_destroy(void);
1482
1483 /*
1484  * mux id
1485  */
1486 int ipa_write_qmap_id(struct ipa_ioc_write_qmapid *param_in);
1487
1488 /*
1489  * interrupts
1490  */
1491 int ipa_add_interrupt_handler(enum ipa_irq_type interrupt,
1492                 ipa_irq_handler_t handler,
1493                 bool deferred_flag,
1494                 void *private_data);
1495
1496 int ipa_remove_interrupt_handler(enum ipa_irq_type interrupt);
1497
1498 int ipa_restore_suspend_handler(void);
1499
1500 /*
1501  * Miscellaneous
1502  */
1503 void ipa_bam_reg_dump(void);
1504
1505 int ipa_get_ep_mapping(enum ipa_client_type client);
1506
1507 bool ipa_is_ready(void);
1508
1509 void ipa_proxy_clk_vote(void);
1510 void ipa_proxy_clk_unvote(void);
1511
1512 enum ipa_hw_type ipa_get_hw_type(void);
1513
1514 bool ipa_is_client_handle_valid(u32 clnt_hdl);
1515
1516 enum ipa_client_type ipa_get_client_mapping(int pipe_idx);
1517
1518 enum ipa_rm_resource_name ipa_get_rm_resource_from_ep(int pipe_idx);
1519
1520 bool ipa_get_modem_cfg_emb_pipe_flt(void);
1521
1522 enum ipa_transport_type ipa_get_transport_type(void);
1523
1524 struct device *ipa_get_dma_dev(void);
1525 struct iommu_domain *ipa_get_smmu_domain(void);
1526
1527 int ipa_disable_apps_wan_cons_deaggr(uint32_t agg_size, uint32_t agg_count);
1528
1529 struct ipa_gsi_ep_config *ipa_get_gsi_ep_info(int ipa_ep_idx);
1530
1531 int ipa_stop_gsi_channel(u32 clnt_hdl);
1532
1533 typedef void (*ipa_ready_cb)(void *user_data);
1534
1535 /**
1536 * ipa_register_ipa_ready_cb() - register a callback to be invoked
1537 * when IPA core driver initialization is complete.
1538 *
1539 * @ipa_ready_cb:    CB to be triggered.
1540 * @user_data:       Data to be sent to the originator of the CB.
1541 *
1542 * Note: This function is expected to be utilized when ipa_is_ready
1543 * function returns false.
1544 * An IPA client may also use this function directly rather than
1545 * calling ipa_is_ready beforehand, as if this API returns -EEXIST,
1546 * this means IPA initialization is complete (and no callback will
1547 * be triggered).
1548 * When the callback is triggered, the client MUST perform his
1549 * operations in a different context.
1550 *
1551 * The function will return 0 on success, -ENOMEM on memory issues and
1552 * -EEXIST if IPA initialization is complete already.
1553 */
1554 int ipa_register_ipa_ready_cb(void (*ipa_ready_cb)(void *user_data),
1555                               void *user_data);
1556
1557 #else /* (CONFIG_IPA || CONFIG_IPA3) */
1558
1559 /*
1560  * Connect / Disconnect
1561  */
1562 static inline int ipa_connect(const struct ipa_connect_params *in,
1563                 struct ipa_sps_params *sps,     u32 *clnt_hdl)
1564 {
1565         return -EPERM;
1566 }
1567
1568 static inline int ipa_disconnect(u32 clnt_hdl)
1569 {
1570         return -EPERM;
1571 }
1572
1573 /*
1574  * Resume / Suspend
1575  */
1576 static inline int ipa_reset_endpoint(u32 clnt_hdl)
1577 {
1578         return -EPERM;
1579 }
1580
1581 /*
1582  * Remove ep delay
1583  */
1584 static inline int ipa_clear_endpoint_delay(u32 clnt_hdl)
1585 {
1586         return -EPERM;
1587 }
1588
1589 /*
1590  * Disable ep
1591  */
1592 static inline int ipa_disable_endpoint(u32 clnt_hdl)
1593 {
1594         return -EPERM;
1595 }
1596
1597 /*
1598  * Configuration
1599  */
1600 static inline int ipa_cfg_ep(u32 clnt_hdl,
1601                 const struct ipa_ep_cfg *ipa_ep_cfg)
1602 {
1603         return -EPERM;
1604 }
1605
1606 static inline int ipa_cfg_ep_nat(u32 clnt_hdl,
1607                 const struct ipa_ep_cfg_nat *ipa_ep_cfg)
1608 {
1609         return -EPERM;
1610 }
1611
1612 static inline int ipa_cfg_ep_hdr(u32 clnt_hdl,
1613                 const struct ipa_ep_cfg_hdr *ipa_ep_cfg)
1614 {
1615         return -EPERM;
1616 }
1617
1618 static inline int ipa_cfg_ep_hdr_ext(u32 clnt_hdl,
1619                 const struct ipa_ep_cfg_hdr_ext *ipa_ep_cfg)
1620 {
1621         return -EPERM;
1622 }
1623
1624 static inline int ipa_cfg_ep_mode(u32 clnt_hdl,
1625                 const struct ipa_ep_cfg_mode *ipa_ep_cfg)
1626 {
1627         return -EPERM;
1628 }
1629
1630 static inline int ipa_cfg_ep_aggr(u32 clnt_hdl,
1631                 const struct ipa_ep_cfg_aggr *ipa_ep_cfg)
1632 {
1633         return -EPERM;
1634 }
1635
1636 static inline int ipa_cfg_ep_deaggr(u32 clnt_hdl,
1637                 const struct ipa_ep_cfg_deaggr *ipa_ep_cfg)
1638 {
1639         return -EPERM;
1640 }
1641
1642 static inline int ipa_cfg_ep_route(u32 clnt_hdl,
1643                 const struct ipa_ep_cfg_route *ipa_ep_cfg)
1644 {
1645         return -EPERM;
1646 }
1647
1648 static inline int ipa_cfg_ep_holb(u32 clnt_hdl,
1649                 const struct ipa_ep_cfg_holb *ipa_ep_cfg)
1650 {
1651         return -EPERM;
1652 }
1653
1654 static inline int ipa_cfg_ep_cfg(u32 clnt_hdl,
1655                 const struct ipa_ep_cfg_cfg *ipa_ep_cfg)
1656 {
1657         return -EPERM;
1658 }
1659
1660 static inline int ipa_cfg_ep_metadata_mask(u32 clnt_hdl,
1661                 const struct ipa_ep_cfg_metadata_mask *ipa_ep_cfg)
1662 {
1663         return -EPERM;
1664 }
1665
1666 static inline int ipa_cfg_ep_ctrl(u32 clnt_hdl,
1667                         const struct ipa_ep_cfg_ctrl *ep_ctrl)
1668 {
1669         return -EPERM;
1670 }
1671
1672 /*
1673  * Header removal / addition
1674  */
1675 static inline int ipa_add_hdr(struct ipa_ioc_add_hdr *hdrs)
1676 {
1677         return -EPERM;
1678 }
1679
1680 static inline int ipa_add_hdr_usr(struct ipa_ioc_add_hdr *hdrs,
1681                                 bool user_only)
1682 {
1683         return -EPERM;
1684 }
1685
1686 static inline int ipa_del_hdr(struct ipa_ioc_del_hdr *hdls)
1687 {
1688         return -EPERM;
1689 }
1690
1691 static inline int ipa_commit_hdr(void)
1692 {
1693         return -EPERM;
1694 }
1695
1696 static inline int ipa_reset_hdr(bool user_only)
1697 {
1698         return -EPERM;
1699 }
1700
1701 static inline int ipa_get_hdr(struct ipa_ioc_get_hdr *lookup)
1702 {
1703         return -EPERM;
1704 }
1705
1706 static inline int ipa_put_hdr(u32 hdr_hdl)
1707 {
1708         return -EPERM;
1709 }
1710
1711 static inline int ipa_copy_hdr(struct ipa_ioc_copy_hdr *copy)
1712 {
1713         return -EPERM;
1714 }
1715
1716 /*
1717  * Header Processing Context
1718  */
1719 static inline int ipa_add_hdr_proc_ctx(
1720                                 struct ipa_ioc_add_hdr_proc_ctx *proc_ctxs,
1721                                 bool user_only)
1722 {
1723         return -EPERM;
1724 }
1725
1726 static inline int ipa_del_hdr_proc_ctx(struct ipa_ioc_del_hdr_proc_ctx *hdls)
1727 {
1728         return -EPERM;
1729 }
1730 /*
1731  * Routing
1732  */
1733 static inline int ipa_add_rt_rule(struct ipa_ioc_add_rt_rule *rules)
1734 {
1735         return -EPERM;
1736 }
1737
1738 static inline int ipa_add_rt_rule_usr(struct ipa_ioc_add_rt_rule *rules,
1739                                         bool user_only)
1740 {
1741         return -EPERM;
1742 }
1743
1744 static inline int ipa_del_rt_rule(struct ipa_ioc_del_rt_rule *hdls)
1745 {
1746         return -EPERM;
1747 }
1748
1749 static inline int ipa_commit_rt(enum ipa_ip_type ip)
1750 {
1751         return -EPERM;
1752 }
1753
1754 static inline int ipa_reset_rt(enum ipa_ip_type ip, bool user_only)
1755 {
1756         return -EPERM;
1757 }
1758
1759 static inline int ipa_get_rt_tbl(struct ipa_ioc_get_rt_tbl *lookup)
1760 {
1761         return -EPERM;
1762 }
1763
1764 static inline int ipa_put_rt_tbl(u32 rt_tbl_hdl)
1765 {
1766         return -EPERM;
1767 }
1768
1769 static inline int ipa_query_rt_index(struct ipa_ioc_get_rt_tbl_indx *in)
1770 {
1771         return -EPERM;
1772 }
1773
1774 static inline int ipa_mdfy_rt_rule(struct ipa_ioc_mdfy_rt_rule *rules)
1775 {
1776         return -EPERM;
1777 }
1778
1779 /*
1780  * Filtering
1781  */
1782 static inline int ipa_add_flt_rule(struct ipa_ioc_add_flt_rule *rules)
1783 {
1784         return -EPERM;
1785 }
1786
1787 static inline int ipa_add_flt_rule_usr(struct ipa_ioc_add_flt_rule *rules,
1788                                         bool user_only)
1789 {
1790         return -EPERM;
1791 }
1792
1793 static inline int ipa_del_flt_rule(struct ipa_ioc_del_flt_rule *hdls)
1794 {
1795         return -EPERM;
1796 }
1797
1798 static inline int ipa_mdfy_flt_rule(struct ipa_ioc_mdfy_flt_rule *rules)
1799 {
1800         return -EPERM;
1801 }
1802
1803 static inline int ipa_commit_flt(enum ipa_ip_type ip)
1804 {
1805         return -EPERM;
1806 }
1807
1808 static inline int ipa_reset_flt(enum ipa_ip_type ip, bool user_only)
1809 {
1810         return -EPERM;
1811 }
1812
1813 /*
1814  * NAT
1815  */
1816 static inline int allocate_nat_device(struct ipa_ioc_nat_alloc_mem *mem)
1817 {
1818         return -EPERM;
1819 }
1820
1821
1822 static inline int ipa_nat_init_cmd(struct ipa_ioc_v4_nat_init *init)
1823 {
1824         return -EPERM;
1825 }
1826
1827
1828 static inline int ipa_nat_dma_cmd(struct ipa_ioc_nat_dma_cmd *dma)
1829 {
1830         return -EPERM;
1831 }
1832
1833
1834 static inline int ipa_nat_del_cmd(struct ipa_ioc_v4_nat_del *del)
1835 {
1836         return -EPERM;
1837 }
1838
1839 /*
1840  * Messaging
1841  */
1842 static inline int ipa_send_msg(struct ipa_msg_meta *meta, void *buff,
1843                 ipa_msg_free_fn callback)
1844 {
1845         return -EPERM;
1846 }
1847
1848 static inline int ipa_register_pull_msg(struct ipa_msg_meta *meta,
1849                 ipa_msg_pull_fn callback)
1850 {
1851         return -EPERM;
1852 }
1853
1854 static inline int ipa_deregister_pull_msg(struct ipa_msg_meta *meta)
1855 {
1856         return -EPERM;
1857 }
1858
1859 /*
1860  * Interface
1861  */
1862 static inline int ipa_register_intf(const char *name,
1863                                      const struct ipa_tx_intf *tx,
1864                                      const struct ipa_rx_intf *rx)
1865 {
1866         return -EPERM;
1867 }
1868
1869 static inline int ipa_register_intf_ext(const char *name,
1870                 const struct ipa_tx_intf *tx,
1871                 const struct ipa_rx_intf *rx,
1872                 const struct ipa_ext_intf *ext)
1873 {
1874         return -EPERM;
1875 }
1876
1877 static inline int ipa_deregister_intf(const char *name)
1878 {
1879         return -EPERM;
1880 }
1881
1882 /*
1883  * Aggregation
1884  */
1885 static inline int ipa_set_aggr_mode(enum ipa_aggr_mode mode)
1886 {
1887         return -EPERM;
1888 }
1889
1890 static inline int ipa_set_qcncm_ndp_sig(char sig[3])
1891 {
1892         return -EPERM;
1893 }
1894
1895 static inline int ipa_set_single_ndp_per_mbim(bool enable)
1896 {
1897         return -EPERM;
1898 }
1899
1900 /*
1901  * Data path
1902  */
1903 static inline int ipa_tx_dp(enum ipa_client_type dst, struct sk_buff *skb,
1904                 struct ipa_tx_meta *metadata)
1905 {
1906         return -EPERM;
1907 }
1908
1909 /*
1910  * To transfer multiple data packets
1911  */
1912 static inline int ipa_tx_dp_mul(
1913         enum ipa_client_type dst,
1914         struct ipa_tx_data_desc *data_desc)
1915 {
1916         return -EPERM;
1917 }
1918
1919 static inline void ipa_free_skb(struct ipa_rx_data *rx_in)
1920 {
1921         return;
1922 }
1923
1924 static inline int ipa_rx_poll(u32 clnt_hdl, int budget)
1925 {
1926         return -EPERM;
1927 }
1928
1929 static inline void ipa_recycle_wan_skb(struct sk_buff *skb)
1930 {
1931 }
1932
1933 /*
1934  * System pipes
1935  */
1936 static inline u16 ipa_get_smem_restr_bytes(void)
1937 {
1938         return -EPERM;
1939 }
1940
1941 static inline int ipa_setup_sys_pipe(struct ipa_sys_connect_params *sys_in,
1942                 u32 *clnt_hdl)
1943 {
1944         return -EPERM;
1945 }
1946
1947 static inline int ipa_teardown_sys_pipe(u32 clnt_hdl)
1948 {
1949         return -EPERM;
1950 }
1951
1952 static inline int ipa_connect_wdi_pipe(struct ipa_wdi_in_params *in,
1953                 struct ipa_wdi_out_params *out)
1954 {
1955         return -EPERM;
1956 }
1957
1958 static inline int ipa_disconnect_wdi_pipe(u32 clnt_hdl)
1959 {
1960         return -EPERM;
1961 }
1962
1963 static inline int ipa_enable_wdi_pipe(u32 clnt_hdl)
1964 {
1965         return -EPERM;
1966 }
1967
1968 static inline int ipa_disable_wdi_pipe(u32 clnt_hdl)
1969 {
1970         return -EPERM;
1971 }
1972
1973 static inline int ipa_resume_wdi_pipe(u32 clnt_hdl)
1974 {
1975         return -EPERM;
1976 }
1977
1978 static inline int ipa_suspend_wdi_pipe(u32 clnt_hdl)
1979 {
1980         return -EPERM;
1981 }
1982
1983 static inline int ipa_broadcast_wdi_quota_reach_ind(uint32_t fid,
1984                 uint64_t num_bytes)
1985 {
1986         return -EPERM;
1987 }
1988
1989 static inline int ipa_uc_wdi_get_dbpa(
1990         struct ipa_wdi_db_params *out)
1991 {
1992         return -EPERM;
1993 }
1994
1995 static inline int ipa_uc_reg_rdyCB(
1996         struct ipa_wdi_uc_ready_params *param)
1997 {
1998         return -EPERM;
1999 }
2000
2001 static inline int ipa_uc_dereg_rdyCB(void)
2002 {
2003         return -EPERM;
2004 }
2005
2006
2007 /*
2008  * Resource manager
2009  */
2010 static inline int ipa_rm_create_resource(
2011                 struct ipa_rm_create_params *create_params)
2012 {
2013         return -EPERM;
2014 }
2015
2016 static inline int ipa_rm_delete_resource(
2017                 enum ipa_rm_resource_name resource_name)
2018 {
2019         return -EPERM;
2020 }
2021
2022 static inline int ipa_rm_register(enum ipa_rm_resource_name resource_name,
2023                         struct ipa_rm_register_params *reg_params)
2024 {
2025         return -EPERM;
2026 }
2027
2028 static inline int ipa_rm_set_perf_profile(
2029                 enum ipa_rm_resource_name resource_name,
2030                 struct ipa_rm_perf_profile *profile)
2031 {
2032         return -EPERM;
2033 }
2034
2035 static inline int ipa_rm_deregister(enum ipa_rm_resource_name resource_name,
2036                         struct ipa_rm_register_params *reg_params)
2037 {
2038         return -EPERM;
2039 }
2040
2041 static inline int ipa_rm_add_dependency(
2042                 enum ipa_rm_resource_name resource_name,
2043                 enum ipa_rm_resource_name depends_on_name)
2044 {
2045         return -EPERM;
2046 }
2047
2048 static inline int ipa_rm_add_dependency_sync(
2049                 enum ipa_rm_resource_name resource_name,
2050                 enum ipa_rm_resource_name depends_on_name)
2051 {
2052         return -EPERM;
2053 }
2054
2055 static inline int ipa_rm_delete_dependency(
2056                 enum ipa_rm_resource_name resource_name,
2057                 enum ipa_rm_resource_name depends_on_name)
2058 {
2059         return -EPERM;
2060 }
2061
2062 static inline int ipa_rm_request_resource(
2063                 enum ipa_rm_resource_name resource_name)
2064 {
2065         return -EPERM;
2066 }
2067
2068 static inline int ipa_rm_release_resource(
2069                 enum ipa_rm_resource_name resource_name)
2070 {
2071         return -EPERM;
2072 }
2073
2074 static inline int ipa_rm_notify_completion(enum ipa_rm_event event,
2075                 enum ipa_rm_resource_name resource_name)
2076 {
2077         return -EPERM;
2078 }
2079
2080 static inline int ipa_rm_inactivity_timer_init(
2081                 enum ipa_rm_resource_name resource_name,
2082                         unsigned long msecs)
2083 {
2084         return -EPERM;
2085 }
2086
2087 static inline int ipa_rm_inactivity_timer_destroy(
2088                 enum ipa_rm_resource_name resource_name)
2089 {
2090         return -EPERM;
2091 }
2092
2093 static inline int ipa_rm_inactivity_timer_request_resource(
2094                                 enum ipa_rm_resource_name resource_name)
2095 {
2096         return -EPERM;
2097 }
2098
2099 static inline int ipa_rm_inactivity_timer_release_resource(
2100                                 enum ipa_rm_resource_name resource_name)
2101 {
2102         return -EPERM;
2103 }
2104
2105 /*
2106  * Tethering bridge (Rmnet / MBIM)
2107  */
2108 static inline int teth_bridge_init(struct teth_bridge_init_params *params)
2109 {
2110         return -EPERM;
2111 }
2112
2113 static inline int teth_bridge_disconnect(enum ipa_client_type client)
2114 {
2115         return -EPERM;
2116 }
2117
2118 static inline int teth_bridge_connect(struct teth_bridge_connect_params
2119                                       *connect_params)
2120 {
2121         return -EPERM;
2122 }
2123
2124 /*
2125  * Tethering client info
2126  */
2127 static inline void ipa_set_client(int index, enum ipacm_client_enum client,
2128         bool uplink)
2129 {
2130         return;
2131 }
2132
2133 static inline enum ipacm_client_enum ipa_get_client(int pipe_idx)
2134 {
2135         return -EPERM;
2136 }
2137
2138 static inline bool ipa_get_client_uplink(int pipe_idx)
2139 {
2140         return -EPERM;
2141 }
2142
2143 /*
2144  * IPADMA
2145  */
2146 static inline int ipa_dma_init(void)
2147 {
2148         return -EPERM;
2149 }
2150
2151 static inline int ipa_dma_enable(void)
2152 {
2153         return -EPERM;
2154 }
2155
2156 static inline int ipa_dma_disable(void)
2157 {
2158         return -EPERM;
2159 }
2160
2161 static inline int ipa_dma_sync_memcpy(phys_addr_t dest, phys_addr_t src
2162                         , int len)
2163 {
2164         return -EPERM;
2165 }
2166
2167 static inline int ipa_dma_async_memcpy(phys_addr_t dest, phys_addr_t src
2168                         , int len, void (*user_cb)(void *user1),
2169                         void *user_param)
2170 {
2171         return -EPERM;
2172 }
2173
2174 static inline int ipa_dma_uc_memcpy(phys_addr_t dest, phys_addr_t src, int len)
2175 {
2176         return -EPERM;
2177 }
2178
2179 static inline void ipa_dma_destroy(void)
2180 {
2181         return;
2182 }
2183
2184 /*
2185  * mux id
2186  */
2187 static inline int ipa_write_qmap_id(struct ipa_ioc_write_qmapid *param_in)
2188 {
2189         return -EPERM;
2190 }
2191
2192 /*
2193  * interrupts
2194  */
2195 static inline int ipa_add_interrupt_handler(enum ipa_irq_type interrupt,
2196                 ipa_irq_handler_t handler,
2197                 bool deferred_flag,
2198                 void *private_data)
2199 {
2200         return -EPERM;
2201 }
2202
2203 static inline int ipa_remove_interrupt_handler(enum ipa_irq_type interrupt)
2204 {
2205         return -EPERM;
2206 }
2207
2208 static inline int ipa_restore_suspend_handler(void)
2209 {
2210         return -EPERM;
2211 }
2212
2213 /*
2214  * Miscellaneous
2215  */
2216 static inline void ipa_bam_reg_dump(void)
2217 {
2218         return;
2219 }
2220
2221 static inline int ipa_get_wdi_stats(struct IpaHwStatsWDIInfoData_t *stats)
2222 {
2223         return -EPERM;
2224 }
2225
2226 static inline int ipa_get_ep_mapping(enum ipa_client_type client)
2227 {
2228         return -EPERM;
2229 }
2230
2231 static inline bool ipa_is_ready(void)
2232 {
2233         return false;
2234 }
2235
2236 static inline void ipa_proxy_clk_vote(void)
2237 {
2238 }
2239
2240 static inline void ipa_proxy_clk_unvote(void)
2241 {
2242 }
2243
2244 static inline enum ipa_hw_type ipa_get_hw_type(void)
2245 {
2246         return IPA_HW_None;
2247 }
2248
2249 static inline bool ipa_is_client_handle_valid(u32 clnt_hdl)
2250 {
2251         return -EINVAL;
2252 }
2253
2254 static inline enum ipa_client_type ipa_get_client_mapping(int pipe_idx)
2255 {
2256         return -EINVAL;
2257 }
2258
2259 static inline enum ipa_rm_resource_name ipa_get_rm_resource_from_ep(
2260         int pipe_idx)
2261 {
2262         return -EFAULT;
2263 }
2264
2265 static inline bool ipa_get_modem_cfg_emb_pipe_flt(void)
2266 {
2267         return -EINVAL;
2268 }
2269
2270 static inline enum ipa_transport_type ipa_get_transport_type(void)
2271 {
2272         return -EFAULT;
2273 }
2274
2275 static inline struct device *ipa_get_dma_dev(void)
2276 {
2277         return NULL;
2278 }
2279
2280 static inline struct iommu_domain *ipa_get_smmu_domain(void)
2281 {
2282         return NULL;
2283 }
2284
2285 static inline int ipa_create_wdi_mapping(u32 num_buffers,
2286                 struct ipa_wdi_buffer_info *info)
2287 {
2288         return -EINVAL;
2289 }
2290
2291 static inline int ipa_release_wdi_mapping(u32 num_buffers,
2292                 struct ipa_wdi_buffer_info *info)
2293 {
2294         return -EINVAL;
2295 }
2296
2297 static inline int ipa_disable_apps_wan_cons_deaggr(void)
2298 {
2299         return -EINVAL;
2300 }
2301
2302 static inline struct ipa_gsi_ep_config *ipa_get_gsi_ep_info(int ipa_ep_idx)
2303 {
2304         return NULL;
2305 }
2306
2307 static inline int ipa_stop_gsi_channel(u32 clnt_hdl)
2308 {
2309         return -EPERM;
2310 }
2311
2312 static inline int ipa_register_ipa_ready_cb(
2313         void (*ipa_ready_cb)(void *user_data),
2314         void *user_data)
2315 {
2316         return -EPERM;
2317 }
2318
2319 #endif /* (CONFIG_IPA || CONFIG_IPA3) */
2320
2321 #endif /* _IPA_H_ */