T536_DTU/app_public/fuxi_public/fuxi_bsp/source/fec.c

/*
 * fec.c
 *
 *  Created on: 2019-8-30
 *      Author: sunxi
 */

//sunxi 20220411: 暂时屏蔽
//#ifndef __LIGHT_DIFF_ACT_PRO__
//#define __LIGHT_DIFF_ACT_PRO__
//#endif


#ifndef __SAVE_TO_BUFF_FOR_READ__
#define __SAVE_TO_BUFF_FOR_READ__
#endif



#ifdef __LIGHT_DIFF_ACT_PRO__ // sunxi 20190904 光差保护

#include <linux/kernel.h>
#include <linux/interrupt.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <asm/cacheflush.h>

#include <my_include/fec.h>
#include <my_include/fec_ring.h>

#include "rt.h"
#include "bsp.h"

#include "fec.h"

#ifdef __SAVE_TO_BUFF_FOR_READ__ // 由采样中断读取读取临时缓冲区的数据，因为使用了 memcpy 拷贝了两次数据，效率会低一些

#define FEC_LP_TXBUF_CNT	256		// 发送缓冲区数量最大值

static unsigned char fec2_lp_txbuf[FEC_LP_TXBUF_CNT][FEC_LP_BUF_MAX];

#if 0 // sunxi 20191015
unsigned char fec2_lp_rx_head = 0;
unsigned char fec2_lp_rx_tail = 0;
struct fec_lp_rx_buf fec2_lp_rxbuf[FEC_LP_BUF_CNT_MAX];
#else // sunxi 20191015
struct fec_lp_rx_buf fec2_lp_rxbuf;
unsigned int fec2_lp_rx_cnt = 0;
#endif

#endif // __SAVE_TO_BUFF_FOR_READ__

#define POLL_FRAME			0x50	//巡检报文
#define	SAMP_FRAME			0xA0	//采样报文

#define POLL_FRAME_WORD     (12+4*9)    //轮巡帧6个字，12字节
#define SAMP_FRAME_WORD	    32	//采样帧16个字，32字节  

/* Interrupt events/masks.
*/
#define FEC_ENET_HBERR	((uint)0x80000000)	/* Heartbeat error */
#define FEC_ENET_BABR	((uint)0x40000000)	/* Babbling receiver */
#define FEC_ENET_BABT	((uint)0x20000000)	/* Babbling transmitter */
#define FEC_ENET_GRA	((uint)0x10000000)	/* Graceful stop complete */
#define FEC_ENET_TXF	((uint)0x08000000)	/* Full frame transmitted */
#define FEC_ENET_TXB	((uint)0x04000000)	/* A buffer was transmitted */
#define FEC_ENET_RXF	((uint)0x02000000)	/* Full frame received */
#define FEC_ENET_RXB	((uint)0x01000000)	/* A buffer was received */
#define FEC_ENET_MII	((uint)0x00800000)	/* MII interrupt */
#define FEC_ENET_EBERR	((uint)0x00400000)	/* SDMA bus error */
#define FEC_ENET_TS_AVAIL       ((uint)0x00010000)
#define FEC_ENET_TS_TIMER       ((uint)0x00008000)


static struct net_device *g_fec2_netdev = NULL;
struct	sk_buff	g_fec2_skb[FEC_LP_TXBUF_CNT];

#ifdef __FEC2_LDAP_TEST__
#define TEST_BUF_MAX	64
static unsigned char g_test_buf[TEST_BUF_MAX] = {0x00};
static unsigned long g_fec2_us1, g_fec2_us2, g_fec2_us3;
#endif // __FEC2_LDAP_TEST__

