自学教程：C++ GRETH_REGSAVE函数代码示例

static int greth_poll(struct napi_struct *napi, int budget){	struct greth_private *greth;	int work_done = 0;	unsigned long flags;	u32 mask, ctrl;	greth = container_of(napi, struct greth_private, napi);restart_txrx_poll:	if (netif_queue_stopped(greth->netdev)) {		if (greth->gbit_mac)			greth_clean_tx_gbit(greth->netdev);		else			greth_clean_tx(greth->netdev);	}	if (greth->gbit_mac) {		work_done += greth_rx_gbit(greth->netdev, budget - work_done);	} else {		work_done += greth_rx(greth->netdev, budget - work_done);	}	if (work_done < budget) {		spin_lock_irqsave(&greth->devlock, flags);		ctrl = GRETH_REGLOAD(greth->regs->control);		if (netif_queue_stopped(greth->netdev)) {			GRETH_REGSAVE(greth->regs->control,					ctrl | GRETH_TXI | GRETH_RXI);			mask = GRETH_INT_RX | GRETH_INT_RE |			       GRETH_INT_TX | GRETH_INT_TE;		} else {			GRETH_REGSAVE(greth->regs->control, ctrl | GRETH_RXI);			mask = GRETH_INT_RX | GRETH_INT_RE;		}		if (GRETH_REGLOAD(greth->regs->status) & mask) {			GRETH_REGSAVE(greth->regs->control, ctrl);			spin_unlock_irqrestore(&greth->devlock, flags);			goto restart_txrx_poll;		} else {			__napi_complete(napi);			spin_unlock_irqrestore(&greth->devlock, flags);		}	}	return work_done;}

static netdev_tx_tgreth_start_xmit(struct sk_buff *skb, struct net_device *dev){	struct greth_private *greth = netdev_priv(dev);	struct greth_bd *bdp;	int err = NETDEV_TX_OK;	u32 status, dma_addr, ctrl;	unsigned long flags;	/* Clean TX Ring */	greth_clean_tx(greth->netdev);	if (unlikely(greth->tx_free <= 0)) {		spin_lock_irqsave(&greth->devlock, flags);/*save from poll/irq*/		ctrl = GRETH_REGLOAD(greth->regs->control);		/* Enable TX IRQ only if not already in poll() routine */		if (ctrl & GRETH_RXI)			GRETH_REGSAVE(greth->regs->control, ctrl | GRETH_TXI);		netif_stop_queue(dev);		spin_unlock_irqrestore(&greth->devlock, flags);		return NETDEV_TX_BUSY;	}	if (netif_msg_pktdata(greth))		greth_print_tx_packet(skb);	if (unlikely(skb->len > MAX_FRAME_SIZE)) {		dev->stats.tx_errors++;		goto out;	}	bdp = greth->tx_bd_base + greth->tx_next;	dma_addr = greth_read_bd(&bdp->addr);	memcpy((unsigned char *) phys_to_virt(dma_addr), skb->data, skb->len);	dma_sync_single_for_device(greth->dev, dma_addr, skb->len, DMA_TO_DEVICE);	status = GRETH_BD_EN | GRETH_BD_IE | (skb->len & GRETH_BD_LEN);	greth->tx_bufs_length[greth->tx_next] = skb->len & GRETH_BD_LEN;	/* Wrap around descriptor ring */	if (greth->tx_next == GRETH_TXBD_NUM_MASK) {		status |= GRETH_BD_WR;	}	greth->tx_next = NEXT_TX(greth->tx_next);	greth->tx_free--;	/* Write descriptor control word and enable transmission */	greth_write_bd(&bdp->stat, status);	spin_lock_irqsave(&greth->devlock, flags); /*save from poll/irq*/	greth_enable_tx(greth);	spin_unlock_irqrestore(&greth->devlock, flags);out:	dev_kfree_skb(skb);	return err;}

