android_kernel_samsung_sm8650-modules/ipanat/inc/ipa_nat_drvi.h

/*
 * Copyright (c) 2013-2020 The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 *  * Neither the name of The Linux Foundation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef IPA_NAT_DRVI_H
#define IPA_NAT_DRVI_H

#include "ipa_table.h"
#include "ipa_mem_descriptor.h"
#include "ipa_nat_utils.h"

#undef MAKE_TBL_HDL
#define MAKE_TBL_HDL(hdl, mt) \
	((mt) << 31 | (hdl))

#undef BREAK_TBL_HDL
#define BREAK_TBL_HDL(hdl_in, mt, hdl_out) \
	do { \
		mt      = (hdl_in) >> 31 & 0x0000000001; \
		hdl_out = (hdl_in)       & 0x00000000FF; \
	} while ( 0 )

#undef VALID_TBL_HDL
#define VALID_TBL_HDL(h) \
	(((h) & 0x00000000FF) == IPA_NAT_MAX_IP4_TBLS)

/*======= IMPLEMENTATION related data structures and functions ======= */

#define IPA_NAT_MAX_IP4_TBLS   1

#define IPA_NAT_RULE_FLAG_FIELD_OFFSET        18
#define IPA_NAT_RULE_NEXT_FIELD_OFFSET        8
#define IPA_NAT_RULE_PROTO_FIELD_OFFSET       22

#define IPA_NAT_INDEX_RULE_NEXT_FIELD_OFFSET       2
#define IPA_NAT_INDEX_RULE_NAT_INDEX_FIELD_OFFSET  0

#define IPA_NAT_FLAG_ENABLE_BIT  1

#define IPA_NAT_INVALID_PROTO_FIELD_VALUE 0xFF00
/*
 * IPA_NAT_INVALID_PROTO_FIELD_VALUE above is what's passed to the IPA
 * in a DMA command.  It is written into the NAT's rule, by the
 * IPA. After being written, It minifests in the rule in the form
 * below, hence it will be used when perusing the "struct
 * ipa_nat_rule".
 */
#define IPA_NAT_INVALID_PROTO_FIELD_VALUE_IN_RULE  0xFF

typedef enum {
	IPA_NAT_TABLE_FLAGS,
	IPA_NAT_TABLE_NEXT_INDEX,
	IPA_NAT_TABLE_PROTOCOL,
	IPA_NAT_INDEX_TABLE_ENTRY,
	IPA_NAT_INDEX_TABLE_NEXT_INDEX,
	IPA_NAT_TABLE_DMA_CMD_MAX
} ipa_nat_table_dma_cmd_type;

/*
 * ------------------------  NAT Table Entry  -----------------------------------------
 *
 * ------------------------------------------------------------------------------------
 * |   7    |    6    |   5    |    4    |     3        |  2   |    1    |    0       |
 * ------------------------------------------------------------------------------------
 * |             Target IP(4B)           |             Private IP(4B)                 |
 * ------------------------------------------------------------------------------------
 * |Target Port(2B)   | Private Port(2B) | Public Port(2B)     | Next Index(2B)       |
 * ------------------------------------------------------------------------------------
 * | Proto   |      TimeStamp(3B)        |       Flags(2B)     | IP check sum Diff(2B)|
 * | (1B)    |                           |EN|Redirect|Resv     |                      |
 * ------------------------------------------------------------------------------------
 * | TCP/UDP checksum |PDN info|Reserved |    SW Specific Parameters(4B)              |
 * |    diff (2B)     |  (1B)  |  (1B)   |                                            |
 * ------------------------------------------------------------------------------------
 *
 * Dont change below structure definition.
 *
 * It should be same as above(little endian order)
 *
 * -------------------------------------------------------------------------------
 */
struct ipa_nat_rule {
	uint64_t private_ip:32;
	uint64_t target_ip:32;

	uint64_t next_index:16;
	uint64_t public_port:16;
	uint64_t private_port:16;
	uint64_t target_port:16;

	uint64_t ip_chksum:16;

	/*--------------------------------------------------
	IPA NAT Flag is interpreted as follows
	---------------------------------------------------
	|  EN   |FIN/RST|  S   | IPv4 uC activation index |
	| [15]  | [14]  | [13] |          [12:0]          |
	---------------------------------------------------
	--------------------------------------------------*/
	uint64_t uc_activation_index:13;
	uint64_t s:1;
	uint64_t redirect:1;
	uint64_t enable:1;

	uint64_t time_stamp:24;
	uint64_t protocol:8;

