Commit 4ea29143 authored by Alex Elder's avatar Alex Elder Committed by David S. Miller
Browse files

net: ipa: kill IPA_TABLE_ENTRY_SIZE 



Entries in an IPA route or filter table are 64-bit little-endian
addresses, each of which refers to a routing or filtering rule.

The format of these table slots are fixed, but IPA_TABLE_ENTRY_SIZE
is used to define their size.  This symbol doesn't really add value,
and I think it unnecessarily obscures what a table entry *is*.

So get rid of IPA_TABLE_ENTRY_SIZE, and just use sizeof(__le64) in
its place throughout the code.

Update the comments in "ipa_table.c" to provide a little better
explanation of these table slots.

Signed-off-by: default avatarAlex Elder <elder@linaro.org>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 19aaf72c

drivers/net/ipa/ipa_cmd.c

+1 −1
Original line number Diff line number Diff line
@@ -153,7 +153,7 @@ static void ipa_cmd_validate_build(void) 
	 * of entries, as and IPv4 and IPv6 route tables have the same number

	 * of entries.

	 */

#define TABLE_SIZE	(TABLE_COUNT_MAX * IPA_TABLE_ENTRY_SIZE)

#define TABLE_SIZE	(TABLE_COUNT_MAX * sizeof(__le64))

#define TABLE_COUNT_MAX	max_t(u32, IPA_ROUTE_COUNT_MAX, IPA_FILTER_COUNT_MAX)

	BUILD_BUG_ON(TABLE_SIZE > field_max(IP_FLTRT_FLAGS_HASH_SIZE_FMASK));

	BUILD_BUG_ON(TABLE_SIZE > field_max(IP_FLTRT_FLAGS_NHASH_SIZE_FMASK));

drivers/net/ipa/ipa_qmi.c

+4 −6
Original line number Diff line number Diff line
@@ -308,12 +308,12 @@ init_modem_driver_req(struct ipa_qmi *ipa_qmi) 
	mem = &ipa->mem[IPA_MEM_V4_ROUTE];

	req.v4_route_tbl_info_valid = 1;

	req.v4_route_tbl_info.start = ipa->mem_offset + mem->offset;

	req.v4_route_tbl_info.count = mem->size / IPA_TABLE_ENTRY_SIZE;

	req.v4_route_tbl_info.count = mem->size / sizeof(__le64);



	mem = &ipa->mem[IPA_MEM_V6_ROUTE];

	req.v6_route_tbl_info_valid = 1;

	req.v6_route_tbl_info.start = ipa->mem_offset + mem->offset;

	req.v6_route_tbl_info.count = mem->size / IPA_TABLE_ENTRY_SIZE;

	req.v6_route_tbl_info.count = mem->size / sizeof(__le64);



	mem = &ipa->mem[IPA_MEM_V4_FILTER];

	req.v4_filter_tbl_start_valid = 1;
@@ -352,8 +352,7 @@ init_modem_driver_req(struct ipa_qmi *ipa_qmi) 
		req.v4_hash_route_tbl_info_valid = 1;

		req.v4_hash_route_tbl_info.start =

				ipa->mem_offset + mem->offset;

		req.v4_hash_route_tbl_info.count =

				mem->size / IPA_TABLE_ENTRY_SIZE;

		req.v4_hash_route_tbl_info.count = mem->size / sizeof(__le64);

	}



	mem = &ipa->mem[IPA_MEM_V6_ROUTE_HASHED];
@@ -361,8 +360,7 @@ init_modem_driver_req(struct ipa_qmi *ipa_qmi) 
		req.v6_hash_route_tbl_info_valid = 1;

		req.v6_hash_route_tbl_info.start =

			ipa->mem_offset + mem->offset;

		req.v6_hash_route_tbl_info.count =

			mem->size / IPA_TABLE_ENTRY_SIZE;

		req.v6_hash_route_tbl_info.count = mem->size / sizeof(__le64);

	}



	mem = &ipa->mem[IPA_MEM_V4_FILTER_HASHED];

