48
48
49
49
#define UETH__VERSION "29-May-2008"
50
50
51
- #define GETHER_NAPI_WEIGHT 32
52
-
53
51
struct eth_dev {
54
52
/* lock is held while accessing port_usb
55
53
*/
@@ -74,7 +72,6 @@ struct eth_dev {
74
72
struct sk_buff_head * list );
75
73
76
74
struct work_struct work ;
77
- struct napi_struct rx_napi ;
78
75
79
76
unsigned long todo ;
80
77
#define WORK_RX_MEMORY 0
@@ -256,16 +253,18 @@ rx_submit(struct eth_dev *dev, struct usb_request *req, gfp_t gfp_flags)
256
253
DBG (dev , "rx submit --> %d\n" , retval );
257
254
if (skb )
258
255
dev_kfree_skb_any (skb );
256
+ spin_lock_irqsave (& dev -> req_lock , flags );
257
+ list_add (& req -> list , & dev -> rx_reqs );
258
+ spin_unlock_irqrestore (& dev -> req_lock , flags );
259
259
}
260
260
return retval ;
261
261
}
262
262
263
263
static void rx_complete (struct usb_ep * ep , struct usb_request * req )
264
264
{
265
- struct sk_buff * skb = req -> context ;
265
+ struct sk_buff * skb = req -> context , * skb2 ;
266
266
struct eth_dev * dev = ep -> driver_data ;
267
267
int status = req -> status ;
268
- bool rx_queue = 0 ;
269
268
270
269
switch (status ) {
271
270
@@ -289,8 +288,30 @@ static void rx_complete(struct usb_ep *ep, struct usb_request *req)
289
288
} else {
290
289
skb_queue_tail (& dev -> rx_frames , skb );
291
290
}
292
- if (!status )
293
- rx_queue = 1 ;
291
+ skb = NULL ;
292
+
293
+ skb2 = skb_dequeue (& dev -> rx_frames );
294
+ while (skb2 ) {
295
+ if (status < 0
296
+ || ETH_HLEN > skb2 -> len
297
+ || skb2 -> len > VLAN_ETH_FRAME_LEN ) {
298
+ dev -> net -> stats .rx_errors ++ ;
299
+ dev -> net -> stats .rx_length_errors ++ ;
300
+ DBG (dev , "rx length %d\n" , skb2 -> len );
301
+ dev_kfree_skb_any (skb2 );
302
+ goto next_frame ;
303
+ }
304
+ skb2 -> protocol = eth_type_trans (skb2 , dev -> net );
305
+ dev -> net -> stats .rx_packets ++ ;
306
+ dev -> net -> stats .rx_bytes += skb2 -> len ;
307
+
308
+ /* no buffer copies needed, unless hardware can't
309
+ * use skb buffers.
310
+ */
311
+ status = netif_rx (skb2 );
312
+ next_frame :
313
+ skb2 = skb_dequeue (& dev -> rx_frames );
314
+ }
294
315
break ;
295
316
296
317
/* software-driven interface shutdown */
@@ -313,20 +334,22 @@ static void rx_complete(struct usb_ep *ep, struct usb_request *req)
313
334
/* FALLTHROUGH */
314
335
315
336
default :
316
- rx_queue = 1 ;
317
- dev_kfree_skb_any (skb );
318
337
dev -> net -> stats .rx_errors ++ ;
319
338
DBG (dev , "rx status %d\n" , status );
320
339
break ;
321
340
}
322
341
342
+ if (skb )
343
+ dev_kfree_skb_any (skb );
344
+ if (!netif_running (dev -> net )) {
323
345
clean :
324
346
spin_lock (& dev -> req_lock );
325
347
list_add (& req -> list , & dev -> rx_reqs );
326
348
spin_unlock (& dev -> req_lock );
327
-
328
- if (rx_queue && likely (napi_schedule_prep (& dev -> rx_napi )))
329
- __napi_schedule (& dev -> rx_napi );
349
+ req = NULL ;
350
+ }
351
+ if (req )
352
+ rx_submit (dev , req , GFP_ATOMIC );
330
353
}
331
354
332
355
static int prealloc (struct list_head * list , struct usb_ep * ep , unsigned n )
@@ -391,24 +414,16 @@ static void rx_fill(struct eth_dev *dev, gfp_t gfp_flags)
391
414
{
392
415
struct usb_request * req ;
393
416
unsigned long flags ;
394
- int rx_counts = 0 ;
395
417
396
418
/* fill unused rxq slots with some skb */
397
419
spin_lock_irqsave (& dev -> req_lock , flags );
398
420
while (!list_empty (& dev -> rx_reqs )) {
399
-
400
- if (++ rx_counts > qlen (dev -> gadget , dev -> qmult ))
401
- break ;
402
-
403
421
req = container_of (dev -> rx_reqs .next ,
404
422
struct usb_request , list );
405
423
list_del_init (& req -> list );
406
424
spin_unlock_irqrestore (& dev -> req_lock , flags );
407
425
408
426
if (rx_submit (dev , req , gfp_flags ) < 0 ) {
409
- spin_lock_irqsave (& dev -> req_lock , flags );
410
- list_add (& req -> list , & dev -> rx_reqs );
411
- spin_unlock_irqrestore (& dev -> req_lock , flags );
412
427
defer_kevent (dev , WORK_RX_MEMORY );
413
428
return ;
414
429
}
@@ -418,41 +433,6 @@ static void rx_fill(struct eth_dev *dev, gfp_t gfp_flags)
418
433
spin_unlock_irqrestore (& dev -> req_lock , flags );
419
434
}
420
435
421
- static int gether_poll (struct napi_struct * napi , int budget )
422
- {
423
- struct eth_dev * dev = container_of (napi , struct eth_dev , rx_napi );
424
- struct sk_buff * skb ;
425
- unsigned int work_done = 0 ;
426
- int status = 0 ;
427
-
428
- while ((skb = skb_dequeue (& dev -> rx_frames ))) {
429
- if (status < 0
430
- || ETH_HLEN > skb -> len
431
- || skb -> len > VLAN_ETH_FRAME_LEN ) {
432
- dev -> net -> stats .rx_errors ++ ;
433
- dev -> net -> stats .rx_length_errors ++ ;
434
- DBG (dev , "rx length %d\n" , skb -> len );
435
- dev_kfree_skb_any (skb );
436
- continue ;
437
- }
438
- skb -> protocol = eth_type_trans (skb , dev -> net );
439
- dev -> net -> stats .rx_packets ++ ;
440
- dev -> net -> stats .rx_bytes += skb -> len ;
441
-
442
- status = netif_rx_ni (skb );
443
- }
444
-
445
- if (netif_running (dev -> net )) {
446
- rx_fill (dev , GFP_KERNEL );
447
- work_done ++ ;
448
- }
449
-
450
- if (work_done < budget )
451
- napi_complete (& dev -> rx_napi );
452
-
453
- return work_done ;
454
- }
455
-
456
436
static void eth_work (struct work_struct * work )
457
437
{
458
438
struct eth_dev * dev = container_of (work , struct eth_dev , work );
@@ -645,7 +625,6 @@ static void eth_start(struct eth_dev *dev, gfp_t gfp_flags)
645
625
/* and open the tx floodgates */
646
626
atomic_set (& dev -> tx_qlen , 0 );
647
627
netif_wake_queue (dev -> net );
648
- napi_enable (& dev -> rx_napi );
649
628
}
650
629
651
630
static int eth_open (struct net_device * net )
@@ -672,7 +651,6 @@ static int eth_stop(struct net_device *net)
672
651
unsigned long flags ;
673
652
674
653
VDBG (dev , "%s\n" , __func__ );
675
- napi_disable (& dev -> rx_napi );
676
654
netif_stop_queue (net );
677
655
678
656
DBG (dev , "stop stats: rx/tx %ld/%ld, errs %ld/%ld\n" ,
@@ -790,7 +768,6 @@ struct eth_dev *gether_setup_name(struct usb_gadget *g,
790
768
return ERR_PTR (- ENOMEM );
791
769
792
770
dev = netdev_priv (net );
793
- netif_napi_add (net , & dev -> rx_napi , gether_poll , GETHER_NAPI_WEIGHT );
794
771
spin_lock_init (& dev -> lock );
795
772
spin_lock_init (& dev -> req_lock );
796
773
INIT_WORK (& dev -> work , eth_work );
@@ -853,7 +830,6 @@ struct net_device *gether_setup_name_default(const char *netname)
853
830
return ERR_PTR (- ENOMEM );
854
831
855
832
dev = netdev_priv (net );
856
- netif_napi_add (net , & dev -> rx_napi , gether_poll , GETHER_NAPI_WEIGHT );
857
833
spin_lock_init (& dev -> lock );
858
834
spin_lock_init (& dev -> req_lock );
859
835
INIT_WORK (& dev -> work , eth_work );
@@ -1137,7 +1113,6 @@ void gether_disconnect(struct gether *link)
1137
1113
{
1138
1114
struct eth_dev * dev = link -> ioport ;
1139
1115
struct usb_request * req ;
1140
- struct sk_buff * skb ;
1141
1116
1142
1117
WARN_ON (!dev );
1143
1118
if (!dev )
@@ -1164,12 +1139,6 @@ void gether_disconnect(struct gether *link)
1164
1139
spin_lock (& dev -> req_lock );
1165
1140
}
1166
1141
spin_unlock (& dev -> req_lock );
1167
-
1168
- spin_lock (& dev -> rx_frames .lock );
1169
- while ((skb = __skb_dequeue (& dev -> rx_frames )))
1170
- dev_kfree_skb_any (skb );
1171
- spin_unlock (& dev -> rx_frames .lock );
1172
-
1173
1142
link -> in_ep -> driver_data = NULL ;
1174
1143
link -> in_ep -> desc = NULL ;
1175
1144
0 commit comments