aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/ethernet/freescale
diff options
context:
space:
mode:
authorChristophe Leroy <christophe.leroy@c-s.fr>2016-09-09 08:26:21 -0400
committerDavid S. Miller <davem@davemloft.net>2016-09-11 00:17:13 -0400
commit8572763af48728561f8bf708b6c0ea9f4db5929e (patch)
tree2bce5c80ae4452092c2e08a9f054296a3af65f24 /drivers/net/ethernet/freescale
parentd1ba24feb466dfd23734e963912ca2e422e6e214 (diff)
net: fs_enet: merge NAPI RX and NAPI TX
Initially, a NAPI TX routine has been implemented separately from NAPI RX, as done on the freescale/gianfar driver. By merging NAPI RX and NAPI TX, we reduce the amount of TX completion interrupts. Handling of the budget in association with TX interrupts is based on indications provided at https://wiki.linuxfoundation.org/networking/napi We never proceed more than the complete TX ring on a single run. At the same time, we fix an issue in the handling of fep->tx_free: It is only when fep->tx_free goes up to MAX_SKB_FRAGS that we need to wake up the queue. There is no need to call netif_wake_queue() at every packet successfully transmitted. Signed-off-by: Christophe Leroy <christophe.leroy@c-s.fr> Signed-off-by: David S. Miller <davem@davemloft.net>
Diffstat (limited to 'drivers/net/ethernet/freescale')
-rw-r--r--drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c268
-rw-r--r--drivers/net/ethernet/freescale/fs_enet/fs_enet.h16
-rw-r--r--drivers/net/ethernet/freescale/fs_enet/mac-fcc.c57
-rw-r--r--drivers/net/ethernet/freescale/fs_enet/mac-fec.c57
-rw-r--r--drivers/net/ethernet/freescale/fs_enet/mac-scc.c57
5 files changed, 160 insertions, 295 deletions
diff --git a/drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c b/drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c
index 61fd486c50bb..37574a97a61c 100644
--- a/drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c
+++ b/drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c
@@ -60,6 +60,9 @@ module_param(fs_enet_debug, int, 0);
60MODULE_PARM_DESC(fs_enet_debug, 60MODULE_PARM_DESC(fs_enet_debug,
61 "Freescale bitmapped debugging message enable value"); 61 "Freescale bitmapped debugging message enable value");
62 62
63#define RX_RING_SIZE 32
64#define TX_RING_SIZE 64
65
63#ifdef CONFIG_NET_POLL_CONTROLLER 66#ifdef CONFIG_NET_POLL_CONTROLLER
64static void fs_enet_netpoll(struct net_device *dev); 67static void fs_enet_netpoll(struct net_device *dev);
65#endif 68#endif
@@ -79,8 +82,8 @@ static void skb_align(struct sk_buff *skb, int align)
79 skb_reserve(skb, align - off); 82 skb_reserve(skb, align - off);
80} 83}
81 84
82/* NAPI receive function */ 85/* NAPI function */
83static int fs_enet_rx_napi(struct napi_struct *napi, int budget) 86static int fs_enet_napi(struct napi_struct *napi, int budget)
84{ 87{
85 struct fs_enet_private *fep = container_of(napi, struct fs_enet_private, napi); 88 struct fs_enet_private *fep = container_of(napi, struct fs_enet_private, napi);
86 struct net_device *dev = fep->ndev; 89 struct net_device *dev = fep->ndev;
@@ -90,9 +93,102 @@ static int fs_enet_rx_napi(struct napi_struct *napi, int budget)
90 int received = 0; 93 int received = 0;
91 u16 pkt_len, sc; 94 u16 pkt_len, sc;
92 int curidx; 95 int curidx;
96 int dirtyidx, do_wake, do_restart;
97 int tx_left = TX_RING_SIZE;
93 98
94 if (budget <= 0) 99 spin_lock(&fep->tx_lock);
95 return received; 100 bdp = fep->dirty_tx;
101
102 /* clear status bits for napi*/
103 (*fep->ops->napi_clear_event)(dev);
104
105 do_wake = do_restart = 0;
106 while (((sc = CBDR_SC(bdp)) & BD_ENET_TX_READY) == 0 && tx_left) {
107 dirtyidx = bdp - fep->tx_bd_base;
108
109 if (fep->tx_free == fep->tx_ring)
110 break;
111
112 skb = fep->tx_skbuff[dirtyidx];
113
114 /*
115 * Check for errors.
116 */
117 if (sc & (BD_ENET_TX_HB | BD_ENET_TX_LC |
118 BD_ENET_TX_RL | BD_ENET_TX_UN | BD_ENET_TX_CSL)) {
119
120 if (sc & BD_ENET_TX_HB) /* No heartbeat */
121 fep->stats.tx_heartbeat_errors++;
122 if (sc & BD_ENET_TX_LC) /* Late collision */
123 fep->stats.tx_window_errors++;
124 if (sc & BD_ENET_TX_RL) /* Retrans limit */
125 fep->stats.tx_aborted_errors++;
126 if (sc & BD_ENET_TX_UN) /* Underrun */
127 fep->stats.tx_fifo_errors++;
128 if (sc & BD_ENET_TX_CSL) /* Carrier lost */
129 fep->stats.tx_carrier_errors++;
130
131 if (sc & (BD_ENET_TX_LC | BD_ENET_TX_RL | BD_ENET_TX_UN)) {
132 fep->stats.tx_errors++;
133 do_restart = 1;
134 }
135 } else
136 fep->stats.tx_packets++;
137
138 if (sc & BD_ENET_TX_READY) {
139 dev_warn(fep->dev,
140 "HEY! Enet xmit interrupt and TX_READY.\n");
141 }
142
143 /*
144 * Deferred means some collisions occurred during transmit,
145 * but we eventually sent the packet OK.
146 */
147 if (sc & BD_ENET_TX_DEF)
148 fep->stats.collisions++;
149
150 /* unmap */
151 if (fep->mapped_as_page[dirtyidx])
152 dma_unmap_page(fep->dev, CBDR_BUFADDR(bdp),
153 CBDR_DATLEN(bdp), DMA_TO_DEVICE);
154 else
155 dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
156 CBDR_DATLEN(bdp), DMA_TO_DEVICE);
157
158 /*
159 * Free the sk buffer associated with this last transmit.
160 */
161 if (skb) {
162 dev_kfree_skb(skb);
163 fep->tx_skbuff[dirtyidx] = NULL;
164 }
165
166 /*
167 * Update pointer to next buffer descriptor to be transmitted.
168 */
169 if ((sc & BD_ENET_TX_WRAP) == 0)
170 bdp++;
171 else
172 bdp = fep->tx_bd_base;
173
174 /*
175 * Since we have freed up a buffer, the ring is no longer
176 * full.
177 */
178 if (++fep->tx_free == MAX_SKB_FRAGS)
179 do_wake = 1;
180 tx_left--;
181 }
182
183 fep->dirty_tx = bdp;
184
185 if (do_restart)
186 (*fep->ops->tx_restart)(dev);
187
188 spin_unlock(&fep->tx_lock);
189
190 if (do_wake)
191 netif_wake_queue(dev);
96 192
97 /* 193 /*
98 * First, grab all of the stats for the incoming packet. 194 * First, grab all of the stats for the incoming packet.
@@ -100,10 +196,8 @@ static int fs_enet_rx_napi(struct napi_struct *napi, int budget)
100 */ 196 */
101 bdp = fep->cur_rx; 197 bdp = fep->cur_rx;
102 198
103 /* clear RX status bits for napi*/ 199 while (((sc = CBDR_SC(bdp)) & BD_ENET_RX_EMPTY) == 0 &&
104 (*fep->ops->napi_clear_rx_event)(dev); 200 received < budget) {
105
106 while (((sc = CBDR_SC(bdp)) & BD_ENET_RX_EMPTY) == 0) {
107 curidx = bdp - fep->rx_bd_base; 201 curidx = bdp - fep->rx_bd_base;
108 202
109 /* 203 /*
@@ -197,134 +291,19 @@ static int fs_enet_rx_napi(struct napi_struct *napi, int budget)
197 bdp = fep->rx_bd_base; 291 bdp = fep->rx_bd_base;
198 292
199 (*fep->ops->rx_bd_done)(dev); 293 (*fep->ops->rx_bd_done)(dev);
200
201 if (received >= budget)
202 break;
203 } 294 }
204 295
205 fep->cur_rx = bdp; 296 fep->cur_rx = bdp;
206 297
207 if (received < budget) { 298 if (received < budget && tx_left) {
208 /* done */ 299 /* done */
209 napi_complete(napi); 300 napi_complete(napi);
210 (*fep->ops->napi_enable_rx)(dev); 301 (*fep->ops->napi_enable)(dev);
211 }
212 return received;
213}
214 302
215static int fs_enet_tx_napi(struct napi_struct *napi, int budget) 303 return received;
216{
217 struct fs_enet_private *fep = container_of(napi, struct fs_enet_private,
218 napi_tx);
219 struct net_device *dev = fep->ndev;
220 cbd_t __iomem *bdp;
221 struct sk_buff *skb;
222 int dirtyidx, do_wake, do_restart;
223 u16 sc;
224 int has_tx_work = 0;
225
226 spin_lock(&fep->tx_lock);
227 bdp = fep->dirty_tx;
228
229 /* clear TX status bits for napi*/
230 (*fep->ops->napi_clear_tx_event)(dev);
231
232 do_wake = do_restart = 0;
233 while (((sc = CBDR_SC(bdp)) & BD_ENET_TX_READY) == 0) {
234 dirtyidx = bdp - fep->tx_bd_base;
235
236 if (fep->tx_free == fep->tx_ring)
237 break;
238
239 skb = fep->tx_skbuff[dirtyidx];
240
241 /*
242 * Check for errors.
243 */
244 if (sc & (BD_ENET_TX_HB | BD_ENET_TX_LC |
245 BD_ENET_TX_RL | BD_ENET_TX_UN | BD_ENET_TX_CSL)) {
246
247 if (sc & BD_ENET_TX_HB) /* No heartbeat */
248 fep->stats.tx_heartbeat_errors++;
249 if (sc & BD_ENET_TX_LC) /* Late collision */
250 fep->stats.tx_window_errors++;
251 if (sc & BD_ENET_TX_RL) /* Retrans limit */
252 fep->stats.tx_aborted_errors++;
253 if (sc & BD_ENET_TX_UN) /* Underrun */
254 fep->stats.tx_fifo_errors++;
255 if (sc & BD_ENET_TX_CSL) /* Carrier lost */
256 fep->stats.tx_carrier_errors++;
257
258 if (sc & (BD_ENET_TX_LC | BD_ENET_TX_RL | BD_ENET_TX_UN)) {
259 fep->stats.tx_errors++;
260 do_restart = 1;
261 }
262 } else
263 fep->stats.tx_packets++;
264
265 if (sc & BD_ENET_TX_READY) {
266 dev_warn(fep->dev,
267 "HEY! Enet xmit interrupt and TX_READY.\n");
268 }
269
270 /*
271 * Deferred means some collisions occurred during transmit,
272 * but we eventually sent the packet OK.
273 */
274 if (sc & BD_ENET_TX_DEF)
275 fep->stats.collisions++;
276
277 /* unmap */
278 if (fep->mapped_as_page[dirtyidx])
279 dma_unmap_page(fep->dev, CBDR_BUFADDR(bdp),
280 CBDR_DATLEN(bdp), DMA_TO_DEVICE);
281 else
282 dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
283 CBDR_DATLEN(bdp), DMA_TO_DEVICE);
284
285 /*
286 * Free the sk buffer associated with this last transmit.
287 */
288 if (skb) {
289 dev_kfree_skb(skb);
290 fep->tx_skbuff[dirtyidx] = NULL;
291 }
292
293 /*
294 * Update pointer to next buffer descriptor to be transmitted.
295 */
296 if ((sc & BD_ENET_TX_WRAP) == 0)
297 bdp++;
298 else
299 bdp = fep->tx_bd_base;
300
301 /*
302 * Since we have freed up a buffer, the ring is no longer
303 * full.
304 */
305 if (++fep->tx_free >= MAX_SKB_FRAGS)
306 do_wake = 1;
307 has_tx_work = 1;
308 }
309
310 fep->dirty_tx = bdp;
311
312 if (do_restart)
313 (*fep->ops->tx_restart)(dev);
314
315 if (!has_tx_work) {
316 napi_complete(napi);
317 (*fep->ops->napi_enable_tx)(dev);
318 } 304 }
319 305
320 spin_unlock(&fep->tx_lock); 306 return budget;
321
322 if (do_wake)
323 netif_wake_queue(dev);
324
325 if (has_tx_work)
326 return budget;
327 return 0;
328} 307}
329 308
330/* 309/*
@@ -350,18 +329,18 @@ fs_enet_interrupt(int irq, void *dev_id)
350 nr++; 329 nr++;
351 330
352 int_clr_events = int_events; 331 int_clr_events = int_events;
353 int_clr_events &= ~fep->ev_napi_rx; 332 int_clr_events &= ~fep->ev_napi;
354 333
355 (*fep->ops->clear_int_events)(dev, int_clr_events); 334 (*fep->ops->clear_int_events)(dev, int_clr_events);
356 335
357 if (int_events & fep->ev_err) 336 if (int_events & fep->ev_err)
358 (*fep->ops->ev_error)(dev, int_events); 337 (*fep->ops->ev_error)(dev, int_events);
359 338
360 if (int_events & fep->ev_rx) { 339 if (int_events & fep->ev) {
361 napi_ok = napi_schedule_prep(&fep->napi); 340 napi_ok = napi_schedule_prep(&fep->napi);
362 341
363 (*fep->ops->napi_disable_rx)(dev); 342 (*fep->ops->napi_disable)(dev);
364 (*fep->ops->clear_int_events)(dev, fep->ev_napi_rx); 343 (*fep->ops->clear_int_events)(dev, fep->ev_napi);
365 344
366 /* NOTE: it is possible for FCCs in NAPI mode */ 345 /* NOTE: it is possible for FCCs in NAPI mode */
367 /* to submit a spurious interrupt while in poll */ 346 /* to submit a spurious interrupt while in poll */
@@ -369,17 +348,6 @@ fs_enet_interrupt(int irq, void *dev_id)
369 __napi_schedule(&fep->napi); 348 __napi_schedule(&fep->napi);
370 } 349 }
371 350
372 if (int_events & fep->ev_tx) {
373 napi_ok = napi_schedule_prep(&fep->napi_tx);
374
375 (*fep->ops->napi_disable_tx)(dev);
376 (*fep->ops->clear_int_events)(dev, fep->ev_napi_tx);
377
378 /* NOTE: it is possible for FCCs in NAPI mode */
379 /* to submit a spurious interrupt while in poll */
380 if (napi_ok)
381 __napi_schedule(&fep->napi_tx);
382 }
383 } 351 }
384 352
385 handled = nr > 0; 353 handled = nr > 0;
@@ -659,7 +627,8 @@ static void fs_timeout(struct net_device *dev)
659 } 627 }
660 628
661 phy_start(dev->phydev); 629 phy_start(dev->phydev);
662 wake = fep->tx_free && !(CBDR_SC(fep->cur_tx) & BD_ENET_TX_READY); 630 wake = fep->tx_free >= MAX_SKB_FRAGS &&
631 !(CBDR_SC(fep->cur_tx) & BD_ENET_TX_READY);
663 spin_unlock_irqrestore(&fep->lock, flags); 632 spin_unlock_irqrestore(&fep->lock, flags);
664 633
665 if (wake) 634 if (wake)
@@ -751,11 +720,10 @@ static int fs_enet_open(struct net_device *dev)
751 int err; 720 int err;
752 721
753 /* to initialize the fep->cur_rx,... */ 722 /* to initialize the fep->cur_rx,... */
754 /* not doing this, will cause a crash in fs_enet_rx_napi */ 723 /* not doing this, will cause a crash in fs_enet_napi */
755 fs_init_bds(fep->ndev); 724 fs_init_bds(fep->ndev);
756 725
757 napi_enable(&fep->napi); 726 napi_enable(&fep->napi);
758 napi_enable(&fep->napi_tx);
759 727
760 /* Install our interrupt handler. */ 728 /* Install our interrupt handler. */
761 r = request_irq(fep->interrupt, fs_enet_interrupt, IRQF_SHARED, 729 r = request_irq(fep->interrupt, fs_enet_interrupt, IRQF_SHARED,
@@ -763,7 +731,6 @@ static int fs_enet_open(struct net_device *dev)
763 if (r != 0) { 731 if (r != 0) {
764 dev_err(fep->dev, "Could not allocate FS_ENET IRQ!"); 732 dev_err(fep->dev, "Could not allocate FS_ENET IRQ!");
765 napi_disable(&fep->napi); 733 napi_disable(&fep->napi);
766 napi_disable(&fep->napi_tx);
767 return -EINVAL; 734 return -EINVAL;
768 } 735 }
769 736
@@ -771,7 +738,6 @@ static int fs_enet_open(struct net_device *dev)
771 if (err) { 738 if (err) {
772 free_irq(fep->interrupt, dev); 739 free_irq(fep->interrupt, dev);
773 napi_disable(&fep->napi); 740 napi_disable(&fep->napi);
774 napi_disable(&fep->napi_tx);
775 return err; 741 return err;
776 } 742 }
777 phy_start(dev->phydev); 743 phy_start(dev->phydev);
@@ -789,7 +755,6 @@ static int fs_enet_close(struct net_device *dev)
789 netif_stop_queue(dev); 755 netif_stop_queue(dev);
790 netif_carrier_off(dev); 756 netif_carrier_off(dev);
791 napi_disable(&fep->napi); 757 napi_disable(&fep->napi);
792 napi_disable(&fep->napi_tx);
793 phy_stop(dev->phydev); 758 phy_stop(dev->phydev);
794 759
795 spin_lock_irqsave(&fep->lock, flags); 760 spin_lock_irqsave(&fep->lock, flags);
@@ -939,8 +904,8 @@ static int fs_enet_probe(struct platform_device *ofdev)
939 fpi->cp_command = *data; 904 fpi->cp_command = *data;
940 } 905 }
941 906
942 fpi->rx_ring = 32; 907 fpi->rx_ring = RX_RING_SIZE;
943 fpi->tx_ring = 64; 908 fpi->tx_ring = TX_RING_SIZE;
944 fpi->rx_copybreak = 240; 909 fpi->rx_copybreak = 240;
945 fpi->napi_weight = 17; 910 fpi->napi_weight = 17;
946 fpi->phy_node = of_parse_phandle(ofdev->dev.of_node, "phy-handle", 0); 911 fpi->phy_node = of_parse_phandle(ofdev->dev.of_node, "phy-handle", 0);
@@ -1024,8 +989,7 @@ static int fs_enet_probe(struct platform_device *ofdev)
1024 989
1025 ndev->netdev_ops = &fs_enet_netdev_ops; 990 ndev->netdev_ops = &fs_enet_netdev_ops;
1026 ndev->watchdog_timeo = 2 * HZ; 991 ndev->watchdog_timeo = 2 * HZ;
1027 netif_napi_add(ndev, &fep->napi, fs_enet_rx_napi, fpi->napi_weight); 992 netif_napi_add(ndev, &fep->napi, fs_enet_napi, fpi->napi_weight);
1028 netif_tx_napi_add(ndev, &fep->napi_tx, fs_enet_tx_napi, 2);
1029 993
1030 ndev->ethtool_ops = &fs_ethtool_ops; 994 ndev->ethtool_ops = &fs_ethtool_ops;
1031 995
diff --git a/drivers/net/ethernet/freescale/fs_enet/fs_enet.h b/drivers/net/ethernet/freescale/fs_enet/fs_enet.h
index e29f54a35210..fee24c822fad 100644
--- a/drivers/net/ethernet/freescale/fs_enet/fs_enet.h
+++ b/drivers/net/ethernet/freescale/fs_enet/fs_enet.h
@@ -81,12 +81,9 @@ struct fs_ops {
81 void (*adjust_link)(struct net_device *dev); 81 void (*adjust_link)(struct net_device *dev);
82 void (*restart)(struct net_device *dev); 82 void (*restart)(struct net_device *dev);
83 void (*stop)(struct net_device *dev); 83 void (*stop)(struct net_device *dev);
84 void (*napi_clear_rx_event)(struct net_device *dev); 84 void (*napi_clear_event)(struct net_device *dev);
85 void (*napi_enable_rx)(struct net_device *dev); 85 void (*napi_enable)(struct net_device *dev);
86 void (*napi_disable_rx)(struct net_device *dev); 86 void (*napi_disable)(struct net_device *dev);
87 void (*napi_clear_tx_event)(struct net_device *dev);
88 void (*napi_enable_tx)(struct net_device *dev);
89 void (*napi_disable_tx)(struct net_device *dev);
90 void (*rx_bd_done)(struct net_device *dev); 87 void (*rx_bd_done)(struct net_device *dev);
91 void (*tx_kickstart)(struct net_device *dev); 88 void (*tx_kickstart)(struct net_device *dev);
92 u32 (*get_int_events)(struct net_device *dev); 89 u32 (*get_int_events)(struct net_device *dev);
@@ -122,7 +119,6 @@ struct phy_info {
122 119
123struct fs_enet_private { 120struct fs_enet_private {
124 struct napi_struct napi; 121 struct napi_struct napi;
125 struct napi_struct napi_tx;
126 struct device *dev; /* pointer back to the device (must be initialized first) */ 122 struct device *dev; /* pointer back to the device (must be initialized first) */
127 struct net_device *ndev; 123 struct net_device *ndev;
128 spinlock_t lock; /* during all ops except TX pckt processing */ 124 spinlock_t lock; /* during all ops except TX pckt processing */
@@ -152,10 +148,8 @@ struct fs_enet_private {
152 int oldduplex, oldspeed, oldlink; /* current settings */ 148 int oldduplex, oldspeed, oldlink; /* current settings */
153 149
154 /* event masks */ 150 /* event masks */
155 u32 ev_napi_rx; /* mask of NAPI rx events */ 151 u32 ev_napi; /* mask of NAPI events */
156 u32 ev_napi_tx; /* mask of NAPI rx events */ 152 u32 ev; /* event mask */
157 u32 ev_rx; /* rx event mask */
158 u32 ev_tx; /* tx event mask */
159 u32 ev_err; /* error event mask */ 153 u32 ev_err; /* error event mask */
160 154
161 u16 bd_rx_empty; /* mask of BD rx empty */ 155 u16 bd_rx_empty; /* mask of BD rx empty */
diff --git a/drivers/net/ethernet/freescale/fs_enet/mac-fcc.c b/drivers/net/ethernet/freescale/fs_enet/mac-fcc.c
index d71761a34022..7919896a9a4e 100644
--- a/drivers/net/ethernet/freescale/fs_enet/mac-fcc.c
+++ b/drivers/net/ethernet/freescale/fs_enet/mac-fcc.c
@@ -124,10 +124,8 @@ out:
124 return ret; 124 return ret;
125} 125}
126 126
127#define FCC_NAPI_RX_EVENT_MSK (FCC_ENET_RXF | FCC_ENET_RXB) 127#define FCC_NAPI_EVENT_MSK (FCC_ENET_RXF | FCC_ENET_RXB | FCC_ENET_TXB)
128#define FCC_NAPI_TX_EVENT_MSK (FCC_ENET_TXB) 128#define FCC_EVENT (FCC_ENET_RXF | FCC_ENET_TXB)
129#define FCC_RX_EVENT (FCC_ENET_RXF)
130#define FCC_TX_EVENT (FCC_ENET_TXB)
131#define FCC_ERR_EVENT_MSK (FCC_ENET_TXE) 129#define FCC_ERR_EVENT_MSK (FCC_ENET_TXE)
132 130
133static int setup_data(struct net_device *dev) 131static int setup_data(struct net_device *dev)
@@ -137,10 +135,8 @@ static int setup_data(struct net_device *dev)
137 if (do_pd_setup(fep) != 0) 135 if (do_pd_setup(fep) != 0)
138 return -EINVAL; 136 return -EINVAL;
139 137
140 fep->ev_napi_rx = FCC_NAPI_RX_EVENT_MSK; 138 fep->ev_napi = FCC_NAPI_EVENT_MSK;
141 fep->ev_napi_tx = FCC_NAPI_TX_EVENT_MSK; 139 fep->ev = FCC_EVENT;
142 fep->ev_rx = FCC_RX_EVENT;
143 fep->ev_tx = FCC_TX_EVENT;
144 fep->ev_err = FCC_ERR_EVENT_MSK; 140 fep->ev_err = FCC_ERR_EVENT_MSK;
145 141
146 return 0; 142 return 0;
@@ -424,52 +420,28 @@ static void stop(struct net_device *dev)
424 fs_cleanup_bds(dev); 420 fs_cleanup_bds(dev);
425} 421}
426 422
427static void napi_clear_rx_event(struct net_device *dev) 423static void napi_clear_event_fs(struct net_device *dev)
428{ 424{
429 struct fs_enet_private *fep = netdev_priv(dev); 425 struct fs_enet_private *fep = netdev_priv(dev);
430 fcc_t __iomem *fccp = fep->fcc.fccp; 426 fcc_t __iomem *fccp = fep->fcc.fccp;
431 427
432 W16(fccp, fcc_fcce, FCC_NAPI_RX_EVENT_MSK); 428 W16(fccp, fcc_fcce, FCC_NAPI_EVENT_MSK);
433} 429}
434 430
435static void napi_enable_rx(struct net_device *dev) 431static void napi_enable_fs(struct net_device *dev)
436{ 432{
437 struct fs_enet_private *fep = netdev_priv(dev); 433 struct fs_enet_private *fep = netdev_priv(dev);
438 fcc_t __iomem *fccp = fep->fcc.fccp; 434 fcc_t __iomem *fccp = fep->fcc.fccp;
439 435
440 S16(fccp, fcc_fccm, FCC_NAPI_RX_EVENT_MSK); 436 S16(fccp, fcc_fccm, FCC_NAPI_EVENT_MSK);
441} 437}
442 438
443static void napi_disable_rx(struct net_device *dev) 439static void napi_disable_fs(struct net_device *dev)
444{ 440{
445 struct fs_enet_private *fep = netdev_priv(dev); 441 struct fs_enet_private *fep = netdev_priv(dev);
446 fcc_t __iomem *fccp = fep->fcc.fccp; 442 fcc_t __iomem *fccp = fep->fcc.fccp;
447 443
448 C16(fccp, fcc_fccm, FCC_NAPI_RX_EVENT_MSK); 444 C16(fccp, fcc_fccm, FCC_NAPI_EVENT_MSK);
449}
450
451static void napi_clear_tx_event(struct net_device *dev)
452{
453 struct fs_enet_private *fep = netdev_priv(dev);
454 fcc_t __iomem *fccp = fep->fcc.fccp;
455
456 W16(fccp, fcc_fcce, FCC_NAPI_TX_EVENT_MSK);
457}
458
459static void napi_enable_tx(struct net_device *dev)
460{
461 struct fs_enet_private *fep = netdev_priv(dev);
462 fcc_t __iomem *fccp = fep->fcc.fccp;
463
464 S16(fccp, fcc_fccm, FCC_NAPI_TX_EVENT_MSK);
465}
466
467static void napi_disable_tx(struct net_device *dev)
468{
469 struct fs_enet_private *fep = netdev_priv(dev);
470 fcc_t __iomem *fccp = fep->fcc.fccp;
471
472 C16(fccp, fcc_fccm, FCC_NAPI_TX_EVENT_MSK);
473} 445}
474 446
475static void rx_bd_done(struct net_device *dev) 447static void rx_bd_done(struct net_device *dev)
@@ -595,12 +567,9 @@ const struct fs_ops fs_fcc_ops = {
595 .set_multicast_list = set_multicast_list, 567 .set_multicast_list = set_multicast_list,
596 .restart = restart, 568 .restart = restart,
597 .stop = stop, 569 .stop = stop,
598 .napi_clear_rx_event = napi_clear_rx_event, 570 .napi_clear_event = napi_clear_event_fs,
599 .napi_enable_rx = napi_enable_rx, 571 .napi_enable = napi_enable_fs,
600 .napi_disable_rx = napi_disable_rx, 572 .napi_disable = napi_disable_fs,
601 .napi_clear_tx_event = napi_clear_tx_event,
602 .napi_enable_tx = napi_enable_tx,
603 .napi_disable_tx = napi_disable_tx,
604 .rx_bd_done = rx_bd_done, 573 .rx_bd_done = rx_bd_done,
605 .tx_kickstart = tx_kickstart, 574 .tx_kickstart = tx_kickstart,
606 .get_int_events = get_int_events, 575 .get_int_events = get_int_events,
diff --git a/drivers/net/ethernet/freescale/fs_enet/mac-fec.c b/drivers/net/ethernet/freescale/fs_enet/mac-fec.c
index 35a318ed3a62..21fbaaf3a5fc 100644
--- a/drivers/net/ethernet/freescale/fs_enet/mac-fec.c
+++ b/drivers/net/ethernet/freescale/fs_enet/mac-fec.c
@@ -109,10 +109,8 @@ static int do_pd_setup(struct fs_enet_private *fep)
109 return 0; 109 return 0;
110} 110}
111 111
112#define FEC_NAPI_RX_EVENT_MSK (FEC_ENET_RXF | FEC_ENET_RXB) 112#define FEC_NAPI_EVENT_MSK (FEC_ENET_RXF | FEC_ENET_RXB | FEC_ENET_TXF)
113#define FEC_NAPI_TX_EVENT_MSK (FEC_ENET_TXF) 113#define FEC_EVENT (FEC_ENET_RXF | FEC_ENET_TXF)
114#define FEC_RX_EVENT (FEC_ENET_RXF)
115#define FEC_TX_EVENT (FEC_ENET_TXF)
116#define FEC_ERR_EVENT_MSK (FEC_ENET_HBERR | FEC_ENET_BABR | \ 114#define FEC_ERR_EVENT_MSK (FEC_ENET_HBERR | FEC_ENET_BABR | \
117 FEC_ENET_BABT | FEC_ENET_EBERR) 115 FEC_ENET_BABT | FEC_ENET_EBERR)
118 116
@@ -126,10 +124,8 @@ static int setup_data(struct net_device *dev)
126 fep->fec.hthi = 0; 124 fep->fec.hthi = 0;
127 fep->fec.htlo = 0; 125 fep->fec.htlo = 0;
128 126
129 fep->ev_napi_rx = FEC_NAPI_RX_EVENT_MSK; 127 fep->ev_napi = FEC_NAPI_EVENT_MSK;
130 fep->ev_napi_tx = FEC_NAPI_TX_EVENT_MSK; 128 fep->ev = FEC_EVENT;
131 fep->ev_rx = FEC_RX_EVENT;
132 fep->ev_tx = FEC_TX_EVENT;
133 fep->ev_err = FEC_ERR_EVENT_MSK; 129 fep->ev_err = FEC_ERR_EVENT_MSK;
134 130
135 return 0; 131 return 0;
@@ -396,52 +392,28 @@ static void stop(struct net_device *dev)
396 } 392 }
397} 393}
398 394
399static void napi_clear_rx_event(struct net_device *dev) 395static void napi_clear_event_fs(struct net_device *dev)
400{ 396{
401 struct fs_enet_private *fep = netdev_priv(dev); 397 struct fs_enet_private *fep = netdev_priv(dev);
402 struct fec __iomem *fecp = fep->fec.fecp; 398 struct fec __iomem *fecp = fep->fec.fecp;
403 399
404 FW(fecp, ievent, FEC_NAPI_RX_EVENT_MSK); 400 FW(fecp, ievent, FEC_NAPI_EVENT_MSK);
405} 401}
406 402
407static void napi_enable_rx(struct net_device *dev) 403static void napi_enable_fs(struct net_device *dev)
408{ 404{
409 struct fs_enet_private *fep = netdev_priv(dev); 405 struct fs_enet_private *fep = netdev_priv(dev);
410 struct fec __iomem *fecp = fep->fec.fecp; 406 struct fec __iomem *fecp = fep->fec.fecp;
411 407
412 FS(fecp, imask, FEC_NAPI_RX_EVENT_MSK); 408 FS(fecp, imask, FEC_NAPI_EVENT_MSK);
413} 409}
414 410
415static void napi_disable_rx(struct net_device *dev) 411static void napi_disable_fs(struct net_device *dev)
416{ 412{
417 struct fs_enet_private *fep = netdev_priv(dev); 413 struct fs_enet_private *fep = netdev_priv(dev);
418 struct fec __iomem *fecp = fep->fec.fecp; 414 struct fec __iomem *fecp = fep->fec.fecp;
419 415
420 FC(fecp, imask, FEC_NAPI_RX_EVENT_MSK); 416 FC(fecp, imask, FEC_NAPI_EVENT_MSK);
421}
422
423static void napi_clear_tx_event(struct net_device *dev)
424{
425 struct fs_enet_private *fep = netdev_priv(dev);
426 struct fec __iomem *fecp = fep->fec.fecp;
427
428 FW(fecp, ievent, FEC_NAPI_TX_EVENT_MSK);
429}
430
431static void napi_enable_tx(struct net_device *dev)
432{
433 struct fs_enet_private *fep = netdev_priv(dev);
434 struct fec __iomem *fecp = fep->fec.fecp;
435
436 FS(fecp, imask, FEC_NAPI_TX_EVENT_MSK);
437}
438
439static void napi_disable_tx(struct net_device *dev)
440{
441 struct fs_enet_private *fep = netdev_priv(dev);
442 struct fec __iomem *fecp = fep->fec.fecp;
443
444 FC(fecp, imask, FEC_NAPI_TX_EVENT_MSK);
445} 417}
446 418
447static void rx_bd_done(struct net_device *dev) 419static void rx_bd_done(struct net_device *dev)
@@ -513,12 +485,9 @@ const struct fs_ops fs_fec_ops = {
513 .set_multicast_list = set_multicast_list, 485 .set_multicast_list = set_multicast_list,
514 .restart = restart, 486 .restart = restart,
515 .stop = stop, 487 .stop = stop,
516 .napi_clear_rx_event = napi_clear_rx_event, 488 .napi_clear_event = napi_clear_event_fs,
517 .napi_enable_rx = napi_enable_rx, 489 .napi_enable = napi_enable_fs,
518 .napi_disable_rx = napi_disable_rx, 490 .napi_disable = napi_disable_fs,
519 .napi_clear_tx_event = napi_clear_tx_event,
520 .napi_enable_tx = napi_enable_tx,
521 .napi_disable_tx = napi_disable_tx,
522 .rx_bd_done = rx_bd_done, 491 .rx_bd_done = rx_bd_done,
523 .tx_kickstart = tx_kickstart, 492 .tx_kickstart = tx_kickstart,
524 .get_int_events = get_int_events, 493 .get_int_events = get_int_events,
diff --git a/drivers/net/ethernet/freescale/fs_enet/mac-scc.c b/drivers/net/ethernet/freescale/fs_enet/mac-scc.c
index e8b9c33d35b4..9d52e1ec0052 100644
--- a/drivers/net/ethernet/freescale/fs_enet/mac-scc.c
+++ b/drivers/net/ethernet/freescale/fs_enet/mac-scc.c
@@ -115,10 +115,8 @@ static int do_pd_setup(struct fs_enet_private *fep)
115 return 0; 115 return 0;
116} 116}
117 117
118#define SCC_NAPI_RX_EVENT_MSK (SCCE_ENET_RXF | SCCE_ENET_RXB) 118#define SCC_NAPI_EVENT_MSK (SCCE_ENET_RXF | SCCE_ENET_RXB | SCCE_ENET_TXB)
119#define SCC_NAPI_TX_EVENT_MSK (SCCE_ENET_TXB) 119#define SCC_EVENT (SCCE_ENET_RXF | SCCE_ENET_TXB)
120#define SCC_RX_EVENT (SCCE_ENET_RXF)
121#define SCC_TX_EVENT (SCCE_ENET_TXB)
122#define SCC_ERR_EVENT_MSK (SCCE_ENET_TXE | SCCE_ENET_BSY) 120#define SCC_ERR_EVENT_MSK (SCCE_ENET_TXE | SCCE_ENET_BSY)
123 121
124static int setup_data(struct net_device *dev) 122static int setup_data(struct net_device *dev)
@@ -130,10 +128,8 @@ static int setup_data(struct net_device *dev)
130 fep->scc.hthi = 0; 128 fep->scc.hthi = 0;
131 fep->scc.htlo = 0; 129 fep->scc.htlo = 0;
132 130
133 fep->ev_napi_rx = SCC_NAPI_RX_EVENT_MSK; 131 fep->ev_napi = SCC_NAPI_EVENT_MSK;
134 fep->ev_napi_tx = SCC_NAPI_TX_EVENT_MSK; 132 fep->ev = SCC_EVENT | SCCE_ENET_TXE;
135 fep->ev_rx = SCC_RX_EVENT;
136 fep->ev_tx = SCC_TX_EVENT | SCCE_ENET_TXE;
137 fep->ev_err = SCC_ERR_EVENT_MSK; 133 fep->ev_err = SCC_ERR_EVENT_MSK;
138 134
139 return 0; 135 return 0;
@@ -379,52 +375,28 @@ static void stop(struct net_device *dev)
379 fs_cleanup_bds(dev); 375 fs_cleanup_bds(dev);
380} 376}
381 377
382static void napi_clear_rx_event(struct net_device *dev) 378static void napi_clear_event_fs(struct net_device *dev)
383{ 379{
384 struct fs_enet_private *fep = netdev_priv(dev); 380 struct fs_enet_private *fep = netdev_priv(dev);
385 scc_t __iomem *sccp = fep->scc.sccp; 381 scc_t __iomem *sccp = fep->scc.sccp;
386 382
387 W16(sccp, scc_scce, SCC_NAPI_RX_EVENT_MSK); 383 W16(sccp, scc_scce, SCC_NAPI_EVENT_MSK);
388} 384}
389 385
390static void napi_enable_rx(struct net_device *dev) 386static void napi_enable_fs(struct net_device *dev)
391{ 387{
392 struct fs_enet_private *fep = netdev_priv(dev); 388 struct fs_enet_private *fep = netdev_priv(dev);
393 scc_t __iomem *sccp = fep->scc.sccp; 389 scc_t __iomem *sccp = fep->scc.sccp;
394 390
395 S16(sccp, scc_sccm, SCC_NAPI_RX_EVENT_MSK); 391 S16(sccp, scc_sccm, SCC_NAPI_EVENT_MSK);
396} 392}
397 393
398static void napi_disable_rx(struct net_device *dev) 394static void napi_disable_fs(struct net_device *dev)
399{ 395{
400 struct fs_enet_private *fep = netdev_priv(dev); 396 struct fs_enet_private *fep = netdev_priv(dev);
401 scc_t __iomem *sccp = fep->scc.sccp; 397 scc_t __iomem *sccp = fep->scc.sccp;
402 398
403 C16(sccp, scc_sccm, SCC_NAPI_RX_EVENT_MSK); 399 C16(sccp, scc_sccm, SCC_NAPI_EVENT_MSK);
404}
405
406static void napi_clear_tx_event(struct net_device *dev)
407{
408 struct fs_enet_private *fep = netdev_priv(dev);
409 scc_t __iomem *sccp = fep->scc.sccp;
410
411 W16(sccp, scc_scce, SCC_NAPI_TX_EVENT_MSK);
412}
413
414static void napi_enable_tx(struct net_device *dev)
415{
416 struct fs_enet_private *fep = netdev_priv(dev);
417 scc_t __iomem *sccp = fep->scc.sccp;
418
419 S16(sccp, scc_sccm, SCC_NAPI_TX_EVENT_MSK);
420}
421
422static void napi_disable_tx(struct net_device *dev)
423{
424 struct fs_enet_private *fep = netdev_priv(dev);
425 scc_t __iomem *sccp = fep->scc.sccp;
426
427 C16(sccp, scc_sccm, SCC_NAPI_TX_EVENT_MSK);
428} 400}
429 401
430static void rx_bd_done(struct net_device *dev) 402static void rx_bd_done(struct net_device *dev)
@@ -497,12 +469,9 @@ const struct fs_ops fs_scc_ops = {
497 .set_multicast_list = set_multicast_list, 469 .set_multicast_list = set_multicast_list,
498 .restart = restart, 470 .restart = restart,
499 .stop = stop, 471 .stop = stop,
500 .napi_clear_rx_event = napi_clear_rx_event, 472 .napi_clear_event = napi_clear_event_fs,
501 .napi_enable_rx = napi_enable_rx, 473 .napi_enable = napi_enable_fs,
502 .napi_disable_rx = napi_disable_rx, 474 .napi_disable = napi_disable_fs,
503 .napi_clear_tx_event = napi_clear_tx_event,
504 .napi_enable_tx = napi_enable_tx,
505 .napi_disable_tx = napi_disable_tx,
506 .rx_bd_done = rx_bd_done, 475 .rx_bd_done = rx_bd_done,
507 .tx_kickstart = tx_kickstart, 476 .tx_kickstart = tx_kickstart,
508 .get_int_events = get_int_events, 477 .get_int_events = get_int_events,
generated by cgit v1.2.2 (git 2.25.0) at 2026-01-09 16:59:44 -0500