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 + -
显示快捷键?