gianfar: comment cleanup

/*

 * drivers/net/ethernet/freescale/gianfar.c

/* drivers/net/ethernet/freescale/gianfar.c

 *

 * Gianfar Ethernet Driver

 * This driver is designed for the non-CPM ethernet controllers

	gfar_write(&regs->attreli, attrs);

	/* Start with defaults, and add stashing or locking

	 * depending on the approprate variables */

	 * depending on the approprate variables

	 */

	attrs = ATTR_INIT_SETTINGS;

	if (priv->bd_stash_en)

}

/* Set up the ethernet device structure, private data,

 * and anything else we need before we start */

 * and anything else we need before we start

 */

static int gfar_probe(struct platform_device *ofdev)

{

	u32 tempval;

	gfar_detect_errata(priv);

	/* Stop the DMA engine now, in case it was running before */

	/* (The firmware could have used it, and left it running). */

	/* Stop the DMA engine now, in case it was running before

	 * (The firmware could have used it, and left it running).

	 */

	gfar_halt(dev);

	/* Reset MAC layer */

	/* Need to reverse the bit maps as  bit_map's MSB is q0

	 * but, for_each_set_bit parses from right to left, which

	 * basically reverses the queue numbers */

	 * basically reverses the queue numbers

	 */

	for (i = 0; i< priv->num_grps; i++) {

		priv->gfargrp[i].tx_bit_map = reverse_bitmap(

				priv->gfargrp[i].tx_bit_map, MAX_TX_QS);

	}

	/* Calculate RSTAT, TSTAT, RQUEUE and TQUEUE values,

	 * also assign queues to groups */

	 * also assign queues to groups

	 */

	for (grp_idx = 0; grp_idx < priv->num_grps; grp_idx++) {

		priv->gfargrp[grp_idx].num_rx_queues = 0x0;

		for_each_set_bit(i, &priv->gfargrp[grp_idx].rx_bit_map,

	/* Print out the device info */

	netdev_info(dev, "mac: %pM\n", dev->dev_addr);

	/* Even more device info helps when determining which kernel */

	/* provided which set of benchmarks. */

	/* Even more device info helps when determining which kernel

	 * provided which set of benchmarks.

	 */

	netdev_info(dev, "Running with NAPI enabled\n");

	for (i = 0; i < priv->num_rx_queues; i++)

		netdev_info(dev, "RX BD ring size for Q[%d]: %d\n",

		else {

			phy_interface_t interface = priv->interface;

			/*

			 * This isn't autodetected right now, so it must

			/* This isn't autodetected right now, so it must

			 * be set by the device tree or platform code.

			 */

			if (interface == PHY_INTERFACE_MODE_RGMII_ID)

	return 0;

}

/*

 * Initialize TBI PHY interface for communicating with the

/* Initialize TBI PHY interface for communicating with the

 * SERDES lynx PHY on the chip.  We communicate with this PHY

 * through the MDIO bus on each controller, treating it as a

 * "normal" PHY at the address found in the TBIPA register.  We assume

		return;

	}

	/*

	 * If the link is already up, we must already be ok, and don't need to

	/* If the link is already up, we must already be ok, and don't need to

	 * configure and reset the TBI<->SerDes link.  Maybe U-Boot configured

	 * everything for us?  Resetting it takes the link down and requires

	 * several seconds for it to come back.

{

	u32 res;

	/*

	 * Normaly TSEC should not hang on GRS commands, so we should

	/* Normaly TSEC should not hang on GRS commands, so we should

	 * actually wait for IEVENT_GRSC flag.

	 */

	if (likely(!gfar_has_errata(priv, GFAR_ERRATA_A002)))

		return 0;

	/*

	 * Read the eTSEC register at offset 0xD1C. If bits 7-14 are

	/* Read the eTSEC register at offset 0xD1C. If bits 7-14 are

	 * the same as bits 23-30, the eTSEC Rx is assumed to be idle

	 * and the Rx can be safely reset.

	 */

}

/* If there are any tx skbs or rx skbs still around, free them.

 * Then free tx_skbuff and rx_skbuff */

 * Then free tx_skbuff and rx_skbuff

 */

static void free_skb_resources(struct gfar_private *priv)

{

	struct gfar_priv_tx_q *tx_queue = NULL;

	int err;

	/* If the device has multiple interrupts, register for

	 * them.  Otherwise, only register for the one */

	 * them.  Otherwise, only register for the one

	 */

	if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {

		/* Install our interrupt handlers for Error,

		 * Transmit, and Receive */

		 * Transmit, and Receive

		 */

		if ((err = request_irq(grp->interruptError, gfar_error, 0,

				grp->int_name_er,grp)) < 0) {

			netif_err(priv, intr, dev, "Can't get IRQ %d\n",

	return err;

}

/* Called when something needs to use the ethernet device */

/* Returns 0 for success. */

/* Called when something needs to use the ethernet device

 * Returns 0 for success.

 */

static int gfar_enet_open(struct net_device *dev)

{

	struct gfar_private *priv = netdev_priv(dev);

	 */

	flags = TXFCB_DEFAULT;

	/* Tell the controller what the protocol is */

	/* And provide the already calculated phcs */

	/* Tell the controller what the protocol is

	 * And provide the already calculated phcs

	 */

	if (ip_hdr(skb)->protocol == IPPROTO_UDP) {

		flags |= TXFCB_UDP;

		fcb->phcs = udp_hdr(skb)->check;

	/* l3os is the distance between the start of the

	 * frame (skb->data) and the start of the IP hdr.

	 * l4os is the distance between the start of the

	 * l3 hdr and the l4 hdr */

	 * l3 hdr and the l4 hdr

	 */

	fcb->l3os = (u16)(skb_network_offset(skb) - fcb_length);

	fcb->l4os = skb_network_header_len(skb);

	return skip_txbd(bdp, 1, base, ring_size);

}

/* This is called by the kernel when a frame is ready for transmission. */

/* It is pointed to by the dev->hard_start_xmit function pointer */

/* This is called by the kernel when a frame is ready for transmission.

 * It is pointed to by the dev->hard_start_xmit function pointer

 */

static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)

{

	struct gfar_private *priv = netdev_priv(dev);

	unsigned long flags;

	unsigned int nr_frags, nr_txbds, length, fcb_length = GMAC_FCB_LEN;

	/*

	 * TOE=1 frames larger than 2500 bytes may see excess delays

	/* TOE=1 frames larger than 2500 bytes may see excess delays

	 * before start of transmission.

	 */

	if (unlikely(gfar_has_errata(priv, GFAR_ERRATA_76) &&

	txbdp_start->bufPtr = dma_map_single(&priv->ofdev->dev, skb->data,

			skb_headlen(skb), DMA_TO_DEVICE);

	/*

	 * If time stamping is requested one additional TxBD must be set up. The

	/* If time stamping is requested one additional TxBD must be set up. The

	 * first TxBD points to the FCB and must have a data length of

	 * GMAC_FCB_LEN. The second TxBD points to the actual frame data with

	 * the full frame length.

	netdev_tx_sent_queue(txq, skb->len);

	/*

	 * We can work in parallel with gfar_clean_tx_ring(), except

	/* We can work in parallel with gfar_clean_tx_ring(), except

	 * when modifying num_txbdfree. Note that we didn't grab the lock

	 * when we were reading the num_txbdfree and checking for available

	 * space, that's because outside of this function it can only grow,

	 */

	spin_lock_irqsave(&tx_queue->txlock, flags);

	/*

	 * The powerpc-specific eieio() is used, as wmb() has too strong

	/* The powerpc-specific eieio() is used, as wmb() has too strong

	 * semantics (it requires synchronization between cacheable and

	 * uncacheable mappings, which eieio doesn't provide and which we

	 * don't need), thus requiring a more expensive sync instruction.  At

	tx_queue->tx_skbuff[tx_queue->skb_curtx] = skb;

	/* Update the current skb pointer to the next entry we will use

	 * (wrapping if necessary) */

	 * (wrapping if necessary)

	 */

	tx_queue->skb_curtx = (tx_queue->skb_curtx + 1) &

		TX_RING_MOD_MASK(tx_queue->tx_ring_size);

	tx_queue->num_txbdfree -= (nr_txbds);

	/* If the next BD still needs to be cleaned up, then the bds

	   are full.  We need to tell the kernel to stop sending us stuff. */

	 * are full.  We need to tell the kernel to stop sending us stuff.

	 */

	if (!tx_queue->num_txbdfree) {

		netif_tx_stop_queue(txq);

	    INCREMENTAL_BUFFER_SIZE;

	/* Only stop and start the controller if it isn't already

	 * stopped, and we changed something */

	 * stopped, and we changed something

	 */

	if ((oldsize != tempsize) && (dev->flags & IFF_UP))

		stop_gfar(dev);

	/* If the mtu is larger than the max size for standard

	 * ethernet frames (ie, a jumbo frame), then set maccfg2

	 * to allow huge frames, and to check the length */

	 * to allow huge frames, and to check the length

	 */

	tempval = gfar_read(&regs->maccfg2);

	if (priv->rx_buffer_size > DEFAULT_RX_BUFFER_SIZE ||

		frags = skb_shinfo(skb)->nr_frags;

		/*

		 * When time stamping, one additional TxBD must be freed.

		/* When time stamping, one additional TxBD must be freed.

		 * Also, we need to dma_unmap_single() the TxPAL.

		 */

		if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS))

		bytes_sent += skb->len;

		/*

		 * If there's room in the queue (limit it to rx_buffer_size)

		/* If there's room in the queue (limit it to rx_buffer_size)

		 * we add this skb back into the pool, if it's the right size

		 */

		if (skb_queue_len(&priv->rx_recycle) < rx_queue->rx_ring_size &&

		gfar_write(&gfargrp->regs->imask, IMASK_RTX_DISABLED);

		__napi_schedule(&gfargrp->napi);

	} else {

		/*

		 * Clear IEVENT, so interrupts aren't called again

		/* Clear IEVENT, so interrupts aren't called again

		 * because of the packets that have already arrived.

		 */

		gfar_write(&gfargrp->regs->ievent, IEVENT_RTX_MASK);

	struct net_device_stats *stats = &dev->stats;

	struct gfar_extra_stats *estats = &priv->extra_stats;

	/* If the packet was truncated, none of the other errors

	 * matter */

	/* If the packet was truncated, none of the other errors matter */

	if (status & RXBD_TRUNCATED) {

		stats->rx_length_errors++;

{

	/* If valid headers were found, and valid sums

	 * were verified, then we tell the kernel that no

	 * checksumming is necessary.  Otherwise, it is */

	 * checksumming is necessary.  Otherwise, it is [FIXME]

	 */

	if ((fcb->flags & RXFCB_CSUM_MASK) == (RXFCB_CIP | RXFCB_CTU))

		skb->ip_summed = CHECKSUM_UNNECESSARY;

	else

}

/* gfar_process_frame() -- handle one incoming packet if skb

 * isn't NULL.  */

/* gfar_process_frame() -- handle one incoming packet if skb isn't NULL. */

static int gfar_process_frame(struct net_device *dev, struct sk_buff *skb,

			      int amount_pull, struct napi_struct *napi)

{

	/* fcb is at the beginning if exists */

	fcb = (struct rxfcb *)skb->data;

	/* Remove the FCB from the skb */

	/* Remove the padded bytes, if there are any */

	/* Remove the FCB from the skb

	 * Remove the padded bytes, if there are any

	 */

	if (amount_pull) {

		skb_record_rx_queue(skb, fcb->rq);

		skb_pull(skb, amount_pull);

	/* Tell the skb what kind of packet this is */

	skb->protocol = eth_type_trans(skb, dev);

	/*

	 * There's need to check for NETIF_F_HW_VLAN_RX here.

	/* There's need to check for NETIF_F_HW_VLAN_RX here.

	 * Even if vlan rx accel is disabled, on some chips

	 * RXFCB_VLN is pseudo randomly set.

	 */

	budget_per_queue = budget/num_queues;

	/* Clear IEVENT, so interrupts aren't called again

	 * because of the packets that have already arrived */

	 * because of the packets that have already arrived

	 */

	gfar_write(&regs->ievent, IEVENT_RTX_MASK);

	while (num_queues && left_over_budget) {

		gfar_write(&regs->imask, IMASK_DEFAULT);

		/* If we are coalescing interrupts, update the timer */

		/* Otherwise, clear it */

		/* If we are coalescing interrupts, update the timer

		 * Otherwise, clear it

		 */

		gfar_configure_coalescing(priv,

				gfargrp->rx_bit_map, gfargrp->tx_bit_map);

	}

}

#ifdef CONFIG_NET_POLL_CONTROLLER

/*

 * Polling 'interrupt' - used by things like netconsole to send skbs

/* Polling 'interrupt' - used by things like netconsole to send skbs

 * without having to re-enable interrupts. It's not called while

 * the interrupt routine is executing.

 */

		u32 ecntrl = gfar_read(&regs->ecntrl);

		/* Now we make sure that we can be in full duplex mode.

		 * If not, we operate in half-duplex mode. */

		 * If not, we operate in half-duplex mode.

		 */

		if (phydev->duplex != priv->oldduplex) {

			new_state = 1;

			if (!(phydev->duplex))

				    ((tempval & ~(MACCFG2_IF)) | MACCFG2_MII);

				/* Reduced mode distinguishes

				 * between 10 and 100 */

				 * between 10 and 100

				 */

				if (phydev->speed == SPEED_100)

					ecntrl |= ECNTRL_R100;

				else

/* Update the hash table based on the current list of multicast

 * addresses we subscribe to.  Also, change the promiscuity of

 * the device based on the flags (this function is called

 * whenever dev->flags is changed */

 * whenever dev->flags is changed

 */

static void gfar_set_multi(struct net_device *dev)

{

	struct netdev_hw_addr *ha;

		/* If we have extended hash tables, we need to

		 * clear the exact match registers to prepare for

		 * setting them */

		 * setting them

		 */

		if (priv->extended_hash) {

			em_num = GFAR_EM_NUM + 1;

			gfar_clear_exact_match(dev);

/* Clears each of the exact match registers to zero, so they

 * don't interfere with normal reception */

 * don't interfere with normal reception

 */

static void gfar_clear_exact_match(struct net_device *dev)

{

	int idx;

 * hash index which gaddr register to use, and the 5 other bits

 * indicate which bit (assuming an IBM numbering scheme, which

 * for PowerPC (tm) is usually the case) in the register holds

 * the entry. */

 * the entry.

 */

static void gfar_set_hash_for_addr(struct net_device *dev, u8 *addr)

{

	u32 tempval;

	macptr += num*2;

	/* Now copy it into the mac registers backwards, cuz */

	/* little endian is silly */

	/* Now copy it into the mac registers backwards, cuz

	 * little endian is silly

	 */

	for (idx = 0; idx < ETH_ALEN; idx++)

		tmpbuf[ETH_ALEN - 1 - idx] = addr[idx];