static int greth_open(struct net_device *dev){	struct greth_private *greth = netdev_priv(dev);	int err;	err = greth_init_rings(greth);	if (err) {		if (netif_msg_ifup(greth))			dev_err(&dev->dev, "Could not allocate memory for DMA rings/n");		return err;	}	err = request_irq(greth->irq, greth_interrupt, 0, "eth", (void *) dev);	if (err) {		if (netif_msg_ifup(greth))			dev_err(&dev->dev, "Could not allocate interrupt %d/n", dev->irq);		greth_clean_rings(greth);		return err;	}	if (netif_msg_ifup(greth))		dev_dbg(&dev->dev, " starting queue/n");	netif_start_queue(dev);	GRETH_REGSAVE(greth->regs->status, 0xFF);	napi_enable(&greth->napi);	greth_enable_irqs(greth);	greth_enable_tx(greth);	greth_enable_rx(greth);	return 0;}

static void greth_clean_tx_gbit(struct net_device *dev){	struct greth_private *greth;	struct greth_bd *bdp, *bdp_last_frag;	struct sk_buff *skb;	u32 stat;	int nr_frags, i;	greth = netdev_priv(dev);	while (greth->tx_free < GRETH_TXBD_NUM) {		skb = greth->tx_skbuff[greth->tx_last];		nr_frags = skb_shinfo(skb)->nr_frags;		/* We only clean fully completed SKBs */		bdp_last_frag = greth->tx_bd_base + SKIP_TX(greth->tx_last, nr_frags);		GRETH_REGSAVE(greth->regs->status, GRETH_INT_TE | GRETH_INT_TX);		mb();		stat = greth_read_bd(&bdp_last_frag->stat);		if (stat & GRETH_BD_EN)			break;		greth->tx_skbuff[greth->tx_last] = NULL;		greth_update_tx_stats(dev, stat);		dev->stats.tx_bytes += skb->len;		bdp = greth->tx_bd_base + greth->tx_last;		greth->tx_last = NEXT_TX(greth->tx_last);		dma_unmap_single(greth->dev,				 greth_read_bd(&bdp->addr),				 skb_headlen(skb),				 DMA_TO_DEVICE);		for (i = 0; i < nr_frags; i++) {			skb_frag_t *frag = &skb_shinfo(skb)->frags[i];			bdp = greth->tx_bd_base + greth->tx_last;			dma_unmap_page(greth->dev,				       greth_read_bd(&bdp->addr),				       frag->size,				       DMA_TO_DEVICE);			greth->tx_last = NEXT_TX(greth->tx_last);		}		greth->tx_free += nr_frags+1;		dev_kfree_skb(skb);	}	if (netif_queue_stopped(dev) && (greth->tx_free > (MAX_SKB_FRAGS+1)))		netif_wake_queue(dev);}

static int greth_set_mac_add(struct net_device *dev, void *p){	struct sockaddr *addr = p;	struct greth_private *greth;	struct greth_regs *regs;	greth = netdev_priv(dev);	regs = greth->regs;	if (!is_valid_ether_addr(addr->sa_data))		return -EADDRNOTAVAIL;	memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);	GRETH_REGSAVE(regs->esa_msb, dev->dev_addr[0] << 8 | dev->dev_addr[1]);	GRETH_REGSAVE(regs->esa_lsb, dev->dev_addr[2] << 24 | dev->dev_addr[3] << 16 |		      dev->dev_addr[4] << 8 | dev->dev_addr[5]);	return 0;}

