wimax/i2400m: implement RX reorder support

Allow the device to give the driver RX data with reorder information.

When that is done, the device will indicate the driver if a packet has
to be held in a (sorted) queue. It will also tell the driver when held
packets have to be released to the OS.

This is done to improve the WiMAX-protocol level retransmission
support when missing frames are detected.

The code docs provide details about the implementation.

In general, this just hooks into the RX path in rx.c; if a packet with
the reorder bit in the RX header is detected, the reorder information
in the header is extracted and one of the four main reorder operations
are executed. In one case (queue) no packet will be delivered to the
networking stack, just queued, whereas in the others (reset, update_ws
and queue_update_ws), queued packet might be delivered depending on
the window start for the specific queue.

The modifications to files other than rx.c are:

- control.c: during device initialization, enable reordering support
  if the rx_reorder_disabled module parameter is not enabled

- driver.c: expose a rx_reorder_disable module parameter and call
  i2400m_rx_setup/release() to initialize/shutdown RX reorder
  support.

- i2400m.h: introduce members in 'struct i2400m' needed for
  implementing reorder support.

- linux/i2400m.h: introduce TLVs, commands and constant definitions
  related to RX reorder

Last but not least, the rx reorder code includes an small circular log
where the last N reorder operations are recorded to be displayed in
case of inconsistency. Otherwise diagnosing issues would be almost
impossible.

Signed-off-by: Inaky Perez-Gonzalez <inaky@linux.intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 14 insertions, 0 deletions

diff --git a/drivers/net/wimax/i2400m/control.c b/drivers/net/wimax/i2400m/control.c
index 4073c3e93bd4..b3cadb626fe0 100644
--- a/drivers/net/wimax/i2400m/control.c
+++ b/drivers/net/wimax/i2400m/control.c
@@ -1312,10 +1312,12 @@ int i2400m_dev_initialize(struct i2400m *i2400m)
         struct i2400m_tlv_config_idle_parameters idle_params;
         struct i2400m_tlv_config_idle_timeout idle_timeout;
         struct i2400m_tlv_config_d2h_data_format df;
+        struct i2400m_tlv_config_dl_host_reorder dlhr;
         const struct i2400m_tlv_hdr *args[9];
         unsigned argc = 0;
 
         d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
+        /* Disable idle mode? (enabled by default) */
         if (i2400m_idle_mode_disabled) {
                 if (i2400m_le_v1_3(i2400m)) {
                         idle_params.hdr.type =
@@ -1335,12 +1337,24 @@ int i2400m_dev_initialize(struct i2400m *i2400m)
                 }
         }
         if (i2400m_ge_v1_4(i2400m)) {
+                /* Enable extended RX data format? */
                 df.hdr.type =
                         cpu_to_le16(I2400M_TLV_CONFIG_D2H_DATA_FORMAT);
                 df.hdr.length = cpu_to_le16(
                         sizeof(df) - sizeof(df.hdr));
                 df.format = 1;
                 args[argc++] = &df.hdr;
+
+                /* Enable RX data reordering?
+                 * (switch flipped in rx.c:i2400m_rx_setup() after fw upload) */
+                if (i2400m->rx_reorder) {
+                        dlhr.hdr.type =
+                                cpu_to_le16(I2400M_TLV_CONFIG_DL_HOST_REORDER);
+                        dlhr.hdr.length = cpu_to_le16(
+                                sizeof(dlhr) - sizeof(dlhr.hdr));
+                        dlhr.reorder = 1;
+                        args[argc++] = &dlhr.hdr;
+                }
         }
         result = i2400m_set_init_config(i2400m, args, argc);
         if (result < 0)