	/*--------------------------------------------------
	32 bit sw_spec_params is interpreted as follows
	------------------------------------
	|     16 bits     |     16 bits    |
	------------------------------------
	|  index table    |  prev index    |
	|     entry       |                |
	------------------------------------
	--------------------------------------------------*/
	uint64_t prev_index:16;
	uint64_t indx_tbl_entry:16;
	uint64_t rsvd2:8;
	/*-----------------------------------------
	8 bit PDN info is interpreted as following
	-----------------------------------------------------
	|     4 bits      |     1 bit      |     3 bits     |
	-----------------------------------------------------
	|  PDN index      |  uC processing |  src dst Rsrv3 |
	|      [7:4]      |       [3]      |  [2] [1]  [0]  |
	-----------------------------------------------------
	-------------------------------------------*/
	uint64_t rsvd3:1;
	uint64_t dst_only:1;
	uint64_t src_only:1;
	uint64_t ucp:1;
	uint64_t pdn_index:4;

	uint64_t tcp_udp_chksum:16;
};

static inline char* prep_nat_rule_4print(
	struct ipa_nat_rule* rule_ptr,
	char*                buf_ptr,
	uint32_t             buf_sz )
{
	if ( rule_ptr && buf_ptr && buf_sz )
	{
		snprintf(
			buf_ptr, buf_sz,
			"NAT RULE: "
			"protocol(0x%02X) "
			"public_port(0x%04X) "
			"target_ip(0x%08X) "
			"target_port(0x%04X) "
			"private_ip(0x%08X) "
			"private_port(0x%04X) "
			"pdn_index(0x%02X) "
			"ip_chksum(0x%04X) "
			"tcp_udp_chksum(0x%04X) "
			"redirect(0x%02X) "
			"enable(0x%02X) "
			"time_stamp(0x%08X) "
			"indx_tbl_entry(0x%04X) "
			"prev_index(0x%04X) "
			"next_index(0x%04X)",
			rule_ptr->protocol,
			rule_ptr->public_port,
			rule_ptr->target_ip,
			rule_ptr->target_port,
			rule_ptr->private_ip,
			rule_ptr->private_port,
			rule_ptr->pdn_index,
			rule_ptr->ip_chksum,
			rule_ptr->tcp_udp_chksum,
			rule_ptr->redirect,
			rule_ptr->enable,
			rule_ptr->time_stamp,
			rule_ptr->indx_tbl_entry,
			rule_ptr->prev_index,
			rule_ptr->next_index);
	}

	return buf_ptr;
}

static inline const char *ipa3_nat_mem_in_as_str(
	enum ipa3_nat_mem_in nmi)
{
	switch (nmi) {
	case IPA_NAT_MEM_IN_DDR:
		return "IPA_NAT_MEM_IN_DDR";
	case IPA_NAT_MEM_IN_SRAM:
		return "IPA_NAT_MEM_IN_SRAM";
	default:
		break;
	}
	return "???";
}

static inline char *ipa_ioc_v4_nat_init_as_str(
	struct ipa_ioc_v4_nat_init *ptr,
	char                       *buf,
	uint32_t                    buf_sz)
{
	if (ptr && buf && buf_sz) {
		snprintf(
			buf, buf_sz,
			"V4 NAT INIT: tbl_index(0x%02X) ipv4_rules_offset(0x%08X) expn_rules_offset(0x%08X) index_offset(0x%08X) index_expn_offset(0x%08X) table_entries(0x%04X) expn_table_entries(0x%04X) ip_addr(0x%08X)",
			ptr->tbl_index,
			ptr->ipv4_rules_offset,
			ptr->expn_rules_offset,
			ptr->index_offset,
			ptr->index_expn_offset,
			ptr->table_entries,
			ptr->expn_table_entries,
			ptr->ip_addr);
	}
	return buf;
}

/*
	IPA NAT Flag is interpreted as follows
	---------------------------------------------------
	|  EN   |FIN/RST|  S   | IPv4 uC activation index |
	| [15]  | [14]  | [13] |          [12:0]          |
	---------------------------------------------------
*/
typedef struct {
	uint32_t uc_activation_index:13;
	uint32_t s:1;
	uint32_t redirect:1;
	uint32_t enable:1;
} ipa_nat_flags;

struct ipa_nat_indx_tbl_rule {
	uint16_t tbl_entry;
	uint16_t next_index;
};

struct ipa_nat_indx_tbl_meta_info {
	uint16_t prev_index;
};

struct ipa_nat_ip4_table_cache {
	uint32_t public_addr;
	ipa_mem_descriptor mem_desc;
	ipa_table table;
	ipa_table index_table;
	struct ipa_nat_indx_tbl_meta_info *index_expn_table_meta;
	ipa_table_dma_cmd_helper table_dma_cmd_helpers[IPA_NAT_TABLE_DMA_CMD_MAX];
};

