sb1250-mac.c

来自「Linux Kernel 2.6.9 for OMAP1710」· C语言 代码 · 共 2,624 行 · 第 1/5 页

C
2,624 行
字号
 *  	    *  Return value: *  	   value read, or 0 if an error occurred. ********************************************************************* */static unsigned int sbmac_mii_read(struct sbmac_softc *s,int phyaddr,int regidx){	int idx;	int error;	int regval;	int mac_mdio_genc;	/*	 * Synchronize ourselves so that the PHY knows the next	 * thing coming down is a command	 */		sbmac_mii_sync(s);		/*	 * Send the data to the PHY.  The sequence is	 * a "start" command (2 bits)	 * a "read" command (2 bits)	 * the PHY addr (5 bits)	 * the register index (5 bits)	 */		sbmac_mii_senddata(s,MII_COMMAND_START, 2);	sbmac_mii_senddata(s,MII_COMMAND_READ, 2);	sbmac_mii_senddata(s,phyaddr, 5);	sbmac_mii_senddata(s,regidx, 5);		mac_mdio_genc = SBMAC_READCSR(s->sbm_mdio) & M_MAC_GENC;		/* 	 * Switch the port around without a clock transition.	 */	SBMAC_WRITECSR(s->sbm_mdio,M_MAC_MDIO_DIR_INPUT | mac_mdio_genc);		/*	 * Send out a clock pulse to signal we want the status	 */		SBMAC_WRITECSR(s->sbm_mdio,		       M_MAC_MDIO_DIR_INPUT | M_MAC_MDC | mac_mdio_genc);	SBMAC_WRITECSR(s->sbm_mdio,M_MAC_MDIO_DIR_INPUT | mac_mdio_genc);		/* 	 * If an error occurred, the PHY will signal '1' back	 */	error = SBMAC_READCSR(s->sbm_mdio) & M_MAC_MDIO_IN;		/* 	 * Issue an 'idle' clock pulse, but keep the direction	 * the same.	 */	SBMAC_WRITECSR(s->sbm_mdio,		       M_MAC_MDIO_DIR_INPUT | M_MAC_MDC | mac_mdio_genc);	SBMAC_WRITECSR(s->sbm_mdio,M_MAC_MDIO_DIR_INPUT | mac_mdio_genc);		regval = 0;		for (idx = 0; idx < 16; idx++) {		regval <<= 1;				if (error == 0) {			if (SBMAC_READCSR(s->sbm_mdio) & M_MAC_MDIO_IN)				regval |= 1;		}				SBMAC_WRITECSR(s->sbm_mdio,			       M_MAC_MDIO_DIR_INPUT|M_MAC_MDC | mac_mdio_genc);		SBMAC_WRITECSR(s->sbm_mdio,			       M_MAC_MDIO_DIR_INPUT | mac_mdio_genc);	}		/* Switch back to output */	SBMAC_WRITECSR(s->sbm_mdio,M_MAC_MDIO_DIR_OUTPUT | mac_mdio_genc);		if (error == 0)		return regval;	return 0;}/********************************************************************** *  SBMAC_MII_WRITE(s,phyaddr,regidx,regval) *   *  Write a value to a PHY register. *   *  Input parameters:  *  	   s - sbmac structure *  	   phyaddr - PHY to use *  	   regidx - register within the PHY *  	   regval - data to write to register *  	    *  Return value: *  	   nothing ********************************************************************* */static void sbmac_mii_write(struct sbmac_softc *s,int phyaddr,int regidx,			    unsigned int regval){	int mac_mdio_genc;	sbmac_mii_sync(s);		sbmac_mii_senddata(s,MII_COMMAND_START,2);	sbmac_mii_senddata(s,MII_COMMAND_WRITE,2);	sbmac_mii_senddata(s,phyaddr, 5);	sbmac_mii_senddata(s,regidx, 5);	sbmac_mii_senddata(s,MII_COMMAND_ACK,2);	sbmac_mii_senddata(s,regval,16);	mac_mdio_genc = SBMAC_READCSR(s->sbm_mdio) & M_MAC_GENC;	SBMAC_WRITECSR(s->sbm_mdio,M_MAC_MDIO_DIR_OUTPUT | mac_mdio_genc);}/********************************************************************** *  SBDMA_INITCTX(d,s,chan,txrx,maxdescr) *   *  Initialize a DMA channel context.  Since there are potentially *  eight DMA channels per MAC, it's nice to do this in a standard *  way.   *   *  Input parameters:  *  	   d - sbmacdma_t structure (DMA channel context) *  	   s - sbmac_softc structure (pointer to a MAC) *  	   chan - channel number (0..1 right now) *  	   txrx - Identifies DMA_TX or DMA_RX for channel direction *      maxdescr - number of descriptors *  	    *  Return value: *  	   nothing ********************************************************************* */static void sbdma_initctx(sbmacdma_t *d,			  struct sbmac_softc *s,			  int chan,			  int txrx,			  int maxdescr){	/* 	 * Save away interesting stuff in the structure 	 */		d->sbdma_eth       = s;	d->sbdma_channel   = chan;	d->sbdma_txdir     = txrx;	#if 0	/* RMON clearing */	s->sbe_idx =(s->sbm_base - A_MAC_BASE_0)/MAC_SPACING;#endif	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_BYTES)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_COLLISIONS)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_LATE_COL)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_EX_COL)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_FCS_ERROR)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_ABORT)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_BAD)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_GOOD)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_RUNT)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_OVERSIZE)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_BYTES)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_MCAST)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_BCAST)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_BAD)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_GOOD)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_RUNT)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_OVERSIZE)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_FCS_ERROR)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_LENGTH_ERROR)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_CODE_ERROR)), 0);	SBMAC_WRITECSR(IOADDR(	A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_ALIGN_ERROR)), 0);	/* 	 * initialize register pointers 	 */		d->sbdma_config0 = 		s->sbm_base + R_MAC_DMA_REGISTER(txrx,chan,R_MAC_DMA_CONFIG0);	d->sbdma_config1 = 		s->sbm_base + R_MAC_DMA_REGISTER(txrx,chan,R_MAC_DMA_CONFIG1);	d->sbdma_dscrbase = 		s->sbm_base + R_MAC_DMA_REGISTER(txrx,chan,R_MAC_DMA_DSCR_BASE);	d->sbdma_dscrcnt = 		s->sbm_base + R_MAC_DMA_REGISTER(txrx,chan,R_MAC_DMA_DSCR_CNT);	d->sbdma_curdscr = 			s->sbm_base + R_MAC_DMA_REGISTER(txrx,chan,R_MAC_DMA_CUR_DSCRADDR);		/*	 * Allocate memory for the ring	 */		d->sbdma_maxdescr = maxdescr;		d->sbdma_dscrtable = (sbdmadscr_t *) 		kmalloc(d->sbdma_maxdescr*sizeof(sbdmadscr_t), GFP_KERNEL);		memset(d->sbdma_dscrtable,0,d->sbdma_maxdescr*sizeof(sbdmadscr_t));		d->sbdma_dscrtable_end = d->sbdma_dscrtable + d->sbdma_maxdescr;		d->sbdma_dscrtable_phys = virt_to_phys(d->sbdma_dscrtable);		/*	 * And context table	 */		d->sbdma_ctxtable = (struct sk_buff **) 		kmalloc(d->sbdma_maxdescr*sizeof(struct sk_buff *), GFP_KERNEL);		memset(d->sbdma_ctxtable,0,d->sbdma_maxdescr*sizeof(struct sk_buff *));	#ifdef CONFIG_SBMAC_COALESCE	/*	 * Setup Rx/Tx DMA coalescing defaults	 */	if ( int_pktcnt ) {		d->sbdma_int_pktcnt = int_pktcnt;	} else {		d->sbdma_int_pktcnt = 1;	}		if ( int_timeout ) {		d->sbdma_int_timeout = int_timeout;	} else {		d->sbdma_int_timeout = 0;	}#endif}/********************************************************************** *  SBDMA_CHANNEL_START(d) *   *  Initialize the hardware registers for a DMA channel. *   *  Input parameters:  *  	   d - DMA channel to init (context must be previously init'd *         rxtx - DMA_RX or DMA_TX depending on what type of channel *  	    *  Return value: *  	   nothing ********************************************************************* */static void sbdma_channel_start(sbmacdma_t *d, int rxtx ){	/*	 * Turn on the DMA channel	 */	#ifdef CONFIG_SBMAC_COALESCE	SBMAC_WRITECSR(d->sbdma_config1,		       V_DMA_INT_TIMEOUT(d->sbdma_int_timeout) |		       0);	SBMAC_WRITECSR(d->sbdma_config0,		       M_DMA_EOP_INT_EN |		       V_DMA_RINGSZ(d->sbdma_maxdescr) |		       V_DMA_INT_PKTCNT(d->sbdma_int_pktcnt) |		       0);#else	SBMAC_WRITECSR(d->sbdma_config1,0);	SBMAC_WRITECSR(d->sbdma_config0,		       V_DMA_RINGSZ(d->sbdma_maxdescr) |		       0);#endif	SBMAC_WRITECSR(d->sbdma_dscrbase,d->sbdma_dscrtable_phys);	/*	 * Initialize ring pointers	 */	d->sbdma_addptr = d->sbdma_dscrtable;	d->sbdma_remptr = d->sbdma_dscrtable;}/********************************************************************** *  SBDMA_CHANNEL_STOP(d) *   *  Initialize the hardware registers for a DMA channel. *   *  Input parameters:  *  	   d - DMA channel to init (context must be previously init'd *  	    *  Return value: *  	   nothing ********************************************************************* */static void sbdma_channel_stop(sbmacdma_t *d){	/*	 * Turn off the DMA channel	 */		SBMAC_WRITECSR(d->sbdma_config1,0);		SBMAC_WRITECSR(d->sbdma_dscrbase,0);		SBMAC_WRITECSR(d->sbdma_config0,0);		/*	 * Zero ring pointers	 */		d->sbdma_addptr = 0;	d->sbdma_remptr = 0;}static void sbdma_align_skb(struct sk_buff *skb,int power2,int offset){	unsigned long addr;	unsigned long newaddr;		addr = (unsigned long) skb->data;		newaddr = (addr + power2 - 1) & ~(power2 - 1);		skb_reserve(skb,newaddr-addr+offset);}/********************************************************************** *  SBDMA_ADD_RCVBUFFER(d,sb) *   *  Add a buffer to the specified DMA channel.   For receive channels, *  this queues a buffer for inbound packets. *   *  Input parameters:  *  	   d - DMA channel descriptor * 	   sb - sk_buff to add, or NULL if we should allocate one *  	    *  Return value: *  	   0 if buffer could not be added (ring is full) *  	   1 if buffer added successfully ********************************************************************* */static int sbdma_add_rcvbuffer(sbmacdma_t *d,struct sk_buff *sb){	sbdmadscr_t *dsc;	sbdmadscr_t *nextdsc;	struct sk_buff *sb_new = NULL;	int pktsize = ENET_PACKET_SIZE;		/* get pointer to our current place in the ring */		dsc = d->sbdma_addptr;	nextdsc = SBDMA_NEXTBUF(d,sbdma_addptr);		/*	 * figure out if the ring is full - if the next descriptor	 * is the same as the one that we're going to remove from	 * the ring, the ring is full	 */		if (nextdsc == d->sbdma_remptr) {		return -ENOSPC;	}	/* 	 * Allocate a sk_buff if we don't already have one.  	 * If we do have an sk_buff, reset it so that it's empty.	 *	 * Note: sk_buffs don't seem to be guaranteed to have any sort	 * of alignment when they are allocated.  Therefore, allocate enough	 * extra space to make sure that:	 *	 *    1. the data does not start in the middle of a cache line.	 *    2. The data does not end in the middle of a cache line	 *    3. The buffer can be aligned such that the IP addresses are 	 *       naturally aligned.	 *	 *  Remember, the SOCs MAC writes whole cache lines at a time,	 *  without reading the old contents first.  So, if the sk_buff's	 *  data portion starts in the middle of a cache line, the SOC	 *  DMA will trash the beginning (and ending) portions.	 */		if (sb == NULL) {		sb_new = dev_alloc_skb(ENET_PACKET_SIZE + SMP_CACHE_BYTES * 2 + ETHER_ALIGN);		if (sb_new == NULL) {			printk(KERN_INFO "%s: sk_buff allocation failed\n",			       d->sbdma_eth->sbm_dev->name);			return -ENOBUFS;		}		sbdma_align_skb(sb_new, SMP_CACHE_BYTES, ETHER_ALIGN);		/* mark skbuff owned by our device */		sb_new->dev = d->sbdma_eth->sbm_dev;	}	else {		sb_new = sb;		/* 		 * nothing special to reinit buffer, it's already aligned		 * and sb->data already points to a good place.		 */	}		/*	 * fill in the descriptor 	 */	#ifdef CONFIG_SBMAC_COALESCE	/*	 * Do not interrupt per DMA transfer.	 */	dsc->dscr_a = virt_to_phys(sb_new->tail) |		V_DMA_DSCRA_A_SIZE(NUMCACHEBLKS(pktsize+ETHER_ALIGN)) |		0;#else	dsc->dscr_a = virt_to_phys(sb_new->tail) |		V_DMA_DSCRA_A_SIZE(NUMCACHEBLKS(pktsize+ETHER_ALIGN)) |		M_DMA_DSCRA_INTERRUPT;#endif	/* receiving: no options */	dsc->dscr_b = 0;		/*	 * fill in the context 	 */		d->sbdma_ctxtable[dsc-d->sbdma_dscrtable] = sb_new;		/* 	 * point at next packet 	 */		d->sbdma_addptr = nextdsc;		/* 	 * Give the buffer to the DMA engine.	 */		SBMAC_WRITECSR(d->sbdma_dscrcnt,1);		return 0;					/* we did it */}/********************************************************************** *  SBDMA_ADD_TXBUFFER(d,sb) *   *  Add a transmit buffer to the specified DMA channel, causing a *  transmit to start. *   *  Input parameters:  *  	   d - DMA channel descriptor * 	   sb - sk_buff to add *  	    *  Return value: *  	   0 transmit queued successfully *  	   otherwise error code ********************************************************************* */static int sbdma_add_txbuffer(sbmacdma_t *d,struct sk_buff *sb){	sbdmadscr_t *dsc;	sbdmadscr_t *nextdsc;	uint64_t phys;	uint64_t ncb;	int length;		/* get pointer to our current place in the ring */		dsc = d->sbdma_addptr;	nextdsc = SBDMA_NEXTBUF(d,sbdma_addptr);		/*	 * figure out if the ring is full - if the next descriptor	 * is the same as the one that we're going to remove from	 * the ring, the ring is full	 */		if (nextdsc == d->sbdma_remptr) {		return -ENOSPC;	}		/*	 * Under Linux, it's not necessary to copy/coalesce buffers	 * like it is on NetBSD.  We think they're all contiguous,	 * but that may not be true for GBE.	 */		length = sb->len;		/*	 * fill in the descriptor.  Note that the number of cache	 * blocks in the descriptor is the number of blocks	 * *spanned*, so we need to add in the offset (if any)	 * while doing the calculation.	 */		phys = virt_to_phys(sb->data);	ncb = NUMCACHEBLKS(length+(phys & (SMP_CACHE_BYTES - 1)));

⌨️ 快捷键说明

复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?