static int fec2_lp_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct fec_enet_private *fep;
	volatile fec_t	*fecp;
	volatile cbd_t	*bdp, *bdp_tmp;
	unsigned short	status;

	fep = netdev_priv(dev);
	fecp = (volatile fec_t *)dev->base_addr;

	if (!fep->link) {
		/* Link is down or autonegotiation is in progress. */
		return 1;
	}

	/* Fill in a Tx ring entry */
	bdp = fep->cur_tx;

	status = bdp->cbd_sc;
#ifndef final_version
	if (status & BD_ENET_TX_READY) {
		/* Ooops.  All transmit buffers are full.  Bail out.
		 * This should not happen, since dev->tbusy should be set.
		 */
		// sunxi 20190814 printk(KERN_ERR "%s: tx queue full!.\n", dev->name);

		return 1;
	}
#endif

	/* Clear all of the status flags.
	 */
	status &= ~BD_ENET_TX_STATS;

	/* Set buffer length and buffer pointer.
	*/
	bdp->cbd_bufaddr = __pa(skb->data);
	bdp->cbd_datlen = skb->len;

	/*
	 *	On some FEC implementations data must be aligned on
	 *	4-byte boundaries. Use bounce buffers to copy data
	 *	and get it aligned. Ugh.
	 */
	/*if (bdp->cbd_bufaddr & 0x3) {
		unsigned int index1;
		index1 = bdp - fep->tx_bd_base;
		memcpy(fep->tx_bounce[index1],
		       (void *)skb->data, bdp->cbd_datlen);
		bdp->cbd_bufaddr = __pa(fep->tx_bounce[index1]);
	} */

	dev->stats.tx_bytes += skb->len;

	/* Push the data cache so the CPM does not get stale memory
	 * data.
	 */
	flush_dcache_range((unsigned long)skb->data,
			   (unsigned long)skb->data + skb->len);

	/* Send it on its way.  Tell FEC it's ready, interrupt when done,
	 * it's the last BD of the frame, and to put the CRC on the end.
	 */

	status |= (BD_ENET_TX_READY | BD_ENET_TX_INTR
			| BD_ENET_TX_LAST | BD_ENET_TX_TC);
	bdp->cbd_sc = status;

	dev->trans_start = jiffies;

	/* Trigger transmission start */
	fecp->fec_x_des_active = 0;

	/* If this was the last BD in the ring, start at the beginning again.
	*/
	if (status & BD_ENET_TX_WRAP)
		bdp = fep->tx_bd_base;
	else
		bdp++;

	if (bdp == fep->dirty_tx) {
		fep->tx_full = 1;
		// sunxi 20200812 由于缓冲区满了后会调用该函数，导致后面调用 netif_wake_queue函数时导致内核出错，因此进行屏蔽，满了的缓冲区丢弃掉最前面一帧数据 netif_stop_queue(dev);
		// sunxi 20200812 added
		bdp_tmp = bdp;
		bdp_tmp ++;
		fep->dirty_tx = (cbd_t *)bdp_tmp;
	}

	fep->cur_tx = (cbd_t *)bdp;

#ifdef __FEC2_LDAP_TEST__
	g_fec2_us2 = ustimer_get_origin();
#endif // __FEC2_LDAP_TEST__

	return 0;
}

int fec2_lp_start_xmit(unsigned char *data, int len)
{
	struct	sk_buff	*skb;
	static unsigned char skb_index = 0;
	unsigned long flags;

	if((g_fec2_netdev == NULL) || (data == NULL) || (len <= 0) || (len > FEC_LP_BUF_MAX))
		return 0;

	rt_irq_save(flags);

	skb = &g_fec2_skb[skb_index];
	skb->data = fec2_lp_txbuf[skb_index];

	//拷贝用户数据到skb->data
	memcpy(skb->data, data, len);
	//指定长度
	skb->len = len;

	skb_index ++;

	if(fec2_lp_enet_start_xmit(skb, g_fec2_netdev))
		len = 0;

	rt_irq_restore(flags);

	return len;
}

