leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

sun4i-emac.c: add dma support

Browse Source 
Thanks for your review. Here is the new version for this patch.

This patch adds support for the emac rx dma present on sun4i. The emac
is able to move packets from rx fifo to RAM by using dma.

Change since v4.
  - rename sbk field to skb
  - rename alloc_emac_dma_req to emac_alloc_dma_req
  - using kzalloc(..., GPF_ATOMIC) in interrupt context to avoid
    sleeping
  - retry by using emac_inblk_32bit when emac_dma_inblk_32bit fails
  - fix some code style issues

Change since v5.
  - fix some code style issue

Signed-off-by: Conley Lee <conleylee@foxmail.com>
Link: https://lore.kernel.org/r/tencent_DE05ADA53D5B084D4605BE6CB11E49EF7408@qq.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
This commit is contained in:
Conley Lee 2021-12-29 09:43:51 +08:00 committed by Jakub Kicinski
parent e2dfb94f27
commit 47869e82c8
1 changed files with 200 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

200
drivers/net/ethernet/allwinner/sun4i-emac.c
View File

@ -29,6 +29,7 @@
#include <linux/platform_device.h>
#include <linux/phy.h>
#include <linux/soc/sunxi/sunxi_sram.h>
#include <linux/dmaengine.h>
#include "sun4i-emac.h"
@ -86,6 +87,16 @@ struct emac_board_info {
unsigned int duplex;
phy_interface_t phy_interface;
struct dma_chan *rx_chan;
phys_addr_t emac_rx_fifo;
};
struct emac_dma_req {
struct emac_board_info *db;
struct dma_async_tx_descriptor *desc;
struct sk_buff *skb;
dma_addr_t rxbuf;
int count;
};
static void emac_update_speed(struct net_device *dev)
@ -205,6 +216,117 @@ static void emac_inblk_32bit(void __iomem *reg, void *data, int count)
readsl(reg, data, round_up(count, 4) / 4);
}
static struct emac_dma_req *
emac_alloc_dma_req(struct emac_board_info *db,
struct dma_async_tx_descriptor *desc, struct sk_buff *skb,
dma_addr_t rxbuf, int count)
{
struct emac_dma_req *req;
req = kzalloc(sizeof(struct emac_dma_req), GFP_ATOMIC);
if (!req)
return NULL;
req->db = db;
req->desc = desc;
req->skb = skb;
req->rxbuf = rxbuf;
req->count = count;
return req;
}
static void emac_free_dma_req(struct emac_dma_req *req)
{
kfree(req);
}
static void emac_dma_done_callback(void *arg)
{
struct emac_dma_req *req = arg;
struct emac_board_info *db = req->db;
struct sk_buff *skb = req->skb;
struct net_device *dev = db->ndev;
int rxlen = req->count;
u32 reg_val;
dma_unmap_single(db->dev, req->rxbuf, rxlen, DMA_FROM_DEVICE);
skb->protocol = eth_type_trans(skb, dev);
netif_rx(skb);
dev->stats.rx_bytes += rxlen;
/* Pass to upper layer */
dev->stats.rx_packets++;
/* re enable cpu receive */
reg_val = readl(db->membase + EMAC_RX_CTL_REG);
reg_val &= ~EMAC_RX_CTL_DMA_EN;
writel(reg_val, db->membase + EMAC_RX_CTL_REG);
/* re enable interrupt */
reg_val = readl(db->membase + EMAC_INT_CTL_REG);
reg_val |= (0x01 << 8);
writel(reg_val, db->membase + EMAC_INT_CTL_REG);
db->emacrx_completed_flag = 1;
emac_free_dma_req(req);
}
static int emac_dma_inblk_32bit(struct emac_board_info *db,
struct sk_buff *skb, void *rdptr, int count)
{
struct dma_async_tx_descriptor *desc;
dma_cookie_t cookie;
dma_addr_t rxbuf;
struct emac_dma_req *req;
int ret = 0;
rxbuf = dma_map_single(db->dev, rdptr, count, DMA_FROM_DEVICE);
ret = dma_mapping_error(db->dev, rxbuf);
if (ret) {
dev_err(db->dev, "dma mapping error.\n");
return ret;
}
desc = dmaengine_prep_slave_single(db->rx_chan, rxbuf, count,
DMA_DEV_TO_MEM,
DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
if (!desc) {
dev_err(db->dev, "prepare slave single failed\n");
ret = -ENOMEM;
goto prepare_err;
}
req = emac_alloc_dma_req(db, desc, skb, rxbuf, count);
if (!req) {
dev_err(db->dev, "alloc emac dma req error.\n");
ret = -ENOMEM;
goto alloc_req_err;
}
desc->callback_param = req;
desc->callback = emac_dma_done_callback;
cookie = dmaengine_submit(desc);
ret = dma_submit_error(cookie);
if (ret) {
dev_err(db->dev, "dma submit error.\n");
goto submit_err;
}
dma_async_issue_pending(db->rx_chan);
return ret;
submit_err:
emac_free_dma_req(req);
alloc_req_err:
dmaengine_desc_free(desc);
prepare_err:
dma_unmap_single(db->dev, rxbuf, count, DMA_FROM_DEVICE);
return ret;
}
/* ethtool ops */
static void emac_get_drvinfo(struct net_device *dev,
struct ethtool_drvinfo *info)
@ -605,6 +727,19 @@ static void emac_rx(struct net_device *dev)
if (netif_msg_rx_status(db))
dev_dbg(db->dev, "RxLen %x\n", rxlen);
if (rxlen >= dev->mtu && db->rx_chan) {
reg_val = readl(db->membase + EMAC_RX_CTL_REG);
reg_val |= EMAC_RX_CTL_DMA_EN;
writel(reg_val, db->membase + EMAC_RX_CTL_REG);
if (!emac_dma_inblk_32bit(db, skb, rdptr, rxlen))
break;
/* re enable cpu receive. then try to receive by emac_inblk_32bit */
reg_val = readl(db->membase + EMAC_RX_CTL_REG);
reg_val &= ~EMAC_RX_CTL_DMA_EN;
writel(reg_val, db->membase + EMAC_RX_CTL_REG);
}
emac_inblk_32bit(db->membase + EMAC_RX_IO_DATA_REG,
rdptr, rxlen);
dev->stats.rx_bytes += rxlen;
@ -659,7 +794,12 @@ static irqreturn_t emac_interrupt(int irq, void *dev_id)
reg_val = readl(db->membase + EMAC_INT_CTL_REG);
reg_val |= (0xf << 0) | (0x01 << 8);
writel(reg_val, db->membase + EMAC_INT_CTL_REG);
} else {
reg_val = readl(db->membase + EMAC_INT_CTL_REG);
reg_val |= (0xf << 0);
writel(reg_val, db->membase + EMAC_INT_CTL_REG);
}
spin_unlock(&db->lock);
return IRQ_HANDLED;
@ -764,6 +904,58 @@ static const struct net_device_ops emac_netdev_ops = {
#endif
};
static int emac_configure_dma(struct emac_board_info *db)
{
struct platform_device *pdev = db->pdev;
struct net_device *ndev = db->ndev;
struct dma_slave_config conf = {};
struct resource *regs;
int err = 0;
regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!regs) {
netdev_err(ndev, "get io resource from device failed.\n");
err = -ENOMEM;
goto out_clear_chan;
}
netdev_info(ndev, "get io resource from device: 0x%x, size = %u\n",
regs->start, resource_size(regs));
db->emac_rx_fifo = regs->start + EMAC_RX_IO_DATA_REG;
db->rx_chan = dma_request_chan(&pdev->dev, "rx");
if (IS_ERR(db->rx_chan)) {
netdev_err(ndev,
"failed to request dma channel. dma is disabled\n");
err = PTR_ERR(db->rx_chan);
goto out_clear_chan;
}
conf.direction = DMA_DEV_TO_MEM;
conf.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
conf.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
conf.src_addr = db->emac_rx_fifo;
conf.dst_maxburst = 4;
conf.src_maxburst = 4;
conf.device_fc = false;
err = dmaengine_slave_config(db->rx_chan, &conf);
if (err) {
netdev_err(ndev, "config dma slave failed\n");
err = -EINVAL;
goto out_slave_configure_err;
}
return err;
out_slave_configure_err:
dma_release_channel(db->rx_chan);
out_clear_chan:
db->rx_chan = NULL;
return err;
}
/* Search EMAC board, allocate space and register it
*/
static int emac_probe(struct platform_device *pdev)
@ -806,6 +998,9 @@ static int emac_probe(struct platform_device *pdev)
goto out_iounmap;
}
if (emac_configure_dma(db))
netdev_info(ndev, "configure dma failed. disable dma.\n");
db->clk = devm_clk_get(&pdev->dev, NULL);
if (IS_ERR(db->clk)) {
ret = PTR_ERR(db->clk);
@ -888,6 +1083,11 @@ static int emac_remove(struct platform_device *pdev)
struct net_device *ndev = platform_get_drvdata(pdev);
struct emac_board_info *db = netdev_priv(ndev);
if (db->rx_chan) {
dmaengine_terminate_all(db->rx_chan);
dma_release_channel(db->rx_chan);
}
unregister_netdev(ndev);
sunxi_sram_release(&pdev->dev);
clk_disable_unprepare(db->clk);