projects / openwrt / openwrt.git / blob
? search:


fae35b54bec9dfbee16296fd22ee3b083dcd4bd9
[openwrt/openwrt.git] / package / madwifi / patches / 300-napi_polling.patch
1 --- a/ath/if_ath.c
2 +++ b/ath/if_ath.c
3 @@ -184,7 +184,11 @@
4 struct sk_buff *, int, int, u_int64_t);
5 static void ath_setdefantenna(struct ath_softc *, u_int);
6 static struct ath_txq *ath_txq_setup(struct ath_softc *, int, int);
7 -static void ath_rx_tasklet(TQUEUE_ARG);
8 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
9 +static int ath_rx_poll(struct napi_struct *napi, int budget);
10 +#else
11 +static int ath_rx_poll(struct net_device *dev, int *budget);
12 +#endif
13 static int ath_hardstart(struct sk_buff *, struct net_device *);
14 static int ath_mgtstart(struct ieee80211com *, struct sk_buff *);
15 #ifdef ATH_SUPERG_COMP
16 @@ -376,6 +380,9 @@
17 u_int32_t new_clamped_maxtxpower);
18 static u_int32_t ath_get_real_maxtxpower(struct ath_softc *sc);
19
20 +static void ath_poll_disable(struct net_device *dev);
21 +static void ath_poll_enable(struct net_device *dev);
22 +
23 /* calibrate every 30 secs in steady state but check every second at first. */
24 static int ath_calinterval = ATH_SHORT_CALINTERVAL;
25 static int ath_countrycode = CTRY_DEFAULT; /* country code */
26 @@ -547,7 +554,6 @@
27
28 atomic_set(&sc->sc_txbuf_counter, 0);
29
30 - ATH_INIT_TQUEUE(&sc->sc_rxtq, ath_rx_tasklet, dev);
31 ATH_INIT_TQUEUE(&sc->sc_txtq, ath_tx_tasklet, dev);
32 ATH_INIT_TQUEUE(&sc->sc_bmisstq, ath_bmiss_tasklet, dev);
33 ATH_INIT_TQUEUE(&sc->sc_bstucktq, ath_bstuck_tasklet, dev);
34 @@ -821,6 +827,12 @@
35 dev->set_mac_address = ath_set_mac_address;
36 dev->change_mtu = ath_change_mtu;
37 dev->tx_queue_len = ATH_TXBUF - ATH_TXBUF_MGT_RESERVED;
38 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
39 + netif_napi_add(dev, &sc->sc_napi, ath_rx_poll, 64);
40 +#else
41 + dev->poll = ath_rx_poll;
42 + dev->weight = 64;
43 +#endif
44 #ifdef USE_HEADERLEN_RESV
45 dev->hard_header_len += sizeof(struct ieee80211_qosframe) +
46 sizeof(struct llc) +
47 @@ -2220,6 +2232,7 @@
48 (status & HAL_INT_GLOBAL) ? " HAL_INT_GLOBAL" : ""
49 );
50
51 + sc->sc_isr = status;
52 status &= sc->sc_imask; /* discard unasked for bits */
53 /* As soon as we know we have a real interrupt we intend to service,
54 * we will check to see if we need an initial hardware TSF reading.
55 @@ -2277,7 +2290,23 @@
56 }
57 if (status & (HAL_INT_RX | HAL_INT_RXPHY)) {
58 ath_uapsd_processtriggers(sc, hw_tsf);
59 - ATH_SCHEDULE_TQUEUE(&sc->sc_rxtq, &needmark);
60 + sc->sc_isr &= ~HAL_INT_RX;
61 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
62 + if (netif_rx_schedule_prep(dev, &sc->sc_napi))
63 +#else
64 + if (netif_rx_schedule_prep(dev))
65 +#endif
66 + {
67 +#ifndef ATH_PRECISE_TSF
68 + sc->sc_imask &= ~HAL_INT_RX;
69 + ath_hal_intrset(ah, sc->sc_imask);
70 +#endif
71 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
72 + __netif_rx_schedule(dev, &sc->sc_napi);
73 +#else
74 + __netif_rx_schedule(dev);
75 +#endif
76 + }
77 }
78 if (status & HAL_INT_TX) {
79 #ifdef ATH_SUPERG_DYNTURBO
80 @@ -2303,6 +2332,11 @@
81 }
82 }
83 #endif
84 + /* disable transmit interrupt */
85 + sc->sc_isr &= ~HAL_INT_TX;
86 + ath_hal_intrset(ah, sc->sc_imask & ~HAL_INT_TX);
87 + sc->sc_imask &= ~HAL_INT_TX;
88 +
89 ATH_SCHEDULE_TQUEUE(&sc->sc_txtq, &needmark);
90 }
91 if (status & HAL_INT_BMISS) {
92 @@ -2515,6 +2549,7 @@
93 if (sc->sc_tx99 != NULL)
94 sc->sc_tx99->start(sc->sc_tx99);
95 #endif
96 + ath_poll_enable(dev);
97
98 done:
99 ATH_UNLOCK(sc);
100 @@ -2555,6 +2590,9 @@
101 if (sc->sc_tx99 != NULL)
102 sc->sc_tx99->stop(sc->sc_tx99);
103 #endif
104 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
105 + ath_poll_disable(dev);
106 +#endif
107 netif_stop_queue(dev); /* XXX re-enabled by ath_newstate */
108 dev->flags &= ~IFF_RUNNING; /* NB: avoid recursion */
109 ieee80211_stop_running(ic); /* stop all VAPs */
110 @@ -4013,12 +4051,47 @@
111 return ath_keyset(sc, k, mac, vap->iv_bss);
112 }
113
114 +static void ath_poll_disable(struct net_device *dev)
115 +{
116 + struct ath_softc *sc = dev->priv;
117 +
118 + /*
119 + * XXX Using in_softirq is not right since we might
120 + * be called from other soft irq contexts than
121 + * ath_rx_poll
122 + */
123 + if (!in_softirq()) {
124 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
125 + napi_disable(&sc->sc_napi);
126 +#else
127 + netif_poll_disable(dev);
128 +#endif
129 + }
130 +}
131 +
132 +static void ath_poll_enable(struct net_device *dev)
133 +{
134 + struct ath_softc *sc = dev->priv;
135 +
136 + /* NB: see above */
137 + if (!in_softirq()) {
138 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
139 + napi_enable(&sc->sc_napi);
140 +#else
141 + netif_poll_enable(dev);
142 +#endif
143 + }
144 +}
145 +
146 +
147 /*
148 * Block/unblock tx+rx processing while a key change is done.
149 * We assume the caller serializes key management operations
150 * so we only need to worry about synchronization with other
151 * uses that originate in the driver.
152 */
153 +#define IS_UP(_dev) \
154 + (((_dev)->flags & (IFF_RUNNING|IFF_UP)) == (IFF_RUNNING|IFF_UP))
155 static void
156 ath_key_update_begin(struct ieee80211vap *vap)
157 {
158 @@ -4032,14 +4105,9 @@
159 * When called from the rx tasklet we cannot use
160 * tasklet_disable because it will block waiting
161 * for us to complete execution.
162 - *
163 - * XXX Using in_softirq is not right since we might
164 - * be called from other soft irq contexts than
165 - * ath_rx_tasklet.
166 */
167 - if (!in_softirq())
168 - tasklet_disable(&sc->sc_rxtq);
169 - netif_stop_queue(dev);
170 + if (IS_UP(vap->iv_dev))
171 + netif_stop_queue(dev);
172 }
173
174 static void
175 @@ -4051,9 +4119,9 @@
176 #endif
177
178 DPRINTF(sc, ATH_DEBUG_KEYCACHE, "End\n");
179 - netif_wake_queue(dev);
180 - if (!in_softirq()) /* NB: see above */
181 - tasklet_enable(&sc->sc_rxtq);
182 +
183 + if (IS_UP(vap->iv_dev))
184 + netif_wake_queue(dev);
185 }
186
187 /*
188 @@ -6360,15 +6428,25 @@
189 sc->sc_rxotherant = 0;
190 }
191
192 -static void
193 -ath_rx_tasklet(TQUEUE_ARG data)
194 +static int
195 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
196 +ath_rx_poll(struct napi_struct *napi, int budget)
197 +#else
198 +ath_rx_poll(struct net_device *dev, int *budget)
199 +#endif
200 {
201 #define PA2DESC(_sc, _pa) \
202 ((struct ath_desc *)((caddr_t)(_sc)->sc_rxdma.dd_desc + \
203 ((_pa) - (_sc)->sc_rxdma.dd_desc_paddr)))
204 - struct net_device *dev = (struct net_device *)data;
205 - struct ath_buf *bf;
206 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
207 + struct ath_softc *sc = container_of(napi, struct ath_softc, sc_napi);
208 + struct net_device *dev = sc->sc_dev;
209 + u_int rx_limit = budget;
210 +#else
211 struct ath_softc *sc = dev->priv;
212 + u_int rx_limit = min(dev->quota, *budget);
213 +#endif
214 + struct ath_buf *bf;
215 struct ieee80211com *ic = &sc->sc_ic;
216 struct ath_hal *ah = sc ? sc->sc_ah : NULL;
217 struct ath_desc *ds;
218 @@ -6378,8 +6456,10 @@
219 unsigned int len;
220 int type;
221 u_int phyerr;
222 + u_int processed = 0, early_stop = 0;
223
224 DPRINTF(sc, ATH_DEBUG_RX_PROC, "invoked\n");
225 +process_rx_again:
226 do {
227 bf = STAILQ_FIRST(&sc->sc_rxbuf);
228 if (bf == NULL) { /* XXX ??? can this happen */
229 @@ -6403,6 +6483,15 @@
230 /* NB: never process the self-linked entry at the end */
231 break;
232 }
233 +
234 + if (rx_limit-- < 2) {
235 + early_stop = 1;
236 + break;
237 + }
238 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
239 + processed++;
240 +#endif
241 +
242 skb = bf->bf_skb;
243 if (skb == NULL) {
244 EPRINTF(sc, "Dropping; buffer contains NULL skbuff.\n");
245 @@ -6450,6 +6539,7 @@
246 sc->sc_stats.ast_rx_phyerr++;
247 phyerr = rs->rs_phyerr & 0x1f;
248 sc->sc_stats.ast_rx_phy[phyerr]++;
249 + goto rx_next;
250 }
251 if (rs->rs_status & HAL_RXERR_DECRYPT) {
252 /*
253 @@ -6645,9 +6735,43 @@
254 STAILQ_INSERT_TAIL(&sc->sc_rxbuf, bf, bf_list);
255 ATH_RXBUF_UNLOCK_IRQ(sc);
256 } while (ath_rxbuf_init(sc, bf) == 0);
257 + if (!early_stop) {
258 + unsigned long flags;
259 + /* Check if more data is received while we were
260 + * processing the descriptor chain.
261 + */
262 +#ifndef ATH_PRECISE_TSF
263 + local_irq_save(flags);
264 + if (sc->sc_isr & HAL_INT_RX) {
265 + u_int64_t hw_tsf = ath_hal_gettsf64(ah);
266 + sc->sc_isr &= ~HAL_INT_RX;
267 + local_irq_restore(flags);
268 + ath_uapsd_processtriggers(sc, hw_tsf);
269 + goto process_rx_again;
270 + }
271 +#endif
272 +#ifndef ATH_PRECISE_TSF
273 + sc->sc_imask |= HAL_INT_RX;
274 + ath_hal_intrset(ah, sc->sc_imask);
275 + local_irq_restore(flags);
276 +#endif
277 + }
278 +
279 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
280 + netif_rx_complete(dev, napi);
281 +#else
282 + netif_rx_complete(dev);
283 + *budget -= processed;
284 + dev->quota -= processed;
285 +#endif
286
287 /* rx signal state monitoring */
288 ath_hal_rxmonitor(ah, &sc->sc_halstats, &sc->sc_curchan);
289 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
290 + return processed;
291 +#else
292 + return early_stop;
293 +#endif
294 #undef PA2DESC
295 }
296
297 @@ -8298,12 +8422,24 @@
298 {
299 struct net_device *dev = (struct net_device *)data;
300 struct ath_softc *sc = dev->priv;
301 + unsigned long flags;
302
303 +process_tx_again:
304 if (txqactive(sc->sc_ah, 0))
305 ath_tx_processq(sc, &sc->sc_txq[0]);
306 if (txqactive(sc->sc_ah, sc->sc_cabq->axq_qnum))
307 ath_tx_processq(sc, sc->sc_cabq);
308
309 + local_irq_save(flags);
310 + if (sc->sc_isr & HAL_INT_TX) {
311 + sc->sc_isr &= ~HAL_INT_TX;
312 + local_irq_restore(flags);
313 + goto process_tx_again;
314 + }
315 + sc->sc_imask |= HAL_INT_TX;
316 + ath_hal_intrset(sc->sc_ah, sc->sc_imask);
317 + local_irq_restore(flags);
318 +
319 netif_wake_queue(dev);
320
321 if (sc->sc_softled)
322 @@ -8319,7 +8455,9 @@
323 {
324 struct net_device *dev = (struct net_device *)data;
325 struct ath_softc *sc = dev->priv;
326 + unsigned long flags;
327
328 +process_tx_again:
329 /*
330 * Process each active queue.
331 */
332 @@ -8340,6 +8478,16 @@
333 if (sc->sc_uapsdq && txqactive(sc->sc_ah, sc->sc_uapsdq->axq_qnum))
334 ath_tx_processq(sc, sc->sc_uapsdq);
335
336 + local_irq_save(flags);
337 + if (sc->sc_isr & HAL_INT_TX) {
338 + sc->sc_isr &= ~HAL_INT_TX;
339 + local_irq_restore(flags);
340 + goto process_tx_again;
341 + }
342 + sc->sc_imask |= HAL_INT_TX;
343 + ath_hal_intrset(sc->sc_ah, sc->sc_imask);
344 + local_irq_restore(flags);
345 +
346 netif_wake_queue(dev);
347
348 if (sc->sc_softled)
349 @@ -8355,13 +8503,25 @@
350 struct net_device *dev = (struct net_device *)data;
351 struct ath_softc *sc = dev->priv;
352 unsigned int i;
353 + unsigned long flags;
354
355 /* Process each active queue. This includes sc_cabq, sc_xrtq and
356 * sc_uapsdq */
357 +process_tx_again:
358 for (i = 0; i < HAL_NUM_TX_QUEUES; i++)
359 if (ATH_TXQ_SETUP(sc, i) && txqactive(sc->sc_ah, i))
360 ath_tx_processq(sc, &sc->sc_txq[i]);
361
362 + local_irq_save(flags);
363 + if (sc->sc_isr & HAL_INT_TX) {
364 + sc->sc_isr &= ~HAL_INT_TX;
365 + local_irq_restore(flags);
366 + goto process_tx_again;
367 + }
368 + sc->sc_imask |= HAL_INT_TX;
369 + ath_hal_intrset(sc->sc_ah, sc->sc_imask);
370 + local_irq_restore(flags);
371 +
372 netif_wake_queue(dev);
373
374 if (sc->sc_softled)
375 @@ -10296,9 +10456,9 @@
376 dev->mtu = mtu;
377 if ((dev->flags & IFF_RUNNING) && !sc->sc_invalid) {
378 /* NB: the rx buffers may need to be reallocated */
379 - tasklet_disable(&sc->sc_rxtq);
380 + ath_poll_disable(dev);
381 error = ath_reset(dev);
382 - tasklet_enable(&sc->sc_rxtq);
383 + ath_poll_enable(dev);
384 }
385 ATH_UNLOCK(sc);
386
387 --- a/ath/if_athvar.h
388 +++ b/ath/if_athvar.h
389 @@ -53,6 +53,10 @@
390 # include <asm/bitops.h>
391 #endif
392
393 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
394 +#define irqs_disabled() 0
395 +#endif
396 +
397 /*
398 * Deduce if tasklets are available. If not then
399 * fall back to using the immediate work queue.
400 @@ -616,6 +620,9 @@
401 struct ath_softc {
402 struct ieee80211com sc_ic; /* NB: must be first */
403 struct net_device *sc_dev;
404 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
405 + struct napi_struct sc_napi;
406 +#endif
407 void __iomem *sc_iobase; /* address of the device */
408 struct semaphore sc_lock; /* dev-level lock */
409 struct net_device_stats sc_devstats; /* device statistics */
410 @@ -730,7 +737,6 @@
411 struct ath_buf *sc_rxbufcur; /* current rx buffer */
412 u_int32_t *sc_rxlink; /* link ptr in last RX desc */
413 spinlock_t sc_rxbuflock;
414 - struct ATH_TQ_STRUCT sc_rxtq; /* rx intr tasklet */
415 struct ATH_TQ_STRUCT sc_rxorntq; /* rxorn intr tasklet */
416 u_int8_t sc_defant; /* current default antenna */
417 u_int8_t sc_rxotherant; /* RXs on non-default antenna */
418 @@ -745,6 +751,7 @@
419 u_int sc_txintrperiod; /* tx interrupt batching */
420 struct ath_txq sc_txq[HAL_NUM_TX_QUEUES];
421 struct ath_txq *sc_ac2q[WME_NUM_AC]; /* WME AC -> h/w qnum */
422 + HAL_INT sc_isr; /* unmasked ISR state */
423 struct ATH_TQ_STRUCT sc_txtq; /* tx intr tasklet */
424 u_int8_t sc_grppoll_str[GRPPOLL_RATE_STR_LEN];
425 struct ath_descdma sc_bdma; /* beacon descriptors */
426 @@ -858,6 +865,8 @@
427 #define ATH_TXBUF_LOCK_CHECK(_sc)
428 #endif
429
430 +#define ATH_DISABLE_INTR local_irq_disable
431 +#define ATH_ENABLE_INTR local_irq_enable
432
433 #define ATH_RXBUF_LOCK_INIT(_sc) spin_lock_init(&(_sc)->sc_rxbuflock)
434 #define ATH_RXBUF_LOCK_DESTROY(_sc)
435 --- a/net80211/ieee80211_input.c
436 +++ b/net80211/ieee80211_input.c
437 @@ -1198,7 +1198,7 @@
438 /* attach vlan tag */
439 struct ieee80211_node *ni_tmp = SKB_CB(skb)->ni;
440 if (vlan_hwaccel_receive_skb(skb, vap->iv_vlgrp, ni->ni_vlan) == NET_RX_DROP) {
441 - /* If netif_rx dropped the packet because
442 + /* If netif_receive_skb dropped the packet because
443 * device was too busy */
444 if (ni_tmp != NULL) {
445 /* node reference was leaked */
446 @@ -1209,8 +1209,8 @@
447 skb = NULL; /* SKB is no longer ours */
448 } else {
449 struct ieee80211_node *ni_tmp = SKB_CB(skb)->ni;
450 - if (netif_rx(skb) == NET_RX_DROP) {
451 - /* If netif_rx dropped the packet because
452 + if (netif_receive_skb(skb) == NET_RX_DROP) {
453 + /* If netif_receive_skb dropped the packet because
454 * device was too busy */
455 if (ni_tmp != NULL) {
456 /* node reference was leaked */
457 @@ -2322,8 +2322,8 @@
458 skb1->protocol = __constant_htons(0x0019); /* ETH_P_80211_RAW */
459
460 ni_tmp = SKB_CB(skb1)->ni;
461 - if (netif_rx(skb1) == NET_RX_DROP) {
462 - /* If netif_rx dropped the packet because
463 + if (netif_receive_skb(skb1) == NET_RX_DROP) {
464 + /* If netif_receive_skb dropped the packet because
465 * device was too busy */
466 if (ni_tmp != NULL) {
467 /* node reference was leaked */
468 --- a/net80211/ieee80211_monitor.c
469 +++ b/net80211/ieee80211_monitor.c
470 @@ -584,8 +584,8 @@
471 skb1->protocol =
472 __constant_htons(0x0019); /* ETH_P_80211_RAW */
473
474 - if (netif_rx(skb1) == NET_RX_DROP) {
475 - /* If netif_rx dropped the packet because
476 + if (netif_receive_skb(skb1) == NET_RX_DROP) {
477 + /* If netif_receive_skb dropped the packet because
478 * device was too busy, reclaim the ref. in
479 * the skb. */
480 if (SKB_CB(skb1)->ni != NULL)
481 --- a/net80211/ieee80211_skb.c
482 +++ b/net80211/ieee80211_skb.c
483 @@ -73,7 +73,7 @@
484 #undef dev_queue_xmit
485 #undef kfree_skb
486 #undef kfree_skb_fast
487 -#undef netif_rx
488 +#undef netif_receive_skb
489 #undef pskb_copy
490 #undef skb_clone
491 #undef skb_copy
492 @@ -638,8 +638,8 @@
493 grp, vlan_tag);
494 }
495
496 -int netif_rx_debug(struct sk_buff *skb, const char* func, int line) {
497 - return netif_rx(untrack_skb(skb, 0, func, line, __func__, __LINE__));
498 +int netif_receive_skb_debug(struct sk_buff *skb, const char* func, int line) {
499 + return netif_receive_skb(untrack_skb(skb, 0, func, line, __func__, __LINE__));
500 }
501
502 struct sk_buff * alloc_skb_debug(unsigned int length, gfp_t gfp_mask,
503 @@ -760,7 +760,7 @@
504 }
505
506 EXPORT_SYMBOL(vlan_hwaccel_receive_skb_debug);
507 -EXPORT_SYMBOL(netif_rx_debug);
508 +EXPORT_SYMBOL(netif_receive_skb_debug);
509 EXPORT_SYMBOL(alloc_skb_debug);
510 EXPORT_SYMBOL(dev_alloc_skb_debug);
511 EXPORT_SYMBOL(skb_clone_debug);
512 --- a/net80211/ieee80211_skb.h
513 +++ b/net80211/ieee80211_skb.h
514 @@ -116,7 +116,7 @@
515 int vlan_hwaccel_receive_skb_debug(struct sk_buff *skb,
516 struct vlan_group *grp, unsigned short vlan_tag,
517 const char* func, int line);
518 -int netif_rx_debug(struct sk_buff *skb, const char* func, int line);
519 +int netif_receive_skb_debug(struct sk_buff *skb, const char* func, int line);
520 struct sk_buff * alloc_skb_debug(unsigned int length, gfp_t gfp_mask,
521 const char *func, int line);
522 struct sk_buff * dev_alloc_skb_debug(unsigned int length,
523 @@ -151,7 +151,7 @@
524 #undef dev_queue_xmit
525 #undef kfree_skb
526 #undef kfree_skb_fast
527 -#undef netif_rx
528 +#undef netif_receive_skb
529 #undef pskb_copy
530 #undef skb_clone
531 #undef skb_copy
532 @@ -168,8 +168,8 @@
533 skb_copy_expand_debug(_skb, _newheadroom, _newtailroom, _gfp_mask, __func__, __LINE__)
534 #define vlan_hwaccel_receive_skb(_skb, _grp, _tag) \
535 vlan_hwaccel_receive_skb_debug(_skb, _grp, _tag, __func__, __LINE__)
536 -#define netif_rx(_skb) \
537 - netif_rx_debug(_skb, __func__, __LINE__)
538 +#define netif_receive_skb(_skb) \
539 + netif_receive_skb_debug(_skb, __func__, __LINE__)
540 #define alloc_skb(_length, _gfp_mask) \
541 alloc_skb_debug(_length, _gfp_mask, __func__, __LINE__)
542 #define dev_alloc_skb(_length) \
OpenWrt Source Repository