static void fec2_enet_tx(struct net_device *dev)
{
	struct	fec_enet_private *fep;
	volatile cbd_t	*bdp;
	unsigned short status;
	unsigned long flags;

	fep = netdev_priv(dev);
	// sunxi 20191015 spin_lock_irqsave(&fep->hw_lock, flags);
	rt_irq_save(flags);
	bdp = fep->dirty_tx;
#ifdef __FEC2_LDAP_TEST__
	g_fec2_us3 = ustimer_get_origin();
#endif // __FEC2_LDAP_TEST__

	while (((status = bdp->cbd_sc) & BD_ENET_TX_READY) == 0) {
		if (bdp == fep->cur_tx && fep->tx_full == 0)
			break;

		/* Check for errors. */
		if (status & (BD_ENET_TX_HB | BD_ENET_TX_LC |
				   BD_ENET_TX_RL | BD_ENET_TX_UN |
				   BD_ENET_TX_CSL)) {
			dev->stats.tx_errors++;
			if (status & BD_ENET_TX_HB)  /* No heartbeat */
				dev->stats.tx_heartbeat_errors++;
			if (status & BD_ENET_TX_LC)  /* Late collision */
				dev->stats.tx_window_errors++;
			if (status & BD_ENET_TX_RL)  /* Retrans limit */
				dev->stats.tx_aborted_errors++;
			if (status & BD_ENET_TX_UN)  /* Underrun */
				dev->stats.tx_fifo_errors++;
			if (status & BD_ENET_TX_CSL) /* Carrier lost */
				dev->stats.tx_carrier_errors++;
		} else {
			dev->stats.tx_packets++;
		}

#ifndef final_version
		if (status & BD_ENET_TX_READY)
			printk(KERN_ERR "HEY! "
				"Enet xmit interrupt and TX_READY.\n");
#endif
		/* Deferred means some collisions occurred during transmit,
		 * but we eventually sent the packet OK.
		 */
		if (status & BD_ENET_TX_DEF)
			dev->stats.collisions++;

		/* Update pointer to next buffer descriptor to be transmitted.
		 */
		if (status & BD_ENET_TX_WRAP)
			bdp = fep->tx_bd_base;
		else
			bdp++;

		/* Since we have freed up a buffer, the ring is no longer
		 * full.
		 * sunxi 20200812 前面发送接口判断如果缓冲区满了，进行数据丢弃，因此不会出现以下情况，不会导致调用以下函数导致内核出错
		 */
		if (fep->tx_full) {
			fep->tx_full = 0;
			// sunxi 20200812 if (netif_queue_stopped(dev))
			// sunxi 20200812 	netif_wake_queue(dev);
		}
	}
	fep->dirty_tx = (cbd_t *)bdp;

#ifdef __FEC2_LDAP_TEST__
	rt_printf("us1 = %lu, us2 = %lu, us3 = %lu\n", g_fec2_us1, g_fec2_us2, g_fec2_us3);
	g_fec2_us1 = 0;
	g_fec2_us2 = 0;
	g_fec2_us3 = 0;
#endif // __FEC2_LDAP_TEST__
	// sunxi 20191015 spin_unlock_irqrestore(&fep->hw_lock, flags);
	rt_irq_restore(flags);
}


extern void fec2_lp_frame_handle(unsigned char *data, bool bGoodPacket,int errtype);