/* Read MII register 'addr' from core 'regs' */static int read_mii(int phyaddr, int regaddr, volatile greth_regs * regs){	while (GRETH_REGLOAD(&regs->mdio) & GRETH_MII_BUSY) {	}	GRETH_REGSAVE(&regs->mdio, ((phyaddr & 0x1F) << 11) | ((regaddr & 0x1F) << 6) | 2);	while (GRETH_REGLOAD(&regs->mdio) & GRETH_MII_BUSY) {	}	if (!(GRETH_REGLOAD(&regs->mdio) & GRETH_MII_NVALID)) {		return (GRETH_REGLOAD(&regs->mdio) >> 16) & 0xFFFF;	} else {		return -1;

static void greth_clean_tx(struct net_device *dev){	struct greth_private *greth;	struct greth_bd *bdp;	u32 stat;	greth = netdev_priv(dev);	while (1) {		bdp = greth->tx_bd_base + greth->tx_last;		GRETH_REGSAVE(greth->regs->status, GRETH_INT_TE | GRETH_INT_TX);		mb();		stat = greth_read_bd(&bdp->stat);		if (unlikely(stat & GRETH_BD_EN))			break;		if (greth->tx_free == GRETH_TXBD_NUM)			break;		/* Check status for errors */		if (unlikely(stat & GRETH_TXBD_STATUS)) {			dev->stats.tx_errors++;			if (stat & GRETH_TXBD_ERR_AL)				dev->stats.tx_aborted_errors++;			if (stat & GRETH_TXBD_ERR_UE)				dev->stats.tx_fifo_errors++;		}		dev->stats.tx_packets++;		dev->stats.tx_bytes += greth->tx_bufs_length[greth->tx_last];		greth->tx_last = NEXT_TX(greth->tx_last);		greth->tx_free++;	}	if (greth->tx_free > 0) {		netif_wake_queue(dev);	}}

static int greth_rx_gbit(struct net_device *dev, int limit){	struct greth_private *greth;	struct greth_bd *bdp;	struct sk_buff *skb, *newskb;	int pkt_len;	int bad, count = 0;	u32 status, dma_addr;	unsigned long flags;	greth = netdev_priv(dev);	for (count = 0; count < limit; ++count) {		bdp = greth->rx_bd_base + greth->rx_cur;		skb = greth->rx_skbuff[greth->rx_cur];		GRETH_REGSAVE(greth->regs->status, GRETH_INT_RE | GRETH_INT_RX);		mb();		status = greth_read_bd(&bdp->stat);		bad = 0;		if (status & GRETH_BD_EN)			break;		/* Check status for errors. */		if (unlikely(status & GRETH_RXBD_STATUS)) {			if (status & GRETH_RXBD_ERR_FT) {				dev->stats.rx_length_errors++;				bad = 1;			} else if (status &				   (GRETH_RXBD_ERR_AE | GRETH_RXBD_ERR_OE | GRETH_RXBD_ERR_LE)) {				dev->stats.rx_frame_errors++;				bad = 1;			} else if (status & GRETH_RXBD_ERR_CRC) {				dev->stats.rx_crc_errors++;				bad = 1;			}		}		/* Allocate new skb to replace current, not needed if the		 * current skb can be reused */		if (!bad && (newskb=netdev_alloc_skb(dev, MAX_FRAME_SIZE + NET_IP_ALIGN))) {			skb_reserve(newskb, NET_IP_ALIGN);			dma_addr = dma_map_single(greth->dev,						      newskb->data,						      MAX_FRAME_SIZE + NET_IP_ALIGN,						      DMA_FROM_DEVICE);			if (!dma_mapping_error(greth->dev, dma_addr)) {				/* Process the incoming frame. */				pkt_len = status & GRETH_BD_LEN;				dma_unmap_single(greth->dev,						 greth_read_bd(&bdp->addr),						 MAX_FRAME_SIZE + NET_IP_ALIGN,						 DMA_FROM_DEVICE);				if (netif_msg_pktdata(greth))					greth_print_rx_packet(phys_to_virt(greth_read_bd(&bdp->addr)), pkt_len);				skb_put(skb, pkt_len);				if (dev->features & NETIF_F_RXCSUM && hw_checksummed(status))					skb->ip_summed = CHECKSUM_UNNECESSARY;				else					skb_checksum_none_assert(skb);				skb->protocol = eth_type_trans(skb, dev);				dev->stats.rx_packets++;				dev->stats.rx_bytes += pkt_len;				netif_receive_skb(skb);				greth->rx_skbuff[greth->rx_cur] = newskb;				greth_write_bd(&bdp->addr, dma_addr);			} else {				if (net_ratelimit())					dev_warn(greth->dev, "Could not create DMA mapping, dropping packet/n");				dev_kfree_skb(newskb);				/* reusing current skb, so it is a drop */				dev->stats.rx_dropped++;			}		} else if (bad) {			/* Bad Frame transfer, the skb is reused */			dev->stats.rx_dropped++;		} else {			/* Failed Allocating a new skb. This is rather stupid			 * but the current "filled" skb is reused, as if			 * transfer failure. One could argue that RX descriptor			 * table handling should be divided into cleaning and			 * filling as the TX part of the driver			 */			if (net_ratelimit())				dev_warn(greth->dev, "Could not allocate SKB, dropping packet/n");			/* reusing current skb, so it is a drop */			dev->stats.rx_dropped++;		}		status = GRETH_BD_EN | GRETH_BD_IE;//.........这里部分代码省略.........

static int greth_rx(struct net_device *dev, int limit){	struct greth_private *greth;	struct greth_bd *bdp;	struct sk_buff *skb;	int pkt_len;	int bad, count;	u32 status, dma_addr;	unsigned long flags;	greth = netdev_priv(dev);	for (count = 0; count < limit; ++count) {		bdp = greth->rx_bd_base + greth->rx_cur;		GRETH_REGSAVE(greth->regs->status, GRETH_INT_RE | GRETH_INT_RX);		mb();		status = greth_read_bd(&bdp->stat);		if (unlikely(status & GRETH_BD_EN)) {			break;		}		dma_addr = greth_read_bd(&bdp->addr);		bad = 0;		/* Check status for errors. */		if (unlikely(status & GRETH_RXBD_STATUS)) {			if (status & GRETH_RXBD_ERR_FT) {				dev->stats.rx_length_errors++;				bad = 1;			}			if (status & (GRETH_RXBD_ERR_AE | GRETH_RXBD_ERR_OE)) {				dev->stats.rx_frame_errors++;				bad = 1;			}			if (status & GRETH_RXBD_ERR_CRC) {				dev->stats.rx_crc_errors++;				bad = 1;			}		}		if (unlikely(bad)) {			dev->stats.rx_errors++;		} else {			pkt_len = status & GRETH_BD_LEN;			skb = netdev_alloc_skb(dev, pkt_len + NET_IP_ALIGN);			if (unlikely(skb == NULL)) {				if (net_ratelimit())					dev_warn(&dev->dev, "low on memory - " "packet dropped/n");				dev->stats.rx_dropped++;			} else {				skb_reserve(skb, NET_IP_ALIGN);				dma_sync_single_for_cpu(greth->dev,							dma_addr,							pkt_len,							DMA_FROM_DEVICE);				if (netif_msg_pktdata(greth))					greth_print_rx_packet(phys_to_virt(dma_addr), pkt_len);				memcpy(skb_put(skb, pkt_len), phys_to_virt(dma_addr), pkt_len);				skb->protocol = eth_type_trans(skb, dev);				dev->stats.rx_bytes += pkt_len;				dev->stats.rx_packets++;				netif_receive_skb(skb);			}		}		status = GRETH_BD_EN | GRETH_BD_IE;		if (greth->rx_cur == GRETH_RXBD_NUM_MASK) {			status |= GRETH_BD_WR;		}		wmb();		greth_write_bd(&bdp->stat, status);		dma_sync_single_for_device(greth->dev, dma_addr, MAX_FRAME_SIZE, DMA_FROM_DEVICE);		spin_lock_irqsave(&greth->devlock, flags); /* save from XMIT */		greth_enable_rx(greth);		spin_unlock_irqrestore(&greth->devlock, flags);		greth->rx_cur = NEXT_RX(greth->rx_cur);	}	return count;}

static void greth_clean_tx_gbit(struct net_device *dev){	struct greth_private *greth;	struct greth_bd *bdp, *bdp_last_frag;	struct sk_buff *skb = NULL;	u32 stat;	int nr_frags, i;	u16 tx_last;	greth = netdev_priv(dev);	tx_last = greth->tx_last;	while (tx_last != greth->tx_next) {		skb = greth->tx_skbuff[tx_last];		nr_frags = skb_shinfo(skb)->nr_frags;		/* We only clean fully completed SKBs */		bdp_last_frag = greth->tx_bd_base + SKIP_TX(tx_last, nr_frags);		GRETH_REGSAVE(greth->regs->status, GRETH_INT_TE | GRETH_INT_TX);		mb();		stat = greth_read_bd(&bdp_last_frag->stat);		if (stat & GRETH_BD_EN)			break;		greth->tx_skbuff[tx_last] = NULL;		greth_update_tx_stats(dev, stat);		dev->stats.tx_bytes += skb->len;		bdp = greth->tx_bd_base + tx_last;		tx_last = NEXT_TX(tx_last);		dma_unmap_single(greth->dev,				 greth_read_bd(&bdp->addr),				 skb_headlen(skb),				 DMA_TO_DEVICE);		for (i = 0; i < nr_frags; i++) {			skb_frag_t *frag = &skb_shinfo(skb)->frags[i];			bdp = greth->tx_bd_base + tx_last;			dma_unmap_page(greth->dev,				       greth_read_bd(&bdp->addr),				       skb_frag_size(frag),				       DMA_TO_DEVICE);			tx_last = NEXT_TX(tx_last);		}		dev_kfree_skb(skb);	}	if (skb) { /* skb is set only if the above while loop was entered */		wmb();		greth->tx_last = tx_last;		if (netif_queue_stopped(dev) &&		    (greth_num_free_bds(tx_last, greth->tx_next) >		    (MAX_SKB_FRAGS+1)))			netif_wake_queue(dev);	}}

static int greth_init_rings(struct greth_private *greth){	struct sk_buff *skb;	struct greth_bd *rx_bd, *tx_bd;	u32 dma_addr;	int i;	rx_bd = greth->rx_bd_base;	tx_bd = greth->tx_bd_base;	/* Initialize descriptor rings and buffers */	if (greth->gbit_mac) {		for (i = 0; i < GRETH_RXBD_NUM; i++) {			skb = netdev_alloc_skb(greth->netdev, MAX_FRAME_SIZE+NET_IP_ALIGN);			if (skb == NULL) {				if (netif_msg_ifup(greth))					dev_err(greth->dev, "Error allocating DMA ring./n");				goto cleanup;			}			skb_reserve(skb, NET_IP_ALIGN);			dma_addr = dma_map_single(greth->dev,						  skb->data,						  MAX_FRAME_SIZE+NET_IP_ALIGN,						  DMA_FROM_DEVICE);			if (dma_mapping_error(greth->dev, dma_addr)) {				if (netif_msg_ifup(greth))					dev_err(greth->dev, "Could not create initial DMA mapping/n");				goto cleanup;			}			greth->rx_skbuff[i] = skb;			greth_write_bd(&rx_bd[i].addr, dma_addr);			greth_write_bd(&rx_bd[i].stat, GRETH_BD_EN | GRETH_BD_IE);		}	} else {		/* 10/100 MAC uses a fixed set of buffers and copy to/from SKBs */		for (i = 0; i < GRETH_RXBD_NUM; i++) {			greth->rx_bufs[i] = kmalloc(MAX_FRAME_SIZE, GFP_KERNEL);			if (greth->rx_bufs[i] == NULL) {				if (netif_msg_ifup(greth))					dev_err(greth->dev, "Error allocating DMA ring./n");				goto cleanup;			}			dma_addr = dma_map_single(greth->dev,						  greth->rx_bufs[i],						  MAX_FRAME_SIZE,						  DMA_FROM_DEVICE);			if (dma_mapping_error(greth->dev, dma_addr)) {				if (netif_msg_ifup(greth))					dev_err(greth->dev, "Could not create initial DMA mapping/n");				goto cleanup;			}			greth_write_bd(&rx_bd[i].addr, dma_addr);			greth_write_bd(&rx_bd[i].stat, GRETH_BD_EN | GRETH_BD_IE);		}		for (i = 0; i < GRETH_TXBD_NUM; i++) {			greth->tx_bufs[i] = kmalloc(MAX_FRAME_SIZE, GFP_KERNEL);			if (greth->tx_bufs[i] == NULL) {				if (netif_msg_ifup(greth))					dev_err(greth->dev, "Error allocating DMA ring./n");				goto cleanup;			}			dma_addr = dma_map_single(greth->dev,						  greth->tx_bufs[i],						  MAX_FRAME_SIZE,						  DMA_TO_DEVICE);			if (dma_mapping_error(greth->dev, dma_addr)) {				if (netif_msg_ifup(greth))					dev_err(greth->dev, "Could not create initial DMA mapping/n");				goto cleanup;			}			greth_write_bd(&tx_bd[i].addr, dma_addr);			greth_write_bd(&tx_bd[i].stat, 0);		}	}	greth_write_bd(&rx_bd[GRETH_RXBD_NUM - 1].stat,		       greth_read_bd(&rx_bd[GRETH_RXBD_NUM - 1].stat) | GRETH_BD_WR);	/* Initialize pointers. */	greth->rx_cur = 0;	greth->tx_next = 0;	greth->tx_last = 0;	greth->tx_free = GRETH_TXBD_NUM;	/* Initialize descriptor base address */	GRETH_REGSAVE(greth->regs->tx_desc_p, greth->tx_bd_base_phys);	GRETH_REGSAVE(greth->regs->rx_desc_p, greth->rx_bd_base_phys);	return 0;//.........这里部分代码省略.........

static netdev_tx_tgreth_start_xmit_gbit(struct sk_buff *skb, struct net_device *dev){	struct greth_private *greth = netdev_priv(dev);	struct greth_bd *bdp;	u32 status = 0, dma_addr, ctrl;	int curr_tx, nr_frags, i, err = NETDEV_TX_OK;	unsigned long flags;	nr_frags = skb_shinfo(skb)->nr_frags;	/* Clean TX Ring */	greth_clean_tx_gbit(dev);	if (greth->tx_free < nr_frags + 1) {		spin_lock_irqsave(&greth->devlock, flags);/*save from poll/irq*/		ctrl = GRETH_REGLOAD(greth->regs->control);		/* Enable TX IRQ only if not already in poll() routine */		if (ctrl & GRETH_RXI)			GRETH_REGSAVE(greth->regs->control, ctrl | GRETH_TXI);		netif_stop_queue(dev);		spin_unlock_irqrestore(&greth->devlock, flags);		err = NETDEV_TX_BUSY;		goto out;	}	if (netif_msg_pktdata(greth))		greth_print_tx_packet(skb);	if (unlikely(skb->len > MAX_FRAME_SIZE)) {		dev->stats.tx_errors++;		goto out;	}	/* Save skb pointer. */	greth->tx_skbuff[greth->tx_next] = skb;	/* Linear buf */	if (nr_frags != 0)		status = GRETH_TXBD_MORE;	if (skb->ip_summed == CHECKSUM_PARTIAL)		status |= GRETH_TXBD_CSALL;	status |= skb_headlen(skb) & GRETH_BD_LEN;	if (greth->tx_next == GRETH_TXBD_NUM_MASK)		status |= GRETH_BD_WR;	bdp = greth->tx_bd_base + greth->tx_next;	greth_write_bd(&bdp->stat, status);	dma_addr = dma_map_single(greth->dev, skb->data, skb_headlen(skb), DMA_TO_DEVICE);	if (unlikely(dma_mapping_error(greth->dev, dma_addr)))		goto map_error;	greth_write_bd(&bdp->addr, dma_addr);	curr_tx = NEXT_TX(greth->tx_next);	/* Frags */	for (i = 0; i < nr_frags; i++) {		skb_frag_t *frag = &skb_shinfo(skb)->frags[i];		greth->tx_skbuff[curr_tx] = NULL;		bdp = greth->tx_bd_base + curr_tx;		status = GRETH_BD_EN;		if (skb->ip_summed == CHECKSUM_PARTIAL)			status |= GRETH_TXBD_CSALL;		status |= frag->size & GRETH_BD_LEN;		/* Wrap around descriptor ring */		if (curr_tx == GRETH_TXBD_NUM_MASK)			status |= GRETH_BD_WR;		/* More fragments left */		if (i < nr_frags - 1)			status |= GRETH_TXBD_MORE;		else			status |= GRETH_BD_IE; /* enable IRQ on last fragment */		greth_write_bd(&bdp->stat, status);		dma_addr = dma_map_page(greth->dev,					frag->page,					frag->page_offset,					frag->size,					DMA_TO_DEVICE);		if (unlikely(dma_mapping_error(greth->dev, dma_addr)))			goto frag_map_error;		greth_write_bd(&bdp->addr, dma_addr);		curr_tx = NEXT_TX(curr_tx);	}	wmb();	/* Enable the descriptor chain by enabling the first descriptor */	bdp = greth->tx_bd_base + greth->tx_next;//.........这里部分代码省略.........