struct ipa_nat_cache {
	ipa_descriptor* ipa_desc;
	struct ipa_nat_ip4_table_cache ip4_tbl[IPA_NAT_MAX_IP4_TBLS];
	uint8_t table_cnt;
	enum ipa3_nat_mem_in nmi;
};

int ipa_nati_add_ipv4_tbl(
	uint32_t    public_ip_addr,
	const char *mem_type_ptr,
	uint16_t    number_of_entries,
	uint32_t   *table_hanle);

int ipa_nati_del_ipv4_table(uint32_t tbl_hdl);

int ipa_nati_query_timestamp(uint32_t  tbl_hdl,
				uint32_t  rule_hdl,
				uint32_t  *time_stamp);

int ipa_nati_modify_pdn(struct ipa_ioc_nat_pdn_entry *entry);

int ipa_nati_get_pdn_index(uint32_t public_ip, uint8_t *pdn_index);

int ipa_nati_alloc_pdn(ipa_nat_pdn_entry *pdn_info, uint8_t *pdn_index);

int ipa_nati_get_pdn_cnt(void);

int ipa_nati_dealloc_pdn(uint8_t pdn_index);

int ipa_nati_add_ipv4_rule(uint32_t tbl_hdl,
				const ipa_nat_ipv4_rule *clnt_rule,
				uint32_t *rule_hdl);

int ipa_nati_del_ipv4_rule(uint32_t tbl_hdl,
				uint32_t rule_hdl);

int ipa_nati_get_sram_size(
	uint32_t* size_ptr);

int ipa_nati_clear_ipv4_tbl(
	uint32_t tbl_hdl );

int ipa_nati_copy_ipv4_tbl(
	uint32_t          src_tbl_hdl,
	uint32_t          dst_tbl_hdl,
	ipa_table_walk_cb copy_cb );

typedef enum
{
	USE_NAT_TABLE   = 0,
	USE_INDEX_TABLE = 1,

	USE_MAX
} WhichTbl2Use;

#define VALID_WHICHTBL2USE(w) \
	( (w) >= USE_NAT_TABLE && (w) < USE_MAX )

int ipa_nati_walk_ipv4_tbl(
	uint32_t          tbl_hdl,
	WhichTbl2Use      which,
	ipa_table_walk_cb walk_cb,
	void*             arb_data_ptr );

/*
 * The following used for retrieving table stats.
 */
typedef struct
{
	enum ipa3_nat_mem_in nmi;
	uint32_t tot_ents;
	uint32_t tot_base_ents;
	uint32_t tot_base_ents_filled;
	uint32_t tot_expn_ents;
	uint32_t tot_expn_ents_filled;
	uint32_t tot_chains;
	uint32_t min_chain_len;
	uint32_t max_chain_len;
	float    avg_chain_len;
} ipa_nati_tbl_stats;

int ipa_nati_ipv4_tbl_stats(
	uint32_t            tbl_hdl,
	ipa_nati_tbl_stats* nat_stats_ptr,
	ipa_nati_tbl_stats* idx_stats_ptr );

int ipa_nati_vote_clock(
	enum ipa_app_clock_vote_type vote_type );

int ipa_NATI_add_ipv4_tbl(
	enum ipa3_nat_mem_in nmi,
	uint32_t             public_ip_addr,
	uint16_t             number_of_entries,
	uint32_t*            tbl_hdl);

int ipa_NATI_del_ipv4_table(
	uint32_t tbl_hdl);

int ipa_NATI_clear_ipv4_tbl(
	uint32_t tbl_hdl );

int ipa_NATI_walk_ipv4_tbl(
	uint32_t          tbl_hdl,
	WhichTbl2Use      which,
	ipa_table_walk_cb walk_cb,
	void*             arb_data_ptr );

int ipa_NATI_ipv4_tbl_stats(
	uint32_t            tbl_hdl,
	ipa_nati_tbl_stats* nat_stats_ptr,
	ipa_nati_tbl_stats* idx_stats_ptr );

int ipa_NATI_query_timestamp(
	uint32_t  tbl_hdl,
	uint32_t  rule_hdl,
	uint32_t* time_stamp);

int ipa_NATI_add_ipv4_rule(
	uint32_t                 tbl_hdl,
	const ipa_nat_ipv4_rule* clnt_rule,
	uint32_t*                rule_hdl);

int ipa_NATI_del_ipv4_rule(
	uint32_t tbl_hdl,
	uint32_t rule_hdl);

int ipa_NATI_post_ipv4_init_cmd(
	uint32_t tbl_hdl );

#endif /* #ifndef IPA_NAT_DRVI_H */