static void fec2_enet_rx(struct net_device *dev)
{
	struct	fec_enet_private *fep;
	volatile fec_t	*fecp;
	volatile cbd_t *bdp;
	unsigned short status;
	int errtype=0;
#if 0
	struct	sk_buff	*skb;
#endif
	ushort	pkt_len;
	__u8 *data;
	unsigned long flags;
	int frame_count;

	ushort i, wRecvCnt;
	ushort wCRC=0;
	ushort ucrc;
	u8 *rdptr = 0;
	bool bGoodPacket = false;

	fep = netdev_priv(dev);
	fecp = (volatile fec_t *)dev->base_addr;

	// sunxi 20190920 spin_lock_irqsave(&fep->hw_lock, flags);
	rt_irq_save(flags);

	/* First, grab all of the stats for the incoming packet.
	 * These get messed up if we get called due to a busy condition.
	 */
	bdp = fep->cur_rx;

	frame_count = 0;
	while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) {

#if 1 //xbtong 目前流量控制好像不起作用，但在MCF54452上经测试是可以起作用的。
	//流控制，防止广播风暴
		frame_count++;
		if(frame_count > 2)
		{
		//  opd寄存器存放发送给对方的PAUSE时间，以slot time(512 bit times ,5.12us) 为单位
		//	printk("rx(%d):%d\n", fep->index, frame_count);
		//	fecp->fec_r_fifo_section_empty = 0;
		//  fecp->fec_opd = 0xfff0;
			// sunxi 20190731 fecp->fec_opd = 0x400;
			fecp->fec_opd = 0x80;
			fecp->fec_x_cntrl |= 0x0008;
		}
#endif

#ifndef final_version
		/* Since we have allocated space to hold a complete frame,
		 * the last indicator should be set.
		 */
		if ((status & BD_ENET_RX_LAST) == 0){
			printk(KERN_INFO "FEC ENET: rcv is not +last\n");
			//非法数据长度处理
			if(bdp->cbd_datlen > FEC_ENET_RX_FRSIZE )
				goto rx_processing_done;
		}
#endif

		if (!fep->opened)
			goto rx_processing_done;

		/* Check for errors. */
		if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
				   BD_ENET_RX_CR | BD_ENET_RX_OV)) {
			dev->stats.rx_errors++;
			if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH)) {
				/* Frame too long or too short. */
				dev->stats.rx_length_errors++;
			}
			if (status & BD_ENET_RX_NO)	/* Frame alignment */
				dev->stats.rx_frame_errors++;
			if (status & BD_ENET_RX_CR)	/* CRC Error */
				dev->stats.rx_crc_errors++;
			if (status & BD_ENET_RX_OV)	/* FIFO overrun */
				dev->stats.rx_fifo_errors++;
		}

		/* Report late collisions as a frame error.
		 * On this error, the BD is closed, but we don't know what we
		 * have in the buffer.  So, just drop this frame on the floor.
		 */
		if (status & BD_ENET_RX_CL) {
			dev->stats.rx_errors++;
			dev->stats.rx_frame_errors++;
			goto rx_processing_done;
		}

		/* Process the incoming frame.
		 */
		dev->stats.rx_packets++;
		pkt_len = bdp->cbd_datlen;
		dev->stats.rx_bytes += pkt_len;
		data = (__u8 *)__va(bdp->cbd_bufaddr);
		data+=12;

		// 以下为光差保护数据接收处理
		/* 1. 光纤保护的数据帧，根据ut的协议帧，不是以太网数据帧格式（6字节目标mac地址，接着6字节源mac地址，再两字节帧类型，然后就是帧数据）
		 * 2. 光纤保护的数据帧：两字节帧类型，0x5000是轮询帧，中间8字节的帧数据，最后加上两字节wCRC，一共10字节，
		 * 3. 0xA000是采样帧，中间26字节的帧数据，最后加上两字节wCRC，一共是28字节。
		 * 4. wCRC 是包括两个字节的帧类型和帧数据的异或
		 */
		rdptr = (u8 *)data;
	    switch( data[0] & 0xF0 )
	    {
	    case POLL_FRAME:  //轮巡帧
	        wRecvCnt = POLL_FRAME_WORD;
	        break;
	    case SAMP_FRAME:  //采样帧
	        wRecvCnt = SAMP_FRAME_WORD;
	        break;
	    default:
	        wRecvCnt = 0;
	        break;
	    }
	    if( wRecvCnt )
	    {
	    	rdptr = (u8 *)data;
	        for( i = 0; i < wRecvCnt-2; i++ )
	        {
			wCRC += *rdptr++;
	        }

	        ucrc=(ushort )rdptr[0]|(rdptr[1]<<8);
	        if( wCRC == ucrc )                //效验成功
	        {
	        	bGoodPacket = true;
	        }
	        else
	        {
			errtype=1;
	        }
	    }
	    else
	    {
	    	memset(data, 0x00, (SAMP_FRAME_WORD ));
	    	wRecvCnt = 0;
	    	errtype=2;
	    }
