1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85#include <linux/workqueue.h>
86#include <linux/usb.h>
87#include "i2400m-usb.h"
88
89
90#define D_SUBMODULE rx
91#include "usb-debug-levels.h"
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116static
117size_t i2400mu_rx_size_grow(struct i2400mu *i2400mu)
118{
119 struct device *dev = &i2400mu->usb_iface->dev;
120 size_t rx_size;
121 const size_t max_pkt_size = 512;
122
123 rx_size = 2 * i2400mu->rx_size;
124 if (rx_size % max_pkt_size == 0) {
125 rx_size -= 8;
126 d_printf(1, dev,
127 "RX: expected size grew to %zu [adjusted -8] "
128 "from %zu\n",
129 rx_size, i2400mu->rx_size);
130 } else
131 d_printf(1, dev,
132 "RX: expected size grew to %zu from %zu\n",
133 rx_size, i2400mu->rx_size);
134 return rx_size;
135}
136
137
138static
139void i2400mu_rx_size_maybe_shrink(struct i2400mu *i2400mu)
140{
141 const size_t max_pkt_size = 512;
142 struct device *dev = &i2400mu->usb_iface->dev;
143
144 if (unlikely(i2400mu->rx_size_cnt >= 100
145 && i2400mu->rx_size_auto_shrink)) {
146 size_t avg_rx_size =
147 i2400mu->rx_size_acc / i2400mu->rx_size_cnt;
148 size_t new_rx_size = i2400mu->rx_size / 2;
149 if (avg_rx_size < new_rx_size) {
150 if (new_rx_size % max_pkt_size == 0) {
151 new_rx_size -= 8;
152 d_printf(1, dev,
153 "RX: expected size shrank to %zu "
154 "[adjusted -8] from %zu\n",
155 new_rx_size, i2400mu->rx_size);
156 } else
157 d_printf(1, dev,
158 "RX: expected size shrank to %zu "
159 "from %zu\n",
160 new_rx_size, i2400mu->rx_size);
161 i2400mu->rx_size = new_rx_size;
162 i2400mu->rx_size_cnt = 0;
163 i2400mu->rx_size_acc = i2400mu->rx_size;
164 }
165 }
166}
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190static
191struct sk_buff *i2400mu_rx(struct i2400mu *i2400mu, struct sk_buff *rx_skb)
192{
193 int result = 0;
194 struct device *dev = &i2400mu->usb_iface->dev;
195 int usb_pipe, read_size, rx_size, do_autopm;
196 struct usb_endpoint_descriptor *epd;
197 const size_t max_pkt_size = 512;
198
199 d_fnstart(4, dev, "(i2400mu %p)\n", i2400mu);
200 do_autopm = atomic_read(&i2400mu->do_autopm);
201 result = do_autopm ?
202 usb_autopm_get_interface(i2400mu->usb_iface) : 0;
203 if (result < 0) {
204 dev_err(dev, "RX: can't get autopm: %d\n", result);
205 do_autopm = 0;
206 }
207 epd = usb_get_epd(i2400mu->usb_iface, I2400MU_EP_BULK_IN);
208 usb_pipe = usb_rcvbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress);
209retry:
210 rx_size = skb_end_pointer(rx_skb) - rx_skb->data - rx_skb->len;
211 if (unlikely(rx_size % max_pkt_size == 0)) {
212 rx_size -= 8;
213 d_printf(1, dev, "RX: rx_size adapted to %d [-8]\n", rx_size);
214 }
215 result = usb_bulk_msg(
216 i2400mu->usb_dev, usb_pipe, rx_skb->data + rx_skb->len,
217 rx_size, &read_size, HZ);
218 usb_mark_last_busy(i2400mu->usb_dev);
219 switch (result) {
220 case 0:
221 if (read_size == 0)
222 goto retry;
223 skb_put(rx_skb, read_size);
224 break;
225 case -EINVAL:
226 case -ENODEV:
227 case -ENOENT:
228 case -ESHUTDOWN:
229 case -ECONNRESET:
230 break;
231 case -EOVERFLOW: {
232 struct sk_buff *new_skb;
233 rx_size = i2400mu_rx_size_grow(i2400mu);
234 if (rx_size <= (1 << 16))
235 i2400mu->rx_size = rx_size;
236 else if (printk_ratelimit()) {
237 dev_err(dev, "BUG? rx_size up to %d\n", rx_size);
238 result = -EINVAL;
239 goto out;
240 }
241 skb_put(rx_skb, read_size);
242 new_skb = skb_copy_expand(rx_skb, 0, rx_size - rx_skb->len,
243 GFP_KERNEL);
244 if (new_skb == NULL) {
245 if (printk_ratelimit())
246 dev_err(dev, "RX: Can't reallocate skb to %d; "
247 "RX dropped\n", rx_size);
248 kfree_skb(rx_skb);
249 rx_skb = NULL;
250 goto out;
251 }
252 kfree_skb(rx_skb);
253 rx_skb = new_skb;
254 i2400mu->rx_size_cnt = 0;
255 i2400mu->rx_size_acc = i2400mu->rx_size;
256 d_printf(1, dev, "RX: size changed to %d, received %d, "
257 "copied %d, capacity %ld\n",
258 rx_size, read_size, rx_skb->len,
259 (long) (skb_end_pointer(new_skb) - new_skb->head));
260 goto retry;
261 }
262
263
264
265
266 case -ETIMEDOUT:
267 dev_err(dev, "RX: timeout: %d\n", result);
268 result = 0;
269 break;
270 default:
271 if (edc_inc(&i2400mu->urb_edc,
272 EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME))
273 goto error_reset;
274 dev_err(dev, "RX: error receiving URB: %d, retrying\n", result);
275 goto retry;
276 }
277out:
278 if (do_autopm)
279 usb_autopm_put_interface(i2400mu->usb_iface);
280 d_fnend(4, dev, "(i2400mu %p) = %p\n", i2400mu, rx_skb);
281 return rx_skb;
282
283error_reset:
284 dev_err(dev, "RX: maximum errors in URB exceeded; "
285 "resetting device\n");
286 usb_queue_reset_device(i2400mu->usb_iface);
287 rx_skb = ERR_PTR(result);
288 goto out;
289}
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308static
309int i2400mu_rxd(void *_i2400mu)
310{
311 int result = 0;
312 struct i2400mu *i2400mu = _i2400mu;
313 struct i2400m *i2400m = &i2400mu->i2400m;
314 struct device *dev = &i2400mu->usb_iface->dev;
315 struct net_device *net_dev = i2400m->wimax_dev.net_dev;
316 size_t pending;
317 int rx_size;
318 struct sk_buff *rx_skb;
319
320 d_fnstart(4, dev, "(i2400mu %p)\n", i2400mu);
321 while (1) {
322 d_printf(2, dev, "TX: waiting for messages\n");
323 pending = 0;
324 wait_event_interruptible(
325 i2400mu->rx_wq,
326 (kthread_should_stop()
327 || (pending = atomic_read(&i2400mu->rx_pending_count)))
328 );
329 if (kthread_should_stop())
330 break;
331 if (pending == 0)
332 continue;
333 rx_size = i2400mu->rx_size;
334 d_printf(2, dev, "RX: reading up to %d bytes\n", rx_size);
335 rx_skb = __netdev_alloc_skb(net_dev, rx_size, GFP_KERNEL);
336 if (rx_skb == NULL) {
337 dev_err(dev, "RX: can't allocate skb [%d bytes]\n",
338 rx_size);
339 msleep(50);
340 continue;
341 }
342
343
344 rx_skb = i2400mu_rx(i2400mu, rx_skb);
345 result = PTR_ERR(rx_skb);
346 if (IS_ERR(rx_skb))
347 goto out;
348 atomic_dec(&i2400mu->rx_pending_count);
349 if (rx_skb == NULL || rx_skb->len == 0) {
350
351 kfree_skb(rx_skb);
352 continue;
353 }
354
355
356 i2400mu->rx_size_cnt++;
357 i2400mu->rx_size_acc += rx_skb->len;
358 result = i2400m_rx(i2400m, rx_skb);
359 if (result == -EIO
360 && edc_inc(&i2400mu->urb_edc,
361 EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) {
362 goto error_reset;
363 }
364
365
366 i2400mu_rx_size_maybe_shrink(i2400mu);
367 }
368 result = 0;
369out:
370 d_fnend(4, dev, "(i2400mu %p) = %d\n", i2400mu, result);
371 return result;
372
373error_reset:
374 dev_err(dev, "RX: maximum errors in received buffer exceeded; "
375 "resetting device\n");
376 usb_queue_reset_device(i2400mu->usb_iface);
377 goto out;
378}
379
380
381
382
383
384
385
386
387
388void i2400mu_rx_kick(struct i2400mu *i2400mu)
389{
390 struct i2400m *i2400m = &i2400mu->i2400m;
391 struct device *dev = &i2400mu->usb_iface->dev;
392
393 d_fnstart(3, dev, "(i2400mu %p)\n", i2400m);
394 atomic_inc(&i2400mu->rx_pending_count);
395 wake_up_all(&i2400mu->rx_wq);
396 d_fnend(3, dev, "(i2400m %p) = void\n", i2400m);
397}
398
399
400int i2400mu_rx_setup(struct i2400mu *i2400mu)
401{
402 int result = 0;
403 struct i2400m *i2400m = &i2400mu->i2400m;
404 struct device *dev = &i2400mu->usb_iface->dev;
405 struct wimax_dev *wimax_dev = &i2400m->wimax_dev;
406
407 i2400mu->rx_kthread = kthread_run(i2400mu_rxd, i2400mu, "%s-rx",
408 wimax_dev->name);
409 if (IS_ERR(i2400mu->rx_kthread)) {
410 result = PTR_ERR(i2400mu->rx_kthread);
411 dev_err(dev, "RX: cannot start thread: %d\n", result);
412 }
413 return result;
414}
415
416void i2400mu_rx_release(struct i2400mu *i2400mu)
417{
418 kthread_stop(i2400mu->rx_kthread);
419}
420
421