drivers/net/xilinx_axi_mrmac.c - platform/external/u-boot - Gitiles

 // SPDX-License-Identifier: GPL-2.0
 /*
  * Xilinx Multirate Ethernet MAC(MRMAC) driver
  *
  * Author(s):   Ashok Reddy Soma <ashok.reddy.soma@xilinx.com>
  *              Michal Simek <michal.simek@xilinx.com>
  *
  * Copyright (C) 2021 Xilinx, Inc. All rights reserved.
  */

 #include <config.h>
 #include <common.h>
 #include <cpu_func.h>
 #include <dm.h>
 #include <log.h>
 #include <net.h>
 #include <malloc.h>
 #include <wait_bit.h>
 #include <asm/io.h>
 #include <linux/delay.h>
 #include <linux/ethtool.h>
 #include "xilinx_axi_mrmac.h"

 static void axi_mrmac_dma_write(struct mcdma_bd *bd, u32 *desc)
 {
 	if (IS_ENABLED(CONFIG_PHYS_64BIT))
 		writeq((unsigned long)bd, desc);
 	else
 		writel((uintptr_t)bd, desc);
 }

 /**
  * axi_mrmac_ethernet_init - MRMAC init function
  * @priv:	MRMAC private structure
  *
  * Return:	0 on success, negative value on errors
  *
  * This function is called to reset and initialize MRMAC core. This is
  * typically called during initialization. It does a reset of MRMAC Rx/Tx
  * channels and Rx/Tx SERDES. It configures MRMAC speed based on mrmac_rate
  * which is read from DT. This function waits for block lock bit to get set,
  * if it is not set within 100ms time returns a timeout error.
  */
 static int axi_mrmac_ethernet_init(struct axi_mrmac_priv *priv)
 {
 	struct mrmac_regs *regs = priv->iobase;
 	u32 reg;
 	u32 ret;

 	/* Perform all the RESET's required */
 	setbits_le32(&regs->reset, MRMAC_RX_SERDES_RST_MASK | MRMAC_RX_RST_MASK
 		     | MRMAC_TX_SERDES_RST_MASK | MRMAC_TX_RST_MASK);

 	mdelay(MRMAC_RESET_DELAY);

 	/* Configure Mode register */
 	reg = readl(&regs->mode);

 	log_debug("Configuring MRMAC speed to %d\n", priv->mrmac_rate);

 	if (priv->mrmac_rate == SPEED_25000) {
 		reg &= ~MRMAC_CTL_RATE_CFG_MASK;
 		reg |= MRMAC_CTL_DATA_RATE_25G;
 		reg |= (MRMAC_CTL_AXIS_CFG_25G_IND << MRMAC_CTL_AXIS_CFG_SHIFT);
 		reg |= (MRMAC_CTL_SERDES_WIDTH_25G <<
 			MRMAC_CTL_SERDES_WIDTH_SHIFT);
 	} else {
 		reg &= ~MRMAC_CTL_RATE_CFG_MASK;
 		reg |= MRMAC_CTL_DATA_RATE_10G;
 		reg |= (MRMAC_CTL_AXIS_CFG_10G_IND << MRMAC_CTL_AXIS_CFG_SHIFT);
 		reg |= (MRMAC_CTL_SERDES_WIDTH_10G <<
 			MRMAC_CTL_SERDES_WIDTH_SHIFT);
 	}

 	/* For tick reg */
 	reg |= MRMAC_CTL_PM_TICK_MASK;
 	writel(reg, &regs->mode);

 	clrbits_le32(&regs->reset, MRMAC_RX_SERDES_RST_MASK | MRMAC_RX_RST_MASK
 		     | MRMAC_TX_SERDES_RST_MASK | MRMAC_TX_RST_MASK);

 	mdelay(MRMAC_RESET_DELAY);

 	/* Setup MRMAC hardware options */
 	setbits_le32(&regs->rx_config, MRMAC_RX_DEL_FCS_MASK);
 	setbits_le32(&regs->tx_config, MRMAC_TX_INS_FCS_MASK);
 	setbits_le32(&regs->tx_config, MRMAC_TX_EN_MASK);
 	setbits_le32(&regs->rx_config, MRMAC_RX_EN_MASK);

 	/* Check for block lock bit to be set. This ensures that
 	 * MRMAC ethernet IP is functioning normally.
 	 */
 	writel(MRMAC_STS_ALL_MASK, (phys_addr_t)priv->iobase +
 		MRMAC_TX_STS_OFFSET);
 	writel(MRMAC_STS_ALL_MASK, (phys_addr_t)priv->iobase +
 		MRMAC_RX_STS_OFFSET);
 	writel(MRMAC_STS_ALL_MASK, (phys_addr_t)priv->iobase +
 		MRMAC_STATRX_BLKLCK_OFFSET);

 	ret = wait_for_bit_le32((u32 *)((phys_addr_t)priv->iobase +
 				MRMAC_STATRX_BLKLCK_OFFSET),
 				MRMAC_RX_BLKLCK_MASK, true,
 				MRMAC_BLKLCK_TIMEOUT, true);
 	if (ret) {
 		log_warning("Error: MRMAC block lock not complete!\n");
 		return -EIO;
 	}

 	writel(MRMAC_TICK_TRIGGER, &regs->tick_reg);

 	return 0;
 }

 /**
  * axi_mcdma_init - Reset MCDMA engine
  * @priv:	MRMAC private structure
  *
  * Return:	0 on success, negative value on timeouts
  *
  * This function is called to reset and initialize MCDMA engine
  */
 static int axi_mcdma_init(struct axi_mrmac_priv *priv)
 {
 	u32 ret;

 	/* Reset the engine so the hardware starts from a known state */
 	writel(XMCDMA_CR_RESET, &priv->mm2s_cmn->control);
 	writel(XMCDMA_CR_RESET, &priv->s2mm_cmn->control);

 	/* Check Tx/Rx MCDMA.RST. Reset is done when the reset bit is low */
 	ret = wait_for_bit_le32(&priv->mm2s_cmn->control, XMCDMA_CR_RESET,
 				false, MRMAC_DMARST_TIMEOUT, true);
 	if (ret) {
 		log_warning("Tx MCDMA reset Timeout\n");
 		return -ETIMEDOUT;
 	}

 	ret = wait_for_bit_le32(&priv->s2mm_cmn->control, XMCDMA_CR_RESET,
 				false, MRMAC_DMARST_TIMEOUT, true);
 	if (ret) {
 		log_warning("Rx MCDMA reset Timeout\n");
 		return -ETIMEDOUT;
 	}

 	/* Enable channel 1 for Tx and Rx */
 	writel(XMCDMA_CHANNEL_1, &priv->mm2s_cmn->chen);
 	writel(XMCDMA_CHANNEL_1, &priv->s2mm_cmn->chen);

 	return 0;
 }

 /**
  * axi_mrmac_start - MRMAC start
  * @dev:	udevice structure
  *
  * Return:	0 on success, negative value on errors
  *
  * This is a initialization function of MRMAC. Call MCDMA initialization
  * function and setup Rx buffer descriptors for starting reception of packets.
  * Enable Tx and Rx channels and trigger Rx channel fetch.
  */
 static int axi_mrmac_start(struct udevice *dev)
 {
 	struct axi_mrmac_priv *priv = dev_get_priv(dev);
 	struct mrmac_regs *regs = priv->iobase;

 	/*
 	 * Initialize MCDMA engine. MCDMA engine must be initialized before
 	 * MRMAC. During MCDMA engine initialization, MCDMA hardware is reset,
 	 * since MCDMA reset line is connected to MRMAC, this would ensure a
 	 * reset of MRMAC.
 	 */
 	axi_mcdma_init(priv);

 	/* Initialize MRMAC hardware */
 	if (axi_mrmac_ethernet_init(priv))
 		return -EIO;

 	/* Disable all Rx interrupts before RxBD space setup */
 	clrbits_le32(&priv->mcdma_rx->control, XMCDMA_IRQ_ALL_MASK);

 	/* Update current descriptor */
 	axi_mrmac_dma_write(priv->rx_bd[0], &priv->mcdma_rx->current);

 	/* Setup Rx BD. MRMAC needs atleast two descriptors */
 	memset(priv->rx_bd[0], 0, RX_BD_TOTAL_SIZE);

 	priv->rx_bd[0]->next_desc = lower_32_bits((u64)priv->rx_bd[1]);
 	priv->rx_bd[0]->buf_addr = lower_32_bits((u64)net_rx_packets[0]);

 	priv->rx_bd[1]->next_desc = lower_32_bits((u64)priv->rx_bd[0]);
 	priv->rx_bd[1]->buf_addr = lower_32_bits((u64)net_rx_packets[1]);

 	if (IS_ENABLED(CONFIG_PHYS_64BIT)) {
 		priv->rx_bd[0]->next_desc_msb = upper_32_bits((u64)priv->rx_bd[1]);
 		priv->rx_bd[0]->buf_addr_msb = upper_32_bits((u64)net_rx_packets[0]);

 		priv->rx_bd[1]->next_desc_msb = upper_32_bits((u64)priv->rx_bd[0]);
 		priv->rx_bd[1]->buf_addr_msb = upper_32_bits((u64)net_rx_packets[1]);
 	}

 	priv->rx_bd[0]->cntrl = PKTSIZE_ALIGN;
 	priv->rx_bd[1]->cntrl = PKTSIZE_ALIGN;

 	/* Flush the last BD so DMA core could see the updates */
 	flush_cache((phys_addr_t)priv->rx_bd[0], RX_BD_TOTAL_SIZE);

 	/* It is necessary to flush rx buffers because if you don't do it
 	 * then cache can contain uninitialized data
 	 */
 	flush_cache((phys_addr_t)priv->rx_bd[0]->buf_addr, RX_BUFF_TOTAL_SIZE);

 	/* Start the hardware */
 	setbits_le32(&priv->s2mm_cmn->control, XMCDMA_CR_RUNSTOP_MASK);
 	setbits_le32(&priv->mm2s_cmn->control, XMCDMA_CR_RUNSTOP_MASK);
 	setbits_le32(&priv->mcdma_rx->control, XMCDMA_IRQ_ALL_MASK);

 	/* Channel fetch */
 	setbits_le32(&priv->mcdma_rx->control, XMCDMA_CR_RUNSTOP_MASK);

 	/* Update tail descriptor. Now it's ready to receive data */
 	axi_mrmac_dma_write(priv->rx_bd[1], &priv->mcdma_rx->tail);

 	/* Enable Tx */
 	setbits_le32(&regs->tx_config, MRMAC_TX_EN_MASK);

 	/* Enable Rx */
 	setbits_le32(&regs->rx_config, MRMAC_RX_EN_MASK);

 	return 0;
 }

 /**
  * axi_mrmac_send - MRMAC Tx function
  * @dev:	udevice structure
  * @ptr:	pointer to Tx buffer
  * @len:	transfer length
  *
  * Return:	0 on success, negative value on errors
  *
  * This is a Tx send function of MRMAC. Setup Tx buffer descriptors and trigger
  * transfer. Wait till the data is transferred.
  */
 static int axi_mrmac_send(struct udevice *dev, void *ptr, int len)
 {
 	struct axi_mrmac_priv *priv = dev_get_priv(dev);
 	u32 ret;

 #ifdef DEBUG
 	print_buffer(ptr, ptr, 1, len, 16);
 #endif
 	if (len > PKTSIZE_ALIGN)
 		len = PKTSIZE_ALIGN;

 	/* If size is less than min packet size, pad to min size */
 	if (len < MIN_PKT_SIZE) {
 		memset(priv->txminframe, 0, MIN_PKT_SIZE);
 		memcpy(priv->txminframe, ptr, len);
 		len = MIN_PKT_SIZE;
 		ptr = priv->txminframe;
 	}

 	writel(XMCDMA_IRQ_ALL_MASK, &priv->mcdma_tx->status);

 	clrbits_le32(&priv->mcdma_tx->control, XMCDMA_CR_RUNSTOP_MASK);

 	/* Flush packet to main memory to be trasfered by DMA */
 	flush_cache((phys_addr_t)ptr, len);

 	/* Setup Tx BD. MRMAC needs atleast two descriptors */
 	memset(priv->tx_bd[0], 0, TX_BD_TOTAL_SIZE);

 	priv->tx_bd[0]->next_desc = lower_32_bits((u64)priv->tx_bd[1]);
 	priv->tx_bd[0]->buf_addr = lower_32_bits((u64)ptr);

 	/* At the end of the ring, link the last BD back to the top */
 	priv->tx_bd[1]->next_desc = lower_32_bits((u64)priv->tx_bd[0]);
 	priv->tx_bd[1]->buf_addr = lower_32_bits((u64)ptr + len / 2);

 	if (IS_ENABLED(CONFIG_PHYS_64BIT)) {
 		priv->tx_bd[0]->next_desc_msb = upper_32_bits((u64)priv->tx_bd[1]);
 		priv->tx_bd[0]->buf_addr_msb = upper_32_bits((u64)ptr);

 		priv->tx_bd[1]->next_desc_msb = upper_32_bits((u64)priv->tx_bd[0]);
 		priv->tx_bd[1]->buf_addr_msb = upper_32_bits((u64)ptr + len / 2);
 	}

 	/* Split Tx data in to half and send in two descriptors */
 	priv->tx_bd[0]->cntrl = (len / 2) | XMCDMA_BD_CTRL_TXSOF_MASK;
 	priv->tx_bd[1]->cntrl = (len - len / 2) | XMCDMA_BD_CTRL_TXEOF_MASK;

 	/* Flush the last BD so DMA core could see the updates */
 	flush_cache((phys_addr_t)priv->tx_bd[0], TX_BD_TOTAL_SIZE);

 	if (readl(&priv->mcdma_tx->status) & XMCDMA_CH_IDLE) {
 		axi_mrmac_dma_write(priv->tx_bd[0], &priv->mcdma_tx->current);
 		/* Channel fetch */
 		setbits_le32(&priv->mcdma_tx->control, XMCDMA_CR_RUNSTOP_MASK);
 	} else {
 		log_warning("Error: current desc is not updated\n");
 		return -EIO;
 	}

 	setbits_le32(&priv->mcdma_tx->control, XMCDMA_IRQ_ALL_MASK);

 	/* Start transfer */
 	axi_mrmac_dma_write(priv->tx_bd[1], &priv->mcdma_tx->tail);

 	/* Wait for transmission to complete */
 	ret = wait_for_bit_le32(&priv->mcdma_tx->status, XMCDMA_IRQ_IOC_MASK,
 				true, 1, true);
 	if (ret) {
 		log_warning("%s: Timeout\n", __func__);
 		return -ETIMEDOUT;
 	}

 	/* Clear status */
 	priv->tx_bd[0]->sband_stats = 0;
 	priv->tx_bd[1]->sband_stats = 0;

 	log_debug("Sending complete\n");

 	return 0;
 }

 static bool isrxready(struct axi_mrmac_priv *priv)
 {
 	u32 status;

 	/* Read pending interrupts */
 	status = readl(&priv->mcdma_rx->status);

 	/* Acknowledge pending interrupts */
 	writel(status & XMCDMA_IRQ_ALL_MASK, &priv->mcdma_rx->status);

 	/*
 	 * If Reception done interrupt is asserted, call Rx call back function
 	 * to handle the processed BDs and then raise the according flag.
 	 */
 	if (status & (XMCDMA_IRQ_IOC_MASK | XMCDMA_IRQ_DELAY_MASK))
 		return 1;

 	return 0;
 }

 /**
  * axi_mrmac_recv - MRMAC Rx function
  * @dev:	udevice structure
  * @flags:	flags from network stack
  * @packetp	pointer to received data
  *
  * Return:	received data length on success, negative value on errors
  *
  * This is a Rx function of MRMAC. Check if any data is received on MCDMA.
  * Copy buffer pointer to packetp and return received data length.
  */
 static int axi_mrmac_recv(struct udevice *dev, int flags, uchar **packetp)
 {
 	struct axi_mrmac_priv *priv = dev_get_priv(dev);
 	u32 rx_bd_end;
 	u32 length;

 	/* Wait for an incoming packet */
 	if (!isrxready(priv))
 		return -EAGAIN;

 	/* Clear all interrupts */
 	writel(XMCDMA_IRQ_ALL_MASK, &priv->mcdma_rx->status);

 	/* Disable IRQ for a moment till packet is handled */
 	clrbits_le32(&priv->mcdma_rx->control, XMCDMA_IRQ_ALL_MASK);

 	/* Disable channel fetch */
 	clrbits_le32(&priv->mcdma_rx->control, XMCDMA_CR_RUNSTOP_MASK);

 	rx_bd_end = (ulong)priv->rx_bd[0] + roundup(RX_BD_TOTAL_SIZE,
 						    ARCH_DMA_MINALIGN);
 	/* Invalidate Rx descriptors to see proper Rx length */
 	invalidate_dcache_range((phys_addr_t)priv->rx_bd[0], rx_bd_end);

 	length = priv->rx_bd[0]->status & XMCDMA_BD_STS_ACTUAL_LEN_MASK;
 	*packetp = (uchar *)(ulong)priv->rx_bd[0]->buf_addr;

 	if (!length) {
 		length = priv->rx_bd[1]->status & XMCDMA_BD_STS_ACTUAL_LEN_MASK;
 		*packetp = (uchar *)(ulong)priv->rx_bd[1]->buf_addr;
 	}

 #ifdef DEBUG
 	print_buffer(*packetp, *packetp, 1, length, 16);
 #endif
 	/* Clear status */
 	priv->rx_bd[0]->status = 0;
 	priv->rx_bd[1]->status = 0;

 	return length;
 }

 /**
  * axi_mrmac_free_pkt - MRMAC free packet function
  * @dev:	udevice structure
  * @packet:	receive buffer pointer
  * @length	received data length
  *
  * Return:	0 on success, negative value on errors
  *
  * This is Rx free packet function of MRMAC. Prepare MRMAC for reception of
  * data again. Invalidate previous data from Rx buffers and set Rx buffer
  * descriptors. Trigger reception by updating tail descriptor.
  */
 static int axi_mrmac_free_pkt(struct udevice *dev, uchar *packet, int length)
 {
 	struct axi_mrmac_priv *priv = dev_get_priv(dev);

 #ifdef DEBUG
 	/* It is useful to clear buffer to be sure that it is consistent */
 	memset(priv->rx_bd[0]->buf_addr, 0, RX_BUFF_TOTAL_SIZE);
 #endif
 	/* Disable all Rx interrupts before RxBD space setup */
 	clrbits_le32(&priv->mcdma_rx->control, XMCDMA_IRQ_ALL_MASK);

 	/* Disable channel fetch */
 	clrbits_le32(&priv->mcdma_rx->control, XMCDMA_CR_RUNSTOP_MASK);

 	/* Update current descriptor */
 	axi_mrmac_dma_write(priv->rx_bd[0], &priv->mcdma_rx->current);

 	/* Write bd to HW */
 	flush_cache((phys_addr_t)priv->rx_bd[0], RX_BD_TOTAL_SIZE);

 	/* It is necessary to flush rx buffers because if you don't do it
 	 * then cache will contain previous packet
 	 */
 	flush_cache((phys_addr_t)priv->rx_bd[0]->buf_addr, RX_BUFF_TOTAL_SIZE);

 	/* Enable all IRQ */
 	setbits_le32(&priv->mcdma_rx->control, XMCDMA_IRQ_ALL_MASK);

 	/* Channel fetch */
 	setbits_le32(&priv->mcdma_rx->control, XMCDMA_CR_RUNSTOP_MASK);

 	/* Update tail descriptor. Now it's ready to receive data */
 	axi_mrmac_dma_write(priv->rx_bd[1], &priv->mcdma_rx->tail);

 	log_debug("Rx completed, framelength = %x\n", length);

 	return 0;
 }

 /**
  * axi_mrmac_stop - Stop MCDMA transfers
  * @dev:	udevice structure
  *
  * Return:	0 on success, negative value on errors
  *
  * Stop MCDMA engine for both Tx and Rx transfers.
  */
 static void axi_mrmac_stop(struct udevice *dev)
 {
 	struct axi_mrmac_priv *priv = dev_get_priv(dev);

 	/* Stop the hardware */
 	clrbits_le32(&priv->mcdma_tx->control, XMCDMA_CR_RUNSTOP_MASK);
 	clrbits_le32(&priv->mcdma_rx->control, XMCDMA_CR_RUNSTOP_MASK);

 	log_debug("Halted\n");
 }

 static int axi_mrmac_probe(struct udevice *dev)
 {
 	struct axi_mrmac_plat *plat = dev_get_plat(dev);
 	struct eth_pdata *pdata = &plat->eth_pdata;
 	struct axi_mrmac_priv *priv = dev_get_priv(dev);

 	priv->iobase = (struct mrmac_regs *)pdata->iobase;

 	priv->mm2s_cmn = plat->mm2s_cmn;
 	priv->mcdma_tx = (struct mcdma_chan_reg *)((phys_addr_t)priv->mm2s_cmn
 						   + XMCDMA_CHAN_OFFSET);
 	priv->s2mm_cmn = (struct mcdma_common_regs *)((phys_addr_t)priv->mm2s_cmn
 						      + XMCDMA_RX_OFFSET);
 	priv->mcdma_rx = (struct mcdma_chan_reg *)((phys_addr_t)priv->s2mm_cmn
 						   + XMCDMA_CHAN_OFFSET);
 	priv->mrmac_rate = plat->mrmac_rate;

 	/* Align buffers to ARCH_DMA_MINALIGN */
 	priv->tx_bd[0] = memalign(ARCH_DMA_MINALIGN, TX_BD_TOTAL_SIZE);
 	priv->tx_bd[1] = (struct mcdma_bd *)((ulong)priv->tx_bd[0] +
 					     sizeof(struct mcdma_bd));

 	priv->rx_bd[0] = memalign(ARCH_DMA_MINALIGN, RX_BD_TOTAL_SIZE);
 	priv->rx_bd[1] = (struct mcdma_bd *)((ulong)priv->rx_bd[0] +
 					     sizeof(struct mcdma_bd));

 	priv->txminframe = memalign(ARCH_DMA_MINALIGN, MIN_PKT_SIZE);

 	return 0;
 }

 static int axi_mrmac_remove(struct udevice *dev)
 {
 	struct axi_mrmac_priv *priv = dev_get_priv(dev);

 	/* Free buffer descriptors */
 	free(priv->tx_bd[0]);
 	free(priv->rx_bd[0]);
 	free(priv->txminframe);

 	return 0;
 }

 static int axi_mrmac_of_to_plat(struct udevice *dev)
 {
 	struct axi_mrmac_plat *plat = dev_get_plat(dev);
 	struct eth_pdata *pdata = &plat->eth_pdata;
 	struct ofnode_phandle_args phandle_args;
 	int ret = 0;

 	pdata->iobase = dev_read_addr(dev);

 	ret = dev_read_phandle_with_args(dev, "axistream-connected", NULL, 0, 0,
 					 &phandle_args);
 	if (ret) {
 		log_debug("axistream not found\n");
 		return -EINVAL;
 	}

 	plat->mm2s_cmn = (struct mcdma_common_regs *)ofnode_read_u64_default
 						(phandle_args.node, "reg", -1);
 	if (!plat->mm2s_cmn) {
 		log_warning("MRMAC dma register space not found\n");
 		return -EINVAL;
 	}

 	/* Set default MRMAC rate to 10000 */
 	plat->mrmac_rate = dev_read_u32_default(dev, "xlnx,mrmac-rate", 10000);

 	return 0;
 }

 static const struct eth_ops axi_mrmac_ops = {
 	.start			= axi_mrmac_start,
 	.send			= axi_mrmac_send,
 	.recv			= axi_mrmac_recv,
 	.free_pkt		= axi_mrmac_free_pkt,
 	.stop			= axi_mrmac_stop,
 };

 static const struct udevice_id axi_mrmac_ids[] = {
 	{ .compatible = "xlnx,mrmac-ethernet-1.0" },
 	{ }
 };

 U_BOOT_DRIVER(axi_mrmac) = {
 	.name   = "axi_mrmac",
 	.id     = UCLASS_ETH,
 	.of_match = axi_mrmac_ids,
 	.of_to_plat = axi_mrmac_of_to_plat,
 	.probe  = axi_mrmac_probe,
 	.remove = axi_mrmac_remove,
 	.ops    = &axi_mrmac_ops,
 	.priv_auto = sizeof(struct axi_mrmac_priv),
 	.plat_auto = sizeof(struct axi_mrmac_plat),
 };
	// SPDX-License-Identifier: GPL-2.0
	/*
	* Xilinx Multirate Ethernet MAC(MRMAC) driver
	*
	* Author(s): Ashok Reddy Soma <ashok.reddy.soma@xilinx.com>
	* Michal Simek <michal.simek@xilinx.com>
	*
	* Copyright (C) 2021 Xilinx, Inc. All rights reserved.
	*/

	#include <config.h>
	#include <common.h>
	#include <cpu_func.h>
	#include <dm.h>
	#include <log.h>
	#include <net.h>
	#include <malloc.h>
	#include <wait_bit.h>
	#include <asm/io.h>
	#include <linux/delay.h>
	#include <linux/ethtool.h>
	#include "xilinx_axi_mrmac.h"

	static void axi_mrmac_dma_write(struct mcdma_bd bd, u32 desc)
	{
	if (IS_ENABLED(CONFIG_PHYS_64BIT))
	writeq((unsigned long)bd, desc);
	else
	writel((uintptr_t)bd, desc);
	}

	/**
	* axi_mrmac_ethernet_init - MRMAC init function
	* @priv: MRMAC private structure
	*
	* Return: 0 on success, negative value on errors
	*
	* This function is called to reset and initialize MRMAC core. This is
	* typically called during initialization. It does a reset of MRMAC Rx/Tx
	* channels and Rx/Tx SERDES. It configures MRMAC speed based on mrmac_rate
	* which is read from DT. This function waits for block lock bit to get set,
	* if it is not set within 100ms time returns a timeout error.
	*/
	static int axi_mrmac_ethernet_init(struct axi_mrmac_priv *priv)
	{
	struct mrmac_regs *regs = priv->iobase;
	u32 reg;
	u32 ret;

	/* Perform all the RESET's required */
	setbits_le32(&regs->reset, MRMAC_RX_SERDES_RST_MASK \| MRMAC_RX_RST_MASK
	\| MRMAC_TX_SERDES_RST_MASK \| MRMAC_TX_RST_MASK);

	mdelay(MRMAC_RESET_DELAY);

	/* Configure Mode register */
	reg = readl(&regs->mode);

	log_debug("Configuring MRMAC speed to %d\n", priv->mrmac_rate);

	if (priv->mrmac_rate == SPEED_25000) {
	reg &= ~MRMAC_CTL_RATE_CFG_MASK;
	reg \|= MRMAC_CTL_DATA_RATE_25G;
	reg \|= (MRMAC_CTL_AXIS_CFG_25G_IND << MRMAC_CTL_AXIS_CFG_SHIFT);
	reg \|= (MRMAC_CTL_SERDES_WIDTH_25G <<
	MRMAC_CTL_SERDES_WIDTH_SHIFT);
	} else {
	reg &= ~MRMAC_CTL_RATE_CFG_MASK;
	reg \|= MRMAC_CTL_DATA_RATE_10G;
	reg \|= (MRMAC_CTL_AXIS_CFG_10G_IND << MRMAC_CTL_AXIS_CFG_SHIFT);
	reg \|= (MRMAC_CTL_SERDES_WIDTH_10G <<
	MRMAC_CTL_SERDES_WIDTH_SHIFT);
	}

	/* For tick reg */
	reg \|= MRMAC_CTL_PM_TICK_MASK;
	writel(reg, &regs->mode);

	clrbits_le32(&regs->reset, MRMAC_RX_SERDES_RST_MASK \| MRMAC_RX_RST_MASK
	\| MRMAC_TX_SERDES_RST_MASK \| MRMAC_TX_RST_MASK);

	mdelay(MRMAC_RESET_DELAY);

	/* Setup MRMAC hardware options */
	setbits_le32(&regs->rx_config, MRMAC_RX_DEL_FCS_MASK);
	setbits_le32(&regs->tx_config, MRMAC_TX_INS_FCS_MASK);
	setbits_le32(&regs->tx_config, MRMAC_TX_EN_MASK);
	setbits_le32(&regs->rx_config, MRMAC_RX_EN_MASK);

	/* Check for block lock bit to be set. This ensures that
	* MRMAC ethernet IP is functioning normally.
	*/
	writel(MRMAC_STS_ALL_MASK, (phys_addr_t)priv->iobase +
	MRMAC_TX_STS_OFFSET);
	writel(MRMAC_STS_ALL_MASK, (phys_addr_t)priv->iobase +
	MRMAC_RX_STS_OFFSET);
	writel(MRMAC_STS_ALL_MASK, (phys_addr_t)priv->iobase +
	MRMAC_STATRX_BLKLCK_OFFSET);

	ret = wait_for_bit_le32((u32 *)((phys_addr_t)priv->iobase +
	MRMAC_STATRX_BLKLCK_OFFSET),
	MRMAC_RX_BLKLCK_MASK, true,
	MRMAC_BLKLCK_TIMEOUT, true);
	if (ret) {
	log_warning("Error: MRMAC block lock not complete!\n");
	return -EIO;
	}

	writel(MRMAC_TICK_TRIGGER, &regs->tick_reg);

	return 0;
	}

	/**
	* axi_mcdma_init - Reset MCDMA engine
	* @priv: MRMAC private structure
	*
	* Return: 0 on success, negative value on timeouts
	*
	* This function is called to reset and initialize MCDMA engine
	*/
	static int axi_mcdma_init(struct axi_mrmac_priv *priv)
	{
	u32 ret;

	/* Reset the engine so the hardware starts from a known state */
	writel(XMCDMA_CR_RESET, &priv->mm2s_cmn->control);
	writel(XMCDMA_CR_RESET, &priv->s2mm_cmn->control);

	/* Check Tx/Rx MCDMA.RST. Reset is done when the reset bit is low */
	ret = wait_for_bit_le32(&priv->mm2s_cmn->control, XMCDMA_CR_RESET,
	false, MRMAC_DMARST_TIMEOUT, true);
	if (ret) {
	log_warning("Tx MCDMA reset Timeout\n");
	return -ETIMEDOUT;
	}

	ret = wait_for_bit_le32(&priv->s2mm_cmn->control, XMCDMA_CR_RESET,
	false, MRMAC_DMARST_TIMEOUT, true);
	if (ret) {
	log_warning("Rx MCDMA reset Timeout\n");
	return -ETIMEDOUT;
	}

	/* Enable channel 1 for Tx and Rx */
	writel(XMCDMA_CHANNEL_1, &priv->mm2s_cmn->chen);
	writel(XMCDMA_CHANNEL_1, &priv->s2mm_cmn->chen);

	return 0;
	}

	/**
	* axi_mrmac_start - MRMAC start
	* @dev: udevice structure
	*
	* Return: 0 on success, negative value on errors
	*
	* This is a initialization function of MRMAC. Call MCDMA initialization
	* function and setup Rx buffer descriptors for starting reception of packets.
	* Enable Tx and Rx channels and trigger Rx channel fetch.
	*/
	static int axi_mrmac_start(struct udevice *dev)
	{
	struct axi_mrmac_priv *priv = dev_get_priv(dev);
	struct mrmac_regs *regs = priv->iobase;

	/*
	* Initialize MCDMA engine. MCDMA engine must be initialized before
	* MRMAC. During MCDMA engine initialization, MCDMA hardware is reset,
	* since MCDMA reset line is connected to MRMAC, this would ensure a
	* reset of MRMAC.
	*/
	axi_mcdma_init(priv);

	/* Initialize MRMAC hardware */
	if (axi_mrmac_ethernet_init(priv))
	return -EIO;

	/* Disable all Rx interrupts before RxBD space setup */
	clrbits_le32(&priv->mcdma_rx->control, XMCDMA_IRQ_ALL_MASK);

	/* Update current descriptor */
	axi_mrmac_dma_write(priv->rx_bd[0], &priv->mcdma_rx->current);

	/* Setup Rx BD. MRMAC needs atleast two descriptors */
	memset(priv->rx_bd[0], 0, RX_BD_TOTAL_SIZE);

	priv->rx_bd[0]->next_desc = lower_32_bits((u64)priv->rx_bd[1]);
	priv->rx_bd[0]->buf_addr = lower_32_bits((u64)net_rx_packets[0]);

	priv->rx_bd[1]->next_desc = lower_32_bits((u64)priv->rx_bd[0]);
	priv->rx_bd[1]->buf_addr = lower_32_bits((u64)net_rx_packets[1]);

	if (IS_ENABLED(CONFIG_PHYS_64BIT)) {
	priv->rx_bd[0]->next_desc_msb = upper_32_bits((u64)priv->rx_bd[1]);
	priv->rx_bd[0]->buf_addr_msb = upper_32_bits((u64)net_rx_packets[0]);

	priv->rx_bd[1]->next_desc_msb = upper_32_bits((u64)priv->rx_bd[0]);
	priv->rx_bd[1]->buf_addr_msb = upper_32_bits((u64)net_rx_packets[1]);
	}

	priv->rx_bd[0]->cntrl = PKTSIZE_ALIGN;
	priv->rx_bd[1]->cntrl = PKTSIZE_ALIGN;

	/* Flush the last BD so DMA core could see the updates */
	flush_cache((phys_addr_t)priv->rx_bd[0], RX_BD_TOTAL_SIZE);

	/* It is necessary to flush rx buffers because if you don't do it
	* then cache can contain uninitialized data
	*/
	flush_cache((phys_addr_t)priv->rx_bd[0]->buf_addr, RX_BUFF_TOTAL_SIZE);

	/* Start the hardware */
	setbits_le32(&priv->s2mm_cmn->control, XMCDMA_CR_RUNSTOP_MASK);
	setbits_le32(&priv->mm2s_cmn->control, XMCDMA_CR_RUNSTOP_MASK);
	setbits_le32(&priv->mcdma_rx->control, XMCDMA_IRQ_ALL_MASK);

	/* Channel fetch */
	setbits_le32(&priv->mcdma_rx->control, XMCDMA_CR_RUNSTOP_MASK);

	/* Update tail descriptor. Now it's ready to receive data */
	axi_mrmac_dma_write(priv->rx_bd[1], &priv->mcdma_rx->tail);

	/* Enable Tx */
	setbits_le32(&regs->tx_config, MRMAC_TX_EN_MASK);

	/* Enable Rx */
	setbits_le32(&regs->rx_config, MRMAC_RX_EN_MASK);

	return 0;
	}

	/**
	* axi_mrmac_send - MRMAC Tx function
	* @dev: udevice structure
	* @ptr: pointer to Tx buffer
	* @len: transfer length
	*
	* Return: 0 on success, negative value on errors
	*
	* This is a Tx send function of MRMAC. Setup Tx buffer descriptors and trigger
	* transfer. Wait till the data is transferred.
	*/
	static int axi_mrmac_send(struct udevice dev, void ptr, int len)
	{
	struct axi_mrmac_priv *priv = dev_get_priv(dev);
	u32 ret;

	#ifdef DEBUG
	print_buffer(ptr, ptr, 1, len, 16);
	#endif
	if (len > PKTSIZE_ALIGN)
	len = PKTSIZE_ALIGN;

	/* If size is less than min packet size, pad to min size */
	if (len < MIN_PKT_SIZE) {
	memset(priv->txminframe, 0, MIN_PKT_SIZE);
	memcpy(priv->txminframe, ptr, len);
	len = MIN_PKT_SIZE;
	ptr = priv->txminframe;
	}

	writel(XMCDMA_IRQ_ALL_MASK, &priv->mcdma_tx->status);

	clrbits_le32(&priv->mcdma_tx->control, XMCDMA_CR_RUNSTOP_MASK);

	/* Flush packet to main memory to be trasfered by DMA */
	flush_cache((phys_addr_t)ptr, len);

	/* Setup Tx BD. MRMAC needs atleast two descriptors */
	memset(priv->tx_bd[0], 0, TX_BD_TOTAL_SIZE);

	priv->tx_bd[0]->next_desc = lower_32_bits((u64)priv->tx_bd[1]);
	priv->tx_bd[0]->buf_addr = lower_32_bits((u64)ptr);

	/* At the end of the ring, link the last BD back to the top */
	priv->tx_bd[1]->next_desc = lower_32_bits((u64)priv->tx_bd[0]);
	priv->tx_bd[1]->buf_addr = lower_32_bits((u64)ptr + len / 2);

	if (IS_ENABLED(CONFIG_PHYS_64BIT)) {
	priv->tx_bd[0]->next_desc_msb = upper_32_bits((u64)priv->tx_bd[1]);
	priv->tx_bd[0]->buf_addr_msb = upper_32_bits((u64)ptr);

	priv->tx_bd[1]->next_desc_msb = upper_32_bits((u64)priv->tx_bd[0]);
	priv->tx_bd[1]->buf_addr_msb = upper_32_bits((u64)ptr + len / 2);
	}

	/* Split Tx data in to half and send in two descriptors */
	priv->tx_bd[0]->cntrl = (len / 2) \| XMCDMA_BD_CTRL_TXSOF_MASK;
	priv->tx_bd[1]->cntrl = (len - len / 2) \| XMCDMA_BD_CTRL_TXEOF_MASK;

	/* Flush the last BD so DMA core could see the updates */
	flush_cache((phys_addr_t)priv->tx_bd[0], TX_BD_TOTAL_SIZE);

	if (readl(&priv->mcdma_tx->status) & XMCDMA_CH_IDLE) {
	axi_mrmac_dma_write(priv->tx_bd[0], &priv->mcdma_tx->current);
	/* Channel fetch */
	setbits_le32(&priv->mcdma_tx->control, XMCDMA_CR_RUNSTOP_MASK);
	} else {
	log_warning("Error: current desc is not updated\n");
	return -EIO;
	}

	setbits_le32(&priv->mcdma_tx->control, XMCDMA_IRQ_ALL_MASK);

	/* Start transfer */
	axi_mrmac_dma_write(priv->tx_bd[1], &priv->mcdma_tx->tail);

	/* Wait for transmission to complete */
	ret = wait_for_bit_le32(&priv->mcdma_tx->status, XMCDMA_IRQ_IOC_MASK,
	true, 1, true);
	if (ret) {
	log_warning("%s: Timeout\n", __func__);
	return -ETIMEDOUT;
	}

	/* Clear status */
	priv->tx_bd[0]->sband_stats = 0;
	priv->tx_bd[1]->sband_stats = 0;

	log_debug("Sending complete\n");

	return 0;
	}

	static bool isrxready(struct axi_mrmac_priv *priv)
	{
	u32 status;

	/* Read pending interrupts */
	status = readl(&priv->mcdma_rx->status);

	/* Acknowledge pending interrupts */
	writel(status & XMCDMA_IRQ_ALL_MASK, &priv->mcdma_rx->status);

	/*
	* If Reception done interrupt is asserted, call Rx call back function
	* to handle the processed BDs and then raise the according flag.
	*/
	if (status & (XMCDMA_IRQ_IOC_MASK \| XMCDMA_IRQ_DELAY_MASK))
	return 1;

	return 0;
	}

	/**
	* axi_mrmac_recv - MRMAC Rx function
	* @dev: udevice structure
	* @flags: flags from network stack
	* @packetp pointer to received data
	*
	* Return: received data length on success, negative value on errors
	*
	* This is a Rx function of MRMAC. Check if any data is received on MCDMA.
	* Copy buffer pointer to packetp and return received data length.
	*/
	static int axi_mrmac_recv(struct udevice dev, int flags, uchar *packetp)
	{
	struct axi_mrmac_priv *priv = dev_get_priv(dev);
	u32 rx_bd_end;
	u32 length;

	/* Wait for an incoming packet */
	if (!isrxready(priv))
	return -EAGAIN;

	/* Clear all interrupts */
	writel(XMCDMA_IRQ_ALL_MASK, &priv->mcdma_rx->status);

	/* Disable IRQ for a moment till packet is handled */
	clrbits_le32(&priv->mcdma_rx->control, XMCDMA_IRQ_ALL_MASK);

	/* Disable channel fetch */
	clrbits_le32(&priv->mcdma_rx->control, XMCDMA_CR_RUNSTOP_MASK);

	rx_bd_end = (ulong)priv->rx_bd[0] + roundup(RX_BD_TOTAL_SIZE,
	ARCH_DMA_MINALIGN);
	/* Invalidate Rx descriptors to see proper Rx length */
	invalidate_dcache_range((phys_addr_t)priv->rx_bd[0], rx_bd_end);

	length = priv->rx_bd[0]->status & XMCDMA_BD_STS_ACTUAL_LEN_MASK;
	packetp = (uchar )(ulong)priv->rx_bd[0]->buf_addr;

	if (!length) {
	length = priv->rx_bd[1]->status & XMCDMA_BD_STS_ACTUAL_LEN_MASK;
	packetp = (uchar )(ulong)priv->rx_bd[1]->buf_addr;
	}

	#ifdef DEBUG
	print_buffer(packetp, packetp, 1, length, 16);
	#endif
	/* Clear status */
	priv->rx_bd[0]->status = 0;
	priv->rx_bd[1]->status = 0;

	return length;
	}

	/**
	* axi_mrmac_free_pkt - MRMAC free packet function
	* @dev: udevice structure
	* @packet: receive buffer pointer
	* @length received data length
	*
	* Return: 0 on success, negative value on errors
	*
	* This is Rx free packet function of MRMAC. Prepare MRMAC for reception of
	* data again. Invalidate previous data from Rx buffers and set Rx buffer
	* descriptors. Trigger reception by updating tail descriptor.
	*/
	static int axi_mrmac_free_pkt(struct udevice dev, uchar packet, int length)
	{
	struct axi_mrmac_priv *priv = dev_get_priv(dev);

	#ifdef DEBUG
	/* It is useful to clear buffer to be sure that it is consistent */
	memset(priv->rx_bd[0]->buf_addr, 0, RX_BUFF_TOTAL_SIZE);
	#endif
	/* Disable all Rx interrupts before RxBD space setup */
	clrbits_le32(&priv->mcdma_rx->control, XMCDMA_IRQ_ALL_MASK);

	/* Disable channel fetch */
	clrbits_le32(&priv->mcdma_rx->control, XMCDMA_CR_RUNSTOP_MASK);

	/* Update current descriptor */
	axi_mrmac_dma_write(priv->rx_bd[0], &priv->mcdma_rx->current);

	/* Write bd to HW */
	flush_cache((phys_addr_t)priv->rx_bd[0], RX_BD_TOTAL_SIZE);

	/* It is necessary to flush rx buffers because if you don't do it
	* then cache will contain previous packet
	*/
	flush_cache((phys_addr_t)priv->rx_bd[0]->buf_addr, RX_BUFF_TOTAL_SIZE);

	/* Enable all IRQ */
	setbits_le32(&priv->mcdma_rx->control, XMCDMA_IRQ_ALL_MASK);

	/* Channel fetch */
	setbits_le32(&priv->mcdma_rx->control, XMCDMA_CR_RUNSTOP_MASK);

	/* Update tail descriptor. Now it's ready to receive data */
	axi_mrmac_dma_write(priv->rx_bd[1], &priv->mcdma_rx->tail);

	log_debug("Rx completed, framelength = %x\n", length);

	return 0;
	}

	/**
	* axi_mrmac_stop - Stop MCDMA transfers
	* @dev: udevice structure
	*
	* Return: 0 on success, negative value on errors
	*
	* Stop MCDMA engine for both Tx and Rx transfers.
	*/
	static void axi_mrmac_stop(struct udevice *dev)
	{
	struct axi_mrmac_priv *priv = dev_get_priv(dev);

	/* Stop the hardware */
	clrbits_le32(&priv->mcdma_tx->control, XMCDMA_CR_RUNSTOP_MASK);
	clrbits_le32(&priv->mcdma_rx->control, XMCDMA_CR_RUNSTOP_MASK);

	log_debug("Halted\n");
	}

	static int axi_mrmac_probe(struct udevice *dev)
	{
	struct axi_mrmac_plat *plat = dev_get_plat(dev);
	struct eth_pdata *pdata = &plat->eth_pdata;
	struct axi_mrmac_priv *priv = dev_get_priv(dev);

	priv->iobase = (struct mrmac_regs *)pdata->iobase;

	priv->mm2s_cmn = plat->mm2s_cmn;
	priv->mcdma_tx = (struct mcdma_chan_reg *)((phys_addr_t)priv->mm2s_cmn
	+ XMCDMA_CHAN_OFFSET);
	priv->s2mm_cmn = (struct mcdma_common_regs *)((phys_addr_t)priv->mm2s_cmn
	+ XMCDMA_RX_OFFSET);
	priv->mcdma_rx = (struct mcdma_chan_reg *)((phys_addr_t)priv->s2mm_cmn
	+ XMCDMA_CHAN_OFFSET);
	priv->mrmac_rate = plat->mrmac_rate;

	/* Align buffers to ARCH_DMA_MINALIGN */
	priv->tx_bd[0] = memalign(ARCH_DMA_MINALIGN, TX_BD_TOTAL_SIZE);
	priv->tx_bd[1] = (struct mcdma_bd *)((ulong)priv->tx_bd[0] +
	sizeof(struct mcdma_bd));

	priv->rx_bd[0] = memalign(ARCH_DMA_MINALIGN, RX_BD_TOTAL_SIZE);
	priv->rx_bd[1] = (struct mcdma_bd *)((ulong)priv->rx_bd[0] +
	sizeof(struct mcdma_bd));

	priv->txminframe = memalign(ARCH_DMA_MINALIGN, MIN_PKT_SIZE);

	return 0;
	}

	static int axi_mrmac_remove(struct udevice *dev)
	{
	struct axi_mrmac_priv *priv = dev_get_priv(dev);

	/* Free buffer descriptors */
	free(priv->tx_bd[0]);
	free(priv->rx_bd[0]);
	free(priv->txminframe);

	return 0;
	}

	static int axi_mrmac_of_to_plat(struct udevice *dev)
	{
	struct axi_mrmac_plat *plat = dev_get_plat(dev);
	struct eth_pdata *pdata = &plat->eth_pdata;
	struct ofnode_phandle_args phandle_args;
	int ret = 0;

	pdata->iobase = dev_read_addr(dev);

	ret = dev_read_phandle_with_args(dev, "axistream-connected", NULL, 0, 0,
	&phandle_args);
	if (ret) {
	log_debug("axistream not found\n");
	return -EINVAL;
	}

	plat->mm2s_cmn = (struct mcdma_common_regs *)ofnode_read_u64_default
	(phandle_args.node, "reg", -1);
	if (!plat->mm2s_cmn) {
	log_warning("MRMAC dma register space not found\n");
	return -EINVAL;
	}

	/* Set default MRMAC rate to 10000 */
	plat->mrmac_rate = dev_read_u32_default(dev, "xlnx,mrmac-rate", 10000);

	return 0;
	}

	static const struct eth_ops axi_mrmac_ops = {
	.start = axi_mrmac_start,
	.send = axi_mrmac_send,
	.recv = axi_mrmac_recv,
	.free_pkt = axi_mrmac_free_pkt,
	.stop = axi_mrmac_stop,
	};

	static const struct udevice_id axi_mrmac_ids[] = {
	{ .compatible = "xlnx,mrmac-ethernet-1.0" },
	{ }
	};

	U_BOOT_DRIVER(axi_mrmac) = {
	.name = "axi_mrmac",
	.id = UCLASS_ETH,
	.of_match = axi_mrmac_ids,
	.of_to_plat = axi_mrmac_of_to_plat,
	.probe = axi_mrmac_probe,
	.remove = axi_mrmac_remove,
	.ops = &axi_mrmac_ops,
	.priv_auto = sizeof(struct axi_mrmac_priv),
	.plat_auto = sizeof(struct axi_mrmac_plat),
	};