]>
Commit | Line | Data |
---|---|---|
aa5a7aca IPG |
1 | /* |
2 | * Intel Wireless WiMAX Connection 2400m | |
3 | * Handle incoming traffic and deliver it to the control or data planes | |
4 | * | |
5 | * | |
6 | * Copyright (C) 2007-2008 Intel Corporation. All rights reserved. | |
7 | * | |
8 | * Redistribution and use in source and binary forms, with or without | |
9 | * modification, are permitted provided that the following conditions | |
10 | * are met: | |
11 | * | |
12 | * * Redistributions of source code must retain the above copyright | |
13 | * notice, this list of conditions and the following disclaimer. | |
14 | * * Redistributions in binary form must reproduce the above copyright | |
15 | * notice, this list of conditions and the following disclaimer in | |
16 | * the documentation and/or other materials provided with the | |
17 | * distribution. | |
18 | * * Neither the name of Intel Corporation nor the names of its | |
19 | * contributors may be used to endorse or promote products derived | |
20 | * from this software without specific prior written permission. | |
21 | * | |
22 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
23 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
24 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
25 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
26 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
27 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
28 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
29 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
30 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
31 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
32 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
33 | * | |
34 | * | |
35 | * Intel Corporation <linux-wimax@intel.com> | |
36 | * Yanir Lubetkin <yanirx.lubetkin@intel.com> | |
37 | * - Initial implementation | |
38 | * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com> | |
39 | * - Use skb_clone(), break up processing in chunks | |
40 | * - Split transport/device specific | |
41 | * - Make buffer size dynamic to exert less memory pressure | |
c747583d | 42 | * - RX reorder support |
aa5a7aca IPG |
43 | * |
44 | * This handles the RX path. | |
45 | * | |
46 | * We receive an RX message from the bus-specific driver, which | |
47 | * contains one or more payloads that have potentially different | |
48 | * destinataries (data or control paths). | |
49 | * | |
50 | * So we just take that payload from the transport specific code in | |
51 | * the form of an skb, break it up in chunks (a cloned skb each in the | |
52 | * case of network packets) and pass it to netdev or to the | |
53 | * command/ack handler (and from there to the WiMAX stack). | |
54 | * | |
55 | * PROTOCOL FORMAT | |
56 | * | |
57 | * The format of the buffer is: | |
58 | * | |
59 | * HEADER (struct i2400m_msg_hdr) | |
60 | * PAYLOAD DESCRIPTOR 0 (struct i2400m_pld) | |
61 | * PAYLOAD DESCRIPTOR 1 | |
62 | * ... | |
63 | * PAYLOAD DESCRIPTOR N | |
64 | * PAYLOAD 0 (raw bytes) | |
65 | * PAYLOAD 1 | |
66 | * ... | |
67 | * PAYLOAD N | |
68 | * | |
69 | * See tx.c for a deeper description on alignment requirements and | |
70 | * other fun facts of it. | |
71 | * | |
fd5c565c IPG |
72 | * DATA PACKETS |
73 | * | |
74 | * In firmwares <= v1.3, data packets have no header for RX, but they | |
75 | * do for TX (currently unused). | |
76 | * | |
77 | * In firmware >= 1.4, RX packets have an extended header (16 | |
78 | * bytes). This header conveys information for management of host | |
79 | * reordering of packets (the device offloads storage of the packets | |
c747583d | 80 | * for reordering to the host). Read below for more information. |
fd5c565c IPG |
81 | * |
82 | * The header is used as dummy space to emulate an ethernet header and | |
83 | * thus be able to act as an ethernet device without having to reallocate. | |
84 | * | |
c747583d IPG |
85 | * DATA RX REORDERING |
86 | * | |
87 | * Starting in firmware v1.4, the device can deliver packets for | |
88 | * delivery with special reordering information; this allows it to | |
89 | * more effectively do packet management when some frames were lost in | |
90 | * the radio traffic. | |
91 | * | |
92 | * Thus, for RX packets that come out of order, the device gives the | |
93 | * driver enough information to queue them properly and then at some | |
94 | * point, the signal to deliver the whole (or part) of the queued | |
95 | * packets to the networking stack. There are 16 such queues. | |
96 | * | |
97 | * This only happens when a packet comes in with the "need reorder" | |
98 | * flag set in the RX header. When such bit is set, the following | |
99 | * operations might be indicated: | |
100 | * | |
101 | * - reset queue: send all queued packets to the OS | |
102 | * | |
103 | * - queue: queue a packet | |
104 | * | |
105 | * - update ws: update the queue's window start and deliver queued | |
106 | * packets that meet the criteria | |
107 | * | |
108 | * - queue & update ws: queue a packet, update the window start and | |
109 | * deliver queued packets that meet the criteria | |
110 | * | |
111 | * (delivery criteria: the packet's [normalized] sequence number is | |
112 | * lower than the new [normalized] window start). | |
113 | * | |
114 | * See the i2400m_roq_*() functions for details. | |
115 | * | |
aa5a7aca IPG |
116 | * ROADMAP |
117 | * | |
118 | * i2400m_rx | |
119 | * i2400m_rx_msg_hdr_check | |
120 | * i2400m_rx_pl_descr_check | |
121 | * i2400m_rx_payload | |
122 | * i2400m_net_rx | |
fd5c565c IPG |
123 | * i2400m_rx_edata |
124 | * i2400m_net_erx | |
c747583d IPG |
125 | * i2400m_roq_reset |
126 | * i2400m_net_erx | |
127 | * i2400m_roq_queue | |
128 | * __i2400m_roq_queue | |
129 | * i2400m_roq_update_ws | |
130 | * __i2400m_roq_update_ws | |
131 | * i2400m_net_erx | |
132 | * i2400m_roq_queue_update_ws | |
133 | * __i2400m_roq_queue | |
134 | * __i2400m_roq_update_ws | |
135 | * i2400m_net_erx | |
aa5a7aca IPG |
136 | * i2400m_rx_ctl |
137 | * i2400m_msg_size_check | |
138 | * i2400m_report_hook_work [in a workqueue] | |
139 | * i2400m_report_hook | |
140 | * wimax_msg_to_user | |
141 | * i2400m_rx_ctl_ack | |
142 | * wimax_msg_to_user_alloc | |
143 | * i2400m_rx_trace | |
144 | * i2400m_msg_size_check | |
145 | * wimax_msg | |
146 | */ | |
147 | #include <linux/kernel.h> | |
148 | #include <linux/if_arp.h> | |
149 | #include <linux/netdevice.h> | |
150 | #include <linux/workqueue.h> | |
151 | #include "i2400m.h" | |
152 | ||
153 | ||
154 | #define D_SUBMODULE rx | |
155 | #include "debug-levels.h" | |
156 | ||
157 | struct i2400m_report_hook_args { | |
158 | struct sk_buff *skb_rx; | |
159 | const struct i2400m_l3l4_hdr *l3l4_hdr; | |
160 | size_t size; | |
a0beba21 | 161 | struct list_head list_node; |
aa5a7aca IPG |
162 | }; |
163 | ||
164 | ||
165 | /* | |
166 | * Execute i2400m_report_hook in a workqueue | |
167 | * | |
a0beba21 IPG |
168 | * Goes over the list of queued reports in i2400m->rx_reports and |
169 | * processes them. | |
aa5a7aca | 170 | * |
a0beba21 IPG |
171 | * NOTE: refcounts on i2400m are not needed because we flush the |
172 | * workqueue this runs on (i2400m->work_queue) before destroying | |
173 | * i2400m. | |
aa5a7aca | 174 | */ |
aa5a7aca IPG |
175 | void i2400m_report_hook_work(struct work_struct *ws) |
176 | { | |
a0beba21 IPG |
177 | struct i2400m *i2400m = container_of(ws, struct i2400m, rx_report_ws); |
178 | struct device *dev = i2400m_dev(i2400m); | |
179 | struct i2400m_report_hook_args *args, *args_next; | |
180 | LIST_HEAD(list); | |
181 | unsigned long flags; | |
182 | ||
183 | while (1) { | |
184 | spin_lock_irqsave(&i2400m->rx_lock, flags); | |
185 | list_splice_init(&i2400m->rx_reports, &list); | |
186 | spin_unlock_irqrestore(&i2400m->rx_lock, flags); | |
187 | if (list_empty(&list)) | |
188 | break; | |
189 | else | |
190 | d_printf(1, dev, "processing queued reports\n"); | |
191 | list_for_each_entry_safe(args, args_next, &list, list_node) { | |
192 | d_printf(2, dev, "processing queued report %p\n", args); | |
193 | i2400m_report_hook(i2400m, args->l3l4_hdr, args->size); | |
194 | kfree_skb(args->skb_rx); | |
195 | list_del(&args->list_node); | |
196 | kfree(args); | |
197 | } | |
198 | } | |
199 | } | |
200 | ||
201 | ||
202 | /* | |
203 | * Flush the list of queued reports | |
204 | */ | |
205 | static | |
206 | void i2400m_report_hook_flush(struct i2400m *i2400m) | |
207 | { | |
208 | struct device *dev = i2400m_dev(i2400m); | |
209 | struct i2400m_report_hook_args *args, *args_next; | |
210 | LIST_HEAD(list); | |
211 | unsigned long flags; | |
212 | ||
213 | d_printf(1, dev, "flushing queued reports\n"); | |
214 | spin_lock_irqsave(&i2400m->rx_lock, flags); | |
215 | list_splice_init(&i2400m->rx_reports, &list); | |
216 | spin_unlock_irqrestore(&i2400m->rx_lock, flags); | |
217 | list_for_each_entry_safe(args, args_next, &list, list_node) { | |
218 | d_printf(2, dev, "flushing queued report %p\n", args); | |
219 | kfree_skb(args->skb_rx); | |
220 | list_del(&args->list_node); | |
221 | kfree(args); | |
222 | } | |
223 | } | |
224 | ||
225 | ||
226 | /* | |
227 | * Queue a report for later processing | |
228 | * | |
229 | * @i2400m: device descriptor | |
230 | * @skb_rx: skb that contains the payload (for reference counting) | |
231 | * @l3l4_hdr: pointer to the control | |
232 | * @size: size of the message | |
233 | */ | |
234 | static | |
235 | void i2400m_report_hook_queue(struct i2400m *i2400m, struct sk_buff *skb_rx, | |
236 | const void *l3l4_hdr, size_t size) | |
237 | { | |
238 | struct device *dev = i2400m_dev(i2400m); | |
239 | unsigned long flags; | |
240 | struct i2400m_report_hook_args *args; | |
241 | ||
242 | args = kzalloc(sizeof(*args), GFP_NOIO); | |
243 | if (args) { | |
244 | args->skb_rx = skb_get(skb_rx); | |
245 | args->l3l4_hdr = l3l4_hdr; | |
246 | args->size = size; | |
247 | spin_lock_irqsave(&i2400m->rx_lock, flags); | |
248 | list_add_tail(&args->list_node, &i2400m->rx_reports); | |
249 | spin_unlock_irqrestore(&i2400m->rx_lock, flags); | |
250 | d_printf(2, dev, "queued report %p\n", args); | |
251 | rmb(); /* see i2400m->ready's documentation */ | |
252 | if (likely(i2400m->ready)) /* only send if up */ | |
253 | queue_work(i2400m->work_queue, &i2400m->rx_report_ws); | |
254 | } else { | |
255 | if (printk_ratelimit()) | |
256 | dev_err(dev, "%s:%u: Can't allocate %zu B\n", | |
257 | __func__, __LINE__, sizeof(*args)); | |
258 | } | |
aa5a7aca IPG |
259 | } |
260 | ||
261 | ||
262 | /* | |
263 | * Process an ack to a command | |
264 | * | |
265 | * @i2400m: device descriptor | |
266 | * @payload: pointer to message | |
267 | * @size: size of the message | |
268 | * | |
269 | * Pass the acknodledgment (in an skb) to the thread that is waiting | |
270 | * for it in i2400m->msg_completion. | |
271 | * | |
272 | * We need to coordinate properly with the thread waiting for the | |
273 | * ack. Check if it is waiting or if it is gone. We loose the spinlock | |
274 | * to avoid allocating on atomic contexts (yeah, could use GFP_ATOMIC, | |
275 | * but this is not so speed critical). | |
276 | */ | |
277 | static | |
278 | void i2400m_rx_ctl_ack(struct i2400m *i2400m, | |
279 | const void *payload, size_t size) | |
280 | { | |
281 | struct device *dev = i2400m_dev(i2400m); | |
282 | struct wimax_dev *wimax_dev = &i2400m->wimax_dev; | |
283 | unsigned long flags; | |
284 | struct sk_buff *ack_skb; | |
285 | ||
286 | /* Anyone waiting for an answer? */ | |
287 | spin_lock_irqsave(&i2400m->rx_lock, flags); | |
288 | if (i2400m->ack_skb != ERR_PTR(-EINPROGRESS)) { | |
289 | dev_err(dev, "Huh? reply to command with no waiters\n"); | |
290 | goto error_no_waiter; | |
291 | } | |
292 | spin_unlock_irqrestore(&i2400m->rx_lock, flags); | |
293 | ||
294 | ack_skb = wimax_msg_alloc(wimax_dev, NULL, payload, size, GFP_KERNEL); | |
295 | ||
296 | /* Check waiter didn't time out waiting for the answer... */ | |
297 | spin_lock_irqsave(&i2400m->rx_lock, flags); | |
298 | if (i2400m->ack_skb != ERR_PTR(-EINPROGRESS)) { | |
299 | d_printf(1, dev, "Huh? waiter for command reply cancelled\n"); | |
300 | goto error_waiter_cancelled; | |
301 | } | |
302 | if (ack_skb == NULL) { | |
303 | dev_err(dev, "CMD/GET/SET ack: cannot allocate SKB\n"); | |
304 | i2400m->ack_skb = ERR_PTR(-ENOMEM); | |
305 | } else | |
306 | i2400m->ack_skb = ack_skb; | |
307 | spin_unlock_irqrestore(&i2400m->rx_lock, flags); | |
308 | complete(&i2400m->msg_completion); | |
309 | return; | |
310 | ||
311 | error_waiter_cancelled: | |
c71a2699 | 312 | kfree_skb(ack_skb); |
aa5a7aca IPG |
313 | error_no_waiter: |
314 | spin_unlock_irqrestore(&i2400m->rx_lock, flags); | |
315 | return; | |
316 | } | |
317 | ||
318 | ||
319 | /* | |
320 | * Receive and process a control payload | |
321 | * | |
322 | * @i2400m: device descriptor | |
323 | * @skb_rx: skb that contains the payload (for reference counting) | |
324 | * @payload: pointer to message | |
325 | * @size: size of the message | |
326 | * | |
327 | * There are two types of control RX messages: reports (asynchronous, | |
328 | * like your every day interrupts) and 'acks' (reponses to a command, | |
329 | * get or set request). | |
330 | * | |
331 | * If it is a report, we run hooks on it (to extract information for | |
332 | * things we need to do in the driver) and then pass it over to the | |
333 | * WiMAX stack to send it to user space. | |
334 | * | |
335 | * NOTE: report processing is done in a workqueue specific to the | |
336 | * generic driver, to avoid deadlocks in the system. | |
337 | * | |
338 | * If it is not a report, it is an ack to a previously executed | |
339 | * command, set or get, so wake up whoever is waiting for it from | |
340 | * i2400m_msg_to_dev(). i2400m_rx_ctl_ack() takes care of that. | |
341 | * | |
342 | * Note that the sizes we pass to other functions from here are the | |
343 | * sizes of the _l3l4_hdr + payload, not full buffer sizes, as we have | |
344 | * verified in _msg_size_check() that they are congruent. | |
345 | * | |
346 | * For reports: We can't clone the original skb where the data is | |
347 | * because we need to send this up via netlink; netlink has to add | |
348 | * headers and we can't overwrite what's preceeding the payload...as | |
349 | * it is another message. So we just dup them. | |
350 | */ | |
351 | static | |
352 | void i2400m_rx_ctl(struct i2400m *i2400m, struct sk_buff *skb_rx, | |
353 | const void *payload, size_t size) | |
354 | { | |
355 | int result; | |
356 | struct device *dev = i2400m_dev(i2400m); | |
357 | const struct i2400m_l3l4_hdr *l3l4_hdr = payload; | |
358 | unsigned msg_type; | |
359 | ||
360 | result = i2400m_msg_size_check(i2400m, l3l4_hdr, size); | |
361 | if (result < 0) { | |
362 | dev_err(dev, "HW BUG? device sent a bad message: %d\n", | |
363 | result); | |
364 | goto error_check; | |
365 | } | |
366 | msg_type = le16_to_cpu(l3l4_hdr->type); | |
367 | d_printf(1, dev, "%s 0x%04x: %zu bytes\n", | |
368 | msg_type & I2400M_MT_REPORT_MASK ? "REPORT" : "CMD/SET/GET", | |
369 | msg_type, size); | |
370 | d_dump(2, dev, l3l4_hdr, size); | |
371 | if (msg_type & I2400M_MT_REPORT_MASK) { | |
a0beba21 IPG |
372 | /* |
373 | * Process each report | |
374 | * | |
375 | * - has to be ran serialized as well | |
376 | * | |
377 | * - the handling might force the execution of | |
378 | * commands. That might cause reentrancy issues with | |
379 | * bus-specific subdrivers and workqueues, so the we | |
380 | * run it in a separate workqueue. | |
381 | * | |
382 | * - when the driver is not yet ready to handle them, | |
383 | * they are queued and at some point the queue is | |
384 | * restarted [NOTE: we can't queue SKBs directly, as | |
385 | * this might be a piece of a SKB, not the whole | |
386 | * thing, and this is cheaper than cloning the | |
387 | * SKB]. | |
388 | * | |
389 | * Note we don't do refcounting for the device | |
390 | * structure; this is because before destroying | |
391 | * 'i2400m', we make sure to flush the | |
392 | * i2400m->work_queue, so there are no issues. | |
393 | */ | |
394 | i2400m_report_hook_queue(i2400m, skb_rx, l3l4_hdr, size); | |
44b849d1 IPG |
395 | if (unlikely(i2400m->trace_msg_from_user)) |
396 | wimax_msg(&i2400m->wimax_dev, "echo", | |
397 | l3l4_hdr, size, GFP_KERNEL); | |
aa5a7aca IPG |
398 | result = wimax_msg(&i2400m->wimax_dev, NULL, l3l4_hdr, size, |
399 | GFP_KERNEL); | |
400 | if (result < 0) | |
401 | dev_err(dev, "error sending report to userspace: %d\n", | |
402 | result); | |
403 | } else /* an ack to a CMD, GET or SET */ | |
404 | i2400m_rx_ctl_ack(i2400m, payload, size); | |
405 | error_check: | |
406 | return; | |
407 | } | |
408 | ||
409 | ||
aa5a7aca IPG |
410 | /* |
411 | * Receive and send up a trace | |
412 | * | |
413 | * @i2400m: device descriptor | |
414 | * @skb_rx: skb that contains the trace (for reference counting) | |
415 | * @payload: pointer to trace message inside the skb | |
416 | * @size: size of the message | |
417 | * | |
418 | * THe i2400m might produce trace information (diagnostics) and we | |
419 | * send them through a different kernel-to-user pipe (to avoid | |
420 | * clogging it). | |
421 | * | |
422 | * As in i2400m_rx_ctl(), we can't clone the original skb where the | |
423 | * data is because we need to send this up via netlink; netlink has to | |
424 | * add headers and we can't overwrite what's preceeding the | |
425 | * payload...as it is another message. So we just dup them. | |
426 | */ | |
427 | static | |
428 | void i2400m_rx_trace(struct i2400m *i2400m, | |
429 | const void *payload, size_t size) | |
430 | { | |
431 | int result; | |
432 | struct device *dev = i2400m_dev(i2400m); | |
433 | struct wimax_dev *wimax_dev = &i2400m->wimax_dev; | |
434 | const struct i2400m_l3l4_hdr *l3l4_hdr = payload; | |
435 | unsigned msg_type; | |
436 | ||
437 | result = i2400m_msg_size_check(i2400m, l3l4_hdr, size); | |
438 | if (result < 0) { | |
439 | dev_err(dev, "HW BUG? device sent a bad trace message: %d\n", | |
440 | result); | |
441 | goto error_check; | |
442 | } | |
443 | msg_type = le16_to_cpu(l3l4_hdr->type); | |
444 | d_printf(1, dev, "Trace %s 0x%04x: %zu bytes\n", | |
445 | msg_type & I2400M_MT_REPORT_MASK ? "REPORT" : "CMD/SET/GET", | |
446 | msg_type, size); | |
447 | d_dump(2, dev, l3l4_hdr, size); | |
aa5a7aca IPG |
448 | result = wimax_msg(wimax_dev, "trace", l3l4_hdr, size, GFP_KERNEL); |
449 | if (result < 0) | |
450 | dev_err(dev, "error sending trace to userspace: %d\n", | |
451 | result); | |
452 | error_check: | |
453 | return; | |
454 | } | |
455 | ||
c747583d IPG |
456 | |
457 | /* | |
458 | * Reorder queue data stored on skb->cb while the skb is queued in the | |
459 | * reorder queues. | |
460 | */ | |
461 | struct i2400m_roq_data { | |
462 | unsigned sn; /* Serial number for the skb */ | |
463 | enum i2400m_cs cs; /* packet type for the skb */ | |
464 | }; | |
465 | ||
466 | ||
467 | /* | |
468 | * ReOrder Queue | |
469 | * | |
470 | * @ws: Window Start; sequence number where the current window start | |
471 | * is for this queue | |
472 | * @queue: the skb queue itself | |
473 | * @log: circular ring buffer used to log information about the | |
474 | * reorder process in this queue that can be displayed in case of | |
475 | * error to help diagnose it. | |
476 | * | |
477 | * This is the head for a list of skbs. In the skb->cb member of the | |
478 | * skb when queued here contains a 'struct i2400m_roq_data' were we | |
479 | * store the sequence number (sn) and the cs (packet type) coming from | |
480 | * the RX payload header from the device. | |
481 | */ | |
482 | struct i2400m_roq | |
483 | { | |
484 | unsigned ws; | |
485 | struct sk_buff_head queue; | |
486 | struct i2400m_roq_log *log; | |
487 | }; | |
488 | ||
489 | ||
490 | static | |
491 | void __i2400m_roq_init(struct i2400m_roq *roq) | |
492 | { | |
493 | roq->ws = 0; | |
494 | skb_queue_head_init(&roq->queue); | |
495 | } | |
496 | ||
497 | ||
498 | static | |
499 | unsigned __i2400m_roq_index(struct i2400m *i2400m, struct i2400m_roq *roq) | |
500 | { | |
501 | return ((unsigned long) roq - (unsigned long) i2400m->rx_roq) | |
502 | / sizeof(*roq); | |
503 | } | |
504 | ||
505 | ||
506 | /* | |
507 | * Normalize a sequence number based on the queue's window start | |
508 | * | |
509 | * nsn = (sn - ws) % 2048 | |
510 | * | |
511 | * Note that if @sn < @roq->ws, we still need a positive number; %'s | |
512 | * sign is implementation specific, so we normalize it by adding 2048 | |
513 | * to bring it to be positive. | |
514 | */ | |
515 | static | |
516 | unsigned __i2400m_roq_nsn(struct i2400m_roq *roq, unsigned sn) | |
517 | { | |
518 | int r; | |
519 | r = ((int) sn - (int) roq->ws) % 2048; | |
520 | if (r < 0) | |
521 | r += 2048; | |
522 | return r; | |
523 | } | |
524 | ||
525 | ||
526 | /* | |
527 | * Circular buffer to keep the last N reorder operations | |
528 | * | |
529 | * In case something fails, dumb then to try to come up with what | |
530 | * happened. | |
531 | */ | |
532 | enum { | |
533 | I2400M_ROQ_LOG_LENGTH = 32, | |
534 | }; | |
535 | ||
536 | struct i2400m_roq_log { | |
537 | struct i2400m_roq_log_entry { | |
538 | enum i2400m_ro_type type; | |
539 | unsigned ws, count, sn, nsn, new_ws; | |
540 | } entry[I2400M_ROQ_LOG_LENGTH]; | |
541 | unsigned in, out; | |
542 | }; | |
543 | ||
544 | ||
545 | /* Print a log entry */ | |
546 | static | |
547 | void i2400m_roq_log_entry_print(struct i2400m *i2400m, unsigned index, | |
548 | unsigned e_index, | |
549 | struct i2400m_roq_log_entry *e) | |
550 | { | |
551 | struct device *dev = i2400m_dev(i2400m); | |
552 | ||
553 | switch(e->type) { | |
554 | case I2400M_RO_TYPE_RESET: | |
555 | dev_err(dev, "q#%d reset ws %u cnt %u sn %u/%u" | |
556 | " - new nws %u\n", | |
557 | index, e->ws, e->count, e->sn, e->nsn, e->new_ws); | |
558 | break; | |
559 | case I2400M_RO_TYPE_PACKET: | |
560 | dev_err(dev, "q#%d queue ws %u cnt %u sn %u/%u\n", | |
561 | index, e->ws, e->count, e->sn, e->nsn); | |
562 | break; | |
563 | case I2400M_RO_TYPE_WS: | |
564 | dev_err(dev, "q#%d update_ws ws %u cnt %u sn %u/%u" | |
565 | " - new nws %u\n", | |
566 | index, e->ws, e->count, e->sn, e->nsn, e->new_ws); | |
567 | break; | |
568 | case I2400M_RO_TYPE_PACKET_WS: | |
569 | dev_err(dev, "q#%d queue_update_ws ws %u cnt %u sn %u/%u" | |
570 | " - new nws %u\n", | |
571 | index, e->ws, e->count, e->sn, e->nsn, e->new_ws); | |
572 | break; | |
573 | default: | |
574 | dev_err(dev, "q#%d BUG? entry %u - unknown type %u\n", | |
575 | index, e_index, e->type); | |
576 | break; | |
577 | } | |
578 | } | |
579 | ||
580 | ||
581 | static | |
582 | void i2400m_roq_log_add(struct i2400m *i2400m, | |
583 | struct i2400m_roq *roq, enum i2400m_ro_type type, | |
584 | unsigned ws, unsigned count, unsigned sn, | |
585 | unsigned nsn, unsigned new_ws) | |
586 | { | |
587 | struct i2400m_roq_log_entry *e; | |
588 | unsigned cnt_idx; | |
589 | int index = __i2400m_roq_index(i2400m, roq); | |
590 | ||
591 | /* if we run out of space, we eat from the end */ | |
592 | if (roq->log->in - roq->log->out == I2400M_ROQ_LOG_LENGTH) | |
593 | roq->log->out++; | |
594 | cnt_idx = roq->log->in++ % I2400M_ROQ_LOG_LENGTH; | |
595 | e = &roq->log->entry[cnt_idx]; | |
596 | ||
597 | e->type = type; | |
598 | e->ws = ws; | |
599 | e->count = count; | |
600 | e->sn = sn; | |
601 | e->nsn = nsn; | |
602 | e->new_ws = new_ws; | |
603 | ||
604 | if (d_test(1)) | |
605 | i2400m_roq_log_entry_print(i2400m, index, cnt_idx, e); | |
606 | } | |
607 | ||
608 | ||
609 | /* Dump all the entries in the FIFO and reinitialize it */ | |
610 | static | |
611 | void i2400m_roq_log_dump(struct i2400m *i2400m, struct i2400m_roq *roq) | |
612 | { | |
613 | unsigned cnt, cnt_idx; | |
614 | struct i2400m_roq_log_entry *e; | |
615 | int index = __i2400m_roq_index(i2400m, roq); | |
616 | ||
617 | BUG_ON(roq->log->out > roq->log->in); | |
618 | for (cnt = roq->log->out; cnt < roq->log->in; cnt++) { | |
619 | cnt_idx = cnt % I2400M_ROQ_LOG_LENGTH; | |
620 | e = &roq->log->entry[cnt_idx]; | |
621 | i2400m_roq_log_entry_print(i2400m, index, cnt_idx, e); | |
622 | memset(e, 0, sizeof(*e)); | |
623 | } | |
624 | roq->log->in = roq->log->out = 0; | |
625 | } | |
626 | ||
627 | ||
628 | /* | |
629 | * Backbone for the queuing of an skb (by normalized sequence number) | |
630 | * | |
631 | * @i2400m: device descriptor | |
632 | * @roq: reorder queue where to add | |
633 | * @skb: the skb to add | |
634 | * @sn: the sequence number of the skb | |
635 | * @nsn: the normalized sequence number of the skb (pre-computed by the | |
636 | * caller from the @sn and @roq->ws). | |
637 | * | |
638 | * We try first a couple of quick cases: | |
639 | * | |
640 | * - the queue is empty | |
641 | * - the skb would be appended to the queue | |
642 | * | |
643 | * These will be the most common operations. | |
644 | * | |
645 | * If these fail, then we have to do a sorted insertion in the queue, | |
646 | * which is the slowest path. | |
647 | * | |
648 | * We don't have to acquire a reference count as we are going to own it. | |
649 | */ | |
650 | static | |
651 | void __i2400m_roq_queue(struct i2400m *i2400m, struct i2400m_roq *roq, | |
652 | struct sk_buff *skb, unsigned sn, unsigned nsn) | |
653 | { | |
654 | struct device *dev = i2400m_dev(i2400m); | |
655 | struct sk_buff *skb_itr; | |
656 | struct i2400m_roq_data *roq_data_itr, *roq_data; | |
657 | unsigned nsn_itr; | |
658 | ||
659 | d_fnstart(4, dev, "(i2400m %p roq %p skb %p sn %u nsn %u)\n", | |
660 | i2400m, roq, skb, sn, nsn); | |
661 | ||
662 | roq_data = (struct i2400m_roq_data *) &skb->cb; | |
663 | BUILD_BUG_ON(sizeof(*roq_data) > sizeof(skb->cb)); | |
664 | roq_data->sn = sn; | |
665 | d_printf(3, dev, "ERX: roq %p [ws %u] nsn %d sn %u\n", | |
666 | roq, roq->ws, nsn, roq_data->sn); | |
667 | ||
668 | /* Queues will be empty on not-so-bad environments, so try | |
669 | * that first */ | |
670 | if (skb_queue_empty(&roq->queue)) { | |
671 | d_printf(2, dev, "ERX: roq %p - first one\n", roq); | |
672 | __skb_queue_head(&roq->queue, skb); | |
673 | goto out; | |
674 | } | |
675 | /* Now try append, as most of the operations will be that */ | |
676 | skb_itr = skb_peek_tail(&roq->queue); | |
677 | roq_data_itr = (struct i2400m_roq_data *) &skb_itr->cb; | |
678 | nsn_itr = __i2400m_roq_nsn(roq, roq_data_itr->sn); | |
679 | /* NSN bounds assumed correct (checked when it was queued) */ | |
680 | if (nsn >= nsn_itr) { | |
681 | d_printf(2, dev, "ERX: roq %p - appended after %p (nsn %d sn %u)\n", | |
682 | roq, skb_itr, nsn_itr, roq_data_itr->sn); | |
683 | __skb_queue_tail(&roq->queue, skb); | |
684 | goto out; | |
685 | } | |
686 | /* None of the fast paths option worked. Iterate to find the | |
687 | * right spot where to insert the packet; we know the queue is | |
688 | * not empty, so we are not the first ones; we also know we | |
689 | * are not going to be the last ones. The list is sorted, so | |
690 | * we have to insert before the the first guy with an nsn_itr | |
691 | * greater that our nsn. */ | |
692 | skb_queue_walk(&roq->queue, skb_itr) { | |
693 | roq_data_itr = (struct i2400m_roq_data *) &skb_itr->cb; | |
694 | nsn_itr = __i2400m_roq_nsn(roq, roq_data_itr->sn); | |
695 | /* NSN bounds assumed correct (checked when it was queued) */ | |
696 | if (nsn_itr > nsn) { | |
697 | d_printf(2, dev, "ERX: roq %p - queued before %p " | |
698 | "(nsn %d sn %u)\n", roq, skb_itr, nsn_itr, | |
699 | roq_data_itr->sn); | |
700 | __skb_queue_before(&roq->queue, skb_itr, skb); | |
701 | goto out; | |
702 | } | |
703 | } | |
704 | /* If we get here, that is VERY bad -- print info to help | |
705 | * diagnose and crash it */ | |
706 | dev_err(dev, "SW BUG? failed to insert packet\n"); | |
707 | dev_err(dev, "ERX: roq %p [ws %u] skb %p nsn %d sn %u\n", | |
708 | roq, roq->ws, skb, nsn, roq_data->sn); | |
709 | skb_queue_walk(&roq->queue, skb_itr) { | |
710 | roq_data_itr = (struct i2400m_roq_data *) &skb_itr->cb; | |
711 | nsn_itr = __i2400m_roq_nsn(roq, roq_data_itr->sn); | |
712 | /* NSN bounds assumed correct (checked when it was queued) */ | |
713 | dev_err(dev, "ERX: roq %p skb_itr %p nsn %d sn %u\n", | |
714 | roq, skb_itr, nsn_itr, roq_data_itr->sn); | |
715 | } | |
716 | BUG(); | |
717 | out: | |
718 | d_fnend(4, dev, "(i2400m %p roq %p skb %p sn %u nsn %d) = void\n", | |
719 | i2400m, roq, skb, sn, nsn); | |
720 | return; | |
721 | } | |
722 | ||
723 | ||
724 | /* | |
725 | * Backbone for the update window start operation | |
726 | * | |
727 | * @i2400m: device descriptor | |
728 | * @roq: Reorder queue | |
729 | * @sn: New sequence number | |
730 | * | |
731 | * Updates the window start of a queue; when doing so, it must deliver | |
732 | * to the networking stack all the queued skb's whose normalized | |
733 | * sequence number is lower than the new normalized window start. | |
734 | */ | |
735 | static | |
736 | unsigned __i2400m_roq_update_ws(struct i2400m *i2400m, struct i2400m_roq *roq, | |
737 | unsigned sn) | |
738 | { | |
739 | struct device *dev = i2400m_dev(i2400m); | |
740 | struct sk_buff *skb_itr, *tmp_itr; | |
741 | struct i2400m_roq_data *roq_data_itr; | |
742 | unsigned new_nws, nsn_itr; | |
743 | ||
744 | new_nws = __i2400m_roq_nsn(roq, sn); | |
745 | if (unlikely(new_nws >= 1024) && d_test(1)) { | |
746 | dev_err(dev, "SW BUG? __update_ws new_nws %u (sn %u ws %u)\n", | |
747 | new_nws, sn, roq->ws); | |
748 | WARN_ON(1); | |
749 | i2400m_roq_log_dump(i2400m, roq); | |
750 | } | |
751 | skb_queue_walk_safe(&roq->queue, skb_itr, tmp_itr) { | |
752 | roq_data_itr = (struct i2400m_roq_data *) &skb_itr->cb; | |
753 | nsn_itr = __i2400m_roq_nsn(roq, roq_data_itr->sn); | |
754 | /* NSN bounds assumed correct (checked when it was queued) */ | |
755 | if (nsn_itr < new_nws) { | |
756 | d_printf(2, dev, "ERX: roq %p - release skb %p " | |
757 | "(nsn %u/%u new nws %u)\n", | |
758 | roq, skb_itr, nsn_itr, roq_data_itr->sn, | |
759 | new_nws); | |
760 | __skb_unlink(skb_itr, &roq->queue); | |
761 | i2400m_net_erx(i2400m, skb_itr, roq_data_itr->cs); | |
762 | } | |
763 | else | |
764 | break; /* rest of packets all nsn_itr > nws */ | |
765 | } | |
766 | roq->ws = sn; | |
767 | return new_nws; | |
768 | } | |
769 | ||
770 | ||
771 | /* | |
772 | * Reset a queue | |
773 | * | |
774 | * @i2400m: device descriptor | |
775 | * @cin: Queue Index | |
776 | * | |
777 | * Deliver all the packets and reset the window-start to zero. Name is | |
778 | * kind of misleading. | |
779 | */ | |
780 | static | |
781 | void i2400m_roq_reset(struct i2400m *i2400m, struct i2400m_roq *roq) | |
782 | { | |
783 | struct device *dev = i2400m_dev(i2400m); | |
784 | struct sk_buff *skb_itr, *tmp_itr; | |
785 | struct i2400m_roq_data *roq_data_itr; | |
786 | ||
787 | d_fnstart(2, dev, "(i2400m %p roq %p)\n", i2400m, roq); | |
788 | i2400m_roq_log_add(i2400m, roq, I2400M_RO_TYPE_RESET, | |
789 | roq->ws, skb_queue_len(&roq->queue), | |
790 | ~0, ~0, 0); | |
791 | skb_queue_walk_safe(&roq->queue, skb_itr, tmp_itr) { | |
792 | roq_data_itr = (struct i2400m_roq_data *) &skb_itr->cb; | |
793 | d_printf(2, dev, "ERX: roq %p - release skb %p (sn %u)\n", | |
794 | roq, skb_itr, roq_data_itr->sn); | |
795 | __skb_unlink(skb_itr, &roq->queue); | |
796 | i2400m_net_erx(i2400m, skb_itr, roq_data_itr->cs); | |
797 | } | |
798 | roq->ws = 0; | |
799 | d_fnend(2, dev, "(i2400m %p roq %p) = void\n", i2400m, roq); | |
800 | return; | |
801 | } | |
802 | ||
803 | ||
804 | /* | |
805 | * Queue a packet | |
806 | * | |
807 | * @i2400m: device descriptor | |
808 | * @cin: Queue Index | |
809 | * @skb: containing the packet data | |
810 | * @fbn: First block number of the packet in @skb | |
811 | * @lbn: Last block number of the packet in @skb | |
812 | * | |
813 | * The hardware is asking the driver to queue a packet for later | |
814 | * delivery to the networking stack. | |
815 | */ | |
816 | static | |
817 | void i2400m_roq_queue(struct i2400m *i2400m, struct i2400m_roq *roq, | |
818 | struct sk_buff * skb, unsigned lbn) | |
819 | { | |
820 | struct device *dev = i2400m_dev(i2400m); | |
821 | unsigned nsn, len; | |
822 | ||
823 | d_fnstart(2, dev, "(i2400m %p roq %p skb %p lbn %u) = void\n", | |
824 | i2400m, roq, skb, lbn); | |
825 | len = skb_queue_len(&roq->queue); | |
826 | nsn = __i2400m_roq_nsn(roq, lbn); | |
827 | if (unlikely(nsn >= 1024)) { | |
828 | dev_err(dev, "SW BUG? queue nsn %d (lbn %u ws %u)\n", | |
829 | nsn, lbn, roq->ws); | |
830 | i2400m_roq_log_dump(i2400m, roq); | |
c931ceeb | 831 | i2400m_reset(i2400m, I2400M_RT_WARM); |
c747583d IPG |
832 | } else { |
833 | __i2400m_roq_queue(i2400m, roq, skb, lbn, nsn); | |
834 | i2400m_roq_log_add(i2400m, roq, I2400M_RO_TYPE_PACKET, | |
835 | roq->ws, len, lbn, nsn, ~0); | |
836 | } | |
837 | d_fnend(2, dev, "(i2400m %p roq %p skb %p lbn %u) = void\n", | |
838 | i2400m, roq, skb, lbn); | |
839 | return; | |
840 | } | |
841 | ||
842 | ||
843 | /* | |
844 | * Update the window start in a reorder queue and deliver all skbs | |
845 | * with a lower window start | |
846 | * | |
847 | * @i2400m: device descriptor | |
848 | * @roq: Reorder queue | |
849 | * @sn: New sequence number | |
850 | */ | |
851 | static | |
852 | void i2400m_roq_update_ws(struct i2400m *i2400m, struct i2400m_roq *roq, | |
853 | unsigned sn) | |
854 | { | |
855 | struct device *dev = i2400m_dev(i2400m); | |
856 | unsigned old_ws, nsn, len; | |
857 | ||
858 | d_fnstart(2, dev, "(i2400m %p roq %p sn %u)\n", i2400m, roq, sn); | |
859 | old_ws = roq->ws; | |
860 | len = skb_queue_len(&roq->queue); | |
861 | nsn = __i2400m_roq_update_ws(i2400m, roq, sn); | |
862 | i2400m_roq_log_add(i2400m, roq, I2400M_RO_TYPE_WS, | |
863 | old_ws, len, sn, nsn, roq->ws); | |
864 | d_fnstart(2, dev, "(i2400m %p roq %p sn %u) = void\n", i2400m, roq, sn); | |
865 | return; | |
866 | } | |
867 | ||
868 | ||
869 | /* | |
870 | * Queue a packet and update the window start | |
871 | * | |
872 | * @i2400m: device descriptor | |
873 | * @cin: Queue Index | |
874 | * @skb: containing the packet data | |
875 | * @fbn: First block number of the packet in @skb | |
876 | * @sn: Last block number of the packet in @skb | |
877 | * | |
878 | * Note that unlike i2400m_roq_update_ws(), which sets the new window | |
879 | * start to @sn, in here we'll set it to @sn + 1. | |
880 | */ | |
881 | static | |
882 | void i2400m_roq_queue_update_ws(struct i2400m *i2400m, struct i2400m_roq *roq, | |
883 | struct sk_buff * skb, unsigned sn) | |
884 | { | |
885 | struct device *dev = i2400m_dev(i2400m); | |
886 | unsigned nsn, old_ws, len; | |
887 | ||
888 | d_fnstart(2, dev, "(i2400m %p roq %p skb %p sn %u)\n", | |
889 | i2400m, roq, skb, sn); | |
890 | len = skb_queue_len(&roq->queue); | |
891 | nsn = __i2400m_roq_nsn(roq, sn); | |
892 | old_ws = roq->ws; | |
893 | if (unlikely(nsn >= 1024)) { | |
894 | dev_err(dev, "SW BUG? queue_update_ws nsn %u (sn %u ws %u)\n", | |
895 | nsn, sn, roq->ws); | |
896 | i2400m_roq_log_dump(i2400m, roq); | |
c931ceeb | 897 | i2400m_reset(i2400m, I2400M_RT_WARM); |
c747583d IPG |
898 | } else { |
899 | /* if the queue is empty, don't bother as we'd queue | |
900 | * it and inmediately unqueue it -- just deliver it */ | |
901 | if (len == 0) { | |
902 | struct i2400m_roq_data *roq_data; | |
903 | roq_data = (struct i2400m_roq_data *) &skb->cb; | |
904 | i2400m_net_erx(i2400m, skb, roq_data->cs); | |
905 | } | |
4e5b6d00 | 906 | else |
c747583d | 907 | __i2400m_roq_queue(i2400m, roq, skb, sn, nsn); |
4e5b6d00 | 908 | __i2400m_roq_update_ws(i2400m, roq, sn + 1); |
c747583d IPG |
909 | i2400m_roq_log_add(i2400m, roq, I2400M_RO_TYPE_PACKET_WS, |
910 | old_ws, len, sn, nsn, roq->ws); | |
911 | } | |
912 | d_fnend(2, dev, "(i2400m %p roq %p skb %p sn %u) = void\n", | |
913 | i2400m, roq, skb, sn); | |
914 | return; | |
915 | } | |
916 | ||
917 | ||
fd5c565c IPG |
918 | /* |
919 | * Receive and send up an extended data packet | |
920 | * | |
921 | * @i2400m: device descriptor | |
922 | * @skb_rx: skb that contains the extended data packet | |
923 | * @single_last: 1 if the payload is the only one or the last one of | |
924 | * the skb. | |
925 | * @payload: pointer to the packet's data inside the skb | |
926 | * @size: size of the payload | |
927 | * | |
928 | * Starting in v1.4 of the i2400m's firmware, the device can send data | |
929 | * packets to the host in an extended format that; this incudes a 16 | |
930 | * byte header (struct i2400m_pl_edata_hdr). Using this header's space | |
931 | * we can fake ethernet headers for ethernet device emulation without | |
932 | * having to copy packets around. | |
933 | * | |
934 | * This function handles said path. | |
c747583d IPG |
935 | * |
936 | * | |
937 | * Receive and send up an extended data packet that requires no reordering | |
938 | * | |
939 | * @i2400m: device descriptor | |
940 | * @skb_rx: skb that contains the extended data packet | |
941 | * @single_last: 1 if the payload is the only one or the last one of | |
942 | * the skb. | |
943 | * @payload: pointer to the packet's data (past the actual extended | |
944 | * data payload header). | |
945 | * @size: size of the payload | |
946 | * | |
947 | * Pass over to the networking stack a data packet that might have | |
948 | * reordering requirements. | |
949 | * | |
950 | * This needs to the decide if the skb in which the packet is | |
951 | * contained can be reused or if it needs to be cloned. Then it has to | |
952 | * be trimmed in the edges so that the beginning is the space for eth | |
953 | * header and then pass it to i2400m_net_erx() for the stack | |
954 | * | |
955 | * Assumes the caller has verified the sanity of the payload (size, | |
956 | * etc) already. | |
fd5c565c IPG |
957 | */ |
958 | static | |
959 | void i2400m_rx_edata(struct i2400m *i2400m, struct sk_buff *skb_rx, | |
960 | unsigned single_last, const void *payload, size_t size) | |
961 | { | |
962 | struct device *dev = i2400m_dev(i2400m); | |
963 | const struct i2400m_pl_edata_hdr *hdr = payload; | |
964 | struct net_device *net_dev = i2400m->wimax_dev.net_dev; | |
965 | struct sk_buff *skb; | |
966 | enum i2400m_cs cs; | |
c747583d IPG |
967 | u32 reorder; |
968 | unsigned ro_needed, ro_type, ro_cin, ro_sn; | |
969 | struct i2400m_roq *roq; | |
970 | struct i2400m_roq_data *roq_data; | |
fd5c565c | 971 | |
c747583d IPG |
972 | BUILD_BUG_ON(ETH_HLEN > sizeof(*hdr)); |
973 | ||
974 | d_fnstart(2, dev, "(i2400m %p skb_rx %p single %u payload %p " | |
fd5c565c IPG |
975 | "size %zu)\n", i2400m, skb_rx, single_last, payload, size); |
976 | if (size < sizeof(*hdr)) { | |
977 | dev_err(dev, "ERX: HW BUG? message with short header (%zu " | |
978 | "vs %zu bytes expected)\n", size, sizeof(*hdr)); | |
979 | goto error; | |
980 | } | |
c747583d | 981 | |
fd5c565c IPG |
982 | if (single_last) { |
983 | skb = skb_get(skb_rx); | |
c747583d | 984 | d_printf(3, dev, "ERX: skb %p reusing\n", skb); |
fd5c565c IPG |
985 | } else { |
986 | skb = skb_clone(skb_rx, GFP_KERNEL); | |
fd5c565c IPG |
987 | if (skb == NULL) { |
988 | dev_err(dev, "ERX: no memory to clone skb\n"); | |
989 | net_dev->stats.rx_dropped++; | |
990 | goto error_skb_clone; | |
991 | } | |
c747583d | 992 | d_printf(3, dev, "ERX: skb %p cloned from %p\n", skb, skb_rx); |
fd5c565c IPG |
993 | } |
994 | /* now we have to pull and trim so that the skb points to the | |
995 | * beginning of the IP packet; the netdev part will add the | |
c747583d IPG |
996 | * ethernet header as needed - we know there is enough space |
997 | * because we checked in i2400m_rx_edata(). */ | |
fd5c565c | 998 | skb_pull(skb, payload + sizeof(*hdr) - (void *) skb->data); |
c747583d IPG |
999 | skb_trim(skb, (void *) skb_end_pointer(skb) - payload - sizeof(*hdr)); |
1000 | ||
1001 | reorder = le32_to_cpu(hdr->reorder); | |
1002 | ro_needed = reorder & I2400M_RO_NEEDED; | |
1003 | cs = hdr->cs; | |
1004 | if (ro_needed) { | |
1005 | ro_type = (reorder >> I2400M_RO_TYPE_SHIFT) & I2400M_RO_TYPE; | |
1006 | ro_cin = (reorder >> I2400M_RO_CIN_SHIFT) & I2400M_RO_CIN; | |
1007 | ro_sn = (reorder >> I2400M_RO_SN_SHIFT) & I2400M_RO_SN; | |
1008 | ||
1009 | roq = &i2400m->rx_roq[ro_cin]; | |
1010 | roq_data = (struct i2400m_roq_data *) &skb->cb; | |
1011 | roq_data->sn = ro_sn; | |
1012 | roq_data->cs = cs; | |
1013 | d_printf(2, dev, "ERX: reorder needed: " | |
1014 | "type %u cin %u [ws %u] sn %u/%u len %zuB\n", | |
1015 | ro_type, ro_cin, roq->ws, ro_sn, | |
1016 | __i2400m_roq_nsn(roq, ro_sn), size); | |
1017 | d_dump(2, dev, payload, size); | |
1018 | switch(ro_type) { | |
1019 | case I2400M_RO_TYPE_RESET: | |
1020 | i2400m_roq_reset(i2400m, roq); | |
1021 | kfree_skb(skb); /* no data here */ | |
1022 | break; | |
1023 | case I2400M_RO_TYPE_PACKET: | |
1024 | i2400m_roq_queue(i2400m, roq, skb, ro_sn); | |
1025 | break; | |
1026 | case I2400M_RO_TYPE_WS: | |
1027 | i2400m_roq_update_ws(i2400m, roq, ro_sn); | |
1028 | kfree_skb(skb); /* no data here */ | |
1029 | break; | |
1030 | case I2400M_RO_TYPE_PACKET_WS: | |
1031 | i2400m_roq_queue_update_ws(i2400m, roq, skb, ro_sn); | |
1032 | break; | |
1033 | default: | |
1034 | dev_err(dev, "HW BUG? unknown reorder type %u\n", ro_type); | |
1035 | } | |
1036 | } | |
1037 | else | |
1038 | i2400m_net_erx(i2400m, skb, cs); | |
fd5c565c IPG |
1039 | error_skb_clone: |
1040 | error: | |
c747583d | 1041 | d_fnend(2, dev, "(i2400m %p skb_rx %p single %u payload %p " |
fd5c565c IPG |
1042 | "size %zu) = void\n", i2400m, skb_rx, single_last, payload, size); |
1043 | return; | |
1044 | } | |
1045 | ||
1046 | ||
aa5a7aca IPG |
1047 | /* |
1048 | * Act on a received payload | |
1049 | * | |
1050 | * @i2400m: device instance | |
1051 | * @skb_rx: skb where the transaction was received | |
fd5c565c IPG |
1052 | * @single_last: 1 this is the only payload or the last one (so the |
1053 | * skb can be reused instead of cloned). | |
aa5a7aca IPG |
1054 | * @pld: payload descriptor |
1055 | * @payload: payload data | |
1056 | * | |
1057 | * Upon reception of a payload, look at its guts in the payload | |
fd5c565c IPG |
1058 | * descriptor and decide what to do with it. If it is a single payload |
1059 | * skb or if the last skb is a data packet, the skb will be referenced | |
1060 | * and modified (so it doesn't have to be cloned). | |
aa5a7aca IPG |
1061 | */ |
1062 | static | |
1063 | void i2400m_rx_payload(struct i2400m *i2400m, struct sk_buff *skb_rx, | |
fd5c565c | 1064 | unsigned single_last, const struct i2400m_pld *pld, |
aa5a7aca IPG |
1065 | const void *payload) |
1066 | { | |
1067 | struct device *dev = i2400m_dev(i2400m); | |
1068 | size_t pl_size = i2400m_pld_size(pld); | |
1069 | enum i2400m_pt pl_type = i2400m_pld_type(pld); | |
1070 | ||
fd5c565c IPG |
1071 | d_printf(7, dev, "RX: received payload type %u, %zu bytes\n", |
1072 | pl_type, pl_size); | |
1073 | d_dump(8, dev, payload, pl_size); | |
1074 | ||
aa5a7aca IPG |
1075 | switch (pl_type) { |
1076 | case I2400M_PT_DATA: | |
1077 | d_printf(3, dev, "RX: data payload %zu bytes\n", pl_size); | |
fd5c565c | 1078 | i2400m_net_rx(i2400m, skb_rx, single_last, payload, pl_size); |
aa5a7aca IPG |
1079 | break; |
1080 | case I2400M_PT_CTRL: | |
1081 | i2400m_rx_ctl(i2400m, skb_rx, payload, pl_size); | |
1082 | break; | |
1083 | case I2400M_PT_TRACE: | |
1084 | i2400m_rx_trace(i2400m, payload, pl_size); | |
1085 | break; | |
fd5c565c IPG |
1086 | case I2400M_PT_EDATA: |
1087 | d_printf(3, dev, "ERX: data payload %zu bytes\n", pl_size); | |
1088 | i2400m_rx_edata(i2400m, skb_rx, single_last, payload, pl_size); | |
1089 | break; | |
aa5a7aca IPG |
1090 | default: /* Anything else shouldn't come to the host */ |
1091 | if (printk_ratelimit()) | |
1092 | dev_err(dev, "RX: HW BUG? unexpected payload type %u\n", | |
1093 | pl_type); | |
1094 | } | |
1095 | } | |
1096 | ||
1097 | ||
1098 | /* | |
1099 | * Check a received transaction's message header | |
1100 | * | |
1101 | * @i2400m: device descriptor | |
1102 | * @msg_hdr: message header | |
1103 | * @buf_size: size of the received buffer | |
1104 | * | |
1105 | * Check that the declarations done by a RX buffer message header are | |
1106 | * sane and consistent with the amount of data that was received. | |
1107 | */ | |
1108 | static | |
1109 | int i2400m_rx_msg_hdr_check(struct i2400m *i2400m, | |
1110 | const struct i2400m_msg_hdr *msg_hdr, | |
1111 | size_t buf_size) | |
1112 | { | |
1113 | int result = -EIO; | |
1114 | struct device *dev = i2400m_dev(i2400m); | |
1115 | if (buf_size < sizeof(*msg_hdr)) { | |
1116 | dev_err(dev, "RX: HW BUG? message with short header (%zu " | |
1117 | "vs %zu bytes expected)\n", buf_size, sizeof(*msg_hdr)); | |
1118 | goto error; | |
1119 | } | |
1120 | if (msg_hdr->barker != cpu_to_le32(I2400M_D2H_MSG_BARKER)) { | |
1121 | dev_err(dev, "RX: HW BUG? message received with unknown " | |
1122 | "barker 0x%08x (buf_size %zu bytes)\n", | |
1123 | le32_to_cpu(msg_hdr->barker), buf_size); | |
1124 | goto error; | |
1125 | } | |
1126 | if (msg_hdr->num_pls == 0) { | |
1127 | dev_err(dev, "RX: HW BUG? zero payload packets in message\n"); | |
1128 | goto error; | |
1129 | } | |
1130 | if (le16_to_cpu(msg_hdr->num_pls) > I2400M_MAX_PLS_IN_MSG) { | |
1131 | dev_err(dev, "RX: HW BUG? message contains more payload " | |
1132 | "than maximum; ignoring.\n"); | |
1133 | goto error; | |
1134 | } | |
1135 | result = 0; | |
1136 | error: | |
1137 | return result; | |
1138 | } | |
1139 | ||
1140 | ||
1141 | /* | |
1142 | * Check a payload descriptor against the received data | |
1143 | * | |
1144 | * @i2400m: device descriptor | |
1145 | * @pld: payload descriptor | |
1146 | * @pl_itr: offset (in bytes) in the received buffer the payload is | |
1147 | * located | |
1148 | * @buf_size: size of the received buffer | |
1149 | * | |
1150 | * Given a payload descriptor (part of a RX buffer), check it is sane | |
1151 | * and that the data it declares fits in the buffer. | |
1152 | */ | |
1153 | static | |
1154 | int i2400m_rx_pl_descr_check(struct i2400m *i2400m, | |
1155 | const struct i2400m_pld *pld, | |
1156 | size_t pl_itr, size_t buf_size) | |
1157 | { | |
1158 | int result = -EIO; | |
1159 | struct device *dev = i2400m_dev(i2400m); | |
1160 | size_t pl_size = i2400m_pld_size(pld); | |
1161 | enum i2400m_pt pl_type = i2400m_pld_type(pld); | |
1162 | ||
1163 | if (pl_size > i2400m->bus_pl_size_max) { | |
1164 | dev_err(dev, "RX: HW BUG? payload @%zu: size %zu is " | |
1165 | "bigger than maximum %zu; ignoring message\n", | |
1166 | pl_itr, pl_size, i2400m->bus_pl_size_max); | |
1167 | goto error; | |
1168 | } | |
1169 | if (pl_itr + pl_size > buf_size) { /* enough? */ | |
1170 | dev_err(dev, "RX: HW BUG? payload @%zu: size %zu " | |
1171 | "goes beyond the received buffer " | |
1172 | "size (%zu bytes); ignoring message\n", | |
1173 | pl_itr, pl_size, buf_size); | |
1174 | goto error; | |
1175 | } | |
1176 | if (pl_type >= I2400M_PT_ILLEGAL) { | |
1177 | dev_err(dev, "RX: HW BUG? illegal payload type %u; " | |
1178 | "ignoring message\n", pl_type); | |
1179 | goto error; | |
1180 | } | |
1181 | result = 0; | |
1182 | error: | |
1183 | return result; | |
1184 | } | |
1185 | ||
1186 | ||
1187 | /** | |
1188 | * i2400m_rx - Receive a buffer of data from the device | |
1189 | * | |
1190 | * @i2400m: device descriptor | |
1191 | * @skb: skbuff where the data has been received | |
1192 | * | |
1193 | * Parse in a buffer of data that contains an RX message sent from the | |
1194 | * device. See the file header for the format. Run all checks on the | |
1195 | * buffer header, then run over each payload's descriptors, verify | |
1196 | * their consistency and act on each payload's contents. If | |
af901ca1 | 1197 | * everything is successful, update the device's statistics. |
aa5a7aca IPG |
1198 | * |
1199 | * Note: You need to set the skb to contain only the length of the | |
1200 | * received buffer; for that, use skb_trim(skb, RECEIVED_SIZE). | |
1201 | * | |
1202 | * Returns: | |
1203 | * | |
1204 | * 0 if ok, < 0 errno on error | |
1205 | * | |
1206 | * If ok, this function owns now the skb and the caller DOESN'T have | |
1207 | * to run kfree_skb() on it. However, on error, the caller still owns | |
1208 | * the skb and it is responsible for releasing it. | |
1209 | */ | |
1210 | int i2400m_rx(struct i2400m *i2400m, struct sk_buff *skb) | |
1211 | { | |
1212 | int i, result; | |
1213 | struct device *dev = i2400m_dev(i2400m); | |
1214 | const struct i2400m_msg_hdr *msg_hdr; | |
1215 | size_t pl_itr, pl_size, skb_len; | |
1216 | unsigned long flags; | |
fd5c565c | 1217 | unsigned num_pls, single_last; |
aa5a7aca IPG |
1218 | |
1219 | skb_len = skb->len; | |
1220 | d_fnstart(4, dev, "(i2400m %p skb %p [size %zu])\n", | |
1221 | i2400m, skb, skb_len); | |
1222 | result = -EIO; | |
1223 | msg_hdr = (void *) skb->data; | |
1224 | result = i2400m_rx_msg_hdr_check(i2400m, msg_hdr, skb->len); | |
1225 | if (result < 0) | |
1226 | goto error_msg_hdr_check; | |
1227 | result = -EIO; | |
1228 | num_pls = le16_to_cpu(msg_hdr->num_pls); | |
1229 | pl_itr = sizeof(*msg_hdr) + /* Check payload descriptor(s) */ | |
1230 | num_pls * sizeof(msg_hdr->pld[0]); | |
8593a196 | 1231 | pl_itr = ALIGN(pl_itr, I2400M_PL_ALIGN); |
aa5a7aca IPG |
1232 | if (pl_itr > skb->len) { /* got all the payload descriptors? */ |
1233 | dev_err(dev, "RX: HW BUG? message too short (%u bytes) for " | |
1234 | "%u payload descriptors (%zu each, total %zu)\n", | |
1235 | skb->len, num_pls, sizeof(msg_hdr->pld[0]), pl_itr); | |
1236 | goto error_pl_descr_short; | |
1237 | } | |
1238 | /* Walk each payload payload--check we really got it */ | |
1239 | for (i = 0; i < num_pls; i++) { | |
1240 | /* work around old gcc warnings */ | |
1241 | pl_size = i2400m_pld_size(&msg_hdr->pld[i]); | |
1242 | result = i2400m_rx_pl_descr_check(i2400m, &msg_hdr->pld[i], | |
1243 | pl_itr, skb->len); | |
1244 | if (result < 0) | |
1245 | goto error_pl_descr_check; | |
fd5c565c IPG |
1246 | single_last = num_pls == 1 || i == num_pls - 1; |
1247 | i2400m_rx_payload(i2400m, skb, single_last, &msg_hdr->pld[i], | |
aa5a7aca | 1248 | skb->data + pl_itr); |
8593a196 | 1249 | pl_itr += ALIGN(pl_size, I2400M_PL_ALIGN); |
aa5a7aca IPG |
1250 | cond_resched(); /* Don't monopolize */ |
1251 | } | |
1252 | kfree_skb(skb); | |
1253 | /* Update device statistics */ | |
1254 | spin_lock_irqsave(&i2400m->rx_lock, flags); | |
1255 | i2400m->rx_pl_num += i; | |
1256 | if (i > i2400m->rx_pl_max) | |
1257 | i2400m->rx_pl_max = i; | |
1258 | if (i < i2400m->rx_pl_min) | |
1259 | i2400m->rx_pl_min = i; | |
1260 | i2400m->rx_num++; | |
1261 | i2400m->rx_size_acc += skb->len; | |
1262 | if (skb->len < i2400m->rx_size_min) | |
1263 | i2400m->rx_size_min = skb->len; | |
1264 | if (skb->len > i2400m->rx_size_max) | |
1265 | i2400m->rx_size_max = skb->len; | |
1266 | spin_unlock_irqrestore(&i2400m->rx_lock, flags); | |
1267 | error_pl_descr_check: | |
1268 | error_pl_descr_short: | |
1269 | error_msg_hdr_check: | |
1270 | d_fnend(4, dev, "(i2400m %p skb %p [size %zu]) = %d\n", | |
1271 | i2400m, skb, skb_len, result); | |
1272 | return result; | |
1273 | } | |
1274 | EXPORT_SYMBOL_GPL(i2400m_rx); | |
c747583d IPG |
1275 | |
1276 | ||
aba3792a IPG |
1277 | void i2400m_unknown_barker(struct i2400m *i2400m, |
1278 | const void *buf, size_t size) | |
1279 | { | |
1280 | struct device *dev = i2400m_dev(i2400m); | |
1281 | char prefix[64]; | |
1282 | const __le32 *barker = buf; | |
1283 | dev_err(dev, "RX: HW BUG? unknown barker %08x, " | |
1284 | "dropping %zu bytes\n", le32_to_cpu(*barker), size); | |
1285 | snprintf(prefix, sizeof(prefix), "%s %s: ", | |
1286 | dev_driver_string(dev), dev_name(dev)); | |
1287 | if (size > 64) { | |
1288 | print_hex_dump(KERN_ERR, prefix, DUMP_PREFIX_OFFSET, | |
1289 | 8, 4, buf, 64, 0); | |
1290 | printk(KERN_ERR "%s... (only first 64 bytes " | |
1291 | "dumped)\n", prefix); | |
1292 | } else | |
1293 | print_hex_dump(KERN_ERR, prefix, DUMP_PREFIX_OFFSET, | |
1294 | 8, 4, buf, size, 0); | |
1295 | } | |
1296 | EXPORT_SYMBOL(i2400m_unknown_barker); | |
1297 | ||
1298 | ||
c747583d IPG |
1299 | /* |
1300 | * Initialize the RX queue and infrastructure | |
1301 | * | |
1302 | * This sets up all the RX reordering infrastructures, which will not | |
1303 | * be used if reordering is not enabled or if the firmware does not | |
1304 | * support it. The device is told to do reordering in | |
1305 | * i2400m_dev_initialize(), where it also looks at the value of the | |
1306 | * i2400m->rx_reorder switch before taking a decission. | |
1307 | * | |
1308 | * Note we allocate the roq queues in one chunk and the actual logging | |
1309 | * support for it (logging) in another one and then we setup the | |
1310 | * pointers from the first to the last. | |
1311 | */ | |
1312 | int i2400m_rx_setup(struct i2400m *i2400m) | |
1313 | { | |
1314 | int result = 0; | |
1315 | struct device *dev = i2400m_dev(i2400m); | |
1316 | ||
1317 | i2400m->rx_reorder = i2400m_rx_reorder_disabled? 0 : 1; | |
1318 | if (i2400m->rx_reorder) { | |
1319 | unsigned itr; | |
1320 | size_t size; | |
1321 | struct i2400m_roq_log *rd; | |
1322 | ||
1323 | result = -ENOMEM; | |
1324 | ||
1325 | size = sizeof(i2400m->rx_roq[0]) * (I2400M_RO_CIN + 1); | |
1326 | i2400m->rx_roq = kzalloc(size, GFP_KERNEL); | |
1327 | if (i2400m->rx_roq == NULL) { | |
1328 | dev_err(dev, "RX: cannot allocate %zu bytes for " | |
1329 | "reorder queues\n", size); | |
1330 | goto error_roq_alloc; | |
1331 | } | |
1332 | ||
1333 | size = sizeof(*i2400m->rx_roq[0].log) * (I2400M_RO_CIN + 1); | |
1334 | rd = kzalloc(size, GFP_KERNEL); | |
1335 | if (rd == NULL) { | |
1336 | dev_err(dev, "RX: cannot allocate %zu bytes for " | |
1337 | "reorder queues log areas\n", size); | |
1338 | result = -ENOMEM; | |
1339 | goto error_roq_log_alloc; | |
1340 | } | |
1341 | ||
1342 | for(itr = 0; itr < I2400M_RO_CIN + 1; itr++) { | |
1343 | __i2400m_roq_init(&i2400m->rx_roq[itr]); | |
1344 | i2400m->rx_roq[itr].log = &rd[itr]; | |
1345 | } | |
1346 | } | |
1347 | return 0; | |
1348 | ||
1349 | error_roq_log_alloc: | |
1350 | kfree(i2400m->rx_roq); | |
1351 | error_roq_alloc: | |
1352 | return result; | |
1353 | } | |
1354 | ||
1355 | ||
1356 | /* Tear down the RX queue and infrastructure */ | |
1357 | void i2400m_rx_release(struct i2400m *i2400m) | |
1358 | { | |
1359 | if (i2400m->rx_reorder) { | |
1360 | unsigned itr; | |
1361 | for(itr = 0; itr < I2400M_RO_CIN + 1; itr++) | |
1362 | __skb_queue_purge(&i2400m->rx_roq[itr].queue); | |
1363 | kfree(i2400m->rx_roq[0].log); | |
1364 | kfree(i2400m->rx_roq); | |
1365 | } | |
a0beba21 IPG |
1366 | /* at this point, nothing can be received... */ |
1367 | i2400m_report_hook_flush(i2400m); | |
c747583d | 1368 | } |