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 40 struct 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 57 static 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 85 rx_drop: 86 netdev->stats.rx_dropped++; 87 netdev->stats.rx_errors++; 88 89 return NET_RX_DROP; 90 } 91 92 static 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 114 static 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 139 static 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 154 static 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 195 static void 196 liteeth_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 202 static 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 209 static 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 233 static 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 297 static int liteeth_remove(struct platform_device *pdev) 298 { 299 struct net_device *netdev = platform_get_drvdata(pdev); 300 301 unregister_netdev(netdev); 302 303 return 0; 304 } 305 306 static const struct of_device_id liteeth_of_match[] = { 307 { .compatible = "litex,liteeth" }, 308 { } 309 }; 310 MODULE_DEVICE_TABLE(of, liteeth_of_match); 311 312 static struct platform_driver liteeth_driver = { 313 .probe = liteeth_probe, 314 .remove = liteeth_remove, 315 .driver = { 316 .name = DRV_NAME, 317 .of_match_table = liteeth_of_match, 318 }, 319 }; 320 module_platform_driver(liteeth_driver); 321 322 MODULE_AUTHOR("Joel Stanley <joel@jms.id.au>"); 323 MODULE_LICENSE("GPL"); 324