4e5b6d006b
When the i2400m receives data and the device indicates there has to be reordering, we keep an sliding window implementation to sort the packets before sending them to the network stack. One of the "operations" that the device indicates is "queue a packet and update the window start". When the queue is empty, this is equivalent to "deliver the packet and update the window start". That case was optimized in i2400m_roq_queue_update_ws() so that we would not pointlessly queue and dequeue a packet. However, when the optimization was active, it wasn't updating the window start. That caused the reorder management code to get confused later on with what seemed to be wrong reorder requests from the device. Thus the fix implemented is to do the right thing and update the window start in both cases, when the queue is empty (and the optimization is done) and when not. Signed-off-by: Inaky Perez-Gonzalez <inaky@linux.intel.com>
1260 lines
38 KiB
C
1260 lines
38 KiB
C
/*
|
|
* Intel Wireless WiMAX Connection 2400m
|
|
* Handle incoming traffic and deliver it to the control or data planes
|
|
*
|
|
*
|
|
* Copyright (C) 2007-2008 Intel Corporation. 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 Intel Corporation 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 BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE 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.
|
|
*
|
|
*
|
|
* Intel Corporation <linux-wimax@intel.com>
|
|
* Yanir Lubetkin <yanirx.lubetkin@intel.com>
|
|
* - Initial implementation
|
|
* Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
|
|
* - Use skb_clone(), break up processing in chunks
|
|
* - Split transport/device specific
|
|
* - Make buffer size dynamic to exert less memory pressure
|
|
* - RX reorder support
|
|
*
|
|
* This handles the RX path.
|
|
*
|
|
* We receive an RX message from the bus-specific driver, which
|
|
* contains one or more payloads that have potentially different
|
|
* destinataries (data or control paths).
|
|
*
|
|
* So we just take that payload from the transport specific code in
|
|
* the form of an skb, break it up in chunks (a cloned skb each in the
|
|
* case of network packets) and pass it to netdev or to the
|
|
* command/ack handler (and from there to the WiMAX stack).
|
|
*
|
|
* PROTOCOL FORMAT
|
|
*
|
|
* The format of the buffer is:
|
|
*
|
|
* HEADER (struct i2400m_msg_hdr)
|
|
* PAYLOAD DESCRIPTOR 0 (struct i2400m_pld)
|
|
* PAYLOAD DESCRIPTOR 1
|
|
* ...
|
|
* PAYLOAD DESCRIPTOR N
|
|
* PAYLOAD 0 (raw bytes)
|
|
* PAYLOAD 1
|
|
* ...
|
|
* PAYLOAD N
|
|
*
|
|
* See tx.c for a deeper description on alignment requirements and
|
|
* other fun facts of it.
|
|
*
|
|
* DATA PACKETS
|
|
*
|
|
* In firmwares <= v1.3, data packets have no header for RX, but they
|
|
* do for TX (currently unused).
|
|
*
|
|
* In firmware >= 1.4, RX packets have an extended header (16
|
|
* bytes). This header conveys information for management of host
|
|
* reordering of packets (the device offloads storage of the packets
|
|
* for reordering to the host). Read below for more information.
|
|
*
|
|
* The header is used as dummy space to emulate an ethernet header and
|
|
* thus be able to act as an ethernet device without having to reallocate.
|
|
*
|
|
* DATA RX REORDERING
|
|
*
|
|
* Starting in firmware v1.4, the device can deliver packets for
|
|
* delivery with special reordering information; this allows it to
|
|
* more effectively do packet management when some frames were lost in
|
|
* the radio traffic.
|
|
*
|
|
* Thus, for RX packets that come out of order, the device gives the
|
|
* driver enough information to queue them properly and then at some
|
|
* point, the signal to deliver the whole (or part) of the queued
|
|
* packets to the networking stack. There are 16 such queues.
|
|
*
|
|
* This only happens when a packet comes in with the "need reorder"
|
|
* flag set in the RX header. When such bit is set, the following
|
|
* operations might be indicated:
|
|
*
|
|
* - reset queue: send all queued packets to the OS
|
|
*
|
|
* - queue: queue a packet
|
|
*
|
|
* - update ws: update the queue's window start and deliver queued
|
|
* packets that meet the criteria
|
|
*
|
|
* - queue & update ws: queue a packet, update the window start and
|
|
* deliver queued packets that meet the criteria
|
|
*
|
|
* (delivery criteria: the packet's [normalized] sequence number is
|
|
* lower than the new [normalized] window start).
|
|
*
|
|
* See the i2400m_roq_*() functions for details.
|
|
*
|
|
* ROADMAP
|
|
*
|
|
* i2400m_rx
|
|
* i2400m_rx_msg_hdr_check
|
|
* i2400m_rx_pl_descr_check
|
|
* i2400m_rx_payload
|
|
* i2400m_net_rx
|
|
* i2400m_rx_edata
|
|
* i2400m_net_erx
|
|
* i2400m_roq_reset
|
|
* i2400m_net_erx
|
|
* i2400m_roq_queue
|
|
* __i2400m_roq_queue
|
|
* i2400m_roq_update_ws
|
|
* __i2400m_roq_update_ws
|
|
* i2400m_net_erx
|
|
* i2400m_roq_queue_update_ws
|
|
* __i2400m_roq_queue
|
|
* __i2400m_roq_update_ws
|
|
* i2400m_net_erx
|
|
* i2400m_rx_ctl
|
|
* i2400m_msg_size_check
|
|
* i2400m_report_hook_work [in a workqueue]
|
|
* i2400m_report_hook
|
|
* wimax_msg_to_user
|
|
* i2400m_rx_ctl_ack
|
|
* wimax_msg_to_user_alloc
|
|
* i2400m_rx_trace
|
|
* i2400m_msg_size_check
|
|
* wimax_msg
|
|
*/
|
|
#include <linux/kernel.h>
|
|
#include <linux/if_arp.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/workqueue.h>
|
|
#include "i2400m.h"
|
|
|
|
|
|
#define D_SUBMODULE rx
|
|
#include "debug-levels.h"
|
|
|
|
struct i2400m_report_hook_args {
|
|
struct sk_buff *skb_rx;
|
|
const struct i2400m_l3l4_hdr *l3l4_hdr;
|
|
size_t size;
|
|
};
|
|
|
|
|
|
/*
|
|
* Execute i2400m_report_hook in a workqueue
|
|
*
|
|
* Unpacks arguments from the deferred call, executes it and then
|
|
* drops the references.
|
|
*
|
|
* Obvious NOTE: References are needed because we are a separate
|
|
* thread; otherwise the buffer changes under us because it is
|
|
* released by the original caller.
|
|
*/
|
|
static
|
|
void i2400m_report_hook_work(struct work_struct *ws)
|
|
{
|
|
struct i2400m_work *iw =
|
|
container_of(ws, struct i2400m_work, ws);
|
|
struct i2400m_report_hook_args *args = (void *) iw->pl;
|
|
i2400m_report_hook(iw->i2400m, args->l3l4_hdr, args->size);
|
|
kfree_skb(args->skb_rx);
|
|
i2400m_put(iw->i2400m);
|
|
kfree(iw);
|
|
}
|
|
|
|
|
|
/*
|
|
* Process an ack to a command
|
|
*
|
|
* @i2400m: device descriptor
|
|
* @payload: pointer to message
|
|
* @size: size of the message
|
|
*
|
|
* Pass the acknodledgment (in an skb) to the thread that is waiting
|
|
* for it in i2400m->msg_completion.
|
|
*
|
|
* We need to coordinate properly with the thread waiting for the
|
|
* ack. Check if it is waiting or if it is gone. We loose the spinlock
|
|
* to avoid allocating on atomic contexts (yeah, could use GFP_ATOMIC,
|
|
* but this is not so speed critical).
|
|
*/
|
|
static
|
|
void i2400m_rx_ctl_ack(struct i2400m *i2400m,
|
|
const void *payload, size_t size)
|
|
{
|
|
struct device *dev = i2400m_dev(i2400m);
|
|
struct wimax_dev *wimax_dev = &i2400m->wimax_dev;
|
|
unsigned long flags;
|
|
struct sk_buff *ack_skb;
|
|
|
|
/* Anyone waiting for an answer? */
|
|
spin_lock_irqsave(&i2400m->rx_lock, flags);
|
|
if (i2400m->ack_skb != ERR_PTR(-EINPROGRESS)) {
|
|
dev_err(dev, "Huh? reply to command with no waiters\n");
|
|
goto error_no_waiter;
|
|
}
|
|
spin_unlock_irqrestore(&i2400m->rx_lock, flags);
|
|
|
|
ack_skb = wimax_msg_alloc(wimax_dev, NULL, payload, size, GFP_KERNEL);
|
|
|
|
/* Check waiter didn't time out waiting for the answer... */
|
|
spin_lock_irqsave(&i2400m->rx_lock, flags);
|
|
if (i2400m->ack_skb != ERR_PTR(-EINPROGRESS)) {
|
|
d_printf(1, dev, "Huh? waiter for command reply cancelled\n");
|
|
goto error_waiter_cancelled;
|
|
}
|
|
if (ack_skb == NULL) {
|
|
dev_err(dev, "CMD/GET/SET ack: cannot allocate SKB\n");
|
|
i2400m->ack_skb = ERR_PTR(-ENOMEM);
|
|
} else
|
|
i2400m->ack_skb = ack_skb;
|
|
spin_unlock_irqrestore(&i2400m->rx_lock, flags);
|
|
complete(&i2400m->msg_completion);
|
|
return;
|
|
|
|
error_waiter_cancelled:
|
|
kfree_skb(ack_skb);
|
|
error_no_waiter:
|
|
spin_unlock_irqrestore(&i2400m->rx_lock, flags);
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* Receive and process a control payload
|
|
*
|
|
* @i2400m: device descriptor
|
|
* @skb_rx: skb that contains the payload (for reference counting)
|
|
* @payload: pointer to message
|
|
* @size: size of the message
|
|
*
|
|
* There are two types of control RX messages: reports (asynchronous,
|
|
* like your every day interrupts) and 'acks' (reponses to a command,
|
|
* get or set request).
|
|
*
|
|
* If it is a report, we run hooks on it (to extract information for
|
|
* things we need to do in the driver) and then pass it over to the
|
|
* WiMAX stack to send it to user space.
|
|
*
|
|
* NOTE: report processing is done in a workqueue specific to the
|
|
* generic driver, to avoid deadlocks in the system.
|
|
*
|
|
* If it is not a report, it is an ack to a previously executed
|
|
* command, set or get, so wake up whoever is waiting for it from
|
|
* i2400m_msg_to_dev(). i2400m_rx_ctl_ack() takes care of that.
|
|
*
|
|
* Note that the sizes we pass to other functions from here are the
|
|
* sizes of the _l3l4_hdr + payload, not full buffer sizes, as we have
|
|
* verified in _msg_size_check() that they are congruent.
|
|
*
|
|
* For reports: We can't clone the original skb where the data is
|
|
* because we need to send this up via netlink; netlink has to add
|
|
* headers and we can't overwrite what's preceeding the payload...as
|
|
* it is another message. So we just dup them.
|
|
*/
|
|
static
|
|
void i2400m_rx_ctl(struct i2400m *i2400m, struct sk_buff *skb_rx,
|
|
const void *payload, size_t size)
|
|
{
|
|
int result;
|
|
struct device *dev = i2400m_dev(i2400m);
|
|
const struct i2400m_l3l4_hdr *l3l4_hdr = payload;
|
|
unsigned msg_type;
|
|
|
|
result = i2400m_msg_size_check(i2400m, l3l4_hdr, size);
|
|
if (result < 0) {
|
|
dev_err(dev, "HW BUG? device sent a bad message: %d\n",
|
|
result);
|
|
goto error_check;
|
|
}
|
|
msg_type = le16_to_cpu(l3l4_hdr->type);
|
|
d_printf(1, dev, "%s 0x%04x: %zu bytes\n",
|
|
msg_type & I2400M_MT_REPORT_MASK ? "REPORT" : "CMD/SET/GET",
|
|
msg_type, size);
|
|
d_dump(2, dev, l3l4_hdr, size);
|
|
if (msg_type & I2400M_MT_REPORT_MASK) {
|
|
/* These hooks have to be ran serialized; as well, the
|
|
* handling might force the execution of commands, and
|
|
* that might cause reentrancy issues with
|
|
* bus-specific subdrivers and workqueues. So we run
|
|
* it in a separate workqueue. */
|
|
struct i2400m_report_hook_args args = {
|
|
.skb_rx = skb_rx,
|
|
.l3l4_hdr = l3l4_hdr,
|
|
.size = size
|
|
};
|
|
if (unlikely(i2400m->ready == 0)) /* only send if up */
|
|
return;
|
|
skb_get(skb_rx);
|
|
i2400m_queue_work(i2400m, i2400m_report_hook_work,
|
|
GFP_KERNEL, &args, sizeof(args));
|
|
result = wimax_msg(&i2400m->wimax_dev, NULL, l3l4_hdr, size,
|
|
GFP_KERNEL);
|
|
if (result < 0)
|
|
dev_err(dev, "error sending report to userspace: %d\n",
|
|
result);
|
|
} else /* an ack to a CMD, GET or SET */
|
|
i2400m_rx_ctl_ack(i2400m, payload, size);
|
|
error_check:
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* Receive and send up a trace
|
|
*
|
|
* @i2400m: device descriptor
|
|
* @skb_rx: skb that contains the trace (for reference counting)
|
|
* @payload: pointer to trace message inside the skb
|
|
* @size: size of the message
|
|
*
|
|
* THe i2400m might produce trace information (diagnostics) and we
|
|
* send them through a different kernel-to-user pipe (to avoid
|
|
* clogging it).
|
|
*
|
|
* As in i2400m_rx_ctl(), we can't clone the original skb where the
|
|
* data is because we need to send this up via netlink; netlink has to
|
|
* add headers and we can't overwrite what's preceeding the
|
|
* payload...as it is another message. So we just dup them.
|
|
*/
|
|
static
|
|
void i2400m_rx_trace(struct i2400m *i2400m,
|
|
const void *payload, size_t size)
|
|
{
|
|
int result;
|
|
struct device *dev = i2400m_dev(i2400m);
|
|
struct wimax_dev *wimax_dev = &i2400m->wimax_dev;
|
|
const struct i2400m_l3l4_hdr *l3l4_hdr = payload;
|
|
unsigned msg_type;
|
|
|
|
result = i2400m_msg_size_check(i2400m, l3l4_hdr, size);
|
|
if (result < 0) {
|
|
dev_err(dev, "HW BUG? device sent a bad trace message: %d\n",
|
|
result);
|
|
goto error_check;
|
|
}
|
|
msg_type = le16_to_cpu(l3l4_hdr->type);
|
|
d_printf(1, dev, "Trace %s 0x%04x: %zu bytes\n",
|
|
msg_type & I2400M_MT_REPORT_MASK ? "REPORT" : "CMD/SET/GET",
|
|
msg_type, size);
|
|
d_dump(2, dev, l3l4_hdr, size);
|
|
if (unlikely(i2400m->ready == 0)) /* only send if up */
|
|
return;
|
|
result = wimax_msg(wimax_dev, "trace", l3l4_hdr, size, GFP_KERNEL);
|
|
if (result < 0)
|
|
dev_err(dev, "error sending trace to userspace: %d\n",
|
|
result);
|
|
error_check:
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* Reorder queue data stored on skb->cb while the skb is queued in the
|
|
* reorder queues.
|
|
*/
|
|
struct i2400m_roq_data {
|
|
unsigned sn; /* Serial number for the skb */
|
|
enum i2400m_cs cs; /* packet type for the skb */
|
|
};
|
|
|
|
|
|
/*
|
|
* ReOrder Queue
|
|
*
|
|
* @ws: Window Start; sequence number where the current window start
|
|
* is for this queue
|
|
* @queue: the skb queue itself
|
|
* @log: circular ring buffer used to log information about the
|
|
* reorder process in this queue that can be displayed in case of
|
|
* error to help diagnose it.
|
|
*
|
|
* This is the head for a list of skbs. In the skb->cb member of the
|
|
* skb when queued here contains a 'struct i2400m_roq_data' were we
|
|
* store the sequence number (sn) and the cs (packet type) coming from
|
|
* the RX payload header from the device.
|
|
*/
|
|
struct i2400m_roq
|
|
{
|
|
unsigned ws;
|
|
struct sk_buff_head queue;
|
|
struct i2400m_roq_log *log;
|
|
};
|
|
|
|
|
|
static
|
|
void __i2400m_roq_init(struct i2400m_roq *roq)
|
|
{
|
|
roq->ws = 0;
|
|
skb_queue_head_init(&roq->queue);
|
|
}
|
|
|
|
|
|
static
|
|
unsigned __i2400m_roq_index(struct i2400m *i2400m, struct i2400m_roq *roq)
|
|
{
|
|
return ((unsigned long) roq - (unsigned long) i2400m->rx_roq)
|
|
/ sizeof(*roq);
|
|
}
|
|
|
|
|
|
/*
|
|
* Normalize a sequence number based on the queue's window start
|
|
*
|
|
* nsn = (sn - ws) % 2048
|
|
*
|
|
* Note that if @sn < @roq->ws, we still need a positive number; %'s
|
|
* sign is implementation specific, so we normalize it by adding 2048
|
|
* to bring it to be positive.
|
|
*/
|
|
static
|
|
unsigned __i2400m_roq_nsn(struct i2400m_roq *roq, unsigned sn)
|
|
{
|
|
int r;
|
|
r = ((int) sn - (int) roq->ws) % 2048;
|
|
if (r < 0)
|
|
r += 2048;
|
|
return r;
|
|
}
|
|
|
|
|
|
/*
|
|
* Circular buffer to keep the last N reorder operations
|
|
*
|
|
* In case something fails, dumb then to try to come up with what
|
|
* happened.
|
|
*/
|
|
enum {
|
|
I2400M_ROQ_LOG_LENGTH = 32,
|
|
};
|
|
|
|
struct i2400m_roq_log {
|
|
struct i2400m_roq_log_entry {
|
|
enum i2400m_ro_type type;
|
|
unsigned ws, count, sn, nsn, new_ws;
|
|
} entry[I2400M_ROQ_LOG_LENGTH];
|
|
unsigned in, out;
|
|
};
|
|
|
|
|
|
/* Print a log entry */
|
|
static
|
|
void i2400m_roq_log_entry_print(struct i2400m *i2400m, unsigned index,
|
|
unsigned e_index,
|
|
struct i2400m_roq_log_entry *e)
|
|
{
|
|
struct device *dev = i2400m_dev(i2400m);
|
|
|
|
switch(e->type) {
|
|
case I2400M_RO_TYPE_RESET:
|
|
dev_err(dev, "q#%d reset ws %u cnt %u sn %u/%u"
|
|
" - new nws %u\n",
|
|
index, e->ws, e->count, e->sn, e->nsn, e->new_ws);
|
|
break;
|
|
case I2400M_RO_TYPE_PACKET:
|
|
dev_err(dev, "q#%d queue ws %u cnt %u sn %u/%u\n",
|
|
index, e->ws, e->count, e->sn, e->nsn);
|
|
break;
|
|
case I2400M_RO_TYPE_WS:
|
|
dev_err(dev, "q#%d update_ws ws %u cnt %u sn %u/%u"
|
|
" - new nws %u\n",
|
|
index, e->ws, e->count, e->sn, e->nsn, e->new_ws);
|
|
break;
|
|
case I2400M_RO_TYPE_PACKET_WS:
|
|
dev_err(dev, "q#%d queue_update_ws ws %u cnt %u sn %u/%u"
|
|
" - new nws %u\n",
|
|
index, e->ws, e->count, e->sn, e->nsn, e->new_ws);
|
|
break;
|
|
default:
|
|
dev_err(dev, "q#%d BUG? entry %u - unknown type %u\n",
|
|
index, e_index, e->type);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
static
|
|
void i2400m_roq_log_add(struct i2400m *i2400m,
|
|
struct i2400m_roq *roq, enum i2400m_ro_type type,
|
|
unsigned ws, unsigned count, unsigned sn,
|
|
unsigned nsn, unsigned new_ws)
|
|
{
|
|
struct i2400m_roq_log_entry *e;
|
|
unsigned cnt_idx;
|
|
int index = __i2400m_roq_index(i2400m, roq);
|
|
|
|
/* if we run out of space, we eat from the end */
|
|
if (roq->log->in - roq->log->out == I2400M_ROQ_LOG_LENGTH)
|
|
roq->log->out++;
|
|
cnt_idx = roq->log->in++ % I2400M_ROQ_LOG_LENGTH;
|
|
e = &roq->log->entry[cnt_idx];
|
|
|
|
e->type = type;
|
|
e->ws = ws;
|
|
e->count = count;
|
|
e->sn = sn;
|
|
e->nsn = nsn;
|
|
e->new_ws = new_ws;
|
|
|
|
if (d_test(1))
|
|
i2400m_roq_log_entry_print(i2400m, index, cnt_idx, e);
|
|
}
|
|
|
|
|
|
/* Dump all the entries in the FIFO and reinitialize it */
|
|
static
|
|
void i2400m_roq_log_dump(struct i2400m *i2400m, struct i2400m_roq *roq)
|
|
{
|
|
unsigned cnt, cnt_idx;
|
|
struct i2400m_roq_log_entry *e;
|
|
int index = __i2400m_roq_index(i2400m, roq);
|
|
|
|
BUG_ON(roq->log->out > roq->log->in);
|
|
for (cnt = roq->log->out; cnt < roq->log->in; cnt++) {
|
|
cnt_idx = cnt % I2400M_ROQ_LOG_LENGTH;
|
|
e = &roq->log->entry[cnt_idx];
|
|
i2400m_roq_log_entry_print(i2400m, index, cnt_idx, e);
|
|
memset(e, 0, sizeof(*e));
|
|
}
|
|
roq->log->in = roq->log->out = 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Backbone for the queuing of an skb (by normalized sequence number)
|
|
*
|
|
* @i2400m: device descriptor
|
|
* @roq: reorder queue where to add
|
|
* @skb: the skb to add
|
|
* @sn: the sequence number of the skb
|
|
* @nsn: the normalized sequence number of the skb (pre-computed by the
|
|
* caller from the @sn and @roq->ws).
|
|
*
|
|
* We try first a couple of quick cases:
|
|
*
|
|
* - the queue is empty
|
|
* - the skb would be appended to the queue
|
|
*
|
|
* These will be the most common operations.
|
|
*
|
|
* If these fail, then we have to do a sorted insertion in the queue,
|
|
* which is the slowest path.
|
|
*
|
|
* We don't have to acquire a reference count as we are going to own it.
|
|
*/
|
|
static
|
|
void __i2400m_roq_queue(struct i2400m *i2400m, struct i2400m_roq *roq,
|
|
struct sk_buff *skb, unsigned sn, unsigned nsn)
|
|
{
|
|
struct device *dev = i2400m_dev(i2400m);
|
|
struct sk_buff *skb_itr;
|
|
struct i2400m_roq_data *roq_data_itr, *roq_data;
|
|
unsigned nsn_itr;
|
|
|
|
d_fnstart(4, dev, "(i2400m %p roq %p skb %p sn %u nsn %u)\n",
|
|
i2400m, roq, skb, sn, nsn);
|
|
|
|
roq_data = (struct i2400m_roq_data *) &skb->cb;
|
|
BUILD_BUG_ON(sizeof(*roq_data) > sizeof(skb->cb));
|
|
roq_data->sn = sn;
|
|
d_printf(3, dev, "ERX: roq %p [ws %u] nsn %d sn %u\n",
|
|
roq, roq->ws, nsn, roq_data->sn);
|
|
|
|
/* Queues will be empty on not-so-bad environments, so try
|
|
* that first */
|
|
if (skb_queue_empty(&roq->queue)) {
|
|
d_printf(2, dev, "ERX: roq %p - first one\n", roq);
|
|
__skb_queue_head(&roq->queue, skb);
|
|
goto out;
|
|
}
|
|
/* Now try append, as most of the operations will be that */
|
|
skb_itr = skb_peek_tail(&roq->queue);
|
|
roq_data_itr = (struct i2400m_roq_data *) &skb_itr->cb;
|
|
nsn_itr = __i2400m_roq_nsn(roq, roq_data_itr->sn);
|
|
/* NSN bounds assumed correct (checked when it was queued) */
|
|
if (nsn >= nsn_itr) {
|
|
d_printf(2, dev, "ERX: roq %p - appended after %p (nsn %d sn %u)\n",
|
|
roq, skb_itr, nsn_itr, roq_data_itr->sn);
|
|
__skb_queue_tail(&roq->queue, skb);
|
|
goto out;
|
|
}
|
|
/* None of the fast paths option worked. Iterate to find the
|
|
* right spot where to insert the packet; we know the queue is
|
|
* not empty, so we are not the first ones; we also know we
|
|
* are not going to be the last ones. The list is sorted, so
|
|
* we have to insert before the the first guy with an nsn_itr
|
|
* greater that our nsn. */
|
|
skb_queue_walk(&roq->queue, skb_itr) {
|
|
roq_data_itr = (struct i2400m_roq_data *) &skb_itr->cb;
|
|
nsn_itr = __i2400m_roq_nsn(roq, roq_data_itr->sn);
|
|
/* NSN bounds assumed correct (checked when it was queued) */
|
|
if (nsn_itr > nsn) {
|
|
d_printf(2, dev, "ERX: roq %p - queued before %p "
|
|
"(nsn %d sn %u)\n", roq, skb_itr, nsn_itr,
|
|
roq_data_itr->sn);
|
|
__skb_queue_before(&roq->queue, skb_itr, skb);
|
|
goto out;
|
|
}
|
|
}
|
|
/* If we get here, that is VERY bad -- print info to help
|
|
* diagnose and crash it */
|
|
dev_err(dev, "SW BUG? failed to insert packet\n");
|
|
dev_err(dev, "ERX: roq %p [ws %u] skb %p nsn %d sn %u\n",
|
|
roq, roq->ws, skb, nsn, roq_data->sn);
|
|
skb_queue_walk(&roq->queue, skb_itr) {
|
|
roq_data_itr = (struct i2400m_roq_data *) &skb_itr->cb;
|
|
nsn_itr = __i2400m_roq_nsn(roq, roq_data_itr->sn);
|
|
/* NSN bounds assumed correct (checked when it was queued) */
|
|
dev_err(dev, "ERX: roq %p skb_itr %p nsn %d sn %u\n",
|
|
roq, skb_itr, nsn_itr, roq_data_itr->sn);
|
|
}
|
|
BUG();
|
|
out:
|
|
d_fnend(4, dev, "(i2400m %p roq %p skb %p sn %u nsn %d) = void\n",
|
|
i2400m, roq, skb, sn, nsn);
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* Backbone for the update window start operation
|
|
*
|
|
* @i2400m: device descriptor
|
|
* @roq: Reorder queue
|
|
* @sn: New sequence number
|
|
*
|
|
* Updates the window start of a queue; when doing so, it must deliver
|
|
* to the networking stack all the queued skb's whose normalized
|
|
* sequence number is lower than the new normalized window start.
|
|
*/
|
|
static
|
|
unsigned __i2400m_roq_update_ws(struct i2400m *i2400m, struct i2400m_roq *roq,
|
|
unsigned sn)
|
|
{
|
|
struct device *dev = i2400m_dev(i2400m);
|
|
struct sk_buff *skb_itr, *tmp_itr;
|
|
struct i2400m_roq_data *roq_data_itr;
|
|
unsigned new_nws, nsn_itr;
|
|
|
|
new_nws = __i2400m_roq_nsn(roq, sn);
|
|
if (unlikely(new_nws >= 1024) && d_test(1)) {
|
|
dev_err(dev, "SW BUG? __update_ws new_nws %u (sn %u ws %u)\n",
|
|
new_nws, sn, roq->ws);
|
|
WARN_ON(1);
|
|
i2400m_roq_log_dump(i2400m, roq);
|
|
}
|
|
skb_queue_walk_safe(&roq->queue, skb_itr, tmp_itr) {
|
|
roq_data_itr = (struct i2400m_roq_data *) &skb_itr->cb;
|
|
nsn_itr = __i2400m_roq_nsn(roq, roq_data_itr->sn);
|
|
/* NSN bounds assumed correct (checked when it was queued) */
|
|
if (nsn_itr < new_nws) {
|
|
d_printf(2, dev, "ERX: roq %p - release skb %p "
|
|
"(nsn %u/%u new nws %u)\n",
|
|
roq, skb_itr, nsn_itr, roq_data_itr->sn,
|
|
new_nws);
|
|
__skb_unlink(skb_itr, &roq->queue);
|
|
i2400m_net_erx(i2400m, skb_itr, roq_data_itr->cs);
|
|
}
|
|
else
|
|
break; /* rest of packets all nsn_itr > nws */
|
|
}
|
|
roq->ws = sn;
|
|
return new_nws;
|
|
}
|
|
|
|
|
|
/*
|
|
* Reset a queue
|
|
*
|
|
* @i2400m: device descriptor
|
|
* @cin: Queue Index
|
|
*
|
|
* Deliver all the packets and reset the window-start to zero. Name is
|
|
* kind of misleading.
|
|
*/
|
|
static
|
|
void i2400m_roq_reset(struct i2400m *i2400m, struct i2400m_roq *roq)
|
|
{
|
|
struct device *dev = i2400m_dev(i2400m);
|
|
struct sk_buff *skb_itr, *tmp_itr;
|
|
struct i2400m_roq_data *roq_data_itr;
|
|
|
|
d_fnstart(2, dev, "(i2400m %p roq %p)\n", i2400m, roq);
|
|
i2400m_roq_log_add(i2400m, roq, I2400M_RO_TYPE_RESET,
|
|
roq->ws, skb_queue_len(&roq->queue),
|
|
~0, ~0, 0);
|
|
skb_queue_walk_safe(&roq->queue, skb_itr, tmp_itr) {
|
|
roq_data_itr = (struct i2400m_roq_data *) &skb_itr->cb;
|
|
d_printf(2, dev, "ERX: roq %p - release skb %p (sn %u)\n",
|
|
roq, skb_itr, roq_data_itr->sn);
|
|
__skb_unlink(skb_itr, &roq->queue);
|
|
i2400m_net_erx(i2400m, skb_itr, roq_data_itr->cs);
|
|
}
|
|
roq->ws = 0;
|
|
d_fnend(2, dev, "(i2400m %p roq %p) = void\n", i2400m, roq);
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* Queue a packet
|
|
*
|
|
* @i2400m: device descriptor
|
|
* @cin: Queue Index
|
|
* @skb: containing the packet data
|
|
* @fbn: First block number of the packet in @skb
|
|
* @lbn: Last block number of the packet in @skb
|
|
*
|
|
* The hardware is asking the driver to queue a packet for later
|
|
* delivery to the networking stack.
|
|
*/
|
|
static
|
|
void i2400m_roq_queue(struct i2400m *i2400m, struct i2400m_roq *roq,
|
|
struct sk_buff * skb, unsigned lbn)
|
|
{
|
|
struct device *dev = i2400m_dev(i2400m);
|
|
unsigned nsn, len;
|
|
|
|
d_fnstart(2, dev, "(i2400m %p roq %p skb %p lbn %u) = void\n",
|
|
i2400m, roq, skb, lbn);
|
|
len = skb_queue_len(&roq->queue);
|
|
nsn = __i2400m_roq_nsn(roq, lbn);
|
|
if (unlikely(nsn >= 1024)) {
|
|
dev_err(dev, "SW BUG? queue nsn %d (lbn %u ws %u)\n",
|
|
nsn, lbn, roq->ws);
|
|
i2400m_roq_log_dump(i2400m, roq);
|
|
i2400m->bus_reset(i2400m, I2400M_RT_WARM);
|
|
} else {
|
|
__i2400m_roq_queue(i2400m, roq, skb, lbn, nsn);
|
|
i2400m_roq_log_add(i2400m, roq, I2400M_RO_TYPE_PACKET,
|
|
roq->ws, len, lbn, nsn, ~0);
|
|
}
|
|
d_fnend(2, dev, "(i2400m %p roq %p skb %p lbn %u) = void\n",
|
|
i2400m, roq, skb, lbn);
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* Update the window start in a reorder queue and deliver all skbs
|
|
* with a lower window start
|
|
*
|
|
* @i2400m: device descriptor
|
|
* @roq: Reorder queue
|
|
* @sn: New sequence number
|
|
*/
|
|
static
|
|
void i2400m_roq_update_ws(struct i2400m *i2400m, struct i2400m_roq *roq,
|
|
unsigned sn)
|
|
{
|
|
struct device *dev = i2400m_dev(i2400m);
|
|
unsigned old_ws, nsn, len;
|
|
|
|
d_fnstart(2, dev, "(i2400m %p roq %p sn %u)\n", i2400m, roq, sn);
|
|
old_ws = roq->ws;
|
|
len = skb_queue_len(&roq->queue);
|
|
nsn = __i2400m_roq_update_ws(i2400m, roq, sn);
|
|
i2400m_roq_log_add(i2400m, roq, I2400M_RO_TYPE_WS,
|
|
old_ws, len, sn, nsn, roq->ws);
|
|
d_fnstart(2, dev, "(i2400m %p roq %p sn %u) = void\n", i2400m, roq, sn);
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* Queue a packet and update the window start
|
|
*
|
|
* @i2400m: device descriptor
|
|
* @cin: Queue Index
|
|
* @skb: containing the packet data
|
|
* @fbn: First block number of the packet in @skb
|
|
* @sn: Last block number of the packet in @skb
|
|
*
|
|
* Note that unlike i2400m_roq_update_ws(), which sets the new window
|
|
* start to @sn, in here we'll set it to @sn + 1.
|
|
*/
|
|
static
|
|
void i2400m_roq_queue_update_ws(struct i2400m *i2400m, struct i2400m_roq *roq,
|
|
struct sk_buff * skb, unsigned sn)
|
|
{
|
|
struct device *dev = i2400m_dev(i2400m);
|
|
unsigned nsn, old_ws, len;
|
|
|
|
d_fnstart(2, dev, "(i2400m %p roq %p skb %p sn %u)\n",
|
|
i2400m, roq, skb, sn);
|
|
len = skb_queue_len(&roq->queue);
|
|
nsn = __i2400m_roq_nsn(roq, sn);
|
|
old_ws = roq->ws;
|
|
if (unlikely(nsn >= 1024)) {
|
|
dev_err(dev, "SW BUG? queue_update_ws nsn %u (sn %u ws %u)\n",
|
|
nsn, sn, roq->ws);
|
|
i2400m_roq_log_dump(i2400m, roq);
|
|
i2400m->bus_reset(i2400m, I2400M_RT_WARM);
|
|
} else {
|
|
/* if the queue is empty, don't bother as we'd queue
|
|
* it and inmediately unqueue it -- just deliver it */
|
|
if (len == 0) {
|
|
struct i2400m_roq_data *roq_data;
|
|
roq_data = (struct i2400m_roq_data *) &skb->cb;
|
|
i2400m_net_erx(i2400m, skb, roq_data->cs);
|
|
}
|
|
else
|
|
__i2400m_roq_queue(i2400m, roq, skb, sn, nsn);
|
|
__i2400m_roq_update_ws(i2400m, roq, sn + 1);
|
|
i2400m_roq_log_add(i2400m, roq, I2400M_RO_TYPE_PACKET_WS,
|
|
old_ws, len, sn, nsn, roq->ws);
|
|
}
|
|
d_fnend(2, dev, "(i2400m %p roq %p skb %p sn %u) = void\n",
|
|
i2400m, roq, skb, sn);
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* Receive and send up an extended data packet
|
|
*
|
|
* @i2400m: device descriptor
|
|
* @skb_rx: skb that contains the extended data packet
|
|
* @single_last: 1 if the payload is the only one or the last one of
|
|
* the skb.
|
|
* @payload: pointer to the packet's data inside the skb
|
|
* @size: size of the payload
|
|
*
|
|
* Starting in v1.4 of the i2400m's firmware, the device can send data
|
|
* packets to the host in an extended format that; this incudes a 16
|
|
* byte header (struct i2400m_pl_edata_hdr). Using this header's space
|
|
* we can fake ethernet headers for ethernet device emulation without
|
|
* having to copy packets around.
|
|
*
|
|
* This function handles said path.
|
|
*
|
|
*
|
|
* Receive and send up an extended data packet that requires no reordering
|
|
*
|
|
* @i2400m: device descriptor
|
|
* @skb_rx: skb that contains the extended data packet
|
|
* @single_last: 1 if the payload is the only one or the last one of
|
|
* the skb.
|
|
* @payload: pointer to the packet's data (past the actual extended
|
|
* data payload header).
|
|
* @size: size of the payload
|
|
*
|
|
* Pass over to the networking stack a data packet that might have
|
|
* reordering requirements.
|
|
*
|
|
* This needs to the decide if the skb in which the packet is
|
|
* contained can be reused or if it needs to be cloned. Then it has to
|
|
* be trimmed in the edges so that the beginning is the space for eth
|
|
* header and then pass it to i2400m_net_erx() for the stack
|
|
*
|
|
* Assumes the caller has verified the sanity of the payload (size,
|
|
* etc) already.
|
|
*/
|
|
static
|
|
void i2400m_rx_edata(struct i2400m *i2400m, struct sk_buff *skb_rx,
|
|
unsigned single_last, const void *payload, size_t size)
|
|
{
|
|
struct device *dev = i2400m_dev(i2400m);
|
|
const struct i2400m_pl_edata_hdr *hdr = payload;
|
|
struct net_device *net_dev = i2400m->wimax_dev.net_dev;
|
|
struct sk_buff *skb;
|
|
enum i2400m_cs cs;
|
|
u32 reorder;
|
|
unsigned ro_needed, ro_type, ro_cin, ro_sn;
|
|
struct i2400m_roq *roq;
|
|
struct i2400m_roq_data *roq_data;
|
|
|
|
BUILD_BUG_ON(ETH_HLEN > sizeof(*hdr));
|
|
|
|
d_fnstart(2, dev, "(i2400m %p skb_rx %p single %u payload %p "
|
|
"size %zu)\n", i2400m, skb_rx, single_last, payload, size);
|
|
if (size < sizeof(*hdr)) {
|
|
dev_err(dev, "ERX: HW BUG? message with short header (%zu "
|
|
"vs %zu bytes expected)\n", size, sizeof(*hdr));
|
|
goto error;
|
|
}
|
|
|
|
if (single_last) {
|
|
skb = skb_get(skb_rx);
|
|
d_printf(3, dev, "ERX: skb %p reusing\n", skb);
|
|
} else {
|
|
skb = skb_clone(skb_rx, GFP_KERNEL);
|
|
if (skb == NULL) {
|
|
dev_err(dev, "ERX: no memory to clone skb\n");
|
|
net_dev->stats.rx_dropped++;
|
|
goto error_skb_clone;
|
|
}
|
|
d_printf(3, dev, "ERX: skb %p cloned from %p\n", skb, skb_rx);
|
|
}
|
|
/* now we have to pull and trim so that the skb points to the
|
|
* beginning of the IP packet; the netdev part will add the
|
|
* ethernet header as needed - we know there is enough space
|
|
* because we checked in i2400m_rx_edata(). */
|
|
skb_pull(skb, payload + sizeof(*hdr) - (void *) skb->data);
|
|
skb_trim(skb, (void *) skb_end_pointer(skb) - payload - sizeof(*hdr));
|
|
|
|
reorder = le32_to_cpu(hdr->reorder);
|
|
ro_needed = reorder & I2400M_RO_NEEDED;
|
|
cs = hdr->cs;
|
|
if (ro_needed) {
|
|
ro_type = (reorder >> I2400M_RO_TYPE_SHIFT) & I2400M_RO_TYPE;
|
|
ro_cin = (reorder >> I2400M_RO_CIN_SHIFT) & I2400M_RO_CIN;
|
|
ro_sn = (reorder >> I2400M_RO_SN_SHIFT) & I2400M_RO_SN;
|
|
|
|
roq = &i2400m->rx_roq[ro_cin];
|
|
roq_data = (struct i2400m_roq_data *) &skb->cb;
|
|
roq_data->sn = ro_sn;
|
|
roq_data->cs = cs;
|
|
d_printf(2, dev, "ERX: reorder needed: "
|
|
"type %u cin %u [ws %u] sn %u/%u len %zuB\n",
|
|
ro_type, ro_cin, roq->ws, ro_sn,
|
|
__i2400m_roq_nsn(roq, ro_sn), size);
|
|
d_dump(2, dev, payload, size);
|
|
switch(ro_type) {
|
|
case I2400M_RO_TYPE_RESET:
|
|
i2400m_roq_reset(i2400m, roq);
|
|
kfree_skb(skb); /* no data here */
|
|
break;
|
|
case I2400M_RO_TYPE_PACKET:
|
|
i2400m_roq_queue(i2400m, roq, skb, ro_sn);
|
|
break;
|
|
case I2400M_RO_TYPE_WS:
|
|
i2400m_roq_update_ws(i2400m, roq, ro_sn);
|
|
kfree_skb(skb); /* no data here */
|
|
break;
|
|
case I2400M_RO_TYPE_PACKET_WS:
|
|
i2400m_roq_queue_update_ws(i2400m, roq, skb, ro_sn);
|
|
break;
|
|
default:
|
|
dev_err(dev, "HW BUG? unknown reorder type %u\n", ro_type);
|
|
}
|
|
}
|
|
else
|
|
i2400m_net_erx(i2400m, skb, cs);
|
|
error_skb_clone:
|
|
error:
|
|
d_fnend(2, dev, "(i2400m %p skb_rx %p single %u payload %p "
|
|
"size %zu) = void\n", i2400m, skb_rx, single_last, payload, size);
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* Act on a received payload
|
|
*
|
|
* @i2400m: device instance
|
|
* @skb_rx: skb where the transaction was received
|
|
* @single_last: 1 this is the only payload or the last one (so the
|
|
* skb can be reused instead of cloned).
|
|
* @pld: payload descriptor
|
|
* @payload: payload data
|
|
*
|
|
* Upon reception of a payload, look at its guts in the payload
|
|
* descriptor and decide what to do with it. If it is a single payload
|
|
* skb or if the last skb is a data packet, the skb will be referenced
|
|
* and modified (so it doesn't have to be cloned).
|
|
*/
|
|
static
|
|
void i2400m_rx_payload(struct i2400m *i2400m, struct sk_buff *skb_rx,
|
|
unsigned single_last, const struct i2400m_pld *pld,
|
|
const void *payload)
|
|
{
|
|
struct device *dev = i2400m_dev(i2400m);
|
|
size_t pl_size = i2400m_pld_size(pld);
|
|
enum i2400m_pt pl_type = i2400m_pld_type(pld);
|
|
|
|
d_printf(7, dev, "RX: received payload type %u, %zu bytes\n",
|
|
pl_type, pl_size);
|
|
d_dump(8, dev, payload, pl_size);
|
|
|
|
switch (pl_type) {
|
|
case I2400M_PT_DATA:
|
|
d_printf(3, dev, "RX: data payload %zu bytes\n", pl_size);
|
|
i2400m_net_rx(i2400m, skb_rx, single_last, payload, pl_size);
|
|
break;
|
|
case I2400M_PT_CTRL:
|
|
i2400m_rx_ctl(i2400m, skb_rx, payload, pl_size);
|
|
break;
|
|
case I2400M_PT_TRACE:
|
|
i2400m_rx_trace(i2400m, payload, pl_size);
|
|
break;
|
|
case I2400M_PT_EDATA:
|
|
d_printf(3, dev, "ERX: data payload %zu bytes\n", pl_size);
|
|
i2400m_rx_edata(i2400m, skb_rx, single_last, payload, pl_size);
|
|
break;
|
|
default: /* Anything else shouldn't come to the host */
|
|
if (printk_ratelimit())
|
|
dev_err(dev, "RX: HW BUG? unexpected payload type %u\n",
|
|
pl_type);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Check a received transaction's message header
|
|
*
|
|
* @i2400m: device descriptor
|
|
* @msg_hdr: message header
|
|
* @buf_size: size of the received buffer
|
|
*
|
|
* Check that the declarations done by a RX buffer message header are
|
|
* sane and consistent with the amount of data that was received.
|
|
*/
|
|
static
|
|
int i2400m_rx_msg_hdr_check(struct i2400m *i2400m,
|
|
const struct i2400m_msg_hdr *msg_hdr,
|
|
size_t buf_size)
|
|
{
|
|
int result = -EIO;
|
|
struct device *dev = i2400m_dev(i2400m);
|
|
if (buf_size < sizeof(*msg_hdr)) {
|
|
dev_err(dev, "RX: HW BUG? message with short header (%zu "
|
|
"vs %zu bytes expected)\n", buf_size, sizeof(*msg_hdr));
|
|
goto error;
|
|
}
|
|
if (msg_hdr->barker != cpu_to_le32(I2400M_D2H_MSG_BARKER)) {
|
|
dev_err(dev, "RX: HW BUG? message received with unknown "
|
|
"barker 0x%08x (buf_size %zu bytes)\n",
|
|
le32_to_cpu(msg_hdr->barker), buf_size);
|
|
goto error;
|
|
}
|
|
if (msg_hdr->num_pls == 0) {
|
|
dev_err(dev, "RX: HW BUG? zero payload packets in message\n");
|
|
goto error;
|
|
}
|
|
if (le16_to_cpu(msg_hdr->num_pls) > I2400M_MAX_PLS_IN_MSG) {
|
|
dev_err(dev, "RX: HW BUG? message contains more payload "
|
|
"than maximum; ignoring.\n");
|
|
goto error;
|
|
}
|
|
result = 0;
|
|
error:
|
|
return result;
|
|
}
|
|
|
|
|
|
/*
|
|
* Check a payload descriptor against the received data
|
|
*
|
|
* @i2400m: device descriptor
|
|
* @pld: payload descriptor
|
|
* @pl_itr: offset (in bytes) in the received buffer the payload is
|
|
* located
|
|
* @buf_size: size of the received buffer
|
|
*
|
|
* Given a payload descriptor (part of a RX buffer), check it is sane
|
|
* and that the data it declares fits in the buffer.
|
|
*/
|
|
static
|
|
int i2400m_rx_pl_descr_check(struct i2400m *i2400m,
|
|
const struct i2400m_pld *pld,
|
|
size_t pl_itr, size_t buf_size)
|
|
{
|
|
int result = -EIO;
|
|
struct device *dev = i2400m_dev(i2400m);
|
|
size_t pl_size = i2400m_pld_size(pld);
|
|
enum i2400m_pt pl_type = i2400m_pld_type(pld);
|
|
|
|
if (pl_size > i2400m->bus_pl_size_max) {
|
|
dev_err(dev, "RX: HW BUG? payload @%zu: size %zu is "
|
|
"bigger than maximum %zu; ignoring message\n",
|
|
pl_itr, pl_size, i2400m->bus_pl_size_max);
|
|
goto error;
|
|
}
|
|
if (pl_itr + pl_size > buf_size) { /* enough? */
|
|
dev_err(dev, "RX: HW BUG? payload @%zu: size %zu "
|
|
"goes beyond the received buffer "
|
|
"size (%zu bytes); ignoring message\n",
|
|
pl_itr, pl_size, buf_size);
|
|
goto error;
|
|
}
|
|
if (pl_type >= I2400M_PT_ILLEGAL) {
|
|
dev_err(dev, "RX: HW BUG? illegal payload type %u; "
|
|
"ignoring message\n", pl_type);
|
|
goto error;
|
|
}
|
|
result = 0;
|
|
error:
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* i2400m_rx - Receive a buffer of data from the device
|
|
*
|
|
* @i2400m: device descriptor
|
|
* @skb: skbuff where the data has been received
|
|
*
|
|
* Parse in a buffer of data that contains an RX message sent from the
|
|
* device. See the file header for the format. Run all checks on the
|
|
* buffer header, then run over each payload's descriptors, verify
|
|
* their consistency and act on each payload's contents. If
|
|
* everything is succesful, update the device's statistics.
|
|
*
|
|
* Note: You need to set the skb to contain only the length of the
|
|
* received buffer; for that, use skb_trim(skb, RECEIVED_SIZE).
|
|
*
|
|
* Returns:
|
|
*
|
|
* 0 if ok, < 0 errno on error
|
|
*
|
|
* If ok, this function owns now the skb and the caller DOESN'T have
|
|
* to run kfree_skb() on it. However, on error, the caller still owns
|
|
* the skb and it is responsible for releasing it.
|
|
*/
|
|
int i2400m_rx(struct i2400m *i2400m, struct sk_buff *skb)
|
|
{
|
|
int i, result;
|
|
struct device *dev = i2400m_dev(i2400m);
|
|
const struct i2400m_msg_hdr *msg_hdr;
|
|
size_t pl_itr, pl_size, skb_len;
|
|
unsigned long flags;
|
|
unsigned num_pls, single_last;
|
|
|
|
skb_len = skb->len;
|
|
d_fnstart(4, dev, "(i2400m %p skb %p [size %zu])\n",
|
|
i2400m, skb, skb_len);
|
|
result = -EIO;
|
|
msg_hdr = (void *) skb->data;
|
|
result = i2400m_rx_msg_hdr_check(i2400m, msg_hdr, skb->len);
|
|
if (result < 0)
|
|
goto error_msg_hdr_check;
|
|
result = -EIO;
|
|
num_pls = le16_to_cpu(msg_hdr->num_pls);
|
|
pl_itr = sizeof(*msg_hdr) + /* Check payload descriptor(s) */
|
|
num_pls * sizeof(msg_hdr->pld[0]);
|
|
pl_itr = ALIGN(pl_itr, I2400M_PL_PAD);
|
|
if (pl_itr > skb->len) { /* got all the payload descriptors? */
|
|
dev_err(dev, "RX: HW BUG? message too short (%u bytes) for "
|
|
"%u payload descriptors (%zu each, total %zu)\n",
|
|
skb->len, num_pls, sizeof(msg_hdr->pld[0]), pl_itr);
|
|
goto error_pl_descr_short;
|
|
}
|
|
/* Walk each payload payload--check we really got it */
|
|
for (i = 0; i < num_pls; i++) {
|
|
/* work around old gcc warnings */
|
|
pl_size = i2400m_pld_size(&msg_hdr->pld[i]);
|
|
result = i2400m_rx_pl_descr_check(i2400m, &msg_hdr->pld[i],
|
|
pl_itr, skb->len);
|
|
if (result < 0)
|
|
goto error_pl_descr_check;
|
|
single_last = num_pls == 1 || i == num_pls - 1;
|
|
i2400m_rx_payload(i2400m, skb, single_last, &msg_hdr->pld[i],
|
|
skb->data + pl_itr);
|
|
pl_itr += ALIGN(pl_size, I2400M_PL_PAD);
|
|
cond_resched(); /* Don't monopolize */
|
|
}
|
|
kfree_skb(skb);
|
|
/* Update device statistics */
|
|
spin_lock_irqsave(&i2400m->rx_lock, flags);
|
|
i2400m->rx_pl_num += i;
|
|
if (i > i2400m->rx_pl_max)
|
|
i2400m->rx_pl_max = i;
|
|
if (i < i2400m->rx_pl_min)
|
|
i2400m->rx_pl_min = i;
|
|
i2400m->rx_num++;
|
|
i2400m->rx_size_acc += skb->len;
|
|
if (skb->len < i2400m->rx_size_min)
|
|
i2400m->rx_size_min = skb->len;
|
|
if (skb->len > i2400m->rx_size_max)
|
|
i2400m->rx_size_max = skb->len;
|
|
spin_unlock_irqrestore(&i2400m->rx_lock, flags);
|
|
error_pl_descr_check:
|
|
error_pl_descr_short:
|
|
error_msg_hdr_check:
|
|
d_fnend(4, dev, "(i2400m %p skb %p [size %zu]) = %d\n",
|
|
i2400m, skb, skb_len, result);
|
|
return result;
|
|
}
|
|
EXPORT_SYMBOL_GPL(i2400m_rx);
|
|
|
|
|
|
/*
|
|
* Initialize the RX queue and infrastructure
|
|
*
|
|
* This sets up all the RX reordering infrastructures, which will not
|
|
* be used if reordering is not enabled or if the firmware does not
|
|
* support it. The device is told to do reordering in
|
|
* i2400m_dev_initialize(), where it also looks at the value of the
|
|
* i2400m->rx_reorder switch before taking a decission.
|
|
*
|
|
* Note we allocate the roq queues in one chunk and the actual logging
|
|
* support for it (logging) in another one and then we setup the
|
|
* pointers from the first to the last.
|
|
*/
|
|
int i2400m_rx_setup(struct i2400m *i2400m)
|
|
{
|
|
int result = 0;
|
|
struct device *dev = i2400m_dev(i2400m);
|
|
|
|
i2400m->rx_reorder = i2400m_rx_reorder_disabled? 0 : 1;
|
|
if (i2400m->rx_reorder) {
|
|
unsigned itr;
|
|
size_t size;
|
|
struct i2400m_roq_log *rd;
|
|
|
|
result = -ENOMEM;
|
|
|
|
size = sizeof(i2400m->rx_roq[0]) * (I2400M_RO_CIN + 1);
|
|
i2400m->rx_roq = kzalloc(size, GFP_KERNEL);
|
|
if (i2400m->rx_roq == NULL) {
|
|
dev_err(dev, "RX: cannot allocate %zu bytes for "
|
|
"reorder queues\n", size);
|
|
goto error_roq_alloc;
|
|
}
|
|
|
|
size = sizeof(*i2400m->rx_roq[0].log) * (I2400M_RO_CIN + 1);
|
|
rd = kzalloc(size, GFP_KERNEL);
|
|
if (rd == NULL) {
|
|
dev_err(dev, "RX: cannot allocate %zu bytes for "
|
|
"reorder queues log areas\n", size);
|
|
result = -ENOMEM;
|
|
goto error_roq_log_alloc;
|
|
}
|
|
|
|
for(itr = 0; itr < I2400M_RO_CIN + 1; itr++) {
|
|
__i2400m_roq_init(&i2400m->rx_roq[itr]);
|
|
i2400m->rx_roq[itr].log = &rd[itr];
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
error_roq_log_alloc:
|
|
kfree(i2400m->rx_roq);
|
|
error_roq_alloc:
|
|
return result;
|
|
}
|
|
|
|
|
|
/* Tear down the RX queue and infrastructure */
|
|
void i2400m_rx_release(struct i2400m *i2400m)
|
|
{
|
|
if (i2400m->rx_reorder) {
|
|
unsigned itr;
|
|
for(itr = 0; itr < I2400M_RO_CIN + 1; itr++)
|
|
__skb_queue_purge(&i2400m->rx_roq[itr].queue);
|
|
kfree(i2400m->rx_roq[0].log);
|
|
kfree(i2400m->rx_roq);
|
|
}
|
|
}
|