drivers/net/ipa/ipa_table.c

+34 −25
Original line number Diff line number Diff line
@@ -27,28 +27,38 @@ 
/**

 * DOC: IPA Filter and Route Tables

 *

 * The IPA has tables defined in its local shared memory that define filter

 * and routing rules.  Each entry in these tables contains a 64-bit DMA

 * address that refers to DRAM (system memory) containing a rule definition.

 * The IPA has tables defined in its local (IPA-resident) memory that define

 * filter and routing rules.  An entry in either of these tables is a little

 * endian 64-bit "slot" that holds the address of a rule definition.  (The

 * size of these slots is 64 bits regardless of the host DMA address size.)

 *

 * Separate tables (both filter and route) used for IPv4 and IPv6.  There

 * are normally another set of "hashed" filter and route tables, which are

 * used with a hash of message metadata.  Hashed operation is not supported

 * by all IPA hardware (IPA v4.2 doesn't support hashed tables).

 *

 * Rules can be in local memory or in DRAM (system memory).  The offset of

 * an object (such as a route or filter table) in IPA-resident memory must

 * 128-byte aligned.  An object in system memory (such as a route or filter

 * rule) must be at an 8-byte aligned address.  We currently only place

 * route or filter rules in system memory.

 *

 * A rule consists of a contiguous block of 32-bit values terminated with

 * 32 zero bits.  A special "zero entry" rule consisting of 64 zero bits

 * represents "no filtering" or "no routing," and is the reset value for

 * filter or route table rules.  Separate tables (both filter and route)

 * used for IPv4 and IPv6.  Additionally, there can be hashed filter or

 * route tables, which are used when a hash of message metadata matches.

 * Hashed operation is not supported by all IPA hardware.

 * filter or route table rules.

 *

 * Each filter rule is associated with an AP or modem TX endpoint, though

 * not all TX endpoints support filtering.  The first 64-bit entry in a

 * not all TX endpoints support filtering.  The first 64-bit slot in a

 * filter table is a bitmap indicating which endpoints have entries in

 * the table.  The low-order bit (bit 0) in this bitmap represents a

 * special global filter, which applies to all traffic.  This is not

 * used in the current code.  Bit 1, if set, indicates that there is an

 * entry (i.e. a DMA address referring to a rule) for endpoint 0 in the

 * table.  Bit 2, if set, indicates there is an entry for endpoint 1,

 * and so on.  Space is set aside in IPA local memory to hold as many

 * filter table entries as might be required, but typically they are not

 * all used.

 * entry (i.e. slot containing a system address referring to a rule) for

 * endpoint 0 in the table.  Bit 3, if set, indicates there is an entry

 * for endpoint 2, and so on.  Space is set aside in IPA local memory to

 * hold as many filter table entries as might be required, but typically

 * they are not all used.

 *

 * The AP initializes all entries in a filter table to refer to a "zero"

 * entry.  Once initialized the modem and AP update the entries for
@@ -122,8 +132,7 @@ static void ipa_table_validate_build(void) 
	 * code in ipa_table_init() uses a pointer to __le64 to

	 * initialize tables.

	 */

	BUILD_BUG_ON(sizeof(dma_addr_t) > IPA_TABLE_ENTRY_SIZE);

	BUILD_BUG_ON(sizeof(__le64) != IPA_TABLE_ENTRY_SIZE);

	BUILD_BUG_ON(sizeof(dma_addr_t) > sizeof(__le64));



	/* A "zero rule" is used to represent no filtering or no routing.

	 * It is a 64-bit block of zeroed memory.  Code in ipa_table_init()
@@ -154,7 +163,7 @@ ipa_table_valid_one(struct ipa *ipa, bool route, bool ipv6, bool hashed) 
		else

			mem = hashed ? &ipa->mem[IPA_MEM_V4_ROUTE_HASHED]

				     : &ipa->mem[IPA_MEM_V4_ROUTE];

		size = IPA_ROUTE_COUNT_MAX * IPA_TABLE_ENTRY_SIZE;

		size = IPA_ROUTE_COUNT_MAX * sizeof(__le64);

	} else {

		if (ipv6)

			mem = hashed ? &ipa->mem[IPA_MEM_V6_FILTER_HASHED]
@@ -162,7 +171,7 @@ ipa_table_valid_one(struct ipa *ipa, bool route, bool ipv6, bool hashed) 
		else

			mem = hashed ? &ipa->mem[IPA_MEM_V4_FILTER_HASHED]

				     : &ipa->mem[IPA_MEM_V4_FILTER];

		size = (1 + IPA_FILTER_COUNT_MAX) * IPA_TABLE_ENTRY_SIZE;

		size = (1 + IPA_FILTER_COUNT_MAX) * sizeof(__le64);

	}



	if (!ipa_cmd_table_valid(ipa, mem, route, ipv6, hashed))
@@ -261,8 +270,8 @@ static void ipa_table_reset_add(struct gsi_trans *trans, bool filter, 
	if (filter)

		first++;	/* skip over bitmap */



	offset = mem->offset + first * IPA_TABLE_ENTRY_SIZE;

	size = count * IPA_TABLE_ENTRY_SIZE;

	offset = mem->offset + first * sizeof(__le64);

	size = count * sizeof(__le64);

	addr = ipa_table_addr(ipa, false, count);



	ipa_cmd_dma_shared_mem_add(trans, offset, size, addr, true);
