Merge branch 'drivers-platform' into release
[linux-2.6] / drivers / net / wimax / i2400m / usb-rx.c
1 /*
2  * Intel Wireless WiMAX Connection 2400m
3  * USB RX handling
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
42  *
43  *
44  * This handles the RX path on USB.
45  *
46  * When a notification is received that says 'there is RX data ready',
47  * we call i2400mu_rx_kick(); that wakes up the RX kthread, which
48  * reads a buffer from USB and passes it to i2400m_rx() in the generic
49  * handling code. The RX buffer has an specific format that is
50  * described in rx.c.
51  *
52  * We use a kernel thread in a loop because:
53  *
54  *  - we want to be able to call the USB power management get/put
55  *    functions (blocking) before each transaction.
56  *
57  *  - We might get a lot of notifications and we don't want to submit
58  *    a zillion reads; by serializing, we are throttling.
59  *
60  *  - RX data processing can get heavy enough so that it is not
61  *    appropiate for doing it in the USB callback; thus we run it in a
62  *    process context.
63  *
64  * We provide a read buffer of an arbitrary size (short of a page); if
65  * the callback reports -EOVERFLOW, it means it was too small, so we
66  * just double the size and retry (being careful to append, as
67  * sometimes the device provided some data). Every now and then we
68  * check if the average packet size is smaller than the current packet
69  * size and if so, we halve it. At the end, the size of the
70  * preallocated buffer should be following the average received
71  * transaction size, adapting dynamically to it.
72  *
73  * ROADMAP
74  *
75  * i2400mu_rx_kick()               Called from notif.c when we get a
76  *                                 'data ready' notification
77  * i2400mu_rxd()                   Kernel RX daemon
78  *   i2400mu_rx()                  Receive USB data
79  *   i2400m_rx()                   Send data to generic i2400m RX handling
80  *
81  * i2400mu_rx_setup()              called from i2400mu_bus_dev_start()
82  *
83  * i2400mu_rx_release()            called from i2400mu_bus_dev_stop()
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  * Dynamic RX size
95  *
96  * We can't let the rx_size be a multiple of 512 bytes (the RX
97  * endpoint's max packet size). On some USB host controllers (we
98  * haven't been able to fully characterize which), if the device is
99  * about to send (for example) X bytes and we only post a buffer to
100  * receive n*512, it will fail to mark that as babble (so that
101  * i2400mu_rx() [case -EOVERFLOW] can resize the buffer and get the
102  * rest).
103  *
104  * So on growing or shrinking, if it is a multiple of the
105  * maxpacketsize, we remove some (instead of incresing some, so in a
106  * buddy allocator we try to waste less space).
107  *
108  * Note we also need a hook for this on i2400mu_rx() -- when we do the
109  * first read, we are sure we won't hit this spot because
110  * i240mm->rx_size has been set properly. However, if we have to
111  * double because of -EOVERFLOW, when we launch the read to get the
112  * rest of the data, we *have* to make sure that also is not a
113  * multiple of the max_pkt_size.
114  */
115
116 static
117 size_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
138 static
139 void 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  * Receive a message with payloads from the USB bus into an skb
170  *
171  * @i2400mu: USB device descriptor
172  * @rx_skb: skb where to place the received message
173  *
174  * Deals with all the USB-specifics of receiving, dynamically
175  * increasing the buffer size if so needed. Returns the payload in the
176  * skb, ready to process. On a zero-length packet, we retry.
177  *
178  * On soft USB errors, we retry (until they become too frequent and
179  * then are promoted to hard); on hard USB errors, we reset the
180  * device. On other errors (skb realloacation, we just drop it and
181  * hope for the next invocation to solve it).
182  *
183  * Returns: pointer to the skb if ok, ERR_PTR on error.
184  *   NOTE: this function might realloc the skb (if it is too small),
185  *   so always update with the one returned.
186  *   ERR_PTR() is < 0 on error.
187  */
188 static
189 struct sk_buff *i2400mu_rx(struct i2400mu *i2400mu, struct sk_buff *rx_skb)
190 {
191         int result = 0;
192         struct device *dev = &i2400mu->usb_iface->dev;
193         int usb_pipe, read_size, rx_size, do_autopm;
194         struct usb_endpoint_descriptor *epd;
195         const size_t max_pkt_size = 512;
196
197         d_fnstart(4, dev, "(i2400mu %p)\n", i2400mu);
198         do_autopm = atomic_read(&i2400mu->do_autopm);
199         result = do_autopm ?
200                 usb_autopm_get_interface(i2400mu->usb_iface) : 0;
201         if (result < 0) {
202                 dev_err(dev, "RX: can't get autopm: %d\n", result);
203                 do_autopm = 0;
204         }
205         epd = usb_get_epd(i2400mu->usb_iface, I2400MU_EP_BULK_IN);
206         usb_pipe = usb_rcvbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress);
207 retry:
208         rx_size = skb_end_pointer(rx_skb) - rx_skb->data - rx_skb->len;
209         if (unlikely(rx_size % max_pkt_size == 0)) {
210                 rx_size -= 8;
211                 d_printf(1, dev, "RX: rx_size adapted to %d [-8]\n", rx_size);
212         }
213         result = usb_bulk_msg(
214                 i2400mu->usb_dev, usb_pipe, rx_skb->data + rx_skb->len,
215                 rx_size, &read_size, HZ);
216         usb_mark_last_busy(i2400mu->usb_dev);
217         switch (result) {
218         case 0:
219                 if (read_size == 0)
220                         goto retry;     /* ZLP, just resubmit */
221                 skb_put(rx_skb, read_size);
222                 break;
223         case -EINVAL:                   /* while removing driver */
224         case -ENODEV:                   /* dev disconnect ... */
225         case -ENOENT:                   /* just ignore it */
226         case -ESHUTDOWN:
227         case -ECONNRESET:
228                 break;
229         case -EOVERFLOW: {              /* too small, reallocate */
230                 struct sk_buff *new_skb;
231                 rx_size = i2400mu_rx_size_grow(i2400mu);
232                 if (rx_size <= (1 << 16))       /* cap it */
233                         i2400mu->rx_size = rx_size;
234                 else if (printk_ratelimit()) {
235                         dev_err(dev, "BUG? rx_size up to %d\n", rx_size);
236                         result = -EINVAL;
237                         goto out;
238                 }
239                 skb_put(rx_skb, read_size);
240                 new_skb = skb_copy_expand(rx_skb, 0, rx_size - rx_skb->len,
241                                           GFP_KERNEL);
242                 if (new_skb == NULL) {
243                         if (printk_ratelimit())
244                                 dev_err(dev, "RX: Can't reallocate skb to %d; "
245                                         "RX dropped\n", rx_size);
246                         kfree(rx_skb);
247                         result = 0;
248                         goto out;       /* drop it...*/
249                 }
250                 kfree_skb(rx_skb);
251                 rx_skb = new_skb;
252                 i2400mu->rx_size_cnt = 0;
253                 i2400mu->rx_size_acc = i2400mu->rx_size;
254                 d_printf(1, dev, "RX: size changed to %d, received %d, "
255                          "copied %d, capacity %ld\n",
256                          rx_size, read_size, rx_skb->len,
257                          (long) (skb_end_pointer(new_skb) - new_skb->head));
258                 goto retry;
259         }
260                 /* In most cases, it happens due to the hardware scheduling a
261                  * read when there was no data - unfortunately, we have no way
262                  * to tell this timeout from a USB timeout. So we just ignore
263                  * it. */
264         case -ETIMEDOUT:
265                 dev_err(dev, "RX: timeout: %d\n", result);
266                 result = 0;
267                 break;
268         default:                        /* Any error */
269                 if (edc_inc(&i2400mu->urb_edc,
270                             EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME))
271                         goto error_reset;
272                 dev_err(dev, "RX: error receiving URB: %d, retrying\n", result);
273                 goto retry;
274         }
275 out:
276         if (do_autopm)
277                 usb_autopm_put_interface(i2400mu->usb_iface);
278         d_fnend(4, dev, "(i2400mu %p) = %p\n", i2400mu, rx_skb);
279         return rx_skb;
280
281 error_reset:
282         dev_err(dev, "RX: maximum errors in URB exceeded; "
283                 "resetting device\n");
284         usb_queue_reset_device(i2400mu->usb_iface);
285         rx_skb = ERR_PTR(result);
286         goto out;
287 }
288
289
290 /*
291  * Kernel thread for USB reception of data
292  *
293  * This thread waits for a kick; once kicked, it will allocate an skb
294  * and receive a single message to it from USB (using
295  * i2400mu_rx()). Once received, it is passed to the generic i2400m RX
296  * code for processing.
297  *
298  * When done processing, it runs some dirty statistics to verify if
299  * the last 100 messages received were smaller than half of the
300  * current RX buffer size. In that case, the RX buffer size is
301  * halved. This will helps lowering the pressure on the memory
302  * allocator.
303  *
304  * Hard errors force the thread to exit.
305  */
306 static
307 int i2400mu_rxd(void *_i2400mu)
308 {
309         int result = 0;
310         struct i2400mu *i2400mu = _i2400mu;
311         struct i2400m *i2400m = &i2400mu->i2400m;
312         struct device *dev = &i2400mu->usb_iface->dev;
313         struct net_device *net_dev = i2400m->wimax_dev.net_dev;
314         size_t pending;
315         int rx_size;
316         struct sk_buff *rx_skb;
317
318         d_fnstart(4, dev, "(i2400mu %p)\n", i2400mu);
319         while (1) {
320                 d_printf(2, dev, "TX: waiting for messages\n");
321                 pending = 0;
322                 wait_event_interruptible(
323                         i2400mu->rx_wq,
324                         (kthread_should_stop()  /* check this first! */
325                          || (pending = atomic_read(&i2400mu->rx_pending_count)))
326                         );
327                 if (kthread_should_stop())
328                         break;
329                 if (pending == 0)
330                         continue;
331                 rx_size = i2400mu->rx_size;
332                 d_printf(2, dev, "RX: reading up to %d bytes\n", rx_size);
333                 rx_skb = __netdev_alloc_skb(net_dev, rx_size, GFP_KERNEL);
334                 if (rx_skb == NULL) {
335                         dev_err(dev, "RX: can't allocate skb [%d bytes]\n",
336                                 rx_size);
337                         msleep(50);     /* give it some time? */
338                         continue;
339                 }
340
341                 /* Receive the message with the payloads */
342                 rx_skb = i2400mu_rx(i2400mu, rx_skb);
343                 result = PTR_ERR(rx_skb);
344                 if (IS_ERR(rx_skb))
345                         goto out;
346                 atomic_dec(&i2400mu->rx_pending_count);
347                 if (rx_skb->len == 0) { /* some ignorable condition */
348                         kfree_skb(rx_skb);
349                         continue;
350                 }
351
352                 /* Deliver the message to the generic i2400m code */
353                 i2400mu->rx_size_cnt++;
354                 i2400mu->rx_size_acc += rx_skb->len;
355                 result = i2400m_rx(i2400m, rx_skb);
356                 if (result == -EIO
357                     && edc_inc(&i2400mu->urb_edc,
358                                EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) {
359                         goto error_reset;
360                 }
361
362                 /* Maybe adjust RX buffer size */
363                 i2400mu_rx_size_maybe_shrink(i2400mu);
364         }
365         result = 0;
366 out:
367         d_fnend(4, dev, "(i2400mu %p) = %d\n", i2400mu, result);
368         return result;
369
370 error_reset:
371         dev_err(dev, "RX: maximum errors in received buffer exceeded; "
372                 "resetting device\n");
373         usb_queue_reset_device(i2400mu->usb_iface);
374         goto out;
375 }
376
377
378 /*
379  * Start reading from the device
380  *
381  * @i2400m: device instance
382  *
383  * Notify the RX thread that there is data pending.
384  */
385 void i2400mu_rx_kick(struct i2400mu *i2400mu)
386 {
387         struct i2400m *i2400m = &i2400mu->i2400m;
388         struct device *dev = &i2400mu->usb_iface->dev;
389
390         d_fnstart(3, dev, "(i2400mu %p)\n", i2400m);
391         atomic_inc(&i2400mu->rx_pending_count);
392         wake_up_all(&i2400mu->rx_wq);
393         d_fnend(3, dev, "(i2400m %p) = void\n", i2400m);
394 }
395
396
397 int i2400mu_rx_setup(struct i2400mu *i2400mu)
398 {
399         int result = 0;
400         struct i2400m *i2400m = &i2400mu->i2400m;
401         struct device *dev = &i2400mu->usb_iface->dev;
402         struct wimax_dev *wimax_dev = &i2400m->wimax_dev;
403
404         i2400mu->rx_kthread = kthread_run(i2400mu_rxd, i2400mu, "%s-rx",
405                                           wimax_dev->name);
406         if (IS_ERR(i2400mu->rx_kthread)) {
407                 result = PTR_ERR(i2400mu->rx_kthread);
408                 dev_err(dev, "RX: cannot start thread: %d\n", result);
409         }
410         return result;
411 }
412
413 void i2400mu_rx_release(struct i2400mu *i2400mu)
414 {
415         kthread_stop(i2400mu->rx_kthread);
416 }
417