#ifdef __SAVE_TO_BUFF_FOR_READ__ // 保存在临时缓冲区，由采样中断读取，因为使用了 memcpy 拷贝了两次数据，效率会低一些
		// 把正确的数据保存到缓冲区

#if 0 // sunxi 20191015
		fec2_lp_rx_head=0;  //为保证采样数据的实效性，只处理一帧数据，不做缓存
		
		fec2_lp_rxbuf[fec2_lp_rx_head].bvalid = bGoodPacket;
		fec2_lp_rxbuf[fec2_lp_rx_head].len = wRecvCnt;
		if(wRecvCnt > 0)
			memcpy(fec2_lp_rxbuf[fec2_lp_rx_head].buf, data, wRecvCnt);
		fec2_lp_rx_head ++;
		if(fec2_lp_rx_head == fec2_lp_rx_tail)
			fec2_lp_rx_tail ++;
#else // sunxi 20191015
		fec2_lp_rx_cnt = 0;
		fec2_lp_rxbuf.bvalid = bGoodPacket;
		fec2_lp_rxbuf.len = wRecvCnt;
		if(wRecvCnt > 0)
			memcpy(fec2_lp_rxbuf.buf, data, wRecvCnt);
		fec2_lp_rx_cnt = 1;
#endif // sunxi 20191015
		// 数据直接网口2接收中断里面进行处理，调用app那边的接口，效率比较高
		fec2_lp_frame_handle(data, bGoodPacket,errtype);	 //接收报文处理
#ifdef __FEC2_LDAP_TEST__
		for(i = 0; i < 256; i ++)
			data[i] = i;
		g_fec2_us1 = ustimer_get_origin();
		fec2_lp_start_xmit(g_test_buf, TEST_BUF_MAX);
#endif // __FEC2_LDAP_TEST__

#endif // __SAVE_TO_BUFF_FOR_READ__

rx_processing_done:

		/* Clear the status flags for this buffer.
		*/
		status &= ~BD_ENET_RX_STATS;

		/* Mark the buffer empty.
		*/
		status |= BD_ENET_RX_EMPTY;
		bdp->cbd_sc = status;

		/* Update BD pointer to next entry.
		*/
		if (status & BD_ENET_RX_WRAP)
			bdp = fep->rx_bd_base;
		else
			bdp++;


		/* Doing this here will keep the FEC running while we process
		 * incoming frames.  On a heavily loaded network, we should be
		 * able to keep up at the expense of system resources.
		 */
		fecp->fec_r_des_active = 0;

	} /* while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) */
	fep->cur_rx = (cbd_t *)bdp;

	// sunxi 20190920 spin_unlock_irqrestore(&fep->hw_lock, flags);
	rt_irq_restore(flags);
}

/* The interrupt handler.
 * This is called from the MPC core interrupt.
 */
static void fec2_enet_interrupt(void)
{
	struct	net_device *dev = g_fec2_netdev;
	volatile fec_t	*fecp;
	uint	int_events;
	if(dev == NULL) // sunxi 20200811 added
		return;
	fecp = (volatile fec_t *)dev->base_addr;

	/* Get the interrupt events that caused us to be here.
	*/
	do {
		int_events = fecp->fec_ievent;
		fecp->fec_ievent = int_events; // & (FEC_ENET_GRA | FEC_ENET_TXF | FEC_ENET_RXF | FEC_ENET_TXB | FEC_ENET_RXB);

		/* Handle receive event in its own function.
		 */
		if (int_events & FEC_ENET_RXF) {
			fec2_enet_rx(dev);
		}

		/* Transmit OK, or non-fatal error. Update the buffer
		   descriptors. FEC handles all errors, we just discover
		   them as part of the transmit process.
		*/
		if (int_events & FEC_ENET_TXF) {
			fec2_enet_tx(dev);
		}

	} while (int_events);
}

