Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
kernel-fxtec-pro1x/include/linux/ipa.h
Shilpa Suresh 0f1b035635 usb: gadget: f_qc_rndis: Add RNDIS support using IPA over BAM2BAM 
On some targets RNDIS function uses BAM to BAM transport,
and is handled by the f_qc_rndis driver. This change
adds RNDIS support using IPA over BAM2BAM.
This is snapshot of the qcrndis driver as of kernel
msm-4.9 'commit e4c6a37f8770697d4 ("msm: vidc: avoid OOB
write while accessing memory")'.

Change-Id: I34e9ab6ca25ea515a36ffd54216a09177e5fa746
Signed-off-by: Shilpa Suresh <sbsure@codeaurora.org>
Signed-off-by: Chetan C R <cchinnad@codeaurora.org>
Signed-off-by: Swetha Chikkaboraiah <schikk@codeaurora.org>
2020-11-19 13:33:31 +05:30

2699 lines
69 KiB
C
Raw Blame History

/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
*/
#ifndef _IPA_H_
#define _IPA_H_
#include <linux/msm_ipa.h>
#include <linux/skbuff.h>
#include <linux/types.h>
#include <linux/if_ether.h>
#include "linux/msm_gsi.h"
#include <linux/msm-sps.h>
#define IPA_APPS_MAX_BW_IN_MBPS 700
#define IPA_BW_THRESHOLD_MAX 3
#define IPA_MAX_CH_STATS_SUPPORTED 5
/**
* enum ipa_transport_type
* transport type: either GSI or SPS
*/
enum ipa_transport_type {
IPA_TRANSPORT_TYPE_SPS,
IPA_TRANSPORT_TYPE_GSI
};
/**
* enum ipa_nat_en_type - NAT setting type in IPA end-point
*/
enum ipa_nat_en_type {
IPA_BYPASS_NAT,
IPA_SRC_NAT,
IPA_DST_NAT,
};
/**
* enum ipa_ipv6ct_en_type - IPv6CT setting type in IPA end-point
*/
enum ipa_ipv6ct_en_type {
IPA_BYPASS_IPV6CT,
IPA_ENABLE_IPV6CT,
};
/**
* enum ipa_mode_type - mode setting type in IPA end-point
* @BASIC: basic mode
* @ENABLE_FRAMING_HDLC: not currently supported
* @ENABLE_DEFRAMING_HDLC: not currently supported
* @DMA: all data arriving IPA will not go through IPA logic blocks, this
* allows IPA to work as DMA for specific pipes.
*/
enum ipa_mode_type {
IPA_BASIC,
IPA_ENABLE_FRAMING_HDLC,
IPA_ENABLE_DEFRAMING_HDLC,
IPA_DMA,
};
/**
* enum ipa_aggr_en_type - aggregation setting type in IPA
* end-point
*/
enum ipa_aggr_en_type {
IPA_BYPASS_AGGR,
IPA_ENABLE_AGGR,
IPA_ENABLE_DEAGGR,
};
/**
* enum ipa_aggr_type - type of aggregation in IPA end-point
*/
enum ipa_aggr_type {
IPA_MBIM_16 = 0,
IPA_HDLC = 1,
IPA_TLP = 2,
IPA_RNDIS = 3,
IPA_GENERIC = 4,
IPA_COALESCE = 5,
IPA_QCMAP = 6,
};
/**
* enum ipa_aggr_mode - global aggregation mode
*/
enum ipa_aggr_mode {
IPA_MBIM_AGGR,
IPA_QCNCM_AGGR,
};
/**
* enum ipa_dp_evt_type - type of event client callback is
* invoked for on data path
* @IPA_RECEIVE: data is struct sk_buff
* @IPA_WRITE_DONE: data is struct sk_buff
*/
enum ipa_dp_evt_type {
IPA_RECEIVE,
IPA_WRITE_DONE,
IPA_CLIENT_START_POLL,
IPA_CLIENT_COMP_NAPI,
};
/**
* enum hdr_total_len_or_pad_type - type of value held by TOTAL_LEN_OR_PAD
* field in header configuration register.
* @IPA_HDR_PAD: field is used as padding length
* @IPA_HDR_TOTAL_LEN: field is used as total length
*/
enum hdr_total_len_or_pad_type {
IPA_HDR_PAD = 0,
IPA_HDR_TOTAL_LEN = 1,
};
/**
* struct ipa_ep_cfg_nat - NAT configuration in IPA end-point
* @nat_en: This defines the default NAT mode for the pipe: in case of
* filter miss - the default NAT mode defines the NATing operation
* on the packet. Valid for Input Pipes only (IPA consumer)
*/
struct ipa_ep_cfg_nat {
enum ipa_nat_en_type nat_en;
};
/**
* struct ipa_ep_cfg_conn_track - IPv6 Connection tracking configuration in
* IPA end-point
* @conn_track_en: Defines speculative conn_track action, means if specific
* pipe needs to have UL/DL IPv6 Connection Tracking or Bypass
* IPv6 Connection Tracking. 0: Bypass IPv6 Connection Tracking
* 1: IPv6 UL/DL Connection Tracking.
* Valid for Input Pipes only (IPA consumer)
*/
struct ipa_ep_cfg_conn_track {
enum ipa_ipv6ct_en_type conn_track_en;
};
/**
* struct ipa_ep_cfg_hdr - header configuration in IPA end-point
*
* @hdr_len:Header length in bytes to be added/removed. Assuming
* header len is constant per endpoint. Valid for
* both Input and Output Pipes
* @hdr_ofst_metadata_valid: 0: Metadata_Ofst value is invalid, i.e., no
* metadata within header.
* 1: Metadata_Ofst value is valid, i.e., metadata
* within header is in offset Metadata_Ofst Valid
* for Input Pipes only (IPA Consumer) (for output
* pipes, metadata already set within the header)
* @hdr_ofst_metadata: Offset within header in which metadata resides
* Size of metadata - 4bytes
* Example - Stream ID/SSID/mux ID.
* Valid for Input Pipes only (IPA Consumer) (for output
* pipes, metadata already set within the header)
* @hdr_additional_const_len: Defines the constant length that should be added
* to the payload length in order for IPA to update
* correctly the length field within the header
* (valid only in case Hdr_Ofst_Pkt_Size_Valid=1)
* Valid for Output Pipes (IPA Producer)
* Starting IPA4.5, this field in H/W requires more bits
* to support larger range, but no spare bits to use.
* So the MSB part is done thourgh the EXT register.
* When accessing this register, need to access the EXT
* register as well.
* @hdr_ofst_pkt_size_valid: 0: Hdr_Ofst_Pkt_Size value is invalid, i.e., no
* length field within the inserted header
* 1: Hdr_Ofst_Pkt_Size value is valid, i.e., a
* packet length field resides within the header
* Valid for Output Pipes (IPA Producer)
* @hdr_ofst_pkt_size: Offset within header in which packet size reside. Upon
* Header Insertion, IPA will update this field within the
* header with the packet length . Assumption is that
* header length field size is constant and is 2Bytes
* Valid for Output Pipes (IPA Producer)
* Starting IPA4.5, this field in H/W requires more bits
* to support larger range, but no spare bits to use.
* So the MSB part is done thourgh the EXT register.
* When accessing this register, need to access the EXT
* register as well.
* @hdr_a5_mux: Determines whether A5 Mux header should be added to the packet.
* This bit is valid only when Hdr_En=01(Header Insertion)
* SW should set this bit for IPA-to-A5 pipes.
* 0: Do not insert A5 Mux Header
* 1: Insert A5 Mux Header
* Valid for Output Pipes (IPA Producer)
* @hdr_remove_additional: bool switch, remove more of the header
* based on the aggregation configuration (register
* HDR_LEN_INC_DEAGG_HDR)
* @hdr_metadata_reg_valid: bool switch, metadata from
* register INIT_HDR_METADATA_n is valid.
* (relevant only for IPA Consumer pipes)
* Starting IPA4.5, this parameter is irrelevant and H/W
* assumes it is always valid.
*/
struct ipa_ep_cfg_hdr {
u32 hdr_len;
u32 hdr_ofst_metadata_valid;
u32 hdr_ofst_metadata;
u32 hdr_additional_const_len;
u32 hdr_ofst_pkt_size_valid;
u32 hdr_ofst_pkt_size;
u32 hdr_a5_mux;
u32 hdr_remove_additional;
u32 hdr_metadata_reg_valid;
};
/**
* struct ipa_ep_cfg_hdr_ext - extended header configuration in IPA end-point
* @hdr_pad_to_alignment: Pad packet to specified alignment
* (2^pad to alignment value), i.e. value of 3 means pad to 2^3 = 8 bytes
* alignment. Alignment is to 0,2 up to 32 bytes (IPAv2 does not support 64
* byte alignment). Valid for Output Pipes only (IPA Producer).
* @hdr_total_len_or_pad_offset: Offset to length field containing either
* total length or pad length, per hdr_total_len_or_pad config
* @hdr_payload_len_inc_padding: 0-IPA_ENDP_INIT_HDR_n's
* HDR_OFST_PKT_SIZE does
* not includes padding bytes size, payload_len = packet length,
* 1-IPA_ENDP_INIT_HDR_n's HDR_OFST_PKT_SIZE includes
* padding bytes size, payload_len = packet length + padding
* @hdr_total_len_or_pad: field is used as PAD length ot as Total length
* (header + packet + padding)
* @hdr_total_len_or_pad_valid: 0-Ignore TOTAL_LEN_OR_PAD field, 1-Process
* TOTAL_LEN_OR_PAD field
* @hdr_little_endian: 0-Big Endian, 1-Little Endian
* @hdr: The header structure. Used starting IPA4.5 where part of the info
* at the header structure is implemented via the EXT register at the H/W
*/
struct ipa_ep_cfg_hdr_ext {
u32 hdr_pad_to_alignment;
u32 hdr_total_len_or_pad_offset;
bool hdr_payload_len_inc_padding;
enum hdr_total_len_or_pad_type hdr_total_len_or_pad;
bool hdr_total_len_or_pad_valid;
bool hdr_little_endian;
struct ipa_ep_cfg_hdr *hdr;
};
/**
* struct ipa_ep_cfg_mode - mode configuration in IPA end-point
* @mode: Valid for Input Pipes only (IPA Consumer)
* @dst: This parameter specifies the output pipe to which the packets
* will be routed to.
* This parameter is valid for Mode=DMA and not valid for
* Mode=Basic
* Valid for Input Pipes only (IPA Consumer)
*/
struct ipa_ep_cfg_mode {
enum ipa_mode_type mode;
enum ipa_client_type dst;
};
/**
* struct ipa_ep_cfg_aggr - aggregation configuration in IPA end-point
*
* @aggr_en: Valid for both Input and Output Pipes
* @aggr: aggregation type (Valid for both Input and Output Pipes)
* @aggr_byte_limit: Limit of aggregated packet size in KB (<=32KB) When set
* to 0, there is no size limitation on the aggregation.
* When both, Aggr_Byte_Limit and Aggr_Time_Limit are set
* to 0, there is no aggregation, every packet is sent
* independently according to the aggregation structure
* Valid for Output Pipes only (IPA Producer )
* @aggr_time_limit: Timer to close aggregated packet When set to 0,
* there is no time limitation on the aggregation. When
* both, Aggr_Byte_Limit and Aggr_Time_Limit are set to 0,
* there is no aggregation, every packet is sent
* independently according to the aggregation structure
* Valid for Output Pipes only (IPA Producer).
* Time unit is -->> usec <<--
* @aggr_pkt_limit: Defines if EOF close aggregation or not. if set to false
* HW closes aggregation (sends EOT) only based on its
* aggregation config (byte/time limit, etc). if set to
* true EOF closes aggregation in addition to HW based
* aggregation closure. Valid for Output Pipes only (IPA
* Producer). EOF affects only Pipes configured for
* generic aggregation.
* @aggr_hard_byte_limit_en: If set to 1, byte-limit aggregation for this
* pipe will apply a hard-limit behavior which will not
* allow frames to be closed with more than byte-limit
* bytes. If set to 0, previous byte-limit behavior
* will apply - frames close once a packet causes the
* accumulated byte-count to cross the byte-limit
* threshold (closed frame will contain that packet).
* @aggr_sw_eof_active: 0: EOF does not close aggregation. HW closes aggregation
* (sends EOT) only based on its aggregation config
* (byte/time limit, etc).
* 1: EOF closes aggregation in addition to HW based
* aggregation closure. Valid for Output Pipes only (IPA
* Producer). EOF affects only Pipes configured for generic
* aggregation.
* @pulse_generator: Pulse generator number to be used.
* For internal use.
* Supported starting IPA4.5.
* @scaled_time: Time limit in accordance to the pulse generator
* granularity.
* For internal use
* Supported starting IPA4.5
*/
struct ipa_ep_cfg_aggr {
enum ipa_aggr_en_type aggr_en;
enum ipa_aggr_type aggr;
u32 aggr_byte_limit;
u32 aggr_time_limit;
u32 aggr_pkt_limit;
u32 aggr_hard_byte_limit_en;
bool aggr_sw_eof_active;
u8 pulse_generator;
u8 scaled_time;
};
/**
* struct ipa_ep_cfg_route - route configuration in IPA end-point
* @rt_tbl_hdl: Defines the default routing table index to be used in case there
* is no filter rule matching, valid for Input Pipes only (IPA
* Consumer). Clients should set this to 0 which will cause default
* v4 and v6 routes setup internally by IPA driver to be used for
* this end-point
*/
struct ipa_ep_cfg_route {
u32 rt_tbl_hdl;
};
/**
* struct ipa_ep_cfg_holb - head of line blocking configuration in IPA end-point
* @en: enable(1 => ok to drop pkt)/disable(0 => never drop pkt)
* @tmr_val: duration in units of 128 IPA clk clock cyles [0,511], 1 clk=1.28us
* IPAv2.5 support 32 bit HOLB timeout value, previous versions
* supports 16 bit
* IPAv4.2: splitting timer value into 2 fields. Timer value is:
* BASE_VALUE * (2^SCALE)
* IPA4.5: tmr_val is in -->>msec<<--. Range is dynamic based
* on H/W configuration. (IPA4.5 absolute maximum is 0.65535*31 -> ~20sec).
* @base_val : IPA4.2 only field. base value of the timer.
* @scale : IPA4.2 only field. scale value for timer.
* @pulse_generator: Pulse generator number to be used.
* For internal use.
* Supported starting IPA4.5.
* @scaled_time: Time limit in accordance to the pulse generator granularity
* For internal use
* Supported starting IPA4.5
*/
struct ipa_ep_cfg_holb {
u32 tmr_val;
u32 base_val;
u32 scale;
u16 en;
u8 pulse_generator;
u8 scaled_time;
};
/**
* struct ipa_ep_cfg_deaggr - deaggregation configuration in IPA end-point
* @deaggr_hdr_len: Deaggregation Header length in bytes. Valid only for Input
* Pipes, which are configured for 'Generic' deaggregation.
* @syspipe_err_detection - If set to 1, enables error detection for
* de-aggregration. Valid only for Input Pipes, which are configured
* for 'Generic' deaggregation.
* Note: if this bit is set, de-aggregated frames must be contiguous
* in memory.
* @packet_offset_valid: - 0: PACKET_OFFSET is not used, 1: PACKET_OFFSET is
* used.
* @packet_offset_location: Location of packet offset field, which specifies
* the offset to the packet from the start of the packet offset field.
* @ignore_min_pkt_err - Ignore packets smaller than header. This is intended
* for use in RNDIS de-aggregated pipes, to silently ignore a redundant
* 1-byte trailer in MSFT implementation.
* @max_packet_len: DEAGGR Max Packet Length in Bytes. A Packet with higher
* size wil be treated as an error. 0 - Packet Length is not Bound,
* IPA should not check for a Max Packet Length.
*/
struct ipa_ep_cfg_deaggr {
u32 deaggr_hdr_len;
bool syspipe_err_detection;
bool packet_offset_valid;
u32 packet_offset_location;
bool ignore_min_pkt_err;
u32 max_packet_len;
};
/**
* enum ipa_cs_offload - checksum offload setting
*/
enum ipa_cs_offload {
IPA_DISABLE_CS_OFFLOAD,
/*
* For enum value = 1, we check the csum required/valid bit which is the
* same bit used for both DL and UL but have different meanings.
* For UL pipe, HW checks if it needs to perform Csum caluclation.
* For DL pipe, HW checks if the csum is valid or invalid
*/
IPA_ENABLE_CS_OFFLOAD_UL,
IPA_ENABLE_CS_DL_QMAP = IPA_ENABLE_CS_OFFLOAD_UL,
IPA_ENABLE_CS_OFFLOAD_DL,
IPA_CS_RSVD
};
/**
* struct ipa_ep_cfg_cfg - IPA ENDP_INIT Configuration register
* @frag_offload_en: - 0 - IP packet fragment handling is disabled. IP packet
* fragments should be sent to SW. SW is responsible for
* configuring filter rules, and IP packet filter exception should be
* used to send all fragments to SW. 1 - IP packet fragment
* handling is enabled. IPA checks for fragments and uses frag
* rules table for processing fragments. Valid only for Input Pipes
* (IPA Consumer)
* @cs_offload_en: Checksum offload enable: 00: Disable checksum offload, 01:
* Enable checksum calculation offload (UL) - For output pipe
* (IPA producer) specifies that checksum trailer is to be added.
* For input pipe (IPA consumer) specifies presence of checksum
* header and IPA checksum calculation accordingly. 10: Enable
* checksum calculation offload (DL) - For output pipe (IPA
* producer) specifies that checksum trailer is to be added. For
* input pipe (IPA consumer) specifies IPA checksum calculation.
* 11: Reserved
* @cs_metadata_hdr_offset: Offset in Words (4 bytes) within header in which
* checksum meta info header (4 bytes) starts (UL). Values are 0-15, which
* mean 0 - 60 byte checksum header offset. Valid for input
* pipes only (IPA consumer)
* @gen_qmb_master_sel: Select bit for ENDP GEN-QMB master. This is used to
* separate DDR & PCIe transactions in-order to limit them as
* a group (using MAX_WRITES/READS limiation). Valid for input and
* output pipes (IPA consumer+producer)
*/
struct ipa_ep_cfg_cfg {
bool frag_offload_en;
enum ipa_cs_offload cs_offload_en;
u8 cs_metadata_hdr_offset;
u8 gen_qmb_master_sel;
};
/**
* struct ipa_ep_cfg_metadata_mask - Endpoint initialization hdr metadata mask
* @metadata_mask: Mask specifying which metadata bits to write to
* IPA_ENDP_INIT_HDR_n.s HDR_OFST_METADATA. Only
* masked metadata bits (set to 1) will be written. Valid for Output
* Pipes only (IPA Producer)
*/
struct ipa_ep_cfg_metadata_mask {
u32 metadata_mask;
};
/**
* struct ipa_ep_cfg_metadata - Meta Data configuration in IPA end-point
* @md: This defines the meta data from tx data descriptor
* @qmap_id: qmap id
*/
struct ipa_ep_cfg_metadata {
u32 qmap_id;
};
/**
* struct ipa_ep_cfg_seq - HPS/DPS sequencer type configuration in IPA end-point
* @set_dynamic: 0 - HPS/DPS seq type is configured statically,
* 1 - HPS/DPS seq type is set to seq_type
* @seq_type: HPS/DPS sequencer type configuration
*/
struct ipa_ep_cfg_seq {
bool set_dynamic;
int seq_type;
};
/**
* struct ipa_ep_cfg - configuration of IPA end-point
* @nat: NAT parameters
* @conn_track: IPv6CT parameters
* @hdr: Header parameters
* @hdr_ext: Extended header parameters
* @mode: Mode parameters
* @aggr: Aggregation parameters
* @deaggr: Deaggregation params
* @route: Routing parameters
* @cfg: Configuration register data
* @metadata_mask: Hdr metadata mask
* @meta: Meta Data
* @seq: HPS/DPS sequencers configuration
*/
struct ipa_ep_cfg {
struct ipa_ep_cfg_nat nat;
struct ipa_ep_cfg_conn_track conn_track;
struct ipa_ep_cfg_hdr hdr;
struct ipa_ep_cfg_hdr_ext hdr_ext;
struct ipa_ep_cfg_mode mode;
struct ipa_ep_cfg_aggr aggr;
struct ipa_ep_cfg_deaggr deaggr;
struct ipa_ep_cfg_route route;
struct ipa_ep_cfg_cfg cfg;
struct ipa_ep_cfg_metadata_mask metadata_mask;
struct ipa_ep_cfg_metadata meta;
struct ipa_ep_cfg_seq seq;
};
/**
* struct ipa_ep_cfg_ctrl - Control configuration in IPA end-point
* @ipa_ep_suspend: 0 - ENDP is enabled, 1 - ENDP is suspended (disabled).
* Valid for PROD Endpoints
* @ipa_ep_delay: 0 - ENDP is free-running, 1 - ENDP is delayed.
* SW controls the data flow of an endpoint usind this bit.
* Valid for CONS Endpoints
*/
struct ipa_ep_cfg_ctrl {
bool ipa_ep_suspend;
bool ipa_ep_delay;
};
/**
* x should be in bytes
*/
#define IPA_NUM_OF_FIFO_DESC(x) (x/sizeof(struct sps_iovec))
typedef void (*ipa_notify_cb)(void *priv, enum ipa_dp_evt_type evt,
unsigned long data);
/**
* enum ipa_wdi_meter_evt_type - type of event client callback is
* for AP+STA mode metering
* @IPA_GET_WDI_SAP_STATS: get IPA_stats betwen SAP and STA -
* use ipa_get_wdi_sap_stats structure
* @IPA_SET_WIFI_QUOTA: set quota limit on STA -
* use ipa_set_wifi_quota structure
* @IPA_SET_WLAN_BW: set wlan BW -
* use ipa_set_wlan_bw structure
*/
enum ipa_wdi_meter_evt_type {
IPA_GET_WDI_SAP_STATS,
IPA_SET_WIFI_QUOTA,
IPA_INFORM_WLAN_BW,
};
struct ipa_get_wdi_sap_stats {
/* indicate to reset stats after query */
uint8_t reset_stats;
/* indicate valid stats from wlan-fw */
uint8_t stats_valid;
/* Tx: SAP->STA */
uint64_t ipv4_tx_packets;
uint64_t ipv4_tx_bytes;
/* Rx: STA->SAP */
uint64_t ipv4_rx_packets;
uint64_t ipv4_rx_bytes;
uint64_t ipv6_tx_packets;
uint64_t ipv6_tx_bytes;
uint64_t ipv6_rx_packets;
uint64_t ipv6_rx_bytes;
};
/**
* struct ipa_set_wifi_quota - structure used for
* IPA_SET_WIFI_QUOTA.
*
* @quota_bytes: Quota (in bytes) for the STA interface.
* @set_quota: Indicate whether to set the quota (use 1) or
* unset the quota.
*
*/
struct ipa_set_wifi_quota {
uint64_t quota_bytes;
uint8_t set_quota;
/* indicate valid quota set from wlan-fw */
uint8_t set_valid;
};
/**
* struct ipa_inform_wlan_bw - structure used for
* IPA_INFORM_WLAN_BW.
*
* @index: Indicate which bw-index hit
* @throughput: throughput usage
*
*/
struct ipa_inform_wlan_bw {
uint8_t index;
uint64_t throughput;
};
typedef void (*ipa_wdi_meter_notifier_cb)(enum ipa_wdi_meter_evt_type evt,
void *data);
/**
* struct ipa_connect_params - low-level client connect input parameters. Either
* client allocates the data and desc FIFO and specifies that in data+desc OR
* specifies sizes and pipe_mem pref and IPA does the allocation.
*
* @ipa_ep_cfg: IPA EP configuration
* @client: type of "client"
* @client_bam_hdl: client SPS handle
* @client_ep_idx: client PER EP index
* @priv: callback cookie
* @notify: callback
* priv - callback cookie evt - type of event data - data relevant
* to event. May not be valid. See event_type enum for valid
* cases.
* @desc_fifo_sz: size of desc FIFO
* @data_fifo_sz: size of data FIFO
* @pipe_mem_preferred: if true, try to alloc the FIFOs in pipe mem, fallback
* to sys mem if pipe mem alloc fails
* @desc: desc FIFO meta-data when client has allocated it
* @data: data FIFO meta-data when client has allocated it
* @skip_ep_cfg: boolean field that determines if EP should be configured
* by IPA driver
* @keep_ipa_awake: when true, IPA will not be clock gated
*/
struct ipa_connect_params {
struct ipa_ep_cfg ipa_ep_cfg;
enum ipa_client_type client;
unsigned long client_bam_hdl;
u32 client_ep_idx;
void *priv;
ipa_notify_cb notify;
u32 desc_fifo_sz;
u32 data_fifo_sz;
bool pipe_mem_preferred;
struct sps_mem_buffer desc;
struct sps_mem_buffer data;
bool skip_ep_cfg;
bool keep_ipa_awake;
};
/**
* struct ipa_sps_params - SPS related output parameters resulting from
* low/high level client connect
* @ipa_bam_hdl: IPA SPS handle
* @ipa_ep_idx: IPA PER EP index
* @desc: desc FIFO meta-data
* @data: data FIFO meta-data
*/
struct ipa_sps_params {
unsigned long ipa_bam_hdl;
u32 ipa_ep_idx;
struct sps_mem_buffer desc;
struct sps_mem_buffer data;
};
/**
* struct ipa_tx_intf - interface tx properties
* @num_props: number of tx properties
* @prop: the tx properties array
*/
struct ipa_tx_intf {
u32 num_props;
struct ipa_ioc_tx_intf_prop *prop;
};
/**
* struct ipa_rx_intf - interface rx properties
* @num_props: number of rx properties
* @prop: the rx properties array
*/
struct ipa_rx_intf {
u32 num_props;
struct ipa_ioc_rx_intf_prop *prop;
};
/**
* struct ipa_ext_intf - interface ext properties
* @excp_pipe_valid: is next field valid?
* @excp_pipe: exception packets should be routed to this pipe
* @num_props: number of ext properties
* @prop: the ext properties array
*/
struct ipa_ext_intf {
bool excp_pipe_valid;
enum ipa_client_type excp_pipe;
u32 num_props;
struct ipa_ioc_ext_intf_prop *prop;
};
/**
* struct ipa_sys_connect_params - information needed to setup an IPA end-point
* in system-BAM mode
* @ipa_ep_cfg: IPA EP configuration
* @client: the type of client who "owns" the EP
* @desc_fifo_sz: size of desc FIFO. This number is used to allocate the desc
* fifo for BAM. For GSI, this size is used by IPA driver as a
* baseline to calculate the GSI ring size in the following way:
* For PROD pipes, GSI ring is 4 * desc_fifo_sz.
For PROD pipes, GSI ring is 2 * desc_fifo_sz.
* @priv: callback cookie
* @notify: callback
* priv - callback cookie
* evt - type of event
* data - data relevant to event. May not be valid. See event_type
* enum for valid cases.
* @skip_ep_cfg: boolean field that determines if EP should be configured
* by IPA driver
* @keep_ipa_awake: when true, IPA will not be clock gated
* @napi_enabled: when true, IPA call client callback to start polling
*/
struct ipa_sys_connect_params {
struct ipa_ep_cfg ipa_ep_cfg;
enum ipa_client_type client;
u32 desc_fifo_sz;
void *priv;
ipa_notify_cb notify;
bool skip_ep_cfg;
bool keep_ipa_awake;
struct napi_struct *napi_obj;
bool napi_enabled;
bool recycle_enabled;
};
/**
* struct ipa_tx_meta - meta-data for the TX packet
* @dma_address: dma mapped address of TX packet
* @dma_address_valid: is above field valid?
*/
struct ipa_tx_meta {
u8 pkt_init_dst_ep;
bool pkt_init_dst_ep_valid;
bool pkt_init_dst_ep_remote;
dma_addr_t dma_address;
bool dma_address_valid;
};
/**
* typedef ipa_msg_free_fn - callback function
* @param buff - [in] the message payload to free
* @param len - [in] size of message payload
* @param type - [in] the message type
*
* Message callback registered by kernel client with IPA driver to
* free message payload after IPA driver processing is complete
*
* No return value
*/
typedef void (*ipa_msg_free_fn)(void *buff, u32 len, u32 type);
/**
* typedef ipa_msg_pull_fn - callback function
* @param buff - [in] where to copy message payload
* @param len - [in] size of buffer to copy payload into
* @param type - [in] the message type
*
* Message callback registered by kernel client with IPA driver for
* IPA driver to pull messages from the kernel client upon demand from
* user-space
*
* Returns how many bytes were copied into the buffer.
*/
typedef int (*ipa_msg_pull_fn)(void *buff, u32 len, u32 type);
/**
* enum ipa_voltage_level - IPA Voltage levels
*/
enum ipa_voltage_level {
IPA_VOLTAGE_UNSPECIFIED,
IPA_VOLTAGE_SVS2 = IPA_VOLTAGE_UNSPECIFIED,
IPA_VOLTAGE_SVS,
IPA_VOLTAGE_NOMINAL,
IPA_VOLTAGE_TURBO,
IPA_VOLTAGE_MAX,
};
/**
* enum ipa_rm_event - IPA RM events
*
* Indicate the resource state change
*/
enum ipa_rm_event {
IPA_RM_RESOURCE_GRANTED,
IPA_RM_RESOURCE_RELEASED
};
typedef void (*ipa_rm_notify_cb)(void *user_data,
enum ipa_rm_event event,
unsigned long data);
/**
* struct ipa_rm_register_params - information needed to
* register IPA RM client with IPA RM
*
* @user_data: IPA RM client provided information
* to be passed to notify_cb callback below
* @notify_cb: callback which is called by resource
* to notify the IPA RM client about its state
* change IPA RM client is expected to perform non
* blocking operations only in notify_cb and
* release notification context as soon as
* possible.
*/
struct ipa_rm_register_params {
void *user_data;
ipa_rm_notify_cb notify_cb;
};
/**
* struct ipa_rm_create_params - information needed to initialize
* the resource
* @name: resource name
* @floor_voltage: floor voltage needed for client to operate in maximum
* bandwidth.
* @reg_params: register parameters, contains are ignored
* for consumer resource NULL should be provided
* for consumer resource
* @request_resource: function which should be called to request resource,
* NULL should be provided for producer resource
* @release_resource: function which should be called to release resource,
* NULL should be provided for producer resource
*
* IPA RM client is expected to perform non blocking operations only
* in request_resource and release_resource functions and
* release notification context as soon as possible.
*/
struct ipa_rm_create_params {
enum ipa_rm_resource_name name;
enum ipa_voltage_level floor_voltage;
struct ipa_rm_register_params reg_params;
int (*request_resource)(void);
int (*release_resource)(void);
};
/**
* struct ipa_rm_perf_profile - information regarding IPA RM client performance
* profile
*
* @max_bandwidth_mbps: maximum bandwidth need of the client in Mbps
*/
struct ipa_rm_perf_profile {
u32 max_supported_bandwidth_mbps;
};
#define A2_MUX_HDR_NAME_V4_PREF "dmux_hdr_v4_"
#define A2_MUX_HDR_NAME_V6_PREF "dmux_hdr_v6_"
/**
* enum teth_tethering_mode - Tethering mode (Rmnet / MBIM)
*/
enum teth_tethering_mode {
TETH_TETHERING_MODE_RMNET,
TETH_TETHERING_MODE_MBIM,
TETH_TETHERING_MODE_MAX,
};
/**
* teth_bridge_init_params - Parameters used for in/out USB API
* @usb_notify_cb: Callback function which should be used by the caller.
* Output parameter.
* @private_data: Data for the callback function. Should be used by the
* caller. Output parameter.
* @skip_ep_cfg: boolean field that determines if Apps-processor
* should or should not confiugre this end-point.
*/
struct teth_bridge_init_params {
ipa_notify_cb usb_notify_cb;
void *private_data;
enum ipa_client_type client;
bool skip_ep_cfg;
};
/**
* struct teth_bridge_connect_params - Parameters used in teth_bridge_connect()
* @ipa_usb_pipe_hdl: IPA to USB pipe handle, returned from ipa_connect()
* @usb_ipa_pipe_hdl: USB to IPA pipe handle, returned from ipa_connect()
* @tethering_mode: Rmnet or MBIM
* @ipa_client_type: IPA "client" name (IPA_CLIENT_USB#_PROD)
*/
struct teth_bridge_connect_params {
u32 ipa_usb_pipe_hdl;
u32 usb_ipa_pipe_hdl;
enum teth_tethering_mode tethering_mode;
enum ipa_client_type client_type;
};
/**
* struct ipa_tx_data_desc - information needed
* to send data packet to HW link: link to data descriptors
* priv: client specific private data
* @pyld_buffer: pointer to the data buffer that holds frame
* @pyld_len: length of the data packet
*/
struct ipa_tx_data_desc {
struct list_head link;
void *priv;
void *pyld_buffer;
u16 pyld_len;
};
/**
* struct ipa_rx_data - information needed
* to send to wlan driver on receiving data from ipa hw
* @skb: skb
* @dma_addr: DMA address of this Rx packet
*/
struct ipa_rx_data {
struct sk_buff *skb;
dma_addr_t dma_addr;
};
/**
* struct ipa_rx_page_data - information needed
* to send to wlan driver on receiving data from ipa hw
* @page: skb page
* @dma_addr: DMA address of this Rx packet
* @is_tmp_alloc: skb page from tmp_alloc or recycle_list
*/
struct ipa_rx_page_data {
struct page *page;
dma_addr_t dma_addr;
bool is_tmp_alloc;
};
/**
* enum ipa_irq_type - IPA Interrupt Type
* Used to register handlers for IPA interrupts
*
* Below enum is a logical mapping and not the actual interrupt bit in HW
*/
enum ipa_irq_type {
IPA_BAD_SNOC_ACCESS_IRQ,
IPA_EOT_COAL_IRQ,
IPA_UC_IRQ_0,
IPA_UC_IRQ_1,
IPA_UC_IRQ_2,
IPA_UC_IRQ_3,
IPA_UC_IN_Q_NOT_EMPTY_IRQ,
IPA_UC_RX_CMD_Q_NOT_FULL_IRQ,
IPA_UC_TX_CMD_Q_NOT_FULL_IRQ,
IPA_UC_TO_PROC_ACK_Q_NOT_FULL_IRQ,
IPA_PROC_TO_UC_ACK_Q_NOT_EMPTY_IRQ,
IPA_RX_ERR_IRQ,
IPA_DEAGGR_ERR_IRQ,
IPA_TX_ERR_IRQ,
IPA_STEP_MODE_IRQ,
IPA_PROC_ERR_IRQ,
IPA_TX_SUSPEND_IRQ,
IPA_TX_HOLB_DROP_IRQ,
IPA_BAM_IDLE_IRQ,
IPA_GSI_IDLE_IRQ = IPA_BAM_IDLE_IRQ,
IPA_BAM_GSI_IDLE_IRQ,
IPA_PIPE_YELLOW_MARKER_BELOW_IRQ,
IPA_PIPE_RED_MARKER_BELOW_IRQ,
IPA_PIPE_YELLOW_MARKER_ABOVE_IRQ,
IPA_PIPE_RED_MARKER_ABOVE_IRQ,
IPA_UCP_IRQ,
IPA_DCMP_IRQ,
IPA_GSI_EE_IRQ,
IPA_GSI_IPA_IF_TLV_RCVD_IRQ,
IPA_GSI_UC_IRQ,
IPA_TLV_LEN_MIN_DSM_IRQ,
IPA_IRQ_MAX
};
/**
* struct ipa_tx_suspend_irq_data - interrupt data for IPA_TX_SUSPEND_IRQ
* @endpoints: bitmask of endpoints which case IPA_TX_SUSPEND_IRQ interrupt
* @dma_addr: DMA address of this Rx packet
*/
struct ipa_tx_suspend_irq_data {
u32 endpoints;
};
/**
* typedef ipa_irq_handler_t - irq handler/callback type
* @param ipa_irq_type - [in] interrupt type
* @param private_data - [in, out] the client private data
* @param interrupt_data - [out] interrupt information data
*
* callback registered by ipa_add_interrupt_handler function to
* handle a specific interrupt type
*
* No return value
*/
typedef void (*ipa_irq_handler_t)(enum ipa_irq_type interrupt,
void *private_data,
void *interrupt_data);
/**
* struct IpaHwBamStats_t - Structure holding the BAM statistics
*
* @bamFifoFull : Number of times Bam Fifo got full - For In Ch: Good,
* For Out Ch: Bad
* @bamFifoEmpty : Number of times Bam Fifo got empty - For In Ch: Bad,
* For Out Ch: Good
* @bamFifoUsageHigh : Number of times Bam fifo usage went above 75% -
* For In Ch: Good, For Out Ch: Bad
* @bamFifoUsageLow : Number of times Bam fifo usage went below 25% -
* For In Ch: Bad, For Out Ch: Good
*/
struct IpaHwBamStats_t {
u32 bamFifoFull;
u32 bamFifoEmpty;
u32 bamFifoUsageHigh;
u32 bamFifoUsageLow;
u32 bamUtilCount;
} __packed;
/**
* struct IpaOffloadStatschannel_info - channel info for uC
* stats
* @dir: Direction of the channel ID DIR_CONSUMER =0,
* DIR_PRODUCER = 1
* @ch_id: GSI ch_id of the IPA endpoint for which stats need
* to be calculated, 0xFF means invalid channel or disable stats
* on already stats enabled channel
*/
struct IpaOffloadStatschannel_info {
u8 dir;
u8 ch_id;
} __packed;
/**
* struct IpaHwOffloadStatsAllocCmdData_t - protocol info for uC
* stats start
* @protocol: Enum that indicates the protocol type
* @ch_id_info: GSI ch_id and dir of the IPA endpoint for which stats
* need to be calculated
*/
struct IpaHwOffloadStatsAllocCmdData_t {
u32 protocol;
struct IpaOffloadStatschannel_info
ch_id_info[IPA_MAX_CH_STATS_SUPPORTED];
} __packed;
/**
* struct IpaHwRingStats_t - Structure holding the Ring statistics
*
* @ringFull : Number of times Transfer Ring got full - For In Ch: Good,
* For Out Ch: Bad
* @ringEmpty : Number of times Transfer Ring got empty - For In Ch: Bad,
* For Out Ch: Good
* @ringUsageHigh : Number of times Transfer Ring usage went above 75% -
* For In Ch: Good, For Out Ch: Bad
* @ringUsageLow : Number of times Transfer Ring usage went below 25% -
* For In Ch: Bad, For Out Ch: Good
*/
struct IpaHwRingStats_t {
u32 ringFull;
u32 ringEmpty;
u32 ringUsageHigh;
u32 ringUsageLow;
u32 RingUtilCount;
} __packed;
/**
* struct ipa_uc_dbg_ring_stats - uC dbg stats info for each
* offloading protocol
* @ring: ring stats for each channel
* @ch_num: number of ch supported for given protocol
*/
struct ipa_uc_dbg_ring_stats {
struct IpaHwRingStats_t ring[IPA_MAX_CH_STATS_SUPPORTED];
u8 num_ch;
};
/**
* struct IpaHwStatsWDIRxInfoData_t - Structure holding the WDI Rx channel
* structures
*
* @max_outstanding_pkts : Number of outstanding packets in Rx Ring
* @num_pkts_processed : Number of packets processed - cumulative
* @rx_ring_rp_value : Read pointer last advertized to the WLAN FW
* @rx_ind_ring_stats : Ring info
* @bam_stats : BAM info
* @num_bam_int_handled : Number of Bam Interrupts handled by FW
* @num_db : Number of times the doorbell was rung
* @num_unexpected_db : Number of unexpected doorbells
* @num_pkts_in_dis_uninit_state : number of completions we
* received in disabled or uninitialized state
* @num_ic_inj_vdev_change : Number of times the Imm Cmd is
* injected due to vdev_id change
* @num_ic_inj_fw_desc_change : Number of times the Imm Cmd is
* injected due to fw_desc change
* @num_qmb_int_handled : Number of QMB interrupts handled
*/
struct IpaHwStatsWDIRxInfoData_t {
u32 max_outstanding_pkts;
u32 num_pkts_processed;
u32 rx_ring_rp_value;
struct IpaHwRingStats_t rx_ind_ring_stats;
struct IpaHwBamStats_t bam_stats;
u32 num_bam_int_handled;
u32 num_db;
u32 num_unexpected_db;
u32 num_pkts_in_dis_uninit_state;
u32 num_ic_inj_vdev_change;
u32 num_ic_inj_fw_desc_change;
u32 num_qmb_int_handled;
u32 reserved1;
u32 reserved2;
} __packed;
/**
* struct IpaHwStatsWDITxInfoData_t - Structure holding the WDI Tx channel
* structures
*
* @num_pkts_processed : Number of packets processed - cumulative
* @copy_engine_doorbell_value : latest value of doorbell written to copy engine
* @num_db_fired : Number of DB from uC FW to Copy engine
* @tx_comp_ring_stats : ring info
* @bam_stats : BAM info
* @num_db : Number of times the doorbell was rung
* @num_unexpected_db : Number of unexpected doorbells
* @num_bam_int_handled : Number of Bam Interrupts handled by FW
* @num_bam_int_in_non_running_state : Number of Bam interrupts while not in
* Running state
* @num_qmb_int_handled : Number of QMB interrupts handled
*/
struct IpaHwStatsWDITxInfoData_t {
u32 num_pkts_processed;
u32 copy_engine_doorbell_value;
u32 num_db_fired;
struct IpaHwRingStats_t tx_comp_ring_stats;
struct IpaHwBamStats_t bam_stats;
u32 num_db;
u32 num_unexpected_db;
u32 num_bam_int_handled;
u32 num_bam_int_in_non_running_state;
u32 num_qmb_int_handled;
u32 num_bam_int_handled_while_wait_for_bam;
} __packed;
/**
* struct IpaHwStatsWDIInfoData_t - Structure holding the WDI channel structures
*
* @rx_ch_stats : RX stats
* @tx_ch_stats : TX stats
*/
struct IpaHwStatsWDIInfoData_t {
struct IpaHwStatsWDIRxInfoData_t rx_ch_stats;
struct IpaHwStatsWDITxInfoData_t tx_ch_stats;
} __packed;
/**
* struct ipa_wdi_ul_params - WDI_RX configuration
* @rdy_ring_base_pa: physical address of the base of the Rx ring (containing
* Rx buffers)
* @rdy_ring_size: size of the Rx ring in bytes
* @rdy_ring_rp_pa: physical address of the location through which IPA uc is
* reading (WDI-1.0)
* @rdy_comp_ring_base_pa: physical address of the base of the Rx completion
* ring (WDI-2.0)
* @rdy_comp_ring_wp_pa: physical address of the location through which IPA
* uc is writing (WDI-2.0)
* @rdy_comp_ring_size: size of the Rx_completion ring in bytes
* expected to communicate about the Read pointer into the Rx Ring
*/
struct ipa_wdi_ul_params {
phys_addr_t rdy_ring_base_pa;
u32 rdy_ring_size;
phys_addr_t rdy_ring_rp_pa;
phys_addr_t rdy_comp_ring_base_pa;
phys_addr_t rdy_comp_ring_wp_pa;
u32 rdy_comp_ring_size;
u32 *rdy_ring_rp_va;
u32 *rdy_comp_ring_wp_va;
};
/**
* struct ipa_wdi_ul_params_smmu - WDI_RX configuration (with WLAN SMMU)
* @rdy_ring: SG table describing the Rx ring (containing Rx buffers)
* @rdy_ring_size: size of the Rx ring in bytes
* @rdy_ring_rp_pa: physical address of the location through which IPA uc is
* expected to communicate about the Read pointer into the Rx Ring
*/
struct ipa_wdi_ul_params_smmu {
struct sg_table rdy_ring;
u32 rdy_ring_size;
phys_addr_t rdy_ring_rp_pa;
struct sg_table rdy_comp_ring;
phys_addr_t rdy_comp_ring_wp_pa;
u32 rdy_comp_ring_size;
u32 *rdy_ring_rp_va;
u32 *rdy_comp_ring_wp_va;
};
/**
* struct ipa_wdi_dl_params - WDI_TX configuration
* @comp_ring_base_pa: physical address of the base of the Tx completion ring
* @comp_ring_size: size of the Tx completion ring in bytes
* @ce_ring_base_pa: physical address of the base of the Copy Engine Source
* Ring
* @ce_door_bell_pa: physical address of the doorbell that the IPA uC has to
* write into to trigger the copy engine
* @ce_ring_size: Copy Engine Ring size in bytes
* @num_tx_buffers: Number of pkt buffers allocated
*/
struct ipa_wdi_dl_params {
phys_addr_t comp_ring_base_pa;
u32 comp_ring_size;
phys_addr_t ce_ring_base_pa;
phys_addr_t ce_door_bell_pa;
u32 ce_ring_size;
u32 num_tx_buffers;
};
/**
* struct ipa_wdi_dl_params_smmu - WDI_TX configuration (with WLAN SMMU)
* @comp_ring: SG table describing the Tx completion ring
* @comp_ring_size: size of the Tx completion ring in bytes
* @ce_ring: SG table describing the Copy Engine Source Ring
* @ce_door_bell_pa: physical address of the doorbell that the IPA uC has to
* write into to trigger the copy engine
* @ce_ring_size: Copy Engine Ring size in bytes
* @num_tx_buffers: Number of pkt buffers allocated
*/
struct ipa_wdi_dl_params_smmu {
struct sg_table comp_ring;
u32 comp_ring_size;
struct sg_table ce_ring;
phys_addr_t ce_door_bell_pa;
u32 ce_ring_size;
u32 num_tx_buffers;
};
/**
* struct ipa_wdi_in_params - information provided by WDI client
* @sys: IPA EP configuration info
* @ul: WDI_RX configuration info
* @dl: WDI_TX configuration info
* @ul_smmu: WDI_RX configuration info when WLAN uses SMMU
* @dl_smmu: WDI_TX configuration info when WLAN uses SMMU
* @smmu_enabled: true if WLAN uses SMMU
* @ipa_wdi_meter_notifier_cb: Get WDI stats and quato info
*/
struct ipa_wdi_in_params {
struct ipa_sys_connect_params sys;
union {
struct ipa_wdi_ul_params ul;
struct ipa_wdi_dl_params dl;
struct ipa_wdi_ul_params_smmu ul_smmu;
struct ipa_wdi_dl_params_smmu dl_smmu;
} u;
bool smmu_enabled;
#ifdef IPA_WAN_MSG_IPv6_ADDR_GW_LEN
ipa_wdi_meter_notifier_cb wdi_notify;
#endif
};
enum ipa_upstream_type {
IPA_UPSTEAM_MODEM = 1,
IPA_UPSTEAM_WLAN,
IPA_UPSTEAM_MAX
};
/**
* struct ipa_wdi_out_params - information provided to WDI client
* @uc_door_bell_pa: physical address of IPA uc doorbell
* @clnt_hdl: opaque handle assigned to client
*/
struct ipa_wdi_out_params {
phys_addr_t uc_door_bell_pa;
u32 clnt_hdl;
};
/**
* struct ipa_wdi_db_params - information provided to retrieve
* physical address of uC doorbell
* @client: type of "client" (IPA_CLIENT_WLAN#_PROD/CONS)
* @uc_door_bell_pa: physical address of IPA uc doorbell
*/
struct ipa_wdi_db_params {
enum ipa_client_type client;
phys_addr_t uc_door_bell_pa;
};
/**
* struct ipa_wdi_uc_ready_params - uC ready CB parameters
* @is_uC_ready: uC loaded or not
* @priv : callback cookie
* @notify: callback
*/
typedef void (*ipa_uc_ready_cb)(void *priv);
struct ipa_wdi_uc_ready_params {
bool is_uC_ready;
void *priv;
ipa_uc_ready_cb notify;
};
/**
* struct ipa_wdi_buffer_info - address info of a WLAN allocated buffer
* @pa: physical address of the buffer
* @iova: IOVA of the buffer as embedded inside the WDI descriptors
* @size: size in bytes of the buffer
* @result: result of map or unmap operations (out param)
*
* IPA driver will create/release IOMMU mapping in IPA SMMU from iova->pa
*/
struct ipa_wdi_buffer_info {
phys_addr_t pa;
unsigned long iova;
size_t size;
int result;
};
/**
* struct ipa_wdi_bw_info - address info of a WLAN allocated buffer
* @threshold: throughput wants to be monitored
* @num: number of threshold entries
* @stop: true to stop monitoring
*
* IPA driver will create/release IOMMU mapping in IPA SMMU from iova->pa
*/
struct ipa_wdi_bw_info {
uint64_t threshold[IPA_BW_THRESHOLD_MAX];
int num;
bool stop;
};
/**
* struct ipa_wdi_tx_info - sw tx info from WLAN
* @sta_tx: sw tx stats on sta interface
* @ap_tx: sw tx stats on ap interface
*
* IPA driver will create/release IOMMU mapping in IPA SMMU from iova->pa
*/
struct ipa_wdi_tx_info {
uint64_t sta_tx;
uint64_t ap_tx;
};
/**
* struct ipa_gsi_ep_config - IPA GSI endpoint configurations
*
* @ipa_ep_num: IPA EP pipe number
* @ipa_gsi_chan_num: GSI channel number
* @ipa_if_tlv: number of IPA_IF TLV
* @ipa_if_aos: number of IPA_IF AOS
* @ee: Execution environment
* @prefetch_mode: Prefetch mode to be used
* @prefetch_threshold: Prefetch empty level threshold.
* relevant for smart and free prefetch modes
*/
struct ipa_gsi_ep_config {
int ipa_ep_num;
int ipa_gsi_chan_num;
int ipa_if_tlv;
int ipa_if_aos;
int ee;
enum gsi_prefetch_mode prefetch_mode;
uint8_t prefetch_threshold;
};
/**
* struct ipa_tz_unlock_reg_info - Used in order unlock regions of memory by TZ
* @reg_addr - Physical address of the start of the region
* @size - Size of the region in bytes
*/
struct ipa_tz_unlock_reg_info {
u64 reg_addr;
u64 size;
};
/**
* struct ipa_smmu_in_params - information provided from client
* @ipa_smmu_client_type: clinet requesting for the smmu info.
*/
enum ipa_smmu_client_type {
IPA_SMMU_WLAN_CLIENT,
IPA_SMMU_AP_CLIENT,
IPA_SMMU_WIGIG_CLIENT,
IPA_SMMU_CLIENT_MAX
};
struct ipa_smmu_in_params {
enum ipa_smmu_client_type smmu_client;
};
/**
* struct ipa_smmu_out_params - information provided to IPA client
* @smmu_enable: IPA S1 SMMU enable/disable status
* @shared_cb: is client CB shared (mappings should be done by client only)
*/
struct ipa_smmu_out_params {
bool smmu_enable;
bool shared_cb;
};
#if defined CONFIG_IPA || defined CONFIG_IPA3
/*
* Connect / Disconnect
*/
int ipa_connect(const struct ipa_connect_params *in, struct ipa_sps_params *sps,
u32 *clnt_hdl);
int ipa_disconnect(u32 clnt_hdl);
/*
* Resume / Suspend
*/
int ipa_reset_endpoint(u32 clnt_hdl);
/*
* Remove ep delay
*/
int ipa_clear_endpoint_delay(u32 clnt_hdl);
/*
* Disable ep
*/
int ipa_disable_endpoint(u32 clnt_hdl);
/*
* Configuration
*/
int ipa_cfg_ep(u32 clnt_hdl, const struct ipa_ep_cfg *ipa_ep_cfg);
int ipa_cfg_ep_nat(u32 clnt_hdl, const struct ipa_ep_cfg_nat *ipa_ep_cfg);
int ipa_cfg_ep_conn_track(u32 clnt_hdl,
const struct ipa_ep_cfg_conn_track *ep_conn_track);
int ipa_cfg_ep_hdr(u32 clnt_hdl, const struct ipa_ep_cfg_hdr *ipa_ep_cfg);
int ipa_cfg_ep_hdr_ext(u32 clnt_hdl,
const struct ipa_ep_cfg_hdr_ext *ipa_ep_cfg);
int ipa_cfg_ep_mode(u32 clnt_hdl, const struct ipa_ep_cfg_mode *ipa_ep_cfg);
int ipa_cfg_ep_aggr(u32 clnt_hdl, const struct ipa_ep_cfg_aggr *ipa_ep_cfg);
int ipa_cfg_ep_deaggr(u32 clnt_hdl,
const struct ipa_ep_cfg_deaggr *ipa_ep_cfg);
int ipa_cfg_ep_route(u32 clnt_hdl, const struct ipa_ep_cfg_route *ipa_ep_cfg);
int ipa_cfg_ep_holb(u32 clnt_hdl, const struct ipa_ep_cfg_holb *ipa_ep_cfg);
int ipa_cfg_ep_cfg(u32 clnt_hdl, const struct ipa_ep_cfg_cfg *ipa_ep_cfg);
int ipa_cfg_ep_metadata_mask(u32 clnt_hdl, const struct ipa_ep_cfg_metadata_mask
*ipa_ep_cfg);
int ipa_cfg_ep_holb_by_client(enum ipa_client_type client,
const struct ipa_ep_cfg_holb *ipa_ep_cfg);
int ipa_cfg_ep_ctrl(u32 clnt_hdl, const struct ipa_ep_cfg_ctrl *ep_ctrl);
/*
* Header removal / addition
*/
int ipa_add_hdr(struct ipa_ioc_add_hdr *hdrs);
int ipa_add_hdr_usr(struct ipa_ioc_add_hdr *hdrs, bool user_only);
int ipa_del_hdr(struct ipa_ioc_del_hdr *hdls);
int ipa_commit_hdr(void);
int ipa_reset_hdr(bool user_only);
int ipa_get_hdr(struct ipa_ioc_get_hdr *lookup);
int ipa_put_hdr(u32 hdr_hdl);
int ipa_copy_hdr(struct ipa_ioc_copy_hdr *copy);
/*
* Header Processing Context
*/
int ipa_add_hdr_proc_ctx(struct ipa_ioc_add_hdr_proc_ctx *proc_ctxs,
bool user_only);
int ipa_del_hdr_proc_ctx(struct ipa_ioc_del_hdr_proc_ctx *hdls);
/*
* Routing
*/
int ipa_add_rt_rule(struct ipa_ioc_add_rt_rule *rules);
int ipa_add_rt_rule_v2(struct ipa_ioc_add_rt_rule_v2 *rules);
int ipa_add_rt_rule_usr(struct ipa_ioc_add_rt_rule *rules, bool user_only);
int ipa_add_rt_rule_usr_v2(struct ipa_ioc_add_rt_rule_v2 *rules,
bool user_only);
int ipa_del_rt_rule(struct ipa_ioc_del_rt_rule *hdls);
int ipa_commit_rt(enum ipa_ip_type ip);
int ipa_reset_rt(enum ipa_ip_type ip, bool user_only);
int ipa_get_rt_tbl(struct ipa_ioc_get_rt_tbl *lookup);
int ipa_put_rt_tbl(u32 rt_tbl_hdl);
int ipa_query_rt_index(struct ipa_ioc_get_rt_tbl_indx *in);
int ipa_mdfy_rt_rule(struct ipa_ioc_mdfy_rt_rule *rules);
int ipa_mdfy_rt_rule_v2(struct ipa_ioc_mdfy_rt_rule_v2 *rules);
/*
* Filtering
*/
int ipa_add_flt_rule(struct ipa_ioc_add_flt_rule *rules);
int ipa_add_flt_rule_v2(struct ipa_ioc_add_flt_rule_v2 *rules);
int ipa_add_flt_rule_usr(struct ipa_ioc_add_flt_rule *rules, bool user_only);
int ipa_add_flt_rule_usr_v2(struct ipa_ioc_add_flt_rule_v2 *rules,
bool user_only);
int ipa_del_flt_rule(struct ipa_ioc_del_flt_rule *hdls);
int ipa_mdfy_flt_rule(struct ipa_ioc_mdfy_flt_rule *rules);
int ipa_mdfy_flt_rule_v2(struct ipa_ioc_mdfy_flt_rule_v2 *rules);
int ipa_commit_flt(enum ipa_ip_type ip);
int ipa_reset_flt(enum ipa_ip_type ip, bool user_only);
/*
* NAT\IPv6CT
*/
int ipa_allocate_nat_device(struct ipa_ioc_nat_alloc_mem *mem);
int ipa_allocate_nat_table(struct ipa_ioc_nat_ipv6ct_table_alloc *table_alloc);
int ipa_allocate_ipv6ct_table(
struct ipa_ioc_nat_ipv6ct_table_alloc *table_alloc);
int ipa_nat_init_cmd(struct ipa_ioc_v4_nat_init *init);
int ipa_ipv6ct_init_cmd(struct ipa_ioc_ipv6ct_init *init);
int ipa_nat_dma_cmd(struct ipa_ioc_nat_dma_cmd *dma);
int ipa_table_dma_cmd(struct ipa_ioc_nat_dma_cmd *dma);
int ipa_nat_del_cmd(struct ipa_ioc_v4_nat_del *del);
int ipa_del_nat_table(struct ipa_ioc_nat_ipv6ct_table_del *del);
int ipa_del_ipv6ct_table(struct ipa_ioc_nat_ipv6ct_table_del *del);
int ipa_nat_mdfy_pdn(struct ipa_ioc_nat_pdn_entry *mdfy_pdn);
/*
* Messaging
*/
int ipa_send_msg(struct ipa_msg_meta *meta, void *buff,
ipa_msg_free_fn callback);
int ipa_register_pull_msg(struct ipa_msg_meta *meta, ipa_msg_pull_fn callback);
int ipa_deregister_pull_msg(struct ipa_msg_meta *meta);
/*
* Interface
*/
int ipa_register_intf(const char *name, const struct ipa_tx_intf *tx,
const struct ipa_rx_intf *rx);
int ipa_register_intf_ext(const char *name, const struct ipa_tx_intf *tx,
const struct ipa_rx_intf *rx,
const struct ipa_ext_intf *ext);
int ipa_deregister_intf(const char *name);
/*
* Aggregation
*/
int ipa_set_aggr_mode(enum ipa_aggr_mode mode);
int ipa_set_qcncm_ndp_sig(char sig[3]);
int ipa_set_single_ndp_per_mbim(bool enable);
/*
* Data path
*/
int ipa_tx_dp(enum ipa_client_type dst, struct sk_buff *skb,
struct ipa_tx_meta *metadata);
/*
* To transfer multiple data packets
* While passing the data descriptor list, the anchor node
* should be of type struct ipa_tx_data_desc not list_head
*/
int ipa_tx_dp_mul(enum ipa_client_type dst,
struct ipa_tx_data_desc *data_desc);
void ipa_free_skb(struct ipa_rx_data *data);
int ipa_rx_poll(u32 clnt_hdl, int budget);
void ipa_recycle_wan_skb(struct sk_buff *skb);
/*
* System pipes
*/
int ipa_setup_sys_pipe(struct ipa_sys_connect_params *sys_in, u32 *clnt_hdl);
int ipa_teardown_sys_pipe(u32 clnt_hdl);
int ipa_connect_wdi_pipe(struct ipa_wdi_in_params *in,
struct ipa_wdi_out_params *out);
int ipa_disconnect_wdi_pipe(u32 clnt_hdl);
int ipa_enable_wdi_pipe(u32 clnt_hdl);
int ipa_disable_wdi_pipe(u32 clnt_hdl);
int ipa_resume_wdi_pipe(u32 clnt_hdl);
int ipa_suspend_wdi_pipe(u32 clnt_hdl);
int ipa_get_wdi_stats(struct IpaHwStatsWDIInfoData_t *stats);
int ipa_uc_bw_monitor(struct ipa_wdi_bw_info *info);
int ipa_set_wlan_tx_info(struct ipa_wdi_tx_info *info);
u16 ipa_get_smem_restr_bytes(void);
int ipa_broadcast_wdi_quota_reach_ind(uint32_t fid,
uint64_t num_bytes);
/*
* To retrieve doorbell physical address of
* wlan pipes
*/
int ipa_uc_wdi_get_dbpa(struct ipa_wdi_db_params *out);
/*
* To register uC ready callback if uC not ready
* and also check uC readiness
* if uC not ready only, register callback
*/
int ipa_uc_reg_rdyCB(struct ipa_wdi_uc_ready_params *param);
/*
* To de-register uC ready callback
*/
int ipa_uc_dereg_rdyCB(void);
int ipa_create_wdi_mapping(u32 num_buffers, struct ipa_wdi_buffer_info *info);
int ipa_release_wdi_mapping(u32 num_buffers, struct ipa_wdi_buffer_info *info);
/*
* Resource manager
*/
int ipa_rm_create_resource(struct ipa_rm_create_params *create_params);
int ipa_rm_delete_resource(enum ipa_rm_resource_name resource_name);
int ipa_rm_register(enum ipa_rm_resource_name resource_name,
struct ipa_rm_register_params *reg_params);
int ipa_rm_deregister(enum ipa_rm_resource_name resource_name,
struct ipa_rm_register_params *reg_params);
int ipa_rm_set_perf_profile(enum ipa_rm_resource_name resource_name,
struct ipa_rm_perf_profile *profile);
int ipa_rm_add_dependency(enum ipa_rm_resource_name resource_name,
enum ipa_rm_resource_name depends_on_name);
int ipa_rm_add_dependency_sync(enum ipa_rm_resource_name resource_name,
enum ipa_rm_resource_name depends_on_name);
int ipa_rm_delete_dependency(enum ipa_rm_resource_name resource_name,
enum ipa_rm_resource_name depends_on_name);
int ipa_rm_request_resource(enum ipa_rm_resource_name resource_name);
int ipa_rm_release_resource(enum ipa_rm_resource_name resource_name);
int ipa_rm_notify_completion(enum ipa_rm_event event,
enum ipa_rm_resource_name resource_name);
int ipa_rm_inactivity_timer_init(enum ipa_rm_resource_name resource_name,
unsigned long msecs);
int ipa_rm_inactivity_timer_destroy(enum ipa_rm_resource_name resource_name);
int ipa_rm_inactivity_timer_request_resource(
enum ipa_rm_resource_name resource_name);
int ipa_rm_inactivity_timer_release_resource(
enum ipa_rm_resource_name resource_name);
/*
* Tethering bridge (Rmnet / MBIM)
*/
int teth_bridge_init(struct teth_bridge_init_params *params);
int teth_bridge_disconnect(enum ipa_client_type client);
int teth_bridge_connect(struct teth_bridge_connect_params *connect_params);
/*
* Tethering client info
*/
void ipa_set_client(int index, enum ipacm_client_enum client, bool uplink);
enum ipacm_client_enum ipa_get_client(int pipe_idx);
bool ipa_get_client_uplink(int pipe_idx);
/*
* IPADMA
*/
int ipa_dma_init(void);
int ipa_dma_enable(void);
int ipa_dma_disable(void);
int ipa_dma_sync_memcpy(u64 dest, u64 src, int len);
int ipa_dma_async_memcpy(u64 dest, u64 src, int len,
void (*user_cb)(void *user1), void *user_param);
int ipa_dma_uc_memcpy(phys_addr_t dest, phys_addr_t src, int len);
void ipa_dma_destroy(void);
/*
* mux id
*/
int ipa_write_qmap_id(struct ipa_ioc_write_qmapid *param_in);
/*
* interrupts
*/
int ipa_add_interrupt_handler(enum ipa_irq_type interrupt,
ipa_irq_handler_t handler,
bool deferred_flag,
void *private_data);
int ipa_remove_interrupt_handler(enum ipa_irq_type interrupt);
int ipa_restore_suspend_handler(void);
/*
* Miscellaneous
*/
void ipa_bam_reg_dump(void);
int ipa_get_ep_mapping(enum ipa_client_type client);
bool ipa_is_ready(void);
void ipa_proxy_clk_vote(void);
void ipa_proxy_clk_unvote(void);
enum ipa_hw_type ipa_get_hw_type(void);
bool ipa_is_client_handle_valid(u32 clnt_hdl);
enum ipa_client_type ipa_get_client_mapping(int pipe_idx);
enum ipa_rm_resource_name ipa_get_rm_resource_from_ep(int pipe_idx);
bool ipa_get_modem_cfg_emb_pipe_flt(void);
enum ipa_transport_type ipa_get_transport_type(void);
struct device *ipa_get_dma_dev(void);
struct iommu_domain *ipa_get_smmu_domain(void);
int ipa_uc_debug_stats_alloc(
struct IpaHwOffloadStatsAllocCmdData_t cmdinfo);
int ipa_uc_debug_stats_dealloc(uint32_t protocol);
void ipa_get_gsi_stats(int prot_id,
struct ipa_uc_dbg_ring_stats *stats);
int ipa_get_prot_id(enum ipa_client_type client);
int ipa_disable_apps_wan_cons_deaggr(uint32_t agg_size, uint32_t agg_count);
const struct ipa_gsi_ep_config *ipa_get_gsi_ep_info
(enum ipa_client_type client);
int ipa_stop_gsi_channel(u32 clnt_hdl);
typedef void (*ipa_ready_cb)(void *user_data);
/**
* ipa_register_ipa_ready_cb() - register a callback to be invoked
* when IPA core driver initialization is complete.
*
* @ipa_ready_cb: CB to be triggered.
* @user_data: Data to be sent to the originator of the CB.
*
* Note: This function is expected to be utilized when ipa_is_ready
* function returns false.
* An IPA client may also use this function directly rather than
* calling ipa_is_ready beforehand, as if this API returns -EEXIST,
* this means IPA initialization is complete (and no callback will
* be triggered).
* When the callback is triggered, the client MUST perform his
* operations in a different context.
*
* The function will return 0 on success, -ENOMEM on memory issues and
* -EEXIST if IPA initialization is complete already.
*/
int ipa_register_ipa_ready_cb(void (*ipa_ready_cb)(void *user_data),
void *user_data);
/**
* ipa_tz_unlock_reg - Unlocks memory regions so that they become accessible
* from AP.
* @reg_info - Pointer to array of memory regions to unlock
* @num_regs - Number of elements in the array
*
* Converts the input array of regions to a struct that TZ understands and
* issues an SCM call.
* Also flushes the memory cache to DDR in order to make sure that TZ sees the
* correct data structure.
*
* Returns: 0 on success, negative on failure
*/
int ipa_tz_unlock_reg(struct ipa_tz_unlock_reg_info *reg_info, u16 num_regs);
int ipa_get_smmu_params(struct ipa_smmu_in_params *in,
struct ipa_smmu_out_params *out);
/**
* ipa_is_vlan_mode - check if a LAN driver should load in VLAN mode
* @iface - type of vlan capable device
* @res - query result: true for vlan mode, false for non vlan mode
*
* API must be called after ipa_is_ready() returns true, otherwise it will fail
*
* Returns: 0 on success, negative on failure
*/
int ipa_is_vlan_mode(enum ipa_vlan_ifaces iface, bool *res);
/**
* ipa_get_lan_rx_napi - returns true if NAPI is enabled in the LAN RX dp
*/
bool ipa_get_lan_rx_napi(void);
#else /* (CONFIG_IPA || CONFIG_IPA3) */
/* low-level IPA client Connect / Disconnect */
static inline int ipa_connect(const struct ipa_connect_params *in,
struct ipa_sps_params *sps, u32 *clnt_hdl)
{
return -EPERM;
}
static inline int ipa_disconnect(u32 clnt_hdl)
{
return -EPERM;
}
/*
* Resume / Suspend
*/
static inline int ipa_reset_endpoint(u32 clnt_hdl)
{
return -EPERM;
}
/*
* Remove ep delay
*/
static inline int ipa_clear_endpoint_delay(u32 clnt_hdl)
{
return -EPERM;
}
/*
* Disable ep
*/
static inline int ipa_disable_endpoint(u32 clnt_hdl)
{
return -EPERM;
}
/*
* Configuration
*/
static inline int ipa_cfg_ep(u32 clnt_hdl,
const struct ipa_ep_cfg *ipa_ep_cfg)
{
return -EPERM;
}
static inline int ipa_cfg_ep_nat(u32 clnt_hdl,
const struct ipa_ep_cfg_nat *ipa_ep_cfg)
{
return -EPERM;
}
static inline int ipa_cfg_ep_conn_track(u32 clnt_hdl,
const struct ipa_ep_cfg_conn_track *ep_conn_track)
{
return -EPERM;
}
static inline int ipa_cfg_ep_hdr(u32 clnt_hdl,
const struct ipa_ep_cfg_hdr *ipa_ep_cfg)
{
return -EPERM;
}
static inline int ipa_cfg_ep_hdr_ext(u32 clnt_hdl,
const struct ipa_ep_cfg_hdr_ext *ipa_ep_cfg)
{
return -EPERM;
}
static inline int ipa_cfg_ep_mode(u32 clnt_hdl,
const struct ipa_ep_cfg_mode *ipa_ep_cfg)
{
return -EPERM;
}
static inline int ipa_cfg_ep_aggr(u32 clnt_hdl,
const struct ipa_ep_cfg_aggr *ipa_ep_cfg)
{
return -EPERM;
}
static inline int ipa_cfg_ep_deaggr(u32 clnt_hdl,
const struct ipa_ep_cfg_deaggr *ipa_ep_cfg)
{
return -EPERM;
}
static inline int ipa_cfg_ep_route(u32 clnt_hdl,
const struct ipa_ep_cfg_route *ipa_ep_cfg)
{
return -EPERM;
}
static inline int ipa_cfg_ep_holb(u32 clnt_hdl,
const struct ipa_ep_cfg_holb *ipa_ep_cfg)
{
return -EPERM;
}
static inline int ipa_cfg_ep_holb_by_client(enum ipa_client_type client,
const struct ipa_ep_cfg_holb *ep_holb)
{
return -EPERM;
}
static inline int ipa_cfg_ep_cfg(u32 clnt_hdl,
const struct ipa_ep_cfg_cfg *ipa_ep_cfg)
{
return -EPERM;
}
static inline int ipa_cfg_ep_metadata_mask(u32 clnt_hdl,
const struct ipa_ep_cfg_metadata_mask *ipa_ep_cfg)
{
return -EPERM;
}
static inline int ipa_cfg_ep_ctrl(u32 clnt_hdl,
const struct ipa_ep_cfg_ctrl *ep_ctrl)
{
return -EPERM;
}
/*
* Header removal / addition
*/
static inline int ipa_add_hdr(struct ipa_ioc_add_hdr *hdrs)
{
return -EPERM;
}
static inline int ipa_add_hdr_usr(struct ipa_ioc_add_hdr *hdrs,
bool user_only)
{
return -EPERM;
}
static inline int ipa_del_hdr(struct ipa_ioc_del_hdr *hdls)
{
return -EPERM;
}
static inline int ipa_commit_hdr(void)
{
return -EPERM;
}
static inline int ipa_reset_hdr(bool user_only)
{
return -EPERM;
}
static inline int ipa_get_hdr(struct ipa_ioc_get_hdr *lookup)
{
return -EPERM;
}
static inline int ipa_put_hdr(u32 hdr_hdl)
{
return -EPERM;
}
static inline int ipa_copy_hdr(struct ipa_ioc_copy_hdr *copy)
{
return -EPERM;
}
/*
* Header Processing Context
*/
static inline int ipa_add_hdr_proc_ctx(
struct ipa_ioc_add_hdr_proc_ctx *proc_ctxs,
bool user_only)
{
return -EPERM;
}
static inline int ipa_del_hdr_proc_ctx(struct ipa_ioc_del_hdr_proc_ctx *hdls)
{
return -EPERM;
}
/*
* Routing
*/
static inline int ipa_add_rt_rule(struct ipa_ioc_add_rt_rule *rules)
{
return -EPERM;
}
static inline int ipa_add_rt_rule_v2(struct ipa_ioc_add_rt_rule_v2 *rules)
{
return -EPERM;
}
static inline int ipa_add_rt_rule_usr(struct ipa_ioc_add_rt_rule *rules,
bool user_only)
{
return -EPERM;
}
static inline int ipa_add_rt_rule_usr_v2(
struct ipa_ioc_add_rt_rule_v2 *rules, bool user_only)
{
return -EPERM;
}
static inline int ipa_del_rt_rule(struct ipa_ioc_del_rt_rule *hdls)
{
return -EPERM;
}
static inline int ipa_commit_rt(enum ipa_ip_type ip)
{
return -EPERM;
}
static inline int ipa_reset_rt(enum ipa_ip_type ip, bool user_only)
{
return -EPERM;
}
static inline int ipa_get_rt_tbl(struct ipa_ioc_get_rt_tbl *lookup)
{
return -EPERM;
}
static inline int ipa_put_rt_tbl(u32 rt_tbl_hdl)
{
return -EPERM;
}
static inline int ipa_query_rt_index(struct ipa_ioc_get_rt_tbl_indx *in)
{
return -EPERM;
}
static inline int ipa_mdfy_rt_rule(struct ipa_ioc_mdfy_rt_rule *rules)
{
return -EPERM;
}
static inline int ipa_mdfy_rt_rule_v2(struct ipa_ioc_mdfy_rt_rule_v2 *rules)
{
return -EPERM;
}
/*
* Filtering
*/
static inline int ipa_add_flt_rule(struct ipa_ioc_add_flt_rule *rules)
{
return -EPERM;
}
static inline int ipa_add_flt_rule_v2(struct ipa_ioc_add_flt_rule_v2 *rules)
{
return -EPERM;
}
static inline int ipa_add_flt_rule_usr(struct ipa_ioc_add_flt_rule *rules,
bool user_only)
{
return -EPERM;
}
static inline int ipa_add_flt_rule_usr_v2(
struct ipa_ioc_add_flt_rule_v2 *rules, bool user_only)
{
return -EPERM;
}
static inline int ipa_del_flt_rule(struct ipa_ioc_del_flt_rule *hdls)
{
return -EPERM;
}
static inline int ipa_mdfy_flt_rule(struct ipa_ioc_mdfy_flt_rule *rules)
{
return -EPERM;
}
static inline int ipa_mdfy_flt_rule_v2(
struct ipa_ioc_mdfy_flt_rule_v2 *rules)
{
return -EPERM;
}
static inline int ipa_commit_flt(enum ipa_ip_type ip)
{
return -EPERM;
}
static inline int ipa_reset_flt(enum ipa_ip_type ip, bool user_only)
{
return -EPERM;
}
/*
* NAT
*/
static inline int ipa_allocate_nat_device(struct ipa_ioc_nat_alloc_mem *mem)
{
return -EPERM;
}
static inline int ipa_allocate_nat_table(
struct ipa_ioc_nat_ipv6ct_table_alloc *table_alloc)
{
return -EPERM;
}
static inline int ipa_allocate_ipv6ct_table(
struct ipa_ioc_nat_ipv6ct_table_alloc *table_alloc)
{
return -EPERM;
}
static inline int ipa_nat_init_cmd(struct ipa_ioc_v4_nat_init *init)
{
return -EPERM;
}
static inline int ipa_ipv6ct_init_cmd(struct ipa_ioc_ipv6ct_init *init)
{
return -EPERM;
}
static inline int ipa_nat_dma_cmd(struct ipa_ioc_nat_dma_cmd *dma)
{
return -EPERM;
}
static inline int ipa_table_dma_cmd(struct ipa_ioc_nat_dma_cmd *dma)
{
return -EPERM;
}
static inline int ipa_nat_del_cmd(struct ipa_ioc_v4_nat_del *del)
{
return -EPERM;
}
static inline int ipa_del_nat_table(struct ipa_ioc_nat_ipv6ct_table_del *del)
{
return -EPERM;
}
static inline int ipa_del_ipv6ct_table(
struct ipa_ioc_nat_ipv6ct_table_del *del)
{
return -EPERM;
}
static inline int ipa_nat_mdfy_pdn(struct ipa_ioc_nat_pdn_entry *mdfy_pdn)
{
return -EPERM;
}
/*
* Messaging
*/
static inline int ipa_send_msg(struct ipa_msg_meta *meta, void *buff,
ipa_msg_free_fn callback)
{
return -EPERM;
}
static inline int ipa_register_pull_msg(struct ipa_msg_meta *meta,
ipa_msg_pull_fn callback)
{
return -EPERM;
}
static inline int ipa_deregister_pull_msg(struct ipa_msg_meta *meta)
{
return -EPERM;
}
/*
* Interface
*/
static inline int ipa_register_intf(const char *name,
const struct ipa_tx_intf *tx,
const struct ipa_rx_intf *rx)
{
return -EPERM;
}
static inline int ipa_register_intf_ext(const char *name,
const struct ipa_tx_intf *tx,
const struct ipa_rx_intf *rx,
const struct ipa_ext_intf *ext)
{
return -EPERM;
}
static inline int ipa_deregister_intf(const char *name)
{
return -EPERM;
}
/*
* Aggregation
*/
static inline int ipa_set_aggr_mode(enum ipa_aggr_mode mode)
{
return -EPERM;
}
static inline int ipa_set_qcncm_ndp_sig(char sig[3])
{
return -EPERM;
}
static inline int ipa_set_single_ndp_per_mbim(bool enable)
{
return -EPERM;
}
/*
* Data path
*/
static inline int ipa_tx_dp(enum ipa_client_type dst, struct sk_buff *skb,
struct ipa_tx_meta *metadata)
{
return -EPERM;
}
/*
* To transfer multiple data packets
*/
static inline int ipa_tx_dp_mul(
enum ipa_client_type dst,
struct ipa_tx_data_desc *data_desc)
{
return -EPERM;
}
static inline void ipa_free_skb(struct ipa_rx_data *rx_in)
{
}
static inline int ipa_rx_poll(u32 clnt_hdl, int budget)
{
return -EPERM;
}
static inline void ipa_recycle_wan_skb(struct sk_buff *skb)
{
}
/*
* System pipes
*/
static inline u16 ipa_get_smem_restr_bytes(void)
{
return -EPERM;
}
static inline int ipa_setup_sys_pipe(struct ipa_sys_connect_params *sys_in,
u32 *clnt_hdl)
{
return -EPERM;
}
static inline int ipa_teardown_sys_pipe(u32 clnt_hdl)
{
return -EPERM;
}
static inline int ipa_connect_wdi_pipe(struct ipa_wdi_in_params *in,
struct ipa_wdi_out_params *out)
{
return -EPERM;
}
static inline int ipa_disconnect_wdi_pipe(u32 clnt_hdl)
{
return -EPERM;
}
static inline int ipa_enable_wdi_pipe(u32 clnt_hdl)
{
return -EPERM;
}
static inline int ipa_disable_wdi_pipe(u32 clnt_hdl)
{
return -EPERM;
}
static inline int ipa_resume_wdi_pipe(u32 clnt_hdl)
{
return -EPERM;
}
static inline int ipa_suspend_wdi_pipe(u32 clnt_hdl)
{
return -EPERM;
}
static inline int ipa_broadcast_wdi_quota_reach_ind(uint32_t fid,
uint64_t num_bytes)
{
return -EPERM;
}
static inline int ipa_uc_wdi_get_dbpa(
struct ipa_wdi_db_params *out)
{
return -EPERM;
}
static inline int ipa_uc_reg_rdyCB(
struct ipa_wdi_uc_ready_params *param)
{
return -EPERM;
}
static inline int ipa_uc_dereg_rdyCB(void)
{
return -EPERM;
}
/*
* Resource manager
*/
static inline int ipa_rm_create_resource(
struct ipa_rm_create_params *create_params)
{
return -EPERM;
}
static inline int ipa_rm_delete_resource(
enum ipa_rm_resource_name resource_name)
{
return -EPERM;
}
static inline int ipa_rm_register(enum ipa_rm_resource_name resource_name,
struct ipa_rm_register_params *reg_params)
{
return -EPERM;
}
static inline int ipa_rm_set_perf_profile(
enum ipa_rm_resource_name resource_name,
struct ipa_rm_perf_profile *profile)
{
return -EPERM;
}
static inline int ipa_rm_deregister(enum ipa_rm_resource_name resource_name,
struct ipa_rm_register_params *reg_params)
{
return -EPERM;
}
static inline int ipa_rm_add_dependency(
enum ipa_rm_resource_name resource_name,
enum ipa_rm_resource_name depends_on_name)
{
return -EPERM;
}
static inline int ipa_rm_add_dependency_sync(
enum ipa_rm_resource_name resource_name,
enum ipa_rm_resource_name depends_on_name)
{
return -EPERM;
}
static inline int ipa_rm_delete_dependency(
enum ipa_rm_resource_name resource_name,
enum ipa_rm_resource_name depends_on_name)
{
return -EPERM;
}
static inline int ipa_rm_request_resource(
enum ipa_rm_resource_name resource_name)
{
return -EPERM;
}
static inline int ipa_rm_release_resource(
enum ipa_rm_resource_name resource_name)
{
return -EPERM;
}
static inline int ipa_rm_notify_completion(enum ipa_rm_event event,
enum ipa_rm_resource_name resource_name)
{
return -EPERM;
}
static inline int ipa_rm_inactivity_timer_init(
enum ipa_rm_resource_name resource_name,
unsigned long msecs)
{
return -EPERM;
}
static inline int ipa_rm_inactivity_timer_destroy(
enum ipa_rm_resource_name resource_name)
{
return -EPERM;
}
static inline int ipa_rm_inactivity_timer_request_resource(
enum ipa_rm_resource_name resource_name)
{
return -EPERM;
}
static inline int ipa_rm_inactivity_timer_release_resource(
enum ipa_rm_resource_name resource_name)
{
return -EPERM;
}
/*
* Tethering bridge (Rmnet / MBIM)
*/
static inline int teth_bridge_init(struct teth_bridge_init_params *params)
{
return -EPERM;
}
static inline int teth_bridge_disconnect(enum ipa_client_type client)
{
return -EPERM;
}
static inline int teth_bridge_connect(struct teth_bridge_connect_params
*connect_params)
{
return -EPERM;
}
/*
* Tethering client info
*/
static inline void ipa_set_client(int index, enum ipacm_client_enum client,
bool uplink)
{
}
static inline enum ipacm_client_enum ipa_get_client(int pipe_idx)
{
return -EPERM;
}
static inline bool ipa_get_client_uplink(int pipe_idx)
{
return -EPERM;
}
/*
* IPADMA
*/
static inline int ipa_dma_init(void)
{
return -EPERM;
}
static inline int ipa_dma_enable(void)
{
return -EPERM;
}
static inline int ipa_dma_disable(void)
{
return -EPERM;
}
static inline int ipa_dma_sync_memcpy(phys_addr_t dest, phys_addr_t src
, int len)
{
return -EPERM;
}
static inline int ipa_dma_async_memcpy(phys_addr_t dest, phys_addr_t src
, int len, void (*user_cb)(void *user1),
void *user_param)
{
return -EPERM;
}
static inline int ipa_dma_uc_memcpy(phys_addr_t dest, phys_addr_t src, int len)
{
return -EPERM;
}
static inline void ipa_dma_destroy(void)
{
}
/*
* mux id
*/
static inline int ipa_write_qmap_id(struct ipa_ioc_write_qmapid *param_in)
{
return -EPERM;
}
/*
* interrupts
*/
static inline int ipa_add_interrupt_handler(enum ipa_irq_type interrupt,
ipa_irq_handler_t handler,
bool deferred_flag,
void *private_data)
{
return -EPERM;
}
static inline int ipa_remove_interrupt_handler(enum ipa_irq_type interrupt)
{
return -EPERM;
}
static inline int ipa_restore_suspend_handler(void)
{
return -EPERM;
}
/*
* Miscellaneous
*/
static inline void ipa_bam_reg_dump(void)
{
}
static inline int ipa_get_wdi_stats(struct IpaHwStatsWDIInfoData_t *stats)
{
return -EPERM;
}
static inline int ipa_uc_bw_monitor(struct ipa_wdi_bw_info *info)
{
return -EPERM;
}
static inline int ipa_set_wlan_tx_info(struct ipa_wdi_tx_info *info)
{
return -EPERM;
}
static inline int ipa_get_ep_mapping(enum ipa_client_type client)
{
return -EPERM;
}
static inline bool ipa_is_ready(void)
{
return false;
}
static inline void ipa_proxy_clk_vote(void)
{
}
static inline void ipa_proxy_clk_unvote(void)
{
}
static inline enum ipa_hw_type ipa_get_hw_type(void)
{
return IPA_HW_None;
}
static inline bool ipa_is_client_handle_valid(u32 clnt_hdl)
{
return -EINVAL;
}
static inline enum ipa_client_type ipa_get_client_mapping(int pipe_idx)
{
return -EINVAL;
}
static inline enum ipa_rm_resource_name ipa_get_rm_resource_from_ep(
int pipe_idx)
{
return -EFAULT;
}
static inline bool ipa_get_modem_cfg_emb_pipe_flt(void)
{
return -EINVAL;
}
static inline enum ipa_transport_type ipa_get_transport_type(void)
{
return -EFAULT;
}
static inline struct device *ipa_get_dma_dev(void)
{
return NULL;
}
static inline struct iommu_domain *ipa_get_smmu_domain(void)
{
return NULL;
}
static inline int ipa_create_wdi_mapping(u32 num_buffers,
struct ipa_wdi_buffer_info *info)
{
return -EINVAL;
}
static inline int ipa_release_wdi_mapping(u32 num_buffers,
struct ipa_wdi_buffer_info *info)
{
return -EINVAL;
}
static inline int ipa_disable_apps_wan_cons_deaggr(void)
{
return -EINVAL;
}
static inline const struct ipa_gsi_ep_config *ipa_get_gsi_ep_info
(enum ipa_client_type client)
{
return NULL;
}
static inline int ipa_stop_gsi_channel(u32 clnt_hdl)
{
return -EPERM;
}
static inline int ipa_register_ipa_ready_cb(
void (*ipa_ready_cb)(void *user_data),
void *user_data)
{
return -EPERM;
}
static inline int ipa_tz_unlock_reg(struct ipa_tz_unlock_reg_info *reg_info,
u16 num_regs)
{
return -EPERM;
}
static inline int ipa_get_smmu_params(struct ipa_smmu_in_params *in,
struct ipa_smmu_out_params *out)
{
return -EPERM;
}
static inline int ipa_is_vlan_mode(enum ipa_vlan_ifaces iface, bool *res)
{
return -EPERM;
}
static inline int ipa_uc_debug_stats_alloc(
struct IpaHwOffloadStatsAllocCmdData_t cmdinfo)
{
return -EPERM;
}
static inline int ipa_uc_debug_stats_dealloc(uint32_t protocol)
{
return -EPERM;
}
static inline void ipa_get_gsi_stats(int prot_id,
struct ipa_uc_dbg_ring_stats *stats)
{
}
static inline int ipa_get_prot_id(enum ipa_client_type client)
{
return -EPERM;
}
static inline bool ipa_get_lan_rx_napi(void)
{
return false;
}
#endif /* (CONFIG_IPA || CONFIG_IPA3) */
#endif /* _IPA_H_ */
Reference in a new issue View git blame Copy permalink