Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * LiteX Liteeth Ethernet
4 *
5 * Copyright 2017 Joel Stanley <joel@jms.id.au>
6 *
7 */
8
9#include <linux/etherdevice.h>
10#include <linux/interrupt.h>
11#include <linux/litex.h>
12#include <linux/module.h>
13#include <linux/of_net.h>
14#include <linux/platform_device.h>
15
16#define LITEETH_WRITER_SLOT 0x00
17#define LITEETH_WRITER_LENGTH 0x04
18#define LITEETH_WRITER_ERRORS 0x08
19#define LITEETH_WRITER_EV_STATUS 0x0C
20#define LITEETH_WRITER_EV_PENDING 0x10
21#define LITEETH_WRITER_EV_ENABLE 0x14
22#define LITEETH_READER_START 0x18
23#define LITEETH_READER_READY 0x1C
24#define LITEETH_READER_LEVEL 0x20
25#define LITEETH_READER_SLOT 0x24
26#define LITEETH_READER_LENGTH 0x28
27#define LITEETH_READER_EV_STATUS 0x2C
28#define LITEETH_READER_EV_PENDING 0x30
29#define LITEETH_READER_EV_ENABLE 0x34
30#define LITEETH_PREAMBLE_CRC 0x38
31#define LITEETH_PREAMBLE_ERRORS 0x3C
32#define LITEETH_CRC_ERRORS 0x40
33
34#define LITEETH_PHY_CRG_RESET 0x00
35#define LITEETH_MDIO_W 0x04
36#define LITEETH_MDIO_R 0x0C
37
38#define DRV_NAME "liteeth"
39
40struct liteeth {
41 void __iomem *base;
42 struct net_device *netdev;
43 struct device *dev;
44 u32 slot_size;
45
46 /* Tx */
47 u32 tx_slot;
48 u32 num_tx_slots;
49 void __iomem *tx_base;
50
51 /* Rx */
52 u32 rx_slot;
53 u32 num_rx_slots;
54 void __iomem *rx_base;
55};
56
57static int liteeth_rx(struct net_device *netdev)
58{
59 struct liteeth *priv = netdev_priv(netdev);
60 struct sk_buff *skb;
61 unsigned char *data;
62 u8 rx_slot;
63 int len;
64
65 rx_slot = litex_read8(priv->base + LITEETH_WRITER_SLOT);
66 len = litex_read32(priv->base + LITEETH_WRITER_LENGTH);
67
68 if (len == 0 || len > 2048)
69 goto rx_drop;
70
71 skb = netdev_alloc_skb_ip_align(netdev, len);
72 if (!skb) {
73 netdev_err(netdev, "couldn't get memory\n");
74 goto rx_drop;
75 }
76
77 data = skb_put(skb, len);
78 memcpy_fromio(data, priv->rx_base + rx_slot * priv->slot_size, len);
79 skb->protocol = eth_type_trans(skb, netdev);
80
81 dev_sw_netstats_rx_add(netdev, len);
82
83 return netif_rx(skb);
84
85rx_drop:
86 netdev->stats.rx_dropped++;
87 netdev->stats.rx_errors++;
88
89 return NET_RX_DROP;
90}
91
92static irqreturn_t liteeth_interrupt(int irq, void *dev_id)
93{
94 struct net_device *netdev = dev_id;
95 struct liteeth *priv = netdev_priv(netdev);
96 u8 reg;
97
98 reg = litex_read8(priv->base + LITEETH_READER_EV_PENDING);
99 if (reg) {
100 if (netif_queue_stopped(netdev))
101 netif_wake_queue(netdev);
102 litex_write8(priv->base + LITEETH_READER_EV_PENDING, reg);
103 }
104
105 reg = litex_read8(priv->base + LITEETH_WRITER_EV_PENDING);
106 if (reg) {
107 liteeth_rx(netdev);
108 litex_write8(priv->base + LITEETH_WRITER_EV_PENDING, reg);
109 }
110
111 return IRQ_HANDLED;
112}
113
114static int liteeth_open(struct net_device *netdev)
115{
116 struct liteeth *priv = netdev_priv(netdev);
117 int err;
118
119 /* Clear pending events */
120 litex_write8(priv->base + LITEETH_WRITER_EV_PENDING, 1);
121 litex_write8(priv->base + LITEETH_READER_EV_PENDING, 1);
122
123 err = request_irq(netdev->irq, liteeth_interrupt, 0, netdev->name, netdev);
124 if (err) {
125 netdev_err(netdev, "failed to request irq %d\n", netdev->irq);
126 return err;
127 }
128
129 /* Enable IRQs */
130 litex_write8(priv->base + LITEETH_WRITER_EV_ENABLE, 1);
131 litex_write8(priv->base + LITEETH_READER_EV_ENABLE, 1);
132
133 netif_carrier_on(netdev);
134 netif_start_queue(netdev);
135
136 return 0;
137}
138
139static int liteeth_stop(struct net_device *netdev)
140{
141 struct liteeth *priv = netdev_priv(netdev);
142
143 netif_stop_queue(netdev);
144 netif_carrier_off(netdev);
145
146 litex_write8(priv->base + LITEETH_WRITER_EV_ENABLE, 0);
147 litex_write8(priv->base + LITEETH_READER_EV_ENABLE, 0);
148
149 free_irq(netdev->irq, netdev);
150
151 return 0;
152}
153
154static netdev_tx_t liteeth_start_xmit(struct sk_buff *skb,
155 struct net_device *netdev)
156{
157 struct liteeth *priv = netdev_priv(netdev);
158 void __iomem *txbuffer;
159
160 if (!litex_read8(priv->base + LITEETH_READER_READY)) {
161 if (net_ratelimit())
162 netdev_err(netdev, "LITEETH_READER_READY not ready\n");
163
164 netif_stop_queue(netdev);
165
166 return NETDEV_TX_BUSY;
167 }
168
169 /* Reject oversize packets */
170 if (unlikely(skb->len > priv->slot_size)) {
171 if (net_ratelimit())
172 netdev_err(netdev, "tx packet too big\n");
173
174 dev_kfree_skb_any(skb);
175 netdev->stats.tx_dropped++;
176 netdev->stats.tx_errors++;
177
178 return NETDEV_TX_OK;
179 }
180
181 txbuffer = priv->tx_base + priv->tx_slot * priv->slot_size;
182 memcpy_toio(txbuffer, skb->data, skb->len);
183 litex_write8(priv->base + LITEETH_READER_SLOT, priv->tx_slot);
184 litex_write16(priv->base + LITEETH_READER_LENGTH, skb->len);
185 litex_write8(priv->base + LITEETH_READER_START, 1);
186
187 dev_sw_netstats_tx_add(netdev, 1, skb->len);
188
189 priv->tx_slot = (priv->tx_slot + 1) % priv->num_tx_slots;
190 dev_kfree_skb_any(skb);
191
192 return NETDEV_TX_OK;
193}
194
195static void
196liteeth_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats)
197{
198 netdev_stats_to_stats64(stats, &netdev->stats);
199 dev_fetch_sw_netstats(stats, netdev->tstats);
200}
201
202static const struct net_device_ops liteeth_netdev_ops = {
203 .ndo_open = liteeth_open,
204 .ndo_stop = liteeth_stop,
205 .ndo_get_stats64 = liteeth_get_stats64,
206 .ndo_start_xmit = liteeth_start_xmit,
207};
208
209static void liteeth_setup_slots(struct liteeth *priv)
210{
211 struct device_node *np = priv->dev->of_node;
212 int err;
213
214 err = of_property_read_u32(np, "litex,rx-slots", &priv->num_rx_slots);
215 if (err) {
216 dev_dbg(priv->dev, "unable to get litex,rx-slots, using 2\n");
217 priv->num_rx_slots = 2;
218 }
219
220 err = of_property_read_u32(np, "litex,tx-slots", &priv->num_tx_slots);
221 if (err) {
222 dev_dbg(priv->dev, "unable to get litex,tx-slots, using 2\n");
223 priv->num_tx_slots = 2;
224 }
225
226 err = of_property_read_u32(np, "litex,slot-size", &priv->slot_size);
227 if (err) {
228 dev_dbg(priv->dev, "unable to get litex,slot-size, using 0x800\n");
229 priv->slot_size = 0x800;
230 }
231}
232
233static int liteeth_probe(struct platform_device *pdev)
234{
235 struct net_device *netdev;
236 void __iomem *buf_base;
237 struct liteeth *priv;
238 int irq, err;
239
240 netdev = devm_alloc_etherdev(&pdev->dev, sizeof(*priv));
241 if (!netdev)
242 return -ENOMEM;
243
244 SET_NETDEV_DEV(netdev, &pdev->dev);
245 platform_set_drvdata(pdev, netdev);
246
247 priv = netdev_priv(netdev);
248 priv->netdev = netdev;
249 priv->dev = &pdev->dev;
250
251 netdev->tstats = devm_netdev_alloc_pcpu_stats(&pdev->dev,
252 struct pcpu_sw_netstats);
253 if (!netdev->tstats)
254 return -ENOMEM;
255
256 irq = platform_get_irq(pdev, 0);
257 if (irq < 0)
258 return irq;
259 netdev->irq = irq;
260
261 priv->base = devm_platform_ioremap_resource_byname(pdev, "mac");
262 if (IS_ERR(priv->base))
263 return PTR_ERR(priv->base);
264
265 buf_base = devm_platform_ioremap_resource_byname(pdev, "buffer");
266 if (IS_ERR(buf_base))
267 return PTR_ERR(buf_base);
268
269 liteeth_setup_slots(priv);
270
271 /* Rx slots */
272 priv->rx_base = buf_base;
273 priv->rx_slot = 0;
274
275 /* Tx slots come after Rx slots */
276 priv->tx_base = buf_base + priv->num_rx_slots * priv->slot_size;
277 priv->tx_slot = 0;
278
279 err = of_get_ethdev_address(pdev->dev.of_node, netdev);
280 if (err)
281 eth_hw_addr_random(netdev);
282
283 netdev->netdev_ops = &liteeth_netdev_ops;
284
285 err = register_netdev(netdev);
286 if (err) {
287 dev_err(&pdev->dev, "Failed to register netdev %d\n", err);
288 return err;
289 }
290
291 netdev_info(netdev, "irq %d slots: tx %d rx %d size %d\n",
292 netdev->irq, priv->num_tx_slots, priv->num_rx_slots, priv->slot_size);
293
294 return 0;
295}
296
297static void liteeth_remove(struct platform_device *pdev)
298{
299 struct net_device *netdev = platform_get_drvdata(pdev);
300
301 unregister_netdev(netdev);
302}
303
304static const struct of_device_id liteeth_of_match[] = {
305 { .compatible = "litex,liteeth" },
306 { }
307};
308MODULE_DEVICE_TABLE(of, liteeth_of_match);
309
310static struct platform_driver liteeth_driver = {
311 .probe = liteeth_probe,
312 .remove_new = liteeth_remove,
313 .driver = {
314 .name = DRV_NAME,
315 .of_match_table = liteeth_of_match,
316 },
317};
318module_platform_driver(liteeth_driver);
319
320MODULE_AUTHOR("Joel Stanley <joel@jms.id.au>");
321MODULE_DESCRIPTION("LiteX Liteeth Ethernet driver");
322MODULE_LICENSE("GPL");
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * LiteX Liteeth Ethernet
4 *
5 * Copyright 2017 Joel Stanley <joel@jms.id.au>
6 *
7 */
8
9#include <linux/etherdevice.h>
10#include <linux/interrupt.h>
11#include <linux/litex.h>
12#include <linux/module.h>
13#include <linux/of_net.h>
14#include <linux/platform_device.h>
15
16#define LITEETH_WRITER_SLOT 0x00
17#define LITEETH_WRITER_LENGTH 0x04
18#define LITEETH_WRITER_ERRORS 0x08
19#define LITEETH_WRITER_EV_STATUS 0x0C
20#define LITEETH_WRITER_EV_PENDING 0x10
21#define LITEETH_WRITER_EV_ENABLE 0x14
22#define LITEETH_READER_START 0x18
23#define LITEETH_READER_READY 0x1C
24#define LITEETH_READER_LEVEL 0x20
25#define LITEETH_READER_SLOT 0x24
26#define LITEETH_READER_LENGTH 0x28
27#define LITEETH_READER_EV_STATUS 0x2C
28#define LITEETH_READER_EV_PENDING 0x30
29#define LITEETH_READER_EV_ENABLE 0x34
30#define LITEETH_PREAMBLE_CRC 0x38
31#define LITEETH_PREAMBLE_ERRORS 0x3C
32#define LITEETH_CRC_ERRORS 0x40
33
34#define LITEETH_PHY_CRG_RESET 0x00
35#define LITEETH_MDIO_W 0x04
36#define LITEETH_MDIO_R 0x0C
37
38#define DRV_NAME "liteeth"
39
40struct liteeth {
41 void __iomem *base;
42 struct net_device *netdev;
43 struct device *dev;
44 u32 slot_size;
45
46 /* Tx */
47 u32 tx_slot;
48 u32 num_tx_slots;
49 void __iomem *tx_base;
50
51 /* Rx */
52 u32 rx_slot;
53 u32 num_rx_slots;
54 void __iomem *rx_base;
55};
56
57static int liteeth_rx(struct net_device *netdev)
58{
59 struct liteeth *priv = netdev_priv(netdev);
60 struct sk_buff *skb;
61 unsigned char *data;
62 u8 rx_slot;
63 int len;
64
65 rx_slot = litex_read8(priv->base + LITEETH_WRITER_SLOT);
66 len = litex_read32(priv->base + LITEETH_WRITER_LENGTH);
67
68 if (len == 0 || len > 2048)
69 goto rx_drop;
70
71 skb = netdev_alloc_skb_ip_align(netdev, len);
72 if (!skb) {
73 netdev_err(netdev, "couldn't get memory\n");
74 goto rx_drop;
75 }
76
77 data = skb_put(skb, len);
78 memcpy_fromio(data, priv->rx_base + rx_slot * priv->slot_size, len);
79 skb->protocol = eth_type_trans(skb, netdev);
80
81 netdev->stats.rx_packets++;
82 netdev->stats.rx_bytes += len;
83
84 return netif_rx(skb);
85
86rx_drop:
87 netdev->stats.rx_dropped++;
88 netdev->stats.rx_errors++;
89
90 return NET_RX_DROP;
91}
92
93static irqreturn_t liteeth_interrupt(int irq, void *dev_id)
94{
95 struct net_device *netdev = dev_id;
96 struct liteeth *priv = netdev_priv(netdev);
97 u8 reg;
98
99 reg = litex_read8(priv->base + LITEETH_READER_EV_PENDING);
100 if (reg) {
101 if (netif_queue_stopped(netdev))
102 netif_wake_queue(netdev);
103 litex_write8(priv->base + LITEETH_READER_EV_PENDING, reg);
104 }
105
106 reg = litex_read8(priv->base + LITEETH_WRITER_EV_PENDING);
107 if (reg) {
108 liteeth_rx(netdev);
109 litex_write8(priv->base + LITEETH_WRITER_EV_PENDING, reg);
110 }
111
112 return IRQ_HANDLED;
113}
114
115static int liteeth_open(struct net_device *netdev)
116{
117 struct liteeth *priv = netdev_priv(netdev);
118 int err;
119
120 /* Clear pending events */
121 litex_write8(priv->base + LITEETH_WRITER_EV_PENDING, 1);
122 litex_write8(priv->base + LITEETH_READER_EV_PENDING, 1);
123
124 err = request_irq(netdev->irq, liteeth_interrupt, 0, netdev->name, netdev);
125 if (err) {
126 netdev_err(netdev, "failed to request irq %d\n", netdev->irq);
127 return err;
128 }
129
130 /* Enable IRQs */
131 litex_write8(priv->base + LITEETH_WRITER_EV_ENABLE, 1);
132 litex_write8(priv->base + LITEETH_READER_EV_ENABLE, 1);
133
134 netif_carrier_on(netdev);
135 netif_start_queue(netdev);
136
137 return 0;
138}
139
140static int liteeth_stop(struct net_device *netdev)
141{
142 struct liteeth *priv = netdev_priv(netdev);
143
144 netif_stop_queue(netdev);
145 netif_carrier_off(netdev);
146
147 litex_write8(priv->base + LITEETH_WRITER_EV_ENABLE, 0);
148 litex_write8(priv->base + LITEETH_READER_EV_ENABLE, 0);
149
150 free_irq(netdev->irq, netdev);
151
152 return 0;
153}
154
155static netdev_tx_t liteeth_start_xmit(struct sk_buff *skb,
156 struct net_device *netdev)
157{
158 struct liteeth *priv = netdev_priv(netdev);
159 void __iomem *txbuffer;
160
161 if (!litex_read8(priv->base + LITEETH_READER_READY)) {
162 if (net_ratelimit())
163 netdev_err(netdev, "LITEETH_READER_READY not ready\n");
164
165 netif_stop_queue(netdev);
166
167 return NETDEV_TX_BUSY;
168 }
169
170 /* Reject oversize packets */
171 if (unlikely(skb->len > priv->slot_size)) {
172 if (net_ratelimit())
173 netdev_err(netdev, "tx packet too big\n");
174
175 dev_kfree_skb_any(skb);
176 netdev->stats.tx_dropped++;
177 netdev->stats.tx_errors++;
178
179 return NETDEV_TX_OK;
180 }
181
182 txbuffer = priv->tx_base + priv->tx_slot * priv->slot_size;
183 memcpy_toio(txbuffer, skb->data, skb->len);
184 litex_write8(priv->base + LITEETH_READER_SLOT, priv->tx_slot);
185 litex_write16(priv->base + LITEETH_READER_LENGTH, skb->len);
186 litex_write8(priv->base + LITEETH_READER_START, 1);
187
188 netdev->stats.tx_bytes += skb->len;
189 netdev->stats.tx_packets++;
190
191 priv->tx_slot = (priv->tx_slot + 1) % priv->num_tx_slots;
192 dev_kfree_skb_any(skb);
193
194 return NETDEV_TX_OK;
195}
196
197static const struct net_device_ops liteeth_netdev_ops = {
198 .ndo_open = liteeth_open,
199 .ndo_stop = liteeth_stop,
200 .ndo_start_xmit = liteeth_start_xmit,
201};
202
203static void liteeth_setup_slots(struct liteeth *priv)
204{
205 struct device_node *np = priv->dev->of_node;
206 int err;
207
208 err = of_property_read_u32(np, "litex,rx-slots", &priv->num_rx_slots);
209 if (err) {
210 dev_dbg(priv->dev, "unable to get litex,rx-slots, using 2\n");
211 priv->num_rx_slots = 2;
212 }
213
214 err = of_property_read_u32(np, "litex,tx-slots", &priv->num_tx_slots);
215 if (err) {
216 dev_dbg(priv->dev, "unable to get litex,tx-slots, using 2\n");
217 priv->num_tx_slots = 2;
218 }
219
220 err = of_property_read_u32(np, "litex,slot-size", &priv->slot_size);
221 if (err) {
222 dev_dbg(priv->dev, "unable to get litex,slot-size, using 0x800\n");
223 priv->slot_size = 0x800;
224 }
225}
226
227static int liteeth_probe(struct platform_device *pdev)
228{
229 struct net_device *netdev;
230 void __iomem *buf_base;
231 struct liteeth *priv;
232 int irq, err;
233
234 netdev = devm_alloc_etherdev(&pdev->dev, sizeof(*priv));
235 if (!netdev)
236 return -ENOMEM;
237
238 SET_NETDEV_DEV(netdev, &pdev->dev);
239 platform_set_drvdata(pdev, netdev);
240
241 priv = netdev_priv(netdev);
242 priv->netdev = netdev;
243 priv->dev = &pdev->dev;
244
245 irq = platform_get_irq(pdev, 0);
246 if (irq < 0)
247 return irq;
248 netdev->irq = irq;
249
250 priv->base = devm_platform_ioremap_resource_byname(pdev, "mac");
251 if (IS_ERR(priv->base))
252 return PTR_ERR(priv->base);
253
254 buf_base = devm_platform_ioremap_resource_byname(pdev, "buffer");
255 if (IS_ERR(buf_base))
256 return PTR_ERR(buf_base);
257
258 liteeth_setup_slots(priv);
259
260 /* Rx slots */
261 priv->rx_base = buf_base;
262 priv->rx_slot = 0;
263
264 /* Tx slots come after Rx slots */
265 priv->tx_base = buf_base + priv->num_rx_slots * priv->slot_size;
266 priv->tx_slot = 0;
267
268 err = of_get_ethdev_address(pdev->dev.of_node, netdev);
269 if (err)
270 eth_hw_addr_random(netdev);
271
272 netdev->netdev_ops = &liteeth_netdev_ops;
273
274 err = register_netdev(netdev);
275 if (err) {
276 dev_err(&pdev->dev, "Failed to register netdev %d\n", err);
277 return err;
278 }
279
280 netdev_info(netdev, "irq %d slots: tx %d rx %d size %d\n",
281 netdev->irq, priv->num_tx_slots, priv->num_rx_slots, priv->slot_size);
282
283 return 0;
284}
285
286static int liteeth_remove(struct platform_device *pdev)
287{
288 struct net_device *netdev = platform_get_drvdata(pdev);
289
290 unregister_netdev(netdev);
291
292 return 0;
293}
294
295static const struct of_device_id liteeth_of_match[] = {
296 { .compatible = "litex,liteeth" },
297 { }
298};
299MODULE_DEVICE_TABLE(of, liteeth_of_match);
300
301static struct platform_driver liteeth_driver = {
302 .probe = liteeth_probe,
303 .remove = liteeth_remove,
304 .driver = {
305 .name = DRV_NAME,
306 .of_match_table = liteeth_of_match,
307 },
308};
309module_platform_driver(liteeth_driver);
310
311MODULE_AUTHOR("Joel Stanley <joel@jms.id.au>");
312MODULE_LICENSE("GPL");