// sunxi 20191217 增加以下4个接口，当模块在手动卸载后，不会出现网口看门狗动作出现的网口2重启的内核出错信息，也不会在手动关闭和打开网口2时出现内核出错信息。
static int fec2_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
	return 0;
}
static void fec2_timeout(struct net_device *dev)
{
}
static int fec2_enet_open(struct net_device *dev)
{
	return 0;
}
static int fec2_enet_close(struct net_device *dev)
{
	return 0;
}

extern struct net_device *fec_get_net_device(int idx);
static const int fec_idx = 1; // sunxi 20200722 增加该变量，使用光纤通信可以不止是网口2，也可以是网口1，但是应用那边也需要对应改动。最好在调用fec2_reinit接口时可以把索引号传进来。
int fec2_reinit(void)
{
#ifdef __FEC2_LDAP_TEST__
	int i;
#endif // __FEC2_LDAP_TEST__
	g_fec2_netdev = fec_get_net_device(fec_idx);
	if(g_fec2_netdev == NULL)
	{
		return 0;
	}

#ifdef __FEC2_LDAP_TEST__
	for(i = 0; i < TEST_BUF_MAX; i ++ )
		g_test_buf[i] = i;
#endif // __FEC2_LDAP_TEST__

	if(g_fec2_netdev->stop != fec2_enet_close)
	{
		g_fec2_netdev->stop(g_fec2_netdev);
		g_fec2_netdev->stop = fec2_enet_close;
		// 重新定位新的网口2中断处理函数
		if(fec_idx == 1)
		{
			//free_irq(113, (void *)g_fec2_netdev);
			//free_irq(117, (void *)g_fec2_netdev);
		}
		else if(!fec_idx)
		{
			//free_irq(100, (void *)g_fec2_netdev);
			//free_irq(104, (void *)g_fec2_netdev);
		}
	}

	// 防止网口2的网络数据在其它地方来发送
	if(g_fec2_netdev->hard_start_xmit != fec2_enet_start_xmit)
	{
		g_fec2_netdev->hard_start_xmit = fec2_enet_start_xmit;
		g_fec2_netdev->tx_timeout = fec2_timeout;
	}

	if(fec_idx == 1)
	{
		rt_request_irq(113, 6, fec2_enet_interrupt, "fec2(TXF)");
		rt_request_irq(117, 6, fec2_enet_interrupt, "fec2(RXF)");
	}
	else if(!fec_idx)
	{
		rt_request_irq(100, 6, fec2_enet_interrupt, "fec1(TXF)");
		rt_request_irq(104, 6, fec2_enet_interrupt, "fec1(RXF)");
	}

	if(g_fec2_netdev->open != fec2_enet_open)
	{
		g_fec2_netdev->open(g_fec2_netdev);
		g_fec2_netdev->open = fec2_enet_open;
	}

	return 0;
}

int fec2_exit(void)
{
	if(g_fec2_netdev == NULL)
	{
		return 0;
	}

	msleep(10); // 让有足够时间把数据都发送出去了再释放实时中断，不然会触发数据发送的看门狗动作。
	if(fec_idx == 1)
	{
		rt_free_irq(117);
		rt_free_irq(113);
	}
	else if(!fec_idx)
	{
		rt_free_irq(104);
		rt_free_irq(100);
	}

	return 0;
}

#endif // __LIGHT_DIFF_ACT_PRO__