net: ipa: determine route table size from memory region

Currently we assume that any routing table contains a fixed number
of entries.  The number of entries in a routing table can actually
vary, depending only on the size of the IPA-local memory region used
to hold the table.

Stop assuming that a routing table has exactly 15 entries.  Instead,
determine the number of entries in a routing table by dividing its
memory region size by the size of an entry.

The number of entries is computed early, when ipa_table_mem_valid()
is called by ipa_table_init().

Signed-off-by: Alex Elder <elder@linaro.org>
Signed-off-by: Paolo Abeni <pabeni@redhat.com>

diff --git a/drivers/net/ipa/ipa_cmd.c b/drivers/net/ipa/ipa_cmd.c
index de2cd86..08e3f39 100644 (file)
--- a/drivers/net/ipa/ipa_cmd.c
+++ b/drivers/net/ipa/ipa_cmd.c
@@ -145,18 +145,15 @@ union ipa_cmd_payload {
 
 static void ipa_cmd_validate_build(void)
 {
-       /* The sizes of a filter and route tables need to fit into fields
-        * in the ipa_cmd_hw_ip_fltrt_init structure.  Although hashed tables
+       /* The size of a filter table needs to fit into fields in the
+        * ipa_cmd_hw_ip_fltrt_init structure.  Although hashed tables
         * might not be used, non-hashed and hashed tables have the same
         * maximum size.  IPv4 and IPv6 filter tables have the same number
-        * of entries, as and IPv4 and IPv6 route tables have the same number
         * of entries.
         */
-#define TABLE_SIZE     (TABLE_COUNT_MAX * sizeof(__le64))
-#define TABLE_COUNT_MAX        max_t(u32, IPA_ROUTE_COUNT_MAX, IPA_FILTER_COUNT_MAX)
+#define TABLE_SIZE     (IPA_FILTER_COUNT_MAX * sizeof(__le64))
        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));
-#undef TABLE_COUNT_MAX
 #undef TABLE_SIZE
 
        /* Hashed and non-hashed fields are assumed to be the same size */
@@ -178,12 +175,14 @@ bool ipa_cmd_table_init_valid(struct ipa *ipa, const struct ipa_mem *mem,
        u32 size_max = field_max(IP_FLTRT_FLAGS_NHASH_SIZE_FMASK);
        const char *table = route ? "route" : "filter";
        struct device *dev = &ipa->pdev->dev;
+       u32 size;
+
+       size = route ? ipa->route_count * sizeof(__le64) : mem->size;
 
        /* Size must fit in the immediate command field that holds it */
-       if (mem->size > size_max) {
+       if (size > size_max) {
                dev_err(dev, "%s table region size too large\n", table);
-               dev_err(dev, "    (0x%04x > 0x%04x)\n",
-                       mem->size, size_max);
+               dev_err(dev, "    (0x%04x > 0x%04x)\n", size, size_max);
 
                return false;
        }

diff --git a/drivers/net/ipa/ipa_table.c b/drivers/net/ipa/ipa_table.c
index 0815c89..23d3f08 100644 (file)
--- a/drivers/net/ipa/ipa_table.c
+++ b/drivers/net/ipa/ipa_table.c
@@ -130,12 +130,8 @@ static void ipa_table_validate_build(void)
         */
        BUILD_BUG_ON(IPA_ZERO_RULE_SIZE != sizeof(__le64));
 
-       /* Impose a practical limit on the number of routes */
-       BUILD_BUG_ON(IPA_ROUTE_COUNT_MAX > 32);
        /* The modem must be allotted at least one route table entry */
        BUILD_BUG_ON(!IPA_ROUTE_MODEM_COUNT);
-       /* AP must too, but we can't use more than what is available */
-       BUILD_BUG_ON(IPA_ROUTE_MODEM_COUNT >= IPA_ROUTE_COUNT_MAX);
 }
 
 static const struct ipa_mem *
@@ -593,18 +589,18 @@ bool ipa_table_mem_valid(struct ipa *ipa, bool modem_route_count)
        if (mem_ipv4->size != mem_ipv6->size)
                return false;
 
-       /* Record the number of routing table entries */
+       /* Compute the number of entries, and for routing tables, record it */
+       count = mem_ipv4->size / sizeof(__le64);
+       if (count < 2)
+               return false;
        if (!filter)
-               ipa->route_count = IPA_ROUTE_COUNT_MAX;
+               ipa->route_count = count;
 
        /* Table offset and size must fit in TABLE_INIT command fields */
        if (!ipa_cmd_table_init_valid(ipa, mem_ipv4, !filter))
                return false;
 
        /* Make sure the regions are big enough */
-       count = mem_ipv4->size / sizeof(__le64);
-       if (count < 2)
-               return false;
        if (filter) {
                /* Filter tables must able to hold the endpoint bitmap plus
                 * an entry for each endpoint that supports filtering

diff --git a/drivers/net/ipa/ipa_table.h b/drivers/net/ipa/ipa_table.h
index 65d96de..3136329 100644 (file)
--- a/drivers/net/ipa/ipa_table.h
+++ b/drivers/net/ipa/ipa_table.h
@@ -16,9 +16,6 @@ struct ipa;
 /* The number of route table entries allotted to the modem */
 #define IPA_ROUTE_MODEM_COUNT  8
 
-/* The maximum number of route table entries (IPv4, IPv6; hashed or not) */
-#define IPA_ROUTE_COUNT_MAX    15
-
 /**
  * ipa_filter_map_valid() - Validate a filter table endpoint bitmap
  * @ipa:       IPA pointer