ethernet/litex/litex_liteeth.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * LiteX Liteeth Ethernet
0004  *
0005  * Copyright 2017 Joel Stanley <joel@jms.id.au>
0006  *
0007  */
0008
0009 #include <linux/etherdevice.h>
0010 #include <linux/interrupt.h>
0011 #include <linux/litex.h>
0012 #include <linux/module.h>
0013 #include <linux/of_net.h>
0014 #include <linux/platform_device.h>
0015
0016 #define LITEETH_WRITER_SLOT       0x00
0017 #define LITEETH_WRITER_LENGTH     0x04
0018 #define LITEETH_WRITER_ERRORS     0x08
0019 #define LITEETH_WRITER_EV_STATUS  0x0C
0020 #define LITEETH_WRITER_EV_PENDING 0x10
0021 #define LITEETH_WRITER_EV_ENABLE  0x14
0022 #define LITEETH_READER_START      0x18
0023 #define LITEETH_READER_READY      0x1C
0024 #define LITEETH_READER_LEVEL      0x20
0025 #define LITEETH_READER_SLOT       0x24
0026 #define LITEETH_READER_LENGTH     0x28
0027 #define LITEETH_READER_EV_STATUS  0x2C
0028 #define LITEETH_READER_EV_PENDING 0x30
0029 #define LITEETH_READER_EV_ENABLE  0x34
0030 #define LITEETH_PREAMBLE_CRC      0x38
0031 #define LITEETH_PREAMBLE_ERRORS   0x3C
0032 #define LITEETH_CRC_ERRORS        0x40
0033
0034 #define LITEETH_PHY_CRG_RESET     0x00
0035 #define LITEETH_MDIO_W            0x04
0036 #define LITEETH_MDIO_R            0x0C
0037
0038 #define DRV_NAME    "liteeth"
0039
0040 struct liteeth {
0041     void __iomem *base;
0042     struct net_device *netdev;
0043     struct device *dev;
0044     u32 slot_size;
0045
0046     /* Tx */
0047     u32 tx_slot;
0048     u32 num_tx_slots;
0049     void __iomem *tx_base;
0050
0051     /* Rx */
0052     u32 rx_slot;
0053     u32 num_rx_slots;
0054     void __iomem *rx_base;
0055 };
0056
0057 static int liteeth_rx(struct net_device *netdev)
0058 {
0059     struct liteeth *priv = netdev_priv(netdev);
0060     struct sk_buff *skb;
0061     unsigned char *data;
0062     u8 rx_slot;
0063     int len;
0064
0065     rx_slot = litex_read8(priv->base + LITEETH_WRITER_SLOT);
0066     len = litex_read32(priv->base + LITEETH_WRITER_LENGTH);
0067
0068     if (len == 0 || len > 2048)
0069         goto rx_drop;
0070
0071     skb = netdev_alloc_skb_ip_align(netdev, len);
0072     if (!skb) {
0073         netdev_err(netdev, "couldn't get memory\n");
0074         goto rx_drop;
0075     }
0076
0077     data = skb_put(skb, len);
0078     memcpy_fromio(data, priv->rx_base + rx_slot * priv->slot_size, len);
0079     skb->protocol = eth_type_trans(skb, netdev);
0080
0081     netdev->stats.rx_packets++;
0082     netdev->stats.rx_bytes += len;
0083
0084     return netif_rx(skb);
0085
0086 rx_drop:
0087     netdev->stats.rx_dropped++;
0088     netdev->stats.rx_errors++;
0089
0090     return NET_RX_DROP;
0091 }
0092
0093 static irqreturn_t liteeth_interrupt(int irq, void *dev_id)
0094 {
0095     struct net_device *netdev = dev_id;
0096     struct liteeth *priv = netdev_priv(netdev);
0097     u8 reg;
0098
0099     reg = litex_read8(priv->base + LITEETH_READER_EV_PENDING);
0100     if (reg) {
0101         if (netif_queue_stopped(netdev))
0102             netif_wake_queue(netdev);
0103         litex_write8(priv->base + LITEETH_READER_EV_PENDING, reg);
0104     }
0105
0106     reg = litex_read8(priv->base + LITEETH_WRITER_EV_PENDING);
0107     if (reg) {
0108         liteeth_rx(netdev);
0109         litex_write8(priv->base + LITEETH_WRITER_EV_PENDING, reg);
0110     }
0111
0112     return IRQ_HANDLED;
0113 }
0114
0115 static int liteeth_open(struct net_device *netdev)
0116 {
0117     struct liteeth *priv = netdev_priv(netdev);
0118     int err;
0119
0120     /* Clear pending events */
0121     litex_write8(priv->base + LITEETH_WRITER_EV_PENDING, 1);
0122     litex_write8(priv->base + LITEETH_READER_EV_PENDING, 1);
0123
0124     err = request_irq(netdev->irq, liteeth_interrupt, 0, netdev->name, netdev);
0125     if (err) {
0126         netdev_err(netdev, "failed to request irq %d\n", netdev->irq);
0127         return err;
0128     }
0129
0130     /* Enable IRQs */
0131     litex_write8(priv->base + LITEETH_WRITER_EV_ENABLE, 1);
0132     litex_write8(priv->base + LITEETH_READER_EV_ENABLE, 1);
0133
0134     netif_carrier_on(netdev);
0135     netif_start_queue(netdev);
0136
0137     return 0;
0138 }
0139
0140 static int liteeth_stop(struct net_device *netdev)
0141 {
0142     struct liteeth *priv = netdev_priv(netdev);
0143
0144     netif_stop_queue(netdev);
0145     netif_carrier_off(netdev);
0146
0147     litex_write8(priv->base + LITEETH_WRITER_EV_ENABLE, 0);
0148     litex_write8(priv->base + LITEETH_READER_EV_ENABLE, 0);
0149
0150     free_irq(netdev->irq, netdev);
0151
0152     return 0;
0153 }
0154
0155 static int liteeth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
0156 {
0157     struct liteeth *priv = netdev_priv(netdev);
0158     void __iomem *txbuffer;
0159
0160     if (!litex_read8(priv->base + LITEETH_READER_READY)) {
0161         if (net_ratelimit())
0162             netdev_err(netdev, "LITEETH_READER_READY not ready\n");
0163
0164         netif_stop_queue(netdev);
0165
0166         return NETDEV_TX_BUSY;
0167     }
0168
0169     /* Reject oversize packets */
0170     if (unlikely(skb->len > priv->slot_size)) {
0171         if (net_ratelimit())
0172             netdev_err(netdev, "tx packet too big\n");
0173
0174         dev_kfree_skb_any(skb);
0175         netdev->stats.tx_dropped++;
0176         netdev->stats.tx_errors++;
0177
0178         return NETDEV_TX_OK;
0179     }
0180
0181     txbuffer = priv->tx_base + priv->tx_slot * priv->slot_size;
0182     memcpy_toio(txbuffer, skb->data, skb->len);
0183     litex_write8(priv->base + LITEETH_READER_SLOT, priv->tx_slot);
0184     litex_write16(priv->base + LITEETH_READER_LENGTH, skb->len);
0185     litex_write8(priv->base + LITEETH_READER_START, 1);
0186
0187     netdev->stats.tx_bytes += skb->len;
0188     netdev->stats.tx_packets++;
0189
0190     priv->tx_slot = (priv->tx_slot + 1) % priv->num_tx_slots;
0191     dev_kfree_skb_any(skb);
0192
0193     return NETDEV_TX_OK;
0194 }
0195
0196 static const struct net_device_ops liteeth_netdev_ops = {
0197     .ndo_open       = liteeth_open,
0198     .ndo_stop       = liteeth_stop,
0199     .ndo_start_xmit         = liteeth_start_xmit,
0200 };
0201
0202 static void liteeth_setup_slots(struct liteeth *priv)
0203 {
0204     struct device_node *np = priv->dev->of_node;
0205     int err;
0206
0207     err = of_property_read_u32(np, "litex,rx-slots", &priv->num_rx_slots);
0208     if (err) {
0209         dev_dbg(priv->dev, "unable to get litex,rx-slots, using 2\n");
0210         priv->num_rx_slots = 2;
0211     }
0212
0213     err = of_property_read_u32(np, "litex,tx-slots", &priv->num_tx_slots);
0214     if (err) {
0215         dev_dbg(priv->dev, "unable to get litex,tx-slots, using 2\n");
0216         priv->num_tx_slots = 2;
0217     }
0218
0219     err = of_property_read_u32(np, "litex,slot-size", &priv->slot_size);
0220     if (err) {
0221         dev_dbg(priv->dev, "unable to get litex,slot-size, using 0x800\n");
0222         priv->slot_size = 0x800;
0223     }
0224 }
0225
0226 static int liteeth_probe(struct platform_device *pdev)
0227 {
0228     struct net_device *netdev;
0229     void __iomem *buf_base;
0230     struct liteeth *priv;
0231     int irq, err;
0232
0233     netdev = devm_alloc_etherdev(&pdev->dev, sizeof(*priv));
0234     if (!netdev)
0235         return -ENOMEM;
0236
0237     SET_NETDEV_DEV(netdev, &pdev->dev);
0238     platform_set_drvdata(pdev, netdev);
0239
0240     priv = netdev_priv(netdev);
0241     priv->netdev = netdev;
0242     priv->dev = &pdev->dev;
0243
0244     irq = platform_get_irq(pdev, 0);
0245     if (irq < 0)
0246         return irq;
0247     netdev->irq = irq;
0248
0249     priv->base = devm_platform_ioremap_resource_byname(pdev, "mac");
0250     if (IS_ERR(priv->base))
0251         return PTR_ERR(priv->base);
0252
0253     buf_base = devm_platform_ioremap_resource_byname(pdev, "buffer");
0254     if (IS_ERR(buf_base))
0255         return PTR_ERR(buf_base);
0256
0257     liteeth_setup_slots(priv);
0258
0259     /* Rx slots */
0260     priv->rx_base = buf_base;
0261     priv->rx_slot = 0;
0262
0263     /* Tx slots come after Rx slots */
0264     priv->tx_base = buf_base + priv->num_rx_slots * priv->slot_size;
0265     priv->tx_slot = 0;
0266
0267     err = of_get_ethdev_address(pdev->dev.of_node, netdev);
0268     if (err)
0269         eth_hw_addr_random(netdev);
0270
0271     netdev->netdev_ops = &liteeth_netdev_ops;
0272
0273     err = register_netdev(netdev);
0274     if (err) {
0275         dev_err(&pdev->dev, "Failed to register netdev %d\n", err);
0276         return err;
0277     }
0278
0279     netdev_info(netdev, "irq %d slots: tx %d rx %d size %d\n",
0280             netdev->irq, priv->num_tx_slots, priv->num_rx_slots, priv->slot_size);
0281
0282     return 0;
0283 }
0284
0285 static int liteeth_remove(struct platform_device *pdev)
0286 {
0287     struct net_device *netdev = platform_get_drvdata(pdev);
0288
0289     unregister_netdev(netdev);
0290
0291     return 0;
0292 }
0293
0294 static const struct of_device_id liteeth_of_match[] = {
0295     { .compatible = "litex,liteeth" },
0296     { }
0297 };
0298 MODULE_DEVICE_TABLE(of, liteeth_of_match);
0299
0300 static struct platform_driver liteeth_driver = {
0301     .probe = liteeth_probe,
0302     .remove = liteeth_remove,
0303     .driver = {
0304         .name = DRV_NAME,
0305         .of_match_table = liteeth_of_match,
0306     },
0307 };
0308 module_platform_driver(liteeth_driver);
0309
0310 MODULE_AUTHOR("Joel Stanley <joel@jms.id.au>");
0311 MODULE_LICENSE("GPL");