@@ -444,11 +453,11 @@ static void ipa_table_init_add(struct gsi_trans *trans, bool filter, 
		count = hweight32(ipa->filter_map);

		hash_count = hash_mem->size ? count : 0;

	} else {

		count = mem->size / IPA_TABLE_ENTRY_SIZE;

		hash_count = hash_mem->size / IPA_TABLE_ENTRY_SIZE;

		count = mem->size / sizeof(__le64);

		hash_count = hash_mem->size / sizeof(__le64);

	}

	size = count * IPA_TABLE_ENTRY_SIZE;

	hash_size = hash_count * IPA_TABLE_ENTRY_SIZE;

	size = count * sizeof(__le64);

	hash_size = hash_count * sizeof(__le64);



	addr = ipa_table_addr(ipa, filter, count);

	hash_addr = ipa_table_addr(ipa, filter, hash_count);
@@ -655,7 +664,7 @@ int ipa_table_init(struct ipa *ipa) 
	 * by dma_alloc_coherent() is guaranteed to be a power-of-2 number

	 * of pages, which satisfies the rule alignment requirement.

	 */

	size = IPA_ZERO_RULE_SIZE + (1 + count) * IPA_TABLE_ENTRY_SIZE;

	size = IPA_ZERO_RULE_SIZE + (1 + count) * sizeof(__le64);

	virt = dma_alloc_coherent(dev, size, &addr, GFP_KERNEL);

	if (!virt)

		return -ENOMEM;
@@ -687,7 +696,7 @@ void ipa_table_exit(struct ipa *ipa) 
	struct device *dev = &ipa->pdev->dev;

	size_t size;



	size = IPA_ZERO_RULE_SIZE + (1 + count) * IPA_TABLE_ENTRY_SIZE;

	size = IPA_ZERO_RULE_SIZE + (1 + count) * sizeof(__le64);



	dma_free_coherent(dev, size, ipa->table_virt, ipa->table_addr);

	ipa->table_addr = 0;

drivers/net/ipa/ipa_table.h

+0 −3
Original line number Diff line number Diff line
@@ -10,9 +10,6 @@ 


struct ipa;



/* The size of a filter or route table entry */

#define IPA_TABLE_ENTRY_SIZE	sizeof(__le64)	/* Holds a physical address */



/* The maximum number of filter table entries (IPv4, IPv6; hashed or not) */

#define IPA_FILTER_